mainwnd.cpp

Windows CE 下的机顶盒应用实例

    hr = _pBrowser->QueryInterface(IID_IConnectionPointContainer, (LPVOID *)&pCPCont);
    if (hr)
        return S_FALSE;
    hr = pCPCont->FindConnectionPoint(DIID_DWebBrowserEvents2, &_pCP);
    if (hr)
	{
		_pCP = NULL;
        goto Cleanup;
	}

    hr = QueryInterface(DIID_DWebBrowserEvents2, (LPVOID *)(&pEvents));
    if (hr)
        goto Cleanup;
    hr = _pCP->Advise(pEvents, &(_dwEventCookie));
    if (hr)
        goto Cleanup;


    Cleanup:
    if (pCPCont)
        pCPCont->Release();
    if (pEvents)
        pEvents->Release();
    return hr;
}



HRESULT HandleNewWindow2(LPTSTR lpszUrl, DISPPARAMS FAR* pdparams)
{

        HANDLE hThread;
        CMainWnd *pNewWnd;
        IDispatch *pDispatch;
        HRESULT hr = S_OK;

        pNewWnd = new CMainWnd;

        if (!pNewWnd)
        {
            return E_OUTOFMEMORY;
        }

        pNewWnd->_lpszUrl = lpszUrl;
        if(!pdparams)
            pNewWnd->_fEmpty = TRUE;
            
        pNewWnd->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

        if (!pNewWnd->hEvent)
        {

        }

        InterlockedIncrement(&glThreadCount);

        hThread = CreateThread(NULL, g_dwMainWindowStackSize, NewWindow, (LPVOID)pNewWnd, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);

        if (!hThread)
        {
            delete pNewWnd;
            InterlockedDecrement(&glThreadCount);
            return E_OUTOFMEMORY;
        }

        WaitForSingleObject(pNewWnd->hEvent, INFINITE);
	CloseHandle(hThread);
        if(pdparams)
        {
            if (pNewWnd->_pBrowser)
            {
                hr = pNewWnd->_pBrowser->QueryInterface(IID_IDispatch, (LPVOID *)(&pDispatch));
            }
            else
            {
                hr = E_FAIL;
                pDispatch = NULL;
            }

            *(pdparams->rgvarg[0].pboolVal) = 0;
            *(pdparams->rgvarg[1].ppdispVal) = pDispatch;
        }
        return hr;
}


STDMETHODIMP CMainWnd::GetExternal(IDispatch **ppDispatch)
{
	HRESULT hr = S_OK;

	if (!ppDispatch) return E_POINTER;

	if (*ppDispatch)
		*ppDispatch = NULL;

	if (!_pUnkExternal)
	{
		_pUnkExternal = new CComObject<CHostExternal>();
		if (!_pUnkExternal) return E_OUTOFMEMORY;
		_pUnkExternal->AddRef();
		(reinterpret_cast<CHostExternal*>(_pUnkExternal))->SetInst(this);
	}

	return _pUnkExternal->QueryInterface(IID_IDispatch, (PVOID*)(ppDispatch));
}

STDMETHODIMP CMainWnd::GetHostInfo(DOCHOSTUIINFO *pInfo)
{
	
	pInfo->cbSize = sizeof(DOCHOSTUIINFO);
	//pInfo->dwFlags = DOCHOSTUIFLAG_NO3DBORDER|DOCHOSTUIFLAG_FLAT_SCROLLBAR;
	//pInfo->dwFlags |= DOCHOSTUIFLAG_SCROLL_NO;

	return S_OK;

}

