зеркало из https://github.com/mozilla/pjs.git
4245 строки
108 KiB
C++
4245 строки
108 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "License"); you may not use this file except in
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS"
|
|
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
|
|
* the License for the specific language governing rights and limitations
|
|
* under the License.
|
|
*
|
|
* The Original Code is Mozilla Communicator client code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape Communications
|
|
* Corporation. Portions created by Netscape are Copyright (C) 1998
|
|
* Netscape Communications Corporation. All Rights Reserved.
|
|
*/
|
|
#include "nsIWebShell.h"
|
|
#include "nsIDocumentLoader.h"
|
|
#include "nsIContentViewer.h"
|
|
#include "nsIDocumentViewer.h"
|
|
#include "nsIClipboardCommands.h"
|
|
#include "nsIDeviceContext.h"
|
|
#include "nsILinkHandler.h"
|
|
#include "nsIStreamListener.h"
|
|
#ifdef NECKO
|
|
#include "nsIPrompt.h"
|
|
#include "nsNeckoUtil.h"
|
|
#include "nsIProtocolHandler.h"
|
|
#include "nsIDNSService.h"
|
|
#include "nsIRefreshURI.h"
|
|
#else
|
|
#include "nsINetSupport.h"
|
|
#include "nsIRefreshUrl.h"
|
|
#include "jsurl.h"
|
|
#endif
|
|
#include "nsIScriptGlobalObject.h"
|
|
#include "nsIScriptContextOwner.h"
|
|
#include "nsIDocumentLoaderObserver.h"
|
|
#include "nsDOMEvent.h"
|
|
#include "nsIPresContext.h"
|
|
#include "nsIComponentManager.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsIEventQueueService.h"
|
|
#include "nsCRT.h"
|
|
#include "nsVoidArray.h"
|
|
#include "nsString.h"
|
|
#include "nsWidgetsCID.h"
|
|
#include "nsGfxCIID.h"
|
|
#include "plevent.h"
|
|
#include "prprf.h"
|
|
#include "nsIPluginHost.h"
|
|
#include "nsplugin.h"
|
|
//#include "nsPluginsCID.h"
|
|
#include "nsIPluginManager.h"
|
|
#include "nsIPref.h"
|
|
#include "nsITimer.h"
|
|
#include "nsITimerCallback.h"
|
|
#include "nsIBrowserWindow.h"
|
|
#include "nsIContent.h"
|
|
#include "prlog.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIStreamObserver.h"
|
|
#include "nsIWebShellServices.h"
|
|
#include "nsIGlobalHistory.h"
|
|
#include "prmem.h"
|
|
#include "nsXPIDLString.h"
|
|
|
|
#ifdef XP_PC
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
//XXX used for nsIStreamObserver implementation. This sould be replaced by DocLoader
|
|
// notifications...
|
|
#include "nsIURL.h"
|
|
#ifdef NECKO
|
|
#include "nsIIOService.h"
|
|
#include "nsIURL.h"
|
|
#endif // NECKO
|
|
|
|
//XXX for nsIPostData; this is wrong; we shouldn't see the nsIDocument type
|
|
#include "nsIDocument.h"
|
|
|
|
#ifdef DEBUG
|
|
#undef NOISY_LINKS
|
|
#else
|
|
#undef NOISY_LINKS
|
|
#endif
|
|
|
|
#ifdef NS_DEBUG
|
|
/**
|
|
* Note: the log module is created during initialization which
|
|
* means that you cannot perform logging before then.
|
|
*/
|
|
static PRLogModuleInfo* gLogModule = PR_NewLogModule("webshell");
|
|
#endif
|
|
|
|
#define WEB_TRACE_CALLS 0x1
|
|
#define WEB_TRACE_HISTORY 0x2
|
|
#define OLD_HISTORY 1
|
|
|
|
#define WEB_LOG_TEST(_lm,_bit) (PRIntn((_lm)->level) & (_bit))
|
|
|
|
#ifdef NS_DEBUG
|
|
#define WEB_TRACE(_bit,_args) \
|
|
PR_BEGIN_MACRO \
|
|
if (WEB_LOG_TEST(gLogModule,_bit)) { \
|
|
PR_LogPrint _args; \
|
|
} \
|
|
PR_END_MACRO
|
|
#else
|
|
#define WEB_TRACE(_bit,_args)
|
|
#endif
|
|
|
|
|
|
#if OLD_EVENT_QUEUE
|
|
/* The following is not used for the GTK version of the browser.
|
|
* It is still lurking around for Motif
|
|
*/
|
|
PLEventQueue* gWebShell_UnixEventQueue;
|
|
|
|
void nsWebShell_SetUnixEventQueue(PLEventQueue* aEventQueue)
|
|
{
|
|
gWebShell_UnixEventQueue = aEventQueue;
|
|
}
|
|
#endif /* OLD_EVENT_QUEUE */
|
|
|
|
|
|
static NS_DEFINE_CID(kGlobalHistoryCID, NS_GLOBALHISTORY_CID);
|
|
#ifdef NECKO
|
|
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
|
|
#endif // NECKO
|
|
|
|
static nsAutoString LinkCommand("linkclick");
|
|
//----------------------------------------------------------------------
|
|
|
|
class nsWebShell : public nsIWebShell,
|
|
public nsIWebShellContainer,
|
|
public nsIWebShellServices,
|
|
public nsILinkHandler,
|
|
public nsIScriptContextOwner,
|
|
public nsIDocumentLoaderObserver,
|
|
#ifdef NECKO
|
|
public nsIPrompt,
|
|
public nsIRefreshURI,
|
|
#else
|
|
public nsIRefreshUrl,
|
|
public nsINetSupport,
|
|
#endif
|
|
// public nsIStreamObserver,
|
|
public nsIClipboardCommands
|
|
{
|
|
public:
|
|
nsWebShell();
|
|
virtual ~nsWebShell();
|
|
|
|
NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
|
|
|
|
// nsISupports
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsIContentViewerContainer
|
|
NS_IMETHOD QueryCapability(const nsIID &aIID, void** aResult);
|
|
NS_IMETHOD Embed(nsIContentViewer* aDocViewer,
|
|
const char* aCommand,
|
|
nsISupports* aExtraInfo);
|
|
NS_IMETHOD GetContentViewer(nsIContentViewer** aResult);
|
|
|
|
// nsIWebShell
|
|
NS_IMETHOD Init(nsNativeWidget aNativeParent,
|
|
PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h,
|
|
nsScrollPreference aScrolling = nsScrollPreference_kAuto,
|
|
PRBool aAllowPlugins = PR_TRUE,
|
|
PRBool aIsSunkenBorder = PR_FALSE);
|
|
NS_IMETHOD Destroy(void);
|
|
NS_IMETHOD GetBounds(PRInt32 &x, PRInt32 &y, PRInt32 &w, PRInt32 &h);
|
|
NS_IMETHOD SetBounds(PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h);
|
|
NS_IMETHOD MoveTo(PRInt32 aX, PRInt32 aY);
|
|
NS_IMETHOD Show();
|
|
NS_IMETHOD Hide();
|
|
NS_IMETHOD SetFocus();
|
|
NS_IMETHOD RemoveFocus();
|
|
NS_IMETHOD Repaint(PRBool aForce);
|
|
NS_IMETHOD SetContentViewer(nsIContentViewer* aViewer);
|
|
NS_IMETHOD SetContainer(nsIWebShellContainer* aContainer);
|
|
NS_IMETHOD GetContainer(nsIWebShellContainer*& aResult);
|
|
NS_IMETHOD SetObserver(nsIStreamObserver* anObserver);
|
|
NS_IMETHOD GetObserver(nsIStreamObserver*& aResult);
|
|
NS_IMETHOD SetDocLoaderObserver(nsIDocumentLoaderObserver* anObserver);
|
|
NS_IMETHOD GetDocLoaderObserver(nsIDocumentLoaderObserver*& aResult);
|
|
NS_IMETHOD SetPrefs(nsIPref* aPrefs);
|
|
NS_IMETHOD GetPrefs(nsIPref*& aPrefs);
|
|
NS_IMETHOD GetRootWebShell(nsIWebShell*& aResult);
|
|
NS_IMETHOD GetRootWebShellEvenIfChrome(nsIWebShell*& aResult);
|
|
NS_IMETHOD SetParent(nsIWebShell* aParent);
|
|
NS_IMETHOD GetParent(nsIWebShell*& aParent);
|
|
NS_IMETHOD GetParentEvenIfChrome(nsIWebShell*& aParent);
|
|
NS_IMETHOD GetChildCount(PRInt32& aResult);
|
|
NS_IMETHOD AddChild(nsIWebShell* aChild);
|
|
NS_IMETHOD RemoveChild(nsIWebShell* aChild);
|
|
NS_IMETHOD ChildAt(PRInt32 aIndex, nsIWebShell*& aResult);
|
|
NS_IMETHOD GetName(const PRUnichar** aName);
|
|
NS_IMETHOD SetName(const PRUnichar* aName);
|
|
NS_IMETHOD FindChildWithName(const PRUnichar* aName,
|
|
nsIWebShell*& aResult);
|
|
|
|
NS_IMETHOD SetWebShellType(nsWebShellType aWebShellType);
|
|
NS_IMETHOD GetWebShellType(nsWebShellType& aWebShellType);
|
|
NS_IMETHOD GetContainingChromeShell(nsIWebShell** aResult);
|
|
NS_IMETHOD SetContainingChromeShell(nsIWebShell* aChromeShell);
|
|
|
|
NS_IMETHOD GetMarginWidth (PRInt32& aWidth);
|
|
NS_IMETHOD SetMarginWidth (PRInt32 aWidth);
|
|
NS_IMETHOD GetMarginHeight(PRInt32& aWidth);
|
|
NS_IMETHOD SetMarginHeight(PRInt32 aHeight);
|
|
NS_IMETHOD GetScrolling(PRInt32& aScrolling);
|
|
NS_IMETHOD SetScrolling(PRInt32 aScrolling, PRBool aSetCurrentAndInitial = PR_TRUE);
|
|
NS_IMETHOD GetIsFrame(PRBool& aIsFrame);
|
|
NS_IMETHOD SetIsFrame(PRBool aIsFrame);
|
|
NS_IMETHOD SetZoom(float aZoom);
|
|
NS_IMETHOD GetZoom(float *aZoom);
|
|
|
|
// Document load api's
|
|
NS_IMETHOD GetDocumentLoader(nsIDocumentLoader*& aResult);
|
|
NS_IMETHOD LoadURL(const PRUnichar *aURLSpec,
|
|
nsIInputStream* aPostDataStream=nsnull,
|
|
PRBool aModifyHistory=PR_TRUE,
|
|
#ifdef NECKO
|
|
nsLoadFlags aType = nsIChannel::LOAD_NORMAL,
|
|
#else
|
|
nsURLReloadType aType = nsURLReload,
|
|
#endif
|
|
const PRUint32 localIP = 0);
|
|
NS_IMETHOD LoadURL(const PRUnichar *aURLSpec,
|
|
const char* aCommand,
|
|
nsIInputStream* aPostDataStream=nsnull,
|
|
PRBool aModifyHistory=PR_TRUE,
|
|
#ifdef NECKO
|
|
nsLoadFlags aType = nsIChannel::LOAD_NORMAL,
|
|
#else
|
|
nsURLReloadType aType = nsURLReload,
|
|
#endif
|
|
const PRUint32 localIP = 0);
|
|
|
|
NS_IMETHOD Stop(void);
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHOD Reload(nsLoadFlags aType);
|
|
#else
|
|
NS_IMETHOD Reload(nsURLReloadType aType);
|
|
#endif
|
|
|
|
// History api's
|
|
NS_IMETHOD Back(void);
|
|
NS_IMETHOD CanBack(void);
|
|
NS_IMETHOD Forward(void);
|
|
NS_IMETHOD CanForward(void);
|
|
NS_IMETHOD GoTo(PRInt32 aHistoryIndex);
|
|
NS_IMETHOD GetHistoryLength(PRInt32& aResult);
|
|
NS_IMETHOD GetHistoryIndex(PRInt32& aResult);
|
|
NS_IMETHOD GetURL(PRInt32 aHistoryIndex, const PRUnichar** aURLResult);
|
|
|
|
// Chrome api's
|
|
NS_IMETHOD SetTitle(const PRUnichar* aTitle);
|
|
NS_IMETHOD GetTitle(const PRUnichar** aResult);
|
|
|
|
// nsIWebShellContainer
|
|
NS_IMETHOD WillLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, nsLoadType aReason);
|
|
NS_IMETHOD BeginLoadURL(nsIWebShell* aShell, const PRUnichar* aURL);
|
|
NS_IMETHOD ProgressLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, PRInt32 aProgress, PRInt32 aProgressMax);
|
|
NS_IMETHOD EndLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, nsresult aStatus);
|
|
NS_IMETHOD NewWebShell(PRUint32 aChromeMask,
|
|
PRBool aVisible,
|
|
nsIWebShell *&aNewWebShell);
|
|
NS_IMETHOD ContentShellAdded(nsIWebShell* aChildShell, nsIContent* frameNode);
|
|
NS_IMETHOD CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent,
|
|
PRInt32 aXPos, PRInt32 aYPos,
|
|
const nsString& aPopupType, const nsString& anAnchorAlignment,
|
|
const nsString& aPopupAlignment,
|
|
nsIDOMWindow* aWindow, nsIDOMWindow** outPopup);
|
|
NS_IMETHOD FindWebShellWithName(const PRUnichar* aName, nsIWebShell*& aResult);
|
|
NS_IMETHOD FocusAvailable(nsIWebShell* aFocusedWebShell, PRBool& aFocusTaken);
|
|
|
|
// nsIWebShellServices
|
|
NS_IMETHOD LoadDocument(const char* aURL,
|
|
const char* aCharset= nsnull ,
|
|
nsCharsetSource aSource = kCharsetUninitialized);
|
|
NS_IMETHOD ReloadDocument(const char* aCharset= nsnull ,
|
|
nsCharsetSource aSource = kCharsetUninitialized);
|
|
NS_IMETHOD StopDocumentLoad(void);
|
|
NS_IMETHOD SetRendering(PRBool aRender);
|
|
|
|
// nsILinkHandler
|
|
NS_IMETHOD OnLinkClick(nsIContent* aContent,
|
|
nsLinkVerb aVerb,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec,
|
|
nsIInputStream* aPostDataStream = 0);
|
|
NS_IMETHOD OnOverLink(nsIContent* aContent,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec);
|
|
NS_IMETHOD GetLinkState(const PRUnichar* aURLSpec, nsLinkState& aState);
|
|
|
|
// nsIScriptContextOwner
|
|
NS_IMETHOD GetScriptContext(nsIScriptContext **aContext);
|
|
NS_IMETHOD GetScriptGlobalObject(nsIScriptGlobalObject **aGlobal);
|
|
NS_IMETHOD ReleaseScriptContext(nsIScriptContext *aContext);
|
|
|
|
#ifdef NECKO
|
|
// nsIDocumentLoaderObserver
|
|
NS_IMETHOD OnStartDocumentLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL,
|
|
const char* aCommand);
|
|
NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader,
|
|
nsIChannel* channel,
|
|
nsresult aStatus,
|
|
nsIDocumentLoaderObserver * );
|
|
NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader,
|
|
nsIChannel* channel,
|
|
nsIContentViewer* aViewer);
|
|
NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader,
|
|
nsIChannel* channel, PRUint32 aProgress,
|
|
PRUint32 aProgressMax);
|
|
NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader,
|
|
nsIChannel* channel, nsString& aMsg);
|
|
NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader,
|
|
nsIChannel* channel, nsresult aStatus);
|
|
NS_IMETHOD HandleUnknownContentType(nsIDocumentLoader* loader,
|
|
nsIChannel* channel,
|
|
const char *aContentType,
|
|
const char *aCommand );
|
|
#else
|
|
// nsIDocumentLoaderObserver
|
|
NS_IMETHOD OnStartDocumentLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL,
|
|
const char* aCommand);
|
|
NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL,
|
|
PRInt32 aStatus,
|
|
nsIDocumentLoaderObserver * );
|
|
NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL, const char* aContentType,
|
|
nsIContentViewer* aViewer);
|
|
NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL, PRUint32 aProgress,
|
|
PRUint32 aProgressMax);
|
|
NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL, nsString& aMsg);
|
|
NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL, PRInt32 aStatus);
|
|
NS_IMETHOD HandleUnknownContentType(nsIDocumentLoader* loader,
|
|
nsIURI* aURL,
|
|
const char *aContentType,
|
|
const char *aCommand );
|
|
#endif
|
|
// NS_IMETHOD OnConnectionsComplete();
|
|
|
|
|
|
NS_IMETHOD RefreshURL(const char* aURL, PRInt32 millis, PRBool repeat);
|
|
|
|
// nsIRefreshURL interface methods...
|
|
#ifndef NECKO
|
|
NS_IMETHOD RefreshURL(nsIURI* aURL, PRInt32 aMillis, PRBool aRepeat);
|
|
NS_IMETHOD CancelRefreshURLTimers(void);
|
|
#else
|
|
NS_IMETHOD RefreshURI(nsIURI* aURI, PRInt32 aMillis, PRBool aRepeat);
|
|
NS_IMETHOD CancelRefreshURITimers(void);
|
|
#endif // NECKO
|
|
|
|
#if 0
|
|
// nsIStreamObserver
|
|
NS_IMETHOD OnStartRequest(nsIURI* aURL, const char *aContentType);
|
|
NS_IMETHOD OnProgress(nsIURI* aURL, PRUint32 aProgress, PRUint32 aProgressMax);
|
|
NS_IMETHOD OnStatus(nsIURI* aURL, const PRUnichar* aMsg);
|
|
NS_IMETHOD OnStopRequest(nsIURI* aURL, nsresult aStatus, const PRUnichar* aMsg);
|
|
#endif /* 0 */
|
|
|
|
#ifdef NECKO
|
|
// nsIPrompt
|
|
NS_DECL_NSIPROMPT
|
|
#else
|
|
// nsINetSupport interface methods
|
|
NS_IMETHOD_(void) Alert(const nsString &aText);
|
|
NS_IMETHOD_(PRBool) Confirm(const nsString &aText);
|
|
NS_IMETHOD_(PRBool) ConfirmYN(const nsString &aText);
|
|
NS_IMETHOD_(PRBool) Prompt(const nsString &aText,
|
|
const nsString &aDefault,
|
|
nsString &aResult);
|
|
NS_IMETHOD_(PRBool) PromptUserAndPassword(const nsString &aText,
|
|
nsString &aUser,
|
|
nsString &aPassword);
|
|
NS_IMETHOD_(PRBool) PromptPassword(const nsString &aText,
|
|
nsString &aPassword);
|
|
#endif
|
|
|
|
// nsIClipboardCommands
|
|
NS_IMETHOD CanCutSelection (PRBool* aResult);
|
|
NS_IMETHOD CanCopySelection (PRBool* aResult);
|
|
NS_IMETHOD CanPasteSelection(PRBool* aResult);
|
|
|
|
NS_IMETHOD CutSelection (void);
|
|
NS_IMETHOD CopySelection (void);
|
|
NS_IMETHOD PasteSelection(void);
|
|
|
|
NS_IMETHOD SelectAll(void);
|
|
NS_IMETHOD SelectNone(void);
|
|
|
|
NS_IMETHOD FindNext(const PRUnichar * aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound);
|
|
|
|
// nsWebShell
|
|
nsIEventQueue* GetEventQueue(void);
|
|
void HandleLinkClickEvent(nsIContent *aContent,
|
|
nsLinkVerb aVerb,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec,
|
|
nsIInputStream* aPostDataStream = 0);
|
|
|
|
void ShowHistory();
|
|
|
|
nsIWebShell* GetTarget(const PRUnichar* aName);
|
|
nsIBrowserWindow* GetBrowserWindow(void);
|
|
|
|
static void RefreshURLCallback(nsITimer* aTimer, void* aClosure);
|
|
|
|
static nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent);
|
|
|
|
nsresult CreatePluginHost(PRBool aAllowPlugins);
|
|
nsresult DestroyPluginHost(void);
|
|
|
|
NS_IMETHOD IsBusy(PRBool& aResult);
|
|
NS_IMETHOD GetDefaultCharacterSet (const PRUnichar** aDefaultCharacterSet);
|
|
NS_IMETHOD SetDefaultCharacterSet (const PRUnichar* aDefaultCharacterSet);
|
|
|
|
NS_IMETHOD GetForceCharacterSet (const PRUnichar** aForceCharacterSet);
|
|
NS_IMETHOD SetForceCharacterSet (const PRUnichar* aForceCharacterSet);
|
|
|
|
NS_IMETHOD GetCharacterSetHint (const PRUnichar** oHintCharset, nsCharsetSource* oSource);
|
|
|
|
NS_IMETHOD SetSessionHistory(nsISessionHistory * aSHist);
|
|
NS_IMETHOD GetSessionHistory(nsISessionHistory *& aResult);
|
|
NS_IMETHOD SetIsInSHist(PRBool aIsFrame);
|
|
NS_IMETHOD GetIsInSHist(PRBool& aIsFrame);
|
|
NS_IMETHOD GetURL(const PRUnichar** aURL);
|
|
NS_IMETHOD SetURL(const PRUnichar* aURL);
|
|
NS_IMETHOD SetUrlDispatcher(nsIUrlDispatcher * anObserver);
|
|
NS_IMETHOD GetUrlDispatcher(nsIUrlDispatcher *& aResult);
|
|
|
|
|
|
protected:
|
|
void InitFrameData(PRBool aCompleteInitScrolling);
|
|
nsresult CheckForTrailingSlash(nsIURI* aURL);
|
|
nsresult StopBeforeRequestingURL(void);
|
|
nsresult StopAfterURLAvailable(void);
|
|
|
|
nsIEventQueue* mThreadEventQueue;
|
|
nsIScriptGlobalObject *mScriptGlobal;
|
|
nsIScriptContext* mScriptContext;
|
|
|
|
nsIStreamObserver * mObserver;
|
|
nsIWebShellContainer* mContainer;
|
|
nsIContentViewer* mContentViewer;
|
|
nsIDeviceContext* mDeviceContext;
|
|
nsIPref* mPrefs;
|
|
nsIWidget* mWindow;
|
|
nsIDocumentLoader* mDocLoader;
|
|
nsIDocumentLoaderObserver* mDocLoaderObserver;
|
|
nsIUrlDispatcher * mUrlDispatcher;
|
|
#ifdef NECKO
|
|
nsIPrompt* mPrompter;
|
|
#else
|
|
nsINetSupport* mNetSupport;
|
|
#endif
|
|
|
|
nsIWebShell* mParent;
|
|
nsVoidArray mChildren;
|
|
nsString mName;
|
|
nsString mDefaultCharacterSet;
|
|
|
|
|
|
nsVoidArray mHistory;
|
|
PRInt32 mHistoryIndex;
|
|
|
|
|
|
nsIGlobalHistory* mHistoryService;
|
|
nsISessionHistory * mSHist;
|
|
|
|
nsString mTitle;
|
|
nsString mURL;
|
|
|
|
nsString mOverURL;
|
|
nsString mOverTarget;
|
|
|
|
PRPackedBool mIsInSHist;
|
|
PRPackedBool mIsFrame;
|
|
PRPackedBool mFailedToLoadHistoryService;
|
|
|
|
nsScrollPreference mScrollPref;
|
|
PRInt32 mMarginWidth;
|
|
PRInt32 mMarginHeight;
|
|
PRInt32 mScrolling[2];
|
|
nsVoidArray mRefreshments;
|
|
|
|
nsWebShellType mWebShellType;
|
|
nsIWebShell* mChromeShell; // Weak reference.
|
|
|
|
void ReleaseChildren();
|
|
void DestroyChildren();
|
|
nsresult CreateScriptEnvironment();
|
|
nsresult DoLoadURL(const nsString& aUrlSpec,
|
|
const char* aCommand,
|
|
nsIInputStream* aPostDataStream,
|
|
#ifdef NECKO
|
|
nsLoadFlags aType,
|
|
#else
|
|
nsURLReloadType aType,
|
|
#endif
|
|
const PRUint32 aLocalIP);
|
|
|
|
float mZoom;
|
|
|
|
static nsIPluginHost *mPluginHost;
|
|
static nsIPluginManager *mPluginManager;
|
|
static PRUint32 mPluginInitCnt;
|
|
PRBool mProcessedEndDocumentLoad;
|
|
|
|
// XXX store mHintCharset and mHintCharsetSource here untill we find out a good cood path
|
|
nsString mHintCharset;
|
|
nsCharsetSource mHintCharsetSource;
|
|
nsString mForceCharacterSet;
|
|
|
|
// if there is no mWindow, this will keep track of the bounds --dwc0001
|
|
nsRect mBounds;
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Class IID's
|
|
static NS_DEFINE_IID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
|
|
static NS_DEFINE_IID(kChildCID, NS_CHILD_CID);
|
|
static NS_DEFINE_IID(kDeviceContextCID, NS_DEVICE_CONTEXT_CID);
|
|
static NS_DEFINE_IID(kDocLoaderServiceCID, NS_DOCUMENTLOADER_SERVICE_CID);
|
|
static NS_DEFINE_IID(kWebShellCID, NS_WEB_SHELL_CID);
|
|
|
|
|
|
// IID's
|
|
static NS_DEFINE_IID(kIContentViewerContainerIID,
|
|
NS_ICONTENT_VIEWER_CONTAINER_IID);
|
|
static NS_DEFINE_IID(kIDocumentLoaderObserverIID,
|
|
NS_IDOCUMENT_LOADER_OBSERVER_IID);
|
|
static NS_DEFINE_IID(kIDeviceContextIID, NS_IDEVICE_CONTEXT_IID);
|
|
static NS_DEFINE_IID(kIDocumentLoaderIID, NS_IDOCUMENTLOADER_IID);
|
|
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
|
|
static NS_DEFINE_IID(kIScriptContextOwnerIID, NS_ISCRIPTCONTEXTOWNER_IID);
|
|
static NS_DEFINE_IID(kIStreamObserverIID, NS_ISTREAMOBSERVER_IID);
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
#ifndef NECKO
|
|
static NS_DEFINE_IID(kINetSupportIID, NS_INETSUPPORT_IID);
|
|
static NS_DEFINE_IID(kRefreshURLIID, NS_IREFRESHURL_IID);
|
|
#else
|
|
static NS_DEFINE_IID(kRefreshURIIID, NS_IREFRESHURI_IID);
|
|
#endif
|
|
|
|
static NS_DEFINE_IID(kIWebShellIID, NS_IWEB_SHELL_IID);
|
|
static NS_DEFINE_IID(kIWebShellServicesIID, NS_IWEB_SHELL_SERVICES_IID);
|
|
static NS_DEFINE_IID(kIWidgetIID, NS_IWIDGET_IID);
|
|
static NS_DEFINE_IID(kIPluginManagerIID, NS_IPLUGINMANAGER_IID);
|
|
static NS_DEFINE_IID(kIPluginHostIID, NS_IPLUGINHOST_IID);
|
|
//static NS_DEFINE_IID(kCPluginHostCID, NS_PLUGIN_HOST_CID);
|
|
static NS_DEFINE_IID(kCPluginManagerCID, NS_PLUGINMANAGER_CID);
|
|
static NS_DEFINE_IID(kIDocumentViewerIID, NS_IDOCUMENT_VIEWER_IID);
|
|
static NS_DEFINE_IID(kITimerCallbackIID, NS_ITIMERCALLBACK_IID);
|
|
static NS_DEFINE_IID(kIWebShellContainerIID, NS_IWEB_SHELL_CONTAINER_IID);
|
|
static NS_DEFINE_IID(kIBrowserWindowIID, NS_IBROWSER_WINDOW_IID);
|
|
static NS_DEFINE_IID(kIClipboardCommandsIID, NS_ICLIPBOARDCOMMANDS_IID);
|
|
static NS_DEFINE_IID(kIEventQueueServiceIID, NS_IEVENTQUEUESERVICE_IID);
|
|
static NS_DEFINE_IID(kISessionHistoryIID, NS_ISESSION_HISTORY_IID);
|
|
|
|
// XXX not sure
|
|
static NS_DEFINE_IID(kILinkHandlerIID, NS_ILINKHANDLER_IID);
|
|
|
|
nsIPluginHost *nsWebShell::mPluginHost = nsnull;
|
|
nsIPluginManager *nsWebShell::mPluginManager = nsnull;
|
|
PRUint32 nsWebShell::mPluginInitCnt = 0;
|
|
|
|
nsresult nsWebShell::CreatePluginHost(PRBool aAllowPlugins)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if ((PR_TRUE == aAllowPlugins) && (0 == mPluginInitCnt))
|
|
{
|
|
if (nsnull == mPluginManager)
|
|
{
|
|
// use the service manager to obtain the plugin manager.
|
|
rv = nsServiceManager::GetService(kCPluginManagerCID, kIPluginManagerIID,
|
|
(nsISupports**)&mPluginManager);
|
|
if (NS_OK == rv)
|
|
{
|
|
if (NS_OK == mPluginManager->QueryInterface(kIPluginHostIID,
|
|
(void **)&mPluginHost))
|
|
{
|
|
mPluginHost->Init();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mPluginInitCnt++;
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsWebShell::DestroyPluginHost(void)
|
|
{
|
|
mPluginInitCnt--;
|
|
|
|
NS_ASSERTION(!(mPluginInitCnt < 0), "underflow in plugin host destruction");
|
|
|
|
if (0 == mPluginInitCnt)
|
|
{
|
|
if (nsnull != mPluginHost) {
|
|
mPluginHost->Destroy();
|
|
mPluginHost->Release();
|
|
mPluginHost = NULL;
|
|
}
|
|
|
|
// use the service manager to release the plugin manager.
|
|
if (nsnull != mPluginManager) {
|
|
nsServiceManager::ReleaseService(kCPluginManagerCID, mPluginManager);
|
|
mPluginManager = NULL;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Note: operator new zeros our memory
|
|
nsWebShell::nsWebShell()
|
|
{
|
|
NS_INIT_REFCNT();
|
|
mHistoryIndex = -1;
|
|
mScrollPref = nsScrollPreference_kAuto;
|
|
mScriptGlobal = nsnull;
|
|
mScriptContext = nsnull;
|
|
mThreadEventQueue = nsnull;
|
|
InitFrameData(PR_TRUE);
|
|
mIsFrame = PR_FALSE;
|
|
mWebShellType = nsWebShellContent;
|
|
mChromeShell = nsnull;
|
|
mSHist = nsnull;
|
|
mIsInSHist = PR_FALSE;
|
|
mFailedToLoadHistoryService = PR_FALSE;
|
|
mDefaultCharacterSet = "";
|
|
mProcessedEndDocumentLoad = PR_FALSE;
|
|
mHintCharset = "";
|
|
mHintCharsetSource = kCharsetUninitialized;
|
|
mForceCharacterSet = "";
|
|
mHistoryService = nsnull;
|
|
#ifdef NECKO
|
|
mPrompter = nsnull;
|
|
#else
|
|
mNetSupport = nsnull;
|
|
#endif
|
|
}
|
|
|
|
nsWebShell::~nsWebShell()
|
|
{
|
|
if (nsnull != mHistoryService) {
|
|
nsServiceManager::ReleaseService(kGlobalHistoryCID, mHistoryService);
|
|
mHistoryService = nsnull;
|
|
}
|
|
|
|
// Stop any pending document loads and destroy the loader...
|
|
if (nsnull != mDocLoader) {
|
|
mDocLoader->Stop();
|
|
mDocLoader->RemoveObserver((nsIDocumentLoaderObserver*)this);
|
|
mDocLoader->SetContainer(nsnull);
|
|
NS_RELEASE(mDocLoader);
|
|
}
|
|
// Cancel any timers that were set for this loader.
|
|
#ifndef NECKO
|
|
CancelRefreshURLTimers();
|
|
#else
|
|
CancelRefreshURITimers();
|
|
#endif // NECKO
|
|
|
|
++mRefCnt; // following releases can cause this destructor to be called
|
|
// recursively if the refcount is allowed to remain 0
|
|
|
|
NS_IF_RELEASE(mWindow);
|
|
NS_IF_RELEASE(mThreadEventQueue);
|
|
NS_IF_RELEASE(mContentViewer);
|
|
NS_IF_RELEASE(mDeviceContext);
|
|
NS_IF_RELEASE(mPrefs);
|
|
NS_IF_RELEASE(mContainer);
|
|
NS_IF_RELEASE(mObserver);
|
|
#ifdef NECKO
|
|
NS_IF_RELEASE(mPrompter);
|
|
#else
|
|
NS_IF_RELEASE(mNetSupport);
|
|
#endif
|
|
|
|
if (nsnull != mScriptGlobal) {
|
|
mScriptGlobal->SetWebShell(nsnull);
|
|
NS_RELEASE(mScriptGlobal);
|
|
}
|
|
NS_IF_RELEASE(mScriptContext);
|
|
|
|
InitFrameData(PR_TRUE);
|
|
mIsFrame = PR_FALSE;
|
|
|
|
// XXX Because we hold references to the children and they hold references
|
|
// to us we never get destroyed. See Destroy() instead...
|
|
#if 0
|
|
// Release references on our children
|
|
ReleaseChildren();
|
|
#endif
|
|
|
|
|
|
// Free up history memory
|
|
PRInt32 i, n = mHistory.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsString* s = (nsString*) mHistory.ElementAt(i);
|
|
delete s;
|
|
}
|
|
|
|
|
|
DestroyPluginHost();
|
|
}
|
|
|
|
void nsWebShell::InitFrameData(PRBool aCompleteInitScrolling)
|
|
{
|
|
if (aCompleteInitScrolling) {
|
|
mScrolling[0] = -1;
|
|
mScrolling[1] = -1;
|
|
mMarginWidth = -1;
|
|
mMarginHeight = -1;
|
|
}
|
|
else {
|
|
mScrolling[1] = mScrolling[0];
|
|
}
|
|
}
|
|
|
|
void
|
|
nsWebShell::ReleaseChildren()
|
|
{
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsIWebShell* shell = (nsIWebShell*) mChildren.ElementAt(i);
|
|
shell->SetParent(nsnull);
|
|
|
|
//Break circular reference of webshell to contentviewer
|
|
shell->SetContentViewer(nsnull);
|
|
NS_RELEASE(shell);
|
|
}
|
|
mChildren.Clear();
|
|
}
|
|
|
|
void
|
|
nsWebShell::DestroyChildren()
|
|
{
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsIWebShell* shell = (nsIWebShell*) mChildren.ElementAt(i);
|
|
shell->SetParent(nsnull);
|
|
shell->Destroy();
|
|
NS_RELEASE(shell);
|
|
}
|
|
mChildren.Clear();
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP_(nsrefcnt) nsWebShell::AddRef(void)
|
|
{
|
|
NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");
|
|
++mRefCnt;
|
|
return mRefCnt;
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsrefcnt) nsWebShell::Release(void)
|
|
{
|
|
NS_PRECONDITION(0 != mRefCnt, "dup release");
|
|
--mRefCnt;
|
|
if (mRefCnt == 0) {
|
|
NS_DELETEXPCOM(this);
|
|
return 0;
|
|
}
|
|
return mRefCnt;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShell::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
{
|
|
nsresult rv = NS_NOINTERFACE;
|
|
|
|
if (NULL == aInstancePtr) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
if (aIID.Equals(kIWebShellServicesIID)) {
|
|
*aInstancePtr = (void*)(nsIWebShellServices*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIWebShellIID)) {
|
|
*aInstancePtr = (void*)(nsIWebShell*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIContentViewerContainerIID)) {
|
|
*aInstancePtr = (void*)(nsIContentViewerContainer*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIScriptContextOwnerIID)) {
|
|
*aInstancePtr = (void*)(nsIScriptContextOwner*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIDocumentLoaderObserverIID)) {
|
|
*aInstancePtr = (void*)(nsIDocumentLoaderObserver*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIWebShellContainerIID)) {
|
|
*aInstancePtr = (void*)(nsIWebShellContainer*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kILinkHandlerIID)) {
|
|
//I added this for plugin support of jumping
|
|
//through links. maybe there is a better way... MMP
|
|
*aInstancePtr = (void*)(nsILinkHandler*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
#ifdef NECKO
|
|
if (aIID.Equals(nsIPrompt::GetIID())) {
|
|
*aInstancePtr = (void*) ((nsIPrompt*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kRefreshURIIID)) {
|
|
*aInstancePtr = (void*) ((nsIRefreshURI*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
#else
|
|
if (aIID.Equals(kINetSupportIID)) {
|
|
*aInstancePtr = (void*) ((nsINetSupport*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kRefreshURLIID)) {
|
|
*aInstancePtr = (void*)((nsIRefreshUrl*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
#endif // NECKO
|
|
if (aIID.Equals(kIClipboardCommandsIID)) {
|
|
*aInstancePtr = (void*) ((nsIClipboardCommands*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kISupportsIID)) {
|
|
*aInstancePtr = (void*)(nsISupports*)(nsIWebShell*)this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
|
|
#if defined(NS_DEBUG)
|
|
/*
|
|
* Check for the debug-only interface indicating thread-safety
|
|
*/
|
|
static NS_DEFINE_IID(kIsThreadsafeIID, NS_ISTHREADSAFE_IID);
|
|
if (aIID.Equals(kIsThreadsafeIID)) {
|
|
return NS_OK;
|
|
}
|
|
#endif /* NS_DEBUG */
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::QueryCapability(const nsIID &aIID, void** aInstancePtr)
|
|
{
|
|
if (nsnull == aInstancePtr) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
if (aIID.Equals(kILinkHandlerIID)) {
|
|
*aInstancePtr = (void*) ((nsILinkHandler*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIScriptContextOwnerIID)) {
|
|
*aInstancePtr = (void*) ((nsIScriptContextOwner*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
|
|
//XXX this seems a little wrong. MMP
|
|
if (nsnull != mPluginManager)
|
|
return mPluginManager->QueryInterface(aIID, aInstancePtr);
|
|
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Embed(nsIContentViewer* aContentViewer,
|
|
const char* aCommand,
|
|
nsISupports* aExtraInfo)
|
|
{
|
|
nsresult rv;
|
|
nsRect bounds;
|
|
|
|
WEB_TRACE(WEB_TRACE_CALLS,
|
|
("nsWebShell::Embed: this=%p aDocViewer=%p aCommand=%s aExtraInfo=%p",
|
|
this, aContentViewer, aCommand ? aCommand : "", aExtraInfo));
|
|
|
|
NS_IF_RELEASE(mContentViewer);
|
|
if (nsnull != mScriptContext) {
|
|
mScriptContext->GC();
|
|
}
|
|
mContentViewer = aContentViewer;
|
|
NS_ADDREF(aContentViewer);
|
|
|
|
// check to see if we have a window to embed into --dwc0001
|
|
if(mWindow) {
|
|
mWindow->GetClientBounds(bounds);
|
|
bounds.x = bounds.y = 0;
|
|
rv = mContentViewer->Init(mWindow->GetNativeData(NS_NATIVE_WIDGET),
|
|
mDeviceContext,
|
|
mPrefs,
|
|
bounds,
|
|
mScrollPref);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
mContentViewer->Show();
|
|
}
|
|
} else {
|
|
mContentViewer = nsnull;
|
|
}
|
|
|
|
// Now that we have switched documents, forget all of our children
|
|
DestroyChildren();
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetContentViewer(nsIContentViewer** aResult)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull == aResult) {
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
} else {
|
|
*aResult = mContentViewer;
|
|
NS_IF_ADDREF(mContentViewer);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::HandleUnknownContentType(nsIDocumentLoader* loader,
|
|
#ifdef NECKO
|
|
nsIChannel* channel,
|
|
#else
|
|
nsIURI* aURL,
|
|
#endif
|
|
const char *aContentType,
|
|
const char *aCommand ) {
|
|
// If we have a doc loader observer, let it respond to this.
|
|
#ifdef NECKO
|
|
return mDocLoaderObserver ? mDocLoaderObserver->HandleUnknownContentType( mDocLoader, channel, aContentType, aCommand )
|
|
#else
|
|
return mDocLoaderObserver ? mDocLoaderObserver->HandleUnknownContentType( mDocLoader, aURL, aContentType, aCommand )
|
|
#endif
|
|
: NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Init(nsNativeWidget aNativeParent,
|
|
PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h,
|
|
nsScrollPreference aScrolling,
|
|
PRBool aAllowPlugins,
|
|
PRBool aIsSunkenBorder)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
// Cache the PL_EventQueue of the current UI thread...
|
|
//
|
|
// Since this call must be made on the UI thread, we know the Event Queue
|
|
// will be associated with the current thread...
|
|
//
|
|
nsIEventQueueService* eventService;
|
|
rv = nsServiceManager::GetService(kEventQueueServiceCID,
|
|
kIEventQueueServiceIID,
|
|
(nsISupports **)&eventService);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// XXX: What if this fails?
|
|
rv = eventService->GetThreadEventQueue(PR_GetCurrentThread(),
|
|
&mThreadEventQueue);
|
|
nsServiceManager::ReleaseService(kEventQueueServiceCID, eventService);
|
|
}
|
|
|
|
|
|
//XXX make sure plugins have started up. this really needs to
|
|
//be associated with the nsIContentViewerContainer interfaces,
|
|
//not the nsIWebShell interfaces. this is a hack. MMP
|
|
nsRect aBounds(x,y,w,h);
|
|
mBounds.SetRect(x,y,w,h); // initialize the webshells bounds --dwc0001
|
|
nsWidgetInitData widgetInit;
|
|
|
|
CreatePluginHost(aAllowPlugins);
|
|
|
|
//mScrollPref = aScrolling;
|
|
|
|
WEB_TRACE(WEB_TRACE_CALLS,
|
|
("nsWebShell::Init: this=%p", this));
|
|
|
|
/* it is ok to have a webshell without an aNativeParent (used later to create the mWindow --dwc0001
|
|
// Initial error checking...
|
|
NS_PRECONDITION(nsnull != aNativeParent, "null Parent Window");
|
|
if (nsnull == aNativeParent) {
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
goto done;
|
|
}
|
|
*/
|
|
// Create a document loader...
|
|
if (nsnull != mParent) {
|
|
nsIDocumentLoader* parentLoader;
|
|
|
|
// Create a child document loader...
|
|
rv = mParent->GetDocumentLoader(parentLoader);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = parentLoader->CreateDocumentLoader(&mDocLoader);
|
|
NS_RELEASE(parentLoader);
|
|
}
|
|
} else {
|
|
nsIDocumentLoader* docLoaderService;
|
|
|
|
// Get the global document loader service...
|
|
rv = nsServiceManager::GetService(kDocLoaderServiceCID,
|
|
kIDocumentLoaderIID,
|
|
(nsISupports **)&docLoaderService);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = docLoaderService->CreateDocumentLoader(&mDocLoader);
|
|
nsServiceManager::ReleaseService(kDocLoaderServiceCID, docLoaderService);
|
|
}
|
|
}
|
|
if (NS_FAILED(rv)) {
|
|
goto done;
|
|
}
|
|
|
|
// Set the webshell as the default IContentViewerContainer for the loader...
|
|
mDocLoader->SetContainer(this);
|
|
|
|
//Register ourselves as an observer for the new doc loader
|
|
mDocLoader->AddObserver((nsIDocumentLoaderObserver*)this);
|
|
|
|
|
|
/* this is the old code, commented out for the new code below while I figure this out -- dwc0001
|
|
// Create device context
|
|
rv = nsComponentManager::CreateInstance(kDeviceContextCID, nsnull,
|
|
kIDeviceContextIID,
|
|
(void **)&mDeviceContext);
|
|
if (NS_FAILED(rv)) {
|
|
goto done;
|
|
}
|
|
mDeviceContext->Init(aNativeParent);
|
|
float dev2twip;
|
|
mDeviceContext->GetDevUnitsToTwips(dev2twip);
|
|
mDeviceContext->SetDevUnitsToAppUnits(dev2twip);
|
|
float twip2dev;
|
|
mDeviceContext->GetTwipsToDevUnits(twip2dev);
|
|
mDeviceContext->SetAppUnitsToDevUnits(twip2dev);
|
|
// mDeviceContext->SetGamma(1.7f);
|
|
mDeviceContext->SetGamma(1.0f);
|
|
|
|
// Create a Native window for the shell container...
|
|
rv = nsComponentManager::CreateInstance(kChildCID, nsnull, kIWidgetIID, (void**)&mWindow);
|
|
if (NS_FAILED(rv)) {
|
|
goto done;
|
|
}
|
|
|
|
widgetInit.clipChildren = PR_FALSE;
|
|
widgetInit.mWindowType = eWindowType_child;
|
|
//widgetInit.mBorderStyle = aIsSunkenBorder ? eBorderStyle_3DChildWindow : eBorderStyle_none;
|
|
mWindow->Create(aNativeParent, aBounds, nsWebShell::HandleEvent,
|
|
mDeviceContext, nsnull, nsnull, &widgetInit);
|
|
*/
|
|
|
|
// Create device context
|
|
if (nsnull != aNativeParent) {
|
|
rv = nsComponentManager::CreateInstance(kDeviceContextCID, nsnull,
|
|
kIDeviceContextIID,
|
|
(void **)&mDeviceContext);
|
|
if (NS_FAILED(rv)) {
|
|
goto done;
|
|
}
|
|
mDeviceContext->Init(aNativeParent);
|
|
float dev2twip;
|
|
mDeviceContext->GetDevUnitsToTwips(dev2twip);
|
|
mDeviceContext->SetDevUnitsToAppUnits(dev2twip);
|
|
float twip2dev;
|
|
mDeviceContext->GetTwipsToDevUnits(twip2dev);
|
|
mDeviceContext->SetAppUnitsToDevUnits(twip2dev);
|
|
// mDeviceContext->SetGamma(1.7f);
|
|
mDeviceContext->SetGamma(1.0f);
|
|
|
|
// Create a Native window for the shell container...
|
|
rv = nsComponentManager::CreateInstance(kChildCID, nsnull, kIWidgetIID, (void**)&mWindow);
|
|
if (NS_FAILED(rv)) {
|
|
goto done;
|
|
}
|
|
|
|
widgetInit.clipChildren = PR_FALSE;
|
|
widgetInit.mWindowType = eWindowType_child;
|
|
//widgetInit.mBorderStyle = aIsSunkenBorder ? eBorderStyle_3DChildWindow : eBorderStyle_none;
|
|
mWindow->Create(aNativeParent, aBounds, nsWebShell::HandleEvent,
|
|
mDeviceContext, nsnull, nsnull, &widgetInit);
|
|
} else {
|
|
// we need a deviceContext
|
|
|
|
rv = nsComponentManager::CreateInstance(kDeviceContextCID, nsnull,kIDeviceContextIID,(void **)&mDeviceContext);
|
|
if (NS_FAILED(rv)) {
|
|
goto done;
|
|
}
|
|
mDeviceContext->Init(aNativeParent);
|
|
float dev2twip;
|
|
mDeviceContext->GetDevUnitsToTwips(dev2twip);
|
|
mDeviceContext->SetDevUnitsToAppUnits(dev2twip);
|
|
float twip2dev;
|
|
mDeviceContext->GetTwipsToDevUnits(twip2dev);
|
|
mDeviceContext->SetAppUnitsToDevUnits(twip2dev);
|
|
mDeviceContext->SetGamma(1.0f);
|
|
|
|
widgetInit.clipChildren = PR_FALSE;
|
|
widgetInit.mWindowType = eWindowType_child;
|
|
}
|
|
|
|
done:
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::IsBusy(PRBool& aResult)
|
|
{
|
|
|
|
if (mDocLoader!=nsnull) {
|
|
mDocLoader->IsBusy(aResult);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Destroy()
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
//Fire unload event before we blow anything away.
|
|
if (nsnull != mScriptGlobal) {
|
|
nsIDocumentViewer* docViewer;
|
|
if (nsnull != mContentViewer &&
|
|
NS_OK == mContentViewer->QueryInterface(kIDocumentViewerIID, (void**)&docViewer)) {
|
|
nsIPresContext *presContext;
|
|
if (NS_OK == docViewer->GetPresContext(presContext)) {
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
nsMouseEvent event;
|
|
event.eventStructType = NS_EVENT;
|
|
event.message = NS_PAGE_UNLOAD;
|
|
rv = mScriptGlobal->HandleDOMEvent(*presContext, &event, nsnull, NS_EVENT_FLAG_INIT, status);
|
|
|
|
NS_RELEASE(presContext);
|
|
}
|
|
NS_RELEASE(docViewer);
|
|
}
|
|
}
|
|
|
|
// Stop any URLs that are currently being loaded...
|
|
Stop();
|
|
|
|
SetContainer(nsnull);
|
|
SetObserver(nsnull);
|
|
SetDocLoaderObserver(nsnull);
|
|
|
|
// Remove this webshell from its parent's child list
|
|
if (nsnull != mParent) {
|
|
mParent->RemoveChild(this);
|
|
}
|
|
|
|
if (nsnull != mDocLoader) {
|
|
mDocLoader->SetContainer(nsnull);
|
|
}
|
|
|
|
NS_IF_RELEASE(mContentViewer);
|
|
|
|
// Destroy our child web shells and release references to them
|
|
DestroyChildren();
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetBounds(PRInt32 &x, PRInt32 &y, PRInt32 &w, PRInt32 &h)
|
|
{
|
|
nsRect aResult;
|
|
|
|
/* old code path --dwc001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
aResult.SetRect(0, 0, 0, 0);
|
|
if (nsnull != mWindow) {
|
|
mWindow->GetClientBounds(aResult);
|
|
}
|
|
*/
|
|
|
|
if (nsnull != mWindow) {
|
|
mWindow->GetClientBounds(aResult);
|
|
} else {
|
|
aResult = mBounds;
|
|
}
|
|
|
|
x = aResult.x;
|
|
y = aResult.y;
|
|
w = aResult.width;
|
|
h = aResult.height;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetBounds(PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h)
|
|
{
|
|
/*
|
|
--dwc0001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
*/
|
|
|
|
PRInt32 borderWidth = 0;
|
|
PRInt32 borderHeight = 0;
|
|
if (nsnull != mWindow) {
|
|
mWindow->GetBorderSize(borderWidth, borderHeight);
|
|
// Don't have the widget repaint. Layout will generate repaint requests
|
|
// during reflow
|
|
mWindow->Resize(x, y, w, h, PR_FALSE);
|
|
}
|
|
|
|
mBounds.SetRect(x,y,w,h); // set the webshells bounds --dwc0001
|
|
|
|
// Set the size of the content area, which is the size of the window
|
|
// minus the borders
|
|
if (nsnull != mContentViewer) {
|
|
nsRect rr(0, 0, w-(borderWidth*2), h-(borderHeight*2));
|
|
mContentViewer->SetBounds(rr);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::MoveTo(PRInt32 aX, PRInt32 aY)
|
|
{
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
|
|
if (nsnull != mWindow) {
|
|
mWindow->Move(aX, aY);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Show()
|
|
{
|
|
/*
|
|
--dwc001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
*/
|
|
|
|
if (nsnull != mWindow) {
|
|
mWindow->Show(PR_TRUE);
|
|
}
|
|
if (nsnull != mContentViewer) {
|
|
mContentViewer->Show();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Hide()
|
|
{
|
|
/*
|
|
--dwc0001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
*/
|
|
|
|
if (nsnull != mWindow) {
|
|
mWindow->Show(PR_FALSE);
|
|
}
|
|
if (nsnull != mContentViewer) {
|
|
mContentViewer->Hide();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetFocus()
|
|
{
|
|
/*
|
|
--dwc0001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
*/
|
|
|
|
if (nsnull != mWindow) {
|
|
mWindow->SetFocus();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::RemoveFocus()
|
|
{
|
|
/*
|
|
--dwc0001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
*/
|
|
|
|
if (nsnull != mWindow) {
|
|
nsIWidget *parentWidget = mWindow->GetParent();
|
|
if (nsnull != parentWidget) {
|
|
parentWidget->SetFocus();
|
|
NS_RELEASE(parentWidget);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Repaint(PRBool aForce)
|
|
{
|
|
/*
|
|
--dwc0001
|
|
NS_PRECONDITION(nsnull != mWindow, "null window");
|
|
*/
|
|
|
|
if (nsnull != mWindow) {
|
|
mWindow->Invalidate(aForce);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetContentViewer(nsIContentViewer* aViewer)
|
|
{
|
|
NS_IF_RELEASE(mContentViewer);
|
|
mContentViewer = aViewer;
|
|
NS_IF_ADDREF(aViewer);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetContainer(nsIWebShellContainer* aContainer)
|
|
{
|
|
NS_IF_RELEASE(mContainer);
|
|
mContainer = aContainer;
|
|
NS_IF_ADDREF(aContainer);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetContainer(nsIWebShellContainer*& aResult)
|
|
{
|
|
aResult = mContainer;
|
|
NS_IF_ADDREF(mContainer);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetSessionHistory(nsISessionHistory* aSHist)
|
|
{
|
|
NS_IF_RELEASE(mSHist);
|
|
mSHist = aSHist;
|
|
NS_IF_ADDREF(aSHist);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetSessionHistory(nsISessionHistory *& aResult)
|
|
{
|
|
aResult = mSHist;
|
|
NS_IF_ADDREF(mSHist);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsEventStatus PR_CALLBACK
|
|
nsWebShell::HandleEvent(nsGUIEvent *aEvent)
|
|
{
|
|
return nsEventStatus_eIgnore;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetObserver(nsIStreamObserver* anObserver)
|
|
{
|
|
NS_IF_RELEASE(mObserver);
|
|
#ifdef NECKO
|
|
NS_IF_RELEASE(mPrompter);
|
|
#else
|
|
NS_IF_RELEASE(mNetSupport);
|
|
#endif
|
|
|
|
mObserver = anObserver;
|
|
if (nsnull != mObserver) {
|
|
#ifdef NECKO
|
|
mObserver->QueryInterface(nsIPrompt::GetIID(), (void**)&mPrompter);
|
|
#else
|
|
mObserver->QueryInterface(kINetSupportIID, (void **) &mNetSupport);
|
|
#endif
|
|
NS_ADDREF(mObserver);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetObserver(nsIStreamObserver*& aResult)
|
|
{
|
|
aResult = mObserver;
|
|
NS_IF_ADDREF(mObserver);
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetDocLoaderObserver(nsIDocumentLoaderObserver* anObserver)
|
|
{
|
|
// if (anObserver != nsnull) {
|
|
NS_IF_RELEASE(mDocLoaderObserver);
|
|
|
|
mDocLoaderObserver = anObserver;
|
|
NS_IF_ADDREF(mDocLoaderObserver);
|
|
// }
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetDocLoaderObserver(nsIDocumentLoaderObserver*& aResult)
|
|
{
|
|
aResult = mDocLoaderObserver;
|
|
NS_IF_ADDREF(mDocLoaderObserver);
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetUrlDispatcher(nsIUrlDispatcher* aDispatcher)
|
|
{
|
|
NS_IF_RELEASE(mUrlDispatcher);
|
|
|
|
mUrlDispatcher = aDispatcher;
|
|
NS_IF_ADDREF(mUrlDispatcher);
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetUrlDispatcher(nsIUrlDispatcher*& aResult)
|
|
{
|
|
aResult = mUrlDispatcher;
|
|
NS_IF_ADDREF(mUrlDispatcher);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetPrefs(nsIPref* aPrefs)
|
|
{
|
|
NS_IF_RELEASE(mPrefs);
|
|
mPrefs = aPrefs;
|
|
NS_IF_ADDREF(mPrefs);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetPrefs(nsIPref*& aPrefs)
|
|
{
|
|
aPrefs = mPrefs;
|
|
NS_IF_ADDREF(aPrefs);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetRootWebShell(nsIWebShell*& aResult)
|
|
{
|
|
nsIWebShell* top = this;
|
|
NS_ADDREF(this);
|
|
for (;;) {
|
|
nsIWebShell* parent;
|
|
top->GetParent(parent);
|
|
if (nsnull == parent) {
|
|
break;
|
|
}
|
|
NS_RELEASE(top);
|
|
top = parent;
|
|
}
|
|
aResult = top;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetRootWebShellEvenIfChrome(nsIWebShell*& aResult)
|
|
{
|
|
nsIWebShell* top = this;
|
|
NS_ADDREF(this);
|
|
for (;;) {
|
|
nsIWebShell* parent;
|
|
top->GetParentEvenIfChrome(parent);
|
|
if (nsnull == parent) {
|
|
break;
|
|
}
|
|
NS_RELEASE(top);
|
|
top = parent;
|
|
}
|
|
aResult = top;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetParent(nsIWebShell* aParent)
|
|
{
|
|
NS_IF_RELEASE(mParent);
|
|
mParent = aParent;
|
|
NS_IF_ADDREF(aParent);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetParent(nsIWebShell*& aParent)
|
|
{
|
|
if (mWebShellType == nsWebShellContent)
|
|
{
|
|
// We cannot return our parent if it is a chrome webshell.
|
|
nsWebShellType parentType;
|
|
if (mParent)
|
|
{
|
|
mParent->GetWebShellType(parentType);
|
|
if (parentType == nsWebShellChrome)
|
|
{
|
|
aParent = nsnull; // Just return null.
|
|
return NS_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
aParent = mParent;
|
|
NS_IF_ADDREF(mParent);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetParentEvenIfChrome(nsIWebShell*& aParent)
|
|
{
|
|
aParent = mParent;
|
|
NS_IF_ADDREF(mParent);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetChildCount(PRInt32& aResult)
|
|
{
|
|
aResult = mChildren.Count();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::AddChild(nsIWebShell* aChild)
|
|
{
|
|
NS_PRECONDITION(nsnull != aChild, "null ptr");
|
|
if (nsnull == aChild) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
mChildren.AppendElement(aChild);
|
|
aChild->SetParent(this);
|
|
const PRUnichar *defaultCharset=nsnull;
|
|
if(NS_SUCCEEDED(this->GetDefaultCharacterSet (&defaultCharset)))
|
|
aChild->SetDefaultCharacterSet(defaultCharset);
|
|
aChild->SetForceCharacterSet(mForceCharacterSet.GetUnicode());
|
|
NS_ADDREF(aChild);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::RemoveChild(nsIWebShell* aChild)
|
|
{
|
|
NS_PRECONDITION(nsnull != aChild, "nsWebShell::RemoveChild(): null ptr");
|
|
if (nsnull == aChild) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
mChildren.RemoveElement(aChild);
|
|
aChild->SetParent(nsnull);
|
|
NS_RELEASE(aChild);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::ChildAt(PRInt32 aIndex, nsIWebShell*& aResult)
|
|
{
|
|
if (PRUint32(aIndex) >= PRUint32(mChildren.Count())) {
|
|
aResult = nsnull;
|
|
}
|
|
else {
|
|
aResult = (nsIWebShell*) mChildren.ElementAt(aIndex);
|
|
NS_IF_ADDREF(aResult);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetName(const PRUnichar** aName)
|
|
{
|
|
*aName = mName.GetUnicode();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetName(const PRUnichar* aName)
|
|
{
|
|
mName = aName;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetURL(const PRUnichar** aURL)
|
|
{
|
|
*aURL = mURL.GetUnicode();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetURL(const PRUnichar* aURL)
|
|
{
|
|
mURL = aURL;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetIsInSHist(PRBool& aResult)
|
|
{
|
|
aResult = mIsInSHist;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetIsInSHist(PRBool aIsInSHist)
|
|
{
|
|
mIsInSHist = aIsInSHist;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::FindChildWithName(const PRUnichar* aName1,
|
|
nsIWebShell*& aResult)
|
|
{
|
|
aResult = nsnull;
|
|
nsString aName(aName1);
|
|
|
|
const PRUnichar *childName;
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsIWebShell* child = (nsIWebShell*) mChildren.ElementAt(i);
|
|
if (nsnull != child) {
|
|
child->GetName(&childName);
|
|
if (aName.Equals(childName)) {
|
|
aResult = child;
|
|
NS_ADDREF(child);
|
|
break;
|
|
}
|
|
|
|
// See if child contains the shell with the given name
|
|
nsresult rv = child->FindChildWithName(aName.GetUnicode(), aResult);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
if (nsnull != aResult) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetWebShellType(nsWebShellType& aWebShellType)
|
|
{
|
|
aWebShellType = mWebShellType;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetWebShellType(nsWebShellType aWebShellType)
|
|
{
|
|
if (aWebShellType != nsWebShellChrome &&
|
|
aWebShellType != nsWebShellContent)
|
|
{
|
|
NS_ERROR("Attempt to set bogus webshell type: values should be content or chrome.");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
mWebShellType = aWebShellType;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetContainingChromeShell(nsIWebShell** aResult)
|
|
{
|
|
NS_IF_ADDREF(mChromeShell);
|
|
*aResult = mChromeShell;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetContainingChromeShell(nsIWebShell* aChromeShell)
|
|
{
|
|
// Weak reference. Don't addref.
|
|
mChromeShell = aChromeShell;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetMarginWidth(PRInt32& aWidth)
|
|
{
|
|
aWidth = mMarginWidth;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetMarginWidth(PRInt32 aWidth)
|
|
{
|
|
mMarginWidth = aWidth;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetMarginHeight(PRInt32& aHeight)
|
|
{
|
|
aHeight = mMarginHeight;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetMarginHeight(PRInt32 aHeight)
|
|
{
|
|
mMarginHeight = aHeight;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetScrolling(PRInt32& aScrolling)
|
|
{
|
|
aScrolling = mScrolling[1];
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetScrolling(PRInt32 aScrolling, PRBool aSetCurrentAndInitial)
|
|
{
|
|
mScrolling[1] = aScrolling;
|
|
if (aSetCurrentAndInitial) {
|
|
mScrolling[0] = aScrolling;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetIsFrame(PRBool& aIsFrame)
|
|
{
|
|
aIsFrame = mIsFrame;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetIsFrame(PRBool aIsFrame)
|
|
{
|
|
mIsFrame = aIsFrame;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetZoom(float aZoom)
|
|
{
|
|
mZoom = aZoom;
|
|
|
|
if (mDeviceContext)
|
|
mDeviceContext->SetZoom(mZoom);
|
|
|
|
if (mContentViewer) {
|
|
nsIDocumentViewer* docv = nsnull;
|
|
mContentViewer->QueryInterface(kIDocumentViewerIID, (void**) &docv);
|
|
if (nsnull != docv) {
|
|
nsIPresContext* cx = nsnull;
|
|
docv->GetPresContext(cx);
|
|
if (nsnull != cx) {
|
|
nsIPresShell *shell = nsnull;
|
|
cx->GetShell(&shell);
|
|
if (nsnull != shell) {
|
|
nsIViewManager *vm = nsnull;
|
|
shell->GetViewManager(&vm);
|
|
if (nsnull != vm) {
|
|
nsIView *rootview = nsnull;
|
|
nsIScrollableView *sv = nsnull;
|
|
vm->GetRootScrollableView(&sv);
|
|
if (nsnull != sv)
|
|
sv->ComputeScrollOffsets();
|
|
vm->GetRootView(rootview);
|
|
if (nsnull != rootview)
|
|
vm->UpdateView(rootview, nsnull, 0);
|
|
NS_RELEASE(vm);
|
|
}
|
|
NS_RELEASE(shell);
|
|
}
|
|
NS_RELEASE(cx);
|
|
}
|
|
NS_RELEASE(docv);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetZoom(float *aZoom)
|
|
{
|
|
*aZoom = mZoom;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Document Load methods
|
|
*/
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetDocumentLoader(nsIDocumentLoader*& aResult)
|
|
{
|
|
aResult = mDocLoader;
|
|
NS_IF_ADDREF(mDocLoader);
|
|
return (nsnull != mDocLoader) ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
#define FILE_PROTOCOL "file:///"
|
|
|
|
static void convertFileToURL(const nsString &aIn, nsString &aOut)
|
|
{
|
|
#ifdef XP_PC
|
|
char szFile[1000];
|
|
aIn.ToCString(szFile, sizeof(szFile));
|
|
if (PL_strchr(szFile, '\\')) {
|
|
PRInt32 len = strlen(szFile);
|
|
PRInt32 sum = len + sizeof(FILE_PROTOCOL);
|
|
char* lpszFileURL = (char *)PR_Malloc(sum + 1);
|
|
|
|
// Translate '\' to '/'
|
|
for (PRInt32 i = 0; i < len; i++) {
|
|
if (szFile[i] == '\\') {
|
|
szFile[i] = '/';
|
|
}
|
|
if (szFile[i] == ':') {
|
|
szFile[i] = '|';
|
|
}
|
|
}
|
|
|
|
// Build the file URL
|
|
PR_snprintf(lpszFileURL, sum, "%s%s", FILE_PROTOCOL, szFile);
|
|
aOut = lpszFileURL;
|
|
PR_Free((void *)lpszFileURL);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
aOut = aIn;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::LoadURL(const PRUnichar *aURLSpec,
|
|
nsIInputStream* aPostDataStream,
|
|
PRBool aModifyHistory,
|
|
#ifdef NECKO
|
|
nsLoadFlags aType,
|
|
#else
|
|
nsURLReloadType aType,
|
|
#endif
|
|
const PRUint32 aLocalIP)
|
|
{
|
|
// Initialize margnwidth, marginheight. Put scrolling back the way it was
|
|
// before the last document was loaded.
|
|
InitFrameData(PR_FALSE);
|
|
|
|
return LoadURL(aURLSpec, "view", aPostDataStream,
|
|
aModifyHistory,aType, aLocalIP);
|
|
}
|
|
|
|
// Nisheeth: returns true if the host and the file parts of
|
|
// the two nsIURI's match.
|
|
static PRBool EqualBaseURLs(nsIURI* url1, nsIURI* url2)
|
|
{
|
|
nsXPIDLCString host1;
|
|
nsXPIDLCString host2;
|
|
nsXPIDLCString file1;
|
|
nsXPIDLCString file2;
|
|
char * anchor1 = nsnull, * anchor2=nsnull;
|
|
PRBool rv = PR_FALSE;
|
|
|
|
if (url1 && url2) {
|
|
// XXX We need to make these strcmps case insensitive.
|
|
#ifdef NECKO
|
|
url1->GetHost(getter_Copies(host1));
|
|
url2->GetHost(getter_Copies(host2));
|
|
#else
|
|
url1->GetHost(getter_Shares(host1));
|
|
url2->GetHost(getter_Shares(host2));
|
|
#endif
|
|
if (0 == PL_strcmp(host1, host2)) {
|
|
#ifdef NECKO
|
|
url1->GetPath(getter_Copies(file1));
|
|
url2->GetPath(getter_Copies(file2));
|
|
#else
|
|
url1->GetFile(getter_Shares(file1));
|
|
url2->GetFile(getter_Shares(file2));
|
|
#endif
|
|
|
|
anchor1 = PL_strrchr(file1, '#');
|
|
if (anchor1) {
|
|
char * tmp = PL_strstr(file1, file2);
|
|
if (tmp && (const char *)tmp == file1) {
|
|
return PR_TRUE;
|
|
}
|
|
}
|
|
anchor2 = PL_strrchr(file2, '#');
|
|
if (anchor2) {
|
|
char * tmp = PL_strstr(file2, file1);
|
|
if (tmp && (const char *)tmp == file2) {
|
|
return PR_TRUE;
|
|
}
|
|
}
|
|
|
|
if (0 == PL_strcmp(file1, file2)) {
|
|
rv = PR_TRUE;
|
|
}
|
|
} // strcmp(host1, host2)
|
|
} // url1 && url2
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShell::DoLoadURL(const nsString& aUrlSpec,
|
|
const char* aCommand,
|
|
nsIInputStream* aPostDataStream,
|
|
#ifdef NECKO
|
|
nsLoadFlags aType,
|
|
#else
|
|
nsURLReloadType aType,
|
|
#endif
|
|
const PRUint32 aLocalIP)
|
|
|
|
|
|
{
|
|
// Ugh. It sucks that we have to hack webshell like this. Forgive me, Father.
|
|
do {
|
|
nsresult rv;
|
|
NS_WITH_SERVICE(nsIGlobalHistory, history, "component://netscape/browser/global-history", &rv);
|
|
if (NS_FAILED(rv)) break;
|
|
|
|
rv = history->AddPage(nsCAutoString(aUrlSpec), nsnull /* referrer */, PR_Now());
|
|
if (NS_FAILED(rv)) break;
|
|
} while (0);
|
|
|
|
|
|
// If it's a normal reload that uses the cache, look at the destination anchor
|
|
// and see if it's an element within the current document
|
|
#ifdef NECKO
|
|
// We don't have a reload loadtype yet in necko. So, check for just history
|
|
// loadtype
|
|
if ((aType == LOAD_HISTORY || aType == nsIChannel::LOAD_NORMAL) && (nsnull != mContentViewer) &&
|
|
(nsnull == aPostDataStream))
|
|
#else
|
|
if ((aType == nsURLReload || aType == nsURLReloadFromHistory) &&
|
|
(nsnull != mContentViewer) && (nsnull == aPostDataStream))
|
|
#endif
|
|
{
|
|
nsCOMPtr<nsIDocumentViewer> docViewer;
|
|
nsresult rv;
|
|
if (NS_SUCCEEDED(mContentViewer->QueryInterface(kIDocumentViewerIID,
|
|
getter_AddRefs(docViewer)))) {
|
|
// Get the document object
|
|
nsCOMPtr<nsIDocument> doc;
|
|
docViewer->GetDocument(*getter_AddRefs(doc));
|
|
|
|
// Get the URL for the document
|
|
nsCOMPtr<nsIURI> docURL = nsDontAddRef<nsIURI>(doc->GetDocumentURL());
|
|
|
|
// See if they're the same
|
|
nsCOMPtr<nsIURI> url;
|
|
#ifndef NECKO
|
|
rv = NS_NewURL(getter_AddRefs(url), aUrlSpec);
|
|
#else
|
|
rv = NS_NewURI(getter_AddRefs(url), aUrlSpec);
|
|
#ifdef DEBUG
|
|
char* urlStr = aUrlSpec.ToNewCString();
|
|
if (rv == NS_ERROR_UNKNOWN_PROTOCOL)
|
|
printf("Error: Unknown protocol: %s\n", urlStr);
|
|
else if (rv == NS_ERROR_UNKNOWN_HOST)
|
|
printf("Error: Unknown host: %s\n", urlStr);
|
|
else if (rv == NS_ERROR_MALFORMED_URI)
|
|
printf("Error: Malformed URI: %s\n", urlStr);
|
|
else if (NS_FAILED(rv))
|
|
printf("Error: Can't load: %s (%x)\n", urlStr, rv);
|
|
nsCRT::free(urlStr);
|
|
#endif
|
|
#endif // NECKO
|
|
if (NS_FAILED(rv)) return rv;
|
|
if (url && docURL && EqualBaseURLs(docURL, url)) {
|
|
// See if there's a destination anchor
|
|
#ifdef NECKO
|
|
char* ref = nsnull;
|
|
nsCOMPtr<nsIURL> url2 = do_QueryInterface(url);
|
|
if (url2) {
|
|
rv = url2->GetRef(&ref);
|
|
}
|
|
#else
|
|
const char* ref;
|
|
url->GetRef(&ref);
|
|
#endif
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
rv = docViewer->GetPresShell(*getter_AddRefs(presShell));
|
|
|
|
if (NS_SUCCEEDED(rv) && presShell) {
|
|
if (nsnull != ref) {
|
|
// Go to the anchor in the current document
|
|
rv = presShell->GoToAnchor(nsAutoString(ref));
|
|
|
|
// Pass notifications to BrowserAppCore just to be consistent with
|
|
// regular page loads thro' necko
|
|
nsCOMPtr<nsIChannel> dummyChannel;
|
|
rv = NS_OpenURI(getter_AddRefs(dummyChannel), url, nsnull);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
mProcessedEndDocumentLoad = PR_FALSE;
|
|
rv = OnEndDocumentLoad(mDocLoader, dummyChannel, 0, this);
|
|
|
|
return rv;
|
|
}
|
|
#ifdef NECKO
|
|
else if (aType == LOAD_HISTORY)
|
|
#else
|
|
else if (aType == nsURLReloadFromHistory)
|
|
#endif
|
|
{
|
|
// Go to the top of the current document
|
|
nsCOMPtr<nsIViewManager> viewMgr;
|
|
rv = presShell->GetViewManager(getter_AddRefs(viewMgr));
|
|
if (NS_SUCCEEDED(rv) && viewMgr) {
|
|
|
|
|
|
nsIScrollableView* view;
|
|
rv = viewMgr->GetRootScrollableView(&view);
|
|
if (NS_SUCCEEDED(rv) && view)
|
|
rv = view->ScrollTo(0, 0, NS_VMREFRESH_IMMEDIATE);
|
|
|
|
// Pass notifications to BrowserAppCore just to be consistent with
|
|
// regular necko loads.
|
|
nsCOMPtr<nsIChannel> dummyChannel;
|
|
rv = NS_OpenURI(getter_AddRefs(dummyChannel), url, nsnull);
|
|
if (NS_FAILED(rv)) return rv;
|
|
mProcessedEndDocumentLoad = PR_FALSE;
|
|
|
|
rv = OnEndDocumentLoad(mDocLoader, dummyChannel, 0, this);
|
|
|
|
|
|
|
|
}
|
|
return rv;
|
|
}
|
|
}
|
|
} // EqualBaseURLs(docURL, url)
|
|
}
|
|
}
|
|
|
|
// Stop loading the current document (if any...). This call may result in
|
|
// firing an EndLoadURL notification for the old document...
|
|
StopBeforeRequestingURL();
|
|
|
|
|
|
// Tell web-shell-container we are loading a new url
|
|
if (nsnull != mContainer) {
|
|
nsresult rv = mContainer->BeginLoadURL(this, aUrlSpec.GetUnicode());
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
mProcessedEndDocumentLoad = PR_FALSE;
|
|
|
|
/* WebShell was primarily passing the buck when it came to streamObserver.
|
|
* So, pass on the observer which is already a streamObserver to DocLoder.
|
|
* - Radha
|
|
*/
|
|
|
|
return mDocLoader->LoadDocument(aUrlSpec, // URL string
|
|
aCommand, // Command
|
|
this, // Container
|
|
aPostDataStream, // Post Data
|
|
nsnull, // Extra Info...
|
|
mObserver, // Observer
|
|
aType, // reload type
|
|
aLocalIP); // load attributes.
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::LoadURL(const PRUnichar *aURLSpec,
|
|
const char* aCommand,
|
|
nsIInputStream* aPostDataStream,
|
|
PRBool aModifyHistory,
|
|
#ifdef NECKO
|
|
nsLoadFlags aType,
|
|
#else
|
|
nsURLReloadType aType,
|
|
#endif
|
|
const PRUint32 aLocalIP)
|
|
{
|
|
nsresult rv;
|
|
|
|
nsString2 urlStr = aURLSpec;
|
|
|
|
#ifdef NECKO
|
|
CancelRefreshURITimers();
|
|
#endif // NECKO
|
|
|
|
// first things first. try to create a uri out of the string.
|
|
nsIURI *uri = nsnull;
|
|
rv = NS_NewURI(&uri, urlStr, nsnull);
|
|
if (NS_FAILED(rv)) {
|
|
// no dice.
|
|
nsAutoString urlSpec;
|
|
urlStr.Trim(" ", PR_TRUE, PR_TRUE);
|
|
|
|
// see if we've got a file url.
|
|
convertFileToURL(urlStr, urlSpec);
|
|
rv = NS_NewURI(&uri, urlSpec, nsnull);
|
|
if (NS_FAILED(rv)) {
|
|
// no dice, try more tricks
|
|
|
|
PRInt32 colon, fSlash = urlSpec.FindChar('/');
|
|
PRUnichar port;
|
|
// if no scheme (protocol) is found, assume http.
|
|
if ( ((colon=urlSpec.FindChar(':')) == -1) // no colon at all
|
|
|| ( (fSlash > -1) && (colon > fSlash) ) // the only colon comes after the first slash
|
|
|| ( (colon < urlSpec.Length()-1) // the first char after the first colon is a digit (i.e. a port)
|
|
&& ((port=urlSpec.CharAt(colon+1)) <= '9')
|
|
&& (port > '0') )) {
|
|
// find host name
|
|
PRInt32 hostPos = urlSpec.FindCharInSet("./:");
|
|
if (hostPos == -1) {
|
|
hostPos = urlSpec.Length();
|
|
}
|
|
|
|
// extract host name
|
|
nsAutoString hostSpec;
|
|
urlSpec.Left(hostSpec, hostPos);
|
|
|
|
// insert url spec corresponding to host name
|
|
if (hostSpec.EqualsIgnoreCase("ftp")) {
|
|
urlSpec.Insert("ftp://", 0, 6);
|
|
} else {
|
|
urlSpec.Insert("http://", 0, 7);
|
|
}
|
|
} // end if colon
|
|
rv = NS_NewURI(&uri, urlSpec, nsnull);
|
|
if (NS_FAILED(rv)) {
|
|
// no dice, even more tricks?
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
char *scheme = nsnull, *CUriSpec = nsnull;
|
|
|
|
rv = uri->GetScheme(&scheme);
|
|
if (NS_FAILED(rv)) return rv;
|
|
rv = uri->GetSpec(&CUriSpec);
|
|
NS_RELEASE(uri);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
nsAutoString uriSpec(CUriSpec);
|
|
nsAllocator::Free(CUriSpec);
|
|
|
|
mURL = uriSpec;
|
|
|
|
|
|
//Take care of mailto: url
|
|
PRBool isMail= PR_FALSE, isBrowser = PR_FALSE;
|
|
|
|
nsAutoString mailTo("mailto");
|
|
if (mailTo.Equals(scheme, PR_TRUE)) {
|
|
isMail = PR_TRUE;
|
|
}
|
|
nsAllocator::Free(scheme);
|
|
|
|
nsIWebShell * root= nsnull;
|
|
rv = GetRootWebShell(root);
|
|
if (NS_SUCCEEDED(rv) && root) {
|
|
nsIDocumentLoaderObserver * dlObserver = nsnull;
|
|
|
|
rv = root->GetDocLoaderObserver(dlObserver);
|
|
if (NS_SUCCEEDED(rv) && dlObserver) {
|
|
isBrowser = PR_TRUE;
|
|
NS_RELEASE(dlObserver);
|
|
}
|
|
}
|
|
|
|
/* Ask the URL dispatcher to take car of this URL only if it is a
|
|
* mailto: link clicked inside a browser or any link clicked
|
|
* inside a *non-browser* window. Note this mechanism s'd go away once
|
|
* we have the protocol registry and window manager available
|
|
*/
|
|
if (isMail) {
|
|
//Ask the container to load the appropriate component for the URL.
|
|
|
|
if (root) {
|
|
nsCOMPtr<nsIUrlDispatcher> urlDispatcher = nsnull;
|
|
rv = GetUrlDispatcher(*getter_AddRefs(urlDispatcher));
|
|
if (NS_SUCCEEDED(rv) && urlDispatcher) {
|
|
printf("calling HandleUrl\n");
|
|
urlDispatcher->HandleUrl(LinkCommand.GetUnicode(),
|
|
mURL.GetUnicode(), aPostDataStream);
|
|
return NS_OK;
|
|
}
|
|
NS_RELEASE(root);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* If this is one of the frames, get it from the top level shell */
|
|
|
|
if (aModifyHistory) {
|
|
nsCOMPtr<nsIWebShell> webShell;
|
|
rv = GetRootWebShell(*getter_AddRefs(webShell));
|
|
if (NS_SUCCEEDED(rv) && webShell)
|
|
{
|
|
nsCOMPtr<nsISessionHistory> shist;
|
|
webShell->GetSessionHistory(*getter_AddRefs(shist));
|
|
/* Add yourself to the Session History */
|
|
if (shist) {
|
|
PRInt32 ret=0;
|
|
ret = shist->add(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsString* url = new nsString(uriSpec);
|
|
if (aModifyHistory) {
|
|
// Discard part of history that is no longer reachable
|
|
PRInt32 i, n = mHistory.Count();
|
|
i = mHistoryIndex + 1;
|
|
while (--n >= i) {
|
|
nsString* u = (nsString*) mHistory.ElementAt(n);
|
|
delete u;
|
|
mHistory.RemoveElementAt(n);
|
|
}
|
|
|
|
// Tack on new url
|
|
mHistory.AppendElement(url);
|
|
mHistoryIndex++;
|
|
}
|
|
else {
|
|
// Replace the current history index with this URL
|
|
nsString* u = (nsString*) mHistory.ElementAt(mHistoryIndex);
|
|
if (nsnull != u) {
|
|
delete u;
|
|
}
|
|
mHistory.ReplaceElementAt(url, mHistoryIndex);
|
|
}
|
|
ShowHistory();
|
|
|
|
|
|
/* The session History may have changed the URL. So pass on the
|
|
* right one for loading
|
|
*/
|
|
// Give web-shell-container right of refusal
|
|
if (nsnull != mContainer) {
|
|
rv = mContainer->WillLoadURL(this, mURL.GetUnicode(), nsLoadURL);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
|
|
return DoLoadURL(uriSpec, aCommand, aPostDataStream, aType, aLocalIP);
|
|
//#endif
|
|
}
|
|
|
|
NS_IMETHODIMP nsWebShell::Stop(void)
|
|
{
|
|
if (nsnull != mContentViewer) {
|
|
mContentViewer->Stop();
|
|
}
|
|
|
|
// Cancel any timers that were set for this loader.
|
|
#ifndef NECKO
|
|
CancelRefreshURLTimers();
|
|
#else
|
|
CancelRefreshURITimers();
|
|
#endif // NECKO
|
|
|
|
if (mDocLoader) {
|
|
// Stop any documents that are currently being loaded...
|
|
mDocLoader->Stop();
|
|
}
|
|
|
|
// Stop the documents being loaded by children too...
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsIWebShell* shell = (nsIWebShell*) mChildren.ElementAt(i);
|
|
shell->Stop();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// This "stops" the current document load enough so that the document loader
|
|
// can be used to load a new URL.
|
|
nsresult
|
|
nsWebShell::StopBeforeRequestingURL()
|
|
{
|
|
if (mDocLoader) {
|
|
// Stop any documents that are currently being loaded...
|
|
mDocLoader->Stop();
|
|
}
|
|
|
|
// Recurse down the webshell hierarchy.
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsWebShell* shell = (nsWebShell*) mChildren.ElementAt(i);
|
|
shell->StopBeforeRequestingURL();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// This "stops" the current document load completely and is called once
|
|
// it has been determined that the new URL is valid and ready to be thrown
|
|
// at us from netlib.
|
|
nsresult
|
|
nsWebShell::StopAfterURLAvailable()
|
|
{
|
|
if (nsnull != mContentViewer) {
|
|
mContentViewer->Stop();
|
|
}
|
|
|
|
// Cancel any timers that were set for this loader.
|
|
#ifndef NECKO
|
|
CancelRefreshURLTimers();
|
|
#else
|
|
CancelRefreshURITimers();
|
|
#endif // NECKO
|
|
|
|
// Recurse down the webshell hierarchy.
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsWebShell* shell = (nsWebShell*) mChildren.ElementAt(i);
|
|
shell->StopAfterURLAvailable();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
|
|
/* The generic session History code here is now obsolete.
|
|
* Use nsISessionHistory instead
|
|
*/
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP nsWebShell::Reload(nsLoadFlags aType)
|
|
#else
|
|
NS_IMETHODIMP nsWebShell::Reload(nsURLReloadType aType)
|
|
#endif
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
nsString* s = (nsString*) mHistory.ElementAt(mHistoryIndex);
|
|
if (nsnull != s) {
|
|
// XXX What about the post data?
|
|
return LoadURL(s->GetUnicode(), nsnull, PR_FALSE, aType);
|
|
}
|
|
return NS_ERROR_FAILURE;
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->Reload(this, aType);
|
|
return NS_OK;
|
|
#endif
|
|
}
|
|
|
|
//----------------------------------------
|
|
|
|
// History methods
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Back(void)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
return GoTo(mHistoryIndex - 1);
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->GoBack(this);
|
|
return NS_OK;
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CanBack(void)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
return (mHistoryIndex > mHistory.Count() - 1 ? NS_OK : NS_COMFALSE);
|
|
#else
|
|
if (mSHist) {
|
|
PRBool result=PR_TRUE;
|
|
mSHist->canBack(result);
|
|
return (result ? NS_OK : NS_COMFALSE);
|
|
}
|
|
return NS_OK;
|
|
#endif
|
|
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::Forward(void)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
return GoTo(mHistoryIndex + 1);
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->GoForward(this);
|
|
return NS_OK;
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CanForward(void)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
return (mHistoryIndex < mHistory.Count() - 1 ? NS_OK : NS_COMFALSE);
|
|
#else
|
|
if (mSHist) {
|
|
PRBool result=PR_TRUE;
|
|
mSHist->canForward(result);
|
|
return (result ? NS_OK : NS_COMFALSE);
|
|
}
|
|
return NS_OK;
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GoTo(PRInt32 aHistoryIndex)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
nsresult rv = NS_ERROR_ILLEGAL_VALUE;
|
|
if ((aHistoryIndex >= 0) &&
|
|
(aHistoryIndex < mHistory.Count())) {
|
|
nsString* s = (nsString*) mHistory.ElementAt(aHistoryIndex);
|
|
|
|
// Give web-shell-container right of refusal
|
|
nsAutoString urlSpec(*s);
|
|
if (nsnull != mContainer) {
|
|
rv = mContainer->WillLoadURL(this, urlSpec.GetUnicode(), nsLoadHistory);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
printf("Goto %d\n", aHistoryIndex);
|
|
mHistoryIndex = aHistoryIndex;
|
|
ShowHistory();
|
|
|
|
rv = DoLoadURL(urlSpec, // URL string
|
|
"view", // Command
|
|
nsnull, // Post Data
|
|
#ifdef NECKO
|
|
nsIChannel::LOAD_NORMAL, // the reload type
|
|
#else
|
|
nsURLReload, // the reload type
|
|
#endif
|
|
0); // load attributes
|
|
}
|
|
return rv;
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->Goto(aHistoryIndex, this, PR_FALSE);
|
|
return NS_OK;
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetHistoryLength(PRInt32& aResult)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
aResult = mHistory.Count();
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->getHistoryLength(aResult);
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetHistoryIndex(PRInt32& aResult)
|
|
{
|
|
#ifdef OLD_HISTORY
|
|
aResult = mHistoryIndex;
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->getCurrentIndex(aResult);
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetURL(PRInt32 aHistoryIndex, const PRUnichar** aURLResult)
|
|
{
|
|
nsresult rv = NS_ERROR_ILLEGAL_VALUE;
|
|
#ifdef OLD_HISTORY
|
|
if ((aHistoryIndex >= 0) &&
|
|
(aHistoryIndex <= mHistory.Count() - 1)) {
|
|
nsString* s = (nsString*) mHistory.ElementAt(aHistoryIndex);
|
|
if (nsnull != s) {
|
|
*aURLResult = s->GetUnicode();
|
|
}
|
|
rv = NS_OK;
|
|
}
|
|
#else
|
|
if (mSHist)
|
|
return mSHist->GetURLForIndex(aHistoryIndex, aURLResult);
|
|
|
|
#endif
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsWebShell::ShowHistory()
|
|
{
|
|
#if defined(OLD_HISTORY) && defined(NS_DEBUG)
|
|
if (WEB_LOG_TEST(gLogModule, WEB_TRACE_HISTORY)) {
|
|
PRInt32 i, n = mHistory.Count();
|
|
for (i = 0; i < n; i++) {
|
|
if (i == mHistoryIndex) {
|
|
printf("**");
|
|
}
|
|
else {
|
|
printf(" ");
|
|
}
|
|
nsString* u = (nsString*) mHistory.ElementAt(i);
|
|
fputs(*u, stdout);
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//----------------------------------------
|
|
|
|
// Chrome API's
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetTitle(const PRUnichar* aTitle)
|
|
{
|
|
// Record local title
|
|
mTitle = aTitle;
|
|
|
|
// Title's set on the top level web-shell are passed ont to the container
|
|
nsIWebShell* parent;
|
|
GetParent(parent);
|
|
if (nsnull == parent) {
|
|
nsIBrowserWindow *browserWindow = GetBrowserWindow();
|
|
if (nsnull != browserWindow) {
|
|
browserWindow->SetTitle(aTitle);
|
|
NS_RELEASE(browserWindow);
|
|
|
|
// Oh this hack sucks. But there isn't any other way that I can
|
|
// reliably get the title text. Sorry.
|
|
do {
|
|
nsresult rv;
|
|
NS_WITH_SERVICE(nsIGlobalHistory, history, "component://netscape/browser/global-history", &rv);
|
|
if (NS_FAILED(rv)) break;
|
|
|
|
rv = history->SetPageTitle(nsCAutoString(mURL), aTitle);
|
|
if (NS_FAILED(rv)) break;
|
|
} while (0);
|
|
}
|
|
} else {
|
|
NS_RELEASE(parent);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetTitle(const PRUnichar** aResult)
|
|
{
|
|
*aResult = mTitle.GetUnicode();
|
|
return NS_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// WebShell container implementation
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::WillLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, nsLoadType aReason)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
if (nsnull != mContainer) {
|
|
rv = mContainer->WillLoadURL(aShell, aURL, aReason);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::BeginLoadURL(nsIWebShell* aShell, const PRUnichar* aURL)
|
|
{
|
|
if (nsnull != mContainer) {
|
|
// XXX: do not propagate this notification up from any frames...
|
|
return mContainer->BeginLoadURL(aShell, aURL);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::ProgressLoadURL(nsIWebShell* aShell,
|
|
const PRUnichar* aURL,
|
|
PRInt32 aProgress,
|
|
PRInt32 aProgressMax)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
if (nsnull != mContainer) {
|
|
rv = mContainer->ProgressLoadURL(aShell, aURL, aProgress, aProgressMax);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::EndLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, nsresult aStatus)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
if (nsnull != mContainer) {
|
|
// XXX: do not propagate this notification up from any frames...
|
|
return mContainer->EndLoadURL(aShell, aURL, aStatus);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::NewWebShell(PRUint32 aChromeMask,
|
|
PRBool aVisible,
|
|
nsIWebShell *&aNewWebShell)
|
|
{
|
|
if (nsnull != mContainer) {
|
|
return mContainer->NewWebShell(aChromeMask, aVisible, aNewWebShell);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::ContentShellAdded(nsIWebShell* aChildShell, nsIContent* frameNode)
|
|
{
|
|
if (nsnull != mContainer) {
|
|
return mContainer->ContentShellAdded(aChildShell, frameNode);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent,
|
|
PRInt32 aXPos, PRInt32 aYPos,
|
|
const nsString& aPopupType, const nsString& anAnchorAlignment,
|
|
const nsString& aPopupAlignment,
|
|
nsIDOMWindow* aWindow, nsIDOMWindow** outPopup)
|
|
{
|
|
if (nsnull != mContainer) {
|
|
return mContainer->CreatePopup(aElement, aPopupContent, aXPos, aYPos, aPopupType,
|
|
anAnchorAlignment, aPopupAlignment,
|
|
aWindow, outPopup);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::FindWebShellWithName(const PRUnichar* aName, nsIWebShell*& aResult)
|
|
{
|
|
if (nsnull != mContainer) {
|
|
return mContainer->FindWebShellWithName(aName, aResult);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::FocusAvailable(nsIWebShell* aFocusedWebShell, PRBool& aFocusTaken)
|
|
{
|
|
//If the WebShell with focus is us, pass this up to container
|
|
if (this == aFocusedWebShell && nsnull != mContainer) {
|
|
mContainer->FocusAvailable(this, aFocusTaken);
|
|
}
|
|
|
|
nsIWebShell* shell = nsnull;
|
|
|
|
//Other wise, check children and move focus to next one
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
shell = (nsIWebShell*)mChildren.ElementAt(i);
|
|
if (shell == aFocusedWebShell) {
|
|
if (++i < n) {
|
|
shell = (nsIWebShell*)mChildren.ElementAt(i);
|
|
shell->SetFocus();
|
|
break;
|
|
}
|
|
else if (nsnull != mContainer) {
|
|
mContainer->FocusAvailable(this, aFocusTaken);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// Web Shell Services API
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::LoadDocument(const char* aURL,
|
|
const char* aCharset,
|
|
nsCharsetSource aSource)
|
|
{
|
|
// XXX hack. kee the aCharset and aSource wait to pick it up
|
|
mHintCharset = aCharset;
|
|
mHintCharsetSource = aSource;
|
|
|
|
nsAutoString url(aURL);
|
|
LoadURL(url.GetUnicode());
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::ReloadDocument(const char* aCharset,
|
|
nsCharsetSource aSource)
|
|
{
|
|
|
|
// XXX hack. kee the aCharset and aSource wait to pick it up
|
|
mHintCharset = aCharset;
|
|
mHintCharsetSource= aSource;
|
|
|
|
return Reload( nsIChannel::LOAD_NORMAL);
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::StopDocumentLoad(void)
|
|
{
|
|
Stop();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetRendering(PRBool aRender)
|
|
{
|
|
if (mContentViewer) {
|
|
mContentViewer->SetEnableRendering(aRender);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// WebShell link handling
|
|
|
|
struct OnLinkClickEvent : public PLEvent {
|
|
OnLinkClickEvent(nsWebShell* aHandler, nsIContent* aContent,
|
|
nsLinkVerb aVerb, const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec, nsIInputStream* aPostDataStream = 0);
|
|
~OnLinkClickEvent();
|
|
|
|
void HandleEvent() {
|
|
mHandler->HandleLinkClickEvent(mContent, mVerb, mURLSpec->GetUnicode(),
|
|
mTargetSpec->GetUnicode(), mPostDataStream);
|
|
}
|
|
|
|
nsWebShell* mHandler;
|
|
nsString* mURLSpec;
|
|
nsString* mTargetSpec;
|
|
nsIInputStream* mPostDataStream;
|
|
nsIContent* mContent;
|
|
nsLinkVerb mVerb;
|
|
};
|
|
|
|
static void PR_CALLBACK HandlePLEvent(OnLinkClickEvent* aEvent)
|
|
{
|
|
aEvent->HandleEvent();
|
|
}
|
|
|
|
static void PR_CALLBACK DestroyPLEvent(OnLinkClickEvent* aEvent)
|
|
{
|
|
delete aEvent;
|
|
}
|
|
|
|
OnLinkClickEvent::OnLinkClickEvent(nsWebShell* aHandler,
|
|
nsIContent *aContent,
|
|
nsLinkVerb aVerb,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec,
|
|
nsIInputStream* aPostDataStream)
|
|
{
|
|
nsIEventQueue* eventQueue;
|
|
|
|
mHandler = aHandler;
|
|
NS_ADDREF(aHandler);
|
|
mURLSpec = new nsString(aURLSpec);
|
|
mTargetSpec = new nsString(aTargetSpec);
|
|
mPostDataStream = aPostDataStream;
|
|
NS_IF_ADDREF(mPostDataStream);
|
|
mContent = aContent;
|
|
NS_IF_ADDREF(mContent);
|
|
mVerb = aVerb;
|
|
|
|
PL_InitEvent(this, nsnull,
|
|
(PLHandleEventProc) ::HandlePLEvent,
|
|
(PLDestroyEventProc) ::DestroyPLEvent);
|
|
|
|
eventQueue = aHandler->GetEventQueue();
|
|
eventQueue->PostEvent(this);
|
|
NS_RELEASE(eventQueue);
|
|
}
|
|
|
|
OnLinkClickEvent::~OnLinkClickEvent()
|
|
{
|
|
NS_IF_RELEASE(mContent);
|
|
NS_IF_RELEASE(mHandler);
|
|
NS_IF_RELEASE(mPostDataStream);
|
|
if (nsnull != mURLSpec) delete mURLSpec;
|
|
if (nsnull != mTargetSpec) delete mTargetSpec;
|
|
|
|
}
|
|
|
|
//----------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnLinkClick(nsIContent* aContent,
|
|
nsLinkVerb aVerb,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec,
|
|
nsIInputStream* aPostDataStream)
|
|
{
|
|
OnLinkClickEvent* ev;
|
|
nsresult rv = NS_OK;
|
|
|
|
ev = new OnLinkClickEvent(this, aContent, aVerb, aURLSpec,
|
|
aTargetSpec, aPostDataStream);
|
|
if (nsnull == ev) {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
// Find the web shell in the entire tree that we can reach that the
|
|
// link click should go to.
|
|
|
|
// XXX This doesn't yet know how to target other windows with their
|
|
// own tree
|
|
nsIWebShell*
|
|
nsWebShell::GetTarget(const PRUnichar* aName)
|
|
{
|
|
nsAutoString name(aName);
|
|
nsIWebShell* target = nsnull;
|
|
|
|
if (0 == name.Length()) {
|
|
NS_ADDREF_THIS();
|
|
return this;
|
|
}
|
|
|
|
if (name.EqualsIgnoreCase("_blank")) {
|
|
nsIWebShell *shell;
|
|
if (NS_OK == NewWebShell(PRUint32(~0), PR_TRUE, shell))
|
|
target = shell;
|
|
else
|
|
{
|
|
//don't know what to do here? MMP
|
|
NS_ASSERTION(PR_FALSE, "unable to get new webshell");
|
|
}
|
|
}
|
|
else if (name.EqualsIgnoreCase("_self")) {
|
|
target = this;
|
|
NS_ADDREF(target);
|
|
}
|
|
else if (name.EqualsIgnoreCase("_parent")) {
|
|
GetParent(target);
|
|
if (target == nsnull) {
|
|
target = this;
|
|
NS_ADDREF(target);
|
|
}
|
|
}
|
|
else if (name.EqualsIgnoreCase("_top")) {
|
|
GetRootWebShell(target); // this addrefs, which is OK
|
|
}
|
|
else if (name.EqualsIgnoreCase("_content")) {
|
|
// a kind of special case: only the window can answer this question
|
|
NS_ASSERTION(mContainer, "null container in WebShell::GetTarget");
|
|
if (nsnull != mContainer)
|
|
mContainer->FindWebShellWithName(aName, target);
|
|
// (and don't SetName())
|
|
// else target remains nsnull, which would be bad
|
|
}
|
|
else {
|
|
// Look from the top of the tree downward
|
|
NS_ASSERTION(mContainer, "null container in WebShell::GetTarget");
|
|
if (nsnull != mContainer) {
|
|
mContainer->FindWebShellWithName(aName, target);
|
|
if (nsnull == target) {
|
|
mContainer->NewWebShell(NS_CHROME_ALL_CHROME, PR_TRUE, target);
|
|
}
|
|
if (nsnull != target) {
|
|
target->SetName(aName);
|
|
}
|
|
else {
|
|
target = this;
|
|
NS_ADDREF(target);
|
|
}
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
nsIEventQueue* nsWebShell::GetEventQueue(void)
|
|
{
|
|
NS_PRECONDITION(nsnull != mThreadEventQueue, "EventQueue for thread is null");
|
|
NS_ADDREF(mThreadEventQueue);
|
|
return mThreadEventQueue;
|
|
}
|
|
|
|
void
|
|
nsWebShell::HandleLinkClickEvent(nsIContent *aContent,
|
|
nsLinkVerb aVerb,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec,
|
|
nsIInputStream* aPostDataStream)
|
|
{
|
|
nsAutoString target(aTargetSpec);
|
|
|
|
|
|
switch(aVerb) {
|
|
case eLinkVerb_New:
|
|
target.SetString("_blank");
|
|
// Fall into replace case
|
|
case eLinkVerb_Replace:
|
|
{
|
|
nsIWebShell* shell = GetTarget(target.GetUnicode());
|
|
if (nsnull != shell) {
|
|
(void)shell->LoadURL(aURLSpec, aPostDataStream);
|
|
NS_RELEASE(shell);
|
|
}
|
|
}
|
|
break;
|
|
case eLinkVerb_Embed:
|
|
default:
|
|
;
|
|
// XXX Need to do this
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnOverLink(nsIContent* aContent,
|
|
const PRUnichar* aURLSpec,
|
|
const PRUnichar* aTargetSpec)
|
|
{
|
|
if (!mOverURL.Equals(aURLSpec) || !mOverTarget.Equals(aTargetSpec)) {
|
|
#ifdef NOISY_LINKS
|
|
fputs("Was '", stdout);
|
|
fputs(mOverURL, stdout);
|
|
fputs("' '", stdout);
|
|
fputs(mOverTarget, stdout);
|
|
fputs("'\n", stdout);
|
|
fputs("Over link '", stdout);
|
|
fputs(aURLSpec, stdout);
|
|
fputs("' '", stdout);
|
|
fputs(aTargetSpec, stdout);
|
|
fputs("'\n", stdout);
|
|
#endif /* NS_DEBUG */
|
|
|
|
mOverURL = aURLSpec;
|
|
mOverTarget = aTargetSpec;
|
|
|
|
// Get the browser window and setStatus
|
|
nsIBrowserWindow *browserWindow;
|
|
|
|
browserWindow = GetBrowserWindow();
|
|
if (nsnull != browserWindow) {
|
|
browserWindow->SetStatus(aURLSpec);
|
|
NS_RELEASE(browserWindow);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetLinkState(const PRUnichar* aURLSpec, nsLinkState& aState)
|
|
{
|
|
aState = eLinkState_Unvisited;
|
|
|
|
nsresult rv;
|
|
|
|
// XXX: GlobalHistory is going to be moved out of the webshell into a more appropriate place.
|
|
if ((nsnull == mHistoryService) && !mFailedToLoadHistoryService) {
|
|
rv = nsServiceManager::GetService(kGlobalHistoryCID,
|
|
nsIGlobalHistory::GetIID(),
|
|
(nsISupports**) &mHistoryService);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
mFailedToLoadHistoryService = PR_TRUE;
|
|
}
|
|
}
|
|
|
|
if (mHistoryService) {
|
|
// XXX aURLSpec should really be a char*, not a PRUnichar*.
|
|
nsAutoString urlStr(aURLSpec);
|
|
|
|
char buf[256];
|
|
char* url = buf;
|
|
|
|
if (urlStr.Length() >= PRInt32(sizeof buf)) {
|
|
url = new char[urlStr.Length() + 1];
|
|
}
|
|
|
|
PRInt64 lastVisitDate;
|
|
|
|
if (url) {
|
|
urlStr.ToCString(url, urlStr.Length() + 1);
|
|
|
|
rv = mHistoryService->GetLastVisitDate(url, &lastVisitDate);
|
|
|
|
if (url != buf)
|
|
delete[] url;
|
|
}
|
|
else {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//XXX: Moved to destructor nsServiceManager::ReleaseService(kGlobalHistoryCID, mHistoryService);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
// a last-visit-date of zero means we've never seen it before; so
|
|
// if it's not zero, we must've seen it.
|
|
if (! LL_IS_ZERO(lastVisitDate))
|
|
aState = eLinkState_Visited;
|
|
|
|
// XXX how to tell if eLinkState_OutOfDate?
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
nsIBrowserWindow* nsWebShell::GetBrowserWindow()
|
|
{
|
|
nsIBrowserWindow *browserWindow = nsnull;
|
|
nsIWebShell *rootWebShell;
|
|
|
|
GetRootWebShellEvenIfChrome(rootWebShell);
|
|
|
|
if (nsnull != rootWebShell) {
|
|
nsIWebShellContainer *rootContainer;
|
|
rootWebShell->GetContainer(rootContainer);
|
|
if (nsnull != rootContainer) {
|
|
rootContainer->QueryInterface(kIBrowserWindowIID, (void**)&browserWindow);
|
|
NS_RELEASE(rootContainer);
|
|
}
|
|
NS_RELEASE(rootWebShell);
|
|
}
|
|
|
|
return browserWindow;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShell::CreateScriptEnvironment()
|
|
{
|
|
nsresult res = NS_OK;
|
|
|
|
if (nsnull == mScriptGlobal) {
|
|
res = NS_NewScriptGlobalObject(&mScriptGlobal);
|
|
if (NS_FAILED(res)) {
|
|
return res;
|
|
}
|
|
mScriptGlobal->SetWebShell(this);
|
|
}
|
|
|
|
if (nsnull == mScriptContext) {
|
|
res = NS_CreateScriptContext(mScriptGlobal, &mScriptContext);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShell::GetScriptContext(nsIScriptContext** aContext)
|
|
{
|
|
NS_PRECONDITION(nsnull != aContext, "null arg");
|
|
nsresult res = NS_OK;
|
|
|
|
res = CreateScriptEnvironment();
|
|
|
|
if (NS_SUCCEEDED(res)) {
|
|
*aContext = mScriptContext;
|
|
NS_ADDREF(mScriptContext);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShell::GetScriptGlobalObject(nsIScriptGlobalObject** aGlobal)
|
|
{
|
|
NS_PRECONDITION(nsnull != aGlobal, "null arg");
|
|
nsresult res = NS_OK;
|
|
|
|
res = CreateScriptEnvironment();
|
|
|
|
if (NS_SUCCEEDED(res)) {
|
|
*aGlobal = mScriptGlobal;
|
|
NS_IF_ADDREF(mScriptGlobal);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShell::ReleaseScriptContext(nsIScriptContext *aContext)
|
|
{
|
|
// XXX Is this right? Why are we passing in a context?
|
|
NS_IF_RELEASE(aContext);
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnStartDocumentLoad(nsIDocumentLoader* loader,
|
|
nsIURI* aURL,
|
|
const char* aCommand)
|
|
{
|
|
nsIDocumentViewer* docViewer;
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
if ((nsnull != mScriptGlobal) &&
|
|
(loader == mDocLoader)) {
|
|
if (nsnull != mContentViewer &&
|
|
NS_OK == mContentViewer->QueryInterface(kIDocumentViewerIID, (void**)&docViewer)) {
|
|
nsIPresContext *presContext;
|
|
if (NS_OK == docViewer->GetPresContext(presContext)) {
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
nsMouseEvent event;
|
|
event.eventStructType = NS_EVENT;
|
|
event.message = NS_PAGE_UNLOAD;
|
|
rv = mScriptGlobal->HandleDOMEvent(*presContext, &event, nsnull, NS_EVENT_FLAG_INIT, status);
|
|
|
|
NS_RELEASE(presContext);
|
|
}
|
|
NS_RELEASE(docViewer);
|
|
}
|
|
}
|
|
|
|
/*
|
|
*Fire the OnStartDocumentLoad of the webshell observer
|
|
*/
|
|
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver))
|
|
{
|
|
mDocLoaderObserver->OnStartDocumentLoad(mDocLoader, aURL, aCommand);
|
|
}
|
|
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnEndDocumentLoad(nsIDocumentLoader* loader,
|
|
#ifdef NECKO
|
|
nsIChannel* channel,
|
|
#else
|
|
nsIURI* aURL,
|
|
#endif
|
|
#ifdef NECKO
|
|
nsresult aStatus,
|
|
#else
|
|
PRInt32 aStatus,
|
|
#endif
|
|
nsIDocumentLoaderObserver * aWebShell)
|
|
{
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
#ifdef NECKO
|
|
nsCOMPtr<nsIURI> aURL;
|
|
rv = channel->GetURI(getter_AddRefs(aURL));
|
|
if (NS_FAILED(rv)) return rv;
|
|
#endif
|
|
|
|
//if (!mProcessedEndDocumentLoad) {
|
|
if (loader == mDocLoader) {
|
|
mProcessedEndDocumentLoad = PR_TRUE;
|
|
|
|
if (nsnull != mScriptGlobal) {
|
|
nsIDocumentViewer* docViewer;
|
|
if (nsnull != mContentViewer &&
|
|
NS_OK == mContentViewer->QueryInterface(kIDocumentViewerIID, (void**)&docViewer)) {
|
|
nsIPresContext *presContext;
|
|
if (NS_OK == docViewer->GetPresContext(presContext)) {
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
nsMouseEvent event;
|
|
event.eventStructType = NS_EVENT;
|
|
event.message = NS_PAGE_LOAD;
|
|
rv = mScriptGlobal->HandleDOMEvent(*presContext, &event, nsnull, NS_EVENT_FLAG_INIT, status);
|
|
|
|
NS_RELEASE(presContext);
|
|
}
|
|
NS_RELEASE(docViewer);
|
|
}
|
|
}
|
|
|
|
// Fire the EndLoadURL of the web shell container
|
|
if (nsnull != aURL) {
|
|
nsAutoString urlString;
|
|
#ifdef NECKO
|
|
char* spec;
|
|
#else
|
|
const char* spec;
|
|
#endif
|
|
rv = aURL->GetSpec(&spec);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
urlString = spec;
|
|
if (nsnull != mContainer) {
|
|
rv = mContainer->EndLoadURL(this, urlString.GetUnicode(), 0);
|
|
}
|
|
#ifdef NECKO
|
|
nsCRT::free(spec);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
nsCOMPtr<nsIDocumentLoaderObserver> dlObserver;
|
|
|
|
if (!mDocLoaderObserver && mParent) {
|
|
/* If this is a frame (in which case it would have a parent && doesn't
|
|
* have a documentloaderObserver, get it from the rootWebShell
|
|
*/
|
|
nsCOMPtr<nsIWebShell> root;
|
|
nsresult res = GetRootWebShell(*getter_AddRefs(root));
|
|
|
|
if (NS_SUCCEEDED(res) && root)
|
|
root->GetDocLoaderObserver(*getter_AddRefs(dlObserver));
|
|
}
|
|
else
|
|
{
|
|
/* Take care of the Trailing slash situation */
|
|
if (mSHist)
|
|
CheckForTrailingSlash(aURL);
|
|
dlObserver = do_QueryInterface(mDocLoaderObserver); // we need this to addref
|
|
}
|
|
|
|
/*
|
|
* Fire the OnEndDocumentLoad of the DocLoaderobserver
|
|
*/
|
|
if (dlObserver && (nsnull != aURL)) {
|
|
#ifdef NECKO
|
|
dlObserver->OnEndDocumentLoad(mDocLoader, channel, aStatus, aWebShell);
|
|
#else
|
|
dlObserver->OnEndDocumentLoad(mDocLoader, aURL, aStatus, aWebShell);
|
|
#endif
|
|
}
|
|
|
|
#ifdef NECKO
|
|
if ( (mDocLoader == loader) && (aStatus == NS_ERROR_UNKNOWN_HOST) ) {
|
|
// We need to check for a dns failure in aStatus, but dns failure codes
|
|
// aren't proliferated yet. This checks for failure for a host lacking
|
|
// "www." and/or ".com" and munges the url acordingly, then fires off
|
|
// a new request.
|
|
//
|
|
// XXX This code may or may not have mem leaks depending on the version
|
|
// XXX stdurl that is in the tree at a given point in time. This needs to
|
|
// XXX be fixed once we have a solid version of std url in.
|
|
char *host = nsnull;
|
|
nsString2 hostStr;
|
|
rv = aURL->GetHost(&host);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
hostStr.SetString(host);
|
|
nsAllocator::Free(host);
|
|
PRInt32 dotLoc = -1;
|
|
dotLoc = hostStr.Find('.');
|
|
PRBool retry = PR_FALSE;
|
|
if (-1 == dotLoc) {
|
|
hostStr.Insert("www.", 0, 4);
|
|
hostStr.Append(".com");
|
|
retry = PR_TRUE;
|
|
} else if ( (hostStr.Length() - dotLoc) == 3) {
|
|
hostStr.Insert("www.", 0, 4);
|
|
retry = PR_TRUE;
|
|
}
|
|
|
|
if (retry) {
|
|
char *modHost = hostStr.ToNewCString();
|
|
if (!modHost)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
rv = aURL->SetHost(modHost);
|
|
nsAllocator::Free(modHost);
|
|
modHost = nsnull;
|
|
if (NS_FAILED(rv)) return rv;
|
|
char *aSpec = nsnull;
|
|
rv = aURL->GetSpec(&aSpec);
|
|
if (NS_FAILED(rv)) return rv;
|
|
nsString2 newURL(aSpec);
|
|
// reload the url
|
|
const PRUnichar *spec = newURL.GetUnicode();
|
|
if (spec) {
|
|
rv = LoadURL(spec, "view");
|
|
}
|
|
} // retry
|
|
} // unknown host
|
|
#endif //NECKO
|
|
|
|
} //!mProcessedEndDocumentLoad
|
|
else {
|
|
rv = NS_OK;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnStartURLLoad(nsIDocumentLoader* loader,
|
|
#ifdef NECKO
|
|
nsIChannel* channel,
|
|
#else
|
|
nsIURI* aURL,
|
|
const char* aContentType,
|
|
#endif
|
|
nsIContentViewer* aViewer)
|
|
{
|
|
nsresult rv;
|
|
#ifdef NECKO
|
|
nsCOMPtr<nsIURI> aURL;
|
|
rv = channel->GetURI(getter_AddRefs(aURL));
|
|
if (NS_FAILED(rv)) return rv;
|
|
#endif
|
|
|
|
|
|
// Stop loading of the earlier document completely when the document url
|
|
// load starts. Now we know that this url is valid and available.
|
|
nsXPIDLCString url;
|
|
#ifdef NECKO
|
|
aURL->GetSpec(getter_Copies(url));
|
|
#else
|
|
aURL->GetSpec(getter_Shares(url));
|
|
#endif
|
|
if (0 == PL_strcmp(url, mURL.GetBuffer()))
|
|
StopAfterURLAvailable();
|
|
|
|
// XXX This is a temporary hack for meeting the M4 milestone
|
|
// for seamonkey. I think Netlib should send a message to all stream listeners
|
|
// when it changes the URL like this. That would mean adding a new method
|
|
// to nsIStreamListener. Need to talk to Rick, Kipp, Gagan about this.
|
|
|
|
/* Overriding comments: History mechanism has changed. So is Necko changing.
|
|
* Need to check in the new world if this is still valid. If so, new methods
|
|
* need to be added to nsISessionHistory. Until then. We don't need this.
|
|
* This is being done so that old History code can be removed.
|
|
*/
|
|
// CheckForTrailingSlash(aURL);
|
|
|
|
/*
|
|
*Fire the OnStartDocumentLoad of the webshell observer
|
|
*/
|
|
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver))
|
|
{
|
|
#ifdef NECKO
|
|
mDocLoaderObserver->OnStartURLLoad(mDocLoader, channel, aViewer);
|
|
#else
|
|
mDocLoaderObserver->OnStartURLLoad(mDocLoader, aURL, aContentType, aViewer);
|
|
#endif
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnProgressURLLoad(nsIDocumentLoader* loader,
|
|
#ifdef NECKO
|
|
nsIChannel* channel,
|
|
#else
|
|
nsIURI* aURL,
|
|
#endif
|
|
PRUint32 aProgress,
|
|
PRUint32 aProgressMax)
|
|
{
|
|
/*
|
|
*Fire the OnStartDocumentLoad of the webshell observer and container...
|
|
*/
|
|
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver))
|
|
{
|
|
#ifdef NECKO
|
|
mDocLoaderObserver->OnProgressURLLoad(mDocLoader, channel, aProgress, aProgressMax);
|
|
#else
|
|
mDocLoaderObserver->OnProgressURLLoad(mDocLoader, aURL, aProgress, aProgressMax);
|
|
#endif
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnStatusURLLoad(nsIDocumentLoader* loader,
|
|
#ifdef NECKO
|
|
nsIChannel* channel,
|
|
#else
|
|
nsIURI* aURL,
|
|
#endif
|
|
nsString& aMsg)
|
|
{
|
|
/*
|
|
*Fire the OnStartDocumentLoad of the webshell observer and container...
|
|
*/
|
|
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver))
|
|
{
|
|
#ifdef NECKO
|
|
mDocLoaderObserver->OnStatusURLLoad(mDocLoader, channel, aMsg);
|
|
#else
|
|
mDocLoaderObserver->OnStatusURLLoad(mDocLoader, aURL, aMsg);
|
|
#endif
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnEndURLLoad(nsIDocumentLoader* loader,
|
|
#ifdef NECKO
|
|
nsIChannel* channel,
|
|
nsresult aStatus)
|
|
#else
|
|
nsIURI* aURL,
|
|
PRInt32 aStatus)
|
|
#endif // NECKO
|
|
{
|
|
#if 0
|
|
const char* spec;
|
|
aURL->GetSpec(&spec);
|
|
printf("nsWebShell::OnEndURLLoad:%p: loader=%p url=%s status=%d\n", this, loader, spec, aStatus);
|
|
#endif
|
|
/*
|
|
*Fire the OnStartDocumentLoad of the webshell observer
|
|
*/
|
|
if ((nsnull != mContainer) && (nsnull != mDocLoaderObserver))
|
|
{
|
|
#ifdef NECKO
|
|
mDocLoaderObserver->OnEndURLLoad(mDocLoader, channel, aStatus);
|
|
#else
|
|
mDocLoaderObserver->OnEndURLLoad(mDocLoader, aURL, aStatus);
|
|
#endif
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* For use with redirect/refresh url api */
|
|
class refreshData : public nsITimerCallback
|
|
{
|
|
public:
|
|
refreshData();
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsITimerCallback interface
|
|
virtual void Notify(nsITimer *timer);
|
|
|
|
nsIWebShell* mShell;
|
|
nsString mUrlSpec;
|
|
PRBool mRepeat;
|
|
PRInt32 mDelay;
|
|
|
|
protected:
|
|
virtual ~refreshData();
|
|
};
|
|
|
|
refreshData::refreshData()
|
|
{
|
|
NS_INIT_REFCNT();
|
|
|
|
mShell = nsnull;
|
|
}
|
|
|
|
refreshData::~refreshData()
|
|
{
|
|
NS_IF_RELEASE(mShell);
|
|
}
|
|
|
|
|
|
NS_IMPL_ISUPPORTS(refreshData, kITimerCallbackIID);
|
|
|
|
void refreshData::Notify(nsITimer *aTimer)
|
|
{
|
|
NS_PRECONDITION((nsnull != mShell), "Null pointer...");
|
|
if (nsnull != mShell) {
|
|
#ifdef NECKO
|
|
mShell->LoadURL(mUrlSpec.GetUnicode(), nsnull, PR_TRUE, nsIChannel::LOAD_NORMAL);
|
|
#else
|
|
mShell->LoadURL(mUrlSpec.GetUnicode(), nsnull, PR_TRUE, nsURLReload);
|
|
#endif
|
|
}
|
|
/*
|
|
* LoadURL(...) will cancel all refresh timers... This causes the Timer and
|
|
* its refreshData instance to be released...
|
|
*/
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
#ifndef NECKO
|
|
nsWebShell::RefreshURL(nsIURI* aURI, PRInt32 millis, PRBool repeat)
|
|
#else
|
|
nsWebShell::RefreshURI(nsIURI* aURI, PRInt32 millis, PRBool repeat)
|
|
#endif // NECKO
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
if (nsnull == aURI) {
|
|
NS_PRECONDITION((aURI != nsnull), "Null pointer");
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
goto done;
|
|
}
|
|
|
|
#ifdef NECKO
|
|
char* spec;
|
|
#else
|
|
const char* spec;
|
|
#endif
|
|
aURI->GetSpec(&spec);
|
|
rv = RefreshURL(spec, millis, repeat);
|
|
#ifdef NECKO
|
|
nsCRT::free(spec);
|
|
#endif
|
|
done:
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::RefreshURL(const char* aURI, PRInt32 millis, PRBool repeat)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
nsITimer *timer=nsnull;
|
|
refreshData *data;
|
|
|
|
if (nsnull == aURI) {
|
|
NS_PRECONDITION((aURI != nsnull), "Null pointer");
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
goto done;
|
|
}
|
|
|
|
NS_NEWXPCOM(data, refreshData);
|
|
if (nsnull == data) {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
goto done;
|
|
}
|
|
|
|
// Set the reference count to one...
|
|
NS_ADDREF(data);
|
|
|
|
data->mShell = this;
|
|
NS_ADDREF(data->mShell);
|
|
|
|
data->mUrlSpec = aURI;
|
|
data->mDelay = millis;
|
|
data->mRepeat = repeat;
|
|
|
|
/* Create the timer. */
|
|
if (NS_OK == NS_NewTimer(&timer)) {
|
|
/* Add the timer to our array. */
|
|
NS_LOCK_INSTANCE();
|
|
mRefreshments.AppendElement(timer);
|
|
timer->Init(data, millis);
|
|
NS_UNLOCK_INSTANCE();
|
|
}
|
|
|
|
NS_RELEASE(data);
|
|
|
|
done:
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
#ifdef NECKO
|
|
nsWebShell::CancelRefreshURITimers(void)
|
|
#else
|
|
nsWebShell::CancelRefreshURLTimers(void)
|
|
#endif // NECKO
|
|
{
|
|
PRInt32 i;
|
|
nsITimer* timer;
|
|
|
|
/* Right now all we can do is cancel all the timers for this webshell. */
|
|
NS_LOCK_INSTANCE();
|
|
|
|
/* Walk the list backwards to avoid copying the array as it shrinks.. */
|
|
for (i = mRefreshments.Count()-1; (0 <= i); i--) {
|
|
timer=(nsITimer*)mRefreshments.ElementAt(i);
|
|
/* Remove the entry from the list before releasing the timer.*/
|
|
mRefreshments.RemoveElementAt(i);
|
|
|
|
if (timer) {
|
|
timer->Cancel();
|
|
NS_RELEASE(timer);
|
|
}
|
|
}
|
|
NS_UNLOCK_INSTANCE();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
/*
|
|
* There are cases where netlib does things like add a trailing slash
|
|
* to the url being retrieved. We need to watch out for such
|
|
* changes and update the currently loading url's entry in the history
|
|
* list. UpdateHistoryEntry() does this.
|
|
*
|
|
* Assumptions:
|
|
*
|
|
* 1) aURL is the URL that was inserted into the history list in LoadURL()
|
|
* 2) The load of aURL is in progress and this function is being called
|
|
* from one of the functions in nsIStreamListener implemented by nsWebShell.
|
|
*/
|
|
nsresult nsWebShell::CheckForTrailingSlash(nsIURI* aURL)
|
|
{
|
|
|
|
const PRUnichar * url=nsnull;
|
|
PRInt32 curIndex=0;
|
|
|
|
/* Get current history index and url for it */
|
|
mSHist->getCurrentIndex(curIndex);
|
|
mSHist->GetURLForIndex(curIndex, &url);
|
|
nsString * historyURL = (nsString *) new nsString(url);
|
|
|
|
/* Get the url that netlib passed us */
|
|
#ifdef NECKO
|
|
char* spec;
|
|
#else
|
|
const char* spec;
|
|
#endif
|
|
aURL->GetSpec(&spec);
|
|
nsString* newURL = (nsString*) new nsString(spec);
|
|
#ifdef NECKO
|
|
nsCRT::free(spec);
|
|
#endif
|
|
|
|
if (newURL && newURL->Last() == '/' && !historyURL->Equals(*newURL)) {
|
|
// Replace the top most history entry with the new url
|
|
printf("Changing URL from %s to %s for history entry %d\n", historyURL->ToNewCString(), newURL->ToNewCString(), curIndex);
|
|
mSHist->SetURLForIndex(curIndex, newURL->GetUnicode());
|
|
}
|
|
else {
|
|
delete newURL;
|
|
delete historyURL;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#if 0
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnStartRequest(nsIURI* aURL, const char *aContentType)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull != mObserver) {
|
|
rv = mObserver->OnStartRequest(aURL, aContentType);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnProgress(nsIURI* aURL, PRUint32 aProgress, PRUint32 aProgressMax)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull != mObserver) {
|
|
rv = mObserver->OnProgress(aURL, aProgress, aProgressMax);
|
|
}
|
|
|
|
// Pass status messages out to the nsIBrowserWindow...
|
|
nsIBrowserWindow *browserWindow;
|
|
|
|
browserWindow = GetBrowserWindow();
|
|
if (nsnull != browserWindow) {
|
|
browserWindow->SetProgress(aProgress, aProgressMax);
|
|
NS_RELEASE(browserWindow);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnStatus(nsIURI* aURL, const PRUnichar* aMsg)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull != mObserver) {
|
|
rv = mObserver->OnStatus(aURL, aMsg);
|
|
}
|
|
|
|
// Pass status messages out to the nsIBrowserWindow...
|
|
nsIBrowserWindow *browserWindow;
|
|
|
|
browserWindow = GetBrowserWindow();
|
|
if (nsnull != browserWindow) {
|
|
browserWindow->SetStatus(aMsg);
|
|
NS_RELEASE(browserWindow);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::OnStopRequest(nsIURI* aURL, nsresult aStatus, const PRUnichar* aMsg)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull != mObserver) {
|
|
rv = mObserver->OnStopRequest(aURL, aStatus, aMsg);
|
|
}
|
|
return rv;
|
|
}
|
|
#endif /* 0 */
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::Alert(const PRUnichar *text)
|
|
#else
|
|
NS_IMETHODIMP_(void)
|
|
nsWebShell::Alert(const nsString &aText)
|
|
#endif
|
|
{
|
|
#ifdef NECKO
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->Alert(text);
|
|
#else
|
|
if (nsnull != mNetSupport) {
|
|
mNetSupport->Alert(aText);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::Confirm(const PRUnichar *text,
|
|
PRBool *result)
|
|
#else
|
|
NS_IMETHODIMP_(PRBool)
|
|
nsWebShell::Confirm(const nsString &aText)
|
|
#endif
|
|
{
|
|
#ifdef NECKO
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->Confirm(text, result);
|
|
#else
|
|
PRBool bResult = PR_FALSE;
|
|
|
|
if (nsnull != mNetSupport) {
|
|
bResult = mNetSupport->Confirm(aText);
|
|
}
|
|
return bResult;
|
|
#endif
|
|
}
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::ConfirmYN(const PRUnichar *text,
|
|
PRBool *result)
|
|
#else
|
|
NS_IMETHODIMP_(PRBool)
|
|
nsWebShell::ConfirmYN(const nsString &aText)
|
|
#endif
|
|
{
|
|
#ifdef NECKO
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->ConfirmYN(text, result);
|
|
#else
|
|
PRBool bResult = PR_FALSE;
|
|
|
|
if (nsnull != mNetSupport) {
|
|
bResult = mNetSupport->ConfirmYN(aText);
|
|
}
|
|
return bResult;
|
|
#endif
|
|
}
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::ConfirmCheck(const PRUnichar *text,
|
|
const PRUnichar *checkMsg,
|
|
PRBool *checkValue,
|
|
PRBool *result)
|
|
{
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->ConfirmCheck(text, checkMsg, checkValue, result);
|
|
}
|
|
#endif
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::ConfirmCheckYN(const PRUnichar *text,
|
|
const PRUnichar *checkMsg,
|
|
PRBool *checkValue,
|
|
PRBool *result)
|
|
{
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->ConfirmCheckYN(text, checkMsg, checkValue, result);
|
|
}
|
|
#endif
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::Prompt(const PRUnichar *text,
|
|
const PRUnichar *defaultText,
|
|
PRUnichar **result,
|
|
PRBool *_retval)
|
|
#else
|
|
NS_IMETHODIMP_(PRBool)
|
|
nsWebShell::Prompt(const nsString &aText,
|
|
const nsString &aDefault,
|
|
nsString &aResult)
|
|
#endif
|
|
{
|
|
#ifdef NECKO
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->Prompt(text, defaultText, result, _retval);
|
|
#else
|
|
PRBool bResult = PR_FALSE;
|
|
if (nsnull != mNetSupport) {
|
|
bResult = mNetSupport->Prompt(aText, aDefault, aResult);
|
|
}
|
|
return bResult;
|
|
#endif
|
|
}
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::PromptUsernameAndPassword(const PRUnichar *text,
|
|
PRUnichar **user,
|
|
PRUnichar **pwd,
|
|
PRBool *_retval)
|
|
#else
|
|
NS_IMETHODIMP_(PRBool)
|
|
nsWebShell::PromptUserAndPassword(const nsString &aText,
|
|
nsString &aUser,
|
|
nsString &aPassword)
|
|
#endif
|
|
{
|
|
#ifdef NECKO
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->PromptUsernameAndPassword(text, user, pwd, _retval);
|
|
#else
|
|
PRBool bResult = PR_FALSE;
|
|
if (nsnull != mNetSupport) {
|
|
bResult = mNetSupport->PromptUserAndPassword(aText, aUser, aPassword);
|
|
}
|
|
return bResult;
|
|
#endif
|
|
}
|
|
|
|
#ifdef NECKO
|
|
NS_IMETHODIMP
|
|
nsWebShell::PromptPassword(const PRUnichar *text,
|
|
PRUnichar **pwd,
|
|
PRBool *_retval)
|
|
#else
|
|
NS_IMETHODIMP_(PRBool)
|
|
nsWebShell::PromptPassword(const nsString &aText,
|
|
nsString &aPassword)
|
|
#endif
|
|
{
|
|
#ifdef NECKO
|
|
if (mPrompter == nsnull)
|
|
return NS_OK;
|
|
return mPrompter->PromptPassword(text, pwd, _retval);
|
|
#else
|
|
PRBool bResult = PR_FALSE;
|
|
|
|
if (nsnull != mNetSupport) {
|
|
bResult = mNetSupport->PromptPassword(aText, aPassword);
|
|
}
|
|
return bResult;
|
|
#endif
|
|
}
|
|
|
|
//----------------------------------------------------
|
|
NS_IMETHODIMP
|
|
nsWebShell::CanCutSelection(PRBool* aResult)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull == aResult) {
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
} else {
|
|
*aResult = PR_FALSE;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CanCopySelection(PRBool* aResult)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull == aResult) {
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
} else {
|
|
*aResult = PR_FALSE;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CanPasteSelection(PRBool* aResult)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull == aResult) {
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
} else {
|
|
*aResult = PR_FALSE;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CutSelection(void)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::CopySelection(void)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::PasteSelection(void)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SelectAll(void)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::SelectNone(void)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
static char *gDefCharset = nsnull;
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetDefaultCharacterSet (const PRUnichar** aDefaultCharacterSet)
|
|
{
|
|
if(0 == mDefaultCharacterSet.Length())
|
|
{
|
|
if((nsnull == gDefCharset) || (nsnull == *gDefCharset))
|
|
{
|
|
if(mPrefs)
|
|
mPrefs->CopyCharPref("intl.charset.default", &gDefCharset);
|
|
}
|
|
if((nsnull == gDefCharset) || (nsnull == *gDefCharset))
|
|
mDefaultCharacterSet = "ISO-8859-1";
|
|
else
|
|
mDefaultCharacterSet = gDefCharset;
|
|
}
|
|
*aDefaultCharacterSet = mDefaultCharacterSet.GetUnicode();
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetDefaultCharacterSet (const PRUnichar* aDefaultCharacterSet)
|
|
{
|
|
mDefaultCharacterSet = aDefaultCharacterSet;
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsIWebShell* child = (nsIWebShell*) mChildren.ElementAt(i);
|
|
if (nsnull != child) {
|
|
child->SetDefaultCharacterSet(aDefaultCharacterSet);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWebShell::GetForceCharacterSet (const PRUnichar** aForceCharacterSet)
|
|
{
|
|
nsString emptyStr = "";
|
|
if (mForceCharacterSet.Equals(emptyStr)) {
|
|
*aForceCharacterSet = nsnull;
|
|
}
|
|
else {
|
|
*aForceCharacterSet = mForceCharacterSet.GetUnicode();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsWebShell::SetForceCharacterSet (const PRUnichar* aForceCharacterSet)
|
|
{
|
|
mForceCharacterSet = aForceCharacterSet;
|
|
PRInt32 i, n = mChildren.Count();
|
|
for (i = 0; i < n; i++) {
|
|
nsIWebShell* child = (nsIWebShell*) mChildren.ElementAt(i);
|
|
if (nsnull != child) {
|
|
child->SetForceCharacterSet(aForceCharacterSet);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsWebShell::GetCharacterSetHint (const PRUnichar** oHintCharset, nsCharsetSource* oSource)
|
|
{
|
|
*oSource = mHintCharsetSource;
|
|
if(kCharsetUninitialized == mHintCharsetSource) {
|
|
*oHintCharset = nsnull;
|
|
} else {
|
|
*oHintCharset = mHintCharset.GetUnicode();
|
|
// clean up after we access it.
|
|
mHintCharsetSource = kCharsetUninitialized;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------
|
|
NS_IMETHODIMP
|
|
nsWebShell::FindNext(const PRUnichar * aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Factory code for creating nsWebShell's
|
|
|
|
class nsWebShellFactory : public nsIFactory
|
|
{
|
|
public:
|
|
nsWebShellFactory();
|
|
virtual ~nsWebShellFactory();
|
|
|
|
// nsISupports methods
|
|
NS_IMETHOD QueryInterface(const nsIID &aIID, void **aResult);
|
|
NS_IMETHOD_(nsrefcnt) AddRef(void);
|
|
NS_IMETHOD_(nsrefcnt) Release(void);
|
|
|
|
// nsIFactory methods
|
|
NS_IMETHOD CreateInstance(nsISupports *aOuter,
|
|
const nsIID &aIID,
|
|
void **aResult);
|
|
|
|
NS_IMETHOD LockFactory(PRBool aLock);
|
|
|
|
private:
|
|
// XXX TEMPORARY placeholder for starting up some
|
|
// services in lieu of a service manager.
|
|
static void StartServices();
|
|
|
|
static PRBool mStartedServices;
|
|
nsrefcnt mRefCnt;
|
|
};
|
|
|
|
PRBool nsWebShellFactory::mStartedServices = PR_FALSE;
|
|
|
|
void
|
|
nsWebShellFactory::StartServices()
|
|
{
|
|
#ifndef NECKO
|
|
// XXX TEMPORARY Till we have real pluggable protocol handlers
|
|
NET_InitJavaScriptProtocol();
|
|
#endif // NECKO
|
|
mStartedServices = PR_TRUE;
|
|
}
|
|
|
|
nsWebShellFactory::nsWebShellFactory()
|
|
{
|
|
if (!mStartedServices) {
|
|
StartServices();
|
|
}
|
|
mRefCnt = 0;
|
|
}
|
|
|
|
nsWebShellFactory::~nsWebShellFactory()
|
|
{
|
|
NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
|
|
}
|
|
|
|
nsresult
|
|
nsWebShellFactory::QueryInterface(const nsIID &aIID, void **aResult)
|
|
{
|
|
if (aResult == NULL) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
// Always NULL result, in case of failure
|
|
*aResult = NULL;
|
|
|
|
if (aIID.Equals(kISupportsIID)) {
|
|
*aResult = (void *)(nsISupports*)this;
|
|
} else if (aIID.Equals(kIFactoryIID)) {
|
|
*aResult = (void *)(nsIFactory*)this;
|
|
}
|
|
|
|
if (*aResult == NULL) {
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
NS_ADDREF_THIS(); // Increase reference count for caller
|
|
return NS_OK;
|
|
}
|
|
|
|
nsrefcnt
|
|
nsWebShellFactory::AddRef()
|
|
{
|
|
return ++mRefCnt;
|
|
}
|
|
|
|
nsrefcnt
|
|
nsWebShellFactory::Release()
|
|
{
|
|
if (--mRefCnt == 0) {
|
|
delete this;
|
|
return 0; // Don't access mRefCnt after deleting!
|
|
}
|
|
return mRefCnt;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShellFactory::CreateInstance(nsISupports *aOuter,
|
|
const nsIID &aIID,
|
|
void **aResult)
|
|
{
|
|
nsresult rv;
|
|
nsWebShell *inst;
|
|
|
|
if (aResult == NULL) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
*aResult = NULL;
|
|
if (nsnull != aOuter) {
|
|
rv = NS_ERROR_NO_AGGREGATION;
|
|
goto done;
|
|
}
|
|
|
|
NS_NEWXPCOM(inst, nsWebShell);
|
|
if (inst == NULL) {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
goto done;
|
|
}
|
|
|
|
NS_ADDREF(inst);
|
|
rv = inst->QueryInterface(aIID, aResult);
|
|
NS_RELEASE(inst);
|
|
|
|
done:
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsWebShellFactory::LockFactory(PRBool aLock)
|
|
{
|
|
// Not implemented in simplest case.
|
|
return NS_OK;
|
|
}
|
|
|
|
extern "C" NS_WEB nsresult
|
|
NS_NewWebShellFactory(nsIFactory** aFactory)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
nsIFactory* inst = new nsWebShellFactory();
|
|
if (nsnull == inst) {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
else {
|
|
NS_ADDREF(inst);
|
|
}
|
|
*aFactory = inst;
|
|
return rv;
|
|
}
|