1998-04-13 20:24:54 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
1999-11-06 03:40:37 +00: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-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00: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-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1998-04-13 20:24:54 +00:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-11-06 03:40:37 +00:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
2000-02-02 22:24:56 +00:00
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
2000-05-02 23:07:11 +00:00
|
|
|
* IBM Corp.
|
1998-05-21 20:37:41 +00:00
|
|
|
*/
|
1999-08-24 07:38:00 +00:00
|
|
|
#define NS_IMPL_IDS
|
|
|
|
#include "nsICharsetAlias.h"
|
|
|
|
#undef NS_IMPL_IDS
|
|
|
|
|
1999-02-12 17:45:58 +00:00
|
|
|
#include "nsCOMPtr.h"
|
2001-03-12 22:41:28 +00:00
|
|
|
#include "nsIFileChannel.h"
|
1999-08-09 19:10:24 +00:00
|
|
|
#include "nsXPIDLString.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsHTMLDocument.h"
|
|
|
|
#include "nsIParser.h"
|
1999-07-14 15:33:48 +00:00
|
|
|
#include "nsIParserFilter.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIHTMLContentSink.h"
|
|
|
|
#include "nsHTMLParts.h"
|
|
|
|
#include "nsIHTMLStyleSheet.h"
|
1998-05-13 23:43:44 +00:00
|
|
|
#include "nsIHTMLCSSStyleSheet.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIStyleSet.h"
|
|
|
|
#include "nsHTMLAtoms.h"
|
2001-03-22 08:51:52 +00:00
|
|
|
#include "nsLayoutAtoms.h"
|
1998-11-11 11:55:32 +00:00
|
|
|
#include "nsIPresShell.h"
|
1998-06-23 00:52:21 +00:00
|
|
|
#include "nsIPresContext.h"
|
1998-05-04 17:54:45 +00:00
|
|
|
#include "nsIHTMLContent.h"
|
1998-09-04 15:41:20 +00:00
|
|
|
#include "nsIDOMNode.h" // for Find
|
1999-01-19 23:07:33 +00:00
|
|
|
#include "nsIDOMNodeList.h"
|
1998-05-04 17:54:45 +00:00
|
|
|
#include "nsIDOMElement.h"
|
1998-05-04 20:34:37 +00:00
|
|
|
#include "nsIDOMText.h"
|
1999-02-16 07:38:27 +00:00
|
|
|
#include "nsIDOMComment.h"
|
2000-03-22 22:16:14 +00:00
|
|
|
#include "nsIDOMDOMImplementation.h"
|
|
|
|
#include "nsIDOMDocumentType.h"
|
2000-09-01 01:54:35 +00:00
|
|
|
#include "nsIDOMWindowInternal.h"
|
1998-09-23 17:16:51 +00:00
|
|
|
#include "nsIDOMHTMLFormElement.h"
|
1998-07-01 11:16:09 +00:00
|
|
|
#include "nsIStreamListener.h"
|
1998-06-17 23:13:28 +00:00
|
|
|
#include "nsIURL.h"
|
1999-06-18 17:34:08 +00:00
|
|
|
#include "nsIIOService.h"
|
1999-06-23 03:29:44 +00:00
|
|
|
#include "nsIURL.h"
|
1999-11-30 04:50:42 +00:00
|
|
|
#include "nsNetUtil.h"
|
1999-11-19 07:35:27 +00:00
|
|
|
#include "nsIContentViewerContainer.h"
|
|
|
|
#include "nsIContentViewer.h"
|
|
|
|
#include "nsIMarkupDocumentViewer.h"
|
1998-07-18 21:47:56 +00:00
|
|
|
#include "nsIWebShell.h"
|
2000-03-11 00:35:36 +00:00
|
|
|
#include "nsIDocShell.h"
|
|
|
|
#include "nsIDocShellTreeItem.h"
|
2000-06-08 22:51:06 +00:00
|
|
|
#include "nsIWebNavigation.h"
|
1999-11-27 03:11:10 +00:00
|
|
|
#include "nsIBaseWindow.h"
|
1999-07-14 15:33:48 +00:00
|
|
|
#include "nsIWebShellServices.h"
|
1998-07-17 06:30:00 +00:00
|
|
|
#include "nsIDocumentLoader.h"
|
1998-07-22 23:32:19 +00:00
|
|
|
#include "nsIScriptGlobalObject.h"
|
|
|
|
#include "nsContentList.h"
|
1999-09-08 23:18:27 +00:00
|
|
|
#include "nsDOMError.h"
|
1999-10-02 03:41:37 +00:00
|
|
|
#include "nsICodebasePrincipal.h"
|
2000-03-31 00:31:18 +00:00
|
|
|
#include "nsIAggregatePrincipal.h"
|
1999-10-02 03:41:37 +00:00
|
|
|
#include "nsIScriptSecurityManager.h"
|
2000-03-18 17:48:12 +00:00
|
|
|
#include "nsJSUtils.h"
|
|
|
|
#include "nsDOMPropEnums.h"
|
2001-01-27 16:58:15 +00:00
|
|
|
#include "nsIScrollableView.h"
|
1999-06-18 17:34:08 +00:00
|
|
|
|
|
|
|
#include "nsIIOService.h"
|
1999-08-19 22:23:20 +00:00
|
|
|
#include "nsICookieService.h"
|
1999-06-18 17:34:08 +00:00
|
|
|
|
1998-09-17 00:55:35 +00:00
|
|
|
#include "nsIServiceManager.h"
|
2000-04-28 14:05:45 +00:00
|
|
|
#include "nsIConsoleService.h"
|
1998-08-04 00:05:22 +00:00
|
|
|
#include "nsIFormManager.h"
|
1999-03-09 09:44:27 +00:00
|
|
|
#include "nsIComponentManager.h"
|
1998-07-30 22:42:27 +00:00
|
|
|
#include "nsParserCIID.h"
|
1998-11-12 22:25:51 +00:00
|
|
|
#include "nsIDOMHTMLElement.h"
|
1999-01-09 00:15:19 +00:00
|
|
|
#include "nsIDOMHTMLMapElement.h"
|
1999-02-04 02:58:02 +00:00
|
|
|
#include "nsIDOMHTMLBodyElement.h"
|
1998-12-20 01:21:23 +00:00
|
|
|
#include "nsINameSpaceManager.h"
|
1999-07-07 04:52:27 +00:00
|
|
|
#include "nsGenericHTMLElement.h"
|
1999-01-19 16:58:45 +00:00
|
|
|
#include "nsGenericDOMNodeList.h"
|
1999-05-18 23:06:31 +00:00
|
|
|
#include "nsICSSLoader.h"
|
1999-08-09 19:10:24 +00:00
|
|
|
#include "nsIHTTPChannel.h"
|
2000-01-24 21:28:28 +00:00
|
|
|
#include "nsIFile.h"
|
1999-09-21 14:18:52 +00:00
|
|
|
#include "nsIEventListenerManager.h"
|
1999-11-14 00:34:15 +00:00
|
|
|
#include "nsISelectElement.h"
|
2000-04-28 14:05:45 +00:00
|
|
|
#include "nsIFrameSelection.h"
|
2000-09-14 11:45:01 +00:00
|
|
|
#include "nsISelectionPrivate.h"//for toStringwithformat code
|
1999-07-14 15:33:48 +00:00
|
|
|
|
|
|
|
#include "nsICharsetDetector.h"
|
|
|
|
#include "nsICharsetDetectionAdaptor.h"
|
|
|
|
#include "nsCharsetDetectionAdaptorCID.h"
|
1999-08-24 07:38:00 +00:00
|
|
|
#include "nsICharsetAlias.h"
|
1999-07-14 15:33:48 +00:00
|
|
|
#include "nsIPref.h"
|
2001-02-19 12:55:42 +00:00
|
|
|
#include "nsContentUtils.h"
|
2000-05-17 06:56:34 +00:00
|
|
|
#include "nsIDocumentCharsetInfo.h"
|
2000-05-13 08:11:29 +00:00
|
|
|
#include "nsIDocumentEncoder.h" //for outputting selection
|
2000-06-01 01:13:45 +00:00
|
|
|
#include "nsIBookmarksService.h"
|
2000-08-21 23:16:43 +00:00
|
|
|
#include "nsINetDataCacheManager.h"
|
|
|
|
#include "nsICachedNetData.h"
|
2000-06-07 01:14:08 +00:00
|
|
|
#include "nsIXMLContent.h" //for createelementNS
|
2000-06-09 04:19:09 +00:00
|
|
|
#include "nsHTMLParts.h" //for createelementNS
|
2001-02-19 12:55:42 +00:00
|
|
|
#include "nsLayoutCID.h"
|
|
|
|
#include "nsContentCID.h"
|
2001-03-29 02:11:48 +00:00
|
|
|
#include "nsIPrompt.h"
|
2000-05-13 08:11:29 +00:00
|
|
|
|
2000-09-13 23:57:52 +00:00
|
|
|
#define DETECTOR_CONTRACTID_MAX 127
|
|
|
|
static char g_detector_contractid[DETECTOR_CONTRACTID_MAX + 1];
|
1999-07-14 15:33:48 +00:00
|
|
|
static PRBool gInitDetector = PR_FALSE;
|
|
|
|
static PRBool gPlugDetector = PR_FALSE;
|
2000-06-16 21:22:00 +00:00
|
|
|
//static PRBool gBookmarkCharset = PR_TRUE;
|
1999-09-22 08:49:28 +00:00
|
|
|
|
1999-07-14 17:13:05 +00:00
|
|
|
#include "prmem.h"
|
1999-11-12 02:06:54 +00:00
|
|
|
#include "prtime.h"
|
1999-07-14 17:13:05 +00:00
|
|
|
|
2001-02-06 05:46:46 +00:00
|
|
|
// Find/Search Includes
|
1998-08-28 15:55:31 +00:00
|
|
|
const PRInt32 kForward = 0;
|
|
|
|
const PRInt32 kBackward = 1;
|
|
|
|
|
1999-12-13 21:00:47 +00:00
|
|
|
//#define DEBUG_charset
|
|
|
|
|
1998-08-28 15:55:31 +00:00
|
|
|
|
1998-07-10 05:35:23 +00:00
|
|
|
//#define rickgdebug 1
|
|
|
|
#ifdef rickgdebug
|
|
|
|
#include "nsHTMLContentSinkStream.h"
|
|
|
|
#endif
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
#define ELEMENT_NOT_IN_TABLE ((nsIContent *)1)
|
2000-09-09 05:46:14 +00:00
|
|
|
|
1999-06-18 17:34:08 +00:00
|
|
|
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
|
2000-09-09 05:46:14 +00:00
|
|
|
static NS_DEFINE_CID(kCookieServiceCID, NS_COOKIESERVICE_CID);
|
1999-06-18 17:34:08 +00:00
|
|
|
|
2000-06-01 01:13:45 +00:00
|
|
|
static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
static PRBool
|
|
|
|
IsNamedItem(nsIContent* aContent, nsIAtom *aTag, nsAWritableString& aName);
|
|
|
|
|
2001-03-10 21:02:12 +00:00
|
|
|
static NS_DEFINE_CID(kCParserCID, NS_PARSER_CID);
|
|
|
|
|
|
|
|
static NS_DEFINE_CID(kHTMLStyleSheetCID,NS_HTMLSTYLESHEET_CID);
|
|
|
|
|
2000-06-01 01:13:45 +00:00
|
|
|
nsIRDFService* nsHTMLDocument::gRDF;
|
|
|
|
nsrefcnt nsHTMLDocument::gRefCntRDFService = 0;
|
1998-10-06 01:39:33 +00:00
|
|
|
|
2000-05-02 23:07:11 +00:00
|
|
|
static int PR_CALLBACK
|
1999-09-23 02:10:15 +00:00
|
|
|
MyPrefChangedCallback(const char*aPrefName, void* instance_data)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
2000-09-13 23:57:52 +00:00
|
|
|
NS_WITH_SERVICE(nsIPref, prefs, "@mozilla.org/preferences;1", &rv);
|
2000-08-18 00:47:03 +00:00
|
|
|
PRUnichar* detector_name = nsnull;
|
1999-09-23 02:10:15 +00:00
|
|
|
if(NS_SUCCEEDED(rv) && NS_SUCCEEDED(
|
2000-08-18 00:47:03 +00:00
|
|
|
rv = prefs->GetLocalizedUnicharPref("intl.charset.detector",
|
1999-09-23 02:10:15 +00:00
|
|
|
&detector_name)))
|
|
|
|
{
|
|
|
|
if(nsCRT::strlen(detector_name) > 0) {
|
2000-09-13 23:57:52 +00:00
|
|
|
PL_strncpy(g_detector_contractid, NS_CHARSET_DETECTOR_CONTRACTID_BASE,DETECTOR_CONTRACTID_MAX);
|
2001-03-08 08:05:05 +00:00
|
|
|
PL_strncat(g_detector_contractid, NS_ConvertUCS2toUTF8(detector_name).get(),DETECTOR_CONTRACTID_MAX);
|
1999-09-23 02:10:15 +00:00
|
|
|
gPlugDetector = PR_TRUE;
|
|
|
|
} else {
|
2000-09-13 23:57:52 +00:00
|
|
|
g_detector_contractid[0]=0;
|
1999-09-23 02:10:15 +00:00
|
|
|
gPlugDetector = PR_FALSE;
|
|
|
|
}
|
|
|
|
PR_FREEIF(detector_name);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2000-08-16 23:16:21 +00:00
|
|
|
|
1999-01-19 16:58:45 +00:00
|
|
|
// ==================================================================
|
|
|
|
// =
|
|
|
|
// ==================================================================
|
1998-04-13 20:24:54 +00:00
|
|
|
NS_LAYOUT nsresult
|
|
|
|
NS_NewHTMLDocument(nsIDocument** aInstancePtrResult)
|
|
|
|
{
|
|
|
|
nsHTMLDocument* doc = new nsHTMLDocument();
|
1999-07-18 06:35:52 +00:00
|
|
|
if(doc)
|
2000-09-09 05:46:14 +00:00
|
|
|
return doc->QueryInterface(NS_GET_IID(nsIDocument), (void**) aInstancePtrResult);
|
1999-07-18 06:35:52 +00:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsHTMLDocument::nsHTMLDocument()
|
1998-07-17 23:00:54 +00:00
|
|
|
: nsMarkupDocument(),
|
1998-09-02 02:06:39 +00:00
|
|
|
mAttrStyleSheet(nsnull),
|
1999-01-15 02:01:36 +00:00
|
|
|
mStyleAttrStyleSheet(nsnull),
|
|
|
|
mBaseURL(nsnull),
|
1999-08-09 19:10:24 +00:00
|
|
|
mBaseTarget(nsnull),
|
1999-09-17 06:56:39 +00:00
|
|
|
mLastModified(nsnull),
|
1999-09-26 10:07:16 +00:00
|
|
|
mReferrer(nsnull),
|
|
|
|
mIsWriting(0)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1998-07-22 23:32:19 +00:00
|
|
|
mImages = nsnull;
|
|
|
|
mApplets = nsnull;
|
|
|
|
mEmbeds = nsnull;
|
|
|
|
mLinks = nsnull;
|
|
|
|
mAnchors = nsnull;
|
1999-05-17 21:17:48 +00:00
|
|
|
mLayers = nsnull;
|
1998-07-23 22:06:05 +00:00
|
|
|
mParser = nsnull;
|
2000-05-04 05:54:04 +00:00
|
|
|
mDTDMode = eDTDMode_quirks;
|
1999-05-18 23:06:31 +00:00
|
|
|
mCSSLoader = nsnull;
|
1998-08-28 15:55:31 +00:00
|
|
|
|
1998-09-04 15:41:20 +00:00
|
|
|
mBodyContent = nsnull;
|
1998-09-23 17:16:51 +00:00
|
|
|
mForms = nsnull;
|
1999-02-03 19:38:16 +00:00
|
|
|
mIsWriting = 0;
|
|
|
|
mWriteLevel = 0;
|
2000-06-01 01:13:45 +00:00
|
|
|
|
|
|
|
if (gRefCntRDFService++ == 0)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
rv = nsServiceManager::GetService(kRDFServiceCID,
|
|
|
|
NS_GET_IID(nsIRDFService),
|
|
|
|
(nsISupports**) &gRDF);
|
|
|
|
|
|
|
|
//NS_WITH_SERVICE(nsIRDFService, gRDF, kRDFServiceCID, &rv);
|
|
|
|
}
|
|
|
|
|
2000-10-24 04:35:25 +00:00
|
|
|
mDomainWasSet = PR_FALSE; // Bug 13871: Frameset spoofing
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
PrePopulateHashTables();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsHTMLDocument::~nsHTMLDocument()
|
|
|
|
{
|
1998-08-15 16:25:33 +00:00
|
|
|
PRInt32 i;
|
1998-09-23 17:16:51 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IF_RELEASE(mImages);
|
|
|
|
NS_IF_RELEASE(mApplets);
|
|
|
|
NS_IF_RELEASE(mEmbeds);
|
|
|
|
NS_IF_RELEASE(mLinks);
|
|
|
|
NS_IF_RELEASE(mAnchors);
|
1999-05-17 21:17:48 +00:00
|
|
|
NS_IF_RELEASE(mLayers);
|
1998-11-26 01:34:53 +00:00
|
|
|
if (nsnull != mAttrStyleSheet) {
|
|
|
|
mAttrStyleSheet->SetOwningDocument(nsnull);
|
|
|
|
NS_RELEASE(mAttrStyleSheet);
|
|
|
|
}
|
|
|
|
if (nsnull != mStyleAttrStyleSheet) {
|
|
|
|
mStyleAttrStyleSheet->SetOwningDocument(nsnull);
|
|
|
|
NS_RELEASE(mStyleAttrStyleSheet);
|
|
|
|
}
|
1999-01-15 02:01:36 +00:00
|
|
|
NS_IF_RELEASE(mBaseURL);
|
|
|
|
if (nsnull != mBaseTarget) {
|
|
|
|
delete mBaseTarget;
|
|
|
|
mBaseTarget = nsnull;
|
|
|
|
}
|
1999-08-09 19:10:24 +00:00
|
|
|
if (nsnull != mLastModified) {
|
2001-02-23 02:03:02 +00:00
|
|
|
delete mLastModified;
|
1999-08-09 19:10:24 +00:00
|
|
|
mLastModified = nsnull;
|
|
|
|
}
|
1999-09-17 06:56:39 +00:00
|
|
|
if (nsnull != mReferrer) {
|
2001-02-23 02:03:02 +00:00
|
|
|
delete mReferrer;
|
1999-09-17 06:56:39 +00:00
|
|
|
mReferrer = nsnull;
|
|
|
|
}
|
1998-07-23 22:06:05 +00:00
|
|
|
NS_IF_RELEASE(mParser);
|
1998-08-15 16:25:33 +00:00
|
|
|
for (i = 0; i < mImageMaps.Count(); i++) {
|
1999-01-09 00:15:19 +00:00
|
|
|
nsIDOMHTMLMapElement* map = (nsIDOMHTMLMapElement*)mImageMaps.ElementAt(i);
|
1998-08-15 16:25:33 +00:00
|
|
|
NS_RELEASE(map);
|
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
NS_IF_RELEASE(mForms);
|
1999-05-26 23:50:26 +00:00
|
|
|
if (mCSSLoader) {
|
|
|
|
mCSSLoader->DropDocumentReference(); // release weak ref
|
|
|
|
NS_RELEASE(mCSSLoader);
|
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
|
1998-09-04 15:41:20 +00:00
|
|
|
NS_IF_RELEASE(mBodyContent);
|
2000-06-01 01:13:45 +00:00
|
|
|
|
|
|
|
if (--gRefCntRDFService == 0)
|
|
|
|
{
|
2000-09-13 23:57:52 +00:00
|
|
|
nsServiceManager::ReleaseService("@mozilla.org/rdf/rdf-service;1", gRDF);
|
2000-06-01 01:13:45 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
InvalidateHashTables();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aInstancePtr, "null ptr");
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
2000-09-09 05:46:14 +00:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIHTMLDocument))) {
|
1998-09-12 19:33:48 +00:00
|
|
|
NS_ADDREF_THIS();
|
1998-07-22 23:32:19 +00:00
|
|
|
*aInstancePtr = (void**) (nsIHTMLDocument *)this;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-09-09 05:46:14 +00:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMHTMLDocument))) {
|
1998-09-12 19:33:48 +00:00
|
|
|
NS_ADDREF_THIS();
|
1998-07-22 23:32:19 +00:00
|
|
|
*aInstancePtr = (void**) (nsIDOMHTMLDocument *)this;
|
1998-04-13 20:24:54 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-09-09 05:46:14 +00:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMNSHTMLDocument))) {
|
1998-09-12 19:33:48 +00:00
|
|
|
NS_ADDREF_THIS();
|
1998-08-07 23:08:00 +00:00
|
|
|
*aInstancePtr = (void**) (nsIDOMNSHTMLDocument *)this;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-09-09 05:46:14 +00:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIHTMLContentContainer))) {
|
1998-11-12 07:54:12 +00:00
|
|
|
NS_ADDREF_THIS();
|
|
|
|
*aInstancePtr = (void**) (nsIHTMLContentContainer *)this;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
return nsDocument::QueryInterface(aIID, aInstancePtr);
|
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
nsrefcnt
|
|
|
|
nsHTMLDocument::AddRef()
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
|
|
|
return nsDocument::AddRef();
|
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
nsrefcnt
|
|
|
|
nsHTMLDocument::Release()
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
|
|
|
return nsDocument::Release();
|
|
|
|
}
|
1998-07-01 11:16:09 +00:00
|
|
|
|
2001-03-12 06:38:39 +00:00
|
|
|
NS_IMETHODIMP
|
1999-07-20 08:46:33 +00:00
|
|
|
nsHTMLDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1999-07-20 08:46:33 +00:00
|
|
|
nsresult result = nsDocument::Reset(aChannel, aLoadGroup);
|
1999-07-16 11:14:36 +00:00
|
|
|
nsCOMPtr<nsIURI> aURL;
|
2001-03-12 06:38:39 +00:00
|
|
|
|
|
|
|
if (aChannel) {
|
|
|
|
result = aChannel->GetURI(getter_AddRefs(aURL));
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
1998-05-13 23:43:44 +00:00
|
|
|
}
|
1998-11-11 22:06:16 +00:00
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
PRInt32 i;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
InvalidateHashTables();
|
|
|
|
PrePopulateHashTables();
|
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
NS_IF_RELEASE(mImages);
|
|
|
|
NS_IF_RELEASE(mApplets);
|
|
|
|
NS_IF_RELEASE(mEmbeds);
|
|
|
|
NS_IF_RELEASE(mLinks);
|
|
|
|
NS_IF_RELEASE(mAnchors);
|
1999-05-17 21:17:48 +00:00
|
|
|
NS_IF_RELEASE(mLayers);
|
1999-01-06 00:32:41 +00:00
|
|
|
|
|
|
|
for (i = 0; i < mImageMaps.Count(); i++) {
|
1999-01-09 00:15:19 +00:00
|
|
|
nsIDOMHTMLMapElement* map = (nsIDOMHTMLMapElement*)mImageMaps.ElementAt(i);
|
1999-01-06 00:32:41 +00:00
|
|
|
NS_RELEASE(map);
|
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
NS_IF_RELEASE(mForms);
|
1998-05-13 23:43:44 +00:00
|
|
|
|
2001-03-12 06:38:39 +00:00
|
|
|
if (aURL) {
|
|
|
|
if (!mAttrStyleSheet) {
|
|
|
|
//result = NS_NewHTMLStyleSheet(&mAttrStyleSheet, aURL, this);
|
|
|
|
result = nsComponentManager::CreateInstance(kHTMLStyleSheetCID, nsnull,
|
|
|
|
NS_GET_IID(nsIHTMLStyleSheet),
|
|
|
|
(void**)&mAttrStyleSheet);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = mAttrStyleSheet->Init(aURL,this);
|
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
NS_RELEASE(mAttrStyleSheet);
|
|
|
|
}
|
2001-02-19 12:55:42 +00:00
|
|
|
}
|
|
|
|
}
|
1999-02-03 19:38:16 +00:00
|
|
|
else {
|
2001-03-12 06:38:39 +00:00
|
|
|
result = mAttrStyleSheet->Reset(aURL);
|
1999-02-03 19:38:16 +00:00
|
|
|
}
|
2001-03-12 06:38:39 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
AddStyleSheet(mAttrStyleSheet); // tell the world about our new style sheet
|
|
|
|
|
|
|
|
if (!mStyleAttrStyleSheet) {
|
|
|
|
result = NS_NewHTMLCSSStyleSheet(&mStyleAttrStyleSheet, aURL, this);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = mStyleAttrStyleSheet->Reset(aURL);
|
|
|
|
}
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
AddStyleSheet(mStyleAttrStyleSheet); // tell the world about our new style sheet
|
|
|
|
}
|
1999-01-06 00:32:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-05-11 20:22:35 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetContentType(nsAWritableString& aContentType) const
|
1999-05-11 20:22:35 +00:00
|
|
|
{
|
2000-08-23 17:27:06 +00:00
|
|
|
aContentType.Assign(NS_LITERAL_STRING("text/html"));
|
1999-05-11 20:22:35 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-07-07 01:27:08 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::CreateShell(nsIPresContext* aContext,
|
|
|
|
nsIViewManager* aViewManager,
|
|
|
|
nsIStyleSet* aStyleSet,
|
|
|
|
nsIPresShell** aInstancePtrResult)
|
|
|
|
{
|
|
|
|
nsresult result = nsMarkupDocument::CreateShell(aContext,
|
|
|
|
aViewManager,
|
|
|
|
aStyleSet,
|
|
|
|
aInstancePtrResult);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
2000-05-04 05:54:04 +00:00
|
|
|
aContext->SetCompatibilityMode(((eDTDMode_strict== mDTDMode) ?
|
1999-07-07 01:27:08 +00:00
|
|
|
eCompatibility_Standard :
|
|
|
|
eCompatibility_NavQuirks));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
NS_IMETHODIMP
|
1999-07-16 11:14:36 +00:00
|
|
|
nsHTMLDocument::StartDocumentLoad(const char* aCommand,
|
|
|
|
nsIChannel* aChannel,
|
1999-07-20 08:46:33 +00:00
|
|
|
nsILoadGroup* aLoadGroup,
|
1999-11-15 22:17:54 +00:00
|
|
|
nsISupports* aContainer,
|
2000-05-01 06:58:53 +00:00
|
|
|
nsIStreamListener **aDocListener,
|
|
|
|
PRBool aReset)
|
1999-01-06 00:32:41 +00:00
|
|
|
{
|
1999-12-09 07:18:38 +00:00
|
|
|
PRBool needsParser=PR_TRUE;
|
|
|
|
if (aCommand)
|
|
|
|
{
|
2000-04-15 20:15:37 +00:00
|
|
|
nsAutoString command; command.AssignWithConversion(aCommand);
|
|
|
|
nsAutoString delayedView; delayedView.AssignWithConversion("view delayedContentLoad");
|
1999-12-09 07:18:38 +00:00
|
|
|
if (command.Equals(delayedView)) {
|
|
|
|
needsParser = PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-08-21 23:16:43 +00:00
|
|
|
nsCOMPtr<nsICachedNetData> cachedData;
|
1999-07-16 11:14:36 +00:00
|
|
|
nsresult rv = nsDocument::StartDocumentLoad(aCommand,
|
1999-07-20 08:46:33 +00:00
|
|
|
aChannel, aLoadGroup,
|
2000-05-01 06:58:53 +00:00
|
|
|
aContainer,
|
|
|
|
aDocListener, aReset);
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
1999-01-06 00:32:41 +00:00
|
|
|
|
2000-04-15 20:15:37 +00:00
|
|
|
nsAutoString charset; charset.AssignWithConversion("ISO-8859-1"); // fallback value in case webShell return error
|
1999-08-25 21:42:30 +00:00
|
|
|
nsCharsetSource charsetSource = kCharsetFromWeakDocTypeDefault;
|
1999-01-06 00:32:41 +00:00
|
|
|
|
1999-07-16 11:14:36 +00:00
|
|
|
nsCOMPtr<nsIURI> aURL;
|
|
|
|
rv = aChannel->GetURI(getter_AddRefs(aURL));
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-11-12 02:06:54 +00:00
|
|
|
nsAutoString lastModified;
|
1999-08-09 19:10:24 +00:00
|
|
|
nsCOMPtr<nsIHTTPChannel> httpChannel = do_QueryInterface(aChannel);
|
2000-08-21 23:16:43 +00:00
|
|
|
|
|
|
|
PRBool bTryCache = PR_FALSE;
|
|
|
|
PRUint32 cacheFlags = 0;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (httpChannel) {
|
1999-09-17 06:56:39 +00:00
|
|
|
nsXPIDLCString lastModHeader;
|
|
|
|
nsIAtom* lastModKey = NS_NewAtom("last-modified");
|
1999-08-09 19:10:24 +00:00
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
rv = httpChannel->GetResponseHeader(lastModKey,
|
|
|
|
getter_Copies(lastModHeader));
|
1999-08-09 19:10:24 +00:00
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
NS_RELEASE(lastModKey);
|
1999-08-09 19:10:24 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2001-03-22 08:51:52 +00:00
|
|
|
lastModified.AssignWithConversion(NS_STATIC_CAST(const char*,
|
|
|
|
lastModHeader));
|
1999-08-09 19:10:24 +00:00
|
|
|
SetLastModified(lastModified);
|
|
|
|
}
|
1999-08-24 07:38:00 +00:00
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
nsXPIDLCString referrerHeader;
|
|
|
|
nsAutoString referrer;
|
|
|
|
// The misspelled key 'referer' is as per the HTTP spec
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsIAtom> referrerKey(dont_AddRef(NS_NewAtom("referer")));
|
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
rv = httpChannel->GetRequestHeader(referrerKey,
|
2001-03-22 08:51:52 +00:00
|
|
|
getter_Copies(referrerHeader));
|
1999-09-17 06:56:39 +00:00
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2001-03-22 08:51:52 +00:00
|
|
|
referrer.AssignWithConversion(NS_STATIC_CAST(const char*,
|
|
|
|
referrerHeader));
|
1999-09-17 06:56:39 +00:00
|
|
|
SetReferrer(referrer);
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if(kCharsetFromHTTPHeader > charsetSource) {
|
|
|
|
nsCOMPtr<nsIAtom>
|
|
|
|
contentTypeKey(dont_AddRef(NS_NewAtom("content-type")));
|
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
nsXPIDLCString contenttypeheader;
|
2001-03-22 08:51:52 +00:00
|
|
|
rv = httpChannel->GetResponseHeader(contentTypeKey,
|
|
|
|
getter_Copies(contenttypeheader));
|
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
nsAutoString contentType;
|
2001-03-22 08:51:52 +00:00
|
|
|
contentType.AssignWithConversion(NS_STATIC_CAST(const char*,
|
|
|
|
contenttypeheader));
|
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
PRInt32 start = contentType.RFind("charset=", PR_TRUE ) ;
|
2001-03-22 08:51:52 +00:00
|
|
|
if(start != kNotFound) {
|
1999-09-17 06:56:39 +00:00
|
|
|
start += 8; // 8 = "charset=".length
|
2000-09-06 20:41:12 +00:00
|
|
|
PRInt32 end = 0;
|
|
|
|
if(PRUnichar('"') == contentType.CharAt(start)) {
|
|
|
|
start++;
|
|
|
|
end = contentType.FindCharInSet("\"", start );
|
|
|
|
if(kNotFound == end )
|
|
|
|
end = contentType.Length();
|
|
|
|
} else {
|
|
|
|
end = contentType.FindCharInSet(";\n\r ", start );
|
|
|
|
if(kNotFound == end )
|
|
|
|
end = contentType.Length();
|
|
|
|
}
|
1999-09-17 06:56:39 +00:00
|
|
|
nsAutoString theCharset;
|
|
|
|
contentType.Mid(theCharset, start, end - start);
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsICharsetAlias> calias(do_CreateInstance(kCharsetAliasCID,
|
|
|
|
&rv));
|
|
|
|
|
|
|
|
if(calias) {
|
1999-09-17 06:56:39 +00:00
|
|
|
nsAutoString preferred;
|
|
|
|
rv = calias->GetPreferred(theCharset, preferred);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
if(NS_SUCCEEDED(rv)) {
|
1999-12-13 21:00:47 +00:00
|
|
|
#ifdef DEBUG_charset
|
|
|
|
char* cCharset = charset.ToNewCString();
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("From HTTP Header, charset = %s\n", cCharset);
|
1999-12-13 21:00:47 +00:00
|
|
|
Recycle(cCharset);
|
|
|
|
#endif
|
1999-09-17 06:56:39 +00:00
|
|
|
charset = preferred;
|
|
|
|
charsetSource = kCharsetFromHTTPHeader;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-08-24 07:38:00 +00:00
|
|
|
|
2000-08-21 23:16:43 +00:00
|
|
|
PRUint32 loadAttr = 0;
|
|
|
|
rv = httpChannel->GetLoadAttributes(&loadAttr);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv),"cannot get load attribute");
|
2001-03-22 08:51:52 +00:00
|
|
|
if(NS_SUCCEEDED(rv)) {
|
|
|
|
// copy from nsHTTPChannel.cpp
|
|
|
|
if(loadAttr & nsIChannel::CACHE_AS_FILE)
|
|
|
|
cacheFlags = nsINetDataCacheManager::CACHE_AS_FILE;
|
|
|
|
else if(loadAttr & nsIChannel::INHIBIT_PERSISTENT_CACHING)
|
|
|
|
cacheFlags = nsINetDataCacheManager::BYPASS_PERSISTENT_CACHE;
|
|
|
|
bTryCache = PR_TRUE;
|
2000-08-21 23:16:43 +00:00
|
|
|
}
|
|
|
|
|
1999-08-09 19:10:24 +00:00
|
|
|
// Don't propogate the result code beyond here, since it
|
|
|
|
// could just be that the response header wasn't found.
|
|
|
|
rv = NS_OK;
|
|
|
|
}
|
1999-07-16 11:14:36 +00:00
|
|
|
|
1999-11-12 02:06:54 +00:00
|
|
|
nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(aChannel);
|
|
|
|
if (fileChannel) {
|
2000-05-25 14:03:57 +00:00
|
|
|
PRTime modDate, usecs;
|
2000-01-24 21:28:28 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
|
|
rv = fileChannel->GetFile(getter_AddRefs(file));
|
2001-02-21 20:38:08 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
// if we failed to get a last modification date, then we don't want to necessarily
|
|
|
|
// fail to create a document for this file. Just don't set the last modified date on it...
|
|
|
|
rv = file->GetLastModificationDate(&modDate);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
PRExplodedTime prtime;
|
|
|
|
char buf[100];
|
|
|
|
PRInt64 intermediateValue;
|
|
|
|
|
|
|
|
LL_I2L(intermediateValue, PR_USEC_PER_MSEC);
|
|
|
|
LL_MUL(usecs, modDate, intermediateValue);
|
|
|
|
PR_ExplodeTime(usecs, PR_LocalTimeParameters, &prtime);
|
|
|
|
|
|
|
|
// Use '%#c' for windows, because '%c' is backward-compatible and
|
|
|
|
// non-y2k with msvc; '%#c' requests that a full year be used in the
|
|
|
|
// result string. Other OSes just use "%c".
|
|
|
|
PR_FormatTime(buf, sizeof buf,
|
|
|
|
#if defined(XP_PC) && !defined(XP_OS2)
|
|
|
|
"%#c",
|
|
|
|
#else
|
|
|
|
"%c",
|
|
|
|
#endif
|
|
|
|
&prtime);
|
|
|
|
lastModified.AssignWithConversion(buf);
|
|
|
|
SetLastModified(lastModified);
|
|
|
|
}
|
|
|
|
}
|
1999-11-12 02:06:54 +00:00
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
if (needsParser) {
|
2001-02-19 12:55:42 +00:00
|
|
|
rv = nsComponentManager::CreateInstance(kCParserCID, nsnull,
|
2001-01-04 20:44:42 +00:00
|
|
|
NS_GET_IID(nsIParser),
|
1999-12-09 07:18:38 +00:00
|
|
|
(void **)&mParser);
|
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
}
|
1999-04-26 17:56:37 +00:00
|
|
|
|
1999-12-09 07:18:38 +00:00
|
|
|
PRUnichar* requestCharset = nsnull;
|
|
|
|
nsCharsetSource requestCharsetSource = kCharsetUninitialized;
|
2000-06-01 01:13:45 +00:00
|
|
|
|
2000-05-26 20:09:32 +00:00
|
|
|
nsCOMPtr <nsIParserFilter> cdetflt;
|
1999-12-09 07:18:38 +00:00
|
|
|
nsCOMPtr<nsIHTMLContentSink> sink;
|
1998-07-10 05:35:23 +00:00
|
|
|
#ifdef rickgdebug
|
1999-12-09 07:18:38 +00:00
|
|
|
nsString outString; // added out. Redirect to stdout if desired -- gpk 04/01/99
|
|
|
|
rv = NS_New_HTML_ContentSinkStream(getter_AddRefs(sink),&outString,0);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
NS_ASSERTION(sink, "null sink in debug code variant.");
|
1998-07-10 05:35:23 +00:00
|
|
|
#else
|
1999-12-09 07:18:38 +00:00
|
|
|
NS_PRECONDITION(nsnull != aContainer, "No content viewer container");
|
2000-03-11 00:35:36 +00:00
|
|
|
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aContainer));
|
1999-12-09 07:18:38 +00:00
|
|
|
|
2000-05-14 19:25:06 +00:00
|
|
|
if(mParser) {
|
2000-08-30 00:35:43 +00:00
|
|
|
nsCOMPtr<nsISupportsParserBundle> parserBundle;
|
|
|
|
nsresult result;
|
2000-05-14 19:25:06 +00:00
|
|
|
|
2000-08-30 00:35:43 +00:00
|
|
|
parserBundle = do_QueryInterface(mParser, &result);
|
2000-05-14 19:25:06 +00:00
|
|
|
|
|
|
|
if(NS_SUCCEEDED(result)) {
|
|
|
|
// We do this to help consumers who don't have access to the webshell.
|
2000-11-01 20:25:33 +00:00
|
|
|
nsAutoString theDocShell,theChannel;
|
|
|
|
theDocShell.AssignWithConversion("docshell");
|
|
|
|
theChannel.AssignWithConversion("channel");
|
|
|
|
parserBundle->SetDataIntoBundle(theDocShell,docShell);
|
|
|
|
parserBundle->SetDataIntoBundle(theChannel,aChannel);
|
2000-05-14 19:25:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-05-17 06:56:34 +00:00
|
|
|
nsCOMPtr<nsIDocumentCharsetInfo> dcInfo;
|
|
|
|
docShell->GetDocumentCharsetInfo(getter_AddRefs(dcInfo));
|
|
|
|
|
2000-01-18 02:40:45 +00:00
|
|
|
//
|
|
|
|
// The following logic is mirrored in nsWebShell::Embed!
|
|
|
|
//
|
1999-12-09 07:18:38 +00:00
|
|
|
nsCOMPtr<nsIMarkupDocumentViewer> muCV;
|
|
|
|
nsCOMPtr<nsIContentViewer> cv;
|
2000-03-11 00:35:36 +00:00
|
|
|
docShell->GetContentViewer(getter_AddRefs(cv));
|
1999-12-09 07:18:38 +00:00
|
|
|
if (cv) {
|
|
|
|
muCV = do_QueryInterface(cv);
|
1999-12-13 22:45:06 +00:00
|
|
|
} else {
|
|
|
|
// in this block of code, if we get an error result, we return it
|
|
|
|
// but if we get a null pointer, that's perfectly legal for parent and parentContentViewer
|
2000-03-11 00:35:36 +00:00
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
|
|
|
|
NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentAsItem;
|
|
|
|
docShellAsItem->GetSameTypeParent(getter_AddRefs(parentAsItem));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShell> parent(do_QueryInterface(parentAsItem));
|
1999-12-13 22:45:06 +00:00
|
|
|
if (parent) {
|
|
|
|
nsCOMPtr<nsIContentViewer> parentContentViewer;
|
|
|
|
rv = parent->GetContentViewer(getter_AddRefs(parentContentViewer));
|
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
if (parentContentViewer) {
|
|
|
|
muCV = do_QueryInterface(parentContentViewer);
|
|
|
|
}
|
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
}
|
|
|
|
if(kCharsetFromUserDefault > charsetSource)
|
|
|
|
{
|
|
|
|
PRUnichar* defaultCharsetFromWebShell = NULL;
|
|
|
|
if (muCV) {
|
|
|
|
rv = muCV->GetDefaultCharacterSet(&defaultCharsetFromWebShell);
|
1999-12-13 22:45:06 +00:00
|
|
|
if(NS_SUCCEEDED(rv)) {
|
1999-12-13 21:00:47 +00:00
|
|
|
#ifdef DEBUG_charset
|
|
|
|
nsAutoString d(defaultCharsetFromWebShell);
|
|
|
|
char* cCharset = d.ToNewCString();
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("From default charset, charset = %s\n", cCharset);
|
1999-12-13 21:00:47 +00:00
|
|
|
Recycle(cCharset);
|
|
|
|
#endif
|
1999-12-13 22:45:06 +00:00
|
|
|
charset = defaultCharsetFromWebShell;
|
|
|
|
Recycle(defaultCharsetFromWebShell);
|
|
|
|
charsetSource = kCharsetFromUserDefault;
|
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
}
|
|
|
|
// for html, we need to find out the Meta tag from the hint.
|
|
|
|
if (muCV) {
|
|
|
|
rv = muCV->GetHintCharacterSet(&requestCharset);
|
|
|
|
if(NS_SUCCEEDED(rv)) {
|
|
|
|
rv = muCV->GetHintCharacterSetSource((PRInt32*)(&requestCharsetSource));
|
1999-12-13 21:00:47 +00:00
|
|
|
if(kCharsetUninitialized != requestCharsetSource) {
|
|
|
|
muCV->SetHintCharacterSetSource((PRInt32)(kCharsetUninitialized));
|
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if(NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
if(requestCharsetSource > charsetSource)
|
|
|
|
{
|
1999-12-13 21:00:47 +00:00
|
|
|
#ifdef DEBUG_charset
|
|
|
|
nsAutoString d(requestCharset);
|
|
|
|
char* cCharset = d.ToNewCString();
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("From request charset, charset = %s req=%d->%d\n",
|
1999-12-13 21:00:47 +00:00
|
|
|
cCharset, charsetSource, requestCharsetSource);
|
|
|
|
Recycle(cCharset);
|
|
|
|
#endif
|
1999-12-09 07:18:38 +00:00
|
|
|
charsetSource = requestCharsetSource;
|
|
|
|
charset = requestCharset;
|
|
|
|
Recycle(requestCharset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(kCharsetFromPreviousLoading > charsetSource)
|
1999-11-19 07:35:27 +00:00
|
|
|
{
|
1999-12-09 07:18:38 +00:00
|
|
|
PRUnichar* forceCharsetFromWebShell = NULL;
|
|
|
|
if (muCV) {
|
|
|
|
rv = muCV->GetForceCharacterSet(&forceCharsetFromWebShell);
|
1999-11-19 07:35:27 +00:00
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
if(NS_SUCCEEDED(rv) && (nsnull != forceCharsetFromWebShell))
|
1999-11-19 07:35:27 +00:00
|
|
|
{
|
1999-12-13 21:00:47 +00:00
|
|
|
#ifdef DEBUG_charset
|
|
|
|
nsAutoString d(forceCharsetFromWebShell);
|
|
|
|
char* cCharset = d.ToNewCString();
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("From force, charset = %s \n", cCharset);
|
1999-12-13 21:00:47 +00:00
|
|
|
Recycle(cCharset);
|
|
|
|
#endif
|
1999-12-09 07:18:38 +00:00
|
|
|
charset = forceCharsetFromWebShell;
|
|
|
|
Recycle(forceCharsetFromWebShell);
|
|
|
|
//TODO: we should define appropriate constant for force charset
|
|
|
|
charsetSource = kCharsetFromPreviousLoading;
|
2000-06-22 00:41:02 +00:00
|
|
|
} else if (dcInfo) {
|
2000-05-17 06:56:34 +00:00
|
|
|
nsCOMPtr<nsIAtom> csAtom;
|
|
|
|
dcInfo->GetForcedCharset(getter_AddRefs(csAtom));
|
2000-05-17 07:40:40 +00:00
|
|
|
if (csAtom.get() != NULL) {
|
2000-05-17 06:56:34 +00:00
|
|
|
csAtom->ToString(charset);
|
|
|
|
charsetSource = kCharsetFromPreviousLoading;
|
2000-06-22 00:41:02 +00:00
|
|
|
dcInfo->SetForcedCharset(NULL);
|
2000-05-17 06:56:34 +00:00
|
|
|
}
|
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
}
|
|
|
|
nsresult rv_detect = NS_OK;
|
|
|
|
if(! gInitDetector)
|
|
|
|
{
|
2000-09-13 23:57:52 +00:00
|
|
|
nsCOMPtr<nsIPref> pref(do_GetService(NS_PREF_CONTRACTID));
|
2000-03-02 07:13:02 +00:00
|
|
|
if(pref)
|
1999-12-09 07:18:38 +00:00
|
|
|
{
|
2000-08-18 00:47:03 +00:00
|
|
|
PRUnichar* detector_name = nsnull;
|
1999-12-09 07:18:38 +00:00
|
|
|
if(NS_SUCCEEDED(
|
2000-08-18 00:47:03 +00:00
|
|
|
rv_detect = pref->GetLocalizedUnicharPref("intl.charset.detector",
|
1999-12-09 07:18:38 +00:00
|
|
|
&detector_name)))
|
1999-11-19 07:35:27 +00:00
|
|
|
{
|
2000-09-13 23:57:52 +00:00
|
|
|
PL_strncpy(g_detector_contractid, NS_CHARSET_DETECTOR_CONTRACTID_BASE,DETECTOR_CONTRACTID_MAX);
|
2001-03-08 08:05:05 +00:00
|
|
|
PL_strncat(g_detector_contractid, NS_ConvertUCS2toUTF8(detector_name).get(),DETECTOR_CONTRACTID_MAX);
|
1999-12-09 07:18:38 +00:00
|
|
|
gPlugDetector = PR_TRUE;
|
|
|
|
PR_FREEIF(detector_name);
|
1999-11-19 07:35:27 +00:00
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
pref->RegisterCallback("intl.charset.detector", MyPrefChangedCallback, nsnull);
|
|
|
|
}
|
|
|
|
gInitDetector = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2000-07-19 19:51:20 +00:00
|
|
|
// don't try to access bookmarks if we are loading about:blank...it's not going
|
|
|
|
// to give us anything useful and it causes Bug #44397. At the same time, I'm loath to do something
|
|
|
|
// like this because I think it's really bogus that layout is depending on bookmarks. This is very evil.
|
|
|
|
nsXPIDLCString scheme;
|
|
|
|
aURL->GetScheme(getter_Copies(scheme));
|
2000-08-02 05:08:15 +00:00
|
|
|
|
2000-08-21 23:16:43 +00:00
|
|
|
nsXPIDLCString urlSpec;
|
|
|
|
aURL->GetSpec(getter_Copies(urlSpec));
|
|
|
|
|
2000-07-19 19:51:20 +00:00
|
|
|
if (scheme && nsCRT::strcasecmp("about", scheme) && (kCharsetFromBookmarks > charsetSource))
|
2000-06-01 01:13:45 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIRDFDataSource> datasource;
|
2000-10-01 05:24:00 +00:00
|
|
|
if (gRDF && NS_SUCCEEDED(rv_detect = gRDF->GetDataSource("rdf:bookmarks", getter_AddRefs(datasource))))
|
2000-06-01 01:13:45 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIBookmarksService> bookmarks = do_QueryInterface(datasource);
|
|
|
|
if (bookmarks)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (urlSpec)
|
|
|
|
{
|
2000-08-02 05:08:15 +00:00
|
|
|
nsXPIDLString pBookmarkedCharset;
|
2000-06-01 01:13:45 +00:00
|
|
|
|
2000-08-02 05:08:15 +00:00
|
|
|
if (NS_SUCCEEDED(rv = bookmarks->GetLastCharset(urlSpec, getter_Copies(pBookmarkedCharset))) &&
|
2000-06-01 01:13:45 +00:00
|
|
|
(rv != NS_RDF_NO_VALUE))
|
|
|
|
{
|
|
|
|
charset = pBookmarkedCharset;
|
|
|
|
charsetSource = kCharsetFromBookmarks;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-09-15 06:13:11 +00:00
|
|
|
if(bTryCache && urlSpec)
|
2000-08-21 23:16:43 +00:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsINetDataCacheManager> cacheMgr;
|
2000-09-13 23:57:52 +00:00
|
|
|
cacheMgr = do_GetService(NS_NETWORK_CACHE_MANAGER_CONTRACTID, &rv);
|
2000-09-15 06:13:11 +00:00
|
|
|
if(NS_SUCCEEDED(rv))
|
2000-08-21 23:16:43 +00:00
|
|
|
{
|
|
|
|
rv = cacheMgr->GetCachedNetData(urlSpec, nsnull, 0, cacheFlags, getter_AddRefs(cachedData));
|
|
|
|
if(NS_SUCCEEDED(rv)) {
|
|
|
|
if(kCharsetFromCache > charsetSource)
|
|
|
|
{
|
|
|
|
nsXPIDLCString cachedCharset;
|
|
|
|
PRUint32 cachedCharsetLen = 0;
|
|
|
|
rv = cachedData->GetAnnotation( "charset", &cachedCharsetLen,
|
|
|
|
getter_Copies(cachedCharset));
|
|
|
|
if(NS_SUCCEEDED(rv) && (cachedCharsetLen > 0))
|
|
|
|
{
|
|
|
|
charset.AssignWithConversion(cachedCharset);
|
|
|
|
charsetSource = kCharsetFromCache;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rv=NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-08-05 00:07:03 +00:00
|
|
|
if (kCharsetFromParentFrame > charsetSource) {
|
|
|
|
if (dcInfo) {
|
|
|
|
nsCOMPtr<nsIAtom> csAtom;
|
|
|
|
dcInfo->GetParentCharset(getter_AddRefs(csAtom));
|
|
|
|
if (csAtom) {
|
|
|
|
csAtom->ToString(charset);
|
|
|
|
charsetSource = kCharsetFromParentFrame;
|
|
|
|
|
2000-10-28 22:17:53 +00:00
|
|
|
// printf("### 0 >>> Having parent CS = %s\n", charset.ToNewCString());
|
2000-08-05 00:07:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-12-09 07:18:38 +00:00
|
|
|
if((kCharsetFromAutoDetection > charsetSource ) && gPlugDetector)
|
|
|
|
{
|
2000-09-13 23:57:52 +00:00
|
|
|
nsCOMPtr <nsICharsetDetector> cdet = do_CreateInstance(g_detector_contractid,
|
2000-05-26 20:09:32 +00:00
|
|
|
&rv_detect);
|
|
|
|
if(NS_SUCCEEDED( rv_detect ))
|
1999-12-09 07:18:38 +00:00
|
|
|
{
|
2000-09-13 23:57:52 +00:00
|
|
|
cdetflt = do_CreateInstance(NS_CHARSET_DETECTION_ADAPTOR_CONTRACTID,
|
2000-05-26 20:09:32 +00:00
|
|
|
&rv_detect);
|
|
|
|
if(NS_SUCCEEDED( rv_detect ))
|
1999-11-19 07:35:27 +00:00
|
|
|
{
|
2000-05-26 20:09:32 +00:00
|
|
|
nsCOMPtr<nsICharsetDetectionAdaptor> adp = do_QueryInterface(cdetflt,
|
|
|
|
&rv_detect);
|
|
|
|
if(cdetflt && NS_SUCCEEDED( rv_detect ))
|
1999-11-19 07:35:27 +00:00
|
|
|
{
|
2000-05-26 20:09:32 +00:00
|
|
|
nsCOMPtr<nsIWebShellServices> wss = do_QueryInterface(docShell,
|
|
|
|
&rv_detect);
|
|
|
|
if( NS_SUCCEEDED( rv_detect ))
|
1999-11-19 07:35:27 +00:00
|
|
|
{
|
2000-02-15 09:15:18 +00:00
|
|
|
rv_detect = adp->Init(wss, cdet, (nsIDocument*)this,
|
|
|
|
mParser, charset.GetUnicode(),aCommand);
|
1999-11-19 07:35:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// IF we cannot create the detector, don't bother to
|
|
|
|
// create one next time.
|
|
|
|
gPlugDetector = PR_FALSE;
|
|
|
|
}
|
1999-04-26 17:56:37 +00:00
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
}
|
1998-07-10 05:35:23 +00:00
|
|
|
#endif
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
1999-12-09 07:18:38 +00:00
|
|
|
|
|
|
|
rv = this->SetDocumentCharacterSet(charset);
|
2000-12-26 01:01:41 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
1999-04-27 21:49:25 +00:00
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
if(cachedData) {
|
2000-08-21 23:16:43 +00:00
|
|
|
rv=cachedData->SetAnnotation("charset",charset.Length()+1,
|
2001-03-08 08:05:05 +00:00
|
|
|
NS_ConvertUCS2toUTF8(charset).get());
|
2000-08-21 23:16:43 +00:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv),"cannot SetAnnotation");
|
|
|
|
}
|
|
|
|
|
1999-12-09 07:18:38 +00:00
|
|
|
// Set the parser as the stream listener for the document loader...
|
2000-12-26 01:01:41 +00:00
|
|
|
if (mParser) {
|
|
|
|
rv = mParser->QueryInterface(NS_GET_IID(nsIStreamListener),
|
|
|
|
(void**)aDocListener);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
1998-07-02 08:14:22 +00:00
|
|
|
|
1999-12-09 07:18:38 +00:00
|
|
|
//The following lines were added by Rick.
|
|
|
|
//These perform "dynamic" DTD registration, allowing
|
|
|
|
//the caller total control over process, and decoupling
|
|
|
|
//parser from any given grammar.
|
1998-07-02 08:14:22 +00:00
|
|
|
|
2000-09-08 04:52:57 +00:00
|
|
|
// nsCOMPtr<nsIDTD> theDTD;
|
|
|
|
// NS_NewNavHTMLDTD(getter_AddRefs(theDTD));
|
1999-01-26 01:25:37 +00:00
|
|
|
// mParser->RegisterDTD(theDTD);
|
1999-07-14 15:33:48 +00:00
|
|
|
|
1999-12-09 07:18:38 +00:00
|
|
|
if(cdetflt)
|
2000-05-26 20:09:32 +00:00
|
|
|
// The current implementation for SetParserFilter needs to
|
|
|
|
// be changed to be more XPCOM friendly. See bug #40149
|
|
|
|
nsCOMPtr<nsIParserFilter> oldFilter = getter_AddRefs(mParser->SetParserFilter(cdetflt));
|
1999-12-09 07:18:38 +00:00
|
|
|
|
1999-12-13 21:00:47 +00:00
|
|
|
#ifdef DEBUG_charset
|
|
|
|
char* cCharset = charset.ToNewCString();
|
2000-10-28 22:17:53 +00:00
|
|
|
printf("set to parser charset = %s source %d\n",
|
1999-12-13 21:00:47 +00:00
|
|
|
cCharset, charsetSource);
|
|
|
|
Recycle(cCharset);
|
|
|
|
#endif
|
1999-12-09 07:18:38 +00:00
|
|
|
mParser->SetDocumentCharset( charset, charsetSource);
|
|
|
|
mParser->SetCommand(aCommand);
|
|
|
|
// create the content sink
|
2000-03-11 00:35:36 +00:00
|
|
|
nsCOMPtr<nsIWebShell> webShell(do_QueryInterface(docShell));
|
2001-03-03 00:39:29 +00:00
|
|
|
rv = NS_NewHTMLContentSink(getter_AddRefs(sink), this, aURL, webShell,aChannel);
|
1999-12-09 07:18:38 +00:00
|
|
|
if (NS_FAILED(rv)) { return rv; }
|
|
|
|
NS_ASSERTION(sink, "null sink with successful result from factory method");
|
|
|
|
mParser->SetContentSink(sink);
|
|
|
|
// parser the content of the URL
|
|
|
|
mParser->Parse(aURL, nsnull, PR_FALSE, (void *)this);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
1998-06-01 19:53:19 +00:00
|
|
|
|
|
|
|
return rv;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
Landing changes Vidur made while the tree was closed for beta1 work, here's a list of the changes. r=me
[1] Cutting down the size of content. Made nsIJSScriptObject inherit from nsIScriptObjectOwner
[2] Cutting down the size of content. Made nsITextContent inherit from nsIContent.
[3] Cutting down the size of content. Moved implementation of nsIDOMReceiver to nsListenerManager. This is not true aggregation since it isn't transitive, but it's OK for now. It will be necessary for nsListenerManager to have a reference to its content in the future anyway, so the transitivity could be done.
dom/public/nsDOMPropEnums.h,v - bug 12559
dom/public/nsIJSScriptObject.h,v - [1]
dom/public/html/MANIFEST,v - bug 12559
dom/public/html/Makefile.in,v - bug 12559
dom/public/html/makefile.win,v - bug 12559
dom/public/html/nsIDOMHTMLInputElement.h,v - bug 17544
dom/public/idl/html/HTMLAnchorElement.idl,v - bug 12559
dom/public/idl/html/HTMLAreaElement.idl,v - bug 12559
dom/public/idl/html/HTMLInputElement.idl,v - bug 17544
dom/src/base/nsGlobalWindow.cpp,v - bug 30700
dom/src/base/nsGlobalWindow.h,v - [1]
dom/src/base/nsLocation.cpp,v - [1]
dom/src/html/nsJSHTMLAnchorElement.cpp,v - bug 12559
dom/src/html/nsJSHTMLAreaElement.cpp,v - bug 12559
dom/src/html/nsJSHTMLInputElement.cpp,v - bug 17544
layout/base/public/nsIDocument.h,v - bug 27953
layout/base/public/nsITextContent.h,v - [2]
layout/base/src/nsCommentNode.cpp,v - [2]
layout/base/src/nsDocument.cpp,v - bug 27953
layout/base/src/nsDocument.h,v - bug 27953
layout/base/src/nsDocumentViewer.cpp,v - bug 27953
layout/base/src/nsGenericDOMDataNode.cpp,v - [3]
layout/base/src/nsGenericDOMDataNode.h,v - [3]
layout/base/src/nsGenericElement.cpp,v - [3]
layout/base/src/nsGenericElement.h,v - [3]
layout/base/src/nsNameSpaceManager.cpp,v - bug 7834
layout/base/src/nsStyleContext.cpp,v - outline property shouldn't reflow
layout/base/src/nsTextNode.cpp,v - [2]
layout/events/src/nsEventListenerManager.cpp,v - [3]
layout/events/src/nsEventListenerManager.h,v - [3]
layout/html/base/src/nsGfxScrollFrame.cpp,v - nsString->nsAutoString
layout/html/content/src/nsAttributeContent.cpp,v - [2]
layout/html/content/src/nsHTMLAnchorElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLAppletElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLAreaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBRElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBaseElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBaseFontElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBodyElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLButtonElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDelElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDirectoryElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDivElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLEmbedElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFieldSetElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFontElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFormElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFrameElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFrameSetElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHRElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHeadElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHeadingElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHtmlElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLIFrameElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLImageElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLInputElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLInsElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLIsIndexElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLIElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLabelElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLayerElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLegendElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLinkElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMapElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMenuElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMetaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLModElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLObjectElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOptGroupElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOptionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLParagraphElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLParamElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLPreElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLQuoteElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLScriptElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSelectElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSpacerElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSpanElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLStyleElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableCaptionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableCellElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableColElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableColGroupElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableRowElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableSectionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTextAreaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTitleElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLUListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLWBRElement.cpp,v - [1][3]
layout/html/document/src/nsHTMLDocument.cpp,v - bug 27953
layout/html/document/src/nsHTMLDocument.h,v - bug 27953
layout/xml/content/src/nsXMLCDATASection.cpp,v - [1][2]
layout/xml/content/src/nsXMLDocumentType.cpp,v - [1][2]
layout/xml/content/src/nsXMLElement.h,v - [1][2]
layout/xml/content/src/nsXMLEntity.cpp,v - [1][2]
layout/xml/content/src/nsXMLNotation.cpp,v - [1][2]
layout/xml/content/src/nsXMLProcessingInstruction.cpp,v - [1][2]
layout/xul/base/src/nsBoxFrame.cpp,v - nsString->nsAutoString
layout/xul/base/src/nsSliderFrame.cpp,v - nsString->nsAutoString
netwerk/protocol/http/src/nsHTTPRequest.cpp,v - nsString->nsAutoString
rdf/content/src/nsXULDocument.cpp,v - bug 27953
rdf/content/src/nsXULDocument.h,v - bug 27953
rdf/content/src/nsXULElement.h,v - [1]
xpcom/base/IIDS.h,v - bug 12559
2000-03-17 13:27:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::StopDocumentLoad()
|
|
|
|
{
|
|
|
|
if (mParser) {
|
|
|
|
mParser->Terminate();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-07-23 22:06:05 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::EndLoad()
|
|
|
|
{
|
|
|
|
NS_IF_RELEASE(mParser);
|
|
|
|
return nsDocument::EndLoad();
|
|
|
|
}
|
1998-07-01 11:16:09 +00:00
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::SetTitle(const nsAReadableString& aTitle)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
if (nsnull == mDocumentTitle) {
|
|
|
|
mDocumentTitle = new nsString(aTitle);
|
|
|
|
}
|
|
|
|
else {
|
2000-08-23 17:27:06 +00:00
|
|
|
mDocumentTitle->Assign(aTitle);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Pass on to any interested containers
|
1998-07-19 01:14:53 +00:00
|
|
|
PRInt32 i, n = mPresShells.Count();
|
1998-04-13 20:24:54 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
nsIPresShell* shell = (nsIPresShell*) mPresShells.ElementAt(i);
|
1999-02-12 17:45:58 +00:00
|
|
|
nsCOMPtr<nsIPresContext> cx;
|
|
|
|
shell->GetPresContext(getter_AddRefs(cx));
|
1999-11-27 03:11:10 +00:00
|
|
|
nsCOMPtr<nsISupports> container;
|
|
|
|
if (NS_OK == cx->GetContainer(getter_AddRefs(container))) {
|
|
|
|
if (container) {
|
2000-02-08 13:40:10 +00:00
|
|
|
nsCOMPtr<nsIBaseWindow> docShell(do_QueryInterface(container));
|
|
|
|
if(docShell) {
|
2000-08-23 17:27:06 +00:00
|
|
|
docShell->SetTitle(mDocumentTitle->GetUnicode());
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-09 00:15:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::AddImageMap(nsIDOMHTMLMapElement* aMap)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aMap, "null ptr");
|
|
|
|
if (nsnull == aMap) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (mImageMaps.AppendElement(aMap)) {
|
|
|
|
NS_ADDREF(aMap);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
1999-03-01 16:57:35 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::RemoveImageMap(nsIDOMHTMLMapElement* aMap)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aMap, "null ptr");
|
|
|
|
if (nsnull == aMap) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (mImageMaps.RemoveElement((void*)aMap)) {
|
|
|
|
NS_RELEASE(aMap);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-09 00:15:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetImageMap(const nsString& aMapName,
|
|
|
|
nsIDOMHTMLMapElement** aResult)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aResult, "null ptr");
|
|
|
|
if (nsnull == aResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoString name;
|
|
|
|
PRInt32 i, n = mImageMaps.Count();
|
|
|
|
for (i = 0; i < n; i++) {
|
1999-01-09 00:15:19 +00:00
|
|
|
nsIDOMHTMLMapElement* map = (nsIDOMHTMLMapElement*)mImageMaps.ElementAt(i);
|
1998-04-13 20:24:54 +00:00
|
|
|
if (NS_OK == map->GetName(name)) {
|
|
|
|
if (name.EqualsIgnoreCase(aMapName)) {
|
|
|
|
*aResult = map;
|
|
|
|
NS_ADDREF(map);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-01-15 22:26:30 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetAttributeStyleSheet(nsIHTMLStyleSheet** aResult)
|
1998-07-25 01:26:12 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aResult, "null ptr");
|
|
|
|
if (nsnull == aResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
*aResult = mAttrStyleSheet;
|
|
|
|
if (nsnull == mAttrStyleSheet) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE; // probably not the right error...
|
|
|
|
}
|
1998-09-12 02:43:19 +00:00
|
|
|
else {
|
|
|
|
NS_ADDREF(mAttrStyleSheet);
|
|
|
|
}
|
1998-07-25 01:26:12 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetInlineStyleSheet(nsIHTMLCSSStyleSheet** aResult)
|
1998-12-02 00:35:41 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aResult, "null ptr");
|
|
|
|
if (nsnull == aResult) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
*aResult = mStyleAttrStyleSheet;
|
|
|
|
if (nsnull == mStyleAttrStyleSheet) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE; // probably not the right error...
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
NS_ADDREF(mStyleAttrStyleSheet);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-12-26 01:01:41 +00:00
|
|
|
void
|
|
|
|
nsHTMLDocument::InternalAddStyleSheet(nsIStyleSheet* aSheet) // subclass hook for sheet ordering
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1999-01-23 07:07:09 +00:00
|
|
|
if (aSheet == mAttrStyleSheet) { // always first
|
|
|
|
mStyleSheets.InsertElementAt(aSheet, 0);
|
|
|
|
}
|
|
|
|
else if (aSheet == mStyleAttrStyleSheet) { // always last
|
|
|
|
mStyleSheets.AppendElement(aSheet);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
else {
|
1999-01-23 07:07:09 +00:00
|
|
|
if (mStyleAttrStyleSheet == mStyleSheets.ElementAt(mStyleSheets.Count() - 1)) {
|
|
|
|
// keep attr sheet last
|
|
|
|
mStyleSheets.InsertElementAt(aSheet, mStyleSheets.Count() - 1);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
mStyleSheets.AppendElement(aSheet);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-05-18 23:06:31 +00:00
|
|
|
void
|
|
|
|
nsHTMLDocument::InternalInsertStyleSheetAt(nsIStyleSheet* aSheet, PRInt32 aIndex)
|
1999-01-23 07:07:09 +00:00
|
|
|
{
|
|
|
|
mStyleSheets.InsertElementAt(aSheet, aIndex + 1); // offset one for the attr style sheet
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1999-01-15 02:01:36 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-06-23 03:29:44 +00:00
|
|
|
nsHTMLDocument::GetBaseURL(nsIURI*& aURL) const
|
1999-01-15 02:01:36 +00:00
|
|
|
{
|
|
|
|
if (nsnull != mBaseURL) {
|
|
|
|
NS_ADDREF(mBaseURL);
|
|
|
|
aURL = mBaseURL;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
aURL = GetDocumentURL();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-12-26 01:01:41 +00:00
|
|
|
nsHTMLDocument::SetBaseURL(const nsAReadableString& aURLSpec)
|
1999-01-15 02:01:36 +00:00
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
|
|
|
NS_IF_RELEASE(mBaseURL);
|
|
|
|
if (0 < aURLSpec.Length()) {
|
1999-06-23 19:55:21 +00:00
|
|
|
{
|
|
|
|
result = NS_NewURI(&mBaseURL, aURLSpec, mDocumentURL);
|
1999-01-15 02:01:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-12-26 01:01:41 +00:00
|
|
|
nsHTMLDocument::GetBaseTarget(nsAWritableString& aTarget) const
|
1999-01-15 02:01:36 +00:00
|
|
|
{
|
|
|
|
if (nsnull != mBaseTarget) {
|
2000-08-23 17:27:06 +00:00
|
|
|
aTarget.Assign(*mBaseTarget);
|
1999-01-15 02:01:36 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
aTarget.Truncate();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-12-26 01:01:41 +00:00
|
|
|
nsHTMLDocument::SetBaseTarget(const nsAReadableString& aTarget)
|
1999-01-15 02:01:36 +00:00
|
|
|
{
|
|
|
|
if (0 < aTarget.Length()) {
|
|
|
|
if (nsnull != mBaseTarget) {
|
|
|
|
*mBaseTarget = aTarget;
|
|
|
|
}
|
|
|
|
else {
|
2000-08-23 17:27:06 +00:00
|
|
|
mBaseTarget = new nsString(aTarget);
|
1999-01-15 02:01:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (nsnull != mBaseTarget) {
|
|
|
|
delete mBaseTarget;
|
|
|
|
mBaseTarget = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-09 19:10:24 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetLastModified(const nsAReadableString& aLastModified)
|
1999-08-09 19:10:24 +00:00
|
|
|
{
|
|
|
|
if (0 < aLastModified.Length()) {
|
|
|
|
if (nsnull != mLastModified) {
|
|
|
|
*mLastModified = aLastModified;
|
|
|
|
}
|
|
|
|
else {
|
2000-08-23 17:27:06 +00:00
|
|
|
mLastModified = new nsString(aLastModified);
|
1999-08-09 19:10:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (nsnull != mLastModified) {
|
2001-02-23 02:03:02 +00:00
|
|
|
delete mLastModified;
|
1999-08-09 19:10:24 +00:00
|
|
|
mLastModified = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-09-17 06:56:39 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetReferrer(const nsAReadableString& aReferrer)
|
1999-09-17 06:56:39 +00:00
|
|
|
{
|
|
|
|
if (0 < aReferrer.Length()) {
|
|
|
|
if (nsnull != mReferrer) {
|
|
|
|
*mReferrer = aReferrer;
|
|
|
|
}
|
|
|
|
else {
|
2000-08-23 17:27:06 +00:00
|
|
|
mReferrer = new nsString(aReferrer);
|
1999-09-17 06:56:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (nsnull != mReferrer) {
|
2001-02-23 02:03:02 +00:00
|
|
|
delete mReferrer;
|
1999-09-17 06:56:39 +00:00
|
|
|
mReferrer = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-05-18 23:06:31 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetCSSLoader(nsICSSLoader*& aLoader)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
if (! mCSSLoader) {
|
|
|
|
result = NS_NewCSSLoader(this, &mCSSLoader);
|
|
|
|
}
|
1999-07-07 01:27:08 +00:00
|
|
|
if (mCSSLoader) {
|
|
|
|
mCSSLoader->SetCaseSensitive(PR_FALSE);
|
2000-05-04 05:54:04 +00:00
|
|
|
mCSSLoader->SetQuirkMode(PRBool(eDTDMode_strict!= mDTDMode));
|
1999-07-07 01:27:08 +00:00
|
|
|
}
|
1999-05-18 23:06:31 +00:00
|
|
|
aLoader = mCSSLoader;
|
|
|
|
NS_IF_ADDREF(aLoader);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-01-15 02:01:36 +00:00
|
|
|
|
1998-09-02 02:06:39 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetDTDMode(nsDTDMode& aMode)
|
|
|
|
{
|
|
|
|
aMode = mDTDMode;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::SetDTDMode(nsDTDMode aMode)
|
|
|
|
{
|
|
|
|
mDTDMode = aMode;
|
1999-07-07 01:27:08 +00:00
|
|
|
if (mCSSLoader) {
|
2000-05-04 05:54:04 +00:00
|
|
|
mCSSLoader->SetQuirkMode(PRBool(eDTDMode_strict!= mDTDMode));
|
1999-07-07 01:27:08 +00:00
|
|
|
}
|
1999-09-15 17:57:16 +00:00
|
|
|
|
|
|
|
nsIPresShell* shell = (nsIPresShell*) mPresShells.ElementAt(0);
|
|
|
|
if (nsnull != shell) {
|
|
|
|
nsCOMPtr<nsIPresContext> pc;
|
|
|
|
shell->GetPresContext(getter_AddRefs(pc));
|
|
|
|
if (pc) {
|
2000-05-04 05:54:04 +00:00
|
|
|
pc->SetCompatibilityMode(((eDTDMode_strict== mDTDMode) ?
|
1999-09-15 17:57:16 +00:00
|
|
|
eCompatibility_Standard :
|
|
|
|
eCompatibility_NavQuirks));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-23 07:07:09 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetHeaderData(nsIAtom* aHeaderField,
|
|
|
|
const nsAReadableString& aData)
|
1999-01-23 07:07:09 +00:00
|
|
|
{
|
|
|
|
nsresult result = nsMarkupDocument::SetHeaderData(aHeaderField, aData);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
if (aHeaderField == nsHTMLAtoms::headerDefaultStyle) {
|
|
|
|
// switch alternate style sheets based on default
|
|
|
|
nsAutoString type;
|
|
|
|
nsAutoString title;
|
2000-04-15 20:15:37 +00:00
|
|
|
nsAutoString textHtml; textHtml.AssignWithConversion("text/html");
|
1999-01-23 07:07:09 +00:00
|
|
|
PRInt32 index;
|
|
|
|
PRInt32 count = mStyleSheets.Count();
|
|
|
|
for (index = 0; index < count; index++) {
|
|
|
|
nsIStyleSheet* sheet = (nsIStyleSheet*)mStyleSheets.ElementAt(index);
|
|
|
|
sheet->GetType(type);
|
|
|
|
if (PR_FALSE == type.Equals(textHtml)) {
|
|
|
|
sheet->GetTitle(title);
|
|
|
|
if (0 < title.Length()) { // if sheet has title
|
2000-08-23 17:27:06 +00:00
|
|
|
nsAutoString data(aData);
|
1999-01-23 07:07:09 +00:00
|
|
|
PRBool disabled = ((0 == aData.Length()) ||
|
2000-08-23 17:27:06 +00:00
|
|
|
(PR_FALSE == title.EqualsIgnoreCase(data)));
|
1999-01-23 07:07:09 +00:00
|
|
|
SetStyleSheetDisabledState(sheet, disabled);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::ContentAppended(nsIContent* aContainer,
|
|
|
|
PRInt32 aNewIndexInContainer)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = RegisterNamedItems(aContainer);
|
2001-01-08 22:16:52 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nsDocument::ContentAppended(aContainer, aNewIndexInContainer);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-03-22 08:51:52 +00:00
|
|
|
nsHTMLDocument::ContentInserted(nsIContent* aContainer, nsIContent* aContent,
|
1998-11-28 23:51:06 +00:00
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = RegisterNamedItems(aContent);
|
1998-11-28 23:51:06 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
return nsDocument::ContentInserted(aContainer, aContent, aIndexInContainer);
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-03-22 08:51:52 +00:00
|
|
|
nsHTMLDocument::ContentReplaced(nsIContent* aContainer, nsIContent* aOldChild,
|
1998-11-28 23:51:06 +00:00
|
|
|
nsIContent* aNewChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = UnregisterNamedItems(aOldChild);
|
1998-11-28 23:51:06 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = RegisterNamedItems(aNewChild);
|
1998-11-28 23:51:06 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nsDocument::ContentReplaced(aContainer, aOldChild,
|
|
|
|
aNewChild, aIndexInContainer);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-03-22 08:51:52 +00:00
|
|
|
nsHTMLDocument::ContentRemoved(nsIContent* aContainer, nsIContent* aContent,
|
1998-11-28 23:51:06 +00:00
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = UnregisterNamedItems(aContent);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nsDocument::ContentRemoved(aContainer, aContent, aIndexInContainer);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::AttributeWillChange(nsIContent* aContent, PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom* aAttribute)
|
|
|
|
{
|
|
|
|
// XXX: Check namespaces!!!
|
|
|
|
|
|
|
|
if (aAttribute == nsHTMLAtoms::name) {
|
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
nsAutoString value;
|
|
|
|
|
|
|
|
aContent->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (IsNamedItem(aContent, tag, value)) {
|
|
|
|
nsresult rv = RemoveFromNameTable(value, aContent);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (aAttribute == nsHTMLAtoms::id) {
|
|
|
|
nsresult rv = RemoveFromIdTable(aContent);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nsDocument::AttributeWillChange(aContent, aNameSpaceID, aAttribute);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::AttributeChanged(nsIContent* aContent, PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom* aAttribute, PRInt32 aHint)
|
|
|
|
{
|
|
|
|
// XXX: Check namespaces!
|
|
|
|
|
|
|
|
if (aAttribute == nsHTMLAtoms::name) {
|
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
nsAutoString value;
|
|
|
|
|
|
|
|
aContent->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (IsNamedItem(aContent, tag, value)) {
|
|
|
|
nsresult rv = AddToNameTable(value, aContent);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (aAttribute == nsHTMLAtoms::id) {
|
|
|
|
nsAutoString value;
|
|
|
|
|
|
|
|
aContent->GetAttribute(aNameSpaceID, nsHTMLAtoms::id, value);
|
1998-11-28 23:51:06 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!value.IsEmpty()) {
|
|
|
|
nsresult rv = AddToIdTable(value, aContent, PR_TRUE);
|
1998-11-28 23:51:06 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
return nsDocument::AttributeChanged(aContent, aNameSpaceID, aAttribute,
|
|
|
|
aHint);
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
2000-01-24 06:43:15 +00:00
|
|
|
NS_IMETHODIMP
|
2001-02-06 05:46:46 +00:00
|
|
|
nsHTMLDocument::FlushPendingNotifications(PRBool aFlushReflows)
|
2000-01-24 06:43:15 +00:00
|
|
|
{
|
2000-10-17 05:07:39 +00:00
|
|
|
// Determine if it is safe to flush the sink
|
|
|
|
// by determining if it safe to flush all the presshells.
|
|
|
|
PRBool isSafeToFlush = PR_TRUE;
|
|
|
|
PRInt32 i = 0, n = mPresShells.Count();
|
|
|
|
while ((i < n) && (isSafeToFlush)) {
|
|
|
|
nsIPresShell* shell = NS_STATIC_CAST(nsIPresShell*, mPresShells[i]);
|
2001-02-06 05:46:46 +00:00
|
|
|
if (shell) {
|
|
|
|
shell->IsSafeToFlush(isSafeToFlush);
|
2000-10-17 05:07:39 +00:00
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
2000-01-24 06:43:15 +00:00
|
|
|
nsresult result = NS_OK;
|
2000-10-17 05:07:39 +00:00
|
|
|
if ((isSafeToFlush) && (mParser)) {
|
2000-01-24 06:43:15 +00:00
|
|
|
nsCOMPtr<nsIContentSink> sink;
|
|
|
|
|
|
|
|
// XXX Ack! Parser doesn't addref sink before passing it back
|
|
|
|
sink = mParser->GetContentSink();
|
|
|
|
if (sink) {
|
|
|
|
result = sink->FlushPendingNotifications();
|
|
|
|
}
|
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2000-01-24 06:43:15 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
2001-02-06 05:46:46 +00:00
|
|
|
result = nsDocument::FlushPendingNotifications(aFlushReflows);
|
2000-01-24 06:43:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2000-06-09 04:19:09 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateElementNS(const nsAReadableString& aNamespaceURI,
|
|
|
|
const nsAReadableString& aQualifiedName,
|
|
|
|
nsIDOMElement** aReturn)
|
2000-06-09 04:19:09 +00:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsINodeInfo> nodeInfo;
|
|
|
|
rv = mNodeInfoManager->GetNodeInfo(aQualifiedName, aNamespaceURI,
|
|
|
|
*getter_AddRefs(nodeInfo));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
PRInt32 namespaceID;
|
|
|
|
nodeInfo->GetNamespaceID(namespaceID);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
if (namespaceID == kNameSpaceID_HTML) {
|
|
|
|
nsCOMPtr<nsIHTMLContent> htmlContent;
|
|
|
|
|
|
|
|
rv = NS_CreateHTMLElement(getter_AddRefs(htmlContent), nodeInfo);
|
|
|
|
content = do_QueryInterface(htmlContent);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nsCOMPtr<nsIXMLContent> xmlContent;
|
|
|
|
rv = NS_NewXMLElement(getter_AddRefs(xmlContent), nodeInfo);
|
|
|
|
content = do_QueryInterface(xmlContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
content->SetContentID(mNextContentID++);
|
|
|
|
|
2000-09-09 05:46:14 +00:00
|
|
|
return content->QueryInterface(NS_GET_IID(nsIDOMElement), (void**)aReturn);
|
2000-06-09 04:19:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
//
|
|
|
|
// nsIDOMDocument interface implementation
|
|
|
|
//
|
1998-07-14 18:44:44 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateElement(const nsAReadableString& aTagName,
|
1998-07-14 18:44:44 +00:00
|
|
|
nsIDOMElement** aReturn)
|
1998-05-04 17:54:45 +00:00
|
|
|
{
|
2000-05-10 13:13:39 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aReturn);
|
|
|
|
NS_ENSURE_TRUE(aTagName.Length(), NS_ERROR_DOM_INVALID_CHARACTER_ERR);
|
|
|
|
|
|
|
|
nsCOMPtr<nsINodeInfo> nodeInfo;
|
|
|
|
nsAutoString tmp(aTagName);
|
|
|
|
tmp.ToLowerCase();
|
|
|
|
|
2000-09-20 05:12:44 +00:00
|
|
|
mNodeInfoManager->GetNodeInfo(tmp, nsnull, kNameSpaceID_None,
|
2000-05-10 13:13:39 +00:00
|
|
|
*getter_AddRefs(nodeInfo));
|
|
|
|
|
1999-10-08 20:41:19 +00:00
|
|
|
nsCOMPtr<nsIHTMLContent> content;
|
2000-05-10 13:13:39 +00:00
|
|
|
nsresult rv = NS_CreateHTMLElement(getter_AddRefs(content), nodeInfo);
|
1999-10-08 20:41:19 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2000-03-21 03:25:16 +00:00
|
|
|
content->SetContentID(mNextContentID++);
|
2000-09-09 05:46:14 +00:00
|
|
|
rv = content->QueryInterface(NS_GET_IID(nsIDOMElement), (void**)aReturn);
|
1998-05-04 17:54:45 +00:00
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateProcessingInstruction(const nsAReadableString& aTarget,
|
|
|
|
const nsAReadableString& aData,
|
1998-10-20 17:07:23 +00:00
|
|
|
nsIDOMProcessingInstruction** aReturn)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1998-10-20 17:07:23 +00:00
|
|
|
// There are no PIs for HTML
|
|
|
|
*aReturn = nsnull;
|
|
|
|
|
1999-09-08 23:18:27 +00:00
|
|
|
return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateCDATASection(const nsAReadableString& aData,
|
1998-10-20 17:07:23 +00:00
|
|
|
nsIDOMCDATASection** aReturn)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1998-10-20 17:07:23 +00:00
|
|
|
// There are no CDATASections in HTML
|
|
|
|
*aReturn = nsnull;
|
|
|
|
|
1999-09-08 23:18:27 +00:00
|
|
|
return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
|
1998-10-20 17:07:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateEntityReference(const nsAReadableString& aName,
|
1998-10-20 17:07:23 +00:00
|
|
|
nsIDOMEntityReference** aReturn)
|
|
|
|
{
|
|
|
|
// There are no EntityReferences in HTML
|
|
|
|
*aReturn = nsnull;
|
|
|
|
|
1999-09-08 23:18:27 +00:00
|
|
|
return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1998-10-20 17:07:23 +00:00
|
|
|
nsHTMLDocument::GetDoctype(nsIDOMDocumentType** aDocumentType)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2000-03-22 22:16:14 +00:00
|
|
|
return nsDocument::GetDoctype(aDocumentType);
|
1998-10-20 17:07:23 +00:00
|
|
|
}
|
|
|
|
|
1999-01-19 16:58:45 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetImplementation(nsIDOMDOMImplementation** aImplementation)
|
|
|
|
{
|
|
|
|
return nsDocument::GetImplementation(aImplementation);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetDocumentElement(nsIDOMElement** aDocumentElement)
|
|
|
|
{
|
|
|
|
return nsDocument::GetDocumentElement(aDocumentElement);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::CreateDocumentFragment(nsIDOMDocumentFragment** aReturn)
|
|
|
|
{
|
|
|
|
return nsDocument::CreateDocumentFragment(aReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateComment(const nsAReadableString& aData, nsIDOMComment** aReturn)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
|
|
|
return nsDocument::CreateComment(aData, aReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateAttribute(const nsAReadableString& aName, nsIDOMAttr** aReturn)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
|
|
|
return nsDocument::CreateAttribute(aName, aReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateTextNode(const nsAReadableString& aData, nsIDOMText** aReturn)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
|
|
|
return nsDocument::CreateTextNode(aData, aReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetElementsByTagName(const nsAReadableString& aTagname, nsIDOMNodeList** aReturn)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
2000-05-17 03:47:06 +00:00
|
|
|
nsAutoString tmp(aTagname);
|
|
|
|
tmp.ToLowerCase(); // HTML elements are lower case internally.
|
|
|
|
return nsDocument::GetElementsByTagName(tmp, aReturn);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// nsIDOMNode interface implementation
|
|
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetChildNodes(nsIDOMNodeList** aChildNodes)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::GetChildNodes(aChildNodes);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetFirstChild(nsIDOMNode** aFirstChild)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::GetFirstChild(aFirstChild);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetLastChild(nsIDOMNode** aLastChild)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::GetLastChild(aLastChild);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::InsertBefore(nsIDOMNode* aNewChild,
|
|
|
|
nsIDOMNode* aRefChild,
|
|
|
|
nsIDOMNode** aReturn)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::InsertBefore(aNewChild, aRefChild, aReturn);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::ReplaceChild(nsIDOMNode* aNewChild,
|
|
|
|
nsIDOMNode* aOldChild,
|
|
|
|
nsIDOMNode** aReturn)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::ReplaceChild(aNewChild, aOldChild, aReturn);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::RemoveChild(aOldChild, aReturn);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::AppendChild(aNewChild, aReturn);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::HasChildNodes(PRBool* aReturn)
|
|
|
|
{
|
1999-03-31 20:49:25 +00:00
|
|
|
return nsDocument::HasChildNodes(aReturn);
|
1999-01-19 16:58:45 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 05:19:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::HasAttributes(PRBool* aReturn)
|
|
|
|
{
|
|
|
|
return nsDocument::HasAttributes(aReturn);
|
|
|
|
}
|
|
|
|
|
1999-01-19 16:58:45 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetNodeName(nsAWritableString& aNodeName)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
|
|
|
return nsDocument::GetNodeName(aNodeName);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetNodeValue(nsAWritableString& aNodeValue)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
|
|
|
return nsDocument::GetNodeValue(aNodeValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetNodeValue(const nsAReadableString& aNodeValue)
|
1999-01-19 16:58:45 +00:00
|
|
|
{
|
|
|
|
return nsDocument::SetNodeValue(aNodeValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetNodeType(PRUint16* aNodeType)
|
|
|
|
{
|
|
|
|
return nsDocument::GetNodeType(aNodeType);
|
|
|
|
}
|
|
|
|
|
2000-04-01 13:31:23 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetNamespaceURI(nsAWritableString& aNamespaceURI)
|
2000-04-01 13:31:23 +00:00
|
|
|
{
|
|
|
|
return nsDocument::GetNamespaceURI(aNamespaceURI);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetPrefix(nsAWritableString& aPrefix)
|
2000-04-01 13:31:23 +00:00
|
|
|
{
|
|
|
|
return nsDocument::GetPrefix(aPrefix);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetPrefix(const nsAReadableString& aPrefix)
|
2000-04-01 13:31:23 +00:00
|
|
|
{
|
|
|
|
return nsDocument::SetPrefix(aPrefix);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetLocalName(nsAWritableString& aLocalName)
|
2000-04-01 13:31:23 +00:00
|
|
|
{
|
|
|
|
return nsDocument::GetLocalName(aLocalName);
|
|
|
|
}
|
|
|
|
|
1999-01-19 16:58:45 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetParentNode(nsIDOMNode** aParentNode)
|
|
|
|
{
|
|
|
|
return nsDocument::GetParentNode(aParentNode);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetPreviousSibling(nsIDOMNode** aPreviousSibling)
|
|
|
|
{
|
|
|
|
return nsDocument::GetPreviousSibling(aPreviousSibling);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetNextSibling(nsIDOMNode** aNextSibling)
|
|
|
|
{
|
|
|
|
return nsDocument::GetNextSibling(aNextSibling);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetAttributes(nsIDOMNamedNodeMap** aAttributes)
|
|
|
|
{
|
|
|
|
return nsDocument::GetAttributes(aAttributes);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetOwnerDocument(nsIDOMDocument** aOwnerDocument)
|
|
|
|
{
|
|
|
|
return nsDocument::GetOwnerDocument(aOwnerDocument);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::CloneNode(PRBool aDeep, nsIDOMNode** aReturn)
|
|
|
|
{
|
|
|
|
return nsDocument::CloneNode(aDeep, aReturn);
|
|
|
|
}
|
|
|
|
|
2000-04-01 13:31:23 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::Normalize()
|
|
|
|
{
|
|
|
|
return nsDocument::Normalize();
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-09-14 05:19:00 +00:00
|
|
|
nsHTMLDocument::IsSupported(const nsAReadableString& aFeature,
|
|
|
|
const nsAReadableString& aVersion,
|
|
|
|
PRBool* aReturn)
|
2000-04-01 13:31:23 +00:00
|
|
|
{
|
2000-09-14 05:19:00 +00:00
|
|
|
return nsDocument::IsSupported(aFeature, aVersion, aReturn);
|
2000-04-01 13:31:23 +00:00
|
|
|
}
|
|
|
|
|
2001-03-30 02:15:21 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetBaseURI(nsAWritableString &aURI)
|
|
|
|
{
|
|
|
|
aURI.Truncate();
|
|
|
|
nsCOMPtr<nsIURI> uri(do_QueryInterface(mBaseURL ? mBaseURL : mDocumentURL));
|
|
|
|
if (uri) {
|
|
|
|
nsXPIDLCString spec;
|
|
|
|
uri->GetSpec(getter_Copies(spec));
|
|
|
|
if (spec) {
|
|
|
|
CopyASCIItoUCS2(nsLiteralCString(spec), aURI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-19 16:58:45 +00:00
|
|
|
|
1998-10-20 17:07:23 +00:00
|
|
|
//
|
|
|
|
// nsIDOMHTMLDocument interface implementation
|
|
|
|
//
|
1998-12-07 06:10:12 +00:00
|
|
|
// see http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html.html#ID-1006298752
|
|
|
|
// for full specification.
|
|
|
|
//
|
1998-10-20 17:07:23 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetTitle(nsAWritableString& aTitle)
|
1998-10-20 17:07:23 +00:00
|
|
|
{
|
|
|
|
if (nsnull != mDocumentTitle) {
|
2000-08-23 17:27:06 +00:00
|
|
|
aTitle.Assign(*mDocumentTitle);
|
|
|
|
} else {
|
|
|
|
aTitle.Truncate();
|
1998-10-20 17:07:23 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetReferrer(nsAWritableString& aReferrer)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-09-17 06:56:39 +00:00
|
|
|
if (nsnull != mReferrer) {
|
2000-08-23 17:27:06 +00:00
|
|
|
aReferrer.Assign(*mReferrer);
|
1998-12-07 06:10:12 +00:00
|
|
|
}
|
1999-09-17 06:56:39 +00:00
|
|
|
else {
|
|
|
|
aReferrer.Truncate();
|
|
|
|
}
|
|
|
|
|
1998-12-07 06:10:12 +00:00
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-10-02 03:41:37 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetDomainURI(nsIURI **uri)
|
|
|
|
{
|
2000-01-26 15:33:57 +00:00
|
|
|
nsCOMPtr<nsIPrincipal> principal;
|
|
|
|
if (NS_FAILED(GetPrincipal(getter_AddRefs(principal))))
|
1999-10-02 03:41:37 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsICodebasePrincipal> codebase = do_QueryInterface(principal);
|
|
|
|
if (!codebase)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
return codebase->GetURI(uri);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetDomain(nsAWritableString& aDomain)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-10-02 03:41:37 +00:00
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
if (NS_FAILED(GetDomainURI(getter_AddRefs(uri))))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
char *hostName;
|
|
|
|
if (NS_FAILED(uri->GetHost(&hostName)))
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-08-23 17:27:06 +00:00
|
|
|
aDomain.Assign(NS_ConvertASCIItoUCS2(hostName));
|
1999-10-02 03:41:37 +00:00
|
|
|
nsCRT::free(hostName);
|
|
|
|
|
1998-12-07 06:10:12 +00:00
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-10-02 03:41:37 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetDomain(const nsAReadableString& aDomain)
|
1999-10-02 03:41:37 +00:00
|
|
|
{
|
|
|
|
// Check new domain
|
2000-03-31 00:31:18 +00:00
|
|
|
|
1999-10-02 03:41:37 +00:00
|
|
|
nsAutoString current;
|
|
|
|
if (NS_FAILED(GetDomain(current)))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
PRBool ok = PR_FALSE;
|
|
|
|
if (current.Equals(aDomain)) {
|
|
|
|
ok = PR_TRUE;
|
|
|
|
} else if (aDomain.Length() < current.Length()) {
|
|
|
|
nsAutoString suffix;
|
|
|
|
current.Right(suffix, aDomain.Length());
|
|
|
|
PRUnichar c = current.CharAt(current.Length() - aDomain.Length() - 1);
|
2000-09-02 07:21:57 +00:00
|
|
|
if (suffix.EqualsIgnoreCase(nsString(aDomain)) &&
|
2000-08-23 17:27:06 +00:00
|
|
|
(c == '.' || c == '/'))
|
1999-10-02 03:41:37 +00:00
|
|
|
ok = PR_TRUE;
|
|
|
|
}
|
|
|
|
if (!ok) {
|
|
|
|
// Error: illegal domain
|
|
|
|
return NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN;
|
|
|
|
}
|
2000-03-31 00:31:18 +00:00
|
|
|
|
1999-10-02 03:41:37 +00:00
|
|
|
// Create new URI
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
if (NS_FAILED(GetDomainURI(getter_AddRefs(uri))))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsXPIDLCString scheme;
|
|
|
|
if (NS_FAILED(uri->GetScheme(getter_Copies(scheme))))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsXPIDLCString path;
|
|
|
|
if (NS_FAILED(uri->GetPath(getter_Copies(path))))
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-04-15 20:15:37 +00:00
|
|
|
nsAutoString newURIString; newURIString.AssignWithConversion( NS_STATIC_CAST(const char*, scheme) );
|
|
|
|
newURIString.AppendWithConversion("://");
|
1999-10-02 03:41:37 +00:00
|
|
|
newURIString += aDomain;
|
2000-04-15 20:15:37 +00:00
|
|
|
newURIString.AppendWithConversion(path);
|
1999-10-02 03:41:37 +00:00
|
|
|
nsIURI *newURI;
|
|
|
|
if (NS_FAILED(NS_NewURI(&newURI, newURIString)))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
1999-11-16 05:07:31 +00:00
|
|
|
// Get codebase principal
|
1999-10-02 03:41:37 +00:00
|
|
|
nsresult rv;
|
|
|
|
NS_WITH_SERVICE(nsIScriptSecurityManager, securityManager,
|
2000-09-13 23:57:52 +00:00
|
|
|
NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
|
1999-10-02 03:41:37 +00:00
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-03-31 00:31:18 +00:00
|
|
|
nsCOMPtr<nsIPrincipal> newCodebase;
|
|
|
|
rv = securityManager->GetCodebasePrincipal(newURI, getter_AddRefs(newCodebase));
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIAggregatePrincipal> agg = do_QueryInterface(mPrincipal, &rv);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Principal not an aggregate.");
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-10-19 10:25:49 +00:00
|
|
|
|
|
|
|
rv = agg->SetCodebase(newCodebase);
|
|
|
|
|
|
|
|
// Bug 13871: Frameset spoofing - note that document.domain was set
|
|
|
|
if (NS_SUCCEEDED(rv))
|
2000-10-24 04:35:25 +00:00
|
|
|
mDomainWasSet = PR_TRUE;
|
2000-10-19 10:25:49 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-10-24 04:35:25 +00:00
|
|
|
nsHTMLDocument::WasDomainSet(PRBool* aDomainWasSet)
|
2000-10-19 10:25:49 +00:00
|
|
|
{
|
2000-10-24 04:35:25 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aDomainWasSet);
|
|
|
|
*aDomainWasSet = mDomainWasSet;
|
2000-10-19 10:25:49 +00:00
|
|
|
return NS_OK;
|
1999-10-02 03:41:37 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetURL(nsAWritableString& aURL)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1998-11-24 21:07:43 +00:00
|
|
|
if (nsnull != mDocumentURL) {
|
1999-06-25 01:53:22 +00:00
|
|
|
char* str;
|
|
|
|
mDocumentURL->GetSpec(&str);
|
2000-08-23 17:27:06 +00:00
|
|
|
aURL.Assign(NS_ConvertASCIItoUCS2(str));
|
1999-06-25 01:53:22 +00:00
|
|
|
nsCRT::free(str);
|
1998-11-24 21:07:43 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetBody(nsIDOMHTMLElement** aBody)
|
|
|
|
{
|
2001-02-23 02:01:30 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aBody);
|
|
|
|
*aBody = nsnull;
|
|
|
|
|
|
|
|
nsISupports* element = nsnull;
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
|
|
|
|
if (mBodyContent || (GetBodyContent() && mBodyContent)) {
|
|
|
|
// There is a body element, return that as the body.
|
|
|
|
element = mBodyContent;
|
|
|
|
} else {
|
|
|
|
// The document is most likely a frameset document so look for the
|
|
|
|
// outer most frameset element
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList> nodeList;
|
|
|
|
|
|
|
|
nsresult rv = GetElementsByTagName(NS_LITERAL_STRING("frameset"),
|
|
|
|
getter_AddRefs(nodeList));
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
if (nodeList) {
|
|
|
|
rv = nodeList->Item(0, getter_AddRefs(node));
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
element = node;
|
|
|
|
}
|
1998-11-12 22:25:51 +00:00
|
|
|
}
|
2001-02-23 02:01:30 +00:00
|
|
|
|
|
|
|
return element ? CallQueryInterface(element, aBody) : NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::SetBody(nsIDOMHTMLElement* aBody)
|
|
|
|
{
|
2000-12-14 22:37:22 +00:00
|
|
|
nsCOMPtr<nsIDOMHTMLBodyElement> bodyElement(do_QueryInterface(aBody));
|
|
|
|
|
|
|
|
// The body element must be of type nsIDOMHTMLBodyElement.
|
|
|
|
if (!bodyElement) {
|
|
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
1999-02-04 02:16:11 +00:00
|
|
|
}
|
|
|
|
|
2000-12-14 22:37:22 +00:00
|
|
|
nsCOMPtr<nsIDOMElement> root;
|
|
|
|
GetDocumentElement(getter_AddRefs(root));
|
|
|
|
|
|
|
|
if (!root) {
|
|
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoString bodyStr;
|
|
|
|
bodyStr.AssignWithConversion("BODY");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> child;
|
|
|
|
root->GetFirstChild(getter_AddRefs(child));
|
|
|
|
|
|
|
|
while (child) {
|
|
|
|
nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(child));
|
|
|
|
|
|
|
|
if (domElement) {
|
|
|
|
nsAutoString tagName;
|
1999-02-04 02:16:11 +00:00
|
|
|
|
|
|
|
domElement->GetTagName(tagName);
|
2000-12-14 22:37:22 +00:00
|
|
|
|
1999-02-04 02:16:11 +00:00
|
|
|
if (bodyStr.EqualsIgnoreCase(tagName)) {
|
2000-12-14 22:37:22 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> ret;
|
|
|
|
|
|
|
|
nsresult rv = root->ReplaceChild(aBody, child, getter_AddRefs(ret));
|
|
|
|
|
1999-02-04 02:16:11 +00:00
|
|
|
NS_IF_RELEASE(mBodyContent);
|
|
|
|
|
2000-12-14 22:37:22 +00:00
|
|
|
return rv;
|
1999-02-04 02:16:11 +00:00
|
|
|
}
|
|
|
|
}
|
2000-12-14 22:37:22 +00:00
|
|
|
|
|
|
|
nsIDOMNode *tmpNode = child;
|
|
|
|
tmpNode->GetNextSibling(getter_AddRefs(child));
|
1999-02-04 02:16:11 +00:00
|
|
|
}
|
2000-12-14 22:37:22 +00:00
|
|
|
|
1999-02-04 02:16:11 +00:00
|
|
|
return PR_FALSE;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetImages(nsIDOMHTMLCollection** aImages)
|
|
|
|
{
|
|
|
|
if (nsnull == mImages) {
|
2000-05-17 20:35:19 +00:00
|
|
|
mImages = new nsContentList(this, nsHTMLAtoms::img, kNameSpaceID_Unknown);
|
1998-07-22 23:32:19 +00:00
|
|
|
if (nsnull == mImages) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
NS_ADDREF(mImages);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aImages = (nsIDOMHTMLCollection *)mImages;
|
|
|
|
NS_ADDREF(mImages);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetApplets(nsIDOMHTMLCollection** aApplets)
|
|
|
|
{
|
|
|
|
if (nsnull == mApplets) {
|
2000-05-17 20:35:19 +00:00
|
|
|
mApplets = new nsContentList(this, nsHTMLAtoms::applet, kNameSpaceID_Unknown);
|
1998-07-22 23:32:19 +00:00
|
|
|
if (nsnull == mApplets) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
NS_ADDREF(mApplets);
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-09-25 00:51:45 +00:00
|
|
|
*aApplets = (nsIDOMHTMLCollection *)mApplets;
|
|
|
|
NS_ADDREF(mApplets);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
PRBool
|
1999-05-04 20:53:44 +00:00
|
|
|
nsHTMLDocument::MatchLinks(nsIContent *aContent, nsString* aData)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1998-08-29 20:20:38 +00:00
|
|
|
nsIAtom *name;
|
|
|
|
aContent->GetTag(name);
|
1998-07-22 23:32:19 +00:00
|
|
|
nsAutoString attr;
|
|
|
|
PRBool result = PR_FALSE;
|
|
|
|
|
|
|
|
if ((nsnull != name) &&
|
1999-01-15 19:18:30 +00:00
|
|
|
((nsHTMLAtoms::area == name) || (nsHTMLAtoms::a == name)) &&
|
1998-12-20 01:21:23 +00:00
|
|
|
(NS_CONTENT_ATTR_HAS_VALUE == aContent->GetAttribute(kNameSpaceID_HTML, nsHTMLAtoms::href, attr))) {
|
1998-07-22 23:32:19 +00:00
|
|
|
result = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IF_RELEASE(name);
|
|
|
|
return result;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetLinks(nsIDOMHTMLCollection** aLinks)
|
|
|
|
{
|
|
|
|
if (nsnull == mLinks) {
|
2001-03-22 08:51:52 +00:00
|
|
|
mLinks = new nsContentList(this, MatchLinks, nsString());
|
1998-07-22 23:32:19 +00:00
|
|
|
if (nsnull == mLinks) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
NS_ADDREF(mLinks);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aLinks = (nsIDOMHTMLCollection *)mLinks;
|
|
|
|
NS_ADDREF(mLinks);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
PRBool
|
1999-05-04 20:53:44 +00:00
|
|
|
nsHTMLDocument::MatchAnchors(nsIContent *aContent, nsString* aData)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1998-08-29 20:20:38 +00:00
|
|
|
nsIAtom *name;
|
|
|
|
aContent->GetTag(name);
|
1998-07-22 23:32:19 +00:00
|
|
|
nsAutoString attr;
|
|
|
|
PRBool result = PR_FALSE;
|
|
|
|
|
|
|
|
if ((nsnull != name) &&
|
1999-01-15 19:18:30 +00:00
|
|
|
(nsHTMLAtoms::a == name) &&
|
1998-12-20 01:21:23 +00:00
|
|
|
(NS_CONTENT_ATTR_HAS_VALUE == aContent->GetAttribute(kNameSpaceID_HTML, nsHTMLAtoms::name, attr))) {
|
1998-07-22 23:32:19 +00:00
|
|
|
result = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IF_RELEASE(name);
|
|
|
|
return result;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetAnchors(nsIDOMHTMLCollection** aAnchors)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!mAnchors) {
|
|
|
|
mAnchors = new nsContentList(this, MatchAnchors, nsString());
|
|
|
|
NS_ENSURE_TRUE(mAnchors, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_ADDREF(mAnchors);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aAnchors = (nsIDOMHTMLCollection *)mAnchors;
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_ADDREF(*aAnchors);
|
1998-07-22 23:32:19 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetCookie(nsAWritableString& aCookie)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-08-19 22:23:20 +00:00
|
|
|
nsresult result = NS_OK;
|
2000-08-23 17:27:06 +00:00
|
|
|
nsAutoString str;
|
1999-08-19 22:23:20 +00:00
|
|
|
NS_WITH_SERVICE(nsICookieService, service, kCookieServiceCID, &result);
|
2001-03-29 02:11:48 +00:00
|
|
|
char * cookie;
|
1999-08-19 22:23:20 +00:00
|
|
|
if ((NS_OK == result) && (nsnull != service) && (nsnull != mDocumentURL)) {
|
2001-03-29 02:11:48 +00:00
|
|
|
result = service->GetCookieString(mDocumentURL, &cookie);
|
|
|
|
}
|
|
|
|
if (nsnull != cookie) {
|
|
|
|
str.AssignWithConversion(cookie);
|
|
|
|
nsCRT::free(cookie);
|
|
|
|
} else {
|
|
|
|
// No Cookie isn't an error condition.
|
|
|
|
aCookie.Truncate();
|
1999-08-19 22:23:20 +00:00
|
|
|
}
|
2000-08-23 17:27:06 +00:00
|
|
|
aCookie.Assign(str);
|
1999-08-19 22:23:20 +00:00
|
|
|
return result;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetCookie(const nsAReadableString& aCookie)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-08-19 22:23:20 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
NS_WITH_SERVICE(nsICookieService, service, kCookieServiceCID, &result);
|
|
|
|
if ((NS_OK == result) && (nsnull != service) && (nsnull != mDocumentURL)) {
|
2001-03-29 02:11:48 +00:00
|
|
|
char *cookie = nsString(aCookie).ToNewCString();
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> globalObj;
|
|
|
|
nsCOMPtr<nsIPrompt> prompt;
|
|
|
|
this->GetScriptGlobalObject(getter_AddRefs(globalObj));
|
|
|
|
if (globalObj) {
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> window (do_QueryInterface(globalObj));
|
|
|
|
if (window) {
|
|
|
|
window->GetPrompter(getter_AddRefs(prompt));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result = service->SetCookieString(mDocumentURL, prompt, cookie);
|
|
|
|
nsCRT::free(cookie);
|
1999-08-19 22:23:20 +00:00
|
|
|
}
|
|
|
|
return result;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
|
1999-05-18 23:44:55 +00:00
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::GetSourceDocumentURL(JSContext* cx,
|
1999-06-23 03:29:44 +00:00
|
|
|
nsIURI** sourceURL)
|
1999-05-18 23:44:55 +00:00
|
|
|
{
|
|
|
|
// XXX Tom said this reminded him of the "Six Degrees of
|
|
|
|
// Kevin Bacon" game. We try to get from here to there using
|
|
|
|
// whatever connections possible. The problem is that this
|
|
|
|
// could break if any of the connections along the way change.
|
|
|
|
// I wish there were a better way.
|
1999-08-18 08:48:33 +00:00
|
|
|
*sourceURL = nsnull;
|
|
|
|
|
1999-12-18 20:29:29 +00:00
|
|
|
// XXX Question, why does this return NS_OK on failure?
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
|
|
|
// We need to use the dynamically scoped global and assume that the
|
|
|
|
// current JSContext is a DOM context with a nsIScriptGlobalObject so
|
|
|
|
// that we can get the url of the caller.
|
|
|
|
// XXX This will fail on non-DOM contexts :(
|
1999-05-18 23:44:55 +00:00
|
|
|
|
1999-12-18 20:29:29 +00:00
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
2001-02-19 12:55:42 +00:00
|
|
|
nsContentUtils::GetDynamicScriptGlobal(cx, getter_AddRefs(global));
|
1999-12-18 20:29:29 +00:00
|
|
|
if (global) {
|
2000-09-01 01:54:35 +00:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> window(do_QueryInterface(global, &result));
|
1999-05-18 23:44:55 +00:00
|
|
|
|
1999-12-18 20:29:29 +00:00
|
|
|
if (window) {
|
|
|
|
nsCOMPtr<nsIDOMDocument> document;
|
|
|
|
|
|
|
|
result = window->GetDocument(getter_AddRefs(document));
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryInterface(document, &result));
|
|
|
|
if (doc) {
|
|
|
|
*sourceURL = doc->GetDocumentURL();
|
|
|
|
result = sourceURL ? NS_OK : NS_ERROR_FAILURE;
|
|
|
|
}
|
1999-05-18 23:44:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-05-28 00:18:48 +00:00
|
|
|
|
|
|
|
// XXX TBI: accepting arguments to the open method.
|
|
|
|
nsresult
|
1999-06-23 03:29:44 +00:00
|
|
|
nsHTMLDocument::OpenCommon(nsIURI* aSourceURL)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2000-09-19 05:11:59 +00:00
|
|
|
// If we already have a parser we ignore the document.open call.
|
|
|
|
if (mParser)
|
|
|
|
return NS_OK;
|
2000-06-08 22:51:06 +00:00
|
|
|
|
|
|
|
// Stop current loads targetted at the window this document is in.
|
|
|
|
if (mScriptGlobalObject) {
|
|
|
|
nsCOMPtr<nsIDocShell> docshell;
|
|
|
|
mScriptGlobalObject->GetDocShell(getter_AddRefs(docshell));
|
|
|
|
|
|
|
|
if (docshell) {
|
2000-07-21 23:44:38 +00:00
|
|
|
docshell->StopLoad();
|
2000-06-08 22:51:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-09-19 05:11:59 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
// The open occurred after the document finished loading.
|
|
|
|
// So we reset the document and create a new one.
|
2000-09-19 05:11:59 +00:00
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
|
|
nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);
|
1999-09-21 06:44:56 +00:00
|
|
|
|
2000-09-19 05:11:59 +00:00
|
|
|
result = NS_OpenURI(getter_AddRefs(channel), aSourceURL, nsnull, group);
|
|
|
|
if (NS_FAILED(result)) return result;
|
2000-08-12 22:19:55 +00:00
|
|
|
|
2000-09-19 05:11:59 +00:00
|
|
|
//Before we reset the doc notify the globalwindow of the change.
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2000-09-19 05:11:59 +00:00
|
|
|
if (mScriptGlobalObject) {
|
|
|
|
//Hold onto ourselves on the offchance that we're down to one ref
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument> kungFuDeathGrip =
|
|
|
|
do_QueryInterface((nsIHTMLDocument*)this);
|
|
|
|
|
2000-09-19 05:11:59 +00:00
|
|
|
result = mScriptGlobalObject->SetNewDocument(kungFuDeathGrip);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
2000-09-19 05:11:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
result = Reset(channel, group);
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = nsComponentManager::CreateInstance(kCParserCID, nsnull,
|
|
|
|
NS_GET_IID(nsIParser),
|
|
|
|
(void **)&mParser);
|
|
|
|
mIsWriting = 1;
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
nsCOMPtr<nsIHTMLContentSink> sink;
|
|
|
|
nsCOMPtr<nsIWebShell> webShell;
|
|
|
|
|
|
|
|
// Get the webshell of our primary presentation shell
|
|
|
|
nsIPresShell* shell = (nsIPresShell*) mPresShells.ElementAt(0);
|
|
|
|
if (shell) {
|
|
|
|
nsCOMPtr<nsIPresContext> cx;
|
|
|
|
shell->GetPresContext(getter_AddRefs(cx));
|
|
|
|
nsCOMPtr<nsISupports> container;
|
|
|
|
if (NS_OK == cx->GetContainer(getter_AddRefs(container))) {
|
|
|
|
if (container) {
|
|
|
|
webShell = do_QueryInterface(container);
|
1999-01-06 00:32:41 +00:00
|
|
|
}
|
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
result = NS_NewHTMLContentSink(getter_AddRefs(sink), this, aSourceURL,
|
|
|
|
webShell, channel);
|
|
|
|
|
|
|
|
if (NS_OK == result) {
|
|
|
|
static NS_DEFINE_CID(kNavDTDCID, NS_CNAVDTD_CID);
|
|
|
|
nsCOMPtr<nsIDTD> theDTD(do_CreateInstance(kNavDTDCID, &result));
|
|
|
|
if(NS_SUCCEEDED(result)) {
|
|
|
|
mParser->RegisterDTD(theDTD);
|
2000-09-19 05:11:59 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
mParser->SetContentSink(sink);
|
1999-01-06 00:32:41 +00:00
|
|
|
}
|
|
|
|
}
|
1999-05-28 00:18:48 +00:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::Open()
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
1999-06-23 03:29:44 +00:00
|
|
|
nsIURI* sourceURL;
|
1999-05-28 00:18:48 +00:00
|
|
|
|
|
|
|
// XXX For the non-script Open case, we have to make
|
|
|
|
// up a URL.
|
1999-06-25 01:53:22 +00:00
|
|
|
result = NS_NewURI(&sourceURL, "about:blank");
|
1999-05-28 00:18:48 +00:00
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = OpenCommon(sourceURL);
|
|
|
|
NS_RELEASE(sourceURL);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-01-01 20:54:38 +00:00
|
|
|
nsHTMLDocument::Open(JSContext *cx, jsval *argv, PRUint32 argc,
|
|
|
|
nsIDOMDocument** aReturn)
|
1999-05-28 00:18:48 +00:00
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
1999-06-23 03:29:44 +00:00
|
|
|
nsIURI* sourceURL;
|
1999-05-28 00:18:48 +00:00
|
|
|
|
|
|
|
// XXX The URL of the newly created document will match
|
|
|
|
// that of the source document. Is this right?
|
|
|
|
result = GetSourceDocumentURL(cx, &sourceURL);
|
|
|
|
// Recover if we had a problem obtaining the source URL
|
|
|
|
if (nsnull == sourceURL) {
|
1999-06-23 19:55:21 +00:00
|
|
|
result = NS_NewURI(&sourceURL, "about:blank");
|
1999-05-28 00:18:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = OpenCommon(sourceURL);
|
|
|
|
NS_RELEASE(sourceURL);
|
|
|
|
}
|
|
|
|
|
2001-01-01 20:54:38 +00:00
|
|
|
QueryInterface(NS_GET_IID(nsIDOMDocument), (void **)aReturn);
|
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
return result;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-02-03 19:38:16 +00:00
|
|
|
#define NS_GENERATE_PARSER_KEY() (void*)((mIsWriting << 31) | (mWriteLevel & 0x7fffffff))
|
|
|
|
|
1999-12-14 23:34:17 +00:00
|
|
|
NS_IMETHODIMP
|
2000-02-03 00:25:53 +00:00
|
|
|
nsHTMLDocument::Clear(JSContext* cx, jsval* argv, PRUint32 argc)
|
1999-12-14 23:34:17 +00:00
|
|
|
{
|
2001-01-23 02:20:33 +00:00
|
|
|
// This method has been deprecated
|
|
|
|
return NS_OK;
|
1999-12-14 23:34:17 +00:00
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::Close()
|
|
|
|
{
|
1999-02-03 19:38:16 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (mParser && mIsWriting) {
|
2000-04-15 20:15:37 +00:00
|
|
|
nsAutoString emptyStr; emptyStr.AssignWithConversion("</HTML>");
|
1999-02-03 19:38:16 +00:00
|
|
|
mWriteLevel++;
|
|
|
|
result = mParser->Parse(emptyStr, NS_GENERATE_PARSER_KEY(),
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_ConvertASCIItoUCS2("text/html"), PR_FALSE,
|
|
|
|
PR_TRUE);
|
1999-02-03 19:38:16 +00:00
|
|
|
mWriteLevel--;
|
|
|
|
mIsWriting = 0;
|
2000-05-22 22:16:56 +00:00
|
|
|
NS_IF_RELEASE(mParser);
|
1999-02-03 19:38:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
nsresult
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::WriteCommon(const nsAReadableString& aText,
|
1999-01-06 00:32:41 +00:00
|
|
|
PRBool aNewlineTerminate)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1998-07-23 22:06:05 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
1999-05-28 00:18:48 +00:00
|
|
|
if (nsnull == mParser) {
|
|
|
|
result = Open();
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_FAILED(result)) {
|
1999-05-28 00:18:48 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoString str(aText);
|
|
|
|
|
|
|
|
if (aNewlineTerminate) {
|
2000-04-15 20:15:37 +00:00
|
|
|
str.AppendWithConversion('\n');
|
1999-05-28 00:18:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mWriteLevel++;
|
|
|
|
result = mParser->Parse(str, NS_GENERATE_PARSER_KEY(),
|
2000-04-15 20:15:37 +00:00
|
|
|
NS_ConvertASCIItoUCS2("text/html"), PR_FALSE,
|
1999-05-28 00:18:48 +00:00
|
|
|
(!mIsWriting || (mWriteLevel > 1)));
|
|
|
|
mWriteLevel--;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::Write(const nsAReadableString& aText)
|
1999-05-28 00:18:48 +00:00
|
|
|
{
|
|
|
|
return WriteCommon(aText, PR_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::Writeln(const nsAReadableString& aText)
|
1999-05-28 00:18:48 +00:00
|
|
|
{
|
|
|
|
return WriteCommon(aText, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::ScriptWriteCommon(JSContext *cx,
|
|
|
|
jsval *argv,
|
|
|
|
PRUint32 argc,
|
|
|
|
PRBool aNewlineTerminate)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
2000-03-24 22:15:37 +00:00
|
|
|
nsXPIDLCString spec;
|
|
|
|
if (!mDocumentURL ||
|
|
|
|
(NS_SUCCEEDED(mDocumentURL->GetSpec(getter_Copies(spec))) &&
|
|
|
|
nsCRT::strcasecmp(spec, "about:blank") == 0))
|
|
|
|
{
|
|
|
|
// The current document's URL and principal are empty or "about:blank".
|
|
|
|
// By writing to this document, the script acquires responsibility for the
|
|
|
|
// document for security purposes. Thus a document.write of a script tag
|
|
|
|
// ends up producing a script with the same principals as the script
|
|
|
|
// that performed the write.
|
|
|
|
nsIScriptContext *context = (nsIScriptContext*)JS_GetContextPrivate(cx);
|
|
|
|
JSObject* obj;
|
|
|
|
if (NS_FAILED(GetScriptObject(context, (void**)&obj)))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsIScriptSecurityManager *sm = nsJSUtils::nsGetSecurityManager(cx, nsnull);
|
|
|
|
if (!sm)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIPrincipal> subject;
|
|
|
|
if (NS_FAILED(sm->GetSubjectPrincipal(getter_AddRefs(subject))))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
if (subject) {
|
|
|
|
nsCOMPtr<nsICodebasePrincipal> codebase = do_QueryInterface(subject);
|
|
|
|
if (codebase) {
|
|
|
|
nsCOMPtr<nsIURI> subjectURI;
|
|
|
|
if (NS_FAILED(codebase->GetURI(getter_AddRefs(subjectURI))))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
NS_IF_RELEASE(mDocumentURL);
|
|
|
|
mDocumentURL = subjectURI;
|
|
|
|
NS_ADDREF(mDocumentURL);
|
|
|
|
|
|
|
|
NS_IF_RELEASE(mPrincipal);
|
|
|
|
mPrincipal = subject;
|
|
|
|
NS_ADDREF(mPrincipal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-01-01 20:54:38 +00:00
|
|
|
if (!mParser) {
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
|
|
|
|
|
|
|
result = Open(cx, argv, argc, getter_AddRefs(doc));
|
|
|
|
if (NS_FAILED(result)) {
|
1999-02-03 19:38:16 +00:00
|
|
|
return result;
|
|
|
|
}
|
1998-07-23 22:06:05 +00:00
|
|
|
}
|
2001-01-01 20:54:38 +00:00
|
|
|
|
1998-07-23 22:06:05 +00:00
|
|
|
if (argc > 0) {
|
|
|
|
PRUint32 index;
|
1998-09-12 00:04:22 +00:00
|
|
|
nsAutoString str;
|
2001-01-01 20:54:38 +00:00
|
|
|
|
1998-07-23 22:06:05 +00:00
|
|
|
for (index = 0; index < argc; index++) {
|
|
|
|
JSString *jsstring = JS_ValueToString(cx, argv[index]);
|
|
|
|
|
2001-01-01 20:54:38 +00:00
|
|
|
if (jsstring) {
|
|
|
|
str.Append(NS_REINTERPRET_CAST(const PRUnichar*,
|
|
|
|
JS_GetStringChars(jsstring)),
|
|
|
|
JS_GetStringLength(jsstring));
|
1998-07-23 22:06:05 +00:00
|
|
|
}
|
|
|
|
}
|
1999-01-06 00:32:41 +00:00
|
|
|
|
|
|
|
if (aNewlineTerminate) {
|
2000-04-15 20:15:37 +00:00
|
|
|
str.AppendWithConversion('\n');
|
1999-01-06 00:32:41 +00:00
|
|
|
}
|
|
|
|
|
1999-02-03 19:38:16 +00:00
|
|
|
mWriteLevel++;
|
|
|
|
result = mParser->Parse(str, NS_GENERATE_PARSER_KEY(),
|
2000-04-15 20:15:37 +00:00
|
|
|
NS_ConvertASCIItoUCS2("text/html"), PR_FALSE,
|
1999-02-03 19:38:16 +00:00
|
|
|
(!mIsWriting || (mWriteLevel > 1)));
|
|
|
|
mWriteLevel--;
|
1998-07-23 22:06:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-01-06 00:32:41 +00:00
|
|
|
nsHTMLDocument::Write(JSContext *cx, jsval *argv, PRUint32 argc)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-05-28 00:18:48 +00:00
|
|
|
return ScriptWriteCommon(cx, argv, argc, PR_FALSE);
|
1999-01-06 00:32:41 +00:00
|
|
|
}
|
1998-07-23 22:06:05 +00:00
|
|
|
|
1999-01-06 00:32:41 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::Writeln(JSContext *cx, jsval *argv, PRUint32 argc)
|
|
|
|
{
|
1999-05-28 00:18:48 +00:00
|
|
|
return ScriptWriteCommon(cx, argv, argc, PR_TRUE);
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
nsIContent *
|
2000-10-04 14:11:19 +00:00
|
|
|
nsHTMLDocument::MatchId(nsIContent *aContent, const nsAReadableString& aId)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
|
|
|
nsAutoString value;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = aContent->GetAttribute(kNameSpaceID_HTML, nsHTMLAtoms::id,
|
|
|
|
value);
|
|
|
|
|
|
|
|
if (rv == NS_CONTENT_ATTR_HAS_VALUE && aId.Equals(value)) {
|
1998-08-07 23:08:00 +00:00
|
|
|
return aContent;
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsIContent *result = nsnull;
|
1998-08-07 23:08:00 +00:00
|
|
|
PRInt32 i, count;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-08-29 20:20:38 +00:00
|
|
|
aContent->ChildCount(count);
|
1998-08-07 23:08:00 +00:00
|
|
|
for (i = 0; i < count && result == nsnull; i++) {
|
1998-08-29 20:20:38 +00:00
|
|
|
nsIContent *child;
|
|
|
|
aContent->ChildAt(i, child);
|
2000-10-04 14:11:19 +00:00
|
|
|
result = MatchId(child, aId);
|
1998-08-07 23:08:00 +00:00
|
|
|
NS_RELEASE(child);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-03-22 08:51:52 +00:00
|
|
|
nsHTMLDocument::GetElementById(const nsAReadableString& aElementId,
|
|
|
|
nsIDOMElement** aReturn)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
2000-07-28 21:48:08 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aReturn);
|
|
|
|
*aReturn = nsnull;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_WARN_IF_FALSE(!aElementId.IsEmpty(), "getElementById(\"\"), fix caller?");
|
2000-07-28 21:48:08 +00:00
|
|
|
if (aElementId.IsEmpty())
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsStringKey key(aElementId);
|
1998-08-07 23:08:00 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsIContent *e = NS_STATIC_CAST(nsIContent *, mIdHashTable.Get(&key));
|
|
|
|
|
|
|
|
if (e == ELEMENT_NOT_IN_TABLE) {
|
|
|
|
// We're looked for this id before and we didn't find it, so it's
|
|
|
|
// not in the document now either
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
} else if (!e) {
|
|
|
|
e = MatchId(mRootContent, aElementId);
|
|
|
|
|
|
|
|
if (!e) {
|
|
|
|
// There is no element with the given id in the document, cache
|
|
|
|
// the fact that it's not in the document
|
|
|
|
mIdHashTable.Put(&key, ELEMENT_NOT_IN_TABLE);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We found an element with a matching id, store that in the hash
|
|
|
|
mIdHashTable.Put(&key, e);
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
2000-07-28 21:48:08 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
return CallQueryInterface(e, aReturn);
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
2000-04-02 17:46:30 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::ImportNode(nsIDOMNode* aImportedNode,
|
|
|
|
PRBool aDeep,
|
|
|
|
nsIDOMNode** aReturn)
|
|
|
|
{
|
2000-06-21 23:56:52 +00:00
|
|
|
return nsDocument::ImportNode(aImportedNode, aDeep, aReturn);
|
2000-04-02 17:46:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::CreateAttributeNS(const nsAReadableString& aNamespaceURI,
|
|
|
|
const nsAReadableString& aQualifiedName,
|
2000-04-02 17:46:30 +00:00
|
|
|
nsIDOMAttr** aReturn)
|
|
|
|
{
|
|
|
|
NS_NOTYETIMPLEMENTED("write me");
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetElementsByTagNameNS(const nsAReadableString& aNamespaceURI,
|
|
|
|
const nsAReadableString& aLocalName,
|
2000-04-02 17:46:30 +00:00
|
|
|
nsIDOMNodeList** aReturn)
|
|
|
|
{
|
2000-05-17 03:47:06 +00:00
|
|
|
nsAutoString tmp(aLocalName);
|
|
|
|
tmp.ToLowerCase(); // HTML elements are lower case internally.
|
|
|
|
return nsDocument::GetElementsByTagNameNS(aNamespaceURI, tmp,
|
2000-05-16 00:55:05 +00:00
|
|
|
aReturn);
|
2000-04-02 17:46:30 +00:00
|
|
|
}
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
PRBool
|
1999-05-04 20:53:44 +00:00
|
|
|
nsHTMLDocument::MatchNameAttribute(nsIContent* aContent, nsString* aData)
|
1999-02-04 23:23:07 +00:00
|
|
|
{
|
|
|
|
nsAutoString name;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::name,
|
|
|
|
name);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && aData && name.Equals(*aData)) {
|
1999-02-04 23:23:07 +00:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetElementsByName(const nsAReadableString& aElementName,
|
1999-02-04 23:23:07 +00:00
|
|
|
nsIDOMNodeList** aReturn)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsContentList* elements = new nsContentList(this, MatchNameAttribute,
|
|
|
|
aElementName);
|
|
|
|
NS_ENSURE_TRUE(elements, NS_ERROR_OUT_OF_MEMORY);
|
2000-08-23 17:27:06 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
*aReturn = elements;
|
|
|
|
NS_ADDREF(*aReturn);
|
1999-02-04 23:23:07 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
2000-08-16 01:04:52 +00:00
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::GetPixelDimensions(nsIPresShell* aShell,
|
|
|
|
PRInt32* aWidth,
|
|
|
|
PRInt32* aHeight)
|
|
|
|
{
|
|
|
|
*aWidth = *aHeight = 0;
|
|
|
|
|
|
|
|
nsresult result;
|
|
|
|
result = FlushPendingNotifications();
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
// Find the <body> element: this is what we'll want to use for the
|
|
|
|
// document's width and height values.
|
|
|
|
if (mBodyContent == nsnull && PR_FALSE == GetBodyContent()) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> body = do_QueryInterface(mBodyContent);
|
|
|
|
|
|
|
|
// Now grab its frame
|
|
|
|
nsIFrame* frame;
|
|
|
|
result = aShell->GetPrimaryFrameFor(body, &frame);
|
|
|
|
if (NS_SUCCEEDED(result) && frame) {
|
|
|
|
nsSize size;
|
|
|
|
nsIView* view;
|
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
|
|
|
|
aShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
result = frame->GetView(presContext, &view);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
// If we have a view check if it's scrollable. If not,
|
|
|
|
// just use the view size itself
|
|
|
|
if (view) {
|
2001-03-22 08:51:52 +00:00
|
|
|
nsIScrollableView* scrollableView = nsnull;
|
|
|
|
|
|
|
|
view->QueryInterface(NS_GET_IID(nsIScrollableView),
|
|
|
|
(void**)&scrollableView);
|
|
|
|
|
|
|
|
if (scrollableView) {
|
2000-08-16 01:04:52 +00:00
|
|
|
scrollableView->GetScrolledView(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
result = view->GetDimensions(&size.width, &size.height);
|
|
|
|
}
|
|
|
|
// If we don't have a view, use the frame size
|
|
|
|
else {
|
|
|
|
result = frame->GetSize(size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert from twips to pixels
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
nsCOMPtr<nsIPresContext> context;
|
|
|
|
|
|
|
|
result = aShell->GetPresContext(getter_AddRefs(context));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
float scale;
|
|
|
|
context->GetTwipsToPixels(&scale);
|
|
|
|
|
|
|
|
*aWidth = NSTwipsToIntPixels(size.width, scale);
|
|
|
|
*aHeight = NSTwipsToIntPixels(size.height, scale);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetWidth(PRInt32* aWidth)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aWidth);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
|
|
|
// We make the assumption that the first presentation shell
|
|
|
|
// is the one for which we need information.
|
|
|
|
shell = getter_AddRefs(GetShellAt(0));
|
|
|
|
if (shell) {
|
|
|
|
PRInt32 width, height;
|
|
|
|
|
|
|
|
result = GetPixelDimensions(shell, &width, &height);
|
|
|
|
*aWidth = width;
|
|
|
|
} else
|
|
|
|
*aWidth = 0;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetHeight(PRInt32* aHeight)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aHeight);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
|
|
|
// We make the assumption that the first presentation shell
|
|
|
|
// is the one for which we need information.
|
|
|
|
shell = getter_AddRefs(GetShellAt(0));
|
|
|
|
if (shell) {
|
|
|
|
PRInt32 width, height;
|
|
|
|
|
|
|
|
result = GetPixelDimensions(shell, &width, &height);
|
|
|
|
*aHeight = height;
|
|
|
|
} else
|
|
|
|
*aHeight = 0;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetAlinkColor(nsAWritableString& aAlinkColor)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
aAlinkColor.Truncate();
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->GetALink(aAlinkColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nscolor color;
|
|
|
|
result = mAttrStyleSheet->GetActiveLinkColor(color);
|
|
|
|
if (NS_OK == result) {
|
|
|
|
nsHTMLValue value(color);
|
|
|
|
nsGenericHTMLElement::ColorToString(value, aAlinkColor);
|
|
|
|
}
|
|
|
|
}
|
1999-02-04 02:58:02 +00:00
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
return NS_OK;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetAlinkColor(const nsAReadableString& aAlinkColor)
|
1998-08-04 00:05:22 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->SetALink(aAlinkColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nsHTMLValue value;
|
|
|
|
|
1999-07-18 00:22:29 +00:00
|
|
|
if (nsGenericHTMLElement::ParseColor(aAlinkColor, this, value)) {
|
1999-07-07 04:52:27 +00:00
|
|
|
mAttrStyleSheet->SetActiveLinkColor(value.GetColorValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetLinkColor(nsAWritableString& aLinkColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
aLinkColor.Truncate();
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->GetLink(aLinkColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nscolor color;
|
|
|
|
result = mAttrStyleSheet->GetLinkColor(color);
|
|
|
|
if (NS_OK == result) {
|
|
|
|
nsHTMLValue value(color);
|
|
|
|
nsGenericHTMLElement::ColorToString(value, aLinkColor);
|
|
|
|
}
|
|
|
|
}
|
1999-02-04 02:58:02 +00:00
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetLinkColor(const nsAReadableString& aLinkColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->SetLink(aLinkColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nsHTMLValue value;
|
1999-07-18 00:22:29 +00:00
|
|
|
if (nsGenericHTMLElement::ParseColor(aLinkColor, this, value)) {
|
1999-07-07 04:52:27 +00:00
|
|
|
mAttrStyleSheet->SetLinkColor(value.GetColorValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetVlinkColor(nsAWritableString& aVlinkColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
aVlinkColor.Truncate();
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
1999-07-08 19:55:47 +00:00
|
|
|
result = body->GetVLink(aVlinkColor);
|
1999-02-04 02:58:02 +00:00
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nscolor color;
|
|
|
|
result = mAttrStyleSheet->GetVisitedLinkColor(color);
|
|
|
|
if (NS_OK == result) {
|
|
|
|
nsHTMLValue value(color);
|
|
|
|
nsGenericHTMLElement::ColorToString(value, aVlinkColor);
|
|
|
|
}
|
|
|
|
}
|
1999-02-04 02:58:02 +00:00
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetVlinkColor(const nsAReadableString& aVlinkColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->SetVLink(aVlinkColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nsHTMLValue value;
|
1999-07-18 00:22:29 +00:00
|
|
|
if (nsGenericHTMLElement::ParseColor(aVlinkColor, this, value)) {
|
1999-07-07 04:52:27 +00:00
|
|
|
mAttrStyleSheet->SetVisitedLinkColor(value.GetColorValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetBgColor(nsAWritableString& aBgColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
aBgColor.Truncate();
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->GetBgColor(aBgColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nscolor color;
|
|
|
|
result = mAttrStyleSheet->GetDocumentBackgroundColor(color);
|
|
|
|
if (NS_OK == result) {
|
|
|
|
nsHTMLValue value(color);
|
|
|
|
nsGenericHTMLElement::ColorToString(value, aBgColor);
|
|
|
|
}
|
|
|
|
}
|
1999-02-04 02:58:02 +00:00
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetBgColor(const nsAReadableString& aBgColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->SetBgColor(aBgColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nsHTMLValue value;
|
1999-07-18 00:22:29 +00:00
|
|
|
if (nsGenericHTMLElement::ParseColor(aBgColor, this, value)) {
|
1999-07-07 04:52:27 +00:00
|
|
|
mAttrStyleSheet->SetDocumentBackgroundColor(value.GetColorValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetFgColor(nsAWritableString& aFgColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
aFgColor.Truncate();
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->GetText(aFgColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nscolor color;
|
|
|
|
result = mAttrStyleSheet->GetDocumentForegroundColor(color);
|
|
|
|
if (NS_OK == result) {
|
|
|
|
nsHTMLValue value(color);
|
|
|
|
nsGenericHTMLElement::ColorToString(value, aFgColor);
|
|
|
|
}
|
|
|
|
}
|
1999-02-04 02:58:02 +00:00
|
|
|
|
1999-07-07 04:52:27 +00:00
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::SetFgColor(const nsAReadableString& aFgColor)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-02-04 02:58:02 +00:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIDOMHTMLBodyElement* body;
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
result = GetBodyElement(&body);
|
1999-02-04 02:58:02 +00:00
|
|
|
if (NS_OK == result) {
|
|
|
|
result = body->SetText(aFgColor);
|
|
|
|
NS_RELEASE(body);
|
|
|
|
}
|
1999-07-07 04:52:27 +00:00
|
|
|
else if (nsnull != mAttrStyleSheet) {
|
|
|
|
nsHTMLValue value;
|
|
|
|
|
1999-07-18 00:22:29 +00:00
|
|
|
if (nsGenericHTMLElement::ParseColor(aFgColor, this, value)) {
|
1999-07-07 04:52:27 +00:00
|
|
|
mAttrStyleSheet->SetDocumentForegroundColor(value.GetColorValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetLastModified(nsAWritableString& aLastModified)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-08-09 19:10:24 +00:00
|
|
|
if (nsnull != mLastModified) {
|
2000-08-23 17:27:06 +00:00
|
|
|
aLastModified.Assign(*mLastModified);
|
1999-08-09 19:10:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2000-08-23 17:27:06 +00:00
|
|
|
aLastModified.Assign(NS_LITERAL_STRING("January 1, 1970 GMT"));
|
1999-08-09 19:10:24 +00:00
|
|
|
}
|
|
|
|
|
1999-06-28 23:39:25 +00:00
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
1998-10-06 01:39:33 +00:00
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetEmbeds(nsIDOMHTMLCollection** aEmbeds)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!mEmbeds) {
|
|
|
|
mEmbeds = new nsContentList(this, nsHTMLAtoms::embed,
|
|
|
|
kNameSpaceID_Unknown);
|
|
|
|
NS_ENSURE_TRUE(mEmbeds, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
1998-09-25 00:51:45 +00:00
|
|
|
NS_ADDREF(mEmbeds);
|
|
|
|
}
|
|
|
|
|
|
|
|
*aEmbeds = (nsIDOMHTMLCollection *)mEmbeds;
|
|
|
|
NS_ADDREF(mEmbeds);
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-08-23 17:27:06 +00:00
|
|
|
nsHTMLDocument::GetSelection(nsAWritableString& aReturn)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
1999-06-28 23:39:25 +00:00
|
|
|
aReturn.Truncate();
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
nsCOMPtr<nsIConsoleService> consoleService
|
|
|
|
(do_GetService("@mozilla.org/consoleservice;1"));
|
|
|
|
|
|
|
|
if (consoleService) {
|
|
|
|
consoleService->LogStringMessage(NS_LITERAL_STRING("Deprecated method document.getSelection() called. Please use window.getSelection() instead.").get());
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* shell = (nsIPresShell*)mPresShells.ElementAt(0);
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
if (!shell) {
|
2000-04-28 14:05:45 +00:00
|
|
|
return NS_OK;
|
2001-01-23 07:45:08 +00:00
|
|
|
}
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
nsCOMPtr<nsIPresContext> cx;
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
shell->GetPresContext(getter_AddRefs(cx));
|
|
|
|
NS_ENSURE_TRUE(cx, NS_OK);
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
nsCOMPtr<nsISupports> container;
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
cx->GetContainer(getter_AddRefs(container));
|
|
|
|
NS_ENSURE_TRUE(container, NS_OK);
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
nsCOMPtr<nsIDOMWindow> window(do_GetInterface(container));
|
|
|
|
NS_ENSURE_TRUE(window, NS_OK);
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2001-01-23 07:45:08 +00:00
|
|
|
nsCOMPtr<nsISelection> selection;
|
|
|
|
|
|
|
|
nsresult rv = window->GetSelection(getter_AddRefs(selection));
|
|
|
|
NS_ENSURE_TRUE(selection && NS_SUCCEEDED(rv), rv);
|
|
|
|
|
|
|
|
nsXPIDLString str;
|
|
|
|
|
|
|
|
rv = selection->ToString(getter_Copies(str));
|
|
|
|
|
|
|
|
aReturn.Assign(str);
|
2000-04-28 14:05:45 +00:00
|
|
|
|
2000-09-14 11:45:01 +00:00
|
|
|
return rv;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
1999-09-21 14:18:52 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::CaptureEvents(PRInt32 aEventFlags)
|
|
|
|
{
|
|
|
|
nsIEventListenerManager *manager;
|
|
|
|
|
|
|
|
if (NS_OK == GetListenerManager(&manager)) {
|
2000-02-16 06:59:07 +00:00
|
|
|
manager->CaptureEvent(aEventFlags);
|
1999-09-21 14:18:52 +00:00
|
|
|
NS_RELEASE(manager);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-02-16 06:59:07 +00:00
|
|
|
|
1999-09-21 14:18:52 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::ReleaseEvents(PRInt32 aEventFlags)
|
|
|
|
{
|
2000-02-16 06:59:07 +00:00
|
|
|
nsIEventListenerManager *manager;
|
|
|
|
|
|
|
|
if (NS_OK == GetListenerManager(&manager)) {
|
|
|
|
manager->ReleaseEvent(aEventFlags);
|
|
|
|
NS_RELEASE(manager);
|
1999-09-21 14:18:52 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-02-16 06:59:07 +00:00
|
|
|
|
1999-09-21 14:18:52 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::RouteEvent(nsIDOMEvent* aEvt)
|
|
|
|
{
|
|
|
|
//XXX Not the best solution -joki
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
static PRBool PR_CALLBACK
|
|
|
|
NameHashCleanupEnumeratorCallback(nsHashKey *aKey, void *aData, void* closure)
|
|
|
|
{
|
|
|
|
nsBaseContentList *list = (nsBaseContentList *)aData;
|
|
|
|
|
|
|
|
// The document this hash is in is most likely going away so we
|
|
|
|
// reset the live nodelists to avoid leaving dangling pointers to
|
|
|
|
// non-existing content
|
|
|
|
list->Reset();
|
|
|
|
|
|
|
|
NS_RELEASE(list);
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
void
|
2001-03-22 08:51:52 +00:00
|
|
|
nsHTMLDocument::InvalidateHashTables()
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
mNameHashTable.Reset(NameHashCleanupEnumeratorCallback);
|
|
|
|
mIdHashTable.Reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
static nsresult
|
|
|
|
AddEmptyListToHash(const nsAReadableString& aName, nsHashtable& aHash)
|
|
|
|
{
|
|
|
|
nsBaseContentList *list = new nsBaseContentList();
|
|
|
|
if (!list) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
NS_ADDREF(list);
|
|
|
|
|
|
|
|
nsStringKey key(aName);
|
|
|
|
|
|
|
|
aHash.Put(&key, list);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pre-fill the name hash with names that are likely to be resolved in
|
|
|
|
// this document to avoid walking the tree looking for elements with
|
|
|
|
// these names.
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::PrePopulateHashTables()
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("write"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("writeln"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("open"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("close"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("forms"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("elements"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("characterSet"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("nodeType"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("parentNode"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = AddEmptyListToHash(NS_LITERAL_STRING("cookie"), mNameHashTable);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return rv;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
static PRBool
|
2001-03-22 08:51:52 +00:00
|
|
|
IsNamedItem(nsIContent* aContent, nsIAtom *aTag, nsAWritableString& aName)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
|
|
|
// Only the content types reflected in Level 0 with a NAME
|
1999-05-17 21:17:48 +00:00
|
|
|
// attribute are registered. Images, layers and forms always get
|
1998-08-07 23:08:00 +00:00
|
|
|
// reflected up to the document. Applets and embeds only go
|
|
|
|
// to the closest container (which could be a form).
|
1998-11-28 23:51:06 +00:00
|
|
|
if ((aTag == nsHTMLAtoms::img) || (aTag == nsHTMLAtoms::form) ||
|
2001-03-22 08:51:52 +00:00
|
|
|
(aTag == nsHTMLAtoms::applet) || (aTag == nsHTMLAtoms::embed) ||
|
|
|
|
(aTag == nsHTMLAtoms::object)) {
|
|
|
|
aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::name, aName);
|
1998-08-07 23:08:00 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!aName.IsEmpty()) {
|
1999-05-17 21:17:48 +00:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::AddToNameTable(const nsAReadableString& aName,
|
|
|
|
nsIContent *aContent)
|
|
|
|
{
|
|
|
|
nsStringKey key(aName);
|
|
|
|
|
|
|
|
nsBaseContentList* list = NS_STATIC_CAST(nsBaseContentList *,
|
|
|
|
mNameHashTable.Get(&key));
|
|
|
|
|
|
|
|
if (!list) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 i;
|
|
|
|
|
|
|
|
list->IndexOf(aContent, i);
|
|
|
|
|
|
|
|
if (i < 0) {
|
|
|
|
list->AppendElement(aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::AddToIdTable(const nsAReadableString& aId,
|
|
|
|
nsIContent *aContent, PRBool aPutInTable)
|
|
|
|
{
|
|
|
|
nsStringKey key(aId);
|
|
|
|
|
|
|
|
nsIContent *e = NS_STATIC_CAST(nsIContent *, mIdHashTable.Get(&key));
|
|
|
|
|
|
|
|
if (e == ELEMENT_NOT_IN_TABLE || (!e && aPutInTable)) {
|
|
|
|
mIdHashTable.Put(&key, aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::RemoveFromNameTable(const nsAReadableString& aName,
|
|
|
|
nsIContent *aContent)
|
|
|
|
{
|
|
|
|
nsStringKey key(aName);
|
|
|
|
|
|
|
|
nsBaseContentList* list = NS_STATIC_CAST(nsBaseContentList *,
|
|
|
|
mNameHashTable.Get(&key));
|
|
|
|
|
|
|
|
if (list) {
|
|
|
|
list->RemoveElement(aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::RemoveFromIdTable(nsIContent *aContent)
|
1998-11-28 23:51:06 +00:00
|
|
|
{
|
|
|
|
nsAutoString value;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::id, value);
|
|
|
|
|
|
|
|
if (value.IsEmpty()) {
|
|
|
|
return NS_OK;
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
nsStringKey key(value);
|
|
|
|
|
|
|
|
nsIContent *e = NS_STATIC_CAST(nsIContent *, mIdHashTable.Get(&key));
|
|
|
|
|
|
|
|
if (e != aContent)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
mIdHashTable.Remove(&key);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::UnregisterNamedItems(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
|
|
|
|
aContent->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (tag == nsLayoutAtoms::textTagName) {
|
|
|
|
// Text nodes are not named items nor can they have children.
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoString value;
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
if (IsNamedItem(aContent, tag, value)) {
|
|
|
|
rv = RemoveFromNameTable(value, aContent);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = RemoveFromIdTable(aContent);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
PRInt32 i, count;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
aContent->ChildCount(count);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
nsIContent *child;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
aContent->ChildAt(i, child);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
UnregisterNamedItems(child);
|
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
NS_RELEASE(child);
|
2001-03-22 08:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::RegisterNamedItems(nsIContent *aContent)
|
1998-11-28 23:51:06 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
|
|
|
|
aContent->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (tag == nsLayoutAtoms::textTagName) {
|
|
|
|
// Text nodes are not named items nor can they have children.
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
nsAutoString value;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (IsNamedItem(aContent, tag, value)) {
|
|
|
|
AddToNameTable(value, aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::id, value);
|
|
|
|
|
|
|
|
if (!value.IsEmpty()) {
|
|
|
|
nsresult rv = AddToIdTable(value, aContent, PR_FALSE);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
PRInt32 i, count;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-08-29 20:20:38 +00:00
|
|
|
aContent->ChildCount(count);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
1998-08-29 20:20:38 +00:00
|
|
|
nsIContent *child;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-08-29 20:20:38 +00:00
|
|
|
aContent->ChildAt(i, child);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
RegisterNamedItems(child);
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
NS_RELEASE(child);
|
2001-03-22 08:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
void
|
|
|
|
nsHTMLDocument::FindNamedItems(const nsAReadableString& aName,
|
|
|
|
nsIContent *aContent, nsBaseContentList& aList)
|
1998-11-28 23:51:06 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsIAtom> tag;
|
1998-11-28 23:51:06 +00:00
|
|
|
nsAutoString value;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
aContent->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (tag == nsLayoutAtoms::textTagName) {
|
|
|
|
// Text nodes are not named items nor can they have children.
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IsNamedItem(aContent, tag, value) && value.Equals(aName)) {
|
|
|
|
aList.AppendElement(aContent);
|
|
|
|
} else {
|
|
|
|
aContent->GetAttribute(kNameSpaceID_None, nsHTMLAtoms::id, value);
|
|
|
|
|
|
|
|
if (value.Equals(aName)) {
|
|
|
|
AddToIdTable(value, aContent, PR_TRUE);
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 i, count;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-11-28 23:51:06 +00:00
|
|
|
aContent->ChildCount(count);
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsIContent> child;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
aContent->ChildAt(i, *getter_AddRefs(child));
|
|
|
|
|
|
|
|
FindNamedItems(aName, child, aList);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::ResolveName(const nsAReadableString& aName,
|
|
|
|
nsIDOMHTMLFormElement *aForm,
|
|
|
|
nsISupports **aResult)
|
|
|
|
{
|
|
|
|
*aResult = nsnull;
|
|
|
|
|
|
|
|
// Bug 69826 - Make sure to flush the content model if the document
|
|
|
|
// is still loading.
|
|
|
|
|
|
|
|
// This is a perf killer while the document is loading!
|
|
|
|
FlushPendingNotifications(PR_FALSE);
|
|
|
|
|
|
|
|
nsStringKey key(aName);
|
|
|
|
|
|
|
|
// We have built a table and cache the named items. The table will
|
|
|
|
// be updated as content is added and removed.
|
|
|
|
|
|
|
|
nsBaseContentList *list = NS_STATIC_CAST(nsContentList *,
|
|
|
|
mNameHashTable.Get(&key));
|
|
|
|
|
|
|
|
if (!list) {
|
|
|
|
#ifdef DEBUG_jst
|
|
|
|
{
|
|
|
|
printf ("nsHTMLDocument name cache miss for name '%s'\n",
|
|
|
|
NS_ConvertUCS2toUTF8(aName).get());
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
list = new nsBaseContentList();
|
|
|
|
NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
NS_ADDREF(list);
|
|
|
|
|
|
|
|
FindNamedItems(aName, mRootContent, *list);
|
|
|
|
|
|
|
|
mNameHashTable.Put(&key, list);
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint32 length;
|
|
|
|
|
|
|
|
list->GetLength(&length);
|
|
|
|
|
|
|
|
if (length == 1) {
|
|
|
|
// Onle one element in the list, return the list in stead of
|
|
|
|
// returning the list
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
|
|
|
|
list->Item(0, getter_AddRefs(node));
|
|
|
|
|
|
|
|
if (aForm && node) {
|
|
|
|
// document.forms["foo"].bar should not map to <form name="bar">
|
|
|
|
// so we check here to see if we found a form and if we did we
|
|
|
|
// ignore what we found in the document. This doesn't deal with
|
|
|
|
// the case where more than one element in found in the document
|
|
|
|
// (i.e. there are two named items in the document that have the
|
|
|
|
// name we're looking for), that case is dealt with in
|
|
|
|
// nsFormContentList
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMHTMLFormElement> f(do_QueryInterface(node));
|
|
|
|
|
|
|
|
if (f) {
|
|
|
|
node = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = node;
|
|
|
|
NS_IF_ADDREF(*aResult);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (length > 1) {
|
|
|
|
// The list contains more than one element, return the whole list,
|
|
|
|
// unless...
|
|
|
|
|
|
|
|
if (aForm) {
|
|
|
|
// ... we're called from a form, in that case we create a
|
|
|
|
// nsFormContentList which will filter out the elements in the
|
|
|
|
// list that don't belong to aForm
|
|
|
|
|
|
|
|
nsFormContentList *fc_list = new nsFormContentList(aForm, *list);
|
|
|
|
NS_ENSURE_TRUE(fc_list, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
PRUint32 len;
|
|
|
|
|
|
|
|
fc_list->GetLength(&len);
|
|
|
|
|
|
|
|
if (len < 2) {
|
|
|
|
// After t nsFormContentList is done filtering there's zero or
|
|
|
|
// one element in the list, return that element, or null if
|
|
|
|
// there's no element in the list.
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
|
|
|
|
fc_list->Item(0, getter_AddRefs(node));
|
|
|
|
|
|
|
|
*aResult = node;
|
|
|
|
NS_IF_ADDREF(*aResult);
|
|
|
|
|
|
|
|
delete fc_list;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
list = fc_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list->QueryInterface(NS_GET_IID(nsISupports), (void **)aResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
// No named items were found, look if we'll find the name by id.
|
|
|
|
|
|
|
|
nsIContent *e = NS_STATIC_CAST(nsIContent *, mIdHashTable.Get(&key));
|
|
|
|
|
2001-04-03 07:14:12 +00:00
|
|
|
if (e && e != ELEMENT_NOT_IN_TABLE) {
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
e->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (tag.get() == nsHTMLAtoms::embed ||
|
|
|
|
tag.get() == nsHTMLAtoms::img ||
|
|
|
|
tag.get() == nsHTMLAtoms::object ||
|
|
|
|
tag.get() == nsHTMLAtoms::applet) {
|
|
|
|
*aResult = e;
|
|
|
|
NS_ADDREF(*aResult);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1998-11-28 23:51:06 +00:00
|
|
|
}
|
|
|
|
|
1998-08-07 23:08:00 +00:00
|
|
|
NS_IMETHODIMP
|
2000-03-18 17:48:12 +00:00
|
|
|
nsHTMLDocument::NamedItem(JSContext* cx, jsval* argv, PRUint32 argc,
|
|
|
|
jsval* aReturn)
|
1998-08-07 23:08:00 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
nsresult rv = NS_OK;
|
1998-11-28 23:51:06 +00:00
|
|
|
|
2000-03-18 17:48:12 +00:00
|
|
|
if (argc < 1)
|
|
|
|
return NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR;
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
JSString *jsstr = ::JS_ValueToString(cx, argv[0]);
|
|
|
|
PRUnichar *ustr = NS_REINTERPRET_CAST(PRUnichar *, JS_GetStringChars(jsstr));
|
1998-08-07 23:08:00 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsISupports> item;
|
1998-08-07 23:08:00 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
rv = ResolveName(nsLiteralString(ustr, ::JS_GetStringLength(jsstr)),
|
|
|
|
nsnull, getter_AddRefs(item));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptObjectOwner> owner(do_QueryInterface(item));
|
|
|
|
|
|
|
|
nsIScriptContext *context = (nsIScriptContext*)::JS_GetContextPrivate(cx);
|
2000-03-18 17:48:12 +00:00
|
|
|
JSObject *scriptObject;
|
2001-03-22 08:51:52 +00:00
|
|
|
rv = GetScriptObject(context, (void **)&scriptObject);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
2000-03-18 17:48:12 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (owner) {
|
|
|
|
nsIScriptSecurityManager *sm =
|
|
|
|
nsJSUtils::nsGetSecurityManager(cx, scriptObject);
|
|
|
|
|
|
|
|
rv = sm->CheckScriptAccess(cx, scriptObject,
|
|
|
|
NS_DOM_PROP_NSHTMLFORMELEMENT_NAMEDITEM,
|
|
|
|
PR_FALSE);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2000-03-18 17:48:12 +00:00
|
|
|
JSObject* obj;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
rv = owner->GetScriptObject(context, (void**)&obj);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
2000-03-18 17:48:12 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2000-03-18 17:48:12 +00:00
|
|
|
*aReturn = OBJECT_TO_JSVAL(obj);
|
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
return rv;
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsISupports> supports;
|
|
|
|
rv = this->QueryInterface(NS_GET_IID(nsISupports), getter_AddRefs(supports));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
rv = nsJSUtils::nsCallJSScriptObjectGetProperty(supports, cx, scriptObject,
|
|
|
|
argv[0], aReturn);
|
1998-08-07 23:08:00 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
return rv;
|
1998-08-04 00:05:22 +00:00
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-03-22 08:51:52 +00:00
|
|
|
nsHTMLDocument::GetScriptObject(nsIScriptContext *aContext,
|
|
|
|
void** aScriptObject)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
1999-09-14 04:17:07 +00:00
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
1998-07-22 23:32:19 +00:00
|
|
|
|
|
|
|
if (nsnull == mScriptObject) {
|
1999-09-14 04:17:07 +00:00
|
|
|
// XXX We make the (possibly erroneous) assumption that the first
|
|
|
|
// presentation shell represents the "primary view" of the document
|
|
|
|
// and that the JS parent chain should incorporate just that view.
|
|
|
|
// This is done for lack of a better model when we have multiple
|
|
|
|
// views.
|
|
|
|
nsIPresShell* shell = (nsIPresShell*) mPresShells.ElementAt(0);
|
|
|
|
if (shell) {
|
|
|
|
nsCOMPtr<nsIPresContext> cx;
|
|
|
|
shell->GetPresContext(getter_AddRefs(cx));
|
|
|
|
nsCOMPtr<nsISupports> container;
|
|
|
|
|
|
|
|
res = cx->GetContainer(getter_AddRefs(container));
|
|
|
|
if (NS_SUCCEEDED(res) && container) {
|
1999-12-03 09:24:22 +00:00
|
|
|
global = do_GetInterface(container);
|
1999-09-14 04:17:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// XXX If we can't find a view, parent to the calling context's
|
|
|
|
// global object. This may not be right either, but we need
|
|
|
|
// something.
|
|
|
|
else {
|
|
|
|
global = getter_AddRefs(aContext->GetGlobalObject());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(res)) {
|
|
|
|
res = NS_NewScriptHTMLDocument(aContext,
|
|
|
|
(nsISupports *)(nsIDOMHTMLDocument *)this,
|
|
|
|
(nsISupports *)global,
|
|
|
|
(void**)&mScriptObject);
|
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
1999-09-14 04:17:07 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
*aScriptObject = mScriptObject;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-11-25 00:05:21 +00:00
|
|
|
PRBool
|
2000-09-22 10:18:07 +00:00
|
|
|
nsHTMLDocument::Resolve(JSContext *aContext, JSObject *aObj, jsval aID,
|
|
|
|
PRBool *aDidDefineProperty)
|
1999-11-25 00:05:21 +00:00
|
|
|
{
|
2000-09-22 10:18:07 +00:00
|
|
|
*aDidDefineProperty = PR_FALSE;
|
|
|
|
|
2000-03-14 03:18:43 +00:00
|
|
|
if (!JSVAL_IS_STRING(aID)) {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
1999-11-29 20:44:36 +00:00
|
|
|
nsresult result;
|
1999-11-25 00:05:21 +00:00
|
|
|
PRBool ret = PR_TRUE;
|
2000-03-18 17:48:12 +00:00
|
|
|
jsval val = 0;
|
|
|
|
|
|
|
|
result = NamedItem(aContext, &aID, 1, &val);
|
|
|
|
if (NS_SUCCEEDED(result) && val) {
|
2001-03-22 08:51:52 +00:00
|
|
|
JSString *str = JSVAL_TO_STRING(aID);
|
|
|
|
ret = ::JS_DefineUCProperty(aContext, aObj,JS_GetStringChars(str),
|
|
|
|
JS_GetStringLength(str), val, nsnull,
|
|
|
|
nsnull, 0);
|
2000-09-22 10:18:07 +00:00
|
|
|
|
|
|
|
*aDidDefineProperty = PR_TRUE;
|
1999-11-25 00:05:21 +00:00
|
|
|
}
|
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
ret = PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
1998-08-28 15:55:31 +00:00
|
|
|
|
|
|
|
//----------------------------
|
1998-09-04 15:41:20 +00:00
|
|
|
|
1998-11-12 22:25:51 +00:00
|
|
|
PRBool
|
|
|
|
nsHTMLDocument::GetBodyContent()
|
|
|
|
{
|
2000-12-14 22:37:22 +00:00
|
|
|
nsCOMPtr<nsIDOMElement> root;
|
|
|
|
|
|
|
|
GetDocumentElement(getter_AddRefs(root));
|
|
|
|
|
|
|
|
if (!root) {
|
1998-11-12 22:25:51 +00:00
|
|
|
return PR_FALSE;
|
|
|
|
}
|
1998-09-04 15:41:20 +00:00
|
|
|
|
2000-04-15 20:15:37 +00:00
|
|
|
nsAutoString bodyStr; bodyStr.AssignWithConversion("BODY");
|
2000-12-14 22:37:22 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> child;
|
|
|
|
root->GetFirstChild(getter_AddRefs(child));
|
1998-11-12 22:25:51 +00:00
|
|
|
|
2000-12-14 22:37:22 +00:00
|
|
|
while (child) {
|
|
|
|
nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(child));
|
|
|
|
|
|
|
|
if (domElement) {
|
|
|
|
nsAutoString tagName;
|
1998-11-12 22:25:51 +00:00
|
|
|
domElement->GetTagName(tagName);
|
2000-12-14 22:37:22 +00:00
|
|
|
|
1998-11-12 22:25:51 +00:00
|
|
|
if (bodyStr.EqualsIgnoreCase(tagName)) {
|
|
|
|
mBodyContent = child;
|
2000-12-16 23:38:56 +00:00
|
|
|
NS_ADDREF(mBodyContent);
|
1998-11-12 22:25:51 +00:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
2000-12-14 22:37:22 +00:00
|
|
|
nsIDOMNode *tmpNode = child;
|
|
|
|
tmpNode->GetNextSibling(getter_AddRefs(child));
|
1998-11-12 22:25:51 +00:00
|
|
|
}
|
2000-12-14 22:37:22 +00:00
|
|
|
|
1998-11-12 22:25:51 +00:00
|
|
|
return PR_FALSE;
|
1998-08-28 15:55:31 +00:00
|
|
|
}
|
|
|
|
|
1999-02-04 23:23:07 +00:00
|
|
|
nsresult
|
|
|
|
nsHTMLDocument::GetBodyElement(nsIDOMHTMLBodyElement** aBody)
|
|
|
|
{
|
|
|
|
if (mBodyContent == nsnull && PR_FALSE == GetBodyContent()) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2000-09-09 05:46:14 +00:00
|
|
|
return mBodyContent->QueryInterface(NS_GET_IID(nsIDOMHTMLBodyElement),
|
1999-02-04 23:23:07 +00:00
|
|
|
(void**)aBody);
|
|
|
|
}
|
|
|
|
|
1998-09-23 17:16:51 +00:00
|
|
|
// forms related stuff
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::AddForm(nsIDOMHTMLFormElement *aForm)
|
|
|
|
{
|
1999-01-18 03:43:43 +00:00
|
|
|
#if 0
|
|
|
|
// Not necessary anymore since forms are real content now
|
1998-09-23 17:16:51 +00:00
|
|
|
NS_PRECONDITION(nsnull != aForm, "null ptr");
|
|
|
|
if (nsnull == aForm) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1998-10-21 09:26:33 +00:00
|
|
|
|
1998-09-23 17:16:51 +00:00
|
|
|
nsIContent* iContent = nsnull;
|
2000-09-09 05:46:14 +00:00
|
|
|
nsresult result = aForm->QueryInterface(NS_GET_IID(nsIContent), (void**)&iContent);
|
1998-09-23 17:16:51 +00:00
|
|
|
if ((NS_OK == result) && iContent) {
|
1998-10-21 09:26:33 +00:00
|
|
|
nsIDOMHTMLCollection* forms = nsnull;
|
|
|
|
|
|
|
|
// Initialize mForms if necessary...
|
|
|
|
if (nsnull == mForms) {
|
2000-05-17 20:35:19 +00:00
|
|
|
mForms = new nsContentList(this, nsHTMLAtoms::form, kNameSpaceID_Unknown);
|
1998-10-22 23:00:37 +00:00
|
|
|
NS_ADDREF(mForms);
|
1998-10-21 09:26:33 +00:00
|
|
|
}
|
|
|
|
|
1998-10-22 23:00:37 +00:00
|
|
|
mForms->Add(iContent);
|
1998-10-21 09:26:33 +00:00
|
|
|
NS_RELEASE(iContent);
|
1998-09-23 17:16:51 +00:00
|
|
|
}
|
|
|
|
return result;
|
1999-01-18 03:43:43 +00:00
|
|
|
#endif
|
|
|
|
return NS_OK;
|
1998-09-23 17:16:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLDocument::GetForms(nsIDOMHTMLCollection** aForms)
|
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!mForms) {
|
2000-05-17 20:35:19 +00:00
|
|
|
mForms = new nsContentList(this, nsHTMLAtoms::form, kNameSpaceID_Unknown);
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_ENSURE_TRUE(mForms, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
1998-10-21 09:26:33 +00:00
|
|
|
NS_ADDREF(mForms);
|
1998-09-23 17:16:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*aForms = (nsIDOMHTMLCollection *)mForms;
|
|
|
|
NS_ADDREF(mForms);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|