STDMETHODIMP CMainWnd::Invoke (
                              DISPID dispidMember,
                              REFIID riid,
                              LCID lcid,
                              WORD wFlags,
                              DISPPARAMS FAR* pdparams,
                              VARIANT FAR* pvarResult,
                              EXCEPINFO FAR* pexcepinfo,
                              UINT FAR* puArgErr
                              )
{
    switch (dispidMember)
    {
    case DISPID_AMBIENT_DLCONTROL:
	if(pvarResult)
	{
		V_VT(pvarResult) = VT_I4;
		// always set these three unless they should be disabled
		pvarResult->lVal = DLCTL_DLIMAGES|DLCTL_VIDEOS|DLCTL_BGSOUNDS;
		
		// put the browser in download only mode
		// pvarResult->lVal |= DLCTL_DOWNLOADONLY;
	}
	break;

    case DISPID_STATUSTEXTCHANGE:
        {
        }
        break;
        
    case DISPID_SETSECURELOCKICON:
        {
        }
        break;

    case DISPID_PROGRESSCHANGE:
        {
            LONG lProgMax = pdparams->rgvarg[0].lVal;
            LONG lProg = pdparams->rgvarg[1].lVal;
            UINT nPos = (lProg == -1) ? 999 : ((lProg-1)%1000);
  
            SendMessage(_hwndProgress, PBM_SETPOS, nPos, 0);
        }
        break;

    // notification for file download
    case DISPID_FILEDOWNLOAD:
	break;


    case DISPID_NAVIGATECOMPLETE2:
        break;

    case DISPID_COMMANDSTATECHANGE:
        break;

    case DISPID_TITLECHANGE:
            if (pdparams && pdparams->rgvarg[0].vt == VT_BSTR)
            {
                TCHAR szTitle[85];
                int len = wcslen(pdparams->rgvarg[0].bstrVal);
                    
                _tcsncpy(_szTitle, pdparams->rgvarg[0].bstrVal, MAX_URL-1);
                _tcsncpy(szTitle, pdparams->rgvarg[0].bstrVal, 80);
                if(len > 80)
                    _tcscat(szTitle, L"...");

                SetWindowText(_hWnd, szTitle);
            }
            break;

    case DISPID_ONQUIT:
        PostMessage(_hWnd, WM_CLOSE, 0, 0L);
        break;

    case DISPID_DOWNLOADBEGIN:
	_wDLCCounter++;
        SetWindowPos(_hwndProgress, HWND_TOP, 0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_SHOWWINDOW);
        break;
    case DISPID_DOWNLOADCOMPLETE:
    case DISPID_DOCUMENTCOMPLETE:
	_wDLCCounter--;
	if(_wDLCCounter <= 0)
	{
        	SetWindowPos(_hwndProgress,NULL, 0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_HIDEWINDOW);
        	ChangeFontSize(TRUE);
		_wDLCCounter = 0;
	}
        break;

    case DISPID_NEWWINDOW2:
        //pdparams->rgvarg[1].boolVal = VARIANT_TRUE;
        //break;        
        return HandleNewWindow2(NULL, pdparams);
            break;


    case DISPID_PROPERTYCHANGE:
    case DISPID_BEFORENAVIGATE2:
        break;
    default:
        return DISP_E_MEMBERNOTFOUND;
    }
    return S_OK;
}


STDMETHODIMP CMainWnd::moveTo( LONG x, LONG y)
{
    SetWindowPos(_hWnd, NULL, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE);
    return S_OK;
}

STDMETHODIMP CMainWnd::moveBy( LONG x, LONG y) 
{
    RECT rcWindow;

    GetWindowRect(_hWnd, &rcWindow);

    SetWindowPos(_hWnd, NULL, rcWindow.left + x, rcWindow.top + y, 0, 0,
                               SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE);
    return S_OK;
}


STDMETHODIMP CMainWnd::resizeTo( LONG x, LONG y) 
{
                // We do not want the size to be less then 100 for top level windows in browser
    if (x < 100)
        x = 100;

    if (y < 100)
        y = 100;

    SetWindowPos(_hWnd, NULL, 0, 0, x, y, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);

    return S_OK;             
}

STDMETHODIMP CMainWnd::resizeBy( LONG x, LONG y) 
{
    RECT rcWindow;
    long w, h;

    GetWindowRect(_hWnd, &rcWindow);

    w = rcWindow.right - rcWindow.left + x;
    h = rcWindow.bottom - rcWindow.top + y;

    if (w < 100)
        w = 100;

    if (h < 100)
        h = 100;

    SetWindowPos(_hWnd, NULL, 0, 0, w, h, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
    return S_OK;
}


EXTERN_C const GUID CGID_MSHTML;
extern "C" BOOL APIENTRY OpenURLDlgProc (HWND hDlg, UINT message, UINT wParam, LONG lParam);

LRESULT CMainWnd::HandleCommand(WPARAM wParam, LPARAM lParam)
{
    UINT nID = LOWORD(wParam);
    switch (nID)
    {
	case ID_INTERNET_OPTIONS:
	{
	   SHELLEXECUTEINFO sei;
           sei.cbSize = sizeof(sei);
           sei.fMask = SEE_MASK_FLAG_NO_UI;
           sei.hwnd = _hWnd;
           sei.lpVerb = NULL;
           sei.lpFile = L"ctlpnl";
           sei.lpParameters = L"inetcpl.cpl";
           sei.lpDirectory = NULL;
           sei.nShow = SW_SHOWNORMAL;

       	   ShellExecuteEx(&sei); 
	 }
	   break;
	case ID_FIND:
		FindString();
	    break;
    case ID_GO_BACK:
        _pBrowser->GoBack();
        return 0;
    case ID_GO_FORWARD:
        _pBrowser->GoForward();
        return 0;
    case ID_GO_HOME:
        _pBrowser->GoHome();
        return 0;
    case ID_GO_SEARCH:
        _pBrowser->GoSearch();
        return 0;
    case ID_VIEW_REFRESH:
        _pBrowser->Refresh();
        return 0;
    case ID_VIEW_STOP:
        _pBrowser->Stop();
        return 0;
    case ID_SCROLL_PAGEUP:
    case ID_SCROLL_PAGEDOWN:
    	{	// TODO: this isn't working...
            ASSERT(_pBrowser);
            LPDISPATCH pDisp = NULL;
            LPOLECOMMANDTARGET pCmdTarg = NULL;
            VARIANTARG var;
            HRESULT hr;

            UINT nCmdId = (ID_SCROLL_PAGEUP == nID 
                           ? IDM_SCROLL_PAGEUP
                           : IDM_SCROLL_PAGEDOWN);

            hr = _pBrowser->get_Document(&pDisp);
            if (FAILED(hr) || !pDisp) break;

            hr = pDisp->QueryInterface(IID_IOleCommandTarget,
                                       (LPVOID*)&pCmdTarg);
            if (FAILED(hr) || !pCmdTarg)
            {
                pDisp->Release();
                break;
            }

            var.vt = VT_I4;
            var.lVal = 0;
            hr = pCmdTarg->Exec(&CGID_MSHTML, nCmdId, 0, 0, 0);

            if (pCmdTarg) pCmdTarg->Release();
            if (pDisp) pDisp->Release();
        }
        break;

    case ID_ZOOMUP:
        _wZoom++;
        if(_wZoom > 4)
            _wZoom = 4;
        ChangeFontSize(FALSE);
        return 0;

    case ID_ZOOMDOWN:
        _wZoom--;
        if(_wZoom < 0)
            _wZoom = 0;
        ChangeFontSize(FALSE);
        return 0;
    case ID_CLOSE:
        _pBrowser->ExecWB(OLECMDID_CLOSE, OLECMDEXECOPT_DODEFAULT, NULL, NULL);
        return 0;
    case ID_FOCUS_URL:
    case ID_OPEN:
        {
            WCHAR *szURL = new TCHAR[MAX_URL];
            if (szURL)
            {
                int nRet = 0;                
                BSTR bstrUrl = NULL;
                _pBrowser->get_LocationURL(&bstrUrl);
                StringCchCopy(szURL, MAX_URL, (LPCTSTR)bstrUrl);
                SysFreeString(bstrUrl);
                nRet =  DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_OPEN_DIALOG), _hWnd, OpenURLDlgProc, (long)szURL);
                if(nRet == 1)
                {
                    _pBrowser->Navigate(szURL, NULL, NULL, NULL, NULL);
                }
                else if(nRet == 2)
                {
                    HandleNewWindow2(szURL, NULL);
                }
                delete[] szURL;
            }
        }
        return 0;
    }
    return 0;
}





