1999-08-04 07:39:34 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
2001-12-06 08:45:07 +03:00
|
|
|
* vim:cindent:ts=2:et:sw=2:
|
1999-08-04 07:39:34 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03: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/
|
1999-08-04 07:39:34 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03: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.
|
1999-08-04 07:39:34 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1999-08-04 07:39:34 +04:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-11-06 06:40:37 +03:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
2000-02-03 01:24:56 +03:00
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
2000-05-03 03:07:11 +04:00
|
|
|
*
|
|
|
|
* This Original Code has been modified by IBM Corporation. Modifications made by IBM
|
|
|
|
* described herein are Copyright (c) International Business Machines Corporation, 2000.
|
|
|
|
* Modifications to Mozilla code or documentation identified per MPL Section 3.3
|
|
|
|
*
|
|
|
|
* Date Modified by Description of modification
|
|
|
|
* 04/20/2000 IBM Corp. OS/2 VisualAge build.
|
1999-08-04 07:39:34 +04:00
|
|
|
*/
|
2001-08-14 11:59:59 +04:00
|
|
|
#include "nscore.h"
|
1999-08-04 07:39:34 +04:00
|
|
|
#include "nsIFrameManager.h"
|
|
|
|
#include "nsIFrame.h"
|
|
|
|
#include "nsIPresContext.h"
|
|
|
|
#include "nsIPresShell.h"
|
|
|
|
#include "nsIStyleSet.h"
|
1999-09-04 03:35:41 +04:00
|
|
|
#include "nsIStyleContext.h"
|
1999-09-21 11:53:14 +04:00
|
|
|
#include "nsStyleChangeList.h"
|
1999-08-06 00:17:44 +04:00
|
|
|
#include "nsIEventQueueService.h"
|
|
|
|
#include "nsIServiceManager.h"
|
1999-08-04 07:39:34 +04:00
|
|
|
#include "nsCOMPtr.h"
|
1999-08-06 00:17:44 +04:00
|
|
|
#include "prthread.h"
|
1999-08-04 07:39:34 +04:00
|
|
|
#include "plhash.h"
|
2001-12-06 08:45:07 +03:00
|
|
|
#include "pldhash.h"
|
1999-08-04 07:39:34 +04:00
|
|
|
#include "nsPlaceholderFrame.h"
|
|
|
|
#include "nsLayoutAtoms.h"
|
2000-05-17 02:05:47 +04:00
|
|
|
#include "nsHTMLAtoms.h"
|
1999-09-21 11:53:14 +04:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
#include "nsISupportsArray.h"
|
|
|
|
#include "nsIStyleRule.h"
|
1999-08-04 07:39:34 +04:00
|
|
|
#endif
|
1999-08-31 18:35:50 +04:00
|
|
|
#include "nsILayoutHistoryState.h"
|
|
|
|
#include "nsIStatefulFrame.h"
|
2000-01-14 12:28:54 +03:00
|
|
|
#include "nsIPresState.h"
|
1999-08-31 18:35:50 +04:00
|
|
|
#include "nsIContent.h"
|
1999-10-16 03:14:44 +04:00
|
|
|
#include "nsINameSpaceManager.h"
|
2000-05-26 03:02:31 +04:00
|
|
|
#include "nsIXMLContent.h"
|
2001-12-18 01:51:39 +03:00
|
|
|
#include "nsIXBLBinding.h"
|
2000-11-28 01:00:33 +03:00
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsIBindingManager.h"
|
|
|
|
#include "nsIScrollableFrame.h"
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
#include "nsIHTMLDocument.h"
|
|
|
|
#include "nsIDOMHTMLDocument.h"
|
|
|
|
#include "nsIDOMNodeList.h"
|
|
|
|
#include "nsIDOMHTMLCollection.h"
|
|
|
|
#include "nsIFormControl.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
|
|
#include "nsIDOMHTMLFormElement.h"
|
|
|
|
#include "nsIForm.h"
|
|
|
|
#include "nsIContentList.h"
|
2001-08-16 11:18:24 +04:00
|
|
|
#include "nsReadableUtils.h"
|
2001-10-26 21:51:22 +04:00
|
|
|
#include "nsUnicharUtils.h"
|
2001-05-30 15:26:21 +04:00
|
|
|
|
2000-09-13 02:47:09 +04:00
|
|
|
#ifdef DEBUG
|
|
|
|
#undef NOISY_DEBUG
|
|
|
|
#else
|
|
|
|
#undef NOISY_DEBUG
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef NOISY_DEBUG
|
|
|
|
#define NOISY_TRACE(_msg) \
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("%s",_msg);
|
2000-09-13 02:47:09 +04:00
|
|
|
#define NOISY_TRACE_FRAME(_msg,_frame) \
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("%s ",_msg); nsFrame::ListTag(stdout,_frame); printf("\n");
|
2000-09-13 02:47:09 +04:00
|
|
|
#else
|
|
|
|
#define NOISY_TRACE(_msg);
|
|
|
|
#define NOISY_TRACE_FRAME(_msg,_frame);
|
|
|
|
#endif
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
// Class IID's
|
2001-10-25 05:08:40 +04:00
|
|
|
static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
|
1999-08-04 07:39:34 +04:00
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
// IID's
|
1999-08-04 07:39:34 +04:00
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
//----------------------------------------------------------------------
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
struct PlaceholderMapEntry : public PLDHashEntryHdr {
|
|
|
|
// key (the out of flow frame) can be obtained through placeholder frame
|
|
|
|
nsPlaceholderFrame *placeholderFrame;
|
|
|
|
};
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
PR_STATIC_CALLBACK(const void *)
|
|
|
|
PlaceholderMapGetKey(PLDHashTable *table, PLDHashEntryHdr *hdr)
|
|
|
|
{
|
|
|
|
PlaceholderMapEntry *entry = NS_STATIC_CAST(PlaceholderMapEntry*, hdr);
|
|
|
|
return entry->placeholderFrame->GetOutOfFlowFrame();
|
|
|
|
}
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
PlaceholderMapMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
|
|
|
|
const void *key)
|
|
|
|
{
|
|
|
|
const PlaceholderMapEntry *entry =
|
|
|
|
NS_STATIC_CAST(const PlaceholderMapEntry*, hdr);
|
|
|
|
return entry->placeholderFrame->GetOutOfFlowFrame() == key;
|
|
|
|
}
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
static PLDHashTableOps PlaceholderMapOps = {
|
|
|
|
PL_DHashAllocTable,
|
|
|
|
PL_DHashFreeTable,
|
|
|
|
PlaceholderMapGetKey,
|
|
|
|
PL_DHashVoidPtrKeyStub,
|
|
|
|
PlaceholderMapMatchEntry,
|
|
|
|
PL_DHashMoveEntryStub,
|
|
|
|
PL_DHashClearEntryStub,
|
|
|
|
PL_DHashFinalizeStub,
|
|
|
|
NULL
|
|
|
|
};
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
//----------------------------------------------------------------------
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
struct PropertyListMapEntry : public PLDHashEntryHdr {
|
|
|
|
nsIFrame *key;
|
|
|
|
void *value;
|
|
|
|
};
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
struct PrimaryFrameMapEntry : public PLDHashEntryHdr {
|
2002-01-05 18:22:52 +03:00
|
|
|
// key (the content node) can almost always be obtained through the
|
|
|
|
// frame. If it weren't for the way image maps (mis)used the primary
|
|
|
|
// frame map, we'd be able to have a 2 word entry instead of a 3 word
|
|
|
|
// entry.
|
|
|
|
nsIContent *content;
|
2001-12-06 08:45:07 +03:00
|
|
|
nsIFrame *frame;
|
|
|
|
};
|
|
|
|
|
2002-01-05 18:22:52 +03:00
|
|
|
// These ops should be used if/when we switch back to a 2-word entry.
|
|
|
|
// See comment in |PrimaryFrameMapEntry| above.
|
|
|
|
#if 0
|
2001-12-06 08:45:07 +03:00
|
|
|
PR_STATIC_CALLBACK(const void *)
|
|
|
|
PrimaryFrameMapGetKey(PLDHashTable *table, PLDHashEntryHdr *hdr)
|
|
|
|
{
|
|
|
|
PrimaryFrameMapEntry *entry = NS_STATIC_CAST(PrimaryFrameMapEntry*, hdr);
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
entry->frame->GetContent(getter_AddRefs(content));
|
|
|
|
return content;
|
|
|
|
// and then release it, but we know the frame still owns it :-)
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_STATIC_CALLBACK(PRBool)
|
|
|
|
PrimaryFrameMapMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
|
|
|
|
const void *key)
|
|
|
|
{
|
|
|
|
const PrimaryFrameMapEntry *entry =
|
|
|
|
NS_STATIC_CAST(const PrimaryFrameMapEntry*, hdr);
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
entry->frame->GetContent(getter_AddRefs(content));
|
|
|
|
return content == key;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PLDHashTableOps PrimaryFrameMapOps = {
|
|
|
|
PL_DHashAllocTable,
|
|
|
|
PL_DHashFreeTable,
|
|
|
|
PrimaryFrameMapGetKey,
|
|
|
|
PL_DHashVoidPtrKeyStub,
|
|
|
|
PrimaryFrameMapMatchEntry,
|
|
|
|
PL_DHashMoveEntryStub,
|
|
|
|
PL_DHashClearEntryStub,
|
|
|
|
PL_DHashFinalizeStub,
|
|
|
|
NULL
|
1999-08-04 07:39:34 +04:00
|
|
|
};
|
2002-01-05 18:22:52 +03:00
|
|
|
#endif /* 0 */
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// XXXldb This seems too complicated for what I think it's doing, and it
|
|
|
|
// should also be using pldhash rather than plhash to use less memory.
|
2001-01-28 02:06:33 +03:00
|
|
|
MOZ_DECL_CTOR_COUNTER(UndisplayedNode)
|
1999-10-09 00:41:19 +04:00
|
|
|
|
2000-03-25 00:50:40 +03:00
|
|
|
class UndisplayedNode {
|
|
|
|
public:
|
1999-10-02 08:25:29 +04:00
|
|
|
UndisplayedNode(nsIContent* aContent, nsIStyleContext* aStyle)
|
|
|
|
{
|
1999-10-09 00:41:19 +04:00
|
|
|
MOZ_COUNT_CTOR(UndisplayedNode);
|
1999-10-02 08:25:29 +04:00
|
|
|
mContent = aContent;
|
|
|
|
mStyle = aStyle;
|
|
|
|
NS_ADDREF(mStyle);
|
|
|
|
mNext = nsnull;
|
|
|
|
}
|
|
|
|
UndisplayedNode(nsIStyleContext* aPseudoStyle)
|
|
|
|
{
|
1999-10-09 00:41:19 +04:00
|
|
|
MOZ_COUNT_CTOR(UndisplayedNode);
|
1999-10-02 08:25:29 +04:00
|
|
|
mContent = nsnull;
|
|
|
|
mStyle = aPseudoStyle;
|
|
|
|
NS_ADDREF(mStyle);
|
|
|
|
mNext = nsnull;
|
|
|
|
}
|
|
|
|
~UndisplayedNode(void)
|
|
|
|
{
|
1999-10-09 00:41:19 +04:00
|
|
|
MOZ_COUNT_DTOR(UndisplayedNode);
|
1999-10-02 08:25:29 +04:00
|
|
|
NS_RELEASE(mStyle);
|
1999-10-05 03:33:23 +04:00
|
|
|
if (mNext) {
|
|
|
|
delete mNext;
|
|
|
|
}
|
1999-10-02 08:25:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsIContent* mContent;
|
|
|
|
nsIStyleContext* mStyle;
|
|
|
|
UndisplayedNode* mNext;
|
|
|
|
};
|
|
|
|
|
|
|
|
class UndisplayedMap {
|
|
|
|
public:
|
|
|
|
UndisplayedMap(PRUint32 aNumBuckets = 16);
|
|
|
|
~UndisplayedMap(void);
|
|
|
|
|
|
|
|
UndisplayedNode* GetFirstNode(nsIContent* aParentContent);
|
|
|
|
|
|
|
|
nsresult AddNodeFor(nsIContent* aParentContent, nsIContent* aChild, nsIStyleContext* aStyle);
|
|
|
|
nsresult AddNodeFor(nsIContent* aParentContent, nsIStyleContext* aPseudoStyle);
|
|
|
|
|
|
|
|
nsresult RemoveNodeFor(nsIContent* aParentContent, UndisplayedNode* aNode);
|
|
|
|
nsresult RemoveNodesFor(nsIContent* aParentContent);
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
nsresult GetNodeFor(nsIContent* aContent, nsIStyleContext** aResult);
|
|
|
|
|
1999-10-02 08:25:29 +04:00
|
|
|
// Removes all entries from the hash table
|
|
|
|
void Clear(void);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
PLHashEntry** GetEntryFor(nsIContent* aParentContent);
|
|
|
|
nsresult AppendNodeFor(UndisplayedNode* aNode, nsIContent* aParentContent);
|
|
|
|
|
|
|
|
PLHashTable* mTable;
|
|
|
|
PLHashEntry** mLastLookup;
|
|
|
|
};
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
//----------------------------------------------------------------------
|
1999-08-04 07:39:34 +04:00
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
class FrameManager;
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
// A CantRenderReplacedElementEvent has a weak pointer to the frame
|
|
|
|
// manager, and the frame manager has a weak pointer to the event.
|
|
|
|
// The event queue owns the event and the FrameManager will delete
|
|
|
|
// the event if it's going to go away.
|
1999-08-06 00:17:44 +04:00
|
|
|
struct CantRenderReplacedElementEvent : public PLEvent {
|
|
|
|
CantRenderReplacedElementEvent(FrameManager* aFrameManager, nsIFrame* aFrame);
|
1999-08-04 07:39:34 +04:00
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
nsIFrame* mFrame; // the frame that can't be rendered
|
|
|
|
CantRenderReplacedElementEvent* mNext; // next event in the list
|
|
|
|
};
|
1999-08-04 07:39:34 +04:00
|
|
|
|
|
|
|
class FrameManager : public nsIFrameManager
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
FrameManager();
|
|
|
|
virtual ~FrameManager();
|
|
|
|
|
|
|
|
NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
|
|
|
|
|
|
|
|
// nsISupports
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
// nsIFrameManager
|
1999-08-06 00:17:44 +04:00
|
|
|
NS_IMETHOD Init(nsIPresShell* aPresShell, nsIStyleSet* aStyleSet);
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_IMETHOD Destroy();
|
1999-08-04 07:39:34 +04:00
|
|
|
|
1999-10-19 02:20:37 +04:00
|
|
|
// Gets and sets the root frame
|
|
|
|
NS_IMETHOD GetRootFrame(nsIFrame** aRootFrame) const;
|
|
|
|
NS_IMETHOD SetRootFrame(nsIFrame* aRootFrame);
|
|
|
|
|
2000-06-01 02:33:12 +04:00
|
|
|
// Get the canvas frame: searches from the Root frame down, may be null
|
|
|
|
NS_IMETHOD GetCanvasFrame(nsIPresContext* aPresContext, nsIFrame** aCanvasFrame) const;
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
// Primary frame functions
|
1999-08-05 07:09:22 +04:00
|
|
|
NS_IMETHOD GetPrimaryFrameFor(nsIContent* aContent, nsIFrame** aPrimaryFrame);
|
1999-08-04 07:39:34 +04:00
|
|
|
NS_IMETHOD SetPrimaryFrameFor(nsIContent* aContent,
|
|
|
|
nsIFrame* aPrimaryFrame);
|
|
|
|
NS_IMETHOD ClearPrimaryFrameMap();
|
|
|
|
|
|
|
|
// Placeholder frame functions
|
|
|
|
NS_IMETHOD GetPlaceholderFrameFor(nsIFrame* aFrame,
|
|
|
|
nsIFrame** aPlaceholderFrame) const;
|
2001-12-06 08:45:07 +03:00
|
|
|
NS_IMETHOD RegisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame);
|
|
|
|
NS_IMETHOD UnregisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame);
|
1999-08-04 07:39:34 +04:00
|
|
|
NS_IMETHOD ClearPlaceholderFrameMap();
|
|
|
|
|
1999-10-02 08:25:29 +04:00
|
|
|
// Undisplayed content functions
|
2001-06-01 02:19:43 +04:00
|
|
|
NS_IMETHOD GetUndisplayedContent(nsIContent* aContent, nsIStyleContext** aStyleContext);
|
1999-10-02 08:25:29 +04:00
|
|
|
NS_IMETHOD SetUndisplayedContent(nsIContent* aContent, nsIStyleContext* aStyleContext);
|
|
|
|
NS_IMETHOD SetUndisplayedPseudoIn(nsIStyleContext* aPseudoContext,
|
|
|
|
nsIContent* aParentContent);
|
|
|
|
NS_IMETHOD ClearUndisplayedContentIn(nsIContent* aContent, nsIContent* aParentContent);
|
|
|
|
NS_IMETHOD ClearAllUndisplayedContentIn(nsIContent* aParentContent);
|
|
|
|
NS_IMETHOD ClearUndisplayedContentMap();
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
// Functions for manipulating the frame model
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_IMETHOD AppendFrames(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aFrameList);
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_IMETHOD InsertFrames(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsIFrame* aFrameList);
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_IMETHOD RemoveFrame(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame);
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_IMETHOD ReplaceFrame(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame,
|
|
|
|
nsIFrame* aNewFrame);
|
1999-08-06 00:17:44 +04:00
|
|
|
|
|
|
|
NS_IMETHOD CantRenderReplacedElement(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame);
|
|
|
|
|
|
|
|
NS_IMETHOD NotifyDestroyingFrame(nsIFrame* aFrame);
|
1999-08-04 07:39:34 +04:00
|
|
|
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_IMETHOD ReParentStyleContext(nsIPresContext* aPresContext,
|
1999-09-04 03:35:41 +04:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsIStyleContext* aNewParentContext);
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_IMETHOD ComputeStyleChangeFor(nsIPresContext* aPresContext,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIFrame* aFrame,
|
1999-10-16 03:14:44 +04:00
|
|
|
PRInt32 aAttrNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsStyleChangeList& aChangeList,
|
|
|
|
PRInt32 aMinChange,
|
|
|
|
PRInt32& aTopLevelChange);
|
2000-05-16 06:43:33 +04:00
|
|
|
NS_IMETHOD AttributeAffectsStyle(nsIAtom *aAttribute, nsIContent *aContent,
|
|
|
|
PRBool &aAffects);
|
1999-09-04 03:35:41 +04:00
|
|
|
|
2000-06-15 04:35:46 +04:00
|
|
|
// Capture state from the entire frame heirarchy and store in aState
|
1999-10-26 08:44:41 +04:00
|
|
|
NS_IMETHOD CaptureFrameState(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsILayoutHistoryState* aState);
|
|
|
|
NS_IMETHOD RestoreFrameState(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsILayoutHistoryState* aState);
|
2000-06-15 04:35:46 +04:00
|
|
|
// Add/restore state for one frame (special, global type, like scroll position)
|
|
|
|
NS_IMETHOD CaptureFrameStateFor(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsILayoutHistoryState* aState,
|
|
|
|
nsIStatefulFrame::SpecialStateID aID = nsIStatefulFrame::eNoID);
|
|
|
|
NS_IMETHOD RestoreFrameStateFor(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsILayoutHistoryState* aState,
|
|
|
|
nsIStatefulFrame::SpecialStateID aID = nsIStatefulFrame::eNoID);
|
2001-05-30 15:26:21 +04:00
|
|
|
NS_IMETHOD GenerateStateKey(nsIContent* aContent,
|
|
|
|
nsIStatefulFrame::SpecialStateID aID,
|
|
|
|
nsCString& aString);
|
1999-08-31 18:35:50 +04:00
|
|
|
|
1999-10-16 04:55:48 +04:00
|
|
|
// Gets and sets properties on a given frame
|
|
|
|
NS_IMETHOD GetFrameProperty(nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName,
|
1999-10-19 08:52:33 +04:00
|
|
|
PRUint32 aOptions,
|
1999-10-16 04:55:48 +04:00
|
|
|
void** aPropertyValue);
|
1999-10-21 09:11:43 +04:00
|
|
|
NS_IMETHOD SetFrameProperty(nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName,
|
|
|
|
void* aPropertyValue,
|
|
|
|
NSFMPropertyDtorFunc aPropDtorFunc);
|
1999-10-16 04:55:48 +04:00
|
|
|
NS_IMETHOD RemoveFrameProperty(nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName);
|
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
#ifdef NS_DEBUG
|
2000-01-22 04:16:50 +03:00
|
|
|
NS_IMETHOD DebugVerifyStyleTree(nsIPresContext* aPresContext, nsIFrame* aFrame);
|
1999-09-21 11:53:14 +04:00
|
|
|
#endif
|
|
|
|
|
1999-10-16 04:55:48 +04:00
|
|
|
struct PropertyList {
|
1999-10-21 09:11:43 +04:00
|
|
|
nsCOMPtr<nsIAtom> mName; // property name
|
2001-12-06 08:45:07 +03:00
|
|
|
PLDHashTable mFrameValueMap; // map of frame/value pairs
|
1999-10-21 09:11:43 +04:00
|
|
|
NSFMPropertyDtorFunc mDtorFunc; // property specific value dtor function
|
|
|
|
PropertyList* mNext;
|
|
|
|
|
|
|
|
PropertyList(nsIAtom* aName,
|
2001-12-06 08:45:07 +03:00
|
|
|
NSFMPropertyDtorFunc aDtorFunc);
|
1999-10-16 04:55:48 +04:00
|
|
|
~PropertyList();
|
|
|
|
|
|
|
|
// Removes the property associated with the given frame, and destroys
|
|
|
|
// the property value
|
1999-10-21 09:11:43 +04:00
|
|
|
PRBool RemovePropertyForFrame(nsIPresContext* aPresContext, nsIFrame* aFrame);
|
1999-10-19 18:41:55 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
// Destroy all remaining properties (without removing them)
|
|
|
|
void Destroy(nsIPresContext* aPresContext);
|
1999-10-16 04:55:48 +04:00
|
|
|
};
|
2001-12-06 08:45:07 +03:00
|
|
|
private:
|
1999-10-16 04:55:48 +04:00
|
|
|
|
1999-10-18 23:02:09 +04:00
|
|
|
nsIPresShell* mPresShell; // weak link, because the pres shell owns us
|
|
|
|
nsIStyleSet* mStyleSet; // weak link. pres shell holds a reference
|
1999-10-19 02:20:37 +04:00
|
|
|
nsIFrame* mRootFrame;
|
2001-12-06 08:45:07 +03:00
|
|
|
PLDHashTable mPrimaryFrameMap;
|
|
|
|
PLDHashTable mPlaceholderMap;
|
1999-10-02 08:25:29 +04:00
|
|
|
UndisplayedMap* mUndisplayedMap;
|
1999-08-06 00:17:44 +04:00
|
|
|
CantRenderReplacedElementEvent* mPostedEvents;
|
1999-10-16 04:55:48 +04:00
|
|
|
PropertyList* mPropertyList;
|
2001-05-30 15:26:21 +04:00
|
|
|
nsCOMPtr<nsIContentList> mHTMLForms;
|
|
|
|
nsCOMPtr<nsIContentList> mHTMLFormControls;
|
2002-03-10 09:47:42 +03:00
|
|
|
PRBool mIsDestroyingFrames;
|
1999-10-02 08:25:29 +04:00
|
|
|
|
1999-11-24 09:03:41 +03:00
|
|
|
void ReResolveStyleContext(nsIPresContext* aPresContext,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsIStyleContext* aParentContext,
|
|
|
|
nsIContent* aParentContent,
|
1999-10-16 03:14:44 +04:00
|
|
|
PRInt32 aAttrNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsStyleChangeList& aChangeList,
|
|
|
|
PRInt32 aMinChange,
|
|
|
|
PRInt32& aResultChange);
|
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
nsresult RevokePostedEvents();
|
1999-08-06 00:17:44 +04:00
|
|
|
CantRenderReplacedElementEvent** FindPostedEventFor(nsIFrame* aFrame);
|
|
|
|
void DequeuePostedEventFor(nsIFrame* aFrame);
|
1999-10-19 18:41:55 +04:00
|
|
|
void DestroyPropertyList(nsIPresContext* aPresContext);
|
1999-10-16 04:55:48 +04:00
|
|
|
PropertyList* GetPropertyListFor(nsIAtom* aPropertyName) const;
|
1999-10-19 18:41:55 +04:00
|
|
|
void RemoveAllPropertiesFor(nsIPresContext* aPresContext, nsIFrame* aFrame);
|
1999-08-06 00:17:44 +04:00
|
|
|
|
1999-08-06 18:34:32 +04:00
|
|
|
friend struct CantRenderReplacedElementEvent;
|
|
|
|
static void HandlePLEvent(CantRenderReplacedElementEvent* aEvent);
|
|
|
|
static void DestroyPLEvent(CantRenderReplacedElementEvent* aEvent);
|
1999-08-04 07:39:34 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
2001-10-23 05:37:21 +04:00
|
|
|
NS_EXPORT nsresult
|
1999-08-04 07:39:34 +04:00
|
|
|
NS_NewFrameManager(nsIFrameManager** aInstancePtrResult)
|
|
|
|
{
|
1999-10-21 09:11:43 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aInstancePtrResult);
|
1999-08-06 18:34:32 +04:00
|
|
|
if (!aInstancePtrResult) {
|
1999-08-04 07:39:34 +04:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
FrameManager* it = new FrameManager;
|
1999-08-06 18:34:32 +04:00
|
|
|
if (!it) {
|
1999-08-04 07:39:34 +04:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
2000-02-03 01:24:56 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIFrameManager), (void **)aInstancePtrResult);
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
FrameManager::FrameManager()
|
|
|
|
{
|
1999-10-09 00:41:19 +04:00
|
|
|
NS_INIT_REFCNT();
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
FrameManager::~FrameManager()
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ASSERTION(!mPresShell, "FrameManager::Destroy never called");
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_ISUPPORTS1(FrameManager, nsIFrameManager)
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::Init(nsIPresShell* aPresShell,
|
|
|
|
nsIStyleSet* aStyleSet)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPresShell, "null aPresShell");
|
|
|
|
NS_ASSERTION(aStyleSet, "null aStyleSet");
|
|
|
|
|
|
|
|
mPresShell = aPresShell;
|
|
|
|
mStyleSet = aStyleSet;
|
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Force the forms and form control content lists to be added as
|
|
|
|
// document observers *before* us (pres shell) so they will be
|
|
|
|
// up to date when we try to use them.
|
|
|
|
nsCOMPtr<nsIDocument> document;
|
|
|
|
mPresShell->GetDocument(getter_AddRefs(document));
|
|
|
|
nsCOMPtr<nsIHTMLDocument> htmlDocument(do_QueryInterface(document));
|
|
|
|
nsCOMPtr<nsIDOMHTMLDocument> domHtmlDocument(do_QueryInterface(htmlDocument));
|
|
|
|
if (domHtmlDocument) {
|
|
|
|
nsCOMPtr<nsIDOMHTMLCollection> forms;
|
|
|
|
domHtmlDocument->GetForms(getter_AddRefs(forms));
|
|
|
|
mHTMLForms = do_QueryInterface(forms);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList> formControls;
|
|
|
|
htmlDocument->GetFormControlElements(getter_AddRefs(formControls));
|
|
|
|
mHTMLFormControls = do_QueryInterface(formControls);
|
|
|
|
}
|
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::Destroy()
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mPresShell, "Frame manager already shut down.");
|
|
|
|
|
1999-10-19 18:41:55 +04:00
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
mPresShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
|
1999-10-19 02:20:37 +04:00
|
|
|
// Destroy the frame hierarchy. Don't destroy the property lists until after
|
|
|
|
// we've destroyed the frame hierarchy because some frames may expect to be
|
|
|
|
// able to retrieve their properties during destruction
|
2001-12-01 03:22:00 +03:00
|
|
|
mPresShell->SetIgnoreFrameDestruction(PR_TRUE);
|
2002-03-10 09:47:42 +03:00
|
|
|
|
|
|
|
mIsDestroyingFrames = PR_TRUE; // This flag prevents GetPrimaryFrameFor from returning pointers to destroyed frames
|
|
|
|
|
1999-10-19 02:20:37 +04:00
|
|
|
if (mRootFrame) {
|
1999-11-24 09:03:41 +03:00
|
|
|
mRootFrame->Destroy(presContext);
|
1999-10-19 02:20:37 +04:00
|
|
|
mRootFrame = nsnull;
|
|
|
|
}
|
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mPrimaryFrameMap.ops) {
|
|
|
|
PL_DHashTableFinish(&mPrimaryFrameMap);
|
|
|
|
mPrimaryFrameMap.ops = nsnull;
|
|
|
|
}
|
|
|
|
if (mPlaceholderMap.ops) {
|
|
|
|
PL_DHashTableFinish(&mPlaceholderMap);
|
|
|
|
mPlaceholderMap.ops = nsnull;
|
|
|
|
}
|
1999-10-19 23:06:37 +04:00
|
|
|
delete mUndisplayedMap;
|
1999-10-19 18:41:55 +04:00
|
|
|
DestroyPropertyList(presContext);
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
// If we're not going to be used anymore, we should revoke the
|
|
|
|
// pending |CantRenderReplacedElementEvent|s being sent to us.
|
|
|
|
nsresult rv = RevokePostedEvents();
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "RevokePostedEvents failed: might crash");
|
1999-10-18 23:02:09 +04:00
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
mPresShell = nsnull; // mPresShell isn't valid anymore. We
|
|
|
|
// won't use it, either, but we check it
|
|
|
|
// at the start of every function so that we'll
|
|
|
|
// be OK when nsIPresShell is converted to IDL.
|
1999-10-18 23:02:09 +04:00
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
return rv;
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
|
1999-10-19 02:20:37 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::GetRootFrame(nsIFrame** aRootFrame) const
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-19 02:20:37 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aRootFrame);
|
|
|
|
*aRootFrame = mRootFrame;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::SetRootFrame(nsIFrame* aRootFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-19 02:20:37 +04:00
|
|
|
NS_PRECONDITION(!mRootFrame, "already have a root frame");
|
|
|
|
if (mRootFrame) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
mRootFrame = aRootFrame;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-06-01 02:33:12 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::GetCanvasFrame(nsIPresContext* aPresContext, nsIFrame** aCanvasFrame) const
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2000-06-01 02:33:12 +04:00
|
|
|
NS_PRECONDITION(aCanvasFrame, "aCanvasFrame argument cannot be null");
|
|
|
|
NS_PRECONDITION(aPresContext, "aPresContext argument cannot be null");
|
|
|
|
|
|
|
|
*aCanvasFrame = nsnull;
|
|
|
|
if (mRootFrame) {
|
|
|
|
// walk the children of the root frame looking for a frame with type==canvas
|
|
|
|
// start at the root
|
|
|
|
nsIFrame* childFrame = mRootFrame;
|
|
|
|
while (childFrame) {
|
|
|
|
// get each sibling of the child and check them, startig at the child
|
|
|
|
nsIFrame *siblingFrame = childFrame;
|
|
|
|
while (siblingFrame) {
|
|
|
|
nsCOMPtr<nsIAtom> frameType;
|
|
|
|
siblingFrame->GetFrameType(getter_AddRefs(frameType));
|
|
|
|
if (frameType.get() == nsLayoutAtoms::canvasFrame) {
|
|
|
|
// this is it: set the out-arg and stop looking
|
|
|
|
*aCanvasFrame = siblingFrame;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
siblingFrame->GetNextSibling(&siblingFrame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// move on to the child's child
|
|
|
|
childFrame->FirstChild(aPresContext, nsnull, &childFrame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
// Primary frame functions
|
|
|
|
NS_IMETHODIMP
|
1999-08-05 07:09:22 +04:00
|
|
|
FrameManager::GetPrimaryFrameFor(nsIContent* aContent, nsIFrame** aResult)
|
1999-08-04 07:39:34 +04:00
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-21 09:11:43 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
|
|
NS_ENSURE_ARG_POINTER(aContent);
|
2001-01-17 01:10:04 +03:00
|
|
|
*aResult = nsnull; // initialize out param
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2002-03-10 09:47:42 +03:00
|
|
|
if (mIsDestroyingFrames) {
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("GetPrimaryFrameFor() called while FrameManager is being destroyed!\n");
|
|
|
|
#endif
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2001-01-17 01:10:04 +03:00
|
|
|
nsresult rv;
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mPrimaryFrameMap.ops) {
|
|
|
|
PrimaryFrameMapEntry *entry = NS_STATIC_CAST(PrimaryFrameMapEntry*,
|
|
|
|
PL_DHashTableOperate(&mPrimaryFrameMap, aContent, PL_DHASH_LOOKUP));
|
|
|
|
if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
|
|
|
|
*aResult = entry->frame;
|
|
|
|
} else {
|
2001-01-17 01:10:04 +03:00
|
|
|
// XXX: todo: Add a lookup into the undisplay map to skip searches
|
|
|
|
// if we already know the content has no frame.
|
|
|
|
// nsCSSFrameConstructor calls SetUndisplayedContent() for every
|
|
|
|
// content node that has display: none.
|
|
|
|
// Today, the undisplay map doesn't quite support what we need.
|
|
|
|
// We need to see if we can add a method to make a search for aContent
|
|
|
|
// very fast in the embedded hash table.
|
|
|
|
// This would almost completely remove the lookup penalty for things
|
|
|
|
// like <SCRIPT> and comments in very large documents.
|
1999-08-04 07:39:34 +04:00
|
|
|
nsCOMPtr<nsIStyleSet> styleSet;
|
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
|
|
|
|
// Give the frame construction code the opportunity to return the
|
|
|
|
// frame that maps the content object
|
|
|
|
mPresShell->GetStyleSet(getter_AddRefs(styleSet));
|
2001-01-17 01:10:04 +03:00
|
|
|
NS_ASSERTION(styleSet, "bad style set");
|
1999-08-04 07:39:34 +04:00
|
|
|
mPresShell->GetPresContext(getter_AddRefs(presContext));
|
2001-01-17 01:10:04 +03:00
|
|
|
NS_ASSERTION(presContext, "bad presContext");
|
|
|
|
if (!styleSet || !presContext) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if the prev sibling of aContent has a cached primary frame,
|
|
|
|
// pass that data in to the style set to speed things up
|
|
|
|
// if any methods in here fail, don't report that failure
|
|
|
|
// we're just trying to enhance performance here, not test for correctness
|
|
|
|
nsFindFrameHint hint;
|
|
|
|
nsCOMPtr<nsIContent> prevSibling, parent;
|
|
|
|
rv = aContent->GetParent(*getter_AddRefs(parent));
|
|
|
|
if (NS_SUCCEEDED(rv) && parent)
|
|
|
|
{
|
|
|
|
PRInt32 index;
|
|
|
|
rv = parent->IndexOf(aContent, index);
|
|
|
|
if (NS_SUCCEEDED(rv) && index>0) // no use looking if it's the first child
|
|
|
|
{
|
2002-01-11 23:10:46 +03:00
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
do {
|
|
|
|
parent->ChildAt(--index, *getter_AddRefs(prevSibling));
|
|
|
|
prevSibling->GetTag(*getter_AddRefs(tag));
|
|
|
|
} while (index &&
|
|
|
|
(tag == nsLayoutAtoms::textTagName ||
|
|
|
|
tag == nsLayoutAtoms::commentTagName ||
|
|
|
|
tag == nsLayoutAtoms::processingInstructionTagName));
|
|
|
|
if (prevSibling) {
|
2001-12-06 08:45:07 +03:00
|
|
|
entry = NS_STATIC_CAST(PrimaryFrameMapEntry*,
|
|
|
|
PL_DHashTableOperate(&mPrimaryFrameMap, prevSibling.get(),
|
|
|
|
PL_DHASH_LOOKUP));
|
|
|
|
if (PL_DHASH_ENTRY_IS_BUSY(entry))
|
|
|
|
hint.mPrimaryFrameForPrevSibling = entry->frame;
|
2001-01-17 01:10:04 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// walk the frame tree to find the frame that maps aContent.
|
|
|
|
// Use the hint if we have it.
|
|
|
|
styleSet->FindPrimaryFrameFor(presContext, this, aContent, aResult,
|
|
|
|
hint.mPrimaryFrameForPrevSibling ? &hint : nsnull);
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::SetPrimaryFrameFor(nsIContent* aContent,
|
|
|
|
nsIFrame* aPrimaryFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-21 09:11:43 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aContent);
|
2001-01-17 01:10:04 +03:00
|
|
|
// it's ok if aPrimaryFrame is null
|
1999-08-04 07:39:34 +04:00
|
|
|
|
|
|
|
// If aPrimaryFrame is NULL, then remove the mapping
|
|
|
|
if (!aPrimaryFrame) {
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mPrimaryFrameMap.ops) {
|
|
|
|
PL_DHashTableOperate(&mPrimaryFrameMap, aContent, PL_DHASH_REMOVE);
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
} else {
|
2002-01-05 18:22:52 +03:00
|
|
|
// This code should be used if/when we switch back to a 2-word entry
|
|
|
|
// in the primary frame map.
|
|
|
|
#if 0
|
|
|
|
//#ifdef DEBUG
|
2001-12-06 08:45:07 +03:00
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
aPrimaryFrame->GetContent(getter_AddRefs(content));
|
|
|
|
NS_PRECONDITION(content == aContent, "wrong content");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Create a new hashtable if necessary
|
|
|
|
if (!mPrimaryFrameMap.ops) {
|
2002-01-05 18:22:52 +03:00
|
|
|
if (!PL_DHashTableInit(&mPrimaryFrameMap, PL_DHashGetStubOps(), nsnull,
|
2001-12-06 08:45:07 +03:00
|
|
|
sizeof(PrimaryFrameMapEntry), 16)) {
|
|
|
|
mPrimaryFrameMap.ops = nsnull;
|
1999-08-04 07:39:34 +04:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a mapping to the hash table
|
2001-12-06 08:45:07 +03:00
|
|
|
PrimaryFrameMapEntry *entry = NS_STATIC_CAST(PrimaryFrameMapEntry*,
|
|
|
|
PL_DHashTableOperate(&mPrimaryFrameMap, aContent, PL_DHASH_ADD));
|
2001-12-06 22:53:37 +03:00
|
|
|
#ifdef DEBUG_dbaron
|
2001-12-06 08:45:07 +03:00
|
|
|
if (entry->frame) {
|
|
|
|
NS_WARNING("already have primary frame for content");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
entry->frame = aPrimaryFrame;
|
2002-01-05 18:22:52 +03:00
|
|
|
entry->content = aContent;
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
2001-01-17 01:10:04 +03:00
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::ClearPrimaryFrameMap()
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mPrimaryFrameMap.ops) {
|
|
|
|
PL_DHashTableFinish(&mPrimaryFrameMap);
|
|
|
|
mPrimaryFrameMap.ops = nsnull;
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Placeholder frame functions
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::GetPlaceholderFrameFor(nsIFrame* aFrame,
|
|
|
|
nsIFrame** aResult) const
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
NS_PRECONDITION(aFrame, "null param unexpected");
|
|
|
|
NS_PRECONDITION(aResult, "null out param unexpected");
|
1999-08-04 07:39:34 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mPlaceholderMap.ops) {
|
|
|
|
PlaceholderMapEntry *entry = NS_STATIC_CAST(PlaceholderMapEntry*,
|
|
|
|
PL_DHashTableOperate(NS_CONST_CAST(PLDHashTable*, &mPlaceholderMap),
|
|
|
|
aFrame, PL_DHASH_LOOKUP));
|
|
|
|
if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
|
|
|
|
*aResult = entry->placeholderFrame;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
*aResult = nsnull;
|
1999-08-04 07:39:34 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-12-06 08:45:07 +03:00
|
|
|
FrameManager::RegisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame)
|
1999-08-04 07:39:34 +04:00
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
NS_PRECONDITION(aPlaceholderFrame, "null param unexpected");
|
|
|
|
#ifdef DEBUG
|
|
|
|
nsCOMPtr<nsIAtom> frameType;
|
|
|
|
aPlaceholderFrame->GetFrameType(getter_AddRefs(frameType));
|
|
|
|
NS_PRECONDITION(nsLayoutAtoms::placeholderFrame == frameType,
|
|
|
|
"unexpected frame type");
|
1999-08-04 07:39:34 +04:00
|
|
|
#endif
|
2001-12-06 08:45:07 +03:00
|
|
|
if (!mPlaceholderMap.ops) {
|
|
|
|
if (!PL_DHashTableInit(&mPlaceholderMap, &PlaceholderMapOps, nsnull,
|
|
|
|
sizeof(PlaceholderMapEntry), 16)) {
|
|
|
|
mPlaceholderMap.ops = nsnull;
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
}
|
2001-12-06 08:45:07 +03:00
|
|
|
PlaceholderMapEntry *entry = NS_STATIC_CAST(PlaceholderMapEntry*,
|
|
|
|
PL_DHashTableOperate(&mPlaceholderMap,
|
|
|
|
aPlaceholderFrame->GetOutOfFlowFrame(),
|
|
|
|
PL_DHASH_ADD));
|
|
|
|
if (!entry)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
entry->placeholderFrame = aPlaceholderFrame;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::UnregisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame)
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
|
|
|
NS_PRECONDITION(aPlaceholderFrame, "null param unexpected");
|
|
|
|
#ifdef DEBUG
|
|
|
|
nsCOMPtr<nsIAtom> frameType;
|
|
|
|
aPlaceholderFrame->GetFrameType(getter_AddRefs(frameType));
|
|
|
|
NS_PRECONDITION(nsLayoutAtoms::placeholderFrame == frameType,
|
|
|
|
"unexpected frame type");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
PL_DHashTableOperate(&mPlaceholderMap,
|
|
|
|
aPlaceholderFrame->GetOutOfFlowFrame(),
|
|
|
|
PL_DHASH_REMOVE);
|
1999-08-04 07:39:34 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::ClearPlaceholderFrameMap()
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mPlaceholderMap.ops) {
|
|
|
|
PL_DHashTableFinish(&mPlaceholderMap);
|
|
|
|
mPlaceholderMap.ops = nsnull;
|
1999-08-04 07:39:34 +04:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::GetUndisplayedContent(nsIContent* aContent, nsIStyleContext** aResult)
|
|
|
|
{
|
2001-12-06 08:45:07 +03:00
|
|
|
if (!aContent)
|
2001-06-01 02:19:43 +04:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
*aResult = nsnull; // initialize out param
|
|
|
|
|
|
|
|
if (mUndisplayedMap)
|
|
|
|
mUndisplayedMap->GetNodeFor(aContent, aResult);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-10-02 08:25:29 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::SetUndisplayedContent(nsIContent* aContent,
|
|
|
|
nsIStyleContext* aStyleContext)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-02 08:25:29 +04:00
|
|
|
if (! mUndisplayedMap) {
|
|
|
|
mUndisplayedMap = new UndisplayedMap;
|
|
|
|
}
|
|
|
|
if (mUndisplayedMap) {
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsIContent* parent = nsnull;
|
|
|
|
aContent->GetParent(parent);
|
|
|
|
if (parent) {
|
|
|
|
result = mUndisplayedMap->AddNodeFor(parent, aContent, aStyleContext);
|
|
|
|
NS_RELEASE(parent);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::SetUndisplayedPseudoIn(nsIStyleContext* aPseudoContext,
|
|
|
|
nsIContent* aParentContent)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-02 08:25:29 +04:00
|
|
|
if (! mUndisplayedMap) {
|
|
|
|
mUndisplayedMap = new UndisplayedMap;
|
|
|
|
}
|
|
|
|
if (mUndisplayedMap) {
|
|
|
|
return mUndisplayedMap->AddNodeFor(aParentContent, aPseudoContext);
|
|
|
|
}
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::ClearUndisplayedContentIn(nsIContent* aContent, nsIContent* aParentContent)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-02 08:25:29 +04:00
|
|
|
if (mUndisplayedMap) {
|
|
|
|
UndisplayedNode* node = mUndisplayedMap->GetFirstNode(aParentContent);
|
|
|
|
while (node) {
|
|
|
|
if (node->mContent == aContent) {
|
|
|
|
return mUndisplayedMap->RemoveNodeFor(aParentContent, node);
|
|
|
|
}
|
|
|
|
node = node->mNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::ClearAllUndisplayedContentIn(nsIContent* aParentContent)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-02 08:25:29 +04:00
|
|
|
if (mUndisplayedMap) {
|
|
|
|
return mUndisplayedMap->RemoveNodesFor(aParentContent);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::ClearUndisplayedContentMap()
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-02 08:25:29 +04:00
|
|
|
if (mUndisplayedMap) {
|
|
|
|
mUndisplayedMap->Clear();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::AppendFrames(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-08-04 07:39:34 +04:00
|
|
|
return aParentFrame->AppendFrames(aPresContext, aPresShell, aListName,
|
|
|
|
aFrameList);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::InsertFrames(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-03-09 06:29:00 +03:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
if (aPrevFrame) {
|
|
|
|
// Insert aFrameList after the last bidi continuation of aPrevFrame.
|
|
|
|
nsIFrame* nextBidi;
|
|
|
|
for (; ;) {
|
|
|
|
GetFrameProperty(aPrevFrame, nsLayoutAtoms::nextBidi, 0, (void**) &nextBidi);
|
|
|
|
if (!nextBidi) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
aPrevFrame = nextBidi;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // IBMBIDI
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
return aParentFrame->InsertFrames(aPresContext, aPresShell, aListName,
|
|
|
|
aPrevFrame, aFrameList);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::RemoveFrame(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2000-11-28 01:00:33 +03:00
|
|
|
|
2001-03-09 06:29:00 +03:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
// Don't let the parent remove next bidi. In the other cases the it should NOT be removed.
|
|
|
|
nsIFrame* nextBidi;
|
|
|
|
GetFrameProperty(aOldFrame, nsLayoutAtoms::nextBidi, 0, (void**) &nextBidi);
|
|
|
|
if (nextBidi) {
|
|
|
|
RemoveFrame(aPresContext, aPresShell, aParentFrame, aListName, nextBidi);
|
|
|
|
}
|
|
|
|
#endif // IBMBIDI
|
|
|
|
|
1999-08-04 07:39:34 +04:00
|
|
|
return aParentFrame->RemoveFrame(aPresContext, aPresShell, aListName,
|
|
|
|
aOldFrame);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::ReplaceFrame(nsIPresContext* aPresContext,
|
1999-08-04 07:39:34 +04:00
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIFrame* aParentFrame,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame,
|
|
|
|
nsIFrame* aNewFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-08-04 07:39:34 +04:00
|
|
|
return aParentFrame->ReplaceFrame(aPresContext, aPresShell, aListName,
|
|
|
|
aOldFrame, aNewFrame);
|
|
|
|
}
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::NotifyDestroyingFrame(nsIFrame* aFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-08-06 00:17:44 +04:00
|
|
|
// Dequeue and destroy and posted events for this frame
|
|
|
|
DequeuePostedEventFor(aFrame);
|
1999-10-16 04:55:48 +04:00
|
|
|
|
|
|
|
// Remove all properties associated with the frame
|
1999-10-19 18:41:55 +04:00
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
mPresShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
|
|
|
|
RemoveAllPropertiesFor(presContext, aFrame);
|
2001-12-11 08:39:36 +03:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2001-12-11 22:16:15 +03:00
|
|
|
if (mPrimaryFrameMap.ops) {
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
aFrame->GetContent(getter_AddRefs(content));
|
|
|
|
PrimaryFrameMapEntry *entry = NS_STATIC_CAST(PrimaryFrameMapEntry*,
|
|
|
|
PL_DHashTableOperate(&mPrimaryFrameMap, content, PL_DHASH_LOOKUP));
|
|
|
|
NS_ASSERTION(!PL_DHASH_ENTRY_IS_BUSY(entry) || entry->frame != aFrame,
|
2002-01-05 18:22:52 +03:00
|
|
|
"frame was not removed from primary frame map before "
|
2001-12-11 22:16:15 +03:00
|
|
|
"destruction or was readded to map after being removed");
|
|
|
|
}
|
2001-12-11 08:39:36 +03:00
|
|
|
#endif
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
nsresult
|
1999-08-06 00:17:44 +04:00
|
|
|
FrameManager::RevokePostedEvents()
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
nsresult rv = NS_OK;
|
2000-06-05 07:37:33 +04:00
|
|
|
#ifdef NOISY_EVENTS
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("%p ~RevokePostedEvents() start\n", this);
|
2000-06-05 07:37:33 +04:00
|
|
|
#endif
|
1999-08-06 00:17:44 +04:00
|
|
|
if (mPostedEvents) {
|
|
|
|
mPostedEvents = nsnull;
|
|
|
|
|
|
|
|
// Revoke any events in the event queue that are owned by us
|
|
|
|
nsIEventQueueService* eventService;
|
|
|
|
|
|
|
|
rv = nsServiceManager::GetService(kEventQueueServiceCID,
|
2001-01-04 23:44:42 +03:00
|
|
|
NS_GET_IID(nsIEventQueueService),
|
1999-08-06 00:17:44 +04:00
|
|
|
(nsISupports **)&eventService);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
nsCOMPtr<nsIEventQueue> eventQueue;
|
1999-11-30 03:32:43 +03:00
|
|
|
rv = eventService->GetThreadEventQueue(NS_CURRENT_THREAD,
|
1999-08-06 00:17:44 +04:00
|
|
|
getter_AddRefs(eventQueue));
|
|
|
|
nsServiceManager::ReleaseService(kEventQueueServiceCID, eventService);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && eventQueue) {
|
2001-03-06 04:46:03 +03:00
|
|
|
rv = eventQueue->RevokeEvents(this);
|
1999-08-06 00:17:44 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-06-05 07:37:33 +04:00
|
|
|
#ifdef NOISY_EVENTS
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("%p ~RevokePostedEvents() end\n", this);
|
2000-06-05 07:37:33 +04:00
|
|
|
#endif
|
2001-03-06 04:46:03 +03:00
|
|
|
return rv;
|
1999-08-06 00:17:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
CantRenderReplacedElementEvent**
|
|
|
|
FrameManager::FindPostedEventFor(nsIFrame* aFrame)
|
|
|
|
{
|
|
|
|
CantRenderReplacedElementEvent** event = &mPostedEvents;
|
|
|
|
|
|
|
|
while (*event) {
|
|
|
|
if ((*event)->mFrame == aFrame) {
|
|
|
|
return event;
|
|
|
|
}
|
|
|
|
event = &(*event)->mNext;
|
|
|
|
}
|
|
|
|
|
|
|
|
return event;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
FrameManager::DequeuePostedEventFor(nsIFrame* aFrame)
|
|
|
|
{
|
|
|
|
// If there's a posted event for this frame, then remove it
|
|
|
|
CantRenderReplacedElementEvent** event = FindPostedEventFor(aFrame);
|
|
|
|
if (*event) {
|
|
|
|
CantRenderReplacedElementEvent* tmp = *event;
|
|
|
|
|
|
|
|
// Remove it from our linked list of posted events
|
|
|
|
*event = (*event)->mNext;
|
|
|
|
|
|
|
|
// Dequeue it from the event queue
|
|
|
|
nsIEventQueueService* eventService;
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
rv = nsServiceManager::GetService(kEventQueueServiceCID,
|
2001-01-04 23:44:42 +03:00
|
|
|
NS_GET_IID(nsIEventQueueService),
|
1999-08-06 00:17:44 +04:00
|
|
|
(nsISupports **)&eventService);
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv),
|
|
|
|
"will crash soon due to event holding dangling pointer to frame");
|
1999-08-06 00:17:44 +04:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
nsCOMPtr<nsIEventQueue> eventQueue;
|
1999-11-30 03:32:43 +03:00
|
|
|
rv = eventService->GetThreadEventQueue(NS_CURRENT_THREAD,
|
1999-08-06 00:17:44 +04:00
|
|
|
getter_AddRefs(eventQueue));
|
|
|
|
nsServiceManager::ReleaseService(kEventQueueServiceCID, eventService);
|
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) && eventQueue,
|
|
|
|
"will crash soon due to event holding dangling pointer to frame");
|
1999-08-06 00:17:44 +04:00
|
|
|
if (NS_SUCCEEDED(rv) && eventQueue) {
|
|
|
|
PLEventQueue* plqueue;
|
|
|
|
|
|
|
|
eventQueue->GetPLEventQueue(&plqueue);
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ASSERTION(plqueue,
|
|
|
|
"will crash soon due to event holding dangling pointer to frame");
|
1999-08-06 00:17:44 +04:00
|
|
|
if (plqueue) {
|
|
|
|
// Removes the event and destroys it
|
|
|
|
PL_DequeueEvent(tmp, plqueue);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2001-03-06 04:46:03 +03:00
|
|
|
FrameManager::HandlePLEvent(CantRenderReplacedElementEvent* aEvent)
|
|
|
|
{
|
2000-06-05 07:37:33 +04:00
|
|
|
#ifdef NOISY_EVENTS
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("FrameManager::HandlePLEvent() start for FM %p\n", aEvent->owner);
|
2000-06-05 07:37:33 +04:00
|
|
|
#endif
|
1999-08-06 18:34:32 +04:00
|
|
|
FrameManager* frameManager = (FrameManager*)aEvent->owner;
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ASSERTION(frameManager, "null frame manager");
|
2000-03-28 05:08:36 +04:00
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
if (!frameManager->mPresShell) {
|
|
|
|
NS_ASSERTION(frameManager->mPresShell,
|
|
|
|
"event not removed from queue on shutdown");
|
|
|
|
return;
|
|
|
|
}
|
1999-08-06 00:17:44 +04:00
|
|
|
|
2001-03-06 04:46:03 +03:00
|
|
|
// Remove the posted event from the linked list
|
|
|
|
CantRenderReplacedElementEvent** events = &frameManager->mPostedEvents;
|
|
|
|
while (*events) {
|
|
|
|
if (*events == aEvent) {
|
|
|
|
*events = (*events)->mNext;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
events = &(*events)->mNext;
|
|
|
|
NS_ASSERTION(*events, "event not in queue");
|
2000-03-28 05:08:36 +04:00
|
|
|
}
|
2001-03-06 04:46:03 +03:00
|
|
|
|
|
|
|
// Notify the style system and then process any reflow commands that
|
|
|
|
// are generated
|
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
frameManager->mPresShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
frameManager->mStyleSet->CantRenderReplacedElement(presContext,
|
|
|
|
aEvent->mFrame);
|
2000-06-05 07:37:33 +04:00
|
|
|
#ifdef NOISY_EVENTS
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("FrameManager::HandlePLEvent() end for FM %p\n", aEvent->owner);
|
2000-06-05 07:37:33 +04:00
|
|
|
#endif
|
1999-08-06 00:17:44 +04:00
|
|
|
}
|
|
|
|
|
1999-08-06 18:34:32 +04:00
|
|
|
void
|
|
|
|
FrameManager::DestroyPLEvent(CantRenderReplacedElementEvent* aEvent)
|
1999-08-06 00:17:44 +04:00
|
|
|
{
|
|
|
|
delete aEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
CantRenderReplacedElementEvent::CantRenderReplacedElementEvent(FrameManager* aFrameManager,
|
|
|
|
nsIFrame* aFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
PL_InitEvent(this, aFrameManager,
|
|
|
|
(PLHandleEventProc)&FrameManager::HandlePLEvent,
|
1999-08-06 18:34:32 +04:00
|
|
|
(PLDestroyEventProc)&FrameManager::DestroyPLEvent);
|
1999-08-06 00:17:44 +04:00
|
|
|
mFrame = aFrame;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::CantRenderReplacedElement(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2000-06-05 07:37:33 +04:00
|
|
|
#ifdef NOISY_EVENTS
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("%p FrameManager::CantRenderReplacedElement called\n", this);
|
2000-06-05 07:37:33 +04:00
|
|
|
#endif
|
1999-08-06 00:17:44 +04:00
|
|
|
|
|
|
|
// We need to notify the style stystem, but post the notification so it
|
|
|
|
// doesn't happen now
|
2001-04-24 04:05:33 +04:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIEventQueueService> eventService = do_GetService(kEventQueueServiceCID, &rv);
|
|
|
|
|
|
|
|
if (eventService) {
|
1999-08-06 00:17:44 +04:00
|
|
|
nsCOMPtr<nsIEventQueue> eventQueue;
|
1999-11-30 03:32:43 +03:00
|
|
|
rv = eventService->GetThreadEventQueue(NS_CURRENT_THREAD,
|
1999-08-06 00:17:44 +04:00
|
|
|
getter_AddRefs(eventQueue));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && eventQueue) {
|
|
|
|
// Verify that there isn't already a posted event associated with
|
2001-04-24 04:05:33 +04:00
|
|
|
// this frame.
|
|
|
|
if (*FindPostedEventFor(aFrame))
|
|
|
|
return NS_OK;
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
CantRenderReplacedElementEvent* ev;
|
|
|
|
|
|
|
|
// Create a new event
|
|
|
|
ev = new CantRenderReplacedElementEvent(this, aFrame);
|
|
|
|
|
|
|
|
// Add the event to our linked list of posted events
|
|
|
|
ev->mNext = mPostedEvents;
|
|
|
|
mPostedEvents = ev;
|
|
|
|
|
|
|
|
// Post the event
|
|
|
|
eventQueue->PostEvent(ev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
static void
|
|
|
|
DumpContext(nsIFrame* aFrame, nsIStyleContext* aContext)
|
|
|
|
{
|
|
|
|
if (aFrame) {
|
|
|
|
fputs("frame: ", stdout);
|
|
|
|
nsAutoString name;
|
1999-11-02 01:12:45 +03:00
|
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
|
2000-02-03 01:24:56 +03:00
|
|
|
if (NS_SUCCEEDED(aFrame->QueryInterface(NS_GET_IID(nsIFrameDebug), (void**)&frameDebug))) {
|
1999-11-02 01:12:45 +03:00
|
|
|
frameDebug->GetFrameName(name);
|
2001-10-16 07:53:44 +04:00
|
|
|
fputs(NS_LossyConvertUCS2toASCII(name).get(), stdout);
|
1999-11-02 01:12:45 +03:00
|
|
|
}
|
2001-03-06 04:46:03 +03:00
|
|
|
fprintf(stdout, " (%p)", NS_STATIC_CAST(void*, aFrame));
|
1999-09-21 11:53:14 +04:00
|
|
|
}
|
|
|
|
if (aContext) {
|
2001-03-06 04:46:03 +03:00
|
|
|
fprintf(stdout, " style: %p ", NS_STATIC_CAST(void*, aContext));
|
1999-09-21 11:53:14 +04:00
|
|
|
|
|
|
|
nsIAtom* pseudoTag;
|
|
|
|
aContext->GetPseudoType(pseudoTag);
|
|
|
|
if (pseudoTag) {
|
|
|
|
nsAutoString buffer;
|
|
|
|
pseudoTag->ToString(buffer);
|
2001-10-16 07:53:44 +04:00
|
|
|
fputs(NS_LossyConvertUCS2toASCII(buffer).get(), stdout);
|
1999-09-21 11:53:14 +04:00
|
|
|
fputs(" ", stdout);
|
|
|
|
NS_RELEASE(pseudoTag);
|
|
|
|
}
|
|
|
|
|
2001-10-24 04:01:09 +04:00
|
|
|
/* XXXdwh fix debugging here. Need to add a List method to nsRuleNode
|
2001-06-01 02:19:43 +04:00
|
|
|
and have the context call list on its rule node.
|
1999-09-21 11:53:14 +04:00
|
|
|
PRInt32 count = aContext->GetStyleRuleCount();
|
|
|
|
if (0 < count) {
|
|
|
|
fputs("{\n", stdout);
|
|
|
|
nsISupportsArray* rules = aContext->GetStyleRules();
|
|
|
|
PRInt32 ix;
|
|
|
|
for (ix = 0; ix < count; ix++) {
|
|
|
|
nsIStyleRule* rule = (nsIStyleRule*)rules->ElementAt(ix);
|
|
|
|
rule->List(stdout, 1);
|
|
|
|
NS_RELEASE(rule);
|
|
|
|
}
|
|
|
|
NS_RELEASE(rules);
|
|
|
|
fputs("}\n", stdout);
|
|
|
|
}
|
2001-06-01 02:19:43 +04:00
|
|
|
else
|
|
|
|
*/
|
|
|
|
{
|
1999-09-21 11:53:14 +04:00
|
|
|
fputs("{}\n", stdout);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-03-16 18:26:56 +03:00
|
|
|
static void
|
|
|
|
VerifySameTree(nsIStyleContext* aContext1, nsIStyleContext* aContext2)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIStyleContext> top1 = aContext1;
|
|
|
|
nsCOMPtr<nsIStyleContext> top2 = aContext2;
|
|
|
|
nsCOMPtr<nsIStyleContext> parent;
|
|
|
|
for (;;) {
|
|
|
|
parent = dont_AddRef(top1->GetParent());
|
|
|
|
if (!parent)
|
|
|
|
break;
|
|
|
|
top1 = parent;
|
|
|
|
}
|
|
|
|
for (;;) {
|
|
|
|
parent = dont_AddRef(top2->GetParent());
|
|
|
|
if (!parent)
|
|
|
|
break;
|
|
|
|
top2 = parent;
|
|
|
|
}
|
|
|
|
if (top1 != top2)
|
|
|
|
printf("Style contexts are not in the same style context tree.\n");
|
|
|
|
}
|
|
|
|
|
2000-09-13 02:47:09 +04:00
|
|
|
static void
|
|
|
|
VerifyContextParent(nsIPresContext* aPresContext, nsIFrame* aFrame,
|
|
|
|
nsIStyleContext* aContext, nsIStyleContext* aParentContext)
|
|
|
|
{
|
|
|
|
nsIAtom* frameType;
|
|
|
|
|
|
|
|
// get the contexts not provided
|
|
|
|
if (!aContext) {
|
|
|
|
aFrame->GetStyleContext(&aContext);
|
|
|
|
} else {
|
|
|
|
// addref here so we can release at end
|
|
|
|
NS_ADDREF(aContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aParentContext) {
|
|
|
|
// Get the correct parent context from the frame
|
|
|
|
// - if the frame is a placeholder, we get the out of flow frame's context
|
|
|
|
// as the parent context instead of asking the frame
|
|
|
|
aFrame->GetFrameType(&frameType);
|
|
|
|
if (nsLayoutAtoms::placeholderFrame == frameType) { // placeholder
|
|
|
|
// get out of flow frame's context as the parent context
|
|
|
|
nsIFrame* outOfFlowFrame = ((nsPlaceholderFrame*)aFrame)->GetOutOfFlowFrame();
|
|
|
|
NS_ASSERTION(outOfFlowFrame, "no out-of-flow frame");
|
|
|
|
outOfFlowFrame->GetStyleContext(&aParentContext);
|
|
|
|
} else {
|
|
|
|
// get the parent context from the frame (indirectly)
|
|
|
|
nsIFrame* providerFrame = nsnull;
|
2002-03-12 18:21:35 +03:00
|
|
|
aFrame->GetStyleContextProvider(aPresContext, &providerFrame);
|
|
|
|
ENSURE_TRUE(providerFrame);
|
|
|
|
nsCOMPtr<nsIStyleContext> providerContext;
|
|
|
|
providerFrame->GetStyleContext(getter_AddRefs(providerContext));
|
|
|
|
ENSURE_TRUE(providerContext);
|
|
|
|
aParentContext = providerContext->GetParent(); // released later
|
|
|
|
// aParentContext could still be null, since some contexts don't have parents
|
2000-09-13 02:47:09 +04:00
|
|
|
}
|
|
|
|
NS_IF_RELEASE(frameType);
|
|
|
|
} else {
|
|
|
|
// addref the parent context so we can release it at end
|
|
|
|
NS_ADDREF(aParentContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ASSERTION(aContext, "Failure to get required contexts");
|
|
|
|
nsIStyleContext* actualParentContext = aContext->GetParent();
|
|
|
|
|
|
|
|
if (aParentContext) {
|
|
|
|
if (aParentContext != actualParentContext) {
|
|
|
|
DumpContext(aFrame, aContext);
|
|
|
|
if (aContext == aParentContext) {
|
|
|
|
fputs("Using parent's style context\n\n", stdout);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fputs("Wrong parent style context: ", stdout);
|
|
|
|
DumpContext(nsnull, actualParentContext);
|
|
|
|
fputs("should be using: ", stdout);
|
|
|
|
DumpContext(nsnull, aParentContext);
|
2002-03-16 18:26:56 +03:00
|
|
|
VerifySameTree(actualParentContext, aParentContext);
|
2000-09-13 02:47:09 +04:00
|
|
|
fputs("\n", stdout);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (actualParentContext) {
|
|
|
|
DumpContext(aFrame, aContext);
|
|
|
|
fputs("Has parent context: ", stdout);
|
|
|
|
DumpContext(nsnull, actualParentContext);
|
|
|
|
fputs("Should be null\n\n", stdout);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IF_RELEASE(actualParentContext);
|
|
|
|
NS_IF_RELEASE(aParentContext);
|
|
|
|
NS_IF_RELEASE(aContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
VerifyStyleTree(nsIPresContext* aPresContext, nsIFrame* aFrame, nsIStyleContext* aParentContext)
|
|
|
|
{
|
|
|
|
nsIStyleContext* context;
|
|
|
|
aFrame->GetStyleContext(&context);
|
|
|
|
|
|
|
|
VerifyContextParent(aPresContext, aFrame, context, aParentContext);
|
|
|
|
|
|
|
|
PRInt32 listIndex = 0;
|
|
|
|
nsIAtom* childList = nsnull;
|
|
|
|
nsIFrame* child;
|
|
|
|
nsIAtom* frameType;
|
|
|
|
|
|
|
|
do {
|
|
|
|
child = nsnull;
|
|
|
|
nsresult result = aFrame->FirstChild(aPresContext, childList, &child);
|
|
|
|
while ((NS_SUCCEEDED(result)) && child) {
|
|
|
|
nsFrameState state;
|
|
|
|
child->GetFrameState(&state);
|
|
|
|
if (NS_FRAME_OUT_OF_FLOW != (state & NS_FRAME_OUT_OF_FLOW)) {
|
|
|
|
// only do frames that are in flow
|
|
|
|
child->GetFrameType(&frameType);
|
|
|
|
if (nsLayoutAtoms::placeholderFrame == frameType) {
|
|
|
|
// placeholder: first recirse and verify the out of flow frame,
|
|
|
|
// then verify the placeholder's context
|
|
|
|
nsIFrame* outOfFlowFrame = ((nsPlaceholderFrame*)child)->GetOutOfFlowFrame();
|
|
|
|
NS_ASSERTION(outOfFlowFrame, "no out-of-flow frame");
|
|
|
|
nsIStyleContext* outOfFlowContext;
|
|
|
|
|
|
|
|
// recurse to out of flow frame, letting the parent context get resolved
|
|
|
|
VerifyStyleTree(aPresContext, outOfFlowFrame, nsnull);
|
|
|
|
|
|
|
|
// verify placeholder using the out of flow's context as parent context
|
|
|
|
outOfFlowFrame->GetStyleContext(&outOfFlowContext);
|
|
|
|
VerifyContextParent(aPresContext,child, nsnull, outOfFlowContext);
|
|
|
|
NS_IF_RELEASE(outOfFlowContext);
|
|
|
|
}
|
|
|
|
else { // regular frame
|
|
|
|
VerifyStyleTree(aPresContext, child, nsnull);
|
|
|
|
}
|
|
|
|
NS_IF_RELEASE(frameType);
|
|
|
|
}
|
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IF_RELEASE(childList);
|
|
|
|
aFrame->GetAdditionalChildListName(listIndex++, &childList);
|
|
|
|
} while (childList);
|
|
|
|
|
|
|
|
// do additional contexts
|
|
|
|
PRInt32 contextIndex = -1;
|
|
|
|
while (1 == 1) {
|
|
|
|
nsIStyleContext* extraContext = nsnull;
|
|
|
|
aFrame->GetAdditionalStyleContext(++contextIndex, &extraContext);
|
|
|
|
if (extraContext) {
|
|
|
|
VerifyContextParent(aPresContext, aFrame, extraContext, context);
|
|
|
|
NS_RELEASE(extraContext);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_RELEASE(context);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::DebugVerifyStyleTree(nsIPresContext* aPresContext, nsIFrame* aFrame)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2000-09-13 02:47:09 +04:00
|
|
|
if (aFrame) {
|
|
|
|
nsIStyleContext* context;
|
|
|
|
aFrame->GetStyleContext(&context);
|
|
|
|
nsIStyleContext* parentContext = context->GetParent();
|
|
|
|
VerifyStyleTree(aPresContext, aFrame, parentContext);
|
|
|
|
NS_IF_RELEASE(parentContext);
|
|
|
|
NS_RELEASE(context);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // DEBUG
|
1999-09-21 11:53:14 +04:00
|
|
|
|
1999-09-04 03:35:41 +04:00
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::ReParentStyleContext(nsIPresContext* aPresContext,
|
1999-09-04 03:35:41 +04:00
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsIStyleContext* aNewParentContext)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-09-04 03:35:41 +04:00
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (aFrame) {
|
1999-09-21 11:53:14 +04:00
|
|
|
#ifdef NS_DEBUG
|
2000-01-22 04:16:50 +03:00
|
|
|
DebugVerifyStyleTree(aPresContext, aFrame);
|
1999-09-21 11:53:14 +04:00
|
|
|
#endif
|
|
|
|
|
1999-09-04 03:35:41 +04:00
|
|
|
nsIStyleContext* oldContext = nsnull;
|
|
|
|
aFrame->GetStyleContext(&oldContext);
|
|
|
|
|
|
|
|
if (oldContext) {
|
|
|
|
nsIStyleContext* newContext = nsnull;
|
1999-11-24 09:03:41 +03:00
|
|
|
result = mStyleSet->ReParentStyleContext(aPresContext,
|
1999-09-04 03:35:41 +04:00
|
|
|
oldContext, aNewParentContext,
|
|
|
|
&newContext);
|
|
|
|
if (NS_SUCCEEDED(result) && newContext) {
|
|
|
|
if (newContext != oldContext) {
|
|
|
|
PRInt32 listIndex = 0;
|
|
|
|
nsIAtom* childList = nsnull;
|
|
|
|
nsIFrame* child;
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIAtom* frameType;
|
1999-09-04 03:35:41 +04:00
|
|
|
|
|
|
|
do {
|
|
|
|
child = nsnull;
|
2000-01-22 04:16:50 +03:00
|
|
|
result = aFrame->FirstChild(aPresContext, childList, &child);
|
1999-09-04 03:35:41 +04:00
|
|
|
while ((NS_SUCCEEDED(result)) && child) {
|
1999-09-21 11:53:14 +04:00
|
|
|
nsFrameState state;
|
|
|
|
child->GetFrameState(&state);
|
|
|
|
if (NS_FRAME_OUT_OF_FLOW != (state & NS_FRAME_OUT_OF_FLOW)) {
|
|
|
|
// only do frames that are in flow
|
|
|
|
child->GetFrameType(&frameType);
|
|
|
|
if (nsLayoutAtoms::placeholderFrame == frameType) { // placeholder
|
|
|
|
// get out of flow frame and recurse there
|
|
|
|
nsIFrame* outOfFlowFrame = ((nsPlaceholderFrame*)child)->GetOutOfFlowFrame();
|
|
|
|
NS_ASSERTION(outOfFlowFrame, "no out-of-flow frame");
|
|
|
|
|
|
|
|
result = ReParentStyleContext(aPresContext, outOfFlowFrame, newContext);
|
|
|
|
|
|
|
|
// reparent placeholder's context under out of flow frame
|
|
|
|
nsIStyleContext* outOfFlowContext;
|
|
|
|
outOfFlowFrame->GetStyleContext(&outOfFlowContext);
|
|
|
|
ReParentStyleContext(aPresContext, child, outOfFlowContext);
|
|
|
|
NS_RELEASE(outOfFlowContext);
|
|
|
|
}
|
|
|
|
else { // regular frame
|
|
|
|
result = ReParentStyleContext(aPresContext, child, newContext);
|
|
|
|
}
|
|
|
|
NS_IF_RELEASE(frameType);
|
|
|
|
}
|
|
|
|
|
1999-09-04 03:35:41 +04:00
|
|
|
child->GetNextSibling(&child);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IF_RELEASE(childList);
|
|
|
|
aFrame->GetAdditionalChildListName(listIndex++, &childList);
|
|
|
|
} while (childList);
|
|
|
|
|
1999-11-24 09:03:41 +03:00
|
|
|
aFrame->SetStyleContext(aPresContext, newContext);
|
1999-09-04 03:35:41 +04:00
|
|
|
|
|
|
|
// do additional contexts
|
|
|
|
PRInt32 contextIndex = -1;
|
|
|
|
while (1 == 1) {
|
|
|
|
nsIStyleContext* oldExtraContext = nsnull;
|
1999-09-21 11:53:14 +04:00
|
|
|
result = aFrame->GetAdditionalStyleContext(++contextIndex, &oldExtraContext);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
if (oldExtraContext) {
|
|
|
|
nsIStyleContext* newExtraContext = nsnull;
|
1999-11-24 09:03:41 +03:00
|
|
|
result = mStyleSet->ReParentStyleContext(aPresContext,
|
1999-09-21 11:53:14 +04:00
|
|
|
oldExtraContext, newContext,
|
|
|
|
&newExtraContext);
|
|
|
|
if (NS_SUCCEEDED(result) && newExtraContext) {
|
|
|
|
aFrame->SetAdditionalStyleContext(contextIndex, newExtraContext);
|
|
|
|
NS_RELEASE(newExtraContext);
|
|
|
|
}
|
|
|
|
NS_RELEASE(oldExtraContext);
|
1999-09-04 03:35:41 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
1999-09-21 11:53:14 +04:00
|
|
|
result = NS_OK; // ok not to have extras (or run out)
|
1999-09-04 03:35:41 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
#ifdef NS_DEBUG
|
2000-01-22 04:16:50 +03:00
|
|
|
VerifyStyleTree(aPresContext, aFrame, aNewParentContext);
|
1999-09-21 11:53:14 +04:00
|
|
|
#endif
|
1999-09-04 03:35:41 +04:00
|
|
|
}
|
|
|
|
NS_RELEASE(newContext);
|
|
|
|
}
|
|
|
|
NS_RELEASE(oldContext);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-10-16 03:14:44 +04:00
|
|
|
static PRBool
|
|
|
|
HasAttributeContent(nsIStyleContext* aStyleContext,
|
|
|
|
PRInt32 aNameSpaceID,
|
|
|
|
nsIAtom* aAttribute)
|
|
|
|
{
|
|
|
|
PRBool result = PR_FALSE;
|
|
|
|
if (aStyleContext) {
|
|
|
|
const nsStyleContent* content = (const nsStyleContent*)aStyleContext->GetStyleData(eStyleStruct_Content);
|
|
|
|
PRUint32 count = content->ContentCount();
|
|
|
|
while ((0 < count) && (! result)) {
|
|
|
|
nsStyleContentType contentType;
|
|
|
|
nsAutoString contentString;
|
|
|
|
content->GetContentAt(--count, contentType, contentString);
|
|
|
|
if (eStyleContentType_Attr == contentType) {
|
|
|
|
nsIAtom* attrName = nsnull;
|
|
|
|
PRInt32 attrNameSpace = kNameSpaceID_None;
|
|
|
|
PRInt32 barIndex = contentString.FindChar('|'); // CSS namespace delimiter
|
|
|
|
if (-1 != barIndex) {
|
|
|
|
nsAutoString nameSpaceVal;
|
|
|
|
contentString.Left(nameSpaceVal, barIndex);
|
|
|
|
PRInt32 error;
|
|
|
|
attrNameSpace = nameSpaceVal.ToInteger(&error, 10);
|
|
|
|
contentString.Cut(0, barIndex + 1);
|
|
|
|
if (contentString.Length()) {
|
|
|
|
attrName = NS_NewAtom(contentString);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
attrName = NS_NewAtom(contentString);
|
|
|
|
}
|
|
|
|
if ((attrName == aAttribute) &&
|
|
|
|
((attrNameSpace == aNameSpaceID) ||
|
|
|
|
(attrNameSpace == kNameSpaceID_Unknown))) {
|
|
|
|
result = PR_TRUE;
|
|
|
|
}
|
|
|
|
NS_IF_RELEASE(attrName);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
static PRInt32
|
|
|
|
CaptureChange(nsIStyleContext* aOldContext, nsIStyleContext* aNewContext,
|
1999-10-02 08:25:29 +04:00
|
|
|
nsIFrame* aFrame, nsIContent* aContent,
|
|
|
|
nsStyleChangeList& aChangeList, PRInt32 aMinChange)
|
1999-09-21 11:53:14 +04:00
|
|
|
{
|
|
|
|
PRInt32 ourChange = NS_STYLE_HINT_NONE;
|
2001-11-14 11:19:13 +03:00
|
|
|
aOldContext->CalcStyleDifference(aNewContext, ourChange);
|
1999-09-21 11:53:14 +04:00
|
|
|
if (aMinChange < ourChange) {
|
1999-10-02 08:25:29 +04:00
|
|
|
aChangeList.AppendChange(aFrame, aContent, ourChange);
|
1999-09-21 11:53:14 +04:00
|
|
|
aMinChange = ourChange;
|
|
|
|
}
|
|
|
|
return aMinChange;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::ReResolveStyleContext(nsIPresContext* aPresContext,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIFrame* aFrame,
|
2002-03-12 18:21:35 +03:00
|
|
|
nsIStyleContext* aParentContextIn,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIContent* aParentContent,
|
1999-10-16 03:14:44 +04:00
|
|
|
PRInt32 aAttrNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsStyleChangeList& aChangeList,
|
|
|
|
PRInt32 aMinChange,
|
|
|
|
PRInt32& aResultChange)
|
|
|
|
{
|
2002-03-16 18:26:56 +03:00
|
|
|
// XXXldb get new context from prev-in-flow if possible, to avoid
|
|
|
|
// duplication. (Or should we just let |GetContext| handle that?)
|
|
|
|
// Getting the hint would be nice too, but that's harder.
|
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIStyleContext* oldContext = nsnull;
|
|
|
|
nsresult result = aFrame->GetStyleContext(&oldContext);
|
|
|
|
if (NS_SUCCEEDED(result) && oldContext) {
|
|
|
|
nsIAtom* pseudoTag = nsnull;
|
|
|
|
oldContext->GetPseudoType(pseudoTag);
|
|
|
|
nsIContent* localContent = nsnull;
|
|
|
|
nsIContent* content = nsnull;
|
|
|
|
result = aFrame->GetContent(&localContent);
|
|
|
|
if (NS_SUCCEEDED(result) && localContent) {
|
|
|
|
content = localContent;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
content = aParentContent;
|
|
|
|
}
|
1999-10-16 03:14:44 +04:00
|
|
|
if (aParentContent && aAttribute) { // attribute came from parent, we don't care about it here when recursing
|
|
|
|
nsFrameState frameState;
|
|
|
|
aFrame->GetFrameState(&frameState);
|
|
|
|
if (0 == (frameState & NS_FRAME_GENERATED_CONTENT)) { // keep it for generated content
|
|
|
|
aAttribute = nsnull;
|
|
|
|
}
|
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
|
2002-03-12 18:21:35 +03:00
|
|
|
nsCOMPtr<nsIStyleContext> parentContext;
|
|
|
|
nsIFrame* resolvedDescendant = nsnull;
|
|
|
|
// Get the frame providing the style context. If it differs from aFrame, then
|
|
|
|
// reslove the provider first, since the provider's context is the parent of aFrame's
|
|
|
|
nsIFrame* providerFrame = nsnull;
|
|
|
|
aFrame->GetStyleContextProvider(aPresContext, &providerFrame);
|
|
|
|
ENSURE_TRUE(providerFrame);
|
|
|
|
if (providerFrame == aFrame) {
|
|
|
|
if (aParentContextIn) {
|
|
|
|
parentContext = aParentContextIn;
|
|
|
|
NOISY_TRACE_FRAME("non-null parent context provided: using it and assuming already resolved",aFrame);
|
|
|
|
} else {
|
|
|
|
nsIFrame* parentFrame;
|
|
|
|
aFrame->GetParent(&parentFrame);
|
|
|
|
if (parentFrame) {
|
|
|
|
parentFrame->GetStyleContext(getter_AddRefs(parentContext));
|
2002-03-10 09:16:01 +03:00
|
|
|
}
|
2000-09-13 02:47:09 +04:00
|
|
|
}
|
2002-03-12 18:21:35 +03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
#ifdef DEBUG
|
|
|
|
// check to make sure that the provider is the child of aFrame
|
|
|
|
nsIFrame* providerFrameParent;
|
|
|
|
providerFrame->GetParent(&providerFrameParent);
|
|
|
|
NS_ASSERTION(providerFrameParent == aFrame, "invalid style context provider");
|
|
|
|
#endif
|
|
|
|
// resolve the provider here (before aFrame below)
|
|
|
|
nsCOMPtr<nsIStyleContext> providerContextParent;
|
|
|
|
nsIFrame* grandParentFrame;
|
|
|
|
aFrame->GetParent(&grandParentFrame);
|
|
|
|
if (grandParentFrame) {
|
|
|
|
grandParentFrame->GetStyleContext(getter_AddRefs(providerContextParent));
|
|
|
|
}
|
|
|
|
ReResolveStyleContext(aPresContext, providerFrame, providerContextParent, content,
|
|
|
|
aAttrNameSpaceID, aAttribute, aChangeList, aMinChange, aResultChange);
|
|
|
|
// the provider's new context becomes the parent context of aFrame's context
|
|
|
|
providerFrame->GetStyleContext(getter_AddRefs(parentContext));
|
|
|
|
resolvedDescendant = providerFrame; // don't want to re-resolve the provider again
|
2000-09-13 02:47:09 +04:00
|
|
|
}
|
2001-12-18 01:51:39 +03:00
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
// do primary context
|
|
|
|
nsIStyleContext* newContext = nsnull;
|
|
|
|
if (pseudoTag) {
|
2002-03-12 18:21:35 +03:00
|
|
|
nsIContent* pseudoContent = (aParentContent) ? aParentContent : localContent;
|
|
|
|
aPresContext->ResolvePseudoStyleContextFor(pseudoContent, pseudoTag, parentContext,
|
|
|
|
PR_FALSE, &newContext);
|
2002-03-10 09:16:01 +03:00
|
|
|
NS_RELEASE(pseudoTag);
|
1999-09-21 11:53:14 +04:00
|
|
|
}
|
|
|
|
else {
|
2001-11-02 07:14:58 +03:00
|
|
|
NS_ASSERTION(localContent,
|
|
|
|
"non pseudo-element frame without content node");
|
|
|
|
// XXX This frame type check is a little ugly. However, it should
|
|
|
|
// be cheaper than doing useless style resolution on placeholder
|
|
|
|
// frames, and it should be able to go away if we make it so that
|
|
|
|
// placeholder frames don't have style contexts at all.
|
|
|
|
//
|
|
|
|
// XXX We also probably need to descend into the style contexts of
|
|
|
|
// the placeholder's out-of-flow frame.
|
|
|
|
nsCOMPtr<nsIAtom> frameType;
|
|
|
|
aFrame->GetFrameType(getter_AddRefs(frameType));
|
|
|
|
if (content->IsContentOfType(nsIContent::eELEMENT) &&
|
|
|
|
frameType != nsLayoutAtoms::placeholderFrame) {
|
2002-03-12 18:21:35 +03:00
|
|
|
aPresContext->ResolveStyleContextFor(content, parentContext,
|
2001-10-30 09:02:05 +03:00
|
|
|
PR_TRUE, &newContext);
|
|
|
|
} else {
|
2002-03-12 18:21:35 +03:00
|
|
|
aPresContext->ResolveStyleContextForNonElement(parentContext,
|
2001-10-30 09:02:05 +03:00
|
|
|
PR_TRUE, &newContext);
|
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
}
|
|
|
|
NS_ASSERTION(newContext, "failed to get new style context");
|
|
|
|
if (newContext) {
|
|
|
|
if (newContext != oldContext) {
|
1999-10-02 08:25:29 +04:00
|
|
|
aMinChange = CaptureChange(oldContext, newContext, aFrame, content, aChangeList, aMinChange);
|
1999-09-25 09:00:41 +04:00
|
|
|
if (aMinChange < NS_STYLE_HINT_FRAMECHANGE) { // if frame gets regenerated, let it keep old context
|
1999-11-24 09:03:41 +03:00
|
|
|
aFrame->SetStyleContext(aPresContext, newContext);
|
1999-09-25 09:00:41 +04:00
|
|
|
}
|
2000-02-16 05:49:01 +03:00
|
|
|
// if old context had image and new context does not have the same image,
|
|
|
|
// stop the image load for the frame
|
2001-06-01 02:19:43 +04:00
|
|
|
const nsStyleBackground* oldColor = (const nsStyleBackground*)oldContext->GetStyleData(eStyleStruct_Background);
|
|
|
|
const nsStyleBackground* newColor = (const nsStyleBackground*)newContext->GetStyleData(eStyleStruct_Background);
|
|
|
|
|
|
|
|
if(oldColor->mBackgroundImage.Length() > 0 &&
|
|
|
|
oldColor->mBackgroundImage != newColor->mBackgroundImage ){
|
2000-02-16 05:49:01 +03:00
|
|
|
// stop the image loading for the frame, the image has changed
|
2001-08-10 00:22:39 +04:00
|
|
|
aPresContext->StopImagesFor(aFrame);
|
2000-02-16 05:49:01 +03:00
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
}
|
1999-09-29 07:32:19 +04:00
|
|
|
else {
|
2001-07-25 10:33:06 +04:00
|
|
|
// XXXdwh figure this out.
|
|
|
|
// oldContext->RemapStyle(aPresContext, PR_FALSE);
|
1999-10-16 03:14:44 +04:00
|
|
|
if (aAttribute && (aMinChange < NS_STYLE_HINT_REFLOW) &&
|
|
|
|
HasAttributeContent(oldContext, aAttrNameSpaceID, aAttribute)) {
|
1999-12-02 12:19:16 +03:00
|
|
|
aChangeList.AppendChange(aFrame, content, NS_STYLE_HINT_REFLOW);
|
1999-10-16 03:14:44 +04:00
|
|
|
}
|
1999-09-29 07:32:19 +04:00
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
NS_RELEASE(oldContext);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
NS_ERROR("resolve style context failed");
|
|
|
|
newContext = oldContext; // new context failed, recover... (take ref)
|
|
|
|
}
|
|
|
|
|
|
|
|
// do additional contexts
|
|
|
|
PRInt32 contextIndex = -1;
|
|
|
|
while (1 == 1) {
|
|
|
|
nsIStyleContext* oldExtraContext = nsnull;
|
|
|
|
result = aFrame->GetAdditionalStyleContext(++contextIndex, &oldExtraContext);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
if (oldExtraContext) {
|
|
|
|
nsIStyleContext* newExtraContext = nsnull;
|
|
|
|
oldExtraContext->GetPseudoType(pseudoTag);
|
|
|
|
NS_ASSERTION(pseudoTag, "extra style context is not pseudo element");
|
1999-11-24 09:03:41 +03:00
|
|
|
result = aPresContext->ResolvePseudoStyleContextFor(content, pseudoTag, newContext,
|
1999-09-21 11:53:14 +04:00
|
|
|
PR_FALSE, &newExtraContext);
|
|
|
|
NS_RELEASE(pseudoTag);
|
|
|
|
if (NS_SUCCEEDED(result) && newExtraContext) {
|
|
|
|
if (oldExtraContext != newExtraContext) {
|
|
|
|
aMinChange = CaptureChange(oldExtraContext, newExtraContext, aFrame,
|
1999-10-02 08:25:29 +04:00
|
|
|
content, aChangeList, aMinChange);
|
1999-09-25 09:00:41 +04:00
|
|
|
if (aMinChange < NS_STYLE_HINT_FRAMECHANGE) {
|
|
|
|
aFrame->SetAdditionalStyleContext(contextIndex, newExtraContext);
|
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
}
|
1999-10-02 08:25:29 +04:00
|
|
|
else {
|
2001-07-25 10:33:06 +04:00
|
|
|
// XXXdwh figure this out.
|
|
|
|
// oldExtraContext->RemapStyle(aPresContext, PR_FALSE);
|
1999-10-16 03:14:44 +04:00
|
|
|
if (aAttribute && (aMinChange < NS_STYLE_HINT_REFLOW) &&
|
|
|
|
HasAttributeContent(oldContext, aAttrNameSpaceID, aAttribute)) {
|
1999-12-02 12:19:16 +03:00
|
|
|
aChangeList.AppendChange(aFrame, content, NS_STYLE_HINT_REFLOW);
|
1999-10-16 03:14:44 +04:00
|
|
|
}
|
1999-10-02 08:25:29 +04:00
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
NS_RELEASE(newExtraContext);
|
|
|
|
}
|
|
|
|
NS_RELEASE(oldExtraContext);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-10-02 08:25:29 +04:00
|
|
|
// now look for undisplayed child content and pseudos
|
1999-10-02 23:45:18 +04:00
|
|
|
if (localContent && mUndisplayedMap) {
|
1999-10-02 08:25:29 +04:00
|
|
|
UndisplayedNode* undisplayed = mUndisplayedMap->GetFirstNode(localContent);
|
|
|
|
while (undisplayed) {
|
|
|
|
nsIStyleContext* undisplayedContext = nsnull;
|
2000-01-28 18:03:00 +03:00
|
|
|
undisplayed->mStyle->GetPseudoType(pseudoTag);
|
|
|
|
if (undisplayed->mContent && pseudoTag == nsnull) { // child content
|
1999-11-24 09:03:41 +03:00
|
|
|
aPresContext->ResolveStyleContextFor(undisplayed->mContent, newContext,
|
2000-12-22 01:16:38 +03:00
|
|
|
PR_TRUE, &undisplayedContext);
|
1999-10-02 08:25:29 +04:00
|
|
|
}
|
|
|
|
else { // pseudo element
|
|
|
|
NS_ASSERTION(pseudoTag, "pseudo element without tag");
|
1999-11-24 09:03:41 +03:00
|
|
|
aPresContext->ResolvePseudoStyleContextFor(localContent, pseudoTag, newContext, PR_FALSE,
|
1999-10-02 08:25:29 +04:00
|
|
|
&undisplayedContext);
|
|
|
|
}
|
2000-01-28 18:03:00 +03:00
|
|
|
NS_IF_RELEASE(pseudoTag);
|
1999-10-02 08:25:29 +04:00
|
|
|
if (undisplayedContext) {
|
|
|
|
if (undisplayedContext == undisplayed->mStyle) {
|
2001-07-25 10:33:06 +04:00
|
|
|
// XXXdwh figure this out.
|
|
|
|
// undisplayedContext->RemapStyle(aPresContext);
|
1999-10-02 08:25:29 +04:00
|
|
|
}
|
|
|
|
const nsStyleDisplay* display =
|
|
|
|
(const nsStyleDisplay*)undisplayedContext->GetStyleData(eStyleStruct_Display);
|
|
|
|
if (display->mDisplay != NS_STYLE_DISPLAY_NONE) {
|
|
|
|
aChangeList.AppendChange(nsnull, ((undisplayed->mContent) ? undisplayed->mContent : localContent),
|
1999-12-02 12:19:16 +03:00
|
|
|
NS_STYLE_HINT_FRAMECHANGE);
|
1999-10-02 08:25:29 +04:00
|
|
|
}
|
|
|
|
NS_RELEASE(undisplayedContext);
|
|
|
|
}
|
|
|
|
undisplayed = undisplayed->mNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
aResultChange = aMinChange;
|
|
|
|
|
2001-12-18 01:51:39 +03:00
|
|
|
if (aMinChange < NS_STYLE_HINT_FRAMECHANGE) {
|
|
|
|
// There is no need to waste time crawling into a frame's children on a frame change.
|
|
|
|
// The act of reconstructing frames will force new style contexts to be resolved on all
|
|
|
|
// of this frame's descendants anyway, so we want to avoid wasting time processing
|
|
|
|
// style contexts that we're just going to throw away anyway. - dwh
|
|
|
|
|
|
|
|
// now do children
|
|
|
|
PRInt32 listIndex = 0;
|
|
|
|
nsIAtom* childList = nsnull;
|
|
|
|
PRInt32 childChange;
|
|
|
|
nsIFrame* child;
|
|
|
|
|
|
|
|
do {
|
|
|
|
child = nsnull;
|
|
|
|
result = aFrame->FirstChild(aPresContext, childList, &child);
|
|
|
|
while ((NS_SUCCEEDED(result)) && (child)) {
|
|
|
|
nsFrameState state;
|
|
|
|
child->GetFrameState(&state);
|
|
|
|
if (NS_FRAME_OUT_OF_FLOW != (state & NS_FRAME_OUT_OF_FLOW)) {
|
|
|
|
// only do frames that are in flow
|
|
|
|
nsCOMPtr<nsIAtom> frameType;
|
|
|
|
child->GetFrameType(getter_AddRefs(frameType));
|
|
|
|
if (nsLayoutAtoms::placeholderFrame == frameType.get()) { // placeholder
|
|
|
|
// get out of flow frame and recurse there
|
|
|
|
nsIFrame* outOfFlowFrame = ((nsPlaceholderFrame*)child)->GetOutOfFlowFrame();
|
|
|
|
NS_ASSERTION(outOfFlowFrame, "no out-of-flow frame");
|
|
|
|
|
|
|
|
if (outOfFlowFrame != resolvedDescendant) {
|
|
|
|
ReResolveStyleContext(aPresContext, outOfFlowFrame, nsnull, content,
|
|
|
|
aAttrNameSpaceID, aAttribute,
|
|
|
|
aChangeList, aMinChange, childChange);
|
|
|
|
} else {
|
|
|
|
NOISY_TRACE("out of flow frame already resolved as descendent\n");
|
|
|
|
}
|
2000-09-13 02:47:09 +04:00
|
|
|
|
2001-12-18 01:51:39 +03:00
|
|
|
// reresolve placeholder's context under out of flow frame
|
|
|
|
nsIStyleContext* outOfFlowContext;
|
|
|
|
outOfFlowFrame->GetStyleContext(&outOfFlowContext);
|
|
|
|
ReResolveStyleContext(aPresContext, child, outOfFlowContext, content,
|
|
|
|
kNameSpaceID_Unknown, nsnull,
|
2000-09-13 02:47:09 +04:00
|
|
|
aChangeList, aMinChange, childChange);
|
2001-12-18 01:51:39 +03:00
|
|
|
NS_RELEASE(outOfFlowContext);
|
|
|
|
}
|
|
|
|
else { // regular child frame
|
|
|
|
if (child != resolvedDescendant) {
|
2002-03-10 09:16:01 +03:00
|
|
|
ReResolveStyleContext(aPresContext, child, nsnull, content,
|
2001-12-18 01:51:39 +03:00
|
|
|
aAttrNameSpaceID, aAttribute,
|
|
|
|
aChangeList, aMinChange, childChange);
|
|
|
|
} else {
|
|
|
|
NOISY_TRACE_FRAME("child frame already resolved as descendent, skipping",aFrame);
|
|
|
|
}
|
2000-09-13 02:47:09 +04:00
|
|
|
}
|
|
|
|
}
|
2001-12-18 01:51:39 +03:00
|
|
|
child->GetNextSibling(&child);
|
2000-09-13 02:47:09 +04:00
|
|
|
}
|
|
|
|
|
2001-12-18 01:51:39 +03:00
|
|
|
NS_IF_RELEASE(childList);
|
|
|
|
aFrame->GetAdditionalChildListName(listIndex++, &childList);
|
|
|
|
} while (childList);
|
|
|
|
// XXX need to do overflow frames???
|
|
|
|
}
|
2000-09-13 02:47:09 +04:00
|
|
|
|
|
|
|
NS_RELEASE(newContext);
|
|
|
|
NS_IF_RELEASE(localContent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-09-21 11:53:14 +04:00
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
FrameManager::ComputeStyleChangeFor(nsIPresContext* aPresContext,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsIFrame* aFrame,
|
1999-10-16 03:14:44 +04:00
|
|
|
PRInt32 aAttrNameSpaceID,
|
|
|
|
nsIAtom* aAttribute,
|
1999-09-21 11:53:14 +04:00
|
|
|
nsStyleChangeList& aChangeList,
|
|
|
|
PRInt32 aMinChange,
|
|
|
|
PRInt32& aTopLevelChange)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-09-21 11:53:14 +04:00
|
|
|
aTopLevelChange = NS_STYLE_HINT_NONE;
|
1999-10-16 03:14:44 +04:00
|
|
|
nsIFrame* frame = aFrame;
|
1999-09-21 11:53:14 +04:00
|
|
|
|
2002-03-16 18:26:56 +03:00
|
|
|
#ifdef DEBUG
|
|
|
|
{
|
|
|
|
nsIFrame* prevInFlow;
|
|
|
|
frame->GetPrevInFlow(&prevInFlow);
|
|
|
|
NS_ASSERTION(!prevInFlow, "must start with the first in flow");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-10-16 03:14:44 +04:00
|
|
|
do {
|
|
|
|
nsIStyleContext* styleContext = nsnull;
|
|
|
|
frame->GetStyleContext(&styleContext);
|
|
|
|
nsIStyleContext* parentContext = styleContext->GetParent();
|
|
|
|
PRInt32 frameChange;
|
|
|
|
ReResolveStyleContext(aPresContext, frame, parentContext, nsnull,
|
|
|
|
aAttrNameSpaceID, aAttribute,
|
|
|
|
aChangeList, aMinChange, frameChange);
|
1999-09-21 11:53:14 +04:00
|
|
|
#ifdef NS_DEBUG
|
2000-01-22 04:16:50 +03:00
|
|
|
VerifyStyleTree(aPresContext, frame, parentContext);
|
1999-09-21 11:53:14 +04:00
|
|
|
#endif
|
1999-10-16 03:14:44 +04:00
|
|
|
NS_IF_RELEASE(parentContext);
|
|
|
|
NS_RELEASE(styleContext);
|
|
|
|
if (aTopLevelChange < frameChange) {
|
|
|
|
aTopLevelChange = frameChange;
|
|
|
|
}
|
1999-09-21 11:53:14 +04:00
|
|
|
|
2002-02-16 19:31:49 +03:00
|
|
|
if (aTopLevelChange >= NS_STYLE_HINT_FRAMECHANGE) {
|
|
|
|
// If it's going to cause a framechange, then don't bother with
|
|
|
|
// the continutaions since they'll be clobbered by the frame
|
|
|
|
// reconstruct anyway.
|
2001-05-23 10:39:34 +04:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
nsIFrame* prevInFlow;
|
|
|
|
frame->GetPrevInFlow(&prevInFlow);
|
|
|
|
NS_ASSERTION(!prevInFlow, "continuing frame had more severe impact than first-in-flow");
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
1999-10-16 03:14:44 +04:00
|
|
|
frame->GetNextInFlow(&frame);
|
|
|
|
} while (frame);
|
1999-09-21 11:53:14 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-09-13 02:47:09 +04:00
|
|
|
|
2000-05-16 06:43:33 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::AttributeAffectsStyle(nsIAtom *aAttribute, nsIContent *aContent,
|
|
|
|
PRBool &aAffects)
|
|
|
|
{
|
2000-05-26 03:02:31 +04:00
|
|
|
nsresult rv = NS_OK;
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2000-05-26 03:02:31 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIXMLContent> xml(do_QueryInterface(aContent));
|
|
|
|
if (xml) {
|
|
|
|
rv = mStyleSet->AttributeAffectsStyle(aAttribute, aContent, aAffects);
|
|
|
|
} else {
|
|
|
|
// not an XML element, so assume it is an HTML element and further assume that
|
|
|
|
// any attribute may affect style
|
|
|
|
// NOTE: we could list all of the presentation-hint attributes and check them,
|
|
|
|
// but there are a lot of them and this is safer.
|
2000-05-17 02:05:47 +04:00
|
|
|
aAffects = PR_TRUE;
|
2000-05-26 03:02:31 +04:00
|
|
|
rv = NS_OK;
|
2000-05-17 02:05:47 +04:00
|
|
|
}
|
2000-05-26 03:02:31 +04:00
|
|
|
return rv;
|
2000-05-16 06:43:33 +04:00
|
|
|
}
|
1999-09-04 03:35:41 +04:00
|
|
|
|
2000-06-15 04:35:46 +04:00
|
|
|
// Capture state for a given frame.
|
|
|
|
// Accept a content id here, in some cases we may not have content (scroll position)
|
|
|
|
NS_IMETHODIMP
|
2001-05-30 15:26:21 +04:00
|
|
|
FrameManager::CaptureFrameStateFor(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsILayoutHistoryState* aState,
|
|
|
|
nsIStatefulFrame::SpecialStateID aID)
|
1999-08-31 18:35:50 +04:00
|
|
|
{
|
2001-05-30 15:26:21 +04:00
|
|
|
NS_ENSURE_TRUE(mPresShell && aFrame && aState, NS_ERROR_FAILURE);
|
1999-08-31 18:35:50 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Only capture state for stateful frames
|
1999-10-23 05:43:49 +04:00
|
|
|
nsIStatefulFrame* statefulFrame = nsnull;
|
2000-02-03 01:24:56 +03:00
|
|
|
aFrame->QueryInterface(NS_GET_IID(nsIStatefulFrame), (void**) &statefulFrame);
|
2001-05-30 15:26:21 +04:00
|
|
|
if (!statefulFrame) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Capture the state, exit early if we get null (nothing to save)
|
|
|
|
nsCOMPtr<nsIPresState> frameState;
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
rv = statefulFrame->SaveState(aPresContext, getter_AddRefs(frameState));
|
|
|
|
if (!frameState) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Generate the hash key to store the state under
|
|
|
|
// Exit early if we get empty key
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
rv = aFrame->GetContent(getter_AddRefs(content));
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
nsCAutoString stateKey;
|
|
|
|
rv = GenerateStateKey(content, aID, stateKey);
|
|
|
|
if(NS_FAILED(rv) || stateKey.IsEmpty()) {
|
|
|
|
return rv;
|
1999-08-31 18:35:50 +04:00
|
|
|
}
|
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Store the state
|
|
|
|
return aState->AddState(stateKey, frameState);
|
1999-10-23 05:43:49 +04:00
|
|
|
}
|
1999-08-31 18:35:50 +04:00
|
|
|
|
1999-10-23 05:43:49 +04:00
|
|
|
NS_IMETHODIMP
|
2001-05-30 15:26:21 +04:00
|
|
|
FrameManager::CaptureFrameState(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
nsILayoutHistoryState* aState)
|
1999-10-23 05:43:49 +04:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-23 05:43:49 +04:00
|
|
|
NS_PRECONDITION(nsnull != aFrame && nsnull != aState, "null parameters passed in");
|
1999-08-31 18:35:50 +04:00
|
|
|
|
1999-10-26 08:44:41 +04:00
|
|
|
rv = CaptureFrameStateFor(aPresContext, aFrame, aState);
|
1999-10-23 05:43:49 +04:00
|
|
|
|
|
|
|
// Now capture state recursively for the frame hierarchy rooted at aFrame
|
|
|
|
nsIAtom* childListName = nsnull;
|
|
|
|
PRInt32 childListIndex = 0;
|
|
|
|
do {
|
|
|
|
nsIFrame* childFrame;
|
2000-01-22 04:16:50 +03:00
|
|
|
aFrame->FirstChild(aPresContext, childListName, &childFrame);
|
1999-10-23 05:43:49 +04:00
|
|
|
while (childFrame) {
|
1999-10-26 08:44:41 +04:00
|
|
|
rv = CaptureFrameState(aPresContext, childFrame, aState);
|
1999-10-23 05:43:49 +04:00
|
|
|
// Get the next sibling child frame
|
|
|
|
childFrame->GetNextSibling(&childFrame);
|
|
|
|
}
|
|
|
|
NS_IF_RELEASE(childListName);
|
|
|
|
aFrame->GetAdditionalChildListName(childListIndex++, &childListName);
|
|
|
|
} while (childListName);
|
1999-08-31 18:35:50 +04:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-06-15 04:35:46 +04:00
|
|
|
// Restore state for a given frame.
|
|
|
|
// Accept a content id here, in some cases we may not have content (scroll position)
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::RestoreFrameStateFor(nsIPresContext* aPresContext, nsIFrame* aFrame, nsILayoutHistoryState* aState, nsIStatefulFrame::SpecialStateID aID)
|
1999-08-31 18:35:50 +04:00
|
|
|
{
|
2001-05-30 15:26:21 +04:00
|
|
|
NS_ENSURE_TRUE(mPresShell && aFrame && aState, NS_ERROR_FAILURE);
|
1999-08-31 18:35:50 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Only capture state for stateful frames
|
1999-10-23 05:43:49 +04:00
|
|
|
nsIStatefulFrame* statefulFrame = nsnull;
|
2000-02-03 01:24:56 +03:00
|
|
|
aFrame->QueryInterface(NS_GET_IID(nsIStatefulFrame), (void**) &statefulFrame);
|
2001-05-30 15:26:21 +04:00
|
|
|
if (!statefulFrame) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Generate the hash key the state was stored under
|
|
|
|
// Exit early if we get empty key
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
rv = aFrame->GetContent(getter_AddRefs(content));
|
2001-09-29 21:50:15 +04:00
|
|
|
// If we don't have content, we can't generate a hash
|
|
|
|
// key and there's probably no state information for us.
|
|
|
|
if (!content) {
|
|
|
|
return rv;
|
|
|
|
}
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
nsCAutoString stateKey;
|
|
|
|
rv = GenerateStateKey(content, aID, stateKey);
|
2001-11-02 10:40:01 +03:00
|
|
|
if (NS_FAILED(rv) || stateKey.IsEmpty()) {
|
2001-05-30 15:26:21 +04:00
|
|
|
return rv;
|
|
|
|
}
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Get the state from the hash
|
|
|
|
nsCOMPtr<nsIPresState> frameState;
|
|
|
|
rv = aState->GetState(stateKey, getter_AddRefs(frameState));
|
|
|
|
if (!frameState) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-06-15 04:35:46 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// Restore it
|
|
|
|
rv = statefulFrame->RestoreState(aPresContext, frameState);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
1999-08-31 18:35:50 +04:00
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// If we restore ok, remove the state from the state table
|
|
|
|
return aState->RemoveState(stateKey);
|
1999-10-23 05:43:49 +04:00
|
|
|
}
|
1999-08-31 18:35:50 +04:00
|
|
|
|
1999-10-23 05:43:49 +04:00
|
|
|
NS_IMETHODIMP
|
1999-10-26 08:44:41 +04:00
|
|
|
FrameManager::RestoreFrameState(nsIPresContext* aPresContext, nsIFrame* aFrame, nsILayoutHistoryState* aState)
|
1999-10-23 05:43:49 +04:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
1999-10-23 05:43:49 +04:00
|
|
|
NS_PRECONDITION(nsnull != aFrame && nsnull != aState, "null parameters passed in");
|
|
|
|
|
1999-10-26 08:44:41 +04:00
|
|
|
rv = RestoreFrameStateFor(aPresContext, aFrame, aState);
|
1999-10-23 05:43:49 +04:00
|
|
|
|
|
|
|
// Now restore state recursively for the frame hierarchy rooted at aFrame
|
|
|
|
nsIAtom* childListName = nsnull;
|
|
|
|
PRInt32 childListIndex = 0;
|
|
|
|
do {
|
|
|
|
nsIFrame* childFrame;
|
2000-01-22 04:16:50 +03:00
|
|
|
aFrame->FirstChild(aPresContext, childListName, &childFrame);
|
2001-05-30 15:26:21 +04:00
|
|
|
while (childFrame) {
|
1999-10-26 08:44:41 +04:00
|
|
|
rv = RestoreFrameState(aPresContext, childFrame, aState);
|
1999-10-23 05:43:49 +04:00
|
|
|
// Get the next sibling child frame
|
|
|
|
childFrame->GetNextSibling(&childFrame);
|
|
|
|
}
|
|
|
|
NS_IF_RELEASE(childListName);
|
|
|
|
aFrame->GetAdditionalChildListName(childListIndex++, &childListName);
|
|
|
|
} while (childListName);
|
1999-08-31 18:35:50 +04:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
|
|
|
|
static inline void KeyAppendSep(nsCString& aKey)
|
|
|
|
{
|
|
|
|
if (!aKey.IsEmpty()) {
|
|
|
|
aKey.Append(">");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void KeyAppendString(nsAReadableString& aString, nsCString& aKey)
|
|
|
|
{
|
|
|
|
KeyAppendSep(aKey);
|
|
|
|
|
|
|
|
// Could escape separator here if collisions happen. > is not a legal char
|
|
|
|
// for a name or type attribute, so we should be safe avoiding that extra work.
|
|
|
|
|
|
|
|
aKey.Append(NS_ConvertUCS2toUTF8(aString));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void KeyAppendInt(PRInt32 aInt, nsCString& aKey)
|
|
|
|
{
|
|
|
|
KeyAppendSep(aKey);
|
|
|
|
|
|
|
|
aKey.AppendInt(aInt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void KeyAppendAtom(nsIAtom* aAtom, nsCString& aKey)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aAtom, "KeyAppendAtom: aAtom can not be null!\n");
|
|
|
|
|
|
|
|
const PRUnichar* atomString = nsnull;
|
|
|
|
aAtom->GetUnicode(&atomString);
|
|
|
|
|
|
|
|
KeyAppendString(nsDependentString(atomString), aKey);
|
|
|
|
}
|
|
|
|
|
2001-08-16 11:18:24 +04:00
|
|
|
static inline PRBool IsAutocompleteOff(nsIDOMElement* aElement)
|
|
|
|
{
|
|
|
|
nsAutoString autocomplete;
|
|
|
|
aElement->GetAttribute(NS_LITERAL_STRING("autocomplete"), autocomplete);
|
|
|
|
ToLowerCase(autocomplete);
|
|
|
|
return autocomplete.Equals(NS_LITERAL_STRING("off"));
|
|
|
|
}
|
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::GenerateStateKey(nsIContent* aContent,
|
|
|
|
nsIStatefulFrame::SpecialStateID aID,
|
|
|
|
nsCString& aKey)
|
|
|
|
{
|
|
|
|
aKey.Truncate();
|
|
|
|
|
|
|
|
// SpecialStateID case - e.g. scrollbars around the content window
|
|
|
|
// The key in this case is the special state id (always < min(contentID))
|
|
|
|
if (nsIStatefulFrame::eNoID != aID) {
|
|
|
|
KeyAppendInt(aID, aKey);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We must have content if we're not using a special state id
|
|
|
|
NS_ENSURE_TRUE(aContent, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Don't capture state for anonymous content
|
|
|
|
PRUint32 contentID;
|
|
|
|
aContent->GetContentID(&contentID);
|
|
|
|
if (!contentID) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-16 11:18:24 +04:00
|
|
|
nsCOMPtr<nsIDOMElement> element(do_QueryInterface(aContent));
|
|
|
|
if (element && IsAutocompleteOff(element)) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
// If we have a dom element, add tag/type/name to hash key
|
|
|
|
// This is paranoia, but guarantees that we won't restore
|
|
|
|
// state to the wrong type of control.
|
|
|
|
nsCOMPtr<nsIAtom> tag;
|
|
|
|
if (aContent->IsContentOfType(nsIContent::eHTML_FORM_CONTROL)) {
|
|
|
|
|
|
|
|
aContent->GetTag(*getter_AddRefs(tag));
|
|
|
|
KeyAppendAtom(tag, aKey);
|
|
|
|
|
|
|
|
nsAutoString name;
|
2001-08-17 12:14:14 +04:00
|
|
|
aContent->GetAttr(kNameSpaceID_HTML, nsHTMLAtoms::name, name);
|
2001-05-30 15:26:21 +04:00
|
|
|
KeyAppendString(name, aKey);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we have a form control and can calculate form information, use
|
|
|
|
// that as the key - it is more reliable than contentID.
|
|
|
|
// Important to have a unique key, and tag/type/name may not be.
|
|
|
|
nsCOMPtr<nsIFormControl> control(do_QueryInterface(aContent));
|
|
|
|
PRBool generatedUniqueKey = PR_FALSE;
|
|
|
|
if (control && mHTMLFormControls && mHTMLForms) {
|
|
|
|
|
|
|
|
if (tag == nsHTMLAtoms::input) {
|
|
|
|
PRInt32 type;
|
|
|
|
control->GetType(&type);
|
|
|
|
KeyAppendInt(type, aKey);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If in a form, add form name / index of form / index in form
|
|
|
|
PRInt32 index = -1;
|
|
|
|
nsCOMPtr<nsIDOMHTMLFormElement> formElement;
|
|
|
|
control->GetForm(getter_AddRefs(formElement));
|
|
|
|
if (formElement) {
|
|
|
|
|
2001-08-16 11:18:24 +04:00
|
|
|
if (IsAutocompleteOff(formElement)) {
|
|
|
|
aKey.Truncate();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-05-30 15:26:21 +04:00
|
|
|
nsAutoString formName;
|
|
|
|
formElement->GetName(formName);
|
|
|
|
KeyAppendString(formName, aKey);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> formContent(do_QueryInterface(formElement));
|
|
|
|
mHTMLForms->IndexOf(formContent, index, PR_FALSE);
|
2001-11-02 10:40:01 +03:00
|
|
|
if (index <= -1) {
|
|
|
|
mHTMLForms->IndexOf(formContent, index, PR_TRUE);
|
|
|
|
}
|
2001-05-30 15:26:21 +04:00
|
|
|
NS_ASSERTION(index > -1,
|
|
|
|
"nsFrameManager::GenerateStateKey didn't find form index!");
|
2001-11-02 10:40:01 +03:00
|
|
|
if (index <= -1) {
|
|
|
|
PRUint32 formsLength;
|
|
|
|
// Assume the form index is going to be added to the form content next
|
|
|
|
mHTMLForms->GetLength(&formsLength, PR_FALSE);
|
|
|
|
index = (PRInt32)formsLength;
|
|
|
|
}
|
2001-05-30 15:26:21 +04:00
|
|
|
if (index > -1) {
|
|
|
|
KeyAppendInt(index, aKey);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIForm> form(do_QueryInterface(formElement));
|
|
|
|
form->IndexOfControl(control, &index);
|
|
|
|
NS_ASSERTION(index > -1,
|
|
|
|
"nsFrameManager::GenerateStateKey didn't find form control index!");
|
|
|
|
|
|
|
|
if (index > -1) {
|
|
|
|
KeyAppendInt(index, aKey);
|
|
|
|
generatedUniqueKey = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
// If not in a form, add index of control in document
|
|
|
|
// Less desirable than indexing by form info.
|
|
|
|
|
|
|
|
// Hash by index of control in doc (we are not in a form)
|
|
|
|
// These are important as they are unique, and type/name may not be.
|
|
|
|
mHTMLFormControls->IndexOf(aContent, index, PR_FALSE);
|
|
|
|
NS_ASSERTION(index > -1,
|
|
|
|
"nsFrameManager::GenerateStateKey didn't find content by type!");
|
|
|
|
if (index > -1) {
|
|
|
|
KeyAppendInt(index, aKey);
|
|
|
|
generatedUniqueKey = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!generatedUniqueKey) {
|
|
|
|
|
|
|
|
// Either we didn't have a form control or we aren't in an HTML document
|
|
|
|
// so we can't figure out form info, hash by content ID instead :(
|
|
|
|
KeyAppendInt(contentID, aKey);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-06 00:17:44 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
static PLHashNumber
|
|
|
|
HashKey(void* key)
|
|
|
|
{
|
2001-08-14 11:59:59 +04:00
|
|
|
return NS_PTR_TO_INT32(key);
|
1999-08-06 00:17:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static PRIntn
|
|
|
|
CompareKeys(void* key1, void* key2)
|
|
|
|
{
|
|
|
|
return key1 == key2;
|
|
|
|
}
|
|
|
|
|
1999-10-16 04:55:48 +04:00
|
|
|
void
|
1999-10-19 18:41:55 +04:00
|
|
|
FrameManager::DestroyPropertyList(nsIPresContext* aPresContext)
|
1999-10-16 04:55:48 +04:00
|
|
|
{
|
|
|
|
if (mPropertyList) {
|
|
|
|
while (mPropertyList) {
|
|
|
|
PropertyList* tmp = mPropertyList;
|
|
|
|
|
|
|
|
mPropertyList = mPropertyList->mNext;
|
2001-12-06 08:45:07 +03:00
|
|
|
tmp->Destroy(aPresContext);
|
1999-10-19 08:52:33 +04:00
|
|
|
delete tmp;
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
FrameManager::PropertyList*
|
|
|
|
FrameManager::GetPropertyListFor(nsIAtom* aPropertyName) const
|
|
|
|
{
|
|
|
|
PropertyList* result;
|
|
|
|
|
|
|
|
for (result = mPropertyList; result; result = result->mNext) {
|
|
|
|
if (result->mName.get() == aPropertyName) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1999-10-19 18:41:55 +04:00
|
|
|
FrameManager::RemoveAllPropertiesFor(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame)
|
1999-10-16 04:55:48 +04:00
|
|
|
{
|
|
|
|
for (PropertyList* prop = mPropertyList; prop; prop = prop->mNext) {
|
1999-10-19 18:41:55 +04:00
|
|
|
prop->RemovePropertyForFrame(aPresContext, aFrame);
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::GetFrameProperty(nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName,
|
1999-10-19 08:52:33 +04:00
|
|
|
PRUint32 aOptions,
|
1999-10-16 04:55:48 +04:00
|
|
|
void** aPropertyValue)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
NS_PRECONDITION(aPropertyName && aFrame, "unexpected null param");
|
1999-10-16 04:55:48 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
PropertyList* propertyList = GetPropertyListFor(aPropertyName);
|
1999-10-16 04:55:48 +04:00
|
|
|
if (propertyList) {
|
2001-12-06 08:45:07 +03:00
|
|
|
PropertyListMapEntry *entry = NS_STATIC_CAST(PropertyListMapEntry*,
|
|
|
|
PL_DHashTableOperate(&propertyList->mFrameValueMap, aFrame,
|
|
|
|
PL_DHASH_LOOKUP));
|
|
|
|
if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
|
|
|
|
*aPropertyValue = entry->value;
|
|
|
|
if (aOptions & NS_IFRAME_MGR_REMOVE_PROP) {
|
|
|
|
// don't call propertyList->mDtorFunc. That's the caller's job now.
|
|
|
|
PL_DHashTableRawRemove(&propertyList->mFrameValueMap, entry);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
*aPropertyValue = 0;
|
|
|
|
return NS_IFRAME_MGR_PROP_NOT_THERE;
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-10-21 09:11:43 +04:00
|
|
|
FrameManager::SetFrameProperty(nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName,
|
|
|
|
void* aPropertyValue,
|
|
|
|
NSFMPropertyDtorFunc aPropDtorFunc)
|
1999-10-16 04:55:48 +04:00
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
NS_PRECONDITION(aPropertyName && aFrame, "unexpected null param");
|
|
|
|
|
1999-10-16 04:55:48 +04:00
|
|
|
PropertyList* propertyList = GetPropertyListFor(aPropertyName);
|
|
|
|
|
|
|
|
if (propertyList) {
|
|
|
|
// Make sure the dtor function matches
|
|
|
|
if (aPropDtorFunc != propertyList->mDtorFunc) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
2001-12-06 08:45:07 +03:00
|
|
|
propertyList = new PropertyList(aPropertyName, aPropDtorFunc);
|
|
|
|
if (!propertyList)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
if (!propertyList->mFrameValueMap.ops) {
|
|
|
|
delete propertyList;
|
1999-10-16 04:55:48 +04:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
propertyList->mNext = mPropertyList;
|
|
|
|
mPropertyList = propertyList;
|
|
|
|
}
|
|
|
|
|
1999-10-19 08:52:33 +04:00
|
|
|
// The current property value (if there is one) is replaced and the current
|
|
|
|
// value is destroyed
|
2001-12-06 08:45:07 +03:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
PropertyListMapEntry *entry = NS_STATIC_CAST(PropertyListMapEntry*,
|
|
|
|
PL_DHashTableOperate(&propertyList->mFrameValueMap, aFrame, PL_DHASH_ADD));
|
|
|
|
// A NULL entry->key is the sign that the entry has just been allocated
|
|
|
|
// for us. If it's non-NULL then we have an existing entry.
|
|
|
|
if (entry->key && propertyList->mDtorFunc) {
|
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
mPresShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
propertyList->mDtorFunc(presContext, aFrame, aPropertyName, entry->value);
|
|
|
|
result = NS_IFRAME_MGR_PROP_OVERWRITTEN;
|
1999-10-19 08:52:33 +04:00
|
|
|
}
|
2001-12-06 08:45:07 +03:00
|
|
|
entry->key = aFrame;
|
|
|
|
entry->value = aPropertyValue;
|
1999-10-19 08:52:33 +04:00
|
|
|
|
1999-10-21 09:11:43 +04:00
|
|
|
return result;
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
FrameManager::RemoveFrameProperty(nsIFrame* aFrame,
|
|
|
|
nsIAtom* aPropertyName)
|
|
|
|
{
|
2001-03-06 04:46:03 +03:00
|
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
2001-12-06 08:45:07 +03:00
|
|
|
NS_PRECONDITION(aPropertyName && aFrame, "unexpected null param");
|
1999-10-16 04:55:48 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
PropertyList* propertyList = GetPropertyListFor(aPropertyName);
|
1999-10-16 04:55:48 +04:00
|
|
|
if (propertyList) {
|
1999-10-19 18:41:55 +04:00
|
|
|
nsCOMPtr<nsIPresContext> presContext;
|
|
|
|
mPresShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
if (propertyList->RemovePropertyForFrame(presContext, aFrame))
|
|
|
|
return NS_OK;
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
return NS_IFRAME_MGR_PROP_NOT_THERE;
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
1999-10-09 00:41:19 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
2001-01-28 02:06:33 +03:00
|
|
|
MOZ_DECL_CTOR_COUNTER(UndisplayedMap)
|
1999-10-09 00:41:19 +04:00
|
|
|
|
1999-10-02 08:25:29 +04:00
|
|
|
UndisplayedMap::UndisplayedMap(PRUint32 aNumBuckets)
|
|
|
|
{
|
1999-10-09 00:41:19 +04:00
|
|
|
MOZ_COUNT_CTOR(UndisplayedMap);
|
1999-10-02 08:25:29 +04:00
|
|
|
mTable = PL_NewHashTable(aNumBuckets, (PLHashFunction)HashKey,
|
|
|
|
(PLHashComparator)CompareKeys,
|
|
|
|
(PLHashComparator)nsnull,
|
|
|
|
nsnull, nsnull);
|
|
|
|
mLastLookup = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
UndisplayedMap::~UndisplayedMap(void)
|
|
|
|
{
|
1999-10-09 00:41:19 +04:00
|
|
|
MOZ_COUNT_DTOR(UndisplayedMap);
|
1999-10-02 08:25:29 +04:00
|
|
|
Clear();
|
|
|
|
PL_HashTableDestroy(mTable);
|
|
|
|
}
|
|
|
|
|
|
|
|
PLHashEntry**
|
|
|
|
UndisplayedMap::GetEntryFor(nsIContent* aParentContent)
|
|
|
|
{
|
|
|
|
if (mLastLookup && (aParentContent == (*mLastLookup)->key)) {
|
|
|
|
return mLastLookup;
|
|
|
|
}
|
2001-08-14 11:59:59 +04:00
|
|
|
PLHashNumber hashCode = NS_PTR_TO_INT32(aParentContent);
|
1999-10-02 08:25:29 +04:00
|
|
|
PLHashEntry** entry = PL_HashTableRawLookup(mTable, hashCode, aParentContent);
|
|
|
|
if (*entry) {
|
|
|
|
mLastLookup = entry;
|
|
|
|
}
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
UndisplayedNode*
|
|
|
|
UndisplayedMap::GetFirstNode(nsIContent* aParentContent)
|
|
|
|
{
|
|
|
|
PLHashEntry** entry = GetEntryFor(aParentContent);
|
|
|
|
if (*entry) {
|
|
|
|
return (UndisplayedNode*)((*entry)->value);
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
UndisplayedMap::AppendNodeFor(UndisplayedNode* aNode, nsIContent* aParentContent)
|
|
|
|
{
|
|
|
|
PLHashEntry** entry = GetEntryFor(aParentContent);
|
|
|
|
if (*entry) {
|
|
|
|
UndisplayedNode* node = (UndisplayedNode*)((*entry)->value);
|
|
|
|
while (node->mNext) {
|
|
|
|
NS_ASSERTION((node->mContent != aNode->mContent) ||
|
|
|
|
((node->mContent == nsnull) &&
|
|
|
|
(node->mStyle != aNode->mStyle)), "node in map twice");
|
|
|
|
node = node->mNext;
|
|
|
|
}
|
|
|
|
node->mNext = aNode;
|
|
|
|
}
|
|
|
|
else {
|
2001-08-14 11:59:59 +04:00
|
|
|
PLHashNumber hashCode = NS_PTR_TO_INT32(aParentContent);
|
1999-10-02 08:25:29 +04:00
|
|
|
PL_HashTableRawAdd(mTable, entry, hashCode, aParentContent, aNode);
|
|
|
|
mLastLookup = nsnull; // hashtable may have shifted bucket out from under us
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
UndisplayedMap::AddNodeFor(nsIContent* aParentContent, nsIContent* aChild,
|
|
|
|
nsIStyleContext* aStyle)
|
|
|
|
{
|
|
|
|
UndisplayedNode* node = new UndisplayedNode(aChild, aStyle);
|
|
|
|
if (! node) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
return AppendNodeFor(node, aParentContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
UndisplayedMap::AddNodeFor(nsIContent* aParentContent, nsIStyleContext* aPseudoStyle)
|
|
|
|
{
|
|
|
|
UndisplayedNode* node = new UndisplayedNode(aPseudoStyle);
|
|
|
|
if (! node) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
return AppendNodeFor(node, aParentContent);
|
|
|
|
}
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
nsresult
|
|
|
|
UndisplayedMap::GetNodeFor(nsIContent* aContent, nsIStyleContext** aResult)
|
|
|
|
{
|
|
|
|
PLHashEntry** entry = GetEntryFor(aContent);
|
|
|
|
if (*entry) {
|
|
|
|
UndisplayedNode* node = (UndisplayedNode*)((*entry)->value);
|
|
|
|
*aResult = node->mStyle;
|
|
|
|
NS_IF_ADDREF(*aResult);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*aResult = nsnull;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-10-02 08:25:29 +04:00
|
|
|
nsresult
|
|
|
|
UndisplayedMap::RemoveNodeFor(nsIContent* aParentContent, UndisplayedNode* aNode)
|
|
|
|
{
|
|
|
|
PLHashEntry** entry = GetEntryFor(aParentContent);
|
|
|
|
NS_ASSERTION(*entry, "content not in map");
|
|
|
|
if (*entry) {
|
|
|
|
if ((UndisplayedNode*)((*entry)->value) == aNode) { // first node
|
|
|
|
if (aNode->mNext) {
|
|
|
|
(*entry)->value = aNode->mNext;
|
|
|
|
aNode->mNext = nsnull;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
PL_HashTableRawRemove(mTable, entry, *entry);
|
|
|
|
mLastLookup = nsnull; // hashtable may have shifted bucket out from under us
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
UndisplayedNode* node = (UndisplayedNode*)((*entry)->value);
|
|
|
|
while (node->mNext) {
|
|
|
|
if (node->mNext == aNode) {
|
|
|
|
node->mNext = aNode->mNext;
|
|
|
|
aNode->mNext = nsnull;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
node = node->mNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
delete aNode;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
UndisplayedMap::RemoveNodesFor(nsIContent* aParentContent)
|
|
|
|
{
|
|
|
|
PLHashEntry** entry = GetEntryFor(aParentContent);
|
|
|
|
NS_ASSERTION(entry, "content not in map");
|
|
|
|
if (*entry) {
|
|
|
|
UndisplayedNode* node = (UndisplayedNode*)((*entry)->value);
|
|
|
|
delete node;
|
|
|
|
if (entry == mLastLookup) {
|
|
|
|
mLastLookup = nsnull;
|
|
|
|
}
|
|
|
|
PL_HashTableRawRemove(mTable, entry, *entry);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-05-03 03:07:11 +04:00
|
|
|
static PRIntn PR_CALLBACK
|
1999-10-02 08:25:29 +04:00
|
|
|
RemoveUndisplayedEntry(PLHashEntry* he, PRIntn i, void* arg)
|
|
|
|
{
|
|
|
|
UndisplayedNode* node = (UndisplayedNode*)(he->value);
|
|
|
|
delete node;
|
|
|
|
// Remove and free this entry and continue enumerating
|
|
|
|
return HT_ENUMERATE_REMOVE | HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UndisplayedMap::Clear(void)
|
|
|
|
{
|
|
|
|
mLastLookup = nsnull;
|
|
|
|
PL_HashTableEnumerateEntries(mTable, RemoveUndisplayedEntry, 0);
|
|
|
|
}
|
1999-10-16 04:55:48 +04:00
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
1999-10-21 09:11:43 +04:00
|
|
|
FrameManager::PropertyList::PropertyList(nsIAtom* aName,
|
2001-12-06 08:45:07 +03:00
|
|
|
NSFMPropertyDtorFunc aDtorFunc)
|
|
|
|
: mName(aName), mDtorFunc(aDtorFunc), mNext(nsnull)
|
1999-10-16 04:55:48 +04:00
|
|
|
{
|
2001-12-06 08:45:07 +03:00
|
|
|
PL_DHashTableInit(&mFrameValueMap, PL_DHashGetStubOps(), this,
|
|
|
|
sizeof(PropertyListMapEntry), 16);
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
1999-10-19 18:41:55 +04:00
|
|
|
FrameManager::PropertyList::~PropertyList()
|
|
|
|
{
|
2001-12-06 08:45:07 +03:00
|
|
|
PL_DHashTableFinish(&mFrameValueMap);
|
1999-10-19 18:41:55 +04:00
|
|
|
}
|
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
PR_STATIC_CALLBACK(PLDHashOperator)
|
|
|
|
DestroyPropertyEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
|
|
|
|
PRUint32 number, void *arg)
|
|
|
|
{
|
|
|
|
FrameManager::PropertyList *propList =
|
|
|
|
NS_STATIC_CAST(FrameManager::PropertyList*, table->data);
|
|
|
|
nsIPresContext *presContext = NS_STATIC_CAST(nsIPresContext*, arg);
|
|
|
|
PropertyListMapEntry* entry = NS_STATIC_CAST(PropertyListMapEntry*, hdr);
|
1999-10-16 04:55:48 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
propList->mDtorFunc(presContext, entry->key, propList->mName, entry->value);
|
|
|
|
return PL_DHASH_NEXT;
|
|
|
|
}
|
1999-10-16 04:55:48 +04:00
|
|
|
|
1999-10-19 18:41:55 +04:00
|
|
|
void
|
2001-12-06 08:45:07 +03:00
|
|
|
FrameManager::PropertyList::Destroy(nsIPresContext* aPresContext)
|
1999-10-16 04:55:48 +04:00
|
|
|
{
|
2001-12-06 08:45:07 +03:00
|
|
|
// Enumerate any remaining frame/value pairs and destroy the value object
|
|
|
|
if (mDtorFunc)
|
|
|
|
PL_DHashTableEnumerate(&mFrameValueMap, DestroyPropertyEnumerator,
|
|
|
|
aPresContext);
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|
|
|
|
|
1999-10-21 09:11:43 +04:00
|
|
|
PRBool
|
1999-10-19 18:41:55 +04:00
|
|
|
FrameManager::PropertyList::RemovePropertyForFrame(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame* aFrame)
|
1999-10-16 04:55:48 +04:00
|
|
|
{
|
2001-12-06 08:45:07 +03:00
|
|
|
PropertyListMapEntry *entry = NS_STATIC_CAST(PropertyListMapEntry*,
|
|
|
|
PL_DHashTableOperate(&mFrameValueMap, aFrame, PL_DHASH_LOOKUP));
|
|
|
|
if (!PL_DHASH_ENTRY_IS_BUSY(entry))
|
|
|
|
return PR_FALSE;
|
1999-10-21 09:11:43 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
if (mDtorFunc)
|
|
|
|
mDtorFunc(aPresContext, aFrame, mName, entry->value);
|
1999-10-16 04:55:48 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
PL_DHashTableRawRemove(&mFrameValueMap, entry);
|
1999-10-21 09:11:43 +04:00
|
|
|
|
2001-12-06 08:45:07 +03:00
|
|
|
return PR_TRUE;
|
1999-10-16 04:55:48 +04:00
|
|
|
}
|