mainwnd.cpp

实现Wince.Net平台下IE浏览器的功能

    {
    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_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);
                                nRet = StringCchCopy(szURL, MAX_URL, (LPCTSTR)bstrURL);
                                SysFreeString(bstrURL);
                    
                                nRet =  DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_OPEN_DIALOG), _hWnd, OpenURLDlgProc, (long)szURL);
                                bstrURL = SysAllocString(szURL);
                                if(nRet == 1)
                                {
                                        _pBrowser->Navigate(bstrURL, NULL, NULL, NULL, NULL);
                                }
                                else if(nRet == 2)
                                {
                                        HandleNewWindow2(bstrURL,NULL);
                                }
                              SysFreeString(bstrURL);
                        delete[] szURL;
                    }
                }
                return 0;
        case ID_FULLSCREEN:
        {
            DWORD dwStyle = GetWindowLong(_hWnd, GWL_STYLE);
            if(_fFullScreen)
            {
                dwStyle |= (WS_OVERLAPPED | WS_SYSMENU | WS_THICKFRAME);
                SetWindowLong(_hWnd, GWL_STYLE, dwStyle);
                SetWindowPos(_hWnd,NULL,  _rcWnd.left, _rcWnd.top, _rcWnd.right-_rcWnd.left, _rcWnd.bottom-_rcWnd.top, SWP_NOZORDER);
                _fFullScreen = FALSE;
            }
            else
            {
                RECT rcWorkArea;
                
                SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0);
                _fFullScreen = TRUE;
                dwStyle &= ~(WS_OVERLAPPED | WS_SYSMENU | WS_THICKFRAME);
                
                SetWindowLong(_hWnd, GWL_STYLE, dwStyle);
                SetWindowPos(_hWnd,NULL,  rcWorkArea.left, rcWorkArea.top, rcWorkArea.right-rcWorkArea.left, rcWorkArea.bottom-rcWorkArea.top, SWP_NOZORDER);

            }
         }
            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:
                  if(!pMainWnd->_fFullScreen)  
		        GetWindowRect(hwnd, &pMainWnd->_rcWnd);			                                       
            break;

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

        case WM_NOTIFY:
	    break;

        case WM_INITMENUPOPUP:
            break;

        case WM_SETTINGCHANGE:
            if(wParam == SPI_SETWORKAREA)
            {
                if(pMainWnd->_fFullScreen)
                {
                    RECT rcWorkArea;
                    // no need to change the window style here, just adjust for the new work-area.
                    SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0);
                    SetWindowPos(pMainWnd->_hWnd,NULL,  rcWorkArea.left, rcWorkArea.top, rcWorkArea.right-rcWorkArea.left, rcWorkArea.bottom-rcWorkArea.top, SWP_NOZORDER);
                }
            }
            break;
        default:
            break;
        }
    }
    return DefWindowProc(hwnd, message, wParam, lParam);
}

BOOL CMainWnd::PreTranslateMessage(LPMSG pMsg)
{
//    if (::TranslateAccelerator(_hWnd, _hAccelTbl, pMsg))  //first shot to the main frame
//        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"IESIMPLE 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 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;

}