browserview.cpp

JDesktop Integration Components （JDIC）

void CBrowserView::OnPaste()
{
    if (m_bUrlBarClipOp)
    {
        mpBrowserFrame->PasteFromClipboardToUrlBar();
        m_bUrlBarClipOp = FALSE;
    }
    else
    {
        nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(mWebBrowser);

        if (clipCmds)
            clipCmds->Paste();
    }
}

void CBrowserView::OnUndoUrlBarEditOp()
{
    if (mpBrowserFrame->CanUndoUrlBarEditOp())
        mpBrowserFrame->UndoUrlBarEditOp();
}

void CBrowserView::OnUpdatePaste(CCmdUI* pCmdUI)
{
    PRBool canPaste = PR_FALSE;

    nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(mWebBrowser);
    if (clipCmds)
        clipCmds->CanPaste(&canPaste);

    if (!canPaste)
    {
        if (mpBrowserFrame->CanPasteToUrlBar())
        {
            canPaste = TRUE;
            m_bUrlBarClipOp = TRUE;
        }
    }

    pCmdUI->Enable(canPaste);
}

void CBrowserView::OnSelectAll()
{
    nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(mWebBrowser);

    if (clipCmds)
        clipCmds->SelectAll();
}

void CBrowserView::OnSelectNone()
{
    nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(mWebBrowser);

    if (clipCmds)
        clipCmds->SelectNone();
}

void CBrowserView::OnFileOpen()
{
    char *lpszFilter =
        "HTML Files Only (*.htm;*.html)|*.htm;*.html|"
        "All Files (*.*)|*.*||";

    CFileDialog cf(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                    lpszFilter, this);
    if (cf.DoModal() == IDOK)
    {
        CString strFullPath = cf.GetPathName(); // Will be like: c:\tmp\junk.htm
        OpenURL(strFullPath);
    }
}

nsresult CBrowserView::SavePageAs()
{
    nsresult rv;

    nsCOMPtr<nsIFilePicker> filePicker = do_CreateInstance("@mozilla.org/filepicker;1", &rv);
    NS_ENSURE_SUCCESS(rv, rv);

    rv = filePicker->Init(nsnull, NS_LITERAL_STRING("Save Page As").get(), nsIFilePicker::modeSave);
    NS_ENSURE_SUCCESS(rv, rv);

    filePicker->AppendFilter(NS_LITERAL_STRING("Web Page, HTML Only (*.htm;*.html)").get(),
                             NS_LITERAL_STRING("*.htm;*.html").get());
    filePicker->AppendFilter(NS_LITERAL_STRING("Text File (*.txt)").get(),
                             NS_LITERAL_STRING("*.txtl").get());

    NS_ENSURE_TRUE(mBaseWindow, NS_ERROR_ABORT);
    nsXPIDLString idlStrTitle;
    mBaseWindow->GetTitle(getter_Copies(idlStrTitle));
    idlStrTitle.Append(NS_LITERAL_STRING(".html"));

    rv = filePicker->SetDefaultString(idlStrTitle);
    NS_ENSURE_SUCCESS(rv, rv);

    PRInt16 dialogResult;
    filePicker->Show(&dialogResult);

    if (dialogResult == nsIFilePicker::returnCancel) {
        return NS_ERROR_ABORT;
    }

    nsCOMPtr<nsILocalFile> localFile;
    rv = filePicker->GetFile(getter_AddRefs(localFile));
    NS_ENSURE_SUCCESS(rv, rv);

    if (dialogResult == nsIFilePicker::returnReplace) {
        // be extra safe and only delete when the file is really a file
        PRBool isFile;
        rv = localFile->IsFile(&isFile);
        if (NS_SUCCEEDED(rv) && isFile) {
            rv = localFile->Remove(PR_FALSE);
            NS_ENSURE_SUCCESS(rv, rv);
        }
    }

    nsCOMPtr<nsIWebBrowserPersist> persist(do_QueryInterface(mWebBrowser));
    rv = persist->SaveURI(nsnull, nsnull, nsnull, nsnull, nsnull, localFile);

    return rv;
}

void CBrowserView::OnFileSaveAs()
{
	SavePageAs();
}

