2001-09-25 01:32:19 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-17 21:52:36 +00:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2000-05-09 21:42:57 +00:00
|
|
|
*
|
2004-04-17 21:52:36 +00:00
|
|
|
* The contents of this file are subject to the Mozilla 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/MPL/
|
2000-05-09 21:42:57 +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.
|
2000-05-09 21:42:57 +00:00
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code.
|
|
|
|
*
|
2004-04-17 21:52:36 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-25 01:32:19 +00:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
2000-05-09 21:42:57 +00:00
|
|
|
*
|
2001-09-25 01:32:19 +00:00
|
|
|
* Contributor(s):
|
2004-04-17 21:52:36 +00:00
|
|
|
* Original Author: David W. Hyatt (hyatt@netscape.com)
|
|
|
|
* Alec Flett <alecf@netscape.com>
|
2001-09-25 01:32:19 +00:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-17 21:52:36 +00:00
|
|
|
* either of 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"),
|
2001-09-25 01:32:19 +00:00
|
|
|
* 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
|
2004-04-17 21:52:36 +00:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-25 01:32:19 +00:00
|
|
|
* 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
|
2004-04-17 21:52:36 +00:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-25 01:32:19 +00:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2000-05-09 21:42:57 +00:00
|
|
|
|
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsIXBLService.h"
|
|
|
|
#include "nsIInputStream.h"
|
2002-12-02 22:30:26 +00:00
|
|
|
#include "nsDoubleHashtable.h"
|
2000-05-09 21:42:57 +00:00
|
|
|
#include "nsIURI.h"
|
|
|
|
#include "nsIURL.h"
|
|
|
|
#include "nsIChannel.h"
|
|
|
|
#include "nsXPIDLString.h"
|
|
|
|
#include "nsIParser.h"
|
|
|
|
#include "nsParserCIID.h"
|
|
|
|
#include "nsNetUtil.h"
|
|
|
|
#include "plstr.h"
|
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
|
|
#include "nsIDocument.h"
|
2004-09-01 16:50:12 +00:00
|
|
|
#include "nsContentUtils.h"
|
2000-10-09 03:08:41 +00:00
|
|
|
#include "nsIPresShell.h"
|
2000-05-09 21:42:57 +00:00
|
|
|
#include "nsIXMLContentSink.h"
|
2001-02-19 12:55:42 +00:00
|
|
|
#include "nsContentCID.h"
|
2000-05-09 21:42:57 +00:00
|
|
|
#include "nsXMLDocument.h"
|
2000-08-06 05:03:36 +00:00
|
|
|
#include "nsIStreamListener.h"
|
2006-05-19 10:01:22 +00:00
|
|
|
#include "nsGenericDOMNodeList.h"
|
2000-05-09 21:42:57 +00:00
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
#include "nsXBLBinding.h"
|
|
|
|
#include "nsXBLPrototypeBinding.h"
|
2000-08-12 06:28:02 +00:00
|
|
|
#include "nsIXBLDocumentInfo.h"
|
2003-04-15 20:35:07 +00:00
|
|
|
#include "nsXBLInsertionPoint.h"
|
2000-08-12 06:28:02 +00:00
|
|
|
|
|
|
|
#include "nsIStyleSheet.h"
|
2004-04-12 21:56:09 +00:00
|
|
|
#include "nsHTMLStyleSheet.h"
|
2000-08-12 06:28:02 +00:00
|
|
|
#include "nsIHTMLCSSStyleSheet.h"
|
|
|
|
|
|
|
|
#include "nsIStyleRuleProcessor.h"
|
2000-09-27 20:23:49 +00:00
|
|
|
#include "nsIWeakReference.h"
|
2000-05-09 21:42:57 +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 "jsapi.h"
|
2000-12-07 10:11:21 +00:00
|
|
|
#include "nsIXPConnect.h"
|
2001-09-05 07:36:55 +00:00
|
|
|
#include "nsDOMCID.h"
|
|
|
|
#include "nsIDOMScriptObjectFactory.h"
|
|
|
|
#include "nsIScriptGlobalObject.h"
|
|
|
|
|
2001-07-16 02:40:48 +00:00
|
|
|
#include "nsIScriptContext.h"
|
2005-02-19 10:31:27 +00:00
|
|
|
#include "nsBindingManager.h"
|
2000-12-07 10:11:21 +00:00
|
|
|
|
2007-03-09 23:43:50 +00:00
|
|
|
#include "nsThreadUtils.h"
|
|
|
|
|
2001-02-02 00:54:47 +00:00
|
|
|
// ==================================================================
|
|
|
|
// = nsAnonymousContentList
|
|
|
|
// ==================================================================
|
|
|
|
|
2007-05-24 14:10:02 +00:00
|
|
|
class nsAnonymousContentList : public nsIDOMNodeList
|
2001-02-07 07:45:36 +00:00
|
|
|
{
|
|
|
|
public:
|
2006-09-18 21:35:21 +00:00
|
|
|
nsAnonymousContentList(nsInsertionPointList* aElements);
|
2001-02-02 00:54:47 +00:00
|
|
|
virtual ~nsAnonymousContentList();
|
|
|
|
|
2007-05-24 14:10:02 +00:00
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
|
|
NS_DECL_CYCLE_COLLECTION_CLASS(nsAnonymousContentList)
|
2001-02-02 00:54:47 +00:00
|
|
|
// nsIDOMNodeList interface
|
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_DECL_NSIDOMNODELIST
|
2001-02-07 07:45:36 +00:00
|
|
|
|
2006-09-18 21:35:21 +00:00
|
|
|
PRInt32 GetInsertionPointCount() { return mElements->Length(); }
|
2003-04-15 20:35:07 +00:00
|
|
|
|
|
|
|
nsXBLInsertionPoint* GetInsertionPointAt(PRInt32 i) { return NS_STATIC_CAST(nsXBLInsertionPoint*, mElements->ElementAt(i)); }
|
2006-09-18 21:35:21 +00:00
|
|
|
void RemoveInsertionPointAt(PRInt32 i) { mElements->RemoveElementAt(i); }
|
2003-04-15 20:35:07 +00:00
|
|
|
|
2001-02-02 00:54:47 +00:00
|
|
|
private:
|
2006-09-18 21:35:21 +00:00
|
|
|
nsInsertionPointList* mElements;
|
2001-02-02 00:54:47 +00:00
|
|
|
};
|
|
|
|
|
2006-09-18 21:35:21 +00:00
|
|
|
nsAnonymousContentList::nsAnonymousContentList(nsInsertionPointList* aElements)
|
2003-04-15 20:35:07 +00:00
|
|
|
: mElements(aElements)
|
2001-02-02 00:54:47 +00:00
|
|
|
{
|
|
|
|
MOZ_COUNT_CTOR(nsAnonymousContentList);
|
|
|
|
|
|
|
|
// We don't reference count our Anonymous reference (to avoid circular
|
|
|
|
// references). We'll be told when the Anonymous goes away.
|
|
|
|
}
|
2003-04-15 20:35:07 +00:00
|
|
|
|
2001-02-02 00:54:47 +00:00
|
|
|
nsAnonymousContentList::~nsAnonymousContentList()
|
|
|
|
{
|
|
|
|
MOZ_COUNT_DTOR(nsAnonymousContentList);
|
2003-04-15 20:35:07 +00:00
|
|
|
delete mElements;
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2007-05-24 14:10:02 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsAnonymousContentList)
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsAnonymousContentList)
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsAnonymousContentList)
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsAnonymousContentList)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMNodeList)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
|
|
NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(NodeList)
|
|
|
|
NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsAnonymousContentList)
|
|
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_0(nsAnonymousContentList)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsAnonymousContentList)
|
|
|
|
{
|
|
|
|
PRInt32 i, count = tmp->mElements->Length();
|
|
|
|
for (i = 0; i < count; ++i) {
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_MEMBER(mElements->ElementAt(i),
|
|
|
|
nsXBLInsertionPoint);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
2001-02-02 00:54:47 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsAnonymousContentList::GetLength(PRUint32* aLength)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aLength != nsnull, "null ptr");
|
|
|
|
if (! aLength)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
2006-09-18 21:35:21 +00:00
|
|
|
PRInt32 cnt = mElements->Length();
|
2001-02-02 00:54:47 +00:00
|
|
|
|
|
|
|
*aLength = 0;
|
2003-04-15 20:35:07 +00:00
|
|
|
for (PRInt32 i = 0; i < cnt; i++)
|
|
|
|
*aLength += NS_STATIC_CAST(nsXBLInsertionPoint*, mElements->ElementAt(i))->ChildCount();
|
2001-02-02 00:54:47 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsAnonymousContentList::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
|
|
|
|
{
|
2006-09-18 21:35:21 +00:00
|
|
|
PRInt32 cnt = mElements->Length();
|
2001-02-02 00:54:47 +00:00
|
|
|
PRUint32 pointCount = 0;
|
2003-04-15 20:35:07 +00:00
|
|
|
|
|
|
|
for (PRInt32 i = 0; i < cnt; i++) {
|
2001-02-02 00:54:47 +00:00
|
|
|
aIndex -= pointCount;
|
|
|
|
|
2003-04-15 20:35:07 +00:00
|
|
|
nsXBLInsertionPoint* point = NS_STATIC_CAST(nsXBLInsertionPoint*, mElements->ElementAt(i));
|
|
|
|
pointCount = point->ChildCount();
|
2001-02-02 00:54:47 +00:00
|
|
|
|
|
|
|
if (aIndex < pointCount) {
|
2003-04-15 20:35:07 +00:00
|
|
|
nsCOMPtr<nsIContent> result = point->ChildAt(aIndex);
|
|
|
|
if (result)
|
2002-12-11 14:24:49 +00:00
|
|
|
return CallQueryInterface(result, aReturn);
|
2003-04-15 20:35:07 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2000-08-12 06:28:02 +00:00
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
//
|
|
|
|
// Generic pldhash table stuff for mapping one nsISupports to another
|
|
|
|
//
|
|
|
|
// These values are never null - a null value implies that this
|
|
|
|
// whole key should be removed (See SetOrRemoveObject)
|
|
|
|
class ObjectEntry : public PLDHashEntryHdr
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
// note that these are allocated within the PLDHashTable, but we
|
|
|
|
// want to keep track of them anyway
|
|
|
|
ObjectEntry() { MOZ_COUNT_CTOR(ObjectEntry); }
|
|
|
|
~ObjectEntry() { MOZ_COUNT_DTOR(ObjectEntry); }
|
|
|
|
|
|
|
|
nsISupports* GetValue() { return mValue; }
|
|
|
|
nsISupports* GetKey() { return mKey; }
|
|
|
|
void SetValue(nsISupports* aValue) { mValue = aValue; }
|
|
|
|
void SetKey(nsISupports* aKey) { mKey = aKey; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsCOMPtr<nsISupports> mKey;
|
|
|
|
nsCOMPtr<nsISupports> mValue;
|
|
|
|
};
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(void)
|
|
|
|
ClearObjectEntry(PLDHashTable* table, PLDHashEntryHdr *entry)
|
|
|
|
{
|
|
|
|
ObjectEntry* objEntry = NS_STATIC_CAST(ObjectEntry*, entry);
|
|
|
|
objEntry->~ObjectEntry();
|
|
|
|
}
|
|
|
|
|
2003-08-05 20:09:21 +00:00
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
2002-12-02 22:30:26 +00:00
|
|
|
InitObjectEntry(PLDHashTable* table, PLDHashEntryHdr* entry, const void* key)
|
|
|
|
{
|
|
|
|
new (entry) ObjectEntry;
|
2003-08-05 20:09:21 +00:00
|
|
|
return PR_TRUE;
|
2002-12-02 22:30:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static PLDHashTableOps ObjectTableOps = {
|
|
|
|
PL_DHashAllocTable,
|
|
|
|
PL_DHashFreeTable,
|
|
|
|
PL_DHashVoidPtrKeyStub,
|
|
|
|
PL_DHashMatchEntryStub,
|
|
|
|
PL_DHashMoveEntryStub,
|
|
|
|
ClearObjectEntry,
|
|
|
|
PL_DHashFinalizeStub,
|
|
|
|
InitObjectEntry
|
|
|
|
};
|
|
|
|
|
|
|
|
// helper routine for adding a new entry
|
|
|
|
static nsresult
|
|
|
|
AddObjectEntry(PLDHashTable& table, nsISupports* aKey, nsISupports* aValue)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aKey, "key must be non-null");
|
|
|
|
if (!aKey) return NS_ERROR_INVALID_ARG;
|
|
|
|
|
|
|
|
ObjectEntry *entry =
|
|
|
|
NS_STATIC_CAST(ObjectEntry*,
|
|
|
|
PL_DHashTableOperate(&table, aKey, PL_DHASH_ADD));
|
|
|
|
|
|
|
|
if (!entry)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
// only add the key if the entry is new
|
|
|
|
if (!entry->GetKey())
|
|
|
|
entry->SetKey(aKey);
|
|
|
|
|
|
|
|
// now attach the new entry - note that entry->mValue could possibly
|
|
|
|
// have a value already, this will release that.
|
|
|
|
entry->SetValue(aValue);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// helper routine for looking up an existing entry. Note that the
|
|
|
|
// return result is NOT addreffed
|
|
|
|
static nsISupports*
|
|
|
|
LookupObject(PLDHashTable& table, nsISupports* aKey)
|
|
|
|
{
|
|
|
|
ObjectEntry *entry =
|
|
|
|
NS_STATIC_CAST(ObjectEntry*,
|
|
|
|
PL_DHashTableOperate(&table, aKey, PL_DHASH_LOOKUP));
|
|
|
|
|
|
|
|
if (PL_DHASH_ENTRY_IS_BUSY(entry))
|
|
|
|
return entry->GetValue();
|
|
|
|
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
RemoveObjectEntry(PLDHashTable& table, nsISupports* aKey)
|
|
|
|
{
|
|
|
|
PL_DHashTableOperate(&table, aKey, PL_DHASH_REMOVE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static nsresult
|
2007-05-11 18:34:12 +00:00
|
|
|
SetOrRemoveObject(PLDHashTable& table, nsIContent* aKey, nsISupports* aValue)
|
2002-12-02 22:30:26 +00:00
|
|
|
{
|
2003-07-14 21:26:24 +00:00
|
|
|
if (aValue) {
|
|
|
|
// lazily create the table, but only when adding elements
|
|
|
|
if (!table.ops &&
|
|
|
|
!PL_DHashTableInit(&table, &ObjectTableOps, nsnull,
|
|
|
|
sizeof(ObjectEntry), 16)) {
|
|
|
|
table.ops = nsnull;
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2007-05-11 18:34:12 +00:00
|
|
|
aKey->SetFlags(NODE_MAY_BE_IN_BINDING_MNGR);
|
2002-12-02 22:30:26 +00:00
|
|
|
return AddObjectEntry(table, aKey, aValue);
|
2003-07-14 21:26:24 +00:00
|
|
|
}
|
2002-12-02 22:30:26 +00:00
|
|
|
|
|
|
|
// no value, so remove the key from the table
|
|
|
|
if (table.ops)
|
|
|
|
RemoveObjectEntry(table, aKey);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-02-07 07:45:36 +00:00
|
|
|
|
2000-05-09 21:42:57 +00:00
|
|
|
// Implementation /////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
// Static member variable initialization
|
|
|
|
|
|
|
|
// Implement our nsISupports methods
|
2007-01-04 22:31:26 +00:00
|
|
|
|
2007-02-18 14:38:04 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsBindingManager)
|
2007-01-09 01:44:16 +00:00
|
|
|
if (tmp->mBindingTable.IsInitialized())
|
|
|
|
tmp->mBindingTable.Clear();
|
|
|
|
|
|
|
|
if (tmp->mDocumentTable.IsInitialized())
|
|
|
|
tmp->mDocumentTable.Clear();
|
|
|
|
|
|
|
|
if (tmp->mLoadingDocTable.IsInitialized())
|
|
|
|
tmp->mLoadingDocTable.Clear();
|
2007-01-04 22:31:26 +00:00
|
|
|
|
|
|
|
if (tmp->mContentListTable.ops)
|
|
|
|
PL_DHashTableFinish(&(tmp->mContentListTable));
|
|
|
|
tmp->mContentListTable.ops = nsnull;
|
|
|
|
|
|
|
|
if (tmp->mAnonymousNodesTable.ops)
|
|
|
|
PL_DHashTableFinish(&(tmp->mAnonymousNodesTable));
|
|
|
|
tmp->mAnonymousNodesTable.ops = nsnull;
|
|
|
|
|
|
|
|
if (tmp->mInsertionParentTable.ops)
|
|
|
|
PL_DHashTableFinish(&(tmp->mInsertionParentTable));
|
|
|
|
tmp->mInsertionParentTable.ops = nsnull;
|
|
|
|
|
|
|
|
if (tmp->mWrapperTable.ops)
|
|
|
|
PL_DHashTableFinish(&(tmp->mWrapperTable));
|
|
|
|
tmp->mWrapperTable.ops = nsnull;
|
|
|
|
|
2007-05-24 14:10:02 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSTARRAY(mAttachedStack)
|
2007-01-04 22:31:26 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
|
|
|
|
|
|
|
|
static PLDHashOperator
|
|
|
|
DocumentInfoHashtableTraverser(nsIURI* key,
|
|
|
|
nsIXBLDocumentInfo* di,
|
|
|
|
void* userArg)
|
|
|
|
{
|
|
|
|
nsCycleCollectionTraversalCallback *cb =
|
|
|
|
NS_STATIC_CAST(nsCycleCollectionTraversalCallback*, userArg);
|
|
|
|
cb->NoteXPCOMChild(di);
|
|
|
|
return PL_DHASH_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PLDHashOperator
|
|
|
|
LoadingDocHashtableTraverser(nsIURI* key,
|
|
|
|
nsIStreamListener* sl,
|
|
|
|
void* userArg)
|
|
|
|
{
|
|
|
|
nsCycleCollectionTraversalCallback *cb =
|
|
|
|
NS_STATIC_CAST(nsCycleCollectionTraversalCallback*, userArg);
|
|
|
|
cb->NoteXPCOMChild(sl);
|
|
|
|
return PL_DHASH_NEXT;
|
|
|
|
}
|
|
|
|
|
2007-02-18 14:38:04 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsBindingManager)
|
2007-03-08 11:17:16 +00:00
|
|
|
// The hashes keyed on nsIContent are traversed from the nsIContent itself.
|
2007-01-04 22:31:26 +00:00
|
|
|
if (tmp->mDocumentTable.IsInitialized())
|
|
|
|
tmp->mDocumentTable.EnumerateRead(&DocumentInfoHashtableTraverser, &cb);
|
|
|
|
if (tmp->mLoadingDocTable.IsInitialized())
|
|
|
|
tmp->mLoadingDocTable.EnumerateRead(&LoadingDocHashtableTraverser, &cb);
|
2007-05-24 14:10:02 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSTARRAY_MEMBER(mAttachedStack,
|
|
|
|
nsXBLBinding)
|
2007-03-09 23:43:50 +00:00
|
|
|
// No need to traverse mProcessAttachedQueueEvent, since it'll just
|
|
|
|
// fire at some point.
|
2007-01-04 22:31:26 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsBindingManager)
|
|
|
|
|
2007-04-25 16:35:27 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsBindingManager)
|
2007-01-04 22:31:26 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
|
2007-02-16 23:02:08 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
2007-01-04 22:31:26 +00:00
|
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsBindingManager)
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsBindingManager)
|
2000-05-09 21:42:57 +00:00
|
|
|
|
|
|
|
// Constructors/Destructors
|
|
|
|
nsBindingManager::nsBindingManager(void)
|
2007-05-31 01:36:06 +00:00
|
|
|
: mProcessingAttachedStack(PR_FALSE),
|
|
|
|
mProcessOnEndUpdate(PR_FALSE)
|
2000-05-09 21:42:57 +00:00
|
|
|
{
|
2002-12-02 22:30:26 +00:00
|
|
|
mContentListTable.ops = nsnull;
|
|
|
|
mAnonymousNodesTable.ops = nsnull;
|
|
|
|
mInsertionParentTable.ops = nsnull;
|
|
|
|
mWrapperTable.ops = nsnull;
|
2000-05-09 21:42:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsBindingManager::~nsBindingManager(void)
|
|
|
|
{
|
2002-12-02 22:30:26 +00:00
|
|
|
if (mContentListTable.ops)
|
|
|
|
PL_DHashTableFinish(&mContentListTable);
|
|
|
|
if (mAnonymousNodesTable.ops)
|
|
|
|
PL_DHashTableFinish(&mAnonymousNodesTable);
|
|
|
|
if (mInsertionParentTable.ops)
|
|
|
|
PL_DHashTableFinish(&mInsertionParentTable);
|
|
|
|
if (mWrapperTable.ops)
|
|
|
|
PL_DHashTableFinish(&mWrapperTable);
|
2000-05-09 21:42:57 +00:00
|
|
|
}
|
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
nsXBLBinding*
|
|
|
|
nsBindingManager::GetBinding(nsIContent* aContent)
|
2002-12-02 22:30:26 +00:00
|
|
|
{
|
2007-05-11 18:34:12 +00:00
|
|
|
if (aContent && aContent->HasFlag(NODE_MAY_BE_IN_BINDING_MNGR) &&
|
|
|
|
mBindingTable.IsInitialized()) {
|
2005-02-25 22:07:01 +00:00
|
|
|
return mBindingTable.GetWeak(aContent);
|
2007-05-11 18:34:12 +00:00
|
|
|
}
|
2005-02-25 22:07:01 +00:00
|
|
|
|
|
|
|
return nsnull;
|
2000-05-09 21:42:57 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2005-02-25 22:07:01 +00:00
|
|
|
nsBindingManager::SetBinding(nsIContent* aContent, nsXBLBinding* aBinding)
|
2000-05-09 21:42:57 +00:00
|
|
|
{
|
2005-02-25 22:07:01 +00:00
|
|
|
if (!mBindingTable.IsInitialized()) {
|
|
|
|
if (!mBindingTable.Init())
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
2005-11-22 15:48:10 +00:00
|
|
|
// After this point, aBinding will be the most-derived binding for aContent.
|
|
|
|
// If we already have a binding for aContent in our table, make sure to
|
|
|
|
// remove it from the attached stack. Otherwise we might end up firing its
|
|
|
|
// constructor twice (if aBinding inherits from it) or firing its constructor
|
|
|
|
// after aContent has been deleted (if aBinding is null and the content node
|
|
|
|
// dies before we process mAttachedStack).
|
|
|
|
nsXBLBinding* oldBinding = mBindingTable.GetWeak(aContent);
|
2006-12-14 21:32:10 +00:00
|
|
|
if (oldBinding) {
|
|
|
|
mAttachedStack.RemoveElement(oldBinding);
|
2005-11-22 15:48:10 +00:00
|
|
|
}
|
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
PRBool result = PR_TRUE;
|
|
|
|
|
|
|
|
if (aBinding) {
|
2007-05-11 18:34:12 +00:00
|
|
|
aContent->SetFlags(NODE_MAY_BE_IN_BINDING_MNGR);
|
2005-02-25 22:07:01 +00:00
|
|
|
result = mBindingTable.Put(aContent, aBinding);
|
|
|
|
} else {
|
|
|
|
mBindingTable.Remove(aContent);
|
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
// The death of the bindings means the death of the JS wrapper,
|
|
|
|
// and the flushing of our explicit and anonymous insertion point
|
|
|
|
// lists.
|
2000-12-07 10:11:21 +00:00
|
|
|
SetWrappedJS(aContent, nsnull);
|
2001-02-08 23:24:55 +00:00
|
|
|
SetContentListFor(aContent, nsnull);
|
|
|
|
SetAnonymousNodesFor(aContent, nsnull);
|
2000-12-07 10:11:21 +00:00
|
|
|
}
|
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
return result ? NS_OK : NS_ERROR_FAILURE;
|
2000-12-07 10:11:21 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIContent*
|
|
|
|
nsBindingManager::GetInsertionParent(nsIContent* aContent)
|
2001-02-02 00:54:47 +00:00
|
|
|
{
|
2002-12-02 22:30:26 +00:00
|
|
|
if (mInsertionParentTable.ops) {
|
2007-02-27 00:14:01 +00:00
|
|
|
return NS_STATIC_CAST(nsIContent*,
|
|
|
|
LookupObject(mInsertionParentTable, aContent));
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
return nsnull;
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2001-02-02 00:54:47 +00:00
|
|
|
nsBindingManager::SetInsertionParent(nsIContent* aContent, nsIContent* aParent)
|
|
|
|
{
|
2002-12-02 22:30:26 +00:00
|
|
|
return SetOrRemoveObject(mInsertionParentTable, aContent, aParent);
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIXPConnectWrappedJS*
|
|
|
|
nsBindingManager::GetWrappedJS(nsIContent* aContent)
|
2000-12-07 10:11:21 +00:00
|
|
|
{
|
2002-12-02 22:30:26 +00:00
|
|
|
if (mWrapperTable.ops) {
|
2007-02-27 00:14:01 +00:00
|
|
|
return NS_STATIC_CAST(nsIXPConnectWrappedJS*, LookupObject(mWrapperTable, aContent));
|
2000-12-07 10:11:21 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
return nsnull;
|
2000-12-07 10:11:21 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2000-12-07 10:11:21 +00:00
|
|
|
nsBindingManager::SetWrappedJS(nsIContent* aContent, nsIXPConnectWrappedJS* aWrappedJS)
|
|
|
|
{
|
2002-12-02 22:30:26 +00:00
|
|
|
return SetOrRemoveObject(mWrapperTable, aContent, aWrappedJS);
|
2000-05-09 21:42:57 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2000-09-20 00:14:04 +00:00
|
|
|
nsBindingManager::ChangeDocumentFor(nsIContent* aContent, nsIDocument* aOldDocument,
|
|
|
|
nsIDocument* aNewDocument)
|
|
|
|
{
|
2005-04-05 23:54:35 +00:00
|
|
|
// XXXbz this code is pretty broken, since moving from one document
|
|
|
|
// to another always passes through a null document!
|
2000-10-09 03:08:41 +00:00
|
|
|
NS_PRECONDITION(aOldDocument != nsnull, "no old document");
|
2005-04-05 23:54:35 +00:00
|
|
|
NS_PRECONDITION(!aNewDocument,
|
|
|
|
"Changing to a non-null new document not supported yet");
|
2000-10-09 03:08:41 +00:00
|
|
|
if (! aOldDocument)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
2005-06-14 12:30:17 +00:00
|
|
|
// Hold a ref to the binding so it won't die when we remove it from our
|
|
|
|
// table.
|
2007-02-27 00:14:01 +00:00
|
|
|
nsRefPtr<nsXBLBinding> binding = GetBinding(aContent);
|
2000-09-20 00:14:04 +00:00
|
|
|
if (binding) {
|
|
|
|
binding->ChangeDocument(aOldDocument, aNewDocument);
|
|
|
|
SetBinding(aContent, nsnull);
|
2003-10-22 06:09:48 +00:00
|
|
|
if (aNewDocument)
|
2005-02-19 10:31:27 +00:00
|
|
|
aNewDocument->BindingManager()->SetBinding(aContent, binding);
|
2000-09-20 00:14:04 +00:00
|
|
|
}
|
|
|
|
|
2001-02-02 00:54:47 +00:00
|
|
|
// Clear out insertion parents and content lists.
|
|
|
|
SetInsertionParent(aContent, nsnull);
|
|
|
|
SetContentListFor(aContent, nsnull);
|
|
|
|
SetAnonymousNodesFor(aContent, nsnull);
|
|
|
|
|
2000-09-20 00:14:04 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIAtom*
|
|
|
|
nsBindingManager::ResolveTag(nsIContent* aContent, PRInt32* aNameSpaceID)
|
2000-05-09 21:42:57 +00:00
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aContent);
|
2000-05-09 21:42:57 +00:00
|
|
|
|
|
|
|
if (binding) {
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIAtom* base = binding->GetBaseTag(aNameSpaceID);
|
2003-11-19 01:20:56 +00:00
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
if (base) {
|
|
|
|
return base;
|
2000-05-09 21:42:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-13 04:14:28 +00:00
|
|
|
*aNameSpaceID = aContent->GetNameSpaceID();
|
2007-02-27 00:14:01 +00:00
|
|
|
return aContent->Tag();
|
2000-05-09 21:42:57 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2001-02-02 00:54:47 +00:00
|
|
|
nsBindingManager::GetContentListFor(nsIContent* aContent, nsIDOMNodeList** aResult)
|
|
|
|
{
|
|
|
|
// Locate the primary binding and get its node list of anonymous children.
|
|
|
|
*aResult = nsnull;
|
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
if (mContentListTable.ops) {
|
|
|
|
*aResult = NS_STATIC_CAST(nsIDOMNodeList*,
|
|
|
|
LookupObject(mContentListTable, aContent));
|
|
|
|
NS_IF_ADDREF(*aResult);
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!*aResult) {
|
|
|
|
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aContent));
|
2007-02-27 00:14:01 +00:00
|
|
|
node->GetChildNodes(aResult);
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2006-09-18 21:35:21 +00:00
|
|
|
nsBindingManager::SetContentListFor(nsIContent* aContent,
|
|
|
|
nsInsertionPointList* aList)
|
2002-12-02 22:30:26 +00:00
|
|
|
{
|
|
|
|
nsIDOMNodeList* contentList = nsnull;
|
2001-02-02 00:54:47 +00:00
|
|
|
if (aList) {
|
2002-12-02 22:30:26 +00:00
|
|
|
contentList = new nsAnonymousContentList(aList);
|
2006-08-24 07:43:44 +00:00
|
|
|
if (!contentList) {
|
|
|
|
delete aList;
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
return SetOrRemoveObject(mContentListTable, aContent, contentList);
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
PRBool
|
|
|
|
nsBindingManager::HasContentListFor(nsIContent* aContent)
|
2001-08-03 07:34:28 +00:00
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
return mContentListTable.ops && LookupObject(mContentListTable, aContent);
|
2001-08-03 07:34:28 +00:00
|
|
|
}
|
|
|
|
|
2003-04-15 20:35:07 +00:00
|
|
|
nsresult
|
|
|
|
nsBindingManager::GetAnonymousNodesInternal(nsIContent* aContent,
|
|
|
|
nsIDOMNodeList** aResult,
|
|
|
|
PRBool* aIsAnonymousContentList)
|
2001-02-02 00:54:47 +00:00
|
|
|
{
|
|
|
|
// Locate the primary binding and get its node list of anonymous children.
|
|
|
|
*aResult = nsnull;
|
2002-12-02 22:30:26 +00:00
|
|
|
if (mAnonymousNodesTable.ops) {
|
|
|
|
*aResult = NS_STATIC_CAST(nsIDOMNodeList*,
|
|
|
|
LookupObject(mAnonymousNodesTable, aContent));
|
|
|
|
NS_IF_ADDREF(*aResult);
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!*aResult) {
|
2003-04-15 20:35:07 +00:00
|
|
|
*aIsAnonymousContentList = PR_FALSE;
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aContent);
|
2005-02-25 22:07:01 +00:00
|
|
|
if (binding) {
|
|
|
|
*aResult = binding->GetAnonymousNodes().get();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2003-04-15 20:35:07 +00:00
|
|
|
} else
|
|
|
|
*aIsAnonymousContentList = PR_TRUE;
|
2001-02-02 00:54:47 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2003-04-15 20:35:07 +00:00
|
|
|
nsBindingManager::GetAnonymousNodesFor(nsIContent* aContent,
|
|
|
|
nsIDOMNodeList** aResult)
|
|
|
|
{
|
|
|
|
PRBool dummy;
|
|
|
|
return GetAnonymousNodesInternal(aContent, aResult, &dummy);
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2006-09-18 21:35:21 +00:00
|
|
|
nsBindingManager::SetAnonymousNodesFor(nsIContent* aContent,
|
|
|
|
nsInsertionPointList* aList)
|
2002-12-02 22:30:26 +00:00
|
|
|
{
|
|
|
|
nsIDOMNodeList* contentList = nsnull;
|
2001-02-02 00:54:47 +00:00
|
|
|
if (aList) {
|
2002-12-02 22:30:26 +00:00
|
|
|
contentList = new nsAnonymousContentList(aList);
|
2006-08-24 07:43:44 +00:00
|
|
|
if (!contentList) {
|
|
|
|
delete aList;
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2005-09-01 04:38:29 +00:00
|
|
|
}
|
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
return SetOrRemoveObject(mAnonymousNodesTable, aContent, contentList);
|
2001-02-02 00:54:47 +00:00
|
|
|
}
|
|
|
|
|
2003-04-15 20:35:07 +00:00
|
|
|
nsresult
|
|
|
|
nsBindingManager::GetXBLChildNodesInternal(nsIContent* aContent,
|
|
|
|
nsIDOMNodeList** aResult,
|
|
|
|
PRBool* aIsAnonymousContentList)
|
2001-02-20 01:05:34 +00:00
|
|
|
{
|
2001-02-21 03:18:45 +00:00
|
|
|
*aResult = nsnull;
|
|
|
|
|
2001-02-20 01:05:34 +00:00
|
|
|
PRUint32 length;
|
|
|
|
|
|
|
|
// Retrieve the anonymous content that we should build.
|
2007-03-08 10:22:54 +00:00
|
|
|
nsCOMPtr<nsIDOMNodeList> result;
|
|
|
|
GetAnonymousNodesInternal(aContent, getter_AddRefs(result),
|
|
|
|
aIsAnonymousContentList);
|
|
|
|
if (result) {
|
|
|
|
result->GetLength(&length);
|
2001-02-20 01:05:34 +00:00
|
|
|
if (length == 0)
|
2007-03-08 10:22:54 +00:00
|
|
|
result = nsnull;
|
2001-02-20 01:05:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// We may have an altered list of children from XBL insertion points.
|
|
|
|
// If we don't have any anonymous kids, we next check to see if we have
|
|
|
|
// insertion points.
|
2007-03-08 10:22:54 +00:00
|
|
|
if (!result) {
|
2002-12-02 22:30:26 +00:00
|
|
|
if (mContentListTable.ops) {
|
2007-03-08 10:22:54 +00:00
|
|
|
result = NS_STATIC_CAST(nsIDOMNodeList*,
|
|
|
|
LookupObject(mContentListTable, aContent));
|
2003-04-15 20:35:07 +00:00
|
|
|
*aIsAnonymousContentList = PR_TRUE;
|
2001-02-21 03:18:45 +00:00
|
|
|
}
|
|
|
|
}
|
2003-04-15 20:35:07 +00:00
|
|
|
|
2007-03-08 10:22:54 +00:00
|
|
|
result.swap(*aResult);
|
|
|
|
|
2001-02-20 01:05:34 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2003-04-15 20:35:07 +00:00
|
|
|
nsBindingManager::GetXBLChildNodesFor(nsIContent* aContent, nsIDOMNodeList** aResult)
|
|
|
|
{
|
|
|
|
PRBool dummy;
|
|
|
|
return GetXBLChildNodesInternal(aContent, aResult, &dummy);
|
|
|
|
}
|
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
nsIContent*
|
|
|
|
nsBindingManager::GetInsertionPoint(nsIContent* aParent, nsIContent* aChild,
|
|
|
|
PRUint32* aIndex)
|
2000-05-22 08:23:09 +00:00
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aParent);
|
2005-02-25 22:07:01 +00:00
|
|
|
return binding ? binding->GetInsertionPoint(aChild, aIndex) : nsnull;
|
2000-05-22 08:23:09 +00:00
|
|
|
}
|
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
nsIContent*
|
|
|
|
nsBindingManager::GetSingleInsertionPoint(nsIContent* aParent,
|
|
|
|
PRUint32* aIndex,
|
2000-05-22 08:23:09 +00:00
|
|
|
PRBool* aMultipleInsertionPoints)
|
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aParent);
|
2005-02-25 22:07:01 +00:00
|
|
|
if (binding)
|
|
|
|
return binding->GetSingleInsertionPoint(aIndex, aMultipleInsertionPoints);
|
2001-03-07 01:46:13 +00:00
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
*aMultipleInsertionPoints = PR_FALSE;
|
|
|
|
return nsnull;
|
2000-05-22 08:23:09 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2003-10-01 22:53:56 +00:00
|
|
|
nsBindingManager::AddLayeredBinding(nsIContent* aContent, nsIURI* aURL)
|
2000-06-02 08:13:29 +00:00
|
|
|
{
|
|
|
|
// First we need to load our binding.
|
|
|
|
nsresult rv;
|
2001-07-25 07:54:28 +00:00
|
|
|
nsCOMPtr<nsIXBLService> xblService =
|
|
|
|
do_GetService("@mozilla.org/xbl;1", &rv);
|
2000-06-02 08:13:29 +00:00
|
|
|
if (!xblService)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
// Load the bindings.
|
2005-02-25 22:07:01 +00:00
|
|
|
nsRefPtr<nsXBLBinding> binding;
|
2000-09-08 10:01:18 +00:00
|
|
|
PRBool dummy;
|
2005-02-25 22:07:01 +00:00
|
|
|
xblService->LoadBindings(aContent, aURL, PR_TRUE, getter_AddRefs(binding),
|
|
|
|
&dummy);
|
2000-07-28 00:35:02 +00:00
|
|
|
if (binding) {
|
|
|
|
AddToAttachedQueue(binding);
|
|
|
|
ProcessAttachedQueue();
|
|
|
|
}
|
2000-06-02 08:13:29 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2003-10-01 22:53:56 +00:00
|
|
|
nsBindingManager::RemoveLayeredBinding(nsIContent* aContent, nsIURI* aURL)
|
2000-06-02 08:13:29 +00:00
|
|
|
{
|
2005-06-01 19:27:43 +00:00
|
|
|
// Hold a ref to the binding so it won't die when we remove it from our table
|
2007-02-27 00:14:01 +00:00
|
|
|
nsRefPtr<nsXBLBinding> binding = GetBinding(aContent);
|
2000-06-02 08:13:29 +00:00
|
|
|
|
2002-10-22 05:28:36 +00:00
|
|
|
if (!binding) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-06-02 08:13:29 +00:00
|
|
|
|
2002-10-22 05:28:36 +00:00
|
|
|
// For now we can only handle removing a binding if it's the only one
|
2005-02-25 22:07:01 +00:00
|
|
|
NS_ENSURE_FALSE(binding->GetBaseBinding(), NS_ERROR_FAILURE);
|
2002-10-22 05:28:36 +00:00
|
|
|
|
|
|
|
// Make sure that the binding has the URI that is requested to be removed
|
2005-02-25 22:07:01 +00:00
|
|
|
nsIURI* bindingUri = binding->PrototypeBinding()->BindingURI();
|
2002-10-22 05:28:36 +00:00
|
|
|
|
|
|
|
PRBool equalUri;
|
2003-11-17 21:03:32 +00:00
|
|
|
nsresult rv = aURL->Equals(bindingUri, &equalUri);
|
2002-10-22 05:28:36 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!equalUri) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-06-02 08:13:29 +00:00
|
|
|
|
2002-10-22 05:28:36 +00:00
|
|
|
// Make sure it isn't a style binding
|
2005-02-25 22:07:01 +00:00
|
|
|
if (binding->IsStyleBinding()) {
|
2002-10-22 05:28:36 +00:00
|
|
|
return NS_OK;
|
2000-06-02 08:13:29 +00:00
|
|
|
}
|
2004-09-10 04:57:30 +00:00
|
|
|
|
|
|
|
// Hold strong ref in case removing the binding tries to close the
|
|
|
|
// window or something.
|
2004-10-11 16:14:27 +00:00
|
|
|
// XXXbz should that be ownerdoc? Wouldn't we need a ref to the
|
|
|
|
// currentdoc too? What's the one that should be passed to
|
|
|
|
// ChangeDocument?
|
2004-09-10 04:57:30 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = aContent->GetOwnerDoc();
|
|
|
|
NS_ASSERTION(doc, "No owner document?");
|
2002-10-22 05:28:36 +00:00
|
|
|
|
|
|
|
// Finally remove the binding...
|
|
|
|
binding->UnhookEventHandlers();
|
|
|
|
binding->ChangeDocument(doc, nsnull);
|
|
|
|
SetBinding(aContent, nsnull);
|
|
|
|
binding->MarkForDeath();
|
|
|
|
|
|
|
|
// ...and recreate it's frames. We need to do this since the frames may have
|
|
|
|
// been removed and style may have changed due to the removal of the
|
|
|
|
// anonymous children.
|
2004-10-11 16:14:27 +00:00
|
|
|
// XXXbz this should be using the current doc (if any), not the owner doc.
|
2007-05-01 22:24:20 +00:00
|
|
|
nsIPresShell *presShell = doc->GetPrimaryShell();
|
2002-10-22 05:28:36 +00:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
return presShell->RecreateFramesFor(aContent);;
|
2000-06-02 08:13:29 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2003-09-27 04:18:26 +00:00
|
|
|
nsBindingManager::LoadBindingDocument(nsIDocument* aBoundDoc,
|
2007-06-12 21:56:06 +00:00
|
|
|
nsIURI* aURL)
|
2000-08-17 08:11:11 +00:00
|
|
|
{
|
2003-11-17 21:03:32 +00:00
|
|
|
NS_PRECONDITION(aURL, "Must have a URI to load!");
|
2000-09-15 06:38:35 +00:00
|
|
|
|
2000-08-17 08:11:11 +00:00
|
|
|
// First we need to load our binding.
|
|
|
|
nsresult rv;
|
2001-07-25 07:54:28 +00:00
|
|
|
nsCOMPtr<nsIXBLService> xblService =
|
|
|
|
do_GetService("@mozilla.org/xbl;1", &rv);
|
2000-08-17 08:11:11 +00:00
|
|
|
if (!xblService)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
// Load the binding doc.
|
|
|
|
nsCOMPtr<nsIXBLDocumentInfo> info;
|
2003-11-17 21:03:32 +00:00
|
|
|
xblService->LoadBindingDocumentInfo(nsnull, aBoundDoc, aURL,
|
|
|
|
PR_TRUE, getter_AddRefs(info));
|
2000-08-17 08:11:11 +00:00
|
|
|
if (!info)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2005-02-25 22:07:01 +00:00
|
|
|
nsBindingManager::AddToAttachedQueue(nsXBLBinding* aBinding)
|
2000-07-28 00:35:02 +00:00
|
|
|
{
|
2005-02-25 22:07:01 +00:00
|
|
|
if (!mAttachedStack.AppendElement(aBinding))
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
2000-07-28 00:35:02 +00:00
|
|
|
|
2007-03-09 23:43:50 +00:00
|
|
|
// If we're in the middle of processing our queue already, don't
|
|
|
|
// bother posting the event.
|
|
|
|
if (!mProcessingAttachedStack && !mProcessAttachedQueueEvent) {
|
|
|
|
mProcessAttachedQueueEvent =
|
|
|
|
new nsRunnableMethod<nsBindingManager>(
|
|
|
|
this, &nsBindingManager::DoProcessAttachedQueue);
|
|
|
|
NS_DispatchToCurrentThread(mProcessAttachedQueueEvent);
|
|
|
|
}
|
|
|
|
|
2000-07-28 00:35:02 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-03-09 23:43:50 +00:00
|
|
|
void
|
|
|
|
nsBindingManager::DoProcessAttachedQueue()
|
|
|
|
{
|
|
|
|
ProcessAttachedQueue();
|
|
|
|
|
|
|
|
NS_ASSERTION(mAttachedStack.Length() == 0,
|
|
|
|
"Shouldn't have pending bindings!");
|
|
|
|
|
|
|
|
mProcessAttachedQueueEvent = nsnull;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
void
|
2000-07-28 00:35:02 +00:00
|
|
|
nsBindingManager::ProcessAttachedQueue()
|
|
|
|
{
|
2007-03-09 23:43:50 +00:00
|
|
|
if (mProcessingAttachedStack || mAttachedStack.Length() == 0)
|
2007-02-27 00:14:01 +00:00
|
|
|
return;
|
2000-07-28 00:35:02 +00:00
|
|
|
|
2003-09-11 02:17:11 +00:00
|
|
|
mProcessingAttachedStack = PR_TRUE;
|
2003-07-28 10:59:54 +00:00
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
PRInt32 lastItem;
|
2006-12-14 21:32:10 +00:00
|
|
|
while ((lastItem = mAttachedStack.Length() - 1) >= 0) {
|
|
|
|
nsRefPtr<nsXBLBinding> binding = mAttachedStack.ElementAt(lastItem);
|
2005-02-25 22:07:01 +00:00
|
|
|
mAttachedStack.RemoveElementAt(lastItem);
|
2000-08-24 09:21:27 +00:00
|
|
|
|
2005-02-25 22:07:01 +00:00
|
|
|
NS_ASSERTION(binding, "null item in attached stack?");
|
|
|
|
binding->ExecuteAttachedHandler();
|
2000-07-28 00:35:02 +00:00
|
|
|
}
|
|
|
|
|
2003-09-11 02:17:11 +00:00
|
|
|
mProcessingAttachedStack = PR_FALSE;
|
2007-03-09 23:43:50 +00:00
|
|
|
|
|
|
|
NS_ASSERTION(mAttachedStack.Length() == 0, "How did we get here?");
|
|
|
|
|
|
|
|
mAttachedStack.Compact();
|
2000-07-28 00:35:02 +00:00
|
|
|
}
|
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
PR_STATIC_CALLBACK(PLDHashOperator)
|
2005-02-27 17:24:53 +00:00
|
|
|
AccumulateBindingsToDetach(nsISupports *aKey, nsXBLBinding *aBinding,
|
2007-06-27 04:25:27 +00:00
|
|
|
void* aVoidArray)
|
2000-09-08 06:57:03 +00:00
|
|
|
{
|
2007-06-27 04:25:27 +00:00
|
|
|
nsVoidArray* arr = NS_STATIC_CAST(nsVoidArray*, aVoidArray);
|
|
|
|
// Hold an owning reference to this binding, just in case
|
|
|
|
if (arr->AppendElement(aBinding))
|
|
|
|
NS_ADDREF(aBinding);
|
2002-12-02 22:30:26 +00:00
|
|
|
return PL_DHASH_NEXT;
|
2000-09-08 06:57:03 +00:00
|
|
|
}
|
|
|
|
|
2007-06-27 04:25:27 +00:00
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
ExecuteDetachedHandler(void* aBinding, void* aClosure)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aBinding, "Null binding in list?");
|
|
|
|
nsXBLBinding* binding = NS_STATIC_CAST(nsXBLBinding*, aBinding);
|
|
|
|
binding->ExecuteDetachedHandler();
|
|
|
|
// Drop our ref to the binding now
|
|
|
|
NS_RELEASE(binding);
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
void
|
2000-09-08 06:57:03 +00:00
|
|
|
nsBindingManager::ExecuteDetachedHandlers()
|
|
|
|
{
|
|
|
|
// Walk our hashtable of bindings.
|
2005-02-27 17:24:53 +00:00
|
|
|
if (mBindingTable.IsInitialized()) {
|
2007-06-27 04:25:27 +00:00
|
|
|
nsVoidArray bindingsToDetach;
|
|
|
|
mBindingTable.EnumerateRead(AccumulateBindingsToDetach, &bindingsToDetach);
|
|
|
|
bindingsToDetach.EnumerateForwards(ExecuteDetachedHandler, nsnull);
|
2005-02-27 17:24:53 +00:00
|
|
|
}
|
2000-09-08 06:57:03 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2000-08-12 06:28:02 +00:00
|
|
|
nsBindingManager::PutXBLDocumentInfo(nsIXBLDocumentInfo* aDocumentInfo)
|
2000-08-05 22:33:29 +00:00
|
|
|
{
|
2003-11-17 21:03:32 +00:00
|
|
|
NS_PRECONDITION(aDocumentInfo, "Must have a non-null documentinfo!");
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(mDocumentTable.IsInitialized() || mDocumentTable.Init(16),
|
|
|
|
NS_ERROR_OUT_OF_MEMORY);
|
2002-12-02 22:30:26 +00:00
|
|
|
|
2003-11-17 21:03:32 +00:00
|
|
|
NS_ENSURE_TRUE(mDocumentTable.Put(aDocumentInfo->DocumentURI(),
|
|
|
|
aDocumentInfo),
|
|
|
|
NS_ERROR_OUT_OF_MEMORY);
|
2002-12-02 22:30:26 +00:00
|
|
|
|
2000-08-05 22:33:29 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
void
|
2001-11-02 01:53:13 +00:00
|
|
|
nsBindingManager::RemoveXBLDocumentInfo(nsIXBLDocumentInfo* aDocumentInfo)
|
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
if (mDocumentTable.IsInitialized()) {
|
|
|
|
mDocumentTable.Remove(aDocumentInfo->DocumentURI());
|
|
|
|
}
|
2001-11-02 01:53:13 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIXBLDocumentInfo*
|
|
|
|
nsBindingManager::GetXBLDocumentInfo(nsIURI* aURL)
|
2000-08-05 22:33:29 +00:00
|
|
|
{
|
2003-11-17 21:03:32 +00:00
|
|
|
if (!mDocumentTable.IsInitialized())
|
2007-02-27 00:14:01 +00:00
|
|
|
return nsnull;
|
2000-08-05 22:33:29 +00:00
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
return mDocumentTable.GetWeak(aURL);
|
2000-08-05 22:33:29 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2003-11-17 21:03:32 +00:00
|
|
|
nsBindingManager::PutLoadingDocListener(nsIURI* aURL, nsIStreamListener* aListener)
|
2000-08-06 04:57:55 +00:00
|
|
|
{
|
2003-11-17 21:03:32 +00:00
|
|
|
NS_PRECONDITION(aListener, "Must have a non-null listener!");
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(mLoadingDocTable.IsInitialized() || mLoadingDocTable.Init(16),
|
|
|
|
NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(mLoadingDocTable.Put(aURL, aListener),
|
|
|
|
NS_ERROR_OUT_OF_MEMORY);
|
2000-08-06 04:57:55 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIStreamListener*
|
|
|
|
nsBindingManager::GetLoadingDocListener(nsIURI* aURL)
|
2000-08-06 04:57:55 +00:00
|
|
|
{
|
2003-11-17 21:03:32 +00:00
|
|
|
if (!mLoadingDocTable.IsInitialized())
|
2007-02-27 00:14:01 +00:00
|
|
|
return nsnull;
|
2000-08-06 04:57:55 +00:00
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
return mLoadingDocTable.GetWeak(aURL);
|
2000-08-06 04:57:55 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
void
|
2003-11-17 21:03:32 +00:00
|
|
|
nsBindingManager::RemoveLoadingDocListener(nsIURI* aURL)
|
2000-08-06 04:57:55 +00:00
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
if (mLoadingDocTable.IsInitialized()) {
|
|
|
|
mLoadingDocTable.Remove(aURL);
|
|
|
|
}
|
2000-08-14 04:04:18 +00:00
|
|
|
}
|
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
PR_STATIC_CALLBACK(PLDHashOperator)
|
2005-02-25 22:07:01 +00:00
|
|
|
MarkForDeath(nsISupports *aKey, nsXBLBinding *aBinding, void* aClosure)
|
2000-08-14 04:04:18 +00:00
|
|
|
{
|
2005-02-25 22:07:01 +00:00
|
|
|
if (aBinding->MarkedForDeath())
|
2002-12-02 22:30:26 +00:00
|
|
|
return PL_DHASH_NEXT; // Already marked for death.
|
2001-12-17 22:51:39 +00:00
|
|
|
|
2003-11-17 21:03:32 +00:00
|
|
|
nsCAutoString path;
|
2005-02-25 22:07:01 +00:00
|
|
|
aBinding->PrototypeBinding()->DocURI()->GetPath(path);
|
2003-11-17 21:03:32 +00:00
|
|
|
|
|
|
|
if (!strncmp(path.get(), "/skin", 5))
|
2005-02-25 22:07:01 +00:00
|
|
|
aBinding->MarkForDeath();
|
2003-11-17 21:03:32 +00:00
|
|
|
|
2002-12-02 22:30:26 +00:00
|
|
|
return PL_DHASH_NEXT;
|
2000-08-14 04:04:18 +00:00
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
void
|
2001-12-17 22:51:39 +00:00
|
|
|
nsBindingManager::FlushSkinBindings()
|
2000-08-14 04:04:18 +00:00
|
|
|
{
|
2005-02-25 22:07:01 +00:00
|
|
|
if (mBindingTable.IsInitialized())
|
|
|
|
mBindingTable.EnumerateRead(MarkForDeath, nsnull);
|
2000-08-06 04:57:55 +00:00
|
|
|
}
|
2000-08-05 22:33:29 +00:00
|
|
|
|
2001-09-22 00:24:24 +00:00
|
|
|
// Used below to protect from recurring in QI calls through XPConnect.
|
|
|
|
struct AntiRecursionData {
|
|
|
|
nsIContent* element;
|
|
|
|
REFNSIID iid;
|
|
|
|
AntiRecursionData* next;
|
|
|
|
|
|
|
|
AntiRecursionData(nsIContent* aElement,
|
|
|
|
REFNSIID aIID,
|
|
|
|
AntiRecursionData* aNext)
|
|
|
|
: element(aElement), iid(aIID), next(aNext) {}
|
|
|
|
};
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
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
|
|
|
nsBindingManager::GetBindingImplementation(nsIContent* aContent, REFNSIID aIID,
|
|
|
|
void** aResult)
|
2000-12-07 10:11:21 +00:00
|
|
|
{
|
|
|
|
*aResult = nsnull;
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aContent);
|
2000-12-07 10:11:21 +00:00
|
|
|
if (binding) {
|
2003-05-13 23:27:33 +00:00
|
|
|
// The binding should not be asked for nsISupports
|
|
|
|
NS_ASSERTION(!aIID.Equals(NS_GET_IID(nsISupports)), "Asking a binding for nsISupports");
|
2005-02-25 22:07:01 +00:00
|
|
|
if (binding->ImplementsInterface(aIID)) {
|
2007-02-27 00:14:01 +00:00
|
|
|
nsCOMPtr<nsIXPConnectWrappedJS> wrappedJS = GetWrappedJS(aContent);
|
2000-12-07 10:11:21 +00:00
|
|
|
|
2001-09-07 01:26:00 +00:00
|
|
|
if (wrappedJS) {
|
2001-09-22 00:24:24 +00:00
|
|
|
// Protect from recurring in QI calls through XPConnect.
|
|
|
|
// This can happen when a second binding is being resolved.
|
|
|
|
// At that point a wrappedJS exists, but it doesn't yet know about
|
|
|
|
// the iid we are asking for. So, without this protection,
|
|
|
|
// AggregatedQueryInterface would end up recurring back into itself
|
|
|
|
// through this code.
|
|
|
|
//
|
|
|
|
// With this protection, when we detect the recursion we return
|
|
|
|
// NS_NOINTERFACE in the inner call. The outer call will then fall
|
|
|
|
// through (see below) and build a new chained wrappedJS for the iid.
|
|
|
|
//
|
|
|
|
// We're careful to not assume that only one direct nesting can occur
|
|
|
|
// because there is a call into JS in the middle and we can't assume
|
|
|
|
// that this code won't be reached by some more complex nesting path.
|
|
|
|
//
|
|
|
|
// NOTE: We *assume* this is single threaded, so we can use a
|
|
|
|
// static linked list to do the check.
|
|
|
|
|
|
|
|
static AntiRecursionData* list = nsnull;
|
|
|
|
|
|
|
|
for (AntiRecursionData* p = list; p; p = p->next) {
|
|
|
|
if (p->element == aContent && p->iid.Equals(aIID)) {
|
|
|
|
*aResult = nsnull;
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
AntiRecursionData item(aContent, aIID, list);
|
|
|
|
list = &item;
|
|
|
|
|
2001-09-07 01:26:00 +00:00
|
|
|
nsresult rv = wrappedJS->AggregatedQueryInterface(aIID, aResult);
|
2001-09-22 00:24:24 +00:00
|
|
|
|
|
|
|
list = item.next;
|
|
|
|
|
2001-09-07 01:26:00 +00:00
|
|
|
if (*aResult)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
// No result was found, so this must be another XBL interface.
|
|
|
|
// Fall through to create a new wrapper.
|
|
|
|
}
|
2000-12-07 10:11:21 +00:00
|
|
|
|
|
|
|
// We have never made a wrapper for this implementation.
|
|
|
|
// Create an XPC wrapper for the script object and hand it back.
|
|
|
|
|
2004-12-02 02:24:28 +00:00
|
|
|
nsIDocument* doc = aContent->GetOwnerDoc();
|
2000-12-07 10:11:21 +00:00
|
|
|
if (!doc)
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
|
2003-10-22 06:09:48 +00:00
|
|
|
nsIScriptGlobalObject *global = doc->GetScriptGlobalObject();
|
2000-12-07 10:11:21 +00:00
|
|
|
if (!global)
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
|
2004-02-09 22:48:53 +00:00
|
|
|
nsIScriptContext *context = global->GetContext();
|
2000-12-07 10:11:21 +00:00
|
|
|
if (!context)
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
|
|
|
|
JSContext* jscontext = (JSContext*)context->GetNativeContext();
|
|
|
|
if (!jscontext)
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
|
2004-09-01 16:50:12 +00:00
|
|
|
nsIXPConnect *xpConnect = nsContentUtils::XPConnect();
|
2000-12-07 10:11:21 +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
|
|
|
nsCOMPtr<nsIXPConnectWrappedNative> wrapper;
|
|
|
|
xpConnect->GetWrappedNativeOfNativeObject(jscontext,
|
2005-07-30 20:57:07 +00:00
|
|
|
global->GetGlobalJSObject(),
|
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
|
|
|
aContent,
|
|
|
|
NS_GET_IID(nsISupports),
|
|
|
|
getter_AddRefs(wrapper));
|
|
|
|
NS_ENSURE_TRUE(wrapper, NS_NOINTERFACE);
|
|
|
|
|
|
|
|
JSObject* jsobj = nsnull;
|
|
|
|
|
|
|
|
wrapper->GetJSObject(&jsobj);
|
|
|
|
NS_ENSURE_TRUE(jsobj, NS_NOINTERFACE);
|
|
|
|
|
|
|
|
nsresult rv = xpConnect->WrapJSAggregatedToNative(aContent, jscontext,
|
|
|
|
jsobj, aIID, aResult);
|
2000-12-07 10:11:21 +00:00
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
// We successfully created a wrapper. We will own this wrapper for as long as the binding remains
|
|
|
|
// alive. At the time the binding is cleared out of the bindingManager, we will remove the wrapper
|
|
|
|
// from the bindingManager as well.
|
|
|
|
nsISupports* supp = NS_STATIC_CAST(nsISupports*, *aResult);
|
|
|
|
wrappedJS = do_QueryInterface(supp);
|
|
|
|
SetWrappedJS(aContent, wrappedJS);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = nsnull;
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsresult
|
2004-09-10 04:57:30 +00:00
|
|
|
nsBindingManager::WalkRules(nsStyleSet* aStyleSet,
|
|
|
|
nsIStyleRuleProcessor::EnumFunc aFunc,
|
|
|
|
RuleProcessorData* aData,
|
|
|
|
PRBool* aCutOffInheritance)
|
2000-08-12 06:28:02 +00:00
|
|
|
{
|
2004-09-10 04:57:30 +00:00
|
|
|
*aCutOffInheritance = PR_FALSE;
|
|
|
|
|
|
|
|
if (!aData->mContent)
|
2000-08-12 06:28:02 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
2004-09-10 04:57:30 +00:00
|
|
|
// Walk the binding scope chain, starting with the binding attached to our
|
|
|
|
// content, up till we run out of scopes or we get cut off.
|
|
|
|
nsIContent *content = aData->mContent;
|
|
|
|
|
|
|
|
do {
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(content);
|
2000-08-12 06:28:02 +00:00
|
|
|
if (binding) {
|
2004-09-10 04:57:30 +00:00
|
|
|
aData->mScopedRoot = content;
|
|
|
|
binding->WalkRules(aFunc, aData);
|
|
|
|
// If we're not looking at our original content, allow the binding to cut
|
|
|
|
// off style inheritance
|
|
|
|
if (content != aData->mContent) {
|
2005-02-25 22:07:01 +00:00
|
|
|
if (!binding->InheritsStyle()) {
|
2004-09-10 04:57:30 +00:00
|
|
|
// Go no further; we're not inheriting style from anything above here
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2000-08-12 06:28:02 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 23:02:08 +00:00
|
|
|
nsIContent* parent = content->GetBindingParent();
|
2007-05-05 06:47:09 +00:00
|
|
|
if (parent == content) {
|
|
|
|
NS_ASSERTION(content->IsNativeAnonymous() ||
|
|
|
|
content->IsNodeOfType(nsINode::eXUL),
|
|
|
|
"Unexpected binding parent");
|
|
|
|
|
|
|
|
break; // The anonymous content case is often deliberately hacked to
|
|
|
|
// return itself to cut off style inheritance here. Do that.
|
|
|
|
}
|
2000-08-12 06:28:02 +00:00
|
|
|
|
2004-09-10 04:57:30 +00:00
|
|
|
content = parent;
|
|
|
|
} while (content);
|
2001-11-10 23:51:45 +00:00
|
|
|
|
2004-09-10 04:57:30 +00:00
|
|
|
// If "content" is non-null that means we cut off inheritance at some point
|
|
|
|
// in the loop.
|
|
|
|
*aCutOffInheritance = (content != nsnull);
|
2000-08-12 06:28:02 +00:00
|
|
|
|
2004-09-10 04:57:30 +00:00
|
|
|
// Null out the scoped root that we set repeatedly
|
2001-11-10 23:51:45 +00:00
|
|
|
aData->mScopedRoot = nsnull;
|
2000-08-25 00:19:38 +00:00
|
|
|
|
2000-08-12 06:28:02 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
PRBool
|
|
|
|
nsBindingManager::ShouldBuildChildFrames(nsIContent* aContent)
|
2000-12-07 10:11:21 +00:00
|
|
|
{
|
2007-02-27 00:14:01 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aContent);
|
2000-12-07 10:11:21 +00:00
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
return !binding || binding->ShouldBuildChildFrames();
|
2000-12-07 10:11:21 +00:00
|
|
|
}
|
2000-08-12 06:28:02 +00:00
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIContent*
|
|
|
|
nsBindingManager::GetNestedInsertionPoint(nsIContent* aParent, nsIContent* aChild)
|
2001-02-07 07:45:36 +00:00
|
|
|
{
|
|
|
|
// Check to see if the content is anonymous.
|
2003-07-28 21:17:26 +00:00
|
|
|
if (aChild->GetBindingParent() == aParent)
|
2007-02-27 00:14:01 +00:00
|
|
|
return nsnull; // It is anonymous. Don't use the insertion point, since that's only
|
|
|
|
// for the explicit kids.
|
2001-02-07 07:45:36 +00:00
|
|
|
|
|
|
|
PRUint32 index;
|
2005-02-25 22:07:01 +00:00
|
|
|
nsIContent *insertionElement = GetInsertionPoint(aParent, aChild, &index);
|
2001-02-08 23:24:55 +00:00
|
|
|
if (insertionElement != aParent) {
|
2001-02-07 07:45:36 +00:00
|
|
|
// See if we nest even further in.
|
2007-02-27 00:14:01 +00:00
|
|
|
nsIContent* nestedPoint = GetNestedInsertionPoint(insertionElement, aChild);
|
2001-02-07 07:45:36 +00:00
|
|
|
if (nestedPoint)
|
|
|
|
insertionElement = nestedPoint;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
return insertionElement;
|
2001-02-07 07:45:36 +00:00
|
|
|
}
|
|
|
|
|
2006-08-15 22:41:58 +00:00
|
|
|
// Note: We don't hold a reference to the document observer; we assume
|
|
|
|
// that it has a live reference to the document.
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2006-08-31 03:17:45 +00:00
|
|
|
nsBindingManager::AddObserver(nsIMutationObserver* aObserver)
|
2001-02-07 07:45:36 +00:00
|
|
|
{
|
2006-08-15 22:41:58 +00:00
|
|
|
// The array makes sure the observer isn't already in the list
|
|
|
|
mObservers.AppendObserver(aObserver);
|
|
|
|
}
|
2001-02-07 07:45:36 +00:00
|
|
|
|
2006-08-15 22:41:58 +00:00
|
|
|
PRBool
|
2006-08-31 03:17:45 +00:00
|
|
|
nsBindingManager::RemoveObserver(nsIMutationObserver* aObserver)
|
2006-08-15 22:41:58 +00:00
|
|
|
{
|
|
|
|
return mObservers.RemoveObserver(aObserver);
|
|
|
|
}
|
2003-09-27 04:18:26 +00:00
|
|
|
|
2006-08-15 22:41:58 +00:00
|
|
|
void
|
|
|
|
nsBindingManager::CharacterDataChanged(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContent,
|
2006-11-03 21:51:01 +00:00
|
|
|
CharacterDataChangeInfo* aInfo)
|
2006-08-15 22:41:58 +00:00
|
|
|
{
|
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(CharacterDataChanged,
|
2006-11-03 21:51:01 +00:00
|
|
|
(aDocument, aContent, aInfo));
|
2006-08-15 22:41:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsBindingManager::AttributeChanged(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContent,
|
|
|
|
PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
|
|
|
PRInt32 aModType)
|
|
|
|
{
|
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(AttributeChanged,
|
|
|
|
(aDocument, aContent, aNameSpaceID,
|
|
|
|
aAttribute, aModType));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsBindingManager::ContentAppended(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
PRInt32 aNewIndexInContainer)
|
|
|
|
{
|
|
|
|
// XXX This is hacked and not quite correct. See below.
|
2007-04-27 04:06:45 +00:00
|
|
|
if (aNewIndexInContainer != -1 &&
|
|
|
|
(mContentListTable.ops || mAnonymousNodesTable.ops)) {
|
2006-08-15 22:41:58 +00:00
|
|
|
// It's not anonymous.
|
|
|
|
PRInt32 childCount = aContainer->GetChildCount();
|
|
|
|
|
|
|
|
nsIContent *child = aContainer->GetChildAt(aNewIndexInContainer);
|
|
|
|
|
2007-02-27 00:14:01 +00:00
|
|
|
nsCOMPtr<nsIContent> ins = GetNestedInsertionPoint(aContainer, child);
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
if (ins) {
|
|
|
|
nsCOMPtr<nsIDOMNodeList> nodeList;
|
|
|
|
PRBool isAnonymousContentList;
|
|
|
|
GetXBLChildNodesInternal(ins, getter_AddRefs(nodeList),
|
|
|
|
&isAnonymousContentList);
|
|
|
|
|
|
|
|
if (nodeList && isAnonymousContentList) {
|
|
|
|
// Find a non-pseudo-insertion point and just jam ourselves in.
|
|
|
|
// This is not 100% correct. Hack city, baby.
|
|
|
|
nsAnonymousContentList* contentList =
|
2006-11-21 21:28:14 +00:00
|
|
|
NS_STATIC_CAST(nsAnonymousContentList*, nodeList.get());
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
PRInt32 count = contentList->GetInsertionPointCount();
|
|
|
|
for (PRInt32 i = 0; i < count; i++) {
|
|
|
|
nsXBLInsertionPoint* point = contentList->GetInsertionPointAt(i);
|
|
|
|
PRInt32 index = point->GetInsertionIndex();
|
|
|
|
if (index != -1) {
|
|
|
|
// We're real. Jam all the kids in.
|
|
|
|
// XXX Check the filters to find the correct points.
|
|
|
|
for (PRInt32 j = aNewIndexInContainer; j < childCount; j++) {
|
|
|
|
child = aContainer->GetChildAt(j);
|
|
|
|
point->AddChild(child);
|
|
|
|
SetInsertionParent(child, ins);
|
|
|
|
}
|
|
|
|
break;
|
2001-02-07 07:45:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(ContentAppended,
|
|
|
|
(aDocument, aContainer,
|
|
|
|
aNewIndexInContainer));
|
2001-02-07 07:45:36 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2001-02-07 07:45:36 +00:00
|
|
|
nsBindingManager::ContentInserted(nsIDocument* aDocument,
|
2003-04-15 20:35:07 +00:00
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
2001-02-07 07:45:36 +00:00
|
|
|
{
|
2006-08-15 22:41:58 +00:00
|
|
|
// XXX This is hacked just to make menus work again.
|
2007-04-27 04:06:45 +00:00
|
|
|
if (aIndexInContainer != -1 &&
|
|
|
|
(mContentListTable.ops || mAnonymousNodesTable.ops)) {
|
2006-08-15 22:41:58 +00:00
|
|
|
// It's not anonymous.
|
2007-02-27 00:14:01 +00:00
|
|
|
nsCOMPtr<nsIContent> ins = GetNestedInsertionPoint(aContainer, aChild);
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
if (ins) {
|
|
|
|
nsCOMPtr<nsIDOMNodeList> nodeList;
|
|
|
|
PRBool isAnonymousContentList;
|
|
|
|
GetXBLChildNodesInternal(ins, getter_AddRefs(nodeList),
|
|
|
|
&isAnonymousContentList);
|
|
|
|
|
|
|
|
if (nodeList && isAnonymousContentList) {
|
|
|
|
// Find a non-pseudo-insertion point and just jam ourselves in.
|
|
|
|
// This is not 100% correct. Hack city, baby.
|
|
|
|
nsAnonymousContentList* contentList =
|
2006-11-21 21:28:14 +00:00
|
|
|
NS_STATIC_CAST(nsAnonymousContentList*, nodeList.get());
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
PRInt32 count = contentList->GetInsertionPointCount();
|
|
|
|
for (PRInt32 i = 0; i < count; i++) {
|
|
|
|
nsXBLInsertionPoint* point = contentList->GetInsertionPointAt(i);
|
|
|
|
if (point->GetInsertionIndex() != -1) {
|
|
|
|
// We're real. Jam the kid in.
|
|
|
|
// XXX Check the filters to find the correct points.
|
|
|
|
|
|
|
|
// Find the right insertion spot. Can't just insert in the insertion
|
|
|
|
// point at aIndexInContainer since the point may contain anonymous
|
|
|
|
// content, not all of aContainer's kids, etc. So find the last
|
|
|
|
// child of aContainer that comes before aIndexInContainer and is in
|
|
|
|
// the insertion point and insert right after it.
|
|
|
|
PRInt32 pointSize = point->ChildCount();
|
|
|
|
PRBool inserted = PR_FALSE;
|
|
|
|
for (PRInt32 parentIndex = aIndexInContainer - 1;
|
|
|
|
parentIndex >= 0 && !inserted; --parentIndex) {
|
|
|
|
nsIContent* currentSibling = aContainer->GetChildAt(parentIndex);
|
|
|
|
for (PRInt32 pointIndex = pointSize - 1; pointIndex >= 0;
|
|
|
|
--pointIndex) {
|
|
|
|
nsCOMPtr<nsIContent> currContent = point->ChildAt(pointIndex);
|
|
|
|
if (currContent == currentSibling) {
|
|
|
|
point->InsertChildAt(pointIndex + 1, aChild);
|
|
|
|
inserted = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
2004-03-02 22:28:48 +00:00
|
|
|
}
|
|
|
|
}
|
2006-08-15 22:41:58 +00:00
|
|
|
if (!inserted) {
|
|
|
|
// None of our previous siblings are in here... just stick
|
|
|
|
// ourselves in at the beginning of the insertion point.
|
|
|
|
// XXXbz if we ever start doing the filter thing right, this may be
|
|
|
|
// no good, since we may _still_ have anonymous kids in there and
|
|
|
|
// may need to get the ordering with those right.
|
|
|
|
point->InsertChildAt(0, aChild);
|
|
|
|
}
|
|
|
|
SetInsertionParent(aChild, ins);
|
|
|
|
break;
|
2004-03-02 22:28:48 +00:00
|
|
|
}
|
2001-02-07 07:45:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(ContentInserted,
|
|
|
|
(aDocument, aContainer, aChild,
|
|
|
|
aIndexInContainer));
|
2001-02-07 07:45:36 +00:00
|
|
|
}
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
void
|
2001-02-07 07:45:36 +00:00
|
|
|
nsBindingManager::ContentRemoved(nsIDocument* aDocument,
|
|
|
|
nsIContent* aContainer,
|
|
|
|
nsIContent* aChild,
|
|
|
|
PRInt32 aIndexInContainer)
|
|
|
|
{
|
2007-06-27 04:51:37 +00:00
|
|
|
if (aIndexInContainer != -1 &&
|
|
|
|
(mContentListTable.ops || mAnonymousNodesTable.ops)) {
|
|
|
|
// It's not anonymous
|
|
|
|
nsCOMPtr<nsIContent> point = GetNestedInsertionPoint(aContainer, aChild);
|
|
|
|
|
|
|
|
if (point) {
|
|
|
|
nsCOMPtr<nsIDOMNodeList> nodeList;
|
|
|
|
PRBool isAnonymousContentList;
|
|
|
|
GetXBLChildNodesInternal(point, getter_AddRefs(nodeList),
|
|
|
|
&isAnonymousContentList);
|
|
|
|
|
|
|
|
if (nodeList && isAnonymousContentList) {
|
|
|
|
// Find a non-pseudo-insertion point and remove ourselves.
|
|
|
|
nsAnonymousContentList* contentList = NS_STATIC_CAST(nsAnonymousContentList*, NS_STATIC_CAST(nsIDOMNodeList*, nodeList));
|
|
|
|
PRInt32 count = contentList->GetInsertionPointCount();
|
|
|
|
for (PRInt32 i =0; i < count; i++) {
|
|
|
|
nsXBLInsertionPoint* point = contentList->GetInsertionPointAt(i);
|
|
|
|
if (point->GetInsertionIndex() != -1) {
|
|
|
|
point->RemoveChild(aChild);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-15 22:41:58 +00:00
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(ContentRemoved,
|
|
|
|
(aDocument, aContainer, aChild,
|
|
|
|
aIndexInContainer));
|
|
|
|
|
2004-01-24 00:46:17 +00:00
|
|
|
|
2001-02-07 07:45:36 +00:00
|
|
|
}
|
2006-08-15 22:41:58 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
nsBindingManager::NodeWillBeDestroyed(const nsINode *aNode)
|
|
|
|
{
|
2007-03-09 23:43:50 +00:00
|
|
|
// Make sure to not run any more XBL constructors
|
|
|
|
mProcessingAttachedStack = PR_TRUE;
|
|
|
|
|
2006-08-15 22:41:58 +00:00
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(NodeWillBeDestroyed, (aNode));
|
|
|
|
}
|
2007-03-08 11:17:16 +00:00
|
|
|
|
2007-03-10 13:49:43 +00:00
|
|
|
void
|
|
|
|
nsBindingManager::ParentChainChanged(nsIContent *aContent)
|
|
|
|
{
|
|
|
|
NS_BINDINGMANAGER_NOTIFY_OBSERVERS(ParentChainChanged, (aContent));
|
|
|
|
}
|
|
|
|
|
2007-03-08 11:17:16 +00:00
|
|
|
void
|
|
|
|
nsBindingManager::Traverse(nsIContent *aContent,
|
|
|
|
nsCycleCollectionTraversalCallback &cb)
|
|
|
|
{
|
2007-05-11 18:34:12 +00:00
|
|
|
if (!aContent->HasFlag(NODE_MAY_BE_IN_BINDING_MNGR)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-03-08 11:17:16 +00:00
|
|
|
nsXBLBinding *binding = GetBinding(aContent);
|
|
|
|
if (binding) {
|
|
|
|
cb.NoteXPCOMChild(aContent);
|
2007-05-24 14:10:02 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_PTR(binding, nsXBLBinding)
|
2007-03-08 11:17:16 +00:00
|
|
|
}
|
|
|
|
nsISupports *value;
|
|
|
|
if (mContentListTable.ops &&
|
|
|
|
(value = LookupObject(mContentListTable, aContent))) {
|
|
|
|
cb.NoteXPCOMChild(aContent);
|
|
|
|
cb.NoteXPCOMChild(value);
|
|
|
|
}
|
|
|
|
if (mAnonymousNodesTable.ops &&
|
|
|
|
(value = LookupObject(mAnonymousNodesTable, aContent))) {
|
|
|
|
cb.NoteXPCOMChild(aContent);
|
|
|
|
cb.NoteXPCOMChild(value);
|
|
|
|
}
|
|
|
|
if (mInsertionParentTable.ops &&
|
|
|
|
(value = LookupObject(mInsertionParentTable, aContent))) {
|
|
|
|
cb.NoteXPCOMChild(aContent);
|
|
|
|
cb.NoteXPCOMChild(value);
|
|
|
|
}
|
|
|
|
if (mWrapperTable.ops &&
|
|
|
|
(value = LookupObject(mWrapperTable, aContent))) {
|
|
|
|
cb.NoteXPCOMChild(aContent);
|
|
|
|
cb.NoteXPCOMChild(value);
|
|
|
|
}
|
|
|
|
}
|
2007-05-31 01:36:06 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
nsBindingManager::BeginOutermostUpdate()
|
|
|
|
{
|
|
|
|
mProcessOnEndUpdate = (mAttachedStack.Length() == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsBindingManager::EndOutermostUpdate()
|
|
|
|
{
|
|
|
|
if (mProcessOnEndUpdate) {
|
|
|
|
mProcessOnEndUpdate = PR_FALSE;
|
|
|
|
ProcessAttachedQueue();
|
|
|
|
}
|
|
|
|
}
|