2001-09-25 01:32:19 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
1998-07-22 23:32:19 +00:00
|
|
|
*
|
2001-09-25 01:32:19 +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-07-22 23:32:19 +00:00
|
|
|
*
|
2001-09-25 01:32:19 +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-07-22 23:32:19 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2001-09-25 01:32:19 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 03:40:37 +00:00
|
|
|
*
|
2001-09-25 01:32:19 +00:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1998-07-22 23:32:19 +00:00
|
|
|
|
|
|
|
#include "nsContentList.h"
|
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsIDOMNode.h"
|
2002-06-28 01:30:09 +00:00
|
|
|
#include "nsIDOM3Node.h"
|
1998-07-22 23:32:19 +00:00
|
|
|
#include "nsIDocument.h"
|
1998-12-20 01:21:23 +00:00
|
|
|
#include "nsINameSpaceManager.h"
|
1999-01-18 03:43:43 +00:00
|
|
|
#include "nsGenericElement.h"
|
1998-12-20 01:21:23 +00:00
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
#include "nsContentUtils.h"
|
|
|
|
|
1999-01-22 22:48:00 +00:00
|
|
|
#include "nsLayoutAtoms.h"
|
1998-12-20 01:21:23 +00:00
|
|
|
#include "nsHTMLAtoms.h" // XXX until atoms get factored into nsLayoutAtoms
|
1998-07-22 23:32:19 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
// Form related includes
|
|
|
|
#include "nsIDOMHTMLFormElement.h"
|
2001-05-30 11:26:21 +00:00
|
|
|
#include "nsIContentList.h"
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2002-05-08 20:48:19 +00:00
|
|
|
#include "pldhash.h"
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsBaseContentList::nsBaseContentList()
|
1998-08-04 00:05:22 +00:00
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
2001-03-22 08:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsBaseContentList::~nsBaseContentList()
|
|
|
|
{
|
|
|
|
// mElements only has weak references to the content objects so we
|
|
|
|
// don't need to do any cleanup here.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
// QueryInterface implementation for nsBaseContentList
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN(nsBaseContentList)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMNodeList)
|
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMNodeList)
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(NodeList)
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsBaseContentList)
|
|
|
|
NS_IMPL_RELEASE(nsBaseContentList)
|
|
|
|
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsBaseContentList::GetLength(PRUint32* aLength)
|
|
|
|
{
|
|
|
|
*aLength = mElements.Count();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsBaseContentList::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
|
|
|
|
{
|
|
|
|
nsISupports *tmp = NS_REINTERPRET_CAST(nsISupports *,
|
2001-12-21 01:10:07 +00:00
|
|
|
mElements.SafeElementAt(aIndex));
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!tmp) {
|
|
|
|
*aReturn = nsnull;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return CallQueryInterface(tmp, aReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsBaseContentList::AppendElement(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
// Shouldn't hold a reference since we'll be told when the content
|
|
|
|
// leaves the document or the document will be destroyed.
|
|
|
|
mElements.AppendElement(aContent);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsBaseContentList::RemoveElement(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
mElements.RemoveElement(aContent);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsBaseContentList::IndexOf(nsIContent *aContent, PRInt32& aIndex)
|
|
|
|
{
|
|
|
|
aIndex = mElements.IndexOf(aContent);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsBaseContentList::Reset()
|
|
|
|
{
|
|
|
|
mElements.Clear();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// nsFormContentList
|
|
|
|
|
|
|
|
// This helper function checks if aContent is in some way associated
|
|
|
|
// with aForm, this check is only successful if the form is a
|
|
|
|
// container (and a form is a container as long as the document is
|
|
|
|
// wellformed). If the form is a container the only elements that are
|
|
|
|
// considerd to be associated with a form are the elements that are
|
|
|
|
// contained within the form. If the form is a leaf element then all
|
|
|
|
// the elements will be accepted into this list.
|
|
|
|
|
|
|
|
static PRBool BelongsInForm(nsIDOMHTMLFormElement *aForm,
|
|
|
|
nsIContent *aContent)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIContent> form(do_QueryInterface(aForm));
|
|
|
|
|
|
|
|
if (!form) {
|
|
|
|
NS_WARNING("This should not happen, form is not an nsIContent!");
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (form.get() == aContent) {
|
|
|
|
// The list for aForm contains the form itself, forms should not
|
|
|
|
// be reachable by name in the form namespace, so we return false
|
|
|
|
// here.
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
|
|
|
|
aContent->GetParent(*getter_AddRefs(content));
|
|
|
|
|
|
|
|
while (content) {
|
|
|
|
if (content == form) {
|
|
|
|
// aContent is contained within the form so we return true.
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
|
|
|
|
content->GetTag(*getter_AddRefs(tag));
|
|
|
|
|
|
|
|
if (tag.get() == nsHTMLAtoms::form) {
|
|
|
|
// The child is contained within a form, but not the right form
|
|
|
|
// so we ignore it.
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIContent *tmp = content;
|
|
|
|
|
|
|
|
tmp->GetParent(*getter_AddRefs(content));
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 count = 0;
|
|
|
|
|
|
|
|
form->ChildCount(count);
|
|
|
|
|
|
|
|
if (!count) {
|
|
|
|
// The form is a leaf and aContent wasn't inside any other form so
|
|
|
|
// we return true
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The form is a container but aContent wasn't inside the form,
|
|
|
|
// return false
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsFormContentList::nsFormContentList(nsIDOMHTMLFormElement *aForm,
|
|
|
|
nsBaseContentList& aContentList)
|
|
|
|
: nsBaseContentList()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
|
|
|
|
// move elements that belong to mForm into this content list
|
|
|
|
|
|
|
|
PRUint32 i, length = 0;
|
|
|
|
nsCOMPtr<nsIDOMNode> item;
|
|
|
|
|
|
|
|
aContentList.GetLength(&length);
|
|
|
|
|
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
aContentList.Item(i, getter_AddRefs(item));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> c(do_QueryInterface(item));
|
|
|
|
|
|
|
|
if (c && BelongsInForm(aForm, c)) {
|
|
|
|
AppendElement(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsFormContentList::~nsFormContentList()
|
|
|
|
{
|
|
|
|
Reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormContentList::AppendElement(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
NS_ADDREF(aContent);
|
|
|
|
|
|
|
|
return nsBaseContentList::AppendElement(aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormContentList::RemoveElement(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
PRInt32 i = mElements.IndexOf(aContent);
|
|
|
|
|
|
|
|
if (i >= 0) {
|
|
|
|
nsIContent *content = NS_STATIC_CAST(nsIContent *, mElements.ElementAt(i));
|
|
|
|
|
|
|
|
NS_RELEASE(content);
|
|
|
|
|
|
|
|
mElements.RemoveElementAt(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormContentList::Reset()
|
|
|
|
{
|
|
|
|
PRInt32 i, length = mElements.Count();
|
|
|
|
|
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
nsIContent *content = NS_STATIC_CAST(nsIContent *, mElements.ElementAt(i));
|
|
|
|
|
|
|
|
NS_RELEASE(content);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nsBaseContentList::Reset();
|
|
|
|
}
|
|
|
|
|
2002-05-08 20:48:19 +00:00
|
|
|
// Hashtable for storing nsContentLists
|
|
|
|
static PLDHashTable gContentListHashTable;
|
|
|
|
|
|
|
|
struct ContentListHashEntry : public PLDHashEntryHdr
|
|
|
|
{
|
|
|
|
nsContentList* mContentList;
|
|
|
|
};
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(const void *)
|
|
|
|
ContentListHashtableGetKey(PLDHashTable *table, PLDHashEntryHdr *entry)
|
|
|
|
{
|
|
|
|
ContentListHashEntry *e = NS_STATIC_CAST(ContentListHashEntry *, entry);
|
|
|
|
return e->mContentList->GetKey();
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(PLDHashNumber)
|
|
|
|
ContentListHashtableHashKey(PLDHashTable *table, const void *key)
|
|
|
|
{
|
|
|
|
const nsContentListKey* list = NS_STATIC_CAST(const nsContentListKey *, key);
|
|
|
|
return list->GetHash();
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
ContentListHashtableMatchEntry(PLDHashTable *table,
|
|
|
|
const PLDHashEntryHdr *entry,
|
|
|
|
const void *key)
|
|
|
|
{
|
|
|
|
const ContentListHashEntry *e =
|
|
|
|
NS_STATIC_CAST(const ContentListHashEntry *, entry);
|
|
|
|
const nsContentListKey* list1 = e->mContentList->GetKey();
|
|
|
|
const nsContentListKey* list2 = NS_STATIC_CAST(const nsContentListKey *, key);
|
|
|
|
|
|
|
|
return list1->Equals(*list2);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_GetContentList(nsIDocument* aDocument, nsIAtom* aMatchAtom,
|
|
|
|
PRInt32 aMatchNameSpaceId, nsIContent* aRootContent,
|
|
|
|
nsIContentList** aInstancePtrResult)
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = nsnull;
|
|
|
|
nsContentList* list = nsnull;
|
|
|
|
|
|
|
|
static PLDHashTableOps hash_table_ops =
|
|
|
|
{
|
|
|
|
PL_DHashAllocTable,
|
|
|
|
PL_DHashFreeTable,
|
|
|
|
ContentListHashtableGetKey,
|
|
|
|
ContentListHashtableHashKey,
|
|
|
|
ContentListHashtableMatchEntry,
|
|
|
|
PL_DHashMoveEntryStub,
|
|
|
|
PL_DHashClearEntryStub,
|
|
|
|
PL_DHashFinalizeStub
|
|
|
|
};
|
|
|
|
|
|
|
|
// Initialize the hashtable if needed.
|
|
|
|
if (!gContentListHashTable.ops) {
|
|
|
|
PRBool success = PL_DHashTableInit(&gContentListHashTable,
|
|
|
|
&hash_table_ops, nsnull,
|
|
|
|
sizeof(ContentListHashEntry),
|
|
|
|
16);
|
|
|
|
|
|
|
|
if (!success) {
|
|
|
|
gContentListHashTable.ops = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ContentListHashEntry *entry = nsnull;
|
|
|
|
// First we look in our hashtable. Then we create a content list if needed
|
|
|
|
if (gContentListHashTable.ops) {
|
|
|
|
nsContentListKey hashKey(aDocument, aMatchAtom,
|
|
|
|
aMatchNameSpaceId, aRootContent);
|
|
|
|
|
|
|
|
// A PL_DHASH_ADD is equivalent to a PL_DHASH_LOOKUP for cases
|
|
|
|
// when the entry is already in the hashtable.
|
|
|
|
entry = NS_STATIC_CAST(ContentListHashEntry *,
|
|
|
|
PL_DHashTableOperate(&gContentListHashTable,
|
|
|
|
&hashKey,
|
|
|
|
PL_DHASH_ADD));
|
|
|
|
if (entry)
|
|
|
|
list = entry->mContentList;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!list) {
|
|
|
|
// We need to create a ContentList and add it to our new entry, if
|
|
|
|
// we have an entry
|
|
|
|
list = new nsContentList(aDocument, aMatchAtom,
|
|
|
|
aMatchNameSpaceId, aRootContent);
|
|
|
|
if (entry) {
|
|
|
|
if (list)
|
|
|
|
entry->mContentList = list;
|
|
|
|
else
|
|
|
|
PL_DHashTableRawRemove(&gContentListHashTable, entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
*aInstancePtrResult = list;
|
|
|
|
NS_ADDREF(*aInstancePtrResult);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
|
|
|
|
// nsContentList implementation
|
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
nsContentList::nsContentList(nsIDocument *aDocument,
|
1999-01-15 19:18:30 +00:00
|
|
|
nsIAtom* aMatchAtom,
|
|
|
|
PRInt32 aMatchNameSpaceId,
|
|
|
|
nsIContent* aRootContent)
|
2002-05-08 20:48:19 +00:00
|
|
|
: nsBaseContentList(), nsContentListKey(aDocument, aMatchAtom, aMatchNameSpaceId, aRootContent)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2000-06-28 04:17:26 +00:00
|
|
|
if (nsLayoutAtoms::wildcard == mMatchAtom) {
|
1999-01-15 19:18:30 +00:00
|
|
|
mMatchAll = PR_TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
mMatchAll = PR_FALSE;
|
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
mFunc = nsnull;
|
1999-02-04 23:23:07 +00:00
|
|
|
mData = nsnull;
|
2002-06-28 01:30:09 +00:00
|
|
|
mState = LIST_DIRTY;
|
1998-07-22 23:32:19 +00:00
|
|
|
Init(aDocument);
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
nsContentList::nsContentList(nsIDocument *aDocument,
|
1999-01-15 19:18:30 +00:00
|
|
|
nsContentListMatchFunc aFunc,
|
2002-03-23 23:54:46 +00:00
|
|
|
const nsAString& aData,
|
1999-01-15 19:18:30 +00:00
|
|
|
nsIContent* aRootContent)
|
2002-05-08 20:48:19 +00:00
|
|
|
: nsBaseContentList(), nsContentListKey(aDocument, nsnull, kNameSpaceID_Unknown, aRootContent)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
|
|
|
mFunc = aFunc;
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!aData.IsEmpty()) {
|
|
|
|
mData = new nsString(aData);
|
1999-05-04 20:53:44 +00:00
|
|
|
// If this fails, fail silently
|
|
|
|
}
|
1999-06-12 00:37:36 +00:00
|
|
|
else {
|
|
|
|
mData = nsnull;
|
|
|
|
}
|
1999-01-15 19:18:30 +00:00
|
|
|
mMatchAtom = nsnull;
|
|
|
|
mRootContent = aRootContent;
|
|
|
|
mMatchAll = PR_FALSE;
|
2002-06-28 01:30:09 +00:00
|
|
|
mState = LIST_DIRTY;
|
1998-07-22 23:32:19 +00:00
|
|
|
Init(aDocument);
|
|
|
|
}
|
|
|
|
|
|
|
|
void nsContentList::Init(nsIDocument *aDocument)
|
|
|
|
{
|
1999-01-18 03:43:43 +00:00
|
|
|
// We don't reference count the reference to the document
|
1998-07-22 23:32:19 +00:00
|
|
|
// If the document goes away first, we'll be informed and we
|
|
|
|
// can drop our reference.
|
|
|
|
// If we go away first, we'll get rid of ourselves from the
|
|
|
|
// document's observer list.
|
|
|
|
mDocument = aDocument;
|
2001-03-22 08:51:52 +00:00
|
|
|
if (mDocument) {
|
1999-01-18 03:43:43 +00:00
|
|
|
mDocument->AddObserver(this);
|
1999-01-15 19:18:30 +00:00
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
nsContentList::~nsContentList()
|
|
|
|
{
|
2002-05-08 20:48:19 +00:00
|
|
|
RemoveFromHashtable();
|
2001-03-22 08:51:52 +00:00
|
|
|
if (mDocument) {
|
1998-07-22 23:32:19 +00:00
|
|
|
mDocument->RemoveObserver(this);
|
|
|
|
}
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
delete mData;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
|
|
|
// QueryInterface implementation for nsContentList
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN(nsContentList)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMHTMLCollection)
|
2001-05-30 11:26:21 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIContentList)
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(HTMLCollection)
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsBaseContentList)
|
1998-07-22 23:32:19 +00:00
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsContentList, nsBaseContentList)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsContentList, nsBaseContentList)
|
1998-07-22 23:32:19 +00:00
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
1998-07-22 23:32:19 +00:00
|
|
|
NS_IMETHODIMP
|
2001-05-30 11:26:21 +00:00
|
|
|
nsContentList::GetLength(PRUint32* aLength, PRBool aDoFlush)
|
1999-01-18 03:43:43 +00:00
|
|
|
{
|
|
|
|
nsresult result = CheckDocumentExistence();
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
2002-06-28 01:30:09 +00:00
|
|
|
BringSelfUpToDate(aDoFlush);
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
*aLength = mElements.Count();
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-05-30 11:26:21 +00:00
|
|
|
nsContentList::Item(PRUint32 aIndex, nsIDOMNode** aReturn, PRBool aDoFlush)
|
1999-01-18 03:43:43 +00:00
|
|
|
{
|
|
|
|
nsresult result = CheckDocumentExistence();
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
2001-05-30 11:26:21 +00:00
|
|
|
if (mDocument && aDoFlush) {
|
2001-03-22 08:51:52 +00:00
|
|
|
// Flush pending content changes Bug 4891
|
|
|
|
mDocument->FlushPendingNotifications(PR_FALSE);
|
2000-06-17 01:28:41 +00:00
|
|
|
}
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
if (mState != LIST_UP_TO_DATE)
|
|
|
|
PopulateSelf(aIndex+1);
|
|
|
|
|
|
|
|
NS_ASSERTION(!mDocument || mState != LIST_DIRTY,
|
|
|
|
"PopulateSelf left the list in a dirty (useless) state!");
|
|
|
|
|
|
|
|
nsIContent *element = NS_STATIC_CAST(nsIContent *,
|
|
|
|
mElements.SafeElementAt(aIndex));
|
2001-12-21 01:10:07 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (element) {
|
|
|
|
result = CallQueryInterface(element, aReturn);
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
*aReturn = nsnull;
|
|
|
|
}
|
|
|
|
}
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
NS_IMETHODIMP
|
2002-03-23 23:54:46 +00:00
|
|
|
nsContentList::NamedItem(const nsAString& aName, nsIDOMNode** aReturn, PRBool aDoFlush)
|
1999-01-18 03:43:43 +00:00
|
|
|
{
|
|
|
|
nsresult result = CheckDocumentExistence();
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
2002-06-28 01:30:09 +00:00
|
|
|
BringSelfUpToDate(aDoFlush);
|
|
|
|
|
2001-03-22 08:51:52 +00:00
|
|
|
PRInt32 i, count = mElements.Count();
|
1999-01-18 03:43:43 +00:00
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2001-03-22 08:51:52 +00:00
|
|
|
nsIContent *content = NS_STATIC_CAST(nsIContent *,
|
|
|
|
mElements.ElementAt(i));
|
|
|
|
if (content) {
|
1999-01-18 03:43:43 +00:00
|
|
|
nsAutoString name;
|
|
|
|
// XXX Should it be an EqualsIgnoreCase?
|
2002-05-20 22:47:02 +00:00
|
|
|
if (((content->GetAttr(kNameSpaceID_None, nsHTMLAtoms::name,
|
|
|
|
name) == NS_CONTENT_ATTR_HAS_VALUE) &&
|
|
|
|
aName.Equals(name)) ||
|
|
|
|
((content->GetAttr(kNameSpaceID_None, nsHTMLAtoms::id,
|
|
|
|
name) == NS_CONTENT_ATTR_HAS_VALUE) &&
|
|
|
|
aName.Equals(name))) {
|
2001-03-22 08:51:52 +00:00
|
|
|
return CallQueryInterface(content, aReturn);
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*aReturn = nsnull;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-05-30 11:26:21 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::IndexOf(nsIContent *aContent, PRInt32& aIndex, PRBool aDoFlush)
|
|
|
|
{
|
|
|
|
nsresult result = CheckDocumentExistence();
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
2002-06-28 01:30:09 +00:00
|
|
|
BringSelfUpToDate(aDoFlush);
|
|
|
|
|
2001-05-30 11:26:21 +00:00
|
|
|
aIndex = mElements.IndexOf(aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::GetLength(PRUint32* aLength)
|
|
|
|
{
|
|
|
|
return GetLength(aLength, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
|
|
|
|
{
|
|
|
|
return Item(aIndex, aReturn, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2002-03-23 23:54:46 +00:00
|
|
|
nsContentList::NamedItem(const nsAString& aName, nsIDOMNode** aReturn)
|
2001-05-30 11:26:21 +00:00
|
|
|
{
|
|
|
|
return NamedItem(aName, aReturn, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
NS_IMETHODIMP
|
2001-03-22 08:51:52 +00:00
|
|
|
nsContentList::ContentAppended(nsIDocument *aDocument, nsIContent* aContainer,
|
|
|
|
PRInt32 aNewIndexInContainer)
|
1999-01-18 03:43:43 +00:00
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
/*
|
|
|
|
* If the state is LIST_DIRTY then we have no useful information in
|
|
|
|
* our list and we want to put off doing work as much as possible.
|
|
|
|
*/
|
|
|
|
if (mState == LIST_DIRTY)
|
|
|
|
return NS_OK;
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
PRInt32 count;
|
1999-01-18 03:43:43 +00:00
|
|
|
aContainer->ChildCount(count);
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
/*
|
|
|
|
* We want to handle the case of ContentAppended by sometimes
|
|
|
|
* appending the content to our list, not just setting state to
|
|
|
|
* LIST_DIRTY, since most of our ContentAppended notifications
|
|
|
|
* should come during pageload and be at the end of the document.
|
|
|
|
* Do a bit of work to see whether we could just append to what we
|
|
|
|
* already have.
|
|
|
|
*/
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
if ((count > 0) && IsDescendantOfRoot(aContainer)) {
|
2002-06-28 01:30:09 +00:00
|
|
|
PRInt32 ourCount = mElements.Count();
|
|
|
|
PRBool appendToList = PR_FALSE;
|
|
|
|
if (ourCount == 0) {
|
|
|
|
appendToList = PR_TRUE;
|
|
|
|
} else {
|
|
|
|
nsIContent* ourLastContent =
|
|
|
|
NS_STATIC_CAST(nsIContent*, mElements.ElementAt(ourCount - 1));
|
|
|
|
/*
|
|
|
|
* We want to append instead of invalidating in two cases:
|
|
|
|
* 1) aContainer is an ancestor of ourLastContent (this case
|
|
|
|
covers aContainer == ourLastContent)
|
|
|
|
* 2) aContainer comes after ourLastContent in document order
|
|
|
|
*/
|
|
|
|
if (nsContentUtils::ContentIsDescendantOf(ourLastContent, aContainer)) {
|
|
|
|
appendToList = PR_TRUE;
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIDOM3Node> ourLastDOM3Node(do_QueryInterface(ourLastContent));
|
|
|
|
nsCOMPtr<nsIDOMNode> newNodeContainer(do_QueryInterface(aContainer));
|
|
|
|
if (ourLastDOM3Node && newNodeContainer) {
|
|
|
|
PRUint16 comparisonFlags;
|
|
|
|
nsresult rv = ourLastDOM3Node->CompareTreePosition(newNodeContainer,
|
|
|
|
&comparisonFlags);
|
|
|
|
if (NS_SUCCEEDED(rv) &&
|
|
|
|
(comparisonFlags & nsIDOMNode::TREE_POSITION_FOLLOWING)) {
|
|
|
|
appendToList = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 i;
|
|
|
|
|
|
|
|
if (!appendToList) {
|
|
|
|
// The new stuff is somewhere in the middle of our list; check
|
|
|
|
// whether we need to invalidate
|
2001-03-22 08:51:52 +00:00
|
|
|
nsCOMPtr<nsIContent> content;
|
2002-06-28 01:30:09 +00:00
|
|
|
for (i = aNewIndexInContainer; i <= count-1; ++i) {
|
|
|
|
aContainer->ChildAt(i, *getter_AddRefs(content));
|
|
|
|
if (MatchSelf(content)) {
|
|
|
|
// Uh-oh. We're gonna have to add elements into the middle
|
|
|
|
// of our list. That's not worth the effort.
|
|
|
|
mState = LIST_DIRTY;
|
|
|
|
break;
|
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point we know we could append. If we're not up to
|
|
|
|
* date, however, that would be a bad idea -- it could miss some
|
|
|
|
* content that we never picked up due to being lazy. Further, we
|
|
|
|
* may never get asked for this content... so don't grab it yet.
|
|
|
|
*/
|
|
|
|
if (mState == LIST_LAZY) // be lazy
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're up to date. That means someone's actively using us; we
|
|
|
|
* may as well grab this content....
|
|
|
|
*/
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
for (i = aNewIndexInContainer; i <= count-1; ++i) {
|
|
|
|
aContainer->ChildAt(i, *getter_AddRefs(content));
|
|
|
|
PRUint32 limit = PRUint32(-1);
|
|
|
|
PopulateWith(content, PR_TRUE, limit);
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::ContentInserted(nsIDocument *aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
if (mState == LIST_DIRTY)
|
|
|
|
return NS_OK;
|
1999-01-18 03:43:43 +00:00
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
if (IsDescendantOfRoot(aContainer) && MatchSelf(aChild))
|
|
|
|
mState = LIST_DIRTY;
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::ContentReplaced(nsIDocument *aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aOldChild,
|
|
|
|
nsIContent* aNewChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
if (mState == LIST_DIRTY)
|
|
|
|
return NS_OK;
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
if (IsDescendantOfRoot(aContainer)) {
|
2002-06-28 01:30:09 +00:00
|
|
|
if (MatchSelf(aOldChild) || MatchSelf(aNewChild)) {
|
|
|
|
mState = LIST_DIRTY;
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ContainsRoot(aOldChild)) {
|
|
|
|
DisconnectFromDocument();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::ContentRemoved(nsIDocument *aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
if (IsDescendantOfRoot(aContainer)) {
|
|
|
|
if (MatchSelf(aChild)) {
|
|
|
|
mState = LIST_DIRTY;
|
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
|
|
|
else if (ContainsRoot(aChild)) {
|
|
|
|
DisconnectFromDocument();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsContentList::DocumentWillBeDestroyed(nsIDocument *aDocument)
|
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
DisconnectFromDocument();
|
1999-01-18 03:43:43 +00:00
|
|
|
Reset();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
PRBool
|
|
|
|
nsContentList::Match(nsIContent *aContent)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
if (!aContent)
|
|
|
|
return PR_FALSE;
|
2000-05-16 00:55:05 +00:00
|
|
|
|
|
|
|
if (mMatchAtom) {
|
|
|
|
nsCOMPtr<nsINodeInfo> ni;
|
|
|
|
aContent->GetNodeInfo(*getter_AddRefs(ni));
|
|
|
|
|
|
|
|
if (!ni)
|
2002-06-28 01:30:09 +00:00
|
|
|
return PR_FALSE;
|
2000-05-16 00:55:05 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aContent));
|
|
|
|
|
|
|
|
if (!node)
|
2002-06-28 01:30:09 +00:00
|
|
|
return PR_FALSE;
|
2000-05-16 00:55:05 +00:00
|
|
|
|
|
|
|
PRUint16 type;
|
|
|
|
node->GetNodeType(&type);
|
|
|
|
|
|
|
|
if (type != nsIDOMNode::ELEMENT_NODE)
|
2002-06-28 01:30:09 +00:00
|
|
|
return PR_FALSE;
|
2000-05-16 00:55:05 +00:00
|
|
|
|
|
|
|
if (mMatchNameSpaceId == kNameSpaceID_Unknown) {
|
2002-06-28 01:30:09 +00:00
|
|
|
return (mMatchAll || ni->Equals(mMatchAtom));
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
return ((mMatchAll && ni->NamespaceEquals(mMatchNameSpaceId)) ||
|
|
|
|
ni->Equals(mMatchAtom, mMatchNameSpaceId));
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
else if (mFunc) {
|
2002-06-28 01:30:09 +00:00
|
|
|
return (*mFunc)(aContent, mData);
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
return PR_FALSE;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
nsresult
|
|
|
|
nsContentList::CheckDocumentExistence()
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-01-18 03:43:43 +00:00
|
|
|
nsresult result = NS_OK;
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!mDocument && mRootContent) {
|
1999-01-18 03:43:43 +00:00
|
|
|
result = mRootContent->GetDocument(mDocument);
|
2001-03-22 08:51:52 +00:00
|
|
|
if (mDocument) {
|
1999-01-18 03:43:43 +00:00
|
|
|
mDocument->AddObserver(this);
|
2002-06-28 01:30:09 +00:00
|
|
|
mState = LIST_DIRTY;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
return result;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
PRBool
|
|
|
|
nsContentList::MatchSelf(nsIContent *aContent)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
if (Match(aContent))
|
1998-07-22 23:32:19 +00:00
|
|
|
return PR_TRUE;
|
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
PRInt32 i, count = -1;
|
|
|
|
|
1998-08-29 20:20:38 +00:00
|
|
|
aContent->ChildCount(count);
|
2002-05-08 20:48:19 +00:00
|
|
|
nsCOMPtr<nsIContent> child;
|
1998-07-22 23:32:19 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2002-05-08 20:48:19 +00:00
|
|
|
aContent->ChildAt(i, *getter_AddRefs(child));
|
1998-07-22 23:32:19 +00:00
|
|
|
if (MatchSelf(child)) {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
void
|
2002-06-28 01:30:09 +00:00
|
|
|
nsContentList::PopulateWith(nsIContent *aContent, PRBool aIncludeRoot,
|
|
|
|
PRUint32 & aElementsToAppend)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
1999-01-18 03:43:43 +00:00
|
|
|
if (aIncludeRoot) {
|
2002-06-28 01:30:09 +00:00
|
|
|
if (Match(aContent)) {
|
2001-03-22 08:51:52 +00:00
|
|
|
mElements.AppendElement(aContent);
|
2002-06-28 01:30:09 +00:00
|
|
|
--aElementsToAppend;
|
|
|
|
if (aElementsToAppend == 0)
|
|
|
|
return;
|
1999-01-18 03:43:43 +00:00
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
PRInt32 i, count;
|
1998-08-29 20:20:38 +00:00
|
|
|
aContent->ChildCount(count);
|
2002-05-08 20:48:19 +00:00
|
|
|
nsCOMPtr<nsIContent> child;
|
1998-07-22 23:32:19 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2002-05-08 20:48:19 +00:00
|
|
|
aContent->ChildAt(i, *getter_AddRefs(child));
|
2002-06-28 01:30:09 +00:00
|
|
|
PopulateWith(child, PR_TRUE, aElementsToAppend);
|
|
|
|
if (aElementsToAppend == 0)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsContentList::PopulateWithStartingAfter(nsIContent *aStartRoot,
|
|
|
|
nsIContent *aStartChild,
|
|
|
|
PRUint32 & aElementsToAppend)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG
|
|
|
|
PRUint32 invariant = aElementsToAppend + mElements.Count();
|
|
|
|
#endif
|
|
|
|
PRInt32 i = 0;
|
|
|
|
if (aStartChild) {
|
|
|
|
aStartRoot->IndexOf(aStartChild, i);
|
|
|
|
NS_ASSERTION(i >= 0, "The start child must be a child of the start root!");
|
|
|
|
++i; // move to one past
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 childCount;
|
|
|
|
aStartRoot->ChildCount(childCount);
|
|
|
|
nsCOMPtr<nsIContent> child;
|
|
|
|
for ( ; i < childCount; ++i) {
|
|
|
|
aStartRoot->ChildAt(i, *getter_AddRefs(child));
|
|
|
|
PopulateWith(child, PR_TRUE, aElementsToAppend);
|
|
|
|
NS_ASSERTION(aElementsToAppend + mElements.Count() == invariant,
|
|
|
|
"Something is awry in PopulateWith!");
|
|
|
|
if (aElementsToAppend == 0)
|
|
|
|
return;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> parent;
|
|
|
|
aStartRoot->GetParent(*getter_AddRefs(parent));
|
|
|
|
|
|
|
|
if (parent)
|
|
|
|
PopulateWithStartingAfter(parent, aStartRoot, aElementsToAppend);
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
void
|
2002-06-28 01:30:09 +00:00
|
|
|
nsContentList::PopulateSelf(PRUint32 aNeededLength)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
if (mState == LIST_DIRTY) {
|
|
|
|
Reset();
|
|
|
|
}
|
|
|
|
PRUint32 count = mElements.Count();
|
|
|
|
|
|
|
|
if (count >= aNeededLength) // We're all set
|
|
|
|
return;
|
|
|
|
|
|
|
|
PRUint32 elementsToAppend = aNeededLength - count;
|
|
|
|
#ifdef DEBUG
|
|
|
|
PRUint32 invariant = elementsToAppend + mElements.Count();
|
|
|
|
#endif
|
|
|
|
if (count != 0) {
|
|
|
|
PopulateWithStartingAfter(NS_STATIC_CAST(nsIContent*,
|
|
|
|
mElements.ElementAt(count - 1)),
|
|
|
|
nsnull,
|
|
|
|
elementsToAppend);
|
|
|
|
NS_ASSERTION(elementsToAppend + mElements.Count() == invariant,
|
|
|
|
"Something is awry in PopulateWithStartingAfter!");
|
|
|
|
} else if (mRootContent) {
|
|
|
|
PopulateWith(mRootContent, PR_FALSE, elementsToAppend);
|
|
|
|
NS_ASSERTION(elementsToAppend + mElements.Count() == invariant,
|
|
|
|
"Something is awry in PopulateWith!");
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
else if (mDocument) {
|
2002-05-08 20:48:19 +00:00
|
|
|
nsCOMPtr<nsIContent> root;
|
|
|
|
mDocument->GetRootContent(getter_AddRefs(root));
|
2000-10-30 18:51:50 +00:00
|
|
|
if (root) {
|
2002-06-28 01:30:09 +00:00
|
|
|
PopulateWith(root, PR_TRUE, elementsToAppend);
|
|
|
|
NS_ASSERTION(elementsToAppend + mElements.Count() == invariant,
|
|
|
|
"Something is awry in PopulateWith!");
|
2000-10-30 18:51:50 +00:00
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
if (mDocument) {
|
|
|
|
if (elementsToAppend != 0)
|
|
|
|
mState = LIST_UP_TO_DATE;
|
|
|
|
else
|
|
|
|
mState = LIST_LAZY;
|
|
|
|
} else {
|
|
|
|
// No document means we have to stay on our toes since we don't
|
|
|
|
// get content notifications.
|
|
|
|
mState = LIST_DIRTY;
|
|
|
|
}
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsContentList::IsDescendantOfRoot(nsIContent* aContainer)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
if (!mRootContent) {
|
2002-06-28 01:30:09 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
aContainer->GetDocument(*getter_AddRefs(doc));
|
|
|
|
NS_ASSERTION(doc == mDocument, "We should not get in here if aContainer is appended to some _other_ document!");
|
|
|
|
#endif
|
1999-01-18 03:43:43 +00:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
if (!aContainer) {
|
1999-01-18 03:43:43 +00:00
|
|
|
return PR_FALSE;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
1999-01-18 03:43:43 +00:00
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
return nsContentUtils::ContentIsDescendantOf(aContainer, mRootContent);
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
PRBool
|
|
|
|
nsContentList::ContainsRoot(nsIContent* aContent)
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2002-06-28 01:30:09 +00:00
|
|
|
if (!mRootContent || !aContent) {
|
1999-01-18 03:43:43 +00:00
|
|
|
return PR_FALSE;
|
|
|
|
}
|
2001-03-22 08:51:52 +00:00
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
return nsContentUtils::ContentIsDescendantOf(mRootContent, aContent);
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
|
|
|
|
1999-01-18 03:43:43 +00:00
|
|
|
void
|
|
|
|
nsContentList::DisconnectFromDocument()
|
1998-07-22 23:32:19 +00:00
|
|
|
{
|
2001-03-22 08:51:52 +00:00
|
|
|
if (mDocument) {
|
2002-05-08 20:48:19 +00:00
|
|
|
// Our key will change... Best remove ourselves before that happens.
|
|
|
|
RemoveFromHashtable();
|
1999-01-18 03:43:43 +00:00
|
|
|
mDocument->RemoveObserver(this);
|
1998-07-22 23:32:19 +00:00
|
|
|
mDocument = nsnull;
|
|
|
|
}
|
2002-06-28 01:30:09 +00:00
|
|
|
|
|
|
|
// We will get no more updates, so we can never know we're up to
|
|
|
|
// date
|
|
|
|
mState = LIST_DIRTY;
|
1998-07-22 23:32:19 +00:00
|
|
|
}
|
2002-05-08 20:48:19 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
nsContentList::RemoveFromHashtable()
|
|
|
|
{
|
|
|
|
if (!gContentListHashTable.ops)
|
|
|
|
return;
|
|
|
|
|
|
|
|
PL_DHashTableOperate(&gContentListHashTable,
|
|
|
|
GetKey(),
|
|
|
|
PL_DHASH_REMOVE);
|
|
|
|
|
|
|
|
if (gContentListHashTable.entryCount == 0) {
|
|
|
|
PL_DHashTableFinish(&gContentListHashTable);
|
|
|
|
gContentListHashTable.ops = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-06-28 01:30:09 +00:00
|
|
|
void
|
|
|
|
nsContentList::BringSelfUpToDate(PRBool aDoFlush)
|
|
|
|
{
|
|
|
|
if (mDocument && aDoFlush) {
|
|
|
|
mDocument->FlushPendingNotifications(PR_FALSE); // Flush pending content changes Bug 4891
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mState != LIST_UP_TO_DATE)
|
|
|
|
PopulateSelf(PRUint32(-1));
|
|
|
|
|
|
|
|
NS_ASSERTION(!mDocument || mState == LIST_UP_TO_DATE,
|
|
|
|
"PopulateSelf dod not bring content list up to date!");
|
|
|
|
}
|