2001-09-29 00:14:13 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
1998-07-19 01:43:02 +04:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.1 (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/
|
1998-07-19 01:43:02 +04:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* 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.
|
1998-07-19 01:43:02 +04:00
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code.
|
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:43:54 +03:00
|
|
|
*
|
2000-03-11 04:05:08 +03:00
|
|
|
* Contributor(s):
|
|
|
|
* Travis Bogard <travis@netscape.com>
|
2001-05-10 06:35:00 +04:00
|
|
|
* Dan Rosen <dr@netscape.com>
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2000-02-03 06:44:22 +03:00
|
|
|
|
2000-02-28 17:51:35 +03:00
|
|
|
#ifdef XP_OS2_VACPP
|
|
|
|
// XXX every other file that pulls in _os2.h has no problem with HTMX there;
|
|
|
|
// this one does; the problem may lie with the order of the headers below,
|
|
|
|
// which is why this fix is here instead of in _os2.h
|
|
|
|
typedef unsigned long HMTX;
|
|
|
|
#endif
|
2000-07-19 17:36:35 +04:00
|
|
|
|
1999-12-18 05:29:57 +03:00
|
|
|
#include "nsDocShell.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
#include "nsIWebShell.h"
|
2000-07-19 03:13:07 +04:00
|
|
|
#include "nsWebShell.h"
|
2000-02-14 12:16:26 +03:00
|
|
|
#include "nsIWebBrowserChrome.h"
|
1999-11-13 07:06:23 +03:00
|
|
|
#include "nsIInterfaceRequestor.h"
|
2001-09-06 01:28:38 +04:00
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
2000-12-21 02:18:03 +03:00
|
|
|
#include "nsIWebProgress.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
#include "nsIDocumentLoader.h"
|
2000-01-29 09:06:25 +03:00
|
|
|
#include "nsIDocumentLoaderFactory.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
#include "nsIContentViewer.h"
|
1998-08-12 08:56:40 +04:00
|
|
|
#include "nsIDocumentViewer.h"
|
1999-11-19 10:35:27 +03:00
|
|
|
#include "nsIMarkupDocumentViewer.h"
|
1998-11-04 11:48:22 +03:00
|
|
|
#include "nsIClipboardCommands.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
#include "nsILinkHandler.h"
|
|
|
|
#include "nsIStreamListener.h"
|
2000-01-12 02:11:32 +03:00
|
|
|
#include "nsIPrompt.h"
|
1999-11-30 07:50:42 +03:00
|
|
|
#include "nsNetUtil.h"
|
1999-07-30 08:20:34 +04:00
|
|
|
#include "nsIProtocolHandler.h"
|
|
|
|
#include "nsIDNSService.h"
|
1999-08-04 01:48:40 +04:00
|
|
|
#include "nsIRefreshURI.h"
|
1998-07-21 08:46:55 +04:00
|
|
|
#include "nsIScriptGlobalObject.h"
|
1999-12-03 12:24:22 +03:00
|
|
|
#include "nsIScriptGlobalObjectOwner.h"
|
2000-12-30 22:22:22 +03:00
|
|
|
#include "nsIDOMEvent.h"
|
1998-08-12 08:56:40 +04:00
|
|
|
#include "nsIPresContext.h"
|
1999-03-09 12:44:27 +03:00
|
|
|
#include "nsIComponentManager.h"
|
1999-01-05 12:46:33 +03:00
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsIEventQueueService.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
#include "nsCRT.h"
|
|
|
|
#include "nsVoidArray.h"
|
|
|
|
#include "nsString.h"
|
2001-09-29 12:28:41 +04:00
|
|
|
#include "nsReadableUtils.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsGfxCIID.h"
|
|
|
|
#include "plevent.h"
|
1998-08-15 03:08:54 +04:00
|
|
|
#include "prprf.h"
|
1998-07-28 03:08:52 +04:00
|
|
|
#include "nsIPluginHost.h"
|
1998-08-02 02:19:05 +04:00
|
|
|
#include "nsplugin.h"
|
1999-02-04 03:03:18 +03:00
|
|
|
//#include "nsPluginsCID.h"
|
|
|
|
#include "nsIPluginManager.h"
|
1998-07-31 10:02:06 +04:00
|
|
|
#include "nsIPref.h"
|
1998-08-19 03:25:17 +04:00
|
|
|
#include "nsITimer.h"
|
1998-09-26 02:25:21 +04:00
|
|
|
#include "nsITimerCallback.h"
|
1998-11-14 03:21:19 +03:00
|
|
|
#include "nsIContent.h"
|
1998-07-27 22:17:07 +04:00
|
|
|
#include "prlog.h"
|
1999-02-12 08:43:46 +03:00
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsIPresShell.h"
|
1999-05-06 05:58:48 +04:00
|
|
|
#include "nsIWebShellServices.h"
|
1999-05-18 09:21:37 +04:00
|
|
|
#include "nsIGlobalHistory.h"
|
1999-06-28 14:35:57 +04:00
|
|
|
#include "prmem.h"
|
2001-06-19 04:28:10 +04:00
|
|
|
#include "prthread.h"
|
1999-07-03 07:41:34 +04:00
|
|
|
#include "nsXPIDLString.h"
|
2000-02-11 07:48:09 +03:00
|
|
|
#include "nsDOMError.h"
|
1999-09-02 00:14:02 +04:00
|
|
|
#include "nsIDOMHTMLElement.h"
|
|
|
|
#include "nsIDOMHTMLDocument.h"
|
|
|
|
#include "nsLayoutCID.h"
|
|
|
|
#include "nsIDOMRange.h"
|
1999-11-18 10:06:39 +03:00
|
|
|
#include "nsIURIContentListener.h"
|
1999-11-12 03:19:00 +03:00
|
|
|
#include "nsIDOMDocument.h"
|
1999-11-27 05:14:40 +03:00
|
|
|
#include "nsIBaseWindow.h"
|
1999-11-30 07:32:09 +03:00
|
|
|
#include "nsIDocShell.h"
|
1999-12-03 13:57:59 +03:00
|
|
|
#include "nsIDocShellTreeItem.h"
|
|
|
|
#include "nsIDocShellTreeNode.h"
|
1999-12-12 13:16:15 +03:00
|
|
|
#include "nsIDocShellTreeOwner.h"
|
1999-11-30 07:32:09 +03:00
|
|
|
#include "nsCURILoader.h"
|
2000-09-01 05:54:35 +04:00
|
|
|
#include "nsIDOMWindowInternal.h"
|
2000-02-29 10:07:36 +03:00
|
|
|
#include "nsEscape.h"
|
|
|
|
#include "nsIPlatformCharset.h"
|
|
|
|
#include "nsICharsetConverterManager.h"
|
2000-02-26 04:04:50 +03:00
|
|
|
#include "nsISocketTransportService.h"
|
2000-04-02 05:19:27 +04:00
|
|
|
#include "nsILayoutHistoryState.h"
|
2000-05-19 01:52:23 +04:00
|
|
|
#include "nsTextFormatter.h"
|
2000-11-16 23:08:48 +03:00
|
|
|
#include "nsPIDOMWindow.h"
|
|
|
|
#include "nsIController.h"
|
|
|
|
#include "nsIFocusController.h"
|
2001-07-16 06:40:48 +04:00
|
|
|
#include "nsGUIEvent.h"
|
|
|
|
#include "nsISelection.h"
|
|
|
|
#include "nsISelectionController.h"
|
2001-04-14 02:20:33 +04:00
|
|
|
#include "nsIFileStream.h"
|
2001-09-22 04:10:58 +04:00
|
|
|
#include "nsISHistoryInternal.h"
|
2001-10-02 00:15:06 +04:00
|
|
|
#include "nsIHistoryEntry.h"
|
1998-07-27 22:17:07 +04:00
|
|
|
|
2001-05-12 01:05:08 +04:00
|
|
|
#include "nsIHttpChannel.h" // add this to the ick include list...we need it to QI for post data interface
|
2001-09-05 07:52:26 +04:00
|
|
|
#include "nsIUploadChannel.h"
|
2000-01-29 09:06:25 +03:00
|
|
|
|
1999-09-13 22:38:02 +04:00
|
|
|
#include "nsILocaleService.h"
|
2000-01-12 02:11:32 +03:00
|
|
|
#include "nsIStringBundle.h"
|
2000-01-13 01:54:07 +03:00
|
|
|
|
1999-06-18 21:34:08 +04:00
|
|
|
#include "nsIIOService.h"
|
1999-06-23 07:29:44 +04:00
|
|
|
#include "nsIURL.h"
|
2000-01-13 01:54:07 +03:00
|
|
|
#include "nsIProtocolHandler.h"
|
2001-04-14 02:20:33 +04:00
|
|
|
#include "nsICachingChannel.h"
|
1998-08-20 10:17:47 +04:00
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
//XXX for nsIPostData; this is wrong; we shouldn't see the nsIDocument type
|
|
|
|
#include "nsIDocument.h"
|
2001-07-25 02:37:40 +04:00
|
|
|
#include "nsITextToSubURI.h"
|
1998-07-19 01:43:02 +04:00
|
|
|
|
2000-10-29 02:17:53 +04:00
|
|
|
#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
|
1999-07-05 03:40:15 +04:00
|
|
|
|
2000-10-29 02:17:53 +04:00
|
|
|
#define WEB_TRACE_CALLS 0x1
|
|
|
|
#define WEB_TRACE_HISTORY 0x2
|
1998-07-19 01:43:02 +04:00
|
|
|
|
2000-10-29 02:17:53 +04:00
|
|
|
#define WEB_LOG_TEST(_lm,_bit) (PRIntn((_lm)->level) & (_bit))
|
2000-10-28 02:43:51 +04:00
|
|
|
|
2000-10-29 02:17:53 +04:00
|
|
|
#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
|
1998-07-19 01:43:02 +04:00
|
|
|
|
2000-09-20 16:23:53 +04:00
|
|
|
//static NS_DEFINE_CID(kGlobalHistoryCID, NS_GLOBALHISTORY_CID);
|
|
|
|
//static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
|
|
|
|
static NS_DEFINE_CID(kSimpleURICID, NS_SIMPLEURI_CID);
|
1999-06-08 01:26:10 +04:00
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// Class IID's
|
1999-01-05 12:46:33 +03:00
|
|
|
static NS_DEFINE_IID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
|
1999-09-02 00:14:02 +04:00
|
|
|
static NS_DEFINE_CID(kCDOMRangeCID, NS_RANGE_CID);
|
1998-07-19 01:43:02 +04:00
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// Note: operator new zeros our memory
|
1999-12-18 05:29:57 +03:00
|
|
|
nsWebShell::nsWebShell() : nsDocShell()
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
2000-09-12 02:06:52 +04:00
|
|
|
#ifdef DEBUG
|
1999-09-07 02:59:11 +04:00
|
|
|
// We're counting the number of |nsWebShells| to help find leaks
|
|
|
|
++gNumberOfWebShells;
|
2000-10-29 02:17:53 +04:00
|
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("WEBSHELL+ = %ld\n", gNumberOfWebShells);
|
2000-10-28 08:09:10 +04:00
|
|
|
#endif
|
1999-08-27 16:32:20 +04:00
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
NS_INIT_REFCNT();
|
2001-06-19 04:28:10 +04:00
|
|
|
mThread = nsnull;
|
2000-02-29 09:51:48 +03:00
|
|
|
InitFrameData();
|
1999-12-08 07:57:23 +03:00
|
|
|
mItemType = typeContent;
|
1999-09-23 07:27:53 +04:00
|
|
|
mCharsetReloadState = eCharsetReloadInit;
|
1999-08-31 18:49:21 +04:00
|
|
|
mHistoryState = nsnull;
|
2000-03-11 04:05:08 +03:00
|
|
|
mBounds.SetRect(0, 0, 0, 0);
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsWebShell::~nsWebShell()
|
|
|
|
{
|
2000-04-13 07:11:25 +04:00
|
|
|
Destroy();
|
1999-06-08 01:26:10 +04:00
|
|
|
|
1998-07-23 08:24:36 +04:00
|
|
|
// Stop any pending document loads and destroy the loader...
|
1998-08-01 10:45:43 +04:00
|
|
|
if (nsnull != mDocLoader) {
|
|
|
|
mDocLoader->Stop();
|
1999-01-14 09:44:23 +03:00
|
|
|
mDocLoader->SetContainer(nsnull);
|
2000-06-19 09:54:37 +04:00
|
|
|
mDocLoader->Destroy();
|
1998-08-01 10:45:43 +04:00
|
|
|
NS_RELEASE(mDocLoader);
|
|
|
|
}
|
1998-08-19 03:25:17 +04:00
|
|
|
// Cancel any timers that were set for this loader.
|
1999-08-04 01:48:40 +04:00
|
|
|
CancelRefreshURITimers();
|
1998-07-23 08:24:36 +04:00
|
|
|
|
1999-06-02 03:02:15 +04:00
|
|
|
++mRefCnt; // following releases can cause this destructor to be called
|
|
|
|
// recursively if the refcount is allowed to remain 0
|
|
|
|
|
1999-12-18 05:29:57 +03:00
|
|
|
mContentViewer=nsnull;
|
2000-03-11 04:05:08 +03:00
|
|
|
mDeviceContext=nsnull;
|
1998-07-19 01:43:02 +04:00
|
|
|
NS_IF_RELEASE(mContainer);
|
|
|
|
|
2000-02-14 09:48:39 +03:00
|
|
|
if (mScriptGlobal) {
|
2000-02-08 16:40:10 +03:00
|
|
|
mScriptGlobal->SetDocShell(nsnull);
|
2000-02-14 09:48:39 +03:00
|
|
|
mScriptGlobal = nsnull;
|
1998-08-07 08:45:03 +04:00
|
|
|
}
|
2000-02-14 09:48:39 +03:00
|
|
|
if (mScriptContext) {
|
1999-09-09 03:16:49 +04:00
|
|
|
mScriptContext->SetOwner(nsnull);
|
2000-02-14 09:48:39 +03:00
|
|
|
mScriptContext = nsnull;
|
1999-09-09 03:16:49 +04:00
|
|
|
}
|
1998-07-25 05:53:54 +04:00
|
|
|
|
2000-02-29 09:51:48 +03:00
|
|
|
InitFrameData();
|
1999-01-19 20:26:06 +03:00
|
|
|
|
2000-09-12 02:06:52 +04:00
|
|
|
#ifdef DEBUG
|
1999-09-07 02:59:11 +04:00
|
|
|
// We're counting the number of |nsWebShells| to help find leaks
|
|
|
|
--gNumberOfWebShells;
|
2000-10-29 02:17:53 +04:00
|
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("WEBSHELL- = %ld\n", gNumberOfWebShells);
|
2000-10-28 08:09:10 +04:00
|
|
|
#endif
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
2000-02-29 09:51:48 +03:00
|
|
|
void nsWebShell::InitFrameData()
|
1999-01-19 20:26:06 +03:00
|
|
|
{
|
2000-02-29 09:51:48 +03:00
|
|
|
SetMarginWidth(-1);
|
|
|
|
SetMarginHeight(-1);
|
1999-01-19 20:26:06 +03:00
|
|
|
}
|
|
|
|
|
2000-03-06 00:26:01 +03:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsWebShell, nsDocShell)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsWebShell, nsDocShell)
|
1998-07-19 01:43:02 +04:00
|
|
|
|
1999-11-23 13:08:32 +03:00
|
|
|
NS_INTERFACE_MAP_BEGIN(nsWebShell)
|
2000-03-06 00:26:01 +03:00
|
|
|
#if 0 // inherits from nsDocShell:
|
1999-11-23 13:08:32 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebShell)
|
2000-03-06 00:26:01 +03:00
|
|
|
#endif
|
1999-11-23 13:08:32 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIWebShell)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIWebShellServices)
|
1999-12-18 05:29:57 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIContentViewerContainer, nsIWebShell)
|
1999-11-23 13:08:32 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIWebShellContainer)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsILinkHandler)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIClipboardCommands)
|
2000-03-06 00:26:01 +03:00
|
|
|
#if 0 // inherits from nsDocShell:
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIScriptGlobalObjectOwner)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
|
1999-11-27 05:14:40 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIBaseWindow)
|
1999-11-30 07:32:09 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDocShell)
|
1999-12-03 13:57:59 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeItem)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeNode)
|
2000-02-14 09:48:39 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIWebNavigation)
|
2000-04-13 07:11:25 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIRefreshURI)
|
2000-02-29 09:51:48 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIScrollable)
|
2000-03-06 00:26:01 +03:00
|
|
|
#endif
|
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsDocShell)
|
1998-07-19 01:43:02 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-11-13 07:06:23 +03:00
|
|
|
nsWebShell::GetInterface(const nsIID &aIID, void** aInstancePtr)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
1999-11-13 07:06:23 +03:00
|
|
|
NS_ENSURE_ARG_POINTER(aInstancePtr);
|
2000-01-11 23:59:24 +03:00
|
|
|
nsresult rv = NS_OK;
|
2000-02-19 05:05:52 +03:00
|
|
|
*aInstancePtr = nsnull;
|
1998-07-19 01:43:02 +04:00
|
|
|
|
1999-11-13 07:06:23 +03:00
|
|
|
if(aIID.Equals(NS_GET_IID(nsILinkHandler)))
|
|
|
|
{
|
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsILinkHandler*, this);
|
1999-12-03 12:24:22 +03:00
|
|
|
NS_ADDREF((nsISupports*)*aInstancePtr);
|
1999-11-13 07:06:23 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-12-03 12:24:22 +03:00
|
|
|
else if(aIID.Equals(NS_GET_IID(nsIScriptGlobalObjectOwner)))
|
1999-11-13 07:06:23 +03:00
|
|
|
{
|
1999-12-03 12:24:22 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIScriptGlobalObjectOwner*, this);
|
|
|
|
NS_ADDREF((nsISupports*)*aInstancePtr);
|
1999-11-13 07:06:23 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-12-03 12:24:22 +03:00
|
|
|
else if(aIID.Equals(NS_GET_IID(nsIScriptGlobalObject)))
|
|
|
|
{
|
2000-02-14 09:48:39 +03:00
|
|
|
NS_ENSURE_SUCCESS(EnsureScriptEnvironment(), NS_ERROR_FAILURE);
|
1999-12-03 12:24:22 +03:00
|
|
|
*aInstancePtr = mScriptGlobal;
|
|
|
|
NS_ADDREF((nsISupports*)*aInstancePtr);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 20:46:42 +04:00
|
|
|
else if(aIID.Equals(NS_GET_IID(nsIDOMWindowInternal)) ||
|
|
|
|
aIID.Equals(NS_GET_IID(nsIDOMWindow)))
|
|
|
|
|
2000-02-08 16:40:10 +03:00
|
|
|
{
|
2000-02-14 09:48:39 +03:00
|
|
|
NS_ENSURE_SUCCESS(EnsureScriptEnvironment(), NS_ERROR_FAILURE);
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 20:46:42 +04:00
|
|
|
NS_ENSURE_SUCCESS(mScriptGlobal->QueryInterface(aIID, aInstancePtr),
|
|
|
|
NS_ERROR_FAILURE);
|
2000-02-08 16:40:10 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-07-28 03:08:52 +04:00
|
|
|
|
2000-01-11 23:59:24 +03:00
|
|
|
if (!*aInstancePtr || NS_FAILED(rv))
|
2000-03-08 03:40:49 +03:00
|
|
|
return nsDocShell::GetInterface(aIID,aInstancePtr);
|
2000-01-11 23:59:24 +03:00
|
|
|
else
|
|
|
|
return rv;
|
1999-11-13 07:06:23 +03:00
|
|
|
}
|
1998-07-28 03:08:52 +04:00
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
NS_IMETHODIMP
|
2000-03-01 01:35:33 +03:00
|
|
|
nsWebShell::SetupNewViewer(nsIContentViewer* aViewer)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
2000-03-01 01:35:33 +03:00
|
|
|
NS_ENSURE_SUCCESS(nsDocShell::SetupNewViewer(aViewer), NS_ERROR_FAILURE);
|
2000-07-28 09:55:54 +04:00
|
|
|
|
1999-08-31 18:49:21 +04:00
|
|
|
// If the history state has been set by session history,
|
|
|
|
// set it on the pres shell now that we have a content
|
|
|
|
// viewer.
|
2000-03-01 01:35:33 +03:00
|
|
|
if(mContentViewer && mHistoryState)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDocumentViewer> docv(do_QueryInterface(mContentViewer));
|
|
|
|
if(docv)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
docv->GetPresShell(*getter_AddRefs(shell));
|
|
|
|
if(shell)
|
|
|
|
shell->SetHistoryState((nsILayoutHistoryState*)mHistoryState);
|
|
|
|
}
|
1999-08-31 18:49:21 +04:00
|
|
|
}
|
2000-03-01 01:35:33 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-07-19 01:43:02 +04:00
|
|
|
|
2000-03-01 01:35:33 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::Embed(nsIContentViewer* aContentViewer,
|
|
|
|
const char* aCommand,
|
|
|
|
nsISupports* aExtraInfo)
|
|
|
|
{
|
2000-06-30 01:48:18 +04:00
|
|
|
return nsDocShell::Embed(aContentViewer, aCommand, aExtraInfo);
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::SetContainer(nsIWebShellContainer* aContainer)
|
|
|
|
{
|
|
|
|
NS_IF_RELEASE(mContainer);
|
|
|
|
mContainer = aContainer;
|
1999-11-18 10:06:39 +03:00
|
|
|
NS_IF_ADDREF(mContainer);
|
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::GetContainer(nsIWebShellContainer*& aResult)
|
|
|
|
{
|
|
|
|
aResult = mContainer;
|
|
|
|
NS_IF_ADDREF(mContainer);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-11-16 23:06:12 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::GetTopLevelWindow(nsIWebShellContainer** aTopLevelWindow)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aTopLevelWindow);
|
1999-11-17 07:19:39 +03:00
|
|
|
*aTopLevelWindow = nsnull;
|
1999-11-16 23:06:12 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIWebShell> rootWebShell;
|
|
|
|
|
|
|
|
GetRootWebShellEvenIfChrome(getter_AddRefs(rootWebShell));
|
1999-11-17 07:19:39 +03:00
|
|
|
if(!rootWebShell)
|
|
|
|
return NS_OK;
|
1999-11-16 23:06:12 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIWebShellContainer> rootContainer;
|
|
|
|
rootWebShell->GetContainer(*aTopLevelWindow);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
nsEventStatus PR_CALLBACK
|
|
|
|
nsWebShell::HandleEvent(nsGUIEvent *aEvent)
|
1999-09-07 02:59:11 +04:00
|
|
|
{
|
1998-07-19 01:43:02 +04:00
|
|
|
return nsEventStatus_eIgnore;
|
|
|
|
}
|
|
|
|
|
1998-10-02 22:44:56 +04:00
|
|
|
NS_IMETHODIMP
|
1998-07-19 05:18:40 +04:00
|
|
|
nsWebShell::GetRootWebShell(nsIWebShell*& aResult)
|
|
|
|
{
|
1999-12-18 05:29:57 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> top;
|
|
|
|
GetSameTypeRootTreeItem(getter_AddRefs(top));
|
|
|
|
nsCOMPtr<nsIWebShell> topAsWebShell(do_QueryInterface(top));
|
|
|
|
aResult = topAsWebShell;
|
|
|
|
NS_IF_ADDREF(aResult);
|
|
|
|
return NS_OK;
|
1998-07-19 05:18:40 +04:00
|
|
|
}
|
|
|
|
|
1999-11-16 23:06:12 +03:00
|
|
|
void
|
|
|
|
nsWebShell::GetRootWebShellEvenIfChrome(nsIWebShell** aResult)
|
1999-04-16 12:15:04 +04:00
|
|
|
{
|
1999-12-18 05:29:57 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> top;
|
|
|
|
GetRootTreeItem(getter_AddRefs(top));
|
|
|
|
nsCOMPtr<nsIWebShell> topAsWebShell(do_QueryInterface(top));
|
|
|
|
*aResult = topAsWebShell;
|
1999-11-16 23:06:12 +03:00
|
|
|
NS_IF_ADDREF(*aResult);
|
1999-04-16 12:15:04 +04:00
|
|
|
}
|
|
|
|
|
2000-07-19 03:13:07 +04:00
|
|
|
/*
|
1998-07-19 01:43:02 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::SetParent(nsIWebShell* aParent)
|
|
|
|
{
|
1999-12-03 13:57:59 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentAsTreeItem(do_QueryInterface(aParent));
|
|
|
|
|
|
|
|
mParent = parentAsTreeItem.get();
|
1999-11-30 07:32:09 +03:00
|
|
|
return NS_OK;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::GetParent(nsIWebShell*& aParent)
|
1999-04-16 12:15:04 +04:00
|
|
|
{
|
1999-12-08 07:57:23 +03:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parent;
|
|
|
|
NS_ENSURE_SUCCESS(GetSameTypeParent(getter_AddRefs(parent)), NS_ERROR_FAILURE);
|
1999-04-16 12:15:04 +04:00
|
|
|
|
1999-12-08 07:57:23 +03:00
|
|
|
if(parent)
|
|
|
|
parent->QueryInterface(NS_GET_IID(nsIWebShell), (void**)&aParent);
|
|
|
|
else
|
|
|
|
aParent = nsnull;
|
|
|
|
return NS_OK;
|
1999-04-16 12:15:04 +04:00
|
|
|
}
|
2000-07-19 03:13:07 +04:00
|
|
|
*/
|
1999-10-26 02:20:10 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::GetReferrer(nsIURI **aReferrer)
|
|
|
|
{
|
2000-02-24 07:16:17 +03:00
|
|
|
*aReferrer = mReferrerURI;
|
|
|
|
NS_IF_ADDREF(*aReferrer);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsWebShell::SetReferrer(const PRUnichar* aReferrer)
|
|
|
|
{
|
2001-05-19 15:27:30 +04:00
|
|
|
NS_NewURI(getter_AddRefs(mReferrerURI), nsDependentString(aReferrer), nsnull);
|
1999-10-26 02:20:10 +04:00
|
|
|
}
|
|
|
|
|
1999-06-15 02:11:47 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::SetURL(const PRUnichar* aURL)
|
|
|
|
{
|
2000-03-04 01:55:40 +03:00
|
|
|
nsCOMPtr<nsIURI> uri;
|
2001-05-19 15:27:30 +04:00
|
|
|
NS_ENSURE_SUCCESS(NS_NewURI(getter_AddRefs(uri), nsDependentString(aURL),
|
2000-08-23 21:27:06 +04:00
|
|
|
nsnull),
|
2000-03-04 01:55:40 +03:00
|
|
|
NS_ERROR_FAILURE);
|
|
|
|
SetCurrentURI(uri);
|
1999-06-15 02:11:47 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-08-15 03:08:54 +04:00
|
|
|
/**
|
|
|
|
* Document Load methods
|
|
|
|
*/
|
1999-09-07 02:59:11 +04:00
|
|
|
NS_IMETHODIMP
|
1998-08-15 03:08:54 +04:00
|
|
|
nsWebShell::GetDocumentLoader(nsIDocumentLoader*& aResult)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
1998-08-15 03:08:54 +04:00
|
|
|
aResult = mDocLoader;
|
|
|
|
NS_IF_ADDREF(mDocLoader);
|
|
|
|
return (nsnull != mDocLoader) ? NS_OK : NS_ERROR_FAILURE;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
1998-08-15 03:08:54 +04:00
|
|
|
//----------------------------------------
|
|
|
|
|
|
|
|
// History methods
|
|
|
|
|
2000-04-16 15:18:41 +04:00
|
|
|
NS_IMETHODIMP nsWebShell::GoTo(PRInt32 aIndex)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
2000-04-16 15:18:41 +04:00
|
|
|
NS_ENSURE_STATE(mSessionHistory);
|
|
|
|
NS_ENSURE_TRUE(!IsFrame(), NS_ERROR_FAILURE);
|
2001-03-28 07:35:38 +04:00
|
|
|
nsCOMPtr<nsIHistoryEntry> entry;
|
1998-07-19 01:43:02 +04:00
|
|
|
|
2001-03-28 07:35:38 +04:00
|
|
|
mSessionHistory->GetEntryAtIndex(aIndex, PR_TRUE, getter_AddRefs(entry));
|
2000-04-16 15:18:41 +04:00
|
|
|
NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
|
2001-03-28 07:35:38 +04:00
|
|
|
nsCOMPtr<nsISHEntry> shEntry(do_QueryInterface(entry));
|
|
|
|
NS_ENSURE_TRUE(shEntry, NS_ERROR_FAILURE);
|
2000-04-12 03:52:28 +04:00
|
|
|
|
2001-03-28 07:35:38 +04:00
|
|
|
NS_ENSURE_SUCCESS(LoadHistoryEntry(shEntry, LOAD_HISTORY), NS_ERROR_FAILURE);
|
1999-08-09 04:03:12 +04:00
|
|
|
|
2000-04-16 15:18:41 +04:00
|
|
|
return NS_OK;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
1999-01-29 02:13:48 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::GetHistoryLength(PRInt32& aResult)
|
|
|
|
{
|
2000-04-16 15:18:41 +04:00
|
|
|
NS_ENSURE_STATE(mSessionHistory);
|
|
|
|
NS_ENSURE_TRUE(!IsFrame(), NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(mSessionHistory->GetCount(&aResult), NS_ERROR_FAILURE);
|
|
|
|
return NS_OK;
|
1999-01-29 02:13:48 +03:00
|
|
|
}
|
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::GetHistoryIndex(PRInt32& aResult)
|
|
|
|
{
|
2000-04-16 15:18:41 +04:00
|
|
|
NS_ENSURE_STATE(mSessionHistory);
|
|
|
|
NS_ENSURE_TRUE(!IsFrame(), NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(mSessionHistory->GetIndex(&aResult), NS_ERROR_FAILURE);
|
|
|
|
return NS_OK;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
1998-07-23 03:40:54 +04:00
|
|
|
NS_IMETHODIMP
|
2001-10-09 00:08:30 +04:00
|
|
|
nsWebShell::GetURL(PRInt32 aIndex, PRUnichar** aURLResult)
|
2000-04-16 15:18:41 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_STATE(mSessionHistory);
|
|
|
|
NS_ENSURE_TRUE(!IsFrame(), NS_ERROR_FAILURE);
|
1998-07-23 03:40:54 +04:00
|
|
|
|
2001-03-28 07:35:38 +04:00
|
|
|
nsCOMPtr<nsIHistoryEntry> entry;
|
2000-04-16 15:18:41 +04:00
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(mSessionHistory->GetEntryAtIndex(aIndex, PR_TRUE,
|
|
|
|
getter_AddRefs(entry)), NS_ERROR_FAILURE);
|
|
|
|
NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
|
|
|
|
entry->GetURI(getter_AddRefs(uri));
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
|
1998-07-19 01:43:02 +04:00
|
|
|
|
2000-04-16 15:18:41 +04:00
|
|
|
nsXPIDLCString spec;
|
|
|
|
uri->GetSpec(getter_Copies(spec));
|
|
|
|
|
2001-09-29 12:28:41 +04:00
|
|
|
*aURLResult = ToNewUnicode(NS_ConvertASCIItoUCS2(spec));
|
2000-04-16 15:18:41 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-08-09 04:03:12 +04:00
|
|
|
|
1998-07-19 05:18:40 +04:00
|
|
|
//----------------------------------------
|
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// WebShell container implementation
|
|
|
|
|
1999-08-31 18:49:21 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::SetHistoryState(nsISupports* aLayoutHistoryState)
|
|
|
|
{
|
|
|
|
mHistoryState = aLayoutHistoryState;
|
1999-09-07 02:59:11 +04:00
|
|
|
return NS_OK;
|
1999-08-31 18:49:21 +04:00
|
|
|
}
|
|
|
|
|
1999-05-06 05:58:48 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Web Shell Services API
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-09-07 02:59:11 +04:00
|
|
|
nsWebShell::LoadDocument(const char* aURL,
|
|
|
|
const char* aCharset,
|
1999-05-06 07:54:40 +04:00
|
|
|
nsCharsetSource aSource)
|
1999-05-06 05:58:48 +04:00
|
|
|
{
|
1999-05-19 04:23:03 +04:00
|
|
|
// XXX hack. kee the aCharset and aSource wait to pick it up
|
1999-11-19 10:35:27 +03:00
|
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
|
|
NS_ENSURE_SUCCESS(GetContentViewer(getter_AddRefs(cv)), NS_ERROR_FAILURE);
|
|
|
|
if (cv)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIMarkupDocumentViewer> muDV = do_QueryInterface(cv);
|
|
|
|
if (muDV)
|
1999-09-23 07:27:53 +04:00
|
|
|
{
|
1999-11-19 10:35:27 +03:00
|
|
|
nsCharsetSource hint;
|
|
|
|
muDV->GetHintCharacterSetSource((PRInt32 *)(&hint));
|
|
|
|
if( aSource > hint )
|
|
|
|
{
|
2001-06-30 15:02:25 +04:00
|
|
|
muDV->SetHintCharacterSet(NS_ConvertASCIItoUCS2(aCharset).get());
|
1999-11-19 10:35:27 +03:00
|
|
|
muDV->SetHintCharacterSetSource((PRInt32)aSource);
|
|
|
|
if(eCharsetReloadRequested != mCharsetReloadState)
|
|
|
|
{
|
|
|
|
mCharsetReloadState = eCharsetReloadRequested;
|
2001-06-30 15:02:25 +04:00
|
|
|
LoadURI(NS_ConvertASCIItoUCS2(aURL).get(), LOAD_FLAGS_NONE);
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
}
|
1999-09-23 07:27:53 +04:00
|
|
|
}
|
|
|
|
}
|
1999-05-06 05:58:48 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-06-30 02:12:14 +04:00
|
|
|
//This functions is only called when a new charset is detected in loading a document.
|
|
|
|
//Its name should be changed to "CharsetReloadDocument"
|
1999-09-07 02:59:11 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::ReloadDocument(const char* aCharset,
|
2000-03-27 06:35:05 +04:00
|
|
|
nsCharsetSource aSource)
|
1999-09-07 02:59:11 +04:00
|
|
|
{
|
1999-05-29 01:32:29 +04:00
|
|
|
|
1999-09-07 02:59:11 +04:00
|
|
|
// XXX hack. kee the aCharset and aSource wait to pick it up
|
1999-11-19 10:35:27 +03:00
|
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
|
|
NS_ENSURE_SUCCESS(GetContentViewer(getter_AddRefs(cv)), NS_ERROR_FAILURE);
|
|
|
|
if (cv)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIMarkupDocumentViewer> muDV = do_QueryInterface(cv);
|
|
|
|
if (muDV)
|
|
|
|
{
|
|
|
|
nsCharsetSource hint;
|
|
|
|
muDV->GetHintCharacterSetSource((PRInt32 *)(&hint));
|
|
|
|
if( aSource > hint )
|
|
|
|
{
|
2001-06-30 15:02:25 +04:00
|
|
|
muDV->SetHintCharacterSet(NS_ConvertASCIItoUCS2(aCharset).get());
|
1999-11-19 10:35:27 +03:00
|
|
|
muDV->SetHintCharacterSetSource((PRInt32)aSource);
|
2001-07-03 02:36:08 +04:00
|
|
|
if(eCharsetReloadRequested != mCharsetReloadState)
|
|
|
|
{
|
|
|
|
mCharsetReloadState = eCharsetReloadRequested;
|
|
|
|
return Reload(LOAD_FLAGS_CHARSET_CHANGE);
|
|
|
|
}
|
1999-11-19 10:35:27 +03:00
|
|
|
}
|
|
|
|
}
|
1999-09-23 07:27:53 +04:00
|
|
|
}
|
2001-09-21 06:38:37 +04:00
|
|
|
//return failer if this request is not accepted due to mCharsetReloadState
|
|
|
|
return NS_ERROR_WEBSHELL_REQUEST_REJECTED;
|
1999-05-19 04:23:03 +04:00
|
|
|
}
|
|
|
|
|
1999-08-18 05:39:20 +04:00
|
|
|
|
1999-05-06 05:58:48 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::StopDocumentLoad(void)
|
|
|
|
{
|
1999-09-23 07:27:53 +04:00
|
|
|
if(eCharsetReloadRequested != mCharsetReloadState)
|
|
|
|
{
|
2001-09-21 06:38:37 +04:00
|
|
|
Stop(nsIWebNavigation::STOP_ALL);
|
|
|
|
return NS_OK;
|
1999-09-23 07:27:53 +04:00
|
|
|
}
|
2001-09-21 06:38:37 +04:00
|
|
|
//return failer if this request is not accepted due to mCharsetReloadState
|
|
|
|
return NS_ERROR_WEBSHELL_REQUEST_REJECTED;
|
1999-05-06 05:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::SetRendering(PRBool aRender)
|
|
|
|
{
|
1999-09-23 07:27:53 +04:00
|
|
|
if(eCharsetReloadRequested != mCharsetReloadState)
|
|
|
|
{
|
|
|
|
if (mContentViewer) {
|
|
|
|
mContentViewer->SetEnableRendering(aRender);
|
2001-09-21 06:38:37 +04:00
|
|
|
return NS_OK;
|
1999-09-23 07:27:53 +04:00
|
|
|
}
|
1999-05-07 23:25:58 +04:00
|
|
|
}
|
2001-09-21 06:38:37 +04:00
|
|
|
//return failer if this request is not accepted due to mCharsetReloadState
|
|
|
|
return NS_ERROR_WEBSHELL_REQUEST_REJECTED;
|
1999-05-06 05:58:48 +04:00
|
|
|
}
|
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// WebShell link handling
|
|
|
|
|
|
|
|
struct OnLinkClickEvent : public PLEvent {
|
1998-11-14 03:21:19 +03:00
|
|
|
OnLinkClickEvent(nsWebShell* aHandler, nsIContent* aContent,
|
|
|
|
nsLinkVerb aVerb, const PRUnichar* aURLSpec,
|
2000-09-05 23:03:56 +04:00
|
|
|
const PRUnichar* aTargetSpec, nsIInputStream* aPostDataStream = 0,
|
|
|
|
nsIInputStream* aHeadersDataStream = 0);
|
1998-07-19 01:43:02 +04:00
|
|
|
~OnLinkClickEvent();
|
|
|
|
|
|
|
|
void HandleEvent() {
|
2001-06-30 15:02:25 +04:00
|
|
|
mHandler->HandleLinkClickEvent(mContent, mVerb, mURLSpec->get(),
|
|
|
|
mTargetSpec->get(), mPostDataStream,
|
2000-09-05 23:03:56 +04:00
|
|
|
mHeadersDataStream);
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsWebShell* mHandler;
|
|
|
|
nsString* mURLSpec;
|
|
|
|
nsString* mTargetSpec;
|
1999-08-04 00:51:41 +04:00
|
|
|
nsIInputStream* mPostDataStream;
|
2000-09-05 23:03:56 +04:00
|
|
|
nsIInputStream* mHeadersDataStream;
|
1999-08-04 00:51:41 +04:00
|
|
|
nsIContent* mContent;
|
|
|
|
nsLinkVerb mVerb;
|
1998-07-19 01:43:02 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static void PR_CALLBACK HandlePLEvent(OnLinkClickEvent* aEvent)
|
|
|
|
{
|
|
|
|
aEvent->HandleEvent();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void PR_CALLBACK DestroyPLEvent(OnLinkClickEvent* aEvent)
|
|
|
|
{
|
|
|
|
delete aEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
OnLinkClickEvent::OnLinkClickEvent(nsWebShell* aHandler,
|
1998-11-14 03:21:19 +03:00
|
|
|
nsIContent *aContent,
|
|
|
|
nsLinkVerb aVerb,
|
1998-08-15 03:08:54 +04:00
|
|
|
const PRUnichar* aURLSpec,
|
|
|
|
const PRUnichar* aTargetSpec,
|
2000-09-05 23:03:56 +04:00
|
|
|
nsIInputStream* aPostDataStream,
|
|
|
|
nsIInputStream* aHeadersDataStream)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
|
|
|
mHandler = aHandler;
|
|
|
|
NS_ADDREF(aHandler);
|
|
|
|
mURLSpec = new nsString(aURLSpec);
|
|
|
|
mTargetSpec = new nsString(aTargetSpec);
|
1999-08-04 00:51:41 +04:00
|
|
|
mPostDataStream = aPostDataStream;
|
|
|
|
NS_IF_ADDREF(mPostDataStream);
|
2000-09-05 23:03:56 +04:00
|
|
|
mHeadersDataStream = aHeadersDataStream;
|
|
|
|
NS_IF_ADDREF(mHeadersDataStream);
|
1998-11-14 03:21:19 +03:00
|
|
|
mContent = aContent;
|
|
|
|
NS_IF_ADDREF(mContent);
|
|
|
|
mVerb = aVerb;
|
1999-09-07 02:59:11 +04:00
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
PL_InitEvent(this, nsnull,
|
|
|
|
(PLHandleEventProc) ::HandlePLEvent,
|
|
|
|
(PLDestroyEventProc) ::DestroyPLEvent);
|
|
|
|
|
2001-06-19 04:28:10 +04:00
|
|
|
nsCOMPtr<nsIEventQueue> eventQueue;
|
|
|
|
aHandler->GetEventQueue(getter_AddRefs(eventQueue));
|
|
|
|
NS_ASSERTION(eventQueue, "no event queue");
|
|
|
|
if (eventQueue)
|
|
|
|
eventQueue->PostEvent(this);
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
OnLinkClickEvent::~OnLinkClickEvent()
|
|
|
|
{
|
1998-11-14 03:21:19 +03:00
|
|
|
NS_IF_RELEASE(mContent);
|
1998-07-19 01:43:02 +04:00
|
|
|
NS_IF_RELEASE(mHandler);
|
1999-08-04 00:51:41 +04:00
|
|
|
NS_IF_RELEASE(mPostDataStream);
|
2000-09-05 23:03:56 +04:00
|
|
|
NS_IF_RELEASE(mHeadersDataStream);
|
1998-07-19 01:43:02 +04:00
|
|
|
if (nsnull != mURLSpec) delete mURLSpec;
|
|
|
|
if (nsnull != mTargetSpec) delete mTargetSpec;
|
1999-09-07 02:59:11 +04:00
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-09-07 02:59:11 +04:00
|
|
|
nsWebShell::OnLinkClick(nsIContent* aContent,
|
1998-11-14 03:21:19 +03:00
|
|
|
nsLinkVerb aVerb,
|
1998-08-15 03:08:54 +04:00
|
|
|
const PRUnichar* aURLSpec,
|
|
|
|
const PRUnichar* aTargetSpec,
|
2000-09-05 23:03:56 +04:00
|
|
|
nsIInputStream* aPostDataStream,
|
|
|
|
nsIInputStream* aHeadersDataStream)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
1998-07-25 01:03:33 +04:00
|
|
|
OnLinkClickEvent* ev;
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
1999-09-07 02:59:11 +04:00
|
|
|
ev = new OnLinkClickEvent(this, aContent, aVerb, aURLSpec,
|
2000-09-05 23:03:56 +04:00
|
|
|
aTargetSpec, aPostDataStream, aHeadersDataStream);
|
1998-07-25 01:03:33 +04:00
|
|
|
if (nsnull == ev) {
|
|
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
return rv;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
2001-06-19 04:28:10 +04:00
|
|
|
nsresult
|
|
|
|
nsWebShell::GetEventQueue(nsIEventQueue **aQueue)
|
1999-01-05 12:46:33 +03:00
|
|
|
{
|
2001-06-19 04:28:10 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aQueue);
|
|
|
|
*aQueue = 0;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIEventQueueService> eventService(do_GetService(kEventQueueServiceCID));
|
|
|
|
if (eventService)
|
|
|
|
eventService->GetThreadEventQueue(mThread, aQueue);
|
|
|
|
return *aQueue ? NS_OK : NS_ERROR_FAILURE;
|
1999-01-05 12:46:33 +03:00
|
|
|
}
|
|
|
|
|
1998-07-19 01:43:02 +04:00
|
|
|
void
|
1998-11-14 03:21:19 +03:00
|
|
|
nsWebShell::HandleLinkClickEvent(nsIContent *aContent,
|
|
|
|
nsLinkVerb aVerb,
|
|
|
|
const PRUnichar* aURLSpec,
|
1998-08-15 03:08:54 +04:00
|
|
|
const PRUnichar* aTargetSpec,
|
2000-09-05 23:03:56 +04:00
|
|
|
nsIInputStream* aPostDataStream,
|
|
|
|
nsIInputStream* aHeadersDataStream)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
2001-05-14 06:16:27 +04:00
|
|
|
nsresult rv;
|
|
|
|
nsAutoString target(aTargetSpec);
|
1998-11-14 03:21:19 +03:00
|
|
|
|
|
|
|
switch(aVerb) {
|
|
|
|
case eLinkVerb_New:
|
2001-05-14 06:16:27 +04:00
|
|
|
target.AssignWithConversion("_blank");
|
1998-11-14 03:21:19 +03:00
|
|
|
// Fall into replace case
|
2000-04-01 04:39:15 +04:00
|
|
|
case eLinkVerb_Undefined:
|
|
|
|
// Fall through, this seems like the most reasonable action
|
1999-09-07 02:59:11 +04:00
|
|
|
case eLinkVerb_Replace:
|
1998-11-14 03:21:19 +03:00
|
|
|
{
|
2000-02-15 07:05:04 +03:00
|
|
|
// for now, just hack the verb to be view-link-clicked
|
|
|
|
// and down in the load document code we'll detect this and
|
|
|
|
// set the correct uri loader command
|
2000-04-16 15:18:41 +04:00
|
|
|
nsCOMPtr<nsIURI> uri;
|
2001-05-19 15:27:30 +04:00
|
|
|
NS_NewURI(getter_AddRefs(uri), nsDependentString(aURLSpec), nsnull);
|
2000-04-16 15:18:41 +04:00
|
|
|
|
2000-09-11 16:38:54 +04:00
|
|
|
// No URI object? This may indicate the URLspec is for an
|
|
|
|
// unrecognized protocol. Embedders might still be interested
|
|
|
|
// in handling the click, so we fire a notification before
|
|
|
|
// throwing the click away.
|
|
|
|
if (!uri && NS_SUCCEEDED(EnsureContentListener()))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIURIContentListener> listener = do_QueryInterface(mContentListener);
|
|
|
|
nsCAutoString spec; spec.AssignWithConversion(aURLSpec);
|
|
|
|
PRBool abort = PR_FALSE;
|
|
|
|
uri = do_CreateInstance(kSimpleURICID, &rv);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "can't create simple uri");
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
2001-10-27 11:43:56 +04:00
|
|
|
rv = uri->SetSpec(spec.get());
|
2000-09-11 16:38:54 +04:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "spec is invalid");
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
2001-05-14 06:16:27 +04:00
|
|
|
listener->OnStartURIOpen(uri, &abort);
|
2000-09-11 16:38:54 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2001-05-14 06:16:27 +04:00
|
|
|
rv = InternalLoad(uri, // New URI
|
|
|
|
mCurrentURI, // Referer URI
|
|
|
|
nsnull, // No onwer
|
|
|
|
PR_TRUE, // Inherit owner from document
|
2001-06-30 15:02:25 +04:00
|
|
|
target.get(), // Window target
|
2001-05-14 06:16:27 +04:00
|
|
|
aPostDataStream, // Post data stream
|
|
|
|
aHeadersDataStream, // Headers stream
|
|
|
|
LOAD_LINK, // Load type
|
|
|
|
nsnull); // No SHEntry
|
1998-11-14 03:21:19 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case eLinkVerb_Embed:
|
2000-04-01 04:39:15 +04:00
|
|
|
// XXX TODO Should be similar to the HTML IMG ALT attribute handling
|
|
|
|
// in NS 4.x
|
1998-11-14 03:21:19 +03:00
|
|
|
default:
|
2000-04-01 04:39:15 +04:00
|
|
|
NS_ABORT_IF_FALSE(0,"unexpected link verb");
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1998-11-14 03:21:19 +03:00
|
|
|
nsWebShell::OnOverLink(nsIContent* aContent,
|
1998-08-15 03:08:54 +04:00
|
|
|
const PRUnichar* aURLSpec,
|
|
|
|
const PRUnichar* aTargetSpec)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
2000-04-01 04:39:15 +04:00
|
|
|
nsCOMPtr<nsIWebBrowserChrome> browserChrome(do_GetInterface(mTreeOwner));
|
2001-07-25 02:37:40 +04:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
if(browserChrome) {
|
|
|
|
nsCOMPtr<nsITextToSubURI> textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
PRUnichar *uStr;
|
|
|
|
nsString aSpec(aURLSpec);
|
|
|
|
PRInt32 pos = aSpec.FindChar(':');
|
|
|
|
nsAutoString scheme;
|
|
|
|
static const char kMailToURI[] = "mailto";
|
|
|
|
// If the scheme is mailtourl then should not convert from a document charset
|
|
|
|
if ((pos == (PRInt32)(sizeof kMailToURI - 1)) && (aSpec.Left(scheme, pos) != -1) &&
|
|
|
|
scheme.EqualsIgnoreCase(kMailToURI)) {
|
|
|
|
// use UTF-8 instead and apply URL escape.
|
|
|
|
rv = textToSubURI->UnEscapeAndConvert("UTF-8",NS_ConvertUCS2toUTF8(aURLSpec).get(), &uStr);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// use doc charset instead and apply URL escape.
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
nsDocShell::GetPresShell(getter_AddRefs(presShell));
|
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
presShell->GetDocument(getter_AddRefs(doc));
|
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
nsAutoString charset;
|
|
|
|
NS_ENSURE_SUCCESS(doc->GetDocumentCharacterSet(charset), NS_ERROR_FAILURE);
|
|
|
|
rv = textToSubURI->UnEscapeAndConvert(NS_ConvertUCS2toUTF8(charset.get()).get(),
|
|
|
|
NS_ConvertUCS2toUTF8(aURLSpec).get(), &uStr);
|
|
|
|
}
|
1998-10-02 22:44:56 +04:00
|
|
|
|
2001-07-25 02:37:40 +04:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = browserChrome->SetStatus(nsIWebBrowserChrome::STATUS_LINK, uStr);
|
|
|
|
nsMemory::Free(uStr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-07-28 03:17:53 +04:00
|
|
|
nsWebShell::GetLinkState(const char* aLinkURI, nsLinkState& aState)
|
1998-07-19 01:43:02 +04:00
|
|
|
{
|
2000-05-16 09:35:23 +04:00
|
|
|
aState = eLinkState_Unvisited;
|
1999-05-18 09:21:37 +04:00
|
|
|
|
2000-04-22 03:31:41 +04:00
|
|
|
if(mGlobalHistory)
|
|
|
|
{
|
2001-03-13 09:19:40 +03:00
|
|
|
PRBool isVisited;
|
|
|
|
NS_ENSURE_SUCCESS(mGlobalHistory->IsVisited(aLinkURI, &isVisited),
|
|
|
|
NS_ERROR_FAILURE);
|
|
|
|
if (isVisited)
|
|
|
|
aState = eLinkState_Visited;
|
2000-04-22 03:31:41 +04:00
|
|
|
}
|
1999-05-18 09:21:37 +04:00
|
|
|
|
2000-04-22 03:31:41 +04:00
|
|
|
return NS_OK;
|
1998-07-19 01:43:02 +04:00
|
|
|
}
|
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
|
2001-02-21 23:38:08 +03:00
|
|
|
nsIChannel* channel,
|
2000-12-21 02:18:03 +03:00
|
|
|
nsresult aStatus)
|
1999-03-29 13:21:01 +04:00
|
|
|
{
|
2000-12-21 02:18:03 +03:00
|
|
|
nsresult rv = NS_OK;
|
2000-04-22 03:31:41 +04:00
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
if(!channel)
|
2000-12-21 02:18:03 +03:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
2001-02-21 23:38:08 +03:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
nsCOMPtr<nsIURI> url;
|
2001-02-21 23:38:08 +03:00
|
|
|
rv = channel->GetURI(getter_AddRefs(url));
|
2000-12-21 02:18:03 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-12-16 00:26:12 +03:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
// clean up reload state for meta charset
|
|
|
|
if(eCharsetReloadRequested == mCharsetReloadState)
|
|
|
|
mCharsetReloadState = eCharsetReloadStopOrigional;
|
|
|
|
else
|
|
|
|
mCharsetReloadState = eCharsetReloadInit;
|
|
|
|
|
|
|
|
//
|
|
|
|
// one of many safeguards that prevent death and destruction if
|
|
|
|
// someone is so very very rude as to bring this window down
|
|
|
|
// during this load handler.
|
|
|
|
//
|
|
|
|
nsCOMPtr<nsIWebShell> kungFuDeathGrip(this);
|
2001-02-21 23:38:08 +03:00
|
|
|
nsDocShell::EndPageLoad(aProgress, channel, aStatus);
|
1999-09-07 02:59:11 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
//
|
|
|
|
// If the page load failed, then deal with the error condition...
|
|
|
|
// Errors are handled as follows:
|
2001-09-05 07:52:26 +04:00
|
|
|
// 1. Check to see if it a file not found error.
|
|
|
|
// 2. Send the URI to a keyword server (if enabled)
|
|
|
|
// 3. If the error was DNS failure, then add www and .com to the URI
|
2000-12-21 02:18:03 +03:00
|
|
|
// (if appropriate).
|
2001-09-05 07:52:26 +04:00
|
|
|
// 4. Throw an error dialog box...
|
2000-12-21 02:18:03 +03:00
|
|
|
//
|
2001-09-05 07:52:26 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
if(url && NS_FAILED(aStatus)) {
|
2001-09-05 07:52:26 +04:00
|
|
|
if (aStatus == NS_ERROR_FILE_NOT_FOUND) {
|
|
|
|
nsCOMPtr<nsIPrompt> prompter;
|
|
|
|
nsCOMPtr<nsIStringBundle> stringBundle;
|
|
|
|
GetPromptAndStringBundle(getter_AddRefs(prompter),
|
|
|
|
getter_AddRefs(stringBundle));
|
|
|
|
if (stringBundle && prompter) {
|
|
|
|
nsXPIDLString messageStr;
|
2001-11-14 04:33:42 +03:00
|
|
|
nsresult rv = stringBundle->GetStringFromName(NS_LITERAL_STRING("fileNotFound").get(),
|
2001-09-05 07:52:26 +04:00
|
|
|
getter_Copies(messageStr));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && messageStr) {
|
|
|
|
nsXPIDLCString spec;
|
|
|
|
url->GetPath(getter_Copies(spec));
|
|
|
|
|
|
|
|
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, (const char*)spec);
|
|
|
|
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
prompter->Alert(nsnull, msg);
|
|
|
|
nsTextFormatter::smprintf_free(msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
nsXPIDLCString host;
|
|
|
|
|
|
|
|
rv = url->GetHost(getter_Copies(host));
|
|
|
|
if (!host) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
CBufDescriptor buf((const char *)host, PR_TRUE, PL_strlen(host) + 1);
|
|
|
|
nsCAutoString hostStr(buf);
|
|
|
|
PRInt32 dotLoc = hostStr.FindChar('.');
|
|
|
|
|
|
|
|
nsXPIDLCString scheme;
|
|
|
|
url->GetScheme(getter_Copies(scheme));
|
|
|
|
|
|
|
|
PRUint32 schemeLen = PL_strlen((const char*)scheme);
|
|
|
|
CBufDescriptor schemeBuf((const char*)scheme, PR_TRUE, schemeLen+1, schemeLen);
|
|
|
|
nsCAutoString schemeStr(schemeBuf);
|
|
|
|
|
|
|
|
//
|
|
|
|
// First try sending the request to a keyword server (if enabled)...
|
|
|
|
//
|
|
|
|
if(aStatus == NS_ERROR_UNKNOWN_HOST ||
|
|
|
|
aStatus == NS_ERROR_CONNECTION_REFUSED ||
|
|
|
|
aStatus == NS_ERROR_NET_TIMEOUT)
|
|
|
|
{
|
|
|
|
PRBool keywordsEnabled = PR_FALSE;
|
|
|
|
|
|
|
|
if(mPrefs) {
|
|
|
|
rv = mPrefs->GetBoolPref("keyword.enabled", &keywordsEnabled);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
// we should only perform a keyword search under the following conditions:
|
|
|
|
// (0) Pref keyword.enabled is true
|
|
|
|
// (1) the url scheme is http (or https)
|
|
|
|
// (2) the url does not have a protocol scheme
|
|
|
|
// If we don't enforce such a policy, then we end up doing keyword searchs on urls
|
|
|
|
// we don't intend like imap, file, mailbox, etc. This could lead to a security
|
|
|
|
// problem where we send data to the keyword server that we shouldn't be.
|
|
|
|
// Someone needs to clean up keywords in general so we can determine on a per url basis
|
|
|
|
// if we want keywords enabled...this is just a bandaid...
|
|
|
|
if (keywordsEnabled && !schemeStr.IsEmpty() &&
|
|
|
|
(schemeStr.Find("http") != 0)) {
|
|
|
|
keywordsEnabled = PR_FALSE;
|
2000-04-22 03:31:41 +04:00
|
|
|
}
|
1999-09-07 02:59:11 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
if(keywordsEnabled && (-1 == dotLoc)) {
|
|
|
|
// only send non-qualified hosts to the keyword server
|
|
|
|
nsAutoString keywordSpec; keywordSpec.AssignWithConversion("keyword:");
|
|
|
|
keywordSpec.Append(NS_ConvertUTF8toUCS2(host));
|
2000-04-22 03:31:41 +04:00
|
|
|
|
2001-06-30 15:02:25 +04:00
|
|
|
return LoadURI(keywordSpec.get(), LOAD_FLAGS_NONE);
|
2000-12-21 02:18:03 +03:00
|
|
|
} // end keywordsEnabled
|
|
|
|
}
|
2000-02-02 01:31:20 +03:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
//
|
|
|
|
// Next, try rewriting the URI using our www.*.com trick
|
|
|
|
//
|
|
|
|
if(aStatus == NS_ERROR_UNKNOWN_HOST) {
|
|
|
|
// Try our www.*.com trick.
|
|
|
|
nsCAutoString retryHost;
|
|
|
|
|
|
|
|
|
|
|
|
if(schemeStr.Find("http") == 0) {
|
|
|
|
if(-1 == dotLoc) {
|
|
|
|
retryHost = "www.";
|
|
|
|
retryHost += hostStr;
|
|
|
|
retryHost += ".com";
|
|
|
|
} else {
|
|
|
|
PRInt32 hostLen = hostStr.Length();
|
|
|
|
if(((hostLen - dotLoc) == 3) || ((hostLen - dotLoc) == 4)) {
|
|
|
|
retryHost = "www.";
|
|
|
|
retryHost += hostStr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-04-22 03:31:41 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
if(!retryHost.IsEmpty()) {
|
|
|
|
// This seems evil, since it is modifying the original URL
|
2001-03-02 12:26:57 +03:00
|
|
|
rv = url->SetHost(retryHost.get());
|
2000-12-21 02:18:03 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
rv = url->GetSpec(getter_Copies(host));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
// reload the url
|
2001-06-30 15:02:25 +04:00
|
|
|
return LoadURI(NS_ConvertASCIItoUCS2(host).get(), LOAD_FLAGS_NONE);
|
2000-12-21 02:18:03 +03:00
|
|
|
} // retry
|
|
|
|
}
|
2000-04-22 03:31:41 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
//
|
|
|
|
// Well, none of the URI rewriting tricks worked :-(
|
|
|
|
// It is time to throw an error dialog box, and be done with it...
|
|
|
|
//
|
2000-01-12 02:11:32 +03:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
// Doc failed to load because the host was not found.
|
|
|
|
if(aStatus == NS_ERROR_UNKNOWN_HOST) {
|
|
|
|
// throw a DNS failure dialog
|
|
|
|
nsCOMPtr<nsIPrompt> prompter;
|
|
|
|
nsCOMPtr<nsIStringBundle> stringBundle;
|
|
|
|
|
|
|
|
rv = GetPromptAndStringBundle(getter_AddRefs(prompter),
|
|
|
|
getter_AddRefs(stringBundle));
|
|
|
|
if (!stringBundle) {
|
|
|
|
return rv;
|
|
|
|
}
|
1999-05-04 03:04:50 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
nsXPIDLString messageStr;
|
2001-11-14 04:33:42 +03:00
|
|
|
rv = stringBundle->GetStringFromName(NS_LITERAL_STRING("dnsNotFound").get(),
|
2000-12-21 02:18:03 +03:00
|
|
|
getter_Copies(messageStr));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-03-29 13:21:01 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
if (host) {
|
|
|
|
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, (const char*)host);
|
|
|
|
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
|
2000-04-29 04:07:40 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
prompter->Alert(nsnull, msg);
|
|
|
|
nsTextFormatter::smprintf_free(msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
|
|
// Doc failed to load because we couldn't connect to the server.
|
|
|
|
// throw a connection failure dialog
|
|
|
|
//
|
|
|
|
else if(aStatus == NS_ERROR_CONNECTION_REFUSED) {
|
|
|
|
PRInt32 port = -1;
|
|
|
|
|
|
|
|
rv = url->GetPort(&port);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPrompt> prompter;
|
|
|
|
nsCOMPtr<nsIStringBundle> stringBundle;
|
|
|
|
|
|
|
|
rv = GetPromptAndStringBundle(getter_AddRefs(prompter),
|
|
|
|
getter_AddRefs(stringBundle));
|
|
|
|
if (!stringBundle) {
|
|
|
|
return rv;
|
|
|
|
}
|
1999-01-14 09:44:23 +03:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
nsXPIDLString messageStr;
|
2001-11-14 04:33:42 +03:00
|
|
|
rv = stringBundle->GetStringFromName(NS_LITERAL_STRING("connectionFailure").get(),
|
2000-12-21 02:18:03 +03:00
|
|
|
getter_Copies(messageStr));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-04-07 01:01:04 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
// build up the host:port string.
|
|
|
|
nsCAutoString combo(host);
|
|
|
|
if (port > 0) {
|
|
|
|
combo.Append(':');
|
|
|
|
combo.AppendInt(port);
|
|
|
|
}
|
|
|
|
|
2001-03-02 12:26:57 +03:00
|
|
|
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, combo.get());
|
2000-12-21 02:18:03 +03:00
|
|
|
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
|
1999-03-29 13:21:01 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
prompter->Alert(nsnull, msg);
|
|
|
|
nsTextFormatter::smprintf_free(msg);
|
|
|
|
}
|
|
|
|
//
|
|
|
|
// Doc failed to load because the socket function timed out.
|
|
|
|
// throw a timeout dialog
|
|
|
|
//
|
|
|
|
else if(aStatus == NS_ERROR_NET_TIMEOUT) {
|
|
|
|
nsCOMPtr<nsIPrompt> prompter;
|
|
|
|
nsCOMPtr<nsIStringBundle> stringBundle;
|
|
|
|
|
|
|
|
rv = GetPromptAndStringBundle(getter_AddRefs(prompter),
|
|
|
|
getter_AddRefs(stringBundle));
|
|
|
|
if (!stringBundle) {
|
|
|
|
return rv;
|
|
|
|
}
|
1999-04-07 01:01:04 +04:00
|
|
|
|
2000-12-21 02:18:03 +03:00
|
|
|
nsXPIDLString messageStr;
|
2001-11-14 04:33:42 +03:00
|
|
|
rv = stringBundle->GetStringFromName(NS_LITERAL_STRING("netTimeout").get(),
|
2000-12-21 02:18:03 +03:00
|
|
|
getter_Copies(messageStr));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, (const char*)host);
|
|
|
|
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
prompter->Alert(nsnull, msg);
|
|
|
|
nsTextFormatter::smprintf_free(msg);
|
|
|
|
} // end NS_ERROR_NET_TIMEOUT
|
2001-04-14 02:20:33 +04:00
|
|
|
else if (aStatus == NS_ERROR_DOCUMENT_NOT_CACHED) {
|
|
|
|
/* A document that was requested to be fetched *only* from
|
|
|
|
* the cache is not in cache. May be this is one of those
|
|
|
|
* postdata results. Throw a dialog to the user,
|
|
|
|
* saying that the page has expired from cache and ask if
|
|
|
|
* they wish to refetch the page from the net.
|
|
|
|
*/
|
|
|
|
nsCOMPtr<nsIPrompt> prompter;
|
|
|
|
PRBool repost;
|
|
|
|
nsCOMPtr<nsIStringBundle> stringBundle;
|
|
|
|
GetPromptAndStringBundle(getter_AddRefs(prompter),
|
|
|
|
getter_AddRefs(stringBundle));
|
|
|
|
|
|
|
|
if (stringBundle && prompter) {
|
|
|
|
nsXPIDLString messageStr;
|
2001-11-14 04:33:42 +03:00
|
|
|
nsresult rv = stringBundle->GetStringFromName(NS_LITERAL_STRING("repost").get(),
|
2001-04-14 02:20:33 +04:00
|
|
|
getter_Copies(messageStr));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && messageStr) {
|
|
|
|
prompter->Confirm(nsnull, messageStr, &repost);
|
|
|
|
/* If the user pressed cancel in the dialog,
|
|
|
|
* return failure. Don't try to load the page with out
|
|
|
|
* the post data.
|
|
|
|
*/
|
|
|
|
if (!repost)
|
2001-09-22 04:10:58 +04:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
// The user wants to repost the data to the server.
|
|
|
|
// If the page was loaded due to a back/forward/go
|
|
|
|
// operation, update the session history index.
|
|
|
|
// This is similar to the updating done in
|
|
|
|
// nsDocShell::OnNewURI() for regular pages
|
|
|
|
nsCOMPtr<nsISHistory> rootSH=mSessionHistory;
|
|
|
|
if (!mSessionHistory) {
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> root;
|
|
|
|
//Get the root docshell
|
|
|
|
GetSameTypeRootTreeItem(getter_AddRefs(root));
|
|
|
|
if (root) {
|
|
|
|
// QI root to nsIWebNavigation
|
|
|
|
nsCOMPtr<nsIWebNavigation> rootAsWebnav(do_QueryInterface(root));
|
|
|
|
if (rootAsWebnav) {
|
|
|
|
// Get the handle to SH from the root docshell
|
|
|
|
rootAsWebnav->GetSessionHistory(getter_AddRefs(rootSH));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // mSessionHistory
|
|
|
|
|
|
|
|
if (rootSH && (mLoadType & LOAD_CMD_HISTORY)) {
|
|
|
|
nsCOMPtr<nsISHistoryInternal> shInternal(do_QueryInterface(rootSH));
|
|
|
|
if (shInternal)
|
|
|
|
shInternal->UpdateIndex();
|
|
|
|
}
|
2001-04-14 02:20:33 +04:00
|
|
|
/* The user does want to repost the data to the server.
|
|
|
|
* Initiate a new load again.
|
|
|
|
*/
|
|
|
|
/* Get the postdata if any from the channel */
|
|
|
|
nsCOMPtr<nsIInputStream> inputStream;
|
|
|
|
nsCOMPtr<nsIURI> referrer;
|
|
|
|
if (channel) {
|
2001-05-12 01:05:08 +04:00
|
|
|
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
|
2001-04-14 02:20:33 +04:00
|
|
|
|
|
|
|
if(httpChannel) {
|
|
|
|
httpChannel->GetReferrer(getter_AddRefs(referrer));
|
2001-09-05 07:52:26 +04:00
|
|
|
httpChannel->GetUploadStream(getter_AddRefs(inputStream));
|
2001-04-14 02:20:33 +04:00
|
|
|
}
|
|
|
|
}
|
2001-11-14 09:45:27 +03:00
|
|
|
nsCOMPtr<nsISeekableStream> postDataSeekable(do_QueryInterface(inputStream));
|
|
|
|
if (postDataSeekable)
|
2001-04-14 02:20:33 +04:00
|
|
|
{
|
2001-11-14 09:45:27 +03:00
|
|
|
postDataSeekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
|
2001-04-14 02:20:33 +04:00
|
|
|
}
|
2001-05-14 06:16:27 +04:00
|
|
|
InternalLoad(url, // URI
|
|
|
|
referrer, // Refering URI
|
|
|
|
nsnull, // Owner
|
|
|
|
PR_TRUE, // Inherit owner
|
|
|
|
nsnull, // No window target
|
|
|
|
inputStream, // Post data stream
|
|
|
|
nsnull, // No headers stream
|
|
|
|
LOAD_RELOAD_BYPASS_PROXY_AND_CACHE,// Load type
|
|
|
|
nsnull); // No SHEntry
|
2001-04-14 02:20:33 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-12-21 02:18:03 +03:00
|
|
|
} // if we have a host
|
1999-03-29 13:21:01 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-01-14 09:44:23 +03:00
|
|
|
|
2000-11-16 23:08:48 +03:00
|
|
|
//
|
|
|
|
// Routines for selection and clipboard
|
|
|
|
//
|
|
|
|
|
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark -
|
|
|
|
#endif
|
|
|
|
|
|
|
|
nsresult
|
2001-04-05 03:48:03 +04:00
|
|
|
nsWebShell::GetControllerForCommand ( const nsAReadableString & inCommand, nsIController** outController )
|
2000-11-16 23:08:48 +03:00
|
|
|
{
|
2001-04-05 03:48:03 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(outController);
|
|
|
|
*outController = nsnull;
|
|
|
|
|
2000-11-16 23:08:48 +03:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window ( do_QueryInterface(mScriptGlobal) );
|
|
|
|
if ( window ) {
|
|
|
|
nsCOMPtr<nsIFocusController> focusController;
|
|
|
|
rv = window->GetRootFocusController ( getter_AddRefs(focusController) );
|
|
|
|
if ( focusController )
|
2001-05-03 14:09:59 +04:00
|
|
|
rv = focusController->GetControllerForCommand ( inCommand, outController );
|
2000-11-16 23:08:48 +03:00
|
|
|
} // if window
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
} // GetControllerForCommand
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
2001-04-05 03:48:03 +04:00
|
|
|
nsWebShell::IsCommandEnabled ( const nsAReadableString & inCommand, PRBool* outEnabled )
|
2000-11-16 23:08:48 +03:00
|
|
|
{
|
2001-04-05 03:48:03 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(outEnabled);
|
|
|
|
*outEnabled = PR_FALSE;
|
|
|
|
|
2000-11-16 23:08:48 +03:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIController> controller;
|
|
|
|
rv = GetControllerForCommand ( inCommand, getter_AddRefs(controller) );
|
|
|
|
if ( controller )
|
2001-04-05 03:48:03 +04:00
|
|
|
rv = controller->IsCommandEnabled(inCommand, outEnabled);
|
2000-11-16 23:08:48 +03:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
2001-04-05 03:48:03 +04:00
|
|
|
nsWebShell::DoCommand ( const nsAReadableString & inCommand )
|
2000-11-16 23:08:48 +03:00
|
|
|
{
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIController> controller;
|
|
|
|
rv = GetControllerForCommand ( inCommand, getter_AddRefs(controller) );
|
|
|
|
if ( controller )
|
2001-04-05 03:48:03 +04:00
|
|
|
rv = controller->DoCommand(inCommand);
|
2000-11-16 23:08:48 +03:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-10-24 00:47:57 +04:00
|
|
|
NS_IMETHODIMP
|
1998-11-04 11:48:22 +03:00
|
|
|
nsWebShell::CanCutSelection(PRBool* aResult)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2001-05-10 06:35:00 +04:00
|
|
|
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_cut"), aResult );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1998-11-04 11:48:22 +03:00
|
|
|
nsWebShell::CanCopySelection(PRBool* aResult)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2001-05-10 06:35:00 +04:00
|
|
|
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copy"), aResult );
|
|
|
|
}
|
1998-11-04 11:48:22 +03:00
|
|
|
|
2001-05-10 06:35:00 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::CanCopyLinkLocation(PRBool* aResult)
|
|
|
|
{
|
|
|
|
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copyLink"), aResult );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-05-10 06:35:00 +04:00
|
|
|
nsWebShell::CanCopyImageLocation(PRBool* aResult)
|
1998-11-04 11:48:22 +03:00
|
|
|
{
|
2001-05-10 06:35:00 +04:00
|
|
|
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copyImageLocation"),
|
|
|
|
aResult );
|
|
|
|
}
|
1998-11-04 11:48:22 +03:00
|
|
|
|
2001-05-10 06:35:00 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::CanCopyImageContents(PRBool* aResult)
|
|
|
|
{
|
|
|
|
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_copyImageContents"),
|
|
|
|
aResult );
|
|
|
|
}
|
1998-11-04 11:48:22 +03:00
|
|
|
|
2001-05-10 06:35:00 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::CanPaste(PRBool* aResult)
|
|
|
|
{
|
|
|
|
return IsCommandEnabled ( NS_LITERAL_STRING("cmd_paste"), aResult );
|
1998-11-04 11:48:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::CutSelection(void)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2000-11-16 23:08:48 +03:00
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_cut") );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1998-11-04 11:48:22 +03:00
|
|
|
nsWebShell::CopySelection(void)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2000-11-16 23:08:48 +03:00
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_copy") );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-12-22 04:13:46 +03:00
|
|
|
nsWebShell::CopyLinkLocation(void)
|
|
|
|
{
|
2001-05-10 06:35:00 +04:00
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_copyLink") );
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::CopyImageLocation(void)
|
|
|
|
{
|
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_copyImageLocation") );
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::CopyImageContents(void)
|
|
|
|
{
|
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_copyImageContents") );
|
2000-12-22 04:13:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::Paste(void)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2000-11-16 23:08:48 +03:00
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_paste") );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1998-11-04 11:48:22 +03:00
|
|
|
nsWebShell::SelectAll(void)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2001-08-08 08:28:11 +04:00
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_selectAll") );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
2000-12-22 04:13:46 +03:00
|
|
|
|
|
|
|
//
|
|
|
|
// SelectNone
|
|
|
|
//
|
|
|
|
// Collapses the current selection, insertion point ends up at beginning
|
|
|
|
// of previous selection.
|
|
|
|
//
|
1998-10-24 00:47:57 +04:00
|
|
|
NS_IMETHODIMP
|
1998-11-04 11:48:22 +03:00
|
|
|
nsWebShell::SelectNone(void)
|
1998-10-24 00:47:57 +04:00
|
|
|
{
|
2001-08-09 13:24:26 +04:00
|
|
|
return DoCommand ( NS_LITERAL_STRING("cmd_selectNone") );
|
1998-10-24 00:47:57 +04:00
|
|
|
}
|
|
|
|
|
1999-05-19 04:23:03 +04:00
|
|
|
|
1998-10-24 00:47:57 +04:00
|
|
|
//----------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsWebShell::FindNext(const PRUnichar * aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound)
|
|
|
|
{
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2000-11-16 23:08:48 +03:00
|
|
|
#ifdef XP_MAC
|
|
|
|
#pragma mark -
|
|
|
|
#endif
|
|
|
|
|
1999-11-27 05:14:40 +03:00
|
|
|
//*****************************************************************************
|
|
|
|
// nsWebShell::nsIBaseWindow
|
|
|
|
//*****************************************************************************
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsWebShell::Create()
|
|
|
|
{
|
2001-06-19 04:28:10 +04:00
|
|
|
// Remember the current thread (in current and forseeable implementations,
|
|
|
|
// it'll just be the unique UI thread)
|
2000-03-11 04:05:08 +03:00
|
|
|
//
|
|
|
|
// Since this call must be made on the UI thread, we know the Event Queue
|
|
|
|
// will be associated with the current thread...
|
|
|
|
//
|
2001-06-19 04:28:10 +04:00
|
|
|
mThread = PR_GetCurrentThread();
|
2000-03-11 04:05:08 +03:00
|
|
|
|
2000-10-29 02:17:53 +04:00
|
|
|
WEB_TRACE(WEB_TRACE_CALLS,
|
|
|
|
("nsWebShell::Init: this=%p", this));
|
2000-03-11 04:05:08 +03:00
|
|
|
|
|
|
|
// HACK....force the uri loader to give us a load cookie for this webshell...then get it's
|
|
|
|
// doc loader and store it...as more of the docshell lands, we'll be able to get rid
|
|
|
|
// of this hack...
|
2000-09-14 03:57:52 +04:00
|
|
|
nsCOMPtr<nsIURILoader> uriLoader = do_GetService(NS_URI_LOADER_CONTRACTID);
|
2000-03-11 04:05:08 +03:00
|
|
|
uriLoader->GetDocumentLoaderForContext(NS_STATIC_CAST( nsISupports*, (nsIWebShell *) this), &mDocLoader);
|
|
|
|
|
|
|
|
// Set the webshell as the default IContentViewerContainer for the loader...
|
|
|
|
mDocLoader->SetContainer(NS_STATIC_CAST(nsIContentViewerContainer*, (nsIWebShell*)this));
|
|
|
|
|
2000-02-14 09:48:39 +03:00
|
|
|
return nsDocShell::Create();
|
1999-11-27 05:14:40 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsWebShell::Destroy()
|
|
|
|
{
|
2000-03-31 04:15:55 +04:00
|
|
|
nsDocShell::Destroy();
|
1999-11-27 05:14:40 +03:00
|
|
|
|
|
|
|
SetContainer(nsnull);
|
|
|
|
|
2000-03-31 04:15:55 +04:00
|
|
|
return NS_OK;
|
1999-11-27 05:14:40 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsWebShell::SetPositionAndSize(PRInt32 x, PRInt32 y, PRInt32 cx,
|
|
|
|
PRInt32 cy, PRBool fRepaint)
|
|
|
|
{
|
2000-03-11 04:05:08 +03:00
|
|
|
mBounds.SetRect(x, y, cx, cy);
|
|
|
|
return nsDocShell::SetPositionAndSize(x, y, cx, cy, fRepaint);
|
1999-12-02 12:43:07 +03:00
|
|
|
}
|
2000-03-11 05:57:39 +03:00
|
|
|
|
2000-03-11 04:05:08 +03:00
|
|
|
NS_IMETHODIMP nsWebShell::GetPositionAndSize(PRInt32* x, PRInt32* y,
|
|
|
|
PRInt32* cx, PRInt32* cy)
|
1999-11-27 05:14:40 +03:00
|
|
|
{
|
2000-03-11 04:05:08 +03:00
|
|
|
if(x)
|
|
|
|
*x = mBounds.x;
|
|
|
|
if(y)
|
|
|
|
*y = mBounds.y;
|
|
|
|
if(cx)
|
|
|
|
*cx = mBounds.width;
|
|
|
|
if(cy)
|
|
|
|
*cy = mBounds.height;
|
|
|
|
|
|
|
|
return NS_OK;
|
1999-11-27 05:14:40 +03:00
|
|
|
}
|
|
|
|
|
2000-09-12 02:06:52 +04:00
|
|
|
#ifdef DEBUG
|
2000-07-19 03:13:07 +04:00
|
|
|
unsigned long nsWebShell::gNumberOfWebShells = 0;
|
|
|
|
#endif
|