EXTERN_C const GUID CGID_ShellDocView;

LRESULT CALLBACK CMainWnd::MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	CMainWnd *pMainWnd = (CMainWnd*)GetWindowLong(hwnd, GWL_USERDATA);

	if (pMainWnd)
	{
		switch (message)
		{
		case WM_CLOSE:
		case WM_DESTROY:
			if(pMainWnd)
				pMainWnd->Close();
			SetWindowLong(hwnd, GWL_USERDATA, (DWORD)0);
			::PostQuitMessage(0);
			break;

		case WM_SETFOCUS:
			if (pMainWnd->_pIPActiveObj)
			{
				pMainWnd->_pIPActiveObj->OnFrameWindowActivate(LOWORD(wParam) != WA_INACTIVE);
			}
			return 0;

		case WM_SIZE:
			{
				RECT rcWnd;
				GetClientRect(hwnd, &rcWnd);
				SetWindowPos(pMainWnd->_hWndBrowser,  
							 NULL, 0, 0,
							 rcWnd.right-rcWnd.left,
							 rcWnd.bottom - rcWnd.top,
							 SWP_NOZORDER);		
			}
			// FALL THROUGH

		case WM_MOVE:
			break;

		case WM_COMMAND:
			return pMainWnd->HandleCommand(wParam, lParam);

		case WM_NOTIFY:
			break;

		case WM_INITMENUPOPUP:
			break;

		case WM_SETTINGCHANGE:
			if(wParam == SPI_SETWORKAREA)
			{
				ASSERT(FALSE);
			}
			break;

		// TODO:  We currently only use WM_COPYDATA for the WMP page.
		// TODO:  If we load other types of pages as well, we'll need to develop
		// TODO:  a protocol to determine who sent the WM_COPYDATA message.
		// TODO:  e.g. - "type=stbihostwmp&url=<URL>"
		case WM_COPYDATA:
			// navigate to the WMP webpage, passing it the copied link
			if( lParam )
			{
				HKEY hKey;
				DWORD cbData, dwType, cbDummy;
				LONG lRet;
				LPTSTR szNavURL;

				lRet = RegOpenKeyEx(HKEY_CURRENT_USER, REG_ROOTKEY, 0, 0, &hKey);
				ASSERT(ERROR_SUCCESS == lRet);
				if (ERROR_SUCCESS != lRet)
				{
					DEBUGMSG(1, (TEXT("Error (%u) getting registry key: ")
								REG_ROOTKEY TEXT("\r\n"), GetLastError()));
					break;
				}

				// just get the size first
				lRet = RegQueryValueEx(hKey, REG_WMPVALUE, NULL,
									   &dwType, NULL, &cbData);
				ASSERT(ERROR_SUCCESS == lRet);
				if (ERROR_SUCCESS != lRet)
				{
					DEBUGMSG(1, (TEXT("Error (%u) getting registry value: ")
								REG_ROOTKEY REG_WMPVALUE, GetLastError()));
					RegCloseKey(hKey);
					break;
				}

				ASSERT(REG_SZ == dwType);
				cbData += _tcslen(TEXT("#")) * sizeof(TCHAR);