mainwnd.cpp

Windows CE 下的机顶盒应用实例

				PCOPYDATASTRUCT lpCDS = (PCOPYDATASTRUCT)lParam;
				ASSERT(lpCDS->cbData == 
					(_tcslen((LPTSTR)lpCDS->lpData) + 1) * sizeof(TCHAR));
				cbData += lpCDS->cbData + sizeof(TCHAR);	// extra TCHAR for null term

				// now that we know the size, create the URL
				szNavURL = new TCHAR[cbData/sizeof(TCHAR)];
				ASSERT(szNavURL);
				if (!szNavURL)
				{
					DEBUGMSG(1, (TEXT("Error creating Windows Media ")
								  TEXT("Navigation URL string!\r\n")));
					break;
				}

				cbDummy = cbData;
				lRet = RegQueryValueEx(hKey, REG_WMPVALUE, NULL, NULL,
									   (LPBYTE)szNavURL, &cbDummy);
				ASSERT(ERROR_SUCCESS == lRet);
				RegCloseKey(hKey);
				if (ERROR_SUCCESS != lRet)
				{
					DEBUGMSG(1, (TEXT("Error (%u) getting registry value: ")
								REG_ROOTKEY REG_WMPVALUE, GetLastError()));
					break;
				}

				_tcscat(szNavURL, TEXT("#"));
				_tcscat(szNavURL, (LPTSTR)lpCDS->lpData);
				szNavURL[cbData/sizeof(TCHAR) - 1] = 0;

				HRESULT hr = pMainWnd->_pBrowser->Navigate(szNavURL, 
								NULL, NULL, NULL, NULL);
				ASSERT(S_OK == hr);
				if (FAILED(hr))
				{
					DEBUGMSG(1, (TEXT("IWebBrowser2::Navigate(\"%s\") failed!\r\n"),
								 szNavURL));
				}
				return 1;
			}
			break;

		default:
			break;
		}
	}

	return DefWindowProc(hwnd, message, wParam, lParam);
}

BOOL CMainWnd::PreTranslateMessage(LPMSG pMsg)
{
	// main frame gets first shot
	if (_fUseNewAccels)
	{
		if (::TranslateAccelerator(_hWnd, _hAccelTblNew, pMsg))
			return TRUE;
	}
	else
	{
	    if (::TranslateAccelerator(_hWnd, _hAccelTblDef, pMsg))
	        return TRUE;
	}

    // then to mshtml
    if (_pIPActiveObj && pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
    {
        HRESULT hr = _pIPActiveObj->TranslateAccelerator(pMsg);
        return (hr != S_FALSE);
    }
    return FALSE;
}

VOID CMainWnd::ChangeFontSize(BOOL fInit)
{
        VARIANT vaSize;
        vaSize.vt = VT_I4;

	if (fInit) {
		// Setting initial value
		vaSize.vt = 0;
		HRESULT hr = _pBrowser->ExecWB(OLECMDID_ZOOM, OLECMDEXECOPT_DONTPROMPTUSER,
									   NULL, &vaSize);
		_wZoom = vaSize.lVal;
	} else {
		vaSize.lVal = _wZoom;
		HRESULT hr = _pBrowser->ExecWB(OLECMDID_ZOOM, OLECMDEXECOPT_DONTPROMPTUSER,
									   &vaSize, NULL);
	}
}

VOID CMainWnd::Close()
{
    RETAILMSG(1,(L"STBIHOST CMainWnd::Close"));

    // Tell the shell to die off
    SendMessage(_hWndBrowser, WM_CLOSE, 0,0);


	if(_pIPActiveObj)
	{
		_pIPActiveObj->Release();
	}
    _pIPActiveObj = NULL;
	if(_pCP)
	{
		_pCP->Unadvise(_dwEventCookie);
		_pCP->Release();
	}
    _pCP = NULL;
	if(_pObject)
	{
		_pObject->Close(FALSE);
		_pObject->Release();
	}
    _pObject = NULL;
	if(_pBrowser)
	    _pBrowser->Release();
    _pBrowser = NULL;

}




HRESULT CMainWnd::FindString()
{
    LPDISPATCH pDisp = NULL;
    LPOLECOMMANDTARGET pCmdTarg = NULL;
    HRESULT sts = S_OK;
    VARIANTARG var;

#define GOERROR_S(bNotCond)  {if (!(bNotCond)) goto errorS; }

    if (!_pBrowser)
        return S_OK;
    sts = _pBrowser->get_Document(&pDisp);
    GOERROR_S(pDisp);
    sts = pDisp->QueryInterface(IID_IOleCommandTarget, (LPVOID*)&pCmdTarg);
    GOERROR_S(pCmdTarg);

    var.vt   = VT_I4;
    var.lVal = 0;
    sts = pCmdTarg->Exec(
                        NULL,
                        OLECMDID_FIND,
                        MSOCMDEXECOPT_PROMPTUSER,
                        NULL,
                        &var);

    errorS:
    if (pCmdTarg)
        pCmdTarg->Release(); // release document's command target
    if (pDisp)
        pDisp->Release();    // release document's dispatch interface
    return sts;
}


BOOL CMainWnd::EnableSafeArea(BOOL fEnable)
{
	BOOL fRet;

	if (fEnable)
	{
		fRet = SetWindowPos(_hWndBrowser, NULL, _ptSafe.x, _ptSafe.y,
							_lSafeWidth, _lSafeHeight, SWP_NOZORDER);
		if (!fRet)
		{
			ASSERT(FALSE);
			RETAILMSG(1, (TEXT("SetWindowPos(x=%i, y=%i, cx=%i, cy=%i) ")
						  TEXT("failed in CMainWnd::EnableSafeArea()"),
						  _ptSafe.x, _ptSafe.y, _lSafeWidth, _lSafeHeight));
		}
	}
	else
	{
		fRet = SetWindowPos(_hWndBrowser, NULL,
							_rcWnd.left, _rcWnd.top,
							_rcWnd.right - _rcWnd.left,
							_rcWnd.bottom - _rcWnd.top,
							SWP_NOZORDER);
		if (!fRet)
		{
			ASSERT(FALSE);
			RETAILMSG(1, (TEXT("SetWindowPos(x=%i, y=%i, cx=%i, cy=%i) ")
						  TEXT("failed in CMainWnd::EnableSafeArea()"),
						  _rcWnd.left, _rcWnd.top,
						  _rcWnd.right - _rcWnd.left,
						  _rcWnd.bottom - _rcWnd.top));
		}
	}

	if (fRet)
	{
		_fSafeArea = fEnable;
	}

	return fRet;
}


BOOL CMainWnd::AssignAccelerator(ACCEL accel, SHORT nKey)
{
	accel.fVirt = FNOINVERT | FVIRTKEY;
	switch (nKey)
	{
	case RCTL_STOP:
		accel.key = VK_MEDIA_STOP;
		accel.cmd = ID_VIEW_STOP;	
		break;

	case RCTL_PLAY:
		accel.key = VK_PLAY;
		accel.cmd = ID_VIEW_REFRESH;	
		break;

	case RCTL_PREV:
		accel.key = VK_MEDIA_PREV_TRACK;
		accel.cmd = ID_GO_HOME;
		break;

	case RCTL_NEXT:
		accel.key = VK_MEDIA_NEXT_TRACK;
		accel.cmd = ID_GO_SEARCH;
		break;

	case RCTL_BACK:
		accel.key = VK_PRIOR;
		accel.cmd = ID_GO_BACK;
		break;

	case RCTL_FWD:
		accel.key = VK_NEXT;
		accel.cmd = ID_GO_FORWARD;

	case RCTL_VOLUP:
		accel.key = VK_VOLUME_UP;
		accel.cmd = ID_SCROLL_PAGEUP;
		break;

	case RCTL_VOLDN:
		accel.key = VK_VOLUME_DOWN;
		accel.cmd = ID_SCROLL_PAGEDOWN;
		break;

	default:
		ASSERT(FALSE);
		return FALSE;
	}

	return TRUE;
}


// This bitmask defines the keys that StbIHost doesn't
// have in its default accelerator table). We need this
// to insure that StbIHost doesn't suddenly start
// handling these keys when a new table overrides the
// default.
//
// We simply have no use for pause, mute, or menu, and
// SHDOCVW uses left, right, up, down, and select for
// TVLENS tab navigation.
#define RCTLKEYS_BM_DONTCARE  ( RCTL_BM_PAUSE | RCTL_BM_MUTE | RCTL_BM_MENU	\
								| RCTL_BM_LEFT | RCTL_BM_RIGHT | RCTL_BM_UP	\
								| RCTL_BM_DOWN | RCTL_BM_SELECT )

BOOL CMainWnd::CreateAccelTbl(ULONG bmKeys)
{
	// if this ASSERT fails, then the datatype
	// for bmKeys needs to be larger
	ASSERT(RCTL_NUMKEYS < sizeof(bmKeys) * 8);

	_fUseNewAccels = TRUE;

	// all the bit fields in bmKeys with value=1 are
	// the ones the current web page wants to use, so
	// we care about the left-overs--the bitfields with
	// value=0
	bmKeys = (~bmKeys & ~RCTLKEYS_BM_DONTCARE & ((1 << RCTL_NUMKEYS) - 1));

	if (!bmKeys)
		return TRUE;

	ULONG bmKeysTmp = bmKeys;

	// determine length of new accelerator table
	_cNewAccels = 0;
	while (0 != bmKeysTmp)
	{
		if (bmKeysTmp & 1)
			_cNewAccels++;
		bmKeysTmp >>= 1;
	}

	// create table
	if (_rgNewAccels)
		delete [] _rgNewAccels;

	_rgNewAccels = new ACCEL[_cNewAccels];
	if (!_rgNewAccels)
	{
		_cNewAccels = 0;
		_fUseNewAccels = FALSE;
		return FALSE;
	}

	SHORT nKeys = 0, nBit = 0;
	while (0 != bmKeys)
	{
		if (bmKeys & 1)
		{
			if (!AssignAccelerator(_rgNewAccels[nKeys], nBit))
			{
				_cNewAccels = 0;
				delete [] _rgNewAccels;
				_fUseNewAccels = FALSE;
				return FALSE;
			}
			nKeys++;
		}

		bmKeys >>= 1;
		nBit++;
	}

	// finally, register new table
	if (_hAccelTblNew)
		DestroyAcceleratorTable(_hAccelTblNew);
		
	_hAccelTblNew = CreateAcceleratorTable(_rgNewAccels, _cNewAccels);
	if (!_hAccelTblNew)
	{
		ASSERT(FALSE);
		_cNewAccels = 0;
		delete [] _rgNewAccels;
		_fUseNewAccels = FALSE;
		return FALSE;
	}
	
	return TRUE;
}


BOOL CMainWnd::DestroyAccelTbl()
{
	if (_rgNewAccels)
	{
		delete [] _rgNewAccels;
		_rgNewAccels = NULL;
	}

	if (_hAccelTblNew)
	{
		DestroyAcceleratorTable(_hAccelTblNew);
		_hAccelTblNew = NULL;
	}

	_cNewAccels = 0;
	_fUseNewAccels = FALSE;

	return TRUE;
}


BOOL HandleBrowse(HWND hwndOwner, WCHAR *szURL);
       
extern "C" BOOL APIENTRY OpenURLDlgProc (HWND hDlg, UINT message, UINT wParam, LONG lParam)
{

    WCHAR *szURL = (WCHAR *)GetWindowLong(hDlg,DWL_USER); 
    int         nRet = 4;
    
    switch(message)
    {

        case WM_INITDIALOG:
            {
                    if(!lParam)
                    {
                         EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);  
                         EnableWindow(GetDlgItem(hDlg, IDC_BROWSE), FALSE);
                    }
                    else
                    {
                            szURL = (WCHAR *)lParam;
                            SetWindowLong(hDlg, DWL_USER, (LONG)szURL);
                            SendMessage(GetDlgItem(hDlg, IDC_URL_EDIT), EM_LIMITTEXT, MAX_URL-1, 0);
                            if(szURL[0])
                            {
                            
                                   SetDlgItemText(hDlg, IDC_URL_EDIT, szURL);
                            }
                    }

            }
            return TRUE;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {	

                case IDOK:
                {
                    GetDlgItemText(hDlg, IDC_URL_EDIT, szURL, MAX_URL-1);    
                    BOOL bNewWnd = SendMessage(GetDlgItem(hDlg, IDC_NEWWINDOW), BM_GETCHECK, 0L, 0L);
                    nRet = (bNewWnd) ? 2 : 1; 
                }
               case IDCANCEL:
                    EndDialog(hDlg, nRet);
                    return TRUE;
                    
                    
	        case IDC_BROWSE:
                    if(HandleBrowse(hDlg, szURL))
                    {
                        SetDlgItemText(hDlg, IDC_URL_EDIT, szURL);
                    }       
                    
                default:
                    return (TRUE);
            }
            break;

        case WM_DESTROY:
            SetWindowLong(hDlg, DWL_USER, 0);
            break;

    }
    return (FALSE);


}


extern HINSTANCE   g_hInstance;
BOOL HandleBrowse(HWND hwndOwner, WCHAR *szURL)
{

    OPENFILENAME    ofn;
    WCHAR           wchFilter[MAX_PATH];
    WCHAR           wchFile[MAX_PATH+8]; 
    int             cbLen;

 
    // Initialize ofn struct
    memset(&ofn, 0, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner   = hwndOwner;
    ofn.Flags       = OFN_FILEMUSTEXIST
                      | OFN_PATHMUSTEXIST
                      | OFN_OVERWRITEPROMPT
                      | OFN_HIDEREADONLY;

    cbLen = LoadString(g_hInstance, IDS_BROWSEFILTER,
                       wchFilter, MAX_PATH-2);

    if (cbLen>0)
    {
        for (; cbLen >= 0; cbLen--)
        {
            if (wchFilter[cbLen]== L'@')
            {
                wchFilter[cbLen] = 0;
            }
        }
    }
    else
    {
        return FALSE;
    }
   
    
    ofn.lpstrFilter = wchFilter;
    ofn.nFilterIndex = 1;
    wcscpy(wchFile, L"file://");
    
    ofn.lpstrFile = wchFile+wcslen(wchFile);  // prefix the string with "file://"
    ofn.nMaxFile = MAX_PATH;
    if (GetOpenFileName(&ofn))
    {
        wcsncpy(szURL, wchFile, MAX_URL-1);
        return TRUE;
    }

    return FALSE;

}