2001-09-25 05:32:19 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 01:52:36 +04:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-04-14 00:24:54 +04:00
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
1998-04-14 00:24:54 +04:00
|
|
|
*
|
2001-09-25 05:32:19 +04:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1998-04-14 00:24:54 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-25 05:32:19 +04:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:40:37 +03:00
|
|
|
*
|
2001-09-25 05:32:19 +04:00
|
|
|
* Contributor(s):
|
2001-06-01 02:19:43 +04:00
|
|
|
* David Hyatt <hyatt@netscape.com>
|
2000-02-03 01:24:56 +03:00
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
2001-09-25 05:32:19 +04:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 01:52:36 +04:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2001-09-25 05:32:19 +04:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 01:52:36 +04:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-25 05:32:19 +04:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-18 01:52:36 +04:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-25 05:32:19 +04:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2001-02-07 12:57:26 +03:00
|
|
|
|
2006-03-25 08:47:31 +03:00
|
|
|
/* the interface (to internal code) for retrieving computed style data */
|
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "nsStyleConsts.h"
|
|
|
|
#include "nsString.h"
|
2004-08-01 03:15:21 +04:00
|
|
|
#include "nsPresContext.h"
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "nsIStyleRule.h"
|
|
|
|
#include "nsCRT.h"
|
|
|
|
|
2000-03-31 11:08:36 +04:00
|
|
|
#include "nsCOMPtr.h"
|
2004-01-08 01:30:53 +03:00
|
|
|
#include "nsStyleSet.h"
|
2000-03-31 11:08:36 +04:00
|
|
|
#include "nsIPresShell.h"
|
2000-12-15 09:09:50 +03:00
|
|
|
#include "prenv.h"
|
2000-03-31 11:08:36 +04:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
#include "nsRuleNode.h"
|
2007-03-23 02:01:14 +03:00
|
|
|
#include "nsUnitConversion.h"
|
2003-02-22 03:32:13 +03:00
|
|
|
#include "nsStyleContext.h"
|
2004-03-09 06:57:51 +03:00
|
|
|
#include "imgIRequest.h"
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2005-04-29 19:44:38 +04:00
|
|
|
#include "nsPrintfCString.h"
|
|
|
|
|
2000-06-22 00:44:59 +04:00
|
|
|
#ifdef DEBUG
|
2001-06-01 02:19:43 +04:00
|
|
|
// #define NOISY_DEBUG
|
2001-05-03 17:20:48 +04:00
|
|
|
#endif
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
//----------------------------------------------------------------------
|
2001-05-03 17:20:48 +04:00
|
|
|
|
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
nsStyleContext::nsStyleContext(nsStyleContext* aParent,
|
2001-12-02 03:44:45 +03:00
|
|
|
nsIAtom* aPseudoTag,
|
|
|
|
nsRuleNode* aRuleNode,
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* aPresContext)
|
2005-02-05 08:24:21 +03:00
|
|
|
: mParent(aParent),
|
2001-06-01 02:19:43 +04:00
|
|
|
mChild(nsnull),
|
|
|
|
mEmptyChild(nsnull),
|
|
|
|
mPseudoTag(aPseudoTag),
|
2001-12-02 03:44:45 +03:00
|
|
|
mRuleNode(aRuleNode),
|
2003-02-22 03:32:13 +03:00
|
|
|
mBits(0),
|
|
|
|
mRefCnt(0)
|
1999-09-04 03:34:20 +04:00
|
|
|
{
|
2001-06-01 02:19:43 +04:00
|
|
|
mNextSibling = this;
|
|
|
|
mPrevSibling = this;
|
2001-12-02 03:44:45 +03:00
|
|
|
if (mParent) {
|
2003-02-22 03:32:13 +03:00
|
|
|
mParent->AddRef();
|
2006-04-28 04:09:05 +04:00
|
|
|
mParent->AddChild(this);
|
1999-02-27 10:11:42 +03:00
|
|
|
}
|
2001-05-03 17:20:48 +04:00
|
|
|
|
2001-07-25 10:33:06 +04:00
|
|
|
ApplyStyleFixups(aPresContext);
|
2002-07-09 08:10:10 +04:00
|
|
|
|
2006-04-28 04:09:05 +04:00
|
|
|
#define eStyleStruct_LastItem (nsStyleStructID_Length - 1)
|
|
|
|
NS_ASSERTION(NS_STYLE_INHERIT_MASK & NS_STYLE_INHERIT_BIT(LastItem),
|
2002-07-09 08:10:10 +04:00
|
|
|
"NS_STYLE_INHERIT_MASK must be bigger, and other bits shifted");
|
2006-04-28 04:09:05 +04:00
|
|
|
#undef eStyleStruct_LastItem
|
2001-05-03 17:20:48 +04:00
|
|
|
}
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
nsStyleContext::~nsStyleContext()
|
2001-05-03 17:20:48 +04:00
|
|
|
{
|
2001-06-01 02:19:43 +04:00
|
|
|
NS_ASSERTION((nsnull == mChild) && (nsnull == mEmptyChild), "destructing context with children");
|
2001-05-03 17:20:48 +04:00
|
|
|
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext *presContext = mRuleNode->GetPresContext();
|
2003-03-06 22:14:17 +03:00
|
|
|
|
2004-01-08 01:30:53 +03:00
|
|
|
presContext->PresShell()->StyleSet()->
|
|
|
|
NotifyStyleContextDestroyed(presContext, this);
|
2003-03-06 22:14:17 +03:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
if (mParent) {
|
|
|
|
mParent->RemoveChild(this);
|
2003-02-22 03:32:13 +03:00
|
|
|
mParent->Release();
|
1999-02-27 10:11:42 +03:00
|
|
|
}
|
2001-02-07 12:57:26 +03:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// Free up our data structs.
|
|
|
|
if (mCachedStyleData.mResetData || mCachedStyleData.mInheritedData) {
|
|
|
|
mCachedStyleData.Destroy(mBits, presContext);
|
|
|
|
}
|
2001-02-07 12:57:26 +03:00
|
|
|
}
|
|
|
|
|
2006-04-28 04:09:05 +04:00
|
|
|
void nsStyleContext::AddChild(nsStyleContext* aChild)
|
2001-02-07 12:57:26 +03:00
|
|
|
{
|
2006-04-28 04:09:05 +04:00
|
|
|
NS_ASSERTION(aChild->mPrevSibling == aChild &&
|
|
|
|
aChild->mNextSibling == aChild,
|
|
|
|
"child already in a child list");
|
|
|
|
|
|
|
|
nsStyleContext **list = aChild->mRuleNode->IsRoot() ? &mEmptyChild : &mChild;
|
|
|
|
|
|
|
|
// Insert at the beginning of the list. See also FindChildWithRules.
|
|
|
|
if (*list) {
|
|
|
|
// Link into existing elements, if there are any.
|
|
|
|
aChild->mNextSibling = (*list);
|
|
|
|
aChild->mPrevSibling = (*list)->mPrevSibling;
|
|
|
|
(*list)->mPrevSibling->mNextSibling = aChild;
|
|
|
|
(*list)->mPrevSibling = aChild;
|
2001-02-07 12:57:26 +03:00
|
|
|
}
|
2006-04-28 04:09:05 +04:00
|
|
|
(*list) = aChild;
|
2001-02-07 12:57:26 +03:00
|
|
|
}
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
void nsStyleContext::RemoveChild(nsStyleContext* aChild)
|
2001-02-07 12:57:26 +03:00
|
|
|
{
|
2002-02-17 04:53:40 +03:00
|
|
|
NS_PRECONDITION(nsnull != aChild && this == aChild->mParent, "bad argument");
|
2001-02-07 12:57:26 +03:00
|
|
|
|
2006-04-28 04:09:05 +04:00
|
|
|
nsStyleContext **list = aChild->mRuleNode->IsRoot() ? &mEmptyChild : &mChild;
|
|
|
|
|
|
|
|
if (aChild->mPrevSibling != aChild) { // has siblings
|
|
|
|
if ((*list) == aChild) {
|
|
|
|
(*list) = (*list)->mNextSibling;
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
2006-04-28 04:09:05 +04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
NS_ASSERTION((*list) == aChild, "bad sibling pointers");
|
|
|
|
(*list) = nsnull;
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
2006-04-28 04:09:05 +04:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
aChild->mPrevSibling->mNextSibling = aChild->mNextSibling;
|
|
|
|
aChild->mNextSibling->mPrevSibling = aChild->mPrevSibling;
|
|
|
|
aChild->mNextSibling = aChild;
|
|
|
|
aChild->mPrevSibling = aChild;
|
1999-10-16 08:05:59 +04:00
|
|
|
}
|
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
already_AddRefed<nsStyleContext>
|
2001-06-01 02:19:43 +04:00
|
|
|
nsStyleContext::FindChildWithRules(const nsIAtom* aPseudoTag,
|
2003-02-22 03:32:13 +03:00
|
|
|
nsRuleNode* aRuleNode)
|
2001-06-01 02:19:43 +04:00
|
|
|
{
|
|
|
|
PRUint32 threshold = 10; // The # of siblings we're willing to examine
|
|
|
|
// before just giving this whole thing up.
|
2001-05-03 17:20:48 +04:00
|
|
|
|
2006-04-28 04:09:05 +04:00
|
|
|
nsStyleContext* result = nsnull;
|
|
|
|
nsStyleContext *list = aRuleNode->IsRoot() ? mEmptyChild : mChild;
|
|
|
|
|
|
|
|
if (list) {
|
|
|
|
nsStyleContext *child = list;
|
|
|
|
do {
|
|
|
|
if (child->mRuleNode == aRuleNode && child->mPseudoTag == aPseudoTag) {
|
|
|
|
result = child;
|
|
|
|
break;
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
2006-04-28 04:09:05 +04:00
|
|
|
child = child->mNextSibling;
|
|
|
|
threshold--;
|
|
|
|
if (threshold == 0)
|
|
|
|
break;
|
|
|
|
} while (child != list);
|
1998-10-27 06:03:02 +03:00
|
|
|
}
|
2003-02-22 03:32:13 +03:00
|
|
|
|
2006-04-28 04:09:05 +04:00
|
|
|
if (result) {
|
|
|
|
if (result != list) {
|
|
|
|
// Move result to the front of the list.
|
|
|
|
RemoveChild(result);
|
|
|
|
AddChild(result);
|
|
|
|
}
|
2003-02-22 03:32:13 +03:00
|
|
|
|
2006-04-28 04:09:05 +04:00
|
|
|
// Add reference for the caller.
|
|
|
|
result->AddRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
1998-06-05 10:01:55 +04:00
|
|
|
}
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
PRBool nsStyleContext::Equals(const nsStyleContext* aOther) const
|
1998-06-05 10:01:55 +04:00
|
|
|
{
|
2001-06-01 02:19:43 +04:00
|
|
|
PRBool result = PR_TRUE;
|
|
|
|
const nsStyleContext* other = (nsStyleContext*)aOther;
|
|
|
|
|
|
|
|
if (other != this) {
|
|
|
|
if (mParent != other->mParent) {
|
|
|
|
result = PR_FALSE;
|
|
|
|
}
|
|
|
|
else if (mBits != other->mBits) {
|
|
|
|
result = PR_FALSE;
|
|
|
|
}
|
|
|
|
else if (mPseudoTag != other->mPseudoTag) {
|
|
|
|
result = PR_FALSE;
|
|
|
|
}
|
|
|
|
else if (mRuleNode != other->mRuleNode) {
|
|
|
|
result = PR_FALSE;
|
|
|
|
}
|
1998-06-05 10:01:55 +04:00
|
|
|
}
|
2001-06-01 02:19:43 +04:00
|
|
|
return result;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
//=========================================================================================================
|
|
|
|
|
2007-03-23 02:01:14 +03:00
|
|
|
const nsStyleStruct* nsStyleContext::GetStyleData(nsStyleStructID aSID)
|
1998-04-21 04:02:44 +04:00
|
|
|
{
|
2007-03-23 02:01:14 +03:00
|
|
|
const nsStyleStruct* cachedData = mCachedStyleData.GetStyleData(aSID);
|
2001-06-01 02:19:43 +04:00
|
|
|
if (cachedData)
|
|
|
|
return cachedData; // We have computed data stored on this node in the context tree.
|
2001-11-14 11:19:13 +03:00
|
|
|
return mRuleNode->GetStyleData(aSID, this, PR_TRUE); // Our rule node will take care of it for us.
|
|
|
|
}
|
|
|
|
|
2006-12-12 20:44:45 +03:00
|
|
|
#define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_) \
|
|
|
|
const nsStyle##name_ * nsStyleContext::GetStyle##name_ () \
|
|
|
|
{ \
|
|
|
|
const nsStyle##name_ * cachedData = mCachedStyleData.GetStyle##name_(); \
|
|
|
|
if (cachedData) \
|
|
|
|
return cachedData; /* We have computed data stored on this node */ \
|
|
|
|
/* in the context tree. */ \
|
|
|
|
/* Else our rule node will take care of it for us. */ \
|
|
|
|
return mRuleNode->GetStyle##name_(this, PR_TRUE); \
|
|
|
|
}
|
|
|
|
#include "nsStyleStructList.h"
|
|
|
|
#undef STYLE_STRUCT
|
|
|
|
|
2007-03-23 02:01:14 +03:00
|
|
|
inline const nsStyleStruct* nsStyleContext::PeekStyleData(nsStyleStructID aSID)
|
2001-11-14 11:19:13 +03:00
|
|
|
{
|
2007-03-23 02:01:14 +03:00
|
|
|
const nsStyleStruct* cachedData = mCachedStyleData.GetStyleData(aSID);
|
2001-11-14 11:19:13 +03:00
|
|
|
if (cachedData)
|
|
|
|
return cachedData; // We have computed data stored on this node in the context tree.
|
|
|
|
return mRuleNode->GetStyleData(aSID, this, PR_FALSE); // Our rule node will take care of it for us.
|
1999-02-27 10:11:42 +03:00
|
|
|
}
|
1998-12-07 21:51:26 +03:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// This is an evil evil function, since it forces you to alloc your own separate copy of
|
|
|
|
// style data! Do not use this function unless you absolutely have to! You should avoid
|
|
|
|
// this at all costs! -dwh
|
2007-03-23 02:01:14 +03:00
|
|
|
nsStyleStruct*
|
2004-02-09 09:55:14 +03:00
|
|
|
nsStyleContext::GetUniqueStyleData(const nsStyleStructID& aSID)
|
2000-06-22 00:44:59 +04:00
|
|
|
{
|
2004-02-09 09:55:14 +03:00
|
|
|
// If we already own the struct and no kids could depend on it, then
|
|
|
|
// just return it. (We leak in this case if there are kids -- and this
|
|
|
|
// function really shouldn't be called for style contexts that could
|
|
|
|
// have kids depending on the data. ClearStyleData would be OK, but
|
|
|
|
// this test for no mChild or mEmptyChild doesn't catch that case.)
|
2007-03-23 02:01:14 +03:00
|
|
|
const nsStyleStruct *current = GetStyleData(aSID);
|
2004-02-09 09:55:14 +03:00
|
|
|
if (!mChild && !mEmptyChild &&
|
|
|
|
!(mBits & nsCachedStyleData::GetBitForSID(aSID)) &&
|
|
|
|
mCachedStyleData.GetStyleData(aSID))
|
2007-07-08 11:08:04 +04:00
|
|
|
return const_cast<nsStyleStruct*>(current);
|
2004-02-09 09:55:14 +03:00
|
|
|
|
2007-03-23 02:01:14 +03:00
|
|
|
nsStyleStruct* result;
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext *presContext = PresContext();
|
2001-06-01 02:19:43 +04:00
|
|
|
switch (aSID) {
|
2004-02-09 09:55:14 +03:00
|
|
|
|
|
|
|
#define UNIQUE_CASE(c_) \
|
|
|
|
case eStyleStruct_##c_: \
|
|
|
|
result = new (presContext) nsStyle##c_( \
|
2007-07-11 12:46:44 +04:00
|
|
|
* static_cast<const nsStyle##c_ *>(current)); \
|
2001-12-14 06:47:02 +03:00
|
|
|
break;
|
2004-02-09 09:55:14 +03:00
|
|
|
|
|
|
|
UNIQUE_CASE(Display)
|
|
|
|
UNIQUE_CASE(Background)
|
|
|
|
UNIQUE_CASE(Text)
|
|
|
|
UNIQUE_CASE(TextReset)
|
|
|
|
|
|
|
|
#undef UNIQUE_CASE
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
default:
|
|
|
|
NS_ERROR("Struct type not supported. Please find another way to do this if you can!\n");
|
2004-02-09 09:55:14 +03:00
|
|
|
return nsnull;
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
|
|
|
|
2005-07-20 01:03:04 +04:00
|
|
|
if (!result) {
|
2007-03-23 02:01:14 +03:00
|
|
|
NS_WARNING("Ran out of memory while trying to allocate memory for a unique nsStyleStruct! "
|
2005-07-20 01:03:04 +04:00
|
|
|
"Returning the non-unique data.");
|
2007-07-08 11:08:04 +04:00
|
|
|
return const_cast<nsStyleStruct*>(current);
|
2005-07-20 01:03:04 +04:00
|
|
|
}
|
|
|
|
|
2004-02-09 09:55:14 +03:00
|
|
|
SetStyle(aSID, result);
|
|
|
|
mBits &= ~nsCachedStyleData::GetBitForSID(aSID);
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
return result;
|
2000-06-22 00:44:59 +04:00
|
|
|
}
|
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
void
|
2007-03-23 02:01:14 +03:00
|
|
|
nsStyleContext::SetStyle(nsStyleStructID aSID, nsStyleStruct* aStruct)
|
2000-12-15 09:09:50 +03:00
|
|
|
{
|
2001-06-01 02:19:43 +04:00
|
|
|
// This method should only be called from nsRuleNode! It is not a public
|
|
|
|
// method!
|
|
|
|
|
2002-07-09 08:10:10 +04:00
|
|
|
NS_ASSERTION(aSID >= 0 && aSID < nsStyleStructID_Length, "out of bounds");
|
|
|
|
|
|
|
|
// NOTE: nsCachedStyleData::GetStyleData works roughly the same way.
|
2002-08-06 17:46:35 +04:00
|
|
|
// See the comments there (in nsRuleNode.h) for more details about
|
|
|
|
// what this is doing and why.
|
|
|
|
|
2002-07-09 08:10:10 +04:00
|
|
|
const nsCachedStyleData::StyleStructInfo& info =
|
|
|
|
nsCachedStyleData::gInfo[aSID];
|
2007-07-08 11:08:04 +04:00
|
|
|
char* resetOrInheritSlot = reinterpret_cast<char*>(&mCachedStyleData) +
|
2002-07-09 08:10:10 +04:00
|
|
|
info.mCachedStyleDataOffset;
|
2007-07-08 11:08:04 +04:00
|
|
|
char* resetOrInherit = reinterpret_cast<char*>
|
|
|
|
(*reinterpret_cast<void**>(resetOrInheritSlot));
|
2002-07-09 08:10:10 +04:00
|
|
|
if (!resetOrInherit) {
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext *presContext = mRuleNode->GetPresContext();
|
2002-07-09 08:10:10 +04:00
|
|
|
if (mCachedStyleData.IsReset(aSID)) {
|
2003-06-20 05:22:44 +04:00
|
|
|
mCachedStyleData.mResetData = new (presContext) nsResetStyleData;
|
2007-07-08 11:08:04 +04:00
|
|
|
resetOrInherit = reinterpret_cast<char*>(mCachedStyleData.mResetData);
|
2002-07-09 08:10:10 +04:00
|
|
|
} else {
|
|
|
|
mCachedStyleData.mInheritedData =
|
2003-06-20 05:22:44 +04:00
|
|
|
new (presContext) nsInheritedStyleData;
|
2002-07-09 08:10:10 +04:00
|
|
|
resetOrInherit =
|
2007-07-08 11:08:04 +04:00
|
|
|
reinterpret_cast<char*>(mCachedStyleData.mInheritedData);
|
2001-12-02 03:44:45 +03:00
|
|
|
}
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
2002-07-09 08:10:10 +04:00
|
|
|
char* dataSlot = resetOrInherit + info.mInheritResetOffset;
|
2007-07-08 11:08:04 +04:00
|
|
|
*reinterpret_cast<nsStyleStruct**>(dataSlot) = aStruct;
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
|
|
|
|
2001-07-25 10:33:06 +04:00
|
|
|
void
|
2004-08-01 03:15:21 +04:00
|
|
|
nsStyleContext::ApplyStyleFixups(nsPresContext* aPresContext)
|
2001-06-01 02:19:43 +04:00
|
|
|
{
|
2001-07-25 10:33:06 +04:00
|
|
|
// See if we have any text decorations.
|
|
|
|
// First see if our parent has text decorations. If our parent does, then we inherit the bit.
|
|
|
|
if (mParent && mParent->HasTextDecorations())
|
|
|
|
mBits |= NS_STYLE_HAS_TEXT_DECORATIONS;
|
|
|
|
else {
|
|
|
|
// We might have defined a decoration.
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleTextReset* text = GetStyleTextReset();
|
2001-07-25 10:33:06 +04:00
|
|
|
if (text->mTextDecoration != NS_STYLE_TEXT_DECORATION_NONE &&
|
|
|
|
text->mTextDecoration != NS_STYLE_TEXT_DECORATION_OVERRIDE_ALL)
|
|
|
|
mBits |= NS_STYLE_HAS_TEXT_DECORATIONS;
|
|
|
|
}
|
|
|
|
|
2005-07-20 16:03:15 +04:00
|
|
|
// Correct tables.
|
|
|
|
const nsStyleDisplay* disp = GetStyleDisplay();
|
|
|
|
if (disp->mDisplay == NS_STYLE_DISPLAY_TABLE) {
|
|
|
|
// -moz-center and -moz-right are used for HTML's alignment
|
|
|
|
// This is covering the <div align="right"><table>...</table></div> case.
|
|
|
|
// In this case, we don't want to inherit the text alignment into the table.
|
|
|
|
const nsStyleText* text = GetStyleText();
|
|
|
|
|
|
|
|
if (text->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_CENTER ||
|
|
|
|
text->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_RIGHT)
|
|
|
|
{
|
|
|
|
nsStyleText* uniqueText = (nsStyleText*)GetUniqueStyleData(eStyleStruct_Text);
|
|
|
|
uniqueText->mTextAlign = NS_STYLE_TEXT_ALIGN_DEFAULT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-07-17 22:21:41 +04:00
|
|
|
// CSS2.1 section 9.2.4 specifies fixups for the 'display' property of
|
|
|
|
// the root element. We can't implement them in nsRuleNode because we
|
|
|
|
// don't want to store all display structs that aren't 'block',
|
|
|
|
// 'inline', or 'table' in the style context tree on the off chance
|
|
|
|
// that the root element has its style reresolved later. So do them
|
|
|
|
// here if needed, by changing the style data, so that other code
|
|
|
|
// doesn't get confused by looking at the style data.
|
|
|
|
if (!mParent) {
|
|
|
|
if (disp->mDisplay != NS_STYLE_DISPLAY_NONE &&
|
|
|
|
disp->mDisplay != NS_STYLE_DISPLAY_BLOCK &&
|
|
|
|
disp->mDisplay != NS_STYLE_DISPLAY_TABLE) {
|
2007-07-08 11:08:04 +04:00
|
|
|
nsStyleDisplay *mutable_display = static_cast<nsStyleDisplay*>
|
|
|
|
(GetUniqueStyleData(eStyleStruct_Display));
|
2004-07-17 22:21:41 +04:00
|
|
|
if (mutable_display->mDisplay == NS_STYLE_DISPLAY_INLINE_TABLE)
|
|
|
|
mutable_display->mDisplay = NS_STYLE_DISPLAY_TABLE;
|
|
|
|
else
|
|
|
|
mutable_display->mDisplay = NS_STYLE_DISPLAY_BLOCK;
|
|
|
|
}
|
|
|
|
}
|
2004-12-31 00:56:11 +03:00
|
|
|
|
|
|
|
// Computer User Interface style, to trigger loads of cursors
|
|
|
|
GetStyleUserInterface();
|
2001-07-25 10:33:06 +04:00
|
|
|
}
|
2001-07-19 02:48:35 +04:00
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
nsChangeHint
|
|
|
|
nsStyleContext::CalcStyleDifference(nsStyleContext* aOther)
|
2001-06-01 02:19:43 +04:00
|
|
|
{
|
2003-02-22 03:32:13 +03:00
|
|
|
nsChangeHint hint = NS_STYLE_HINT_NONE;
|
2003-03-16 03:20:21 +03:00
|
|
|
NS_ENSURE_TRUE(aOther, hint);
|
|
|
|
// We must always ensure that we populate the structs on the new style
|
|
|
|
// context that are filled in on the old context, so that if we get
|
|
|
|
// two style changes in succession, the second of which causes a real
|
2007-03-23 02:01:14 +03:00
|
|
|
// style change, the PeekStyleData doesn't fail.
|
2003-03-16 03:20:21 +03:00
|
|
|
|
|
|
|
// If our rule nodes are the same, then we are looking at the same
|
|
|
|
// style data. We know this because CalcStyleDifference is always
|
|
|
|
// called on two style contexts that point to the same element, so we
|
|
|
|
// know that our position in the style context tree is the same and
|
|
|
|
// our position in the rule node tree is also the same.
|
|
|
|
PRBool compare = mRuleNode != aOther->mRuleNode;
|
|
|
|
|
2004-12-28 16:48:25 +03:00
|
|
|
nsChangeHint maxHint = nsChangeHint(NS_STYLE_HINT_FRAMECHANGE |
|
2005-06-10 17:57:27 +04:00
|
|
|
nsChangeHint_UpdateCursor);
|
2003-03-16 03:20:21 +03:00
|
|
|
|
2003-03-16 07:51:56 +03:00
|
|
|
#define DO_STRUCT_DIFFERENCE(struct_) \
|
|
|
|
PR_BEGIN_MACRO \
|
2004-10-01 07:33:05 +04:00
|
|
|
NS_ASSERTION(NS_IsHintSubset(nsStyle##struct_::MaxDifference(), maxHint), \
|
|
|
|
"Struct placed in the wrong maxHint section"); \
|
2003-03-16 07:51:56 +03:00
|
|
|
const nsStyle##struct_* this##struct_ = \
|
2007-07-11 12:46:44 +04:00
|
|
|
static_cast<const nsStyle##struct_*>( \
|
2006-12-12 20:44:45 +03:00
|
|
|
PeekStyleData(eStyleStruct_##struct_)); \
|
2003-03-16 07:51:56 +03:00
|
|
|
if (this##struct_) { \
|
2006-12-12 20:44:45 +03:00
|
|
|
const nsStyle##struct_* other##struct_ = aOther->GetStyle##struct_(); \
|
2003-03-16 07:51:56 +03:00
|
|
|
if (compare && \
|
|
|
|
!NS_IsHintSubset(maxHint, hint) && \
|
|
|
|
this##struct_ != other##struct_) { \
|
2004-10-01 07:33:05 +04:00
|
|
|
NS_ASSERTION(NS_IsHintSubset( \
|
|
|
|
this##struct_->CalcDifference(*other##struct_), \
|
|
|
|
nsStyle##struct_::MaxDifference()), \
|
|
|
|
"CalcDifference() returned bigger hint than MaxDifference()"); \
|
2003-03-16 07:51:56 +03:00
|
|
|
NS_UpdateHint(hint, this##struct_->CalcDifference(*other##struct_)); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
PR_END_MACRO
|
|
|
|
|
2003-03-16 03:20:21 +03:00
|
|
|
// We begin by examining those style structs that are capable of
|
|
|
|
// causing the maximal difference, a FRAMECHANGE.
|
|
|
|
// FRAMECHANGE Structs: Display, XUL, Content, UserInterface,
|
2007-04-21 09:40:13 +04:00
|
|
|
// Visibility, Outline, TableBorder, Table, UIReset, Quotes
|
2003-03-16 07:51:56 +03:00
|
|
|
DO_STRUCT_DIFFERENCE(Display);
|
|
|
|
DO_STRUCT_DIFFERENCE(XUL);
|
2004-06-17 15:57:37 +04:00
|
|
|
DO_STRUCT_DIFFERENCE(Column);
|
2003-03-16 07:51:56 +03:00
|
|
|
DO_STRUCT_DIFFERENCE(Content);
|
|
|
|
DO_STRUCT_DIFFERENCE(UserInterface);
|
|
|
|
DO_STRUCT_DIFFERENCE(Visibility);
|
2004-07-16 20:56:21 +04:00
|
|
|
DO_STRUCT_DIFFERENCE(Outline);
|
2004-09-11 10:13:47 +04:00
|
|
|
DO_STRUCT_DIFFERENCE(TableBorder);
|
2004-10-01 07:33:05 +04:00
|
|
|
DO_STRUCT_DIFFERENCE(Table);
|
|
|
|
DO_STRUCT_DIFFERENCE(UIReset);
|
Bug 300030: Move intrinsic width computation out of nsIFrame::Reflow and into its own methods on nsIFrame. Replace reflow reasons, types, and commands with dirty bits/notifications. Thanks to bzbarsky for almost all of the HTML form controls (mozilla/layout/forms) changes, and many others for help testing and patching. For detailed commit logs, see REFLOW_YYYYMMDD_BRANCH, where YYYYMMDD is one of 20061031, 20060830, 20060603, 20060302, 20060119, 20051011, 20050804, 20050429, 20050315, 20050111, and 20041213.
2006-12-08 08:38:33 +03:00
|
|
|
DO_STRUCT_DIFFERENCE(List);
|
2003-03-16 03:20:21 +03:00
|
|
|
// If the quotes implementation is ever going to change we might not need
|
|
|
|
// a framechange here and a reflow should be sufficient. See bug 35768.
|
2003-03-16 07:51:56 +03:00
|
|
|
DO_STRUCT_DIFFERENCE(Quotes);
|
2001-12-12 10:59:31 +03:00
|
|
|
|
2003-03-16 03:20:21 +03:00
|
|
|
// At this point, we know that the worst kind of damage we could do is
|
|
|
|
// a reflow.
|
|
|
|
maxHint = NS_STYLE_HINT_REFLOW;
|
|
|
|
|
|
|
|
// The following structs cause (as their maximal difference) a reflow
|
|
|
|
// to occur. REFLOW Structs: Font, Margin, Padding, Border, List,
|
2004-10-01 07:33:05 +04:00
|
|
|
// Position, Text, TextReset
|
2003-03-16 07:51:56 +03:00
|
|
|
DO_STRUCT_DIFFERENCE(Font);
|
|
|
|
DO_STRUCT_DIFFERENCE(Margin);
|
|
|
|
DO_STRUCT_DIFFERENCE(Padding);
|
|
|
|
DO_STRUCT_DIFFERENCE(Border);
|
|
|
|
DO_STRUCT_DIFFERENCE(Position);
|
|
|
|
DO_STRUCT_DIFFERENCE(Text);
|
|
|
|
DO_STRUCT_DIFFERENCE(TextReset);
|
2003-03-16 03:20:21 +03:00
|
|
|
|
|
|
|
// At this point, we know that the worst kind of damage we could do is
|
|
|
|
// a re-render (i.e., a VISUAL change).
|
|
|
|
maxHint = NS_STYLE_HINT_VISUAL;
|
|
|
|
|
|
|
|
// The following structs cause (as their maximal difference) a
|
2007-04-21 09:40:13 +04:00
|
|
|
// re-render to occur. VISUAL Structs: Color, Background
|
2003-03-16 07:51:56 +03:00
|
|
|
DO_STRUCT_DIFFERENCE(Color);
|
2007-04-21 09:40:13 +04:00
|
|
|
DO_STRUCT_DIFFERENCE(Background);
|
2005-04-05 01:42:26 +04:00
|
|
|
#ifdef MOZ_SVG
|
|
|
|
DO_STRUCT_DIFFERENCE(SVG);
|
|
|
|
#endif
|
2003-03-16 07:51:56 +03:00
|
|
|
|
|
|
|
#undef DO_STRUCT_DIFFERENCE
|
2000-06-22 00:44:59 +04:00
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
return hint;
|
2000-06-22 00:44:59 +04:00
|
|
|
}
|
|
|
|
|
2003-03-06 22:14:17 +03:00
|
|
|
void
|
|
|
|
nsStyleContext::Mark()
|
|
|
|
{
|
|
|
|
// Mark our rule node.
|
|
|
|
mRuleNode->Mark();
|
|
|
|
|
|
|
|
// Mark our children (i.e., tell them to mark their rule nodes, etc.).
|
|
|
|
if (mChild) {
|
|
|
|
nsStyleContext* child = mChild;
|
|
|
|
do {
|
|
|
|
child->Mark();
|
|
|
|
child = child->mNextSibling;
|
|
|
|
} while (mChild != child);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mEmptyChild) {
|
|
|
|
nsStyleContext* child = mEmptyChild;
|
|
|
|
do {
|
|
|
|
child->Mark();
|
|
|
|
child = child->mNextSibling;
|
|
|
|
} while (mEmptyChild != child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-10-16 09:31:36 +04:00
|
|
|
#ifdef DEBUG
|
2003-10-02 06:58:40 +04:00
|
|
|
|
|
|
|
class URICString : public nsCAutoString {
|
|
|
|
public:
|
|
|
|
URICString(nsIURI* aURI) {
|
2003-10-06 06:16:20 +04:00
|
|
|
if (aURI) {
|
|
|
|
aURI->GetSpec(*this);
|
|
|
|
} else {
|
2003-10-06 06:56:27 +04:00
|
|
|
Assign("[none]");
|
2003-10-06 06:16:20 +04:00
|
|
|
}
|
2003-10-02 06:58:40 +04:00
|
|
|
}
|
|
|
|
|
2004-03-09 06:57:51 +03:00
|
|
|
URICString(imgIRequest* aImageRequest) {
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
if (aImageRequest) {
|
|
|
|
aImageRequest->GetURI(getter_AddRefs(uri));
|
|
|
|
}
|
|
|
|
if (uri) {
|
|
|
|
uri->GetSpec(*this);
|
|
|
|
} else {
|
|
|
|
Assign("[none]");
|
|
|
|
}
|
|
|
|
}
|
2007-07-19 01:56:57 +04:00
|
|
|
|
|
|
|
URICString(nsCSSValue::URL* aURI) {
|
|
|
|
if (aURI) {
|
|
|
|
NS_ASSERTION(aURI->mURI, "Must have URI here!");
|
|
|
|
aURI->mURI->GetSpec(*this);
|
|
|
|
} else {
|
|
|
|
Assign("[none]");
|
|
|
|
}
|
|
|
|
}
|
2004-03-09 06:57:51 +03:00
|
|
|
|
2003-10-02 06:58:40 +04:00
|
|
|
URICString& operator=(const URICString& aOther) {
|
|
|
|
Assign(aOther);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
void nsStyleContext::List(FILE* out, PRInt32 aIndent)
|
1998-05-19 01:04:26 +04:00
|
|
|
{
|
|
|
|
// Indent
|
1999-07-05 22:43:38 +04:00
|
|
|
PRInt32 ix;
|
|
|
|
for (ix = aIndent; --ix >= 0; ) fputs(" ", out);
|
2002-09-30 18:18:27 +04:00
|
|
|
fprintf(out, "%p(%d) parent=%p ",
|
2003-02-22 03:32:13 +03:00
|
|
|
(void*)this, mRefCnt, (void *)mParent);
|
2001-12-02 03:44:45 +03:00
|
|
|
if (mPseudoTag) {
|
1998-11-03 23:18:40 +03:00
|
|
|
nsAutoString buffer;
|
|
|
|
mPseudoTag->ToString(buffer);
|
2006-02-03 17:18:39 +03:00
|
|
|
fputs(NS_LossyConvertUTF16toASCII(buffer).get(), out);
|
1998-11-03 23:18:40 +03:00
|
|
|
fputs(" ", out);
|
|
|
|
}
|
2001-10-17 04:25:26 +04:00
|
|
|
|
2001-10-24 04:01:09 +04:00
|
|
|
if (mRuleNode) {
|
2001-10-17 04:25:26 +04:00
|
|
|
fputs("{\n", out);
|
2001-10-24 04:01:09 +04:00
|
|
|
nsRuleNode* ruleNode = mRuleNode;
|
2001-10-17 04:25:26 +04:00
|
|
|
while (ruleNode) {
|
2003-06-20 05:22:44 +04:00
|
|
|
nsIStyleRule *styleRule = ruleNode->GetRule();
|
2001-10-17 04:25:26 +04:00
|
|
|
if (styleRule) {
|
|
|
|
styleRule->List(out, aIndent + 1);
|
|
|
|
}
|
2001-10-24 04:01:09 +04:00
|
|
|
ruleNode = ruleNode->GetParent();
|
2001-10-17 04:25:26 +04:00
|
|
|
}
|
|
|
|
for (ix = aIndent; --ix >= 0; ) fputs(" ", out);
|
|
|
|
fputs("}\n", out);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fputs("{}\n", out);
|
|
|
|
}
|
|
|
|
|
1998-06-26 09:49:01 +04:00
|
|
|
if (nsnull != mChild) {
|
2001-06-01 02:19:43 +04:00
|
|
|
nsStyleContext* child = mChild;
|
1998-06-26 09:49:01 +04:00
|
|
|
do {
|
|
|
|
child->List(out, aIndent + 1);
|
1998-07-17 09:43:31 +04:00
|
|
|
child = child->mNextSibling;
|
1998-06-26 09:49:01 +04:00
|
|
|
} while (mChild != child);
|
|
|
|
}
|
1998-10-08 05:27:38 +04:00
|
|
|
if (nsnull != mEmptyChild) {
|
2001-06-01 02:19:43 +04:00
|
|
|
nsStyleContext* child = mEmptyChild;
|
1998-11-03 23:18:40 +03:00
|
|
|
do {
|
|
|
|
child->List(out, aIndent + 1);
|
|
|
|
child = child->mNextSibling;
|
|
|
|
} while (mEmptyChild != child);
|
1998-10-08 05:27:38 +04:00
|
|
|
}
|
1998-05-19 01:04:26 +04:00
|
|
|
}
|
|
|
|
|
2000-12-07 18:31:40 +03:00
|
|
|
static void IndentBy(FILE* out, PRInt32 aIndent) {
|
|
|
|
while (--aIndent >= 0) fputs(" ", out);
|
|
|
|
}
|
|
|
|
// virtual
|
2004-08-01 03:15:21 +04:00
|
|
|
void nsStyleContext::DumpRegressionData(nsPresContext* aPresContext, FILE* out, PRInt32 aIndent)
|
2000-12-07 18:31:40 +03:00
|
|
|
{
|
|
|
|
nsAutoString str;
|
|
|
|
|
|
|
|
// FONT
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleFont* font = GetStyleFont();
|
2001-09-27 22:33:58 +04:00
|
|
|
fprintf(out, "<font %s %d %d %d />\n",
|
2005-09-06 21:09:58 +04:00
|
|
|
NS_ConvertUTF16toUTF8(font->mFont.name).get(),
|
2001-09-27 22:33:58 +04:00
|
|
|
font->mFont.size,
|
|
|
|
font->mSize,
|
2001-06-01 02:19:43 +04:00
|
|
|
font->mFlags);
|
2000-12-07 18:31:40 +03:00
|
|
|
|
|
|
|
// COLOR
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleColor* color = GetStyleColor();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<color data=\"%ld\"/>\n",
|
|
|
|
(long)color->mColor);
|
2000-12-07 18:31:40 +03:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// BACKGROUND
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleBackground* bg = GetStyleBackground();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<background data=\"%d %d %d %ld %ld %ld %s\"/>\n",
|
|
|
|
(int)bg->mBackgroundAttachment,
|
|
|
|
(int)bg->mBackgroundFlags,
|
|
|
|
(int)bg->mBackgroundRepeat,
|
|
|
|
(long)bg->mBackgroundColor,
|
2004-02-09 09:55:14 +03:00
|
|
|
// XXX These aren't initialized unless flags are set:
|
2003-01-19 05:36:04 +03:00
|
|
|
(long)bg->mBackgroundXPosition.mCoord, // potentially lossy on some platforms
|
|
|
|
(long)bg->mBackgroundYPosition.mCoord, // potentially lossy on some platforms
|
2003-10-02 06:58:40 +04:00
|
|
|
URICString(bg->mBackgroundImage).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2001-02-07 12:57:26 +03:00
|
|
|
// SPACING (ie. margin, padding, border, outline)
|
2000-12-07 18:31:40 +03:00
|
|
|
IndentBy(out,aIndent);
|
|
|
|
fprintf(out, "<spacing data=\"");
|
|
|
|
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleMargin* margin = GetStyleMargin();
|
2001-06-01 02:19:43 +04:00
|
|
|
margin->mMargin.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStylePadding* padding = GetStylePadding();
|
2001-06-01 02:19:43 +04:00
|
|
|
padding->mPadding.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleBorder* border = GetStyleBorder();
|
2005-04-29 19:44:38 +04:00
|
|
|
#ifdef NS_COORD_IS_FLOAT
|
|
|
|
const char format [] = "top: %ftw right: %ftw bottom: %ftw left: %ftw";
|
|
|
|
#else
|
|
|
|
const char format [] = "top: %dtw right: %dtw bottom: %dtw left: %dtw";
|
|
|
|
#endif
|
|
|
|
nsPrintfCString output(format,
|
|
|
|
border->GetBorderWidth(NS_SIDE_TOP),
|
|
|
|
border->GetBorderWidth(NS_SIDE_RIGHT),
|
|
|
|
border->GetBorderWidth(NS_SIDE_BOTTOM),
|
|
|
|
border->GetBorderWidth(NS_SIDE_LEFT));
|
|
|
|
fprintf(out, "%s ", output.get());
|
2001-06-01 02:19:43 +04:00
|
|
|
border->mBorderRadius.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleOutline* outline = GetStyleOutline();
|
2001-06-01 02:19:43 +04:00
|
|
|
outline->mOutlineRadius.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
outline->mOutlineWidth.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "%d", (int)border->mFloatEdge);
|
2000-12-07 18:31:40 +03:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
|
|
|
// LIST
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleList* list = GetStyleList();
|
2000-12-07 18:31:40 +03:00
|
|
|
fprintf(out, "<list data=\"%d %d %s\" />\n",
|
2001-06-01 02:19:43 +04:00
|
|
|
(int)list->mListStyleType,
|
|
|
|
(int)list->mListStyleType,
|
2003-10-02 06:58:40 +04:00
|
|
|
URICString(list->mListStyleImage).get());
|
2000-12-07 18:31:40 +03:00
|
|
|
|
|
|
|
// POSITION
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStylePosition* pos = GetStylePosition();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<position data=\"");
|
|
|
|
pos->mOffset.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
pos->mWidth.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
pos->mMinWidth.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
pos->mMaxWidth.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
pos->mHeight.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
pos->mMinHeight.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
pos->mMaxHeight.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "%d ", (int)pos->mBoxSizing);
|
|
|
|
pos->mZIndex.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2000-12-07 18:31:40 +03:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
|
|
|
// TEXT
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleText* text = GetStyleText();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<text data=\"%d %d %d ",
|
|
|
|
(int)text->mTextAlign,
|
|
|
|
(int)text->mTextTransform,
|
|
|
|
(int)text->mWhiteSpace);
|
|
|
|
text->mLetterSpacing.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
text->mLineHeight.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
text->mTextIndent.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
text->mWordSpacing.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2000-12-07 18:31:40 +03:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// TEXT RESET
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleTextReset* textReset = GetStyleTextReset();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<textreset data=\"%d ",
|
|
|
|
(int)textReset->mTextDecoration);
|
|
|
|
textReset->mVerticalAlign.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
2000-12-07 18:31:40 +03:00
|
|
|
// DISPLAY
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleDisplay* disp = GetStyleDisplay();
|
2004-09-05 04:04:04 +04:00
|
|
|
fprintf(out, "<display data=\"%d %d %f %d %d %d %d %d %d %d %ld %ld %ld %ld %s\" />\n",
|
2001-06-01 02:19:43 +04:00
|
|
|
(int)disp->mPosition,
|
|
|
|
(int)disp->mDisplay,
|
2003-11-02 01:34:59 +03:00
|
|
|
(float)disp->mOpacity,
|
2001-06-01 02:19:43 +04:00
|
|
|
(int)disp->mFloats,
|
|
|
|
(int)disp->mBreakType,
|
|
|
|
(int)disp->mBreakBefore,
|
|
|
|
(int)disp->mBreakAfter,
|
2004-09-05 04:04:04 +04:00
|
|
|
(int)disp->mOverflowX,
|
|
|
|
(int)disp->mOverflowY,
|
2001-06-01 02:19:43 +04:00
|
|
|
(int)disp->mClipFlags,
|
|
|
|
(long)disp->mClip.x,
|
|
|
|
(long)disp->mClip.y,
|
|
|
|
(long)disp->mClip.width,
|
|
|
|
(long)disp->mClip.height,
|
2003-10-02 06:58:40 +04:00
|
|
|
URICString(disp->mBinding).get()
|
2000-12-07 18:31:40 +03:00
|
|
|
);
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// VISIBILITY
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleVisibility* vis = GetStyleVisibility();
|
2003-11-02 01:34:59 +03:00
|
|
|
fprintf(out, "<visibility data=\"%d %d\" />\n",
|
2001-06-01 02:19:43 +04:00
|
|
|
(int)vis->mDirection,
|
2003-11-02 01:34:59 +03:00
|
|
|
(int)vis->mVisible
|
2001-06-01 02:19:43 +04:00
|
|
|
);
|
|
|
|
|
2000-12-07 18:31:40 +03:00
|
|
|
// TABLE
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleTable* table = GetStyleTable();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<table data=\"%d %d %d ",
|
|
|
|
(int)table->mLayoutStrategy,
|
|
|
|
(int)table->mFrame,
|
|
|
|
(int)table->mRules);
|
|
|
|
fprintf(out, "%ld %ld ",
|
|
|
|
(long)table->mCols,
|
|
|
|
(long)table->mSpan);
|
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
|
|
|
// TABLEBORDER
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleTableBorder* tableBorder = GetStyleTableBorder();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<tableborder data=\"%d ",
|
|
|
|
(int)tableBorder->mBorderCollapse);
|
|
|
|
tableBorder->mBorderSpacingX.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
tableBorder->mBorderSpacingY.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "%d %d ",
|
|
|
|
(int)tableBorder->mCaptionSide,
|
|
|
|
(int)tableBorder->mEmptyCells);
|
2000-12-07 18:31:40 +03:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
|
|
|
// CONTENT
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleContent* content = GetStyleContent();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<content data=\"%ld %ld %ld ",
|
|
|
|
(long)content->ContentCount(),
|
|
|
|
(long)content->CounterIncrementCount(),
|
|
|
|
(long)content->CounterResetCount());
|
|
|
|
// XXX: iterate over the content and counters...
|
|
|
|
content->mMarkerOffset.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2000-12-07 18:31:40 +03:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// QUOTES
|
2000-12-07 18:31:40 +03:00
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleQuotes* quotes = GetStyleQuotes();
|
2001-06-01 02:19:43 +04:00
|
|
|
fprintf(out, "<quotes data=\"%ld ",
|
|
|
|
(long)quotes->QuotesCount());
|
|
|
|
// XXX: iterate over the quotes...
|
|
|
|
fprintf(out, "\" />\n");
|
2000-12-07 18:31:40 +03:00
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// UI
|
2000-12-07 18:31:40 +03:00
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleUserInterface* ui = GetStyleUserInterface();
|
2004-01-18 04:12:58 +03:00
|
|
|
fprintf(out, "<ui data=\"%d %d %d %d\" />\n",
|
2001-06-01 02:19:43 +04:00
|
|
|
(int)ui->mUserInput,
|
|
|
|
(int)ui->mUserModify,
|
|
|
|
(int)ui->mUserFocus,
|
2004-01-18 04:12:58 +03:00
|
|
|
(int)ui->mCursor);
|
2001-06-01 02:19:43 +04:00
|
|
|
|
|
|
|
// UIReset
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleUIReset* uiReset = GetStyleUIReset();
|
2007-05-16 19:51:37 +04:00
|
|
|
fprintf(out, "<uireset data=\"%d %d\" />\n",
|
|
|
|
(int)uiReset->mUserSelect,
|
|
|
|
(int)uiReset->mIMEMode);
|
2001-05-03 17:20:48 +04:00
|
|
|
|
2004-06-17 15:57:37 +04:00
|
|
|
// Column
|
|
|
|
IndentBy(out,aIndent);
|
|
|
|
const nsStyleColumn* column = GetStyleColumn();
|
|
|
|
fprintf(out, "<column data=\"%d ",
|
|
|
|
(int)column->mColumnCount);
|
|
|
|
column->mColumnWidth.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s ", NS_ConvertUTF16toUTF8(str).get());
|
2004-07-18 16:12:46 +04:00
|
|
|
column->mColumnGap.ToString(str);
|
2005-09-06 21:09:58 +04:00
|
|
|
fprintf(out, "%s", NS_ConvertUTF16toUTF8(str).get());
|
2004-06-17 15:57:37 +04:00
|
|
|
fprintf(out, "\" />\n");
|
|
|
|
|
2001-05-03 17:20:48 +04:00
|
|
|
// XUL
|
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleXUL* xul = GetStyleXUL();
|
2001-09-26 03:35:36 +04:00
|
|
|
fprintf(out, "<xul data=\"%d %d %d %d %d %d",
|
2001-08-02 04:09:27 +04:00
|
|
|
(int)xul->mBoxAlign,
|
|
|
|
(int)xul->mBoxDirection,
|
|
|
|
(int)xul->mBoxFlex,
|
|
|
|
(int)xul->mBoxOrient,
|
2001-09-26 02:17:00 +04:00
|
|
|
(int)xul->mBoxPack,
|
|
|
|
(int)xul->mBoxOrdinal);
|
2002-02-14 17:54:06 +03:00
|
|
|
fprintf(out, "\" />\n");
|
2001-12-12 10:59:31 +03:00
|
|
|
|
|
|
|
#ifdef MOZ_SVG
|
Landing of SVG_20020806_BRANCH, Bug 182533. Refactoring of SVG backend, new GDI+ and Libart rendering
backends, text support on Windows (GDI+), rudimentary text support on Linux (libart/freetype2), presentation
attributes, lots of bug fixes (see bug 182533 for dependency list).
Not part of default build; code is #ifdef'ed out.
r=sicking, sr=jst for dom and htmlparser changes
r=bsmedberg, sr=tor for config changes
r=dbaron, sr=bzbarsky for content and layout changes
r=tor, sr=bzbarsky for gfx changes
2004-02-07 15:39:26 +03:00
|
|
|
// SVG
|
2001-12-12 10:59:31 +03:00
|
|
|
IndentBy(out,aIndent);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleSVG* svg = GetStyleSVG();
|
2004-10-15 03:02:53 +04:00
|
|
|
fprintf(out, "<svg data=\"%d ",(int)svg->mFill.mType);
|
|
|
|
if (svg->mFill.mType == eStyleSVGPaintType_Server)
|
2007-01-09 14:02:17 +03:00
|
|
|
fprintf(out, "%s %ld ", URICString(svg->mFill.mPaint.mPaintServer).get(),
|
|
|
|
(long)svg->mFill.mFallbackColor);
|
2004-10-15 03:02:53 +04:00
|
|
|
else
|
|
|
|
fprintf(out, "%ld ", (long)svg->mFill.mPaint.mColor);
|
2005-01-25 06:55:03 +03:00
|
|
|
|
|
|
|
fprintf(out, "%d ", (int)svg->mStroke.mType);
|
2004-10-15 03:02:53 +04:00
|
|
|
if (svg->mStroke.mType == eStyleSVGPaintType_Server)
|
2007-01-09 14:02:17 +03:00
|
|
|
fprintf(out, "%s %ld ", URICString(svg->mStroke.mPaint.mPaintServer).get(),
|
|
|
|
(long)svg->mStroke.mFallbackColor);
|
2004-10-15 03:02:53 +04:00
|
|
|
else
|
|
|
|
fprintf(out, "%ld ", (long)svg->mStroke.mPaint.mColor);
|
2005-01-25 06:55:03 +03:00
|
|
|
|
2005-04-05 01:42:26 +04:00
|
|
|
fprintf(out, "%s %s %s ",
|
2005-01-25 06:55:03 +03:00
|
|
|
URICString(svg->mMarkerEnd).get(),
|
|
|
|
URICString(svg->mMarkerMid).get(),
|
|
|
|
URICString(svg->mMarkerStart).get());
|
|
|
|
|
2005-09-06 21:07:18 +04:00
|
|
|
for (PRUint32 i = 0; i < svg->mStrokeDasharrayLength; i++) {
|
|
|
|
svg->mStrokeDasharray[i].ToString(str);
|
2004-11-09 21:19:28 +03:00
|
|
|
fprintf(out,
|
2005-09-06 21:07:18 +04:00
|
|
|
"%s%c",
|
2005-09-06 21:09:58 +04:00
|
|
|
NS_ConvertUTF16toUTF8(str).get(),
|
2004-11-09 21:19:28 +03:00
|
|
|
(i == svg->mStrokeDasharrayLength) ? ' ' : ',');
|
2005-09-06 21:07:18 +04:00
|
|
|
}
|
2005-01-25 06:55:03 +03:00
|
|
|
|
2005-09-06 21:07:18 +04:00
|
|
|
svg->mStrokeDashoffset.ToString(str);
|
2007-01-09 23:40:09 +03:00
|
|
|
fprintf(out, "%f %s %f %f ",
|
2005-01-25 06:55:03 +03:00
|
|
|
svg->mFillOpacity,
|
2005-09-06 21:09:58 +04:00
|
|
|
NS_ConvertUTF16toUTF8(str).get(),
|
Landing of SVG_20020806_BRANCH, Bug 182533. Refactoring of SVG backend, new GDI+ and Libart rendering
backends, text support on Windows (GDI+), rudimentary text support on Linux (libart/freetype2), presentation
attributes, lots of bug fixes (see bug 182533 for dependency list).
Not part of default build; code is #ifdef'ed out.
r=sicking, sr=jst for dom and htmlparser changes
r=bsmedberg, sr=tor for config changes
r=dbaron, sr=bzbarsky for content and layout changes
r=tor, sr=bzbarsky for gfx changes
2004-02-07 15:39:26 +03:00
|
|
|
svg->mStrokeMiterlimit,
|
2007-01-09 23:40:09 +03:00
|
|
|
svg->mStrokeOpacity);
|
2005-09-06 21:07:18 +04:00
|
|
|
svg->mStrokeWidth.ToString(str);
|
2007-01-30 16:19:55 +03:00
|
|
|
fprintf(out, "%s %d %d %d %d %d %d %d %d %d %d %d\" />\n",
|
2005-09-06 21:09:58 +04:00
|
|
|
NS_ConvertUTF16toUTF8(str).get(),
|
2005-01-25 06:55:03 +03:00
|
|
|
(int)svg->mStrokeDasharrayLength,
|
|
|
|
(int)svg->mClipRule,
|
2007-01-30 16:19:55 +03:00
|
|
|
(int)svg->mColorInterpolation,
|
|
|
|
(int)svg->mColorInterpolationFilters,
|
2005-01-25 06:55:03 +03:00
|
|
|
(int)svg->mFillRule,
|
|
|
|
(int)svg->mPointerEvents,
|
|
|
|
(int)svg->mShapeRendering,
|
|
|
|
(int)svg->mStrokeLinecap,
|
|
|
|
(int)svg->mStrokeLinejoin,
|
Landing of SVG_20020806_BRANCH, Bug 182533. Refactoring of SVG backend, new GDI+ and Libart rendering
backends, text support on Windows (GDI+), rudimentary text support on Linux (libart/freetype2), presentation
attributes, lots of bug fixes (see bug 182533 for dependency list).
Not part of default build; code is #ifdef'ed out.
r=sicking, sr=jst for dom and htmlparser changes
r=bsmedberg, sr=tor for config changes
r=dbaron, sr=bzbarsky for content and layout changes
r=tor, sr=bzbarsky for gfx changes
2004-02-07 15:39:26 +03:00
|
|
|
(int)svg->mTextAnchor,
|
|
|
|
(int)svg->mTextRendering);
|
|
|
|
|
|
|
|
// SVGReset
|
|
|
|
IndentBy(out,aIndent);
|
|
|
|
const nsStyleSVGReset* svgReset = GetStyleSVGReset();
|
2005-04-05 01:42:26 +04:00
|
|
|
|
2007-01-09 14:02:17 +03:00
|
|
|
fprintf(out, "<svgreset data=\"%ld ", (long)svgReset->mStopColor);
|
2005-04-05 01:42:26 +04:00
|
|
|
|
2007-01-09 23:40:09 +03:00
|
|
|
fprintf(out, "%ld ", (long)svgReset->mFloodColor);
|
|
|
|
|
|
|
|
fprintf(out, "%s %s %s %f %f %d\" />\n",
|
2005-01-25 06:55:03 +03:00
|
|
|
URICString(svgReset->mClipPath).get(),
|
2005-09-07 02:30:40 +04:00
|
|
|
URICString(svgReset->mFilter).get(),
|
2006-01-20 20:00:43 +03:00
|
|
|
URICString(svgReset->mMask).get(),
|
2005-04-05 01:42:26 +04:00
|
|
|
svgReset->mStopOpacity,
|
2007-01-09 23:40:09 +03:00
|
|
|
svgReset->mFloodOpacity,
|
Landing of SVG_20020806_BRANCH, Bug 182533. Refactoring of SVG backend, new GDI+ and Libart rendering
backends, text support on Windows (GDI+), rudimentary text support on Linux (libart/freetype2), presentation
attributes, lots of bug fixes (see bug 182533 for dependency list).
Not part of default build; code is #ifdef'ed out.
r=sicking, sr=jst for dom and htmlparser changes
r=bsmedberg, sr=tor for config changes
r=dbaron, sr=bzbarsky for content and layout changes
r=tor, sr=bzbarsky for gfx changes
2004-02-07 15:39:26 +03:00
|
|
|
(int)svgReset->mDominantBaseline);
|
2001-05-03 17:20:48 +04:00
|
|
|
#endif
|
|
|
|
//#insert new style structs here#
|
2000-12-07 18:31:40 +03:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
// Overloaded new operator. Initializes the memory to 0 and relies on an arena
|
|
|
|
// (which comes from the presShell) to perform the allocation.
|
|
|
|
void*
|
2004-08-01 03:15:21 +04:00
|
|
|
nsStyleContext::operator new(size_t sz, nsPresContext* aPresContext) CPP_THROW_NEW
|
2001-06-01 02:19:43 +04:00
|
|
|
{
|
|
|
|
// Check the recycle list first.
|
2004-04-13 04:28:44 +04:00
|
|
|
return aPresContext->AllocateFromShell(sz);
|
2001-06-01 02:19:43 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Overridden to prevent the global delete from being called, since the memory
|
|
|
|
// came out of an nsIArena instead of the global delete operator's heap.
|
|
|
|
void
|
|
|
|
nsStyleContext::Destroy()
|
|
|
|
{
|
|
|
|
// Get the pres context from our rule node.
|
2004-08-01 03:15:21 +04:00
|
|
|
nsCOMPtr<nsPresContext> presContext = mRuleNode->GetPresContext();
|
2001-06-01 02:19:43 +04:00
|
|
|
|
|
|
|
// Call our destructor.
|
|
|
|
this->~nsStyleContext();
|
|
|
|
|
|
|
|
// Don't let the memory be freed, since it will be recycled
|
|
|
|
// instead. Don't call the global operator delete.
|
|
|
|
presContext->FreeToShell(sizeof(nsStyleContext), this);
|
|
|
|
}
|
|
|
|
|
2003-02-22 03:32:13 +03:00
|
|
|
already_AddRefed<nsStyleContext>
|
|
|
|
NS_NewStyleContext(nsStyleContext* aParentContext,
|
1998-11-03 23:18:40 +03:00
|
|
|
nsIAtom* aPseudoTag,
|
2001-10-24 04:01:09 +04:00
|
|
|
nsRuleNode* aRuleNode,
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* aPresContext)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
2001-06-01 02:19:43 +04:00
|
|
|
nsStyleContext* context = new (aPresContext) nsStyleContext(aParentContext, aPseudoTag,
|
2001-10-24 04:01:09 +04:00
|
|
|
aRuleNode, aPresContext);
|
2003-02-22 03:32:13 +03:00
|
|
|
if (context)
|
|
|
|
context->AddRef();
|
|
|
|
return context;
|
2000-06-22 00:44:59 +04:00
|
|
|
}
|
|
|
|
|