nsresult CBrowserView::GetURL(nsCAutoString &uriString)
{
    nsCOMPtr<nsIURI> currentURI;
    nsresult rv = mWebNav->GetCurrentURI(getter_AddRefs(currentURI));
    NS_ENSURE_SUCCESS(rv, rv);
    if (currentURI == NULL)
        return NS_ERROR_FAILURE;
    else
        return currentURI->GetSpec(uriString);
}

void CBrowserView::OpenURL(const char* pUrl, const char* pPostData, const char* pHeader)
{
    OpenURL(NS_ConvertASCIItoUCS2(pUrl).get(), pPostData, pHeader);
}

void CBrowserView::OpenURL(const PRUnichar* pUrl, const char* pPostData, const char* pHeader)
{
    if (! mWebNav)
        return;

    nsresult rv;
    nsCOMPtr<nsIInputStream> postDataStream;
    nsCOMPtr<nsIInputStream> headersStream;

    if (pPostData) 
    {
        unsigned long nSizeData = strlen(pPostData);
        if (nSizeData > 0) 
        {
            char szCL[64];
            sprintf(szCL, "Content-Length: %lu\r\n\r\n", nSizeData);
            unsigned long nSizeCL = strlen(szCL);
            unsigned long nSize = nSizeCL + nSizeData;

            // byte stream owns this memory.
            char *tmpPostData = (char *) nsMemory::Alloc(nSize + 1); 
            if (tmpPostData) 
            {
                memcpy(tmpPostData, szCL, nSizeCL);
                memcpy(tmpPostData + nSizeCL, pPostData, nSizeData);
                tmpPostData[nSize] = '\0';

                nsCOMPtr<nsIStringInputStream> stream;
                stream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv);
                if (NS_FAILED(rv) || !stream) 
                {
                    NS_ASSERTION(0, "cannot create PostData stream");
                    nsMemory::Free(tmpPostData);
                    return;
                }

                stream->AdoptData(tmpPostData, nSize);
                postDataStream = do_QueryInterface(stream);
            }
        }
    }
    
    if (pHeader) 
    {
        unsigned long nSize = strlen(pHeader) + 1;
        if (nSize > 0) 
        {
            // byteArray stream owns this memory.
            char *tmpHeader = (char *) nsMemory::Alloc(nSize); 
            if (tmpHeader) 
            {
                memcpy(tmpHeader, pHeader, nSize);

                nsCOMPtr<nsIStringInputStream> stream;
                stream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv);
                if (NS_FAILED(rv) || !stream) 
                {
                    NS_ASSERTION(0, "cannot create Header stream");
                    nsMemory::Free(tmpHeader);
                    return;
                }

                stream->AdoptData(tmpHeader, nSize);
                headersStream = do_QueryInterface(stream);
            }
        }
    }

    mWebNav->LoadURI(pUrl,                              // URI string
                     nsIWebNavigation::LOAD_FLAGS_NONE, // Load flags
                     nsnull,                            // Refering URI
                     postDataStream,                    // Post data
                     headersStream);                    // Extra headers
}

CBrowserFrame* CBrowserView::CreateNewBrowserFrame(
                                    PRUint32 chromeMask,
                                    PRInt32 x, PRInt32 y,
                                    PRInt32 cx, PRInt32 cy,
                                    PRBool bShowWindow)
{
    MozEmbedApp *pApp = (MozEmbedApp *)AfxGetApp();
    if (!pApp)
        return NULL;

    return pApp->CreateNewBrowserFrame(
        chromeMask, NULL, x, y, cx, cy, bShowWindow);
}

void CBrowserView::OpenURLInNewWindow(const PRUnichar* pUrl)
{
    if (!pUrl)
        return;

    CBrowserFrame* pFrm = CreateNewBrowserFrame();
    if (!pFrm)
        return;

    // Load the URL into it...

    // Note that OpenURL() is overloaded - one takes a "char *"
    // and the other a "PRUniChar *". We're using the "PRUnichar *"
    // version here

    pFrm->m_wndBrowserView.OpenURL(pUrl);
}

void CBrowserView::OnCopyLinkLocation()
{
    if (! mCtxMenuLinkUrl.Length())
        return;

    if (! OpenClipboard())
        return;

    HGLOBAL hClipData = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, mCtxMenuLinkUrl.Length() + 1);
    if (! hClipData)
        return;

    char *pszClipData = (char*)::GlobalLock(hClipData);
    if (!pszClipData)
        return;

    mCtxMenuLinkUrl.ToCString(pszClipData, mCtxMenuLinkUrl.Length() + 1);

    GlobalUnlock(hClipData);

    EmptyClipboard();
    SetClipboardData(CF_TEXT, hClipData);
    CloseClipboard();
}

void CBrowserView::OnOpenLinkInNewWindow()
{
    if (mCtxMenuLinkUrl.Length())
        OpenURLInNewWindow(mCtxMenuLinkUrl.get());
}

void CBrowserView::OnViewImageInNewWindow()
{
    if (mCtxMenuImgSrc.Length())
        OpenURLInNewWindow(mCtxMenuImgSrc.get());
}

void CBrowserView::OnUpdateViewImage(CCmdUI *pCmdUI)
{
    pCmdUI->Enable(mCtxMenuImgSrc.Length() > 0);
}

void CBrowserView::OnSaveLinkAs()
{
    if (! mCtxMenuLinkUrl.Length())
        return;

    // Try to get the file name part from the URL
    // To do that we first construct an obj which supports
    // nsIRUI interface. Makes it easy to extract portions
    // of a URL like the filename, scheme etc. + We'll also
    // use it while saving this link to a file
    nsresult rv   = NS_OK;
    nsCOMPtr<nsIURI> linkURI;
    rv = NS_NewURI(getter_AddRefs(linkURI), mCtxMenuLinkUrl);
    if (NS_FAILED(rv))
        return;

    // Get the "path" portion (see nsIURI.h for more info
    // on various parts of a URI)
    nsCAutoString fileName;
    linkURI->GetPath(fileName);

    // The path may have the "/" char in it - strip those
    fileName.StripChars("\\/");

    // Now, use this file name in a File Save As dlg...

    char *lpszFilter =
        "HTML Files (*.htm;*.html)|*.htm;*.html|"
        "Text Files (*.txt)|*.txt|"
        "All Files (*.*)|*.*||";

    const char *pFileName = fileName.Length() ? fileName.get() : NULL;

    CFileDialog cf(FALSE, "htm", pFileName, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
        lpszFilter, this);
    if (cf.DoModal() == IDOK)
    {
        CString strFullPath = cf.GetPathName();

        nsCOMPtr<nsIWebBrowserPersist> persist(do_QueryInterface(mWebBrowser));
        if (persist)
        {
            nsCOMPtr<nsILocalFile> file;
            NS_NewNativeLocalFile(nsDependentCString(strFullPath.GetBuffer(0)), TRUE, getter_AddRefs(file));
            persist->SaveURI(linkURI, nsnull, nsnull, nsnull, nsnull, file);
        }
    }
}

void CBrowserView::OnSaveImageAs()
{
    if (! mCtxMenuImgSrc.Length())
        return;

    // Try to get the file name part from the URL
    // To do that we first construct an obj which supports
    // nsIRUI interface. Makes it easy to extract portions
    // of a URL like the filename, scheme etc. + We'll also
    // use it while saving this link to a file
    nsresult rv   = NS_OK;
    nsCOMPtr<nsIURI> linkURI;
    rv = NS_NewURI(getter_AddRefs(linkURI), mCtxMenuImgSrc);
    if (NS_FAILED(rv))
        return;

    // Get the "path" portion (see nsIURI.h for more info
    // on various parts of a URI)
    nsCAutoString path;
    linkURI->GetPath(path);

    // The path may have the "/" char in it - strip those
    nsCAutoString fileName(path);
    fileName.StripChars("\\/");

    // Now, use this file name in a File Save As dlg...

    char *lpszFilter = "All Files (*.*)|*.*||";
    const char *pFileName = fileName.Length() ? fileName.get() : NULL;

    CFileDialog cf(FALSE, NULL, pFileName, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
        lpszFilter, this);
    if (cf.DoModal() == IDOK)
    {
        CString strFullPath = cf.GetPathName();

        nsCOMPtr<nsIWebBrowserPersist> persist(do_QueryInterface(mWebBrowser));
        if (persist)
        {
            nsCOMPtr<nsILocalFile> file;
            NS_NewNativeLocalFile(nsDependentCString(strFullPath.GetBuffer(0)), TRUE, getter_AddRefs(file));
            persist->SaveURI(linkURI, nsnull, nsnull, nsnull, nsnull, file);
        }
    }
}


// Called from the busy state related methods in the
// BrowserFrameGlue object
//
// When aBusy is TRUE it means that browser is busy loading a URL
// When aBusy is FALSE, it's done loading
// We use this to update our STOP tool bar button
//
// We basically note this state into a member variable
// The actual toolbar state will be updated in response to the
// ON_UPDATE_COMMAND_UI method - OnUpdateNavStop() being called
//
void CBrowserView::UpdateBusyState(PRBool aBusy)
{
  if (mbDocumentLoading && !aBusy && m_InPrintPreview)
  {
      nsCOMPtr<nsIWebBrowserPrint> print(do_GetInterface(mWebBrowser));
        if (print)
        {
          PRBool isDoingPP;
          print->GetDoingPrintPreview(&isDoingPP);
          if (!isDoingPP)
          {
              m_InPrintPreview = FALSE;
              CMenu* menu = mpBrowserFrame->GetMenu();
              if (menu)
              {
                  menu->CheckMenuItem( ID_FILE_PRINTPREVIEW, MF_UNCHECKED );
              }
          }
      }
  }
    mbDocumentLoading = aBusy;
}

void CBrowserView::SetCtxMenuLinkUrl(nsAutoString& strLinkUrl)
{
    mCtxMenuLinkUrl = strLinkUrl;
}

void CBrowserView::SetCtxMenuImageSrc(nsAutoString& strImgSrc)
{
    mCtxMenuImgSrc = strImgSrc;
}

void CBrowserView::SetCurrentFrameURL(nsAutoString& strCurrentFrameURL)
{
    mCtxMenuCurrentFrameURL = strCurrentFrameURL;
}

void CBrowserView::Activate(UINT nState, CWnd* pWndOther, BOOL bMinimized)
{
    nsCOMPtr<nsIWebBrowserFocus> focus(do_GetInterface(mWebBrowser));
    if (!focus)
        return;

    switch(nState) {
        case WA_ACTIVE:
        case WA_CLICKACTIVE:
            focus->Activate();
            break;
        case WA_INACTIVE:
            focus->Deactivate();
            break;
        default:
            break;
    }
}

void CBrowserView::ShowSecurityInfo()
{
    HWND hParent = mpBrowserFrame->m_hWnd;

    if (m_SecurityState == SECURITY_STATE_INSECURE) {
        CString csMsg;
        csMsg.LoadString(IDS_NOSECURITY_INFO);
        ::MessageBox(hParent, csMsg, "MozEmbed", MB_OK);
        return;
    }

    ::MessageBox(hParent, "To Be Done..........", "MozEmbed", MB_OK);
}

// Determintes if the currently loaded document
// contains frames
//
BOOL CBrowserView::ViewContentContainsFrames()
{
    nsresult rv = NS_OK;

    // Get nsIDOMDocument from nsIWebNavigation
    nsCOMPtr<nsIDOMDocument> domDoc;
    rv = mWebNav->GetDocument(getter_AddRefs(domDoc));
    if (NS_FAILED(rv))
       return FALSE;

    // QI nsIDOMDocument for nsIDOMHTMLDocument
    nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryInterface(domDoc);
    if (!htmlDoc)
        return FALSE;

    // Get the <body> element of the doc
    nsCOMPtr<nsIDOMHTMLElement> body;
    rv = htmlDoc->GetBody(getter_AddRefs(body));
    if (NS_FAILED(rv))
       return FALSE;

    // Is it of type nsIDOMHTMLFrameSetElement?
    nsCOMPtr<nsIDOMHTMLFrameSetElement> frameset = do_QueryInterface(body);

    return (frameset != nsnull);
}

void CBrowserView::OnViewFrameSource()
{
    USES_CONVERSION;

    // Build the view-source: url
    //
    nsCAutoString viewSrcUrl;
    viewSrcUrl.Append("view-source:");
    viewSrcUrl.Append(W2T(mCtxMenuCurrentFrameURL.get()));

    OpenViewSourceWindow(viewSrcUrl.get());
}

void CBrowserView::OnOpenFrameInNewWindow()
{
    if (mCtxMenuCurrentFrameURL.Length())
        OpenURLInNewWindow(mCtxMenuCurrentFrameURL.get());
}