mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-14 10:43:24 +00:00
2090 lines
65 KiB
C++
2090 lines
65 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
#include "nsIHTMLStyleSheet.h"
|
|
#include "nsIArena.h"
|
|
#include "nsCRT.h"
|
|
#include "nsIAtom.h"
|
|
#include "nsIURL.h"
|
|
#include "nsISupportsArray.h"
|
|
#include "nsHashtable.h"
|
|
#include "nsIHTMLContent.h"
|
|
#include "nsIHTMLAttributes.h"
|
|
#include "nsIStyleRule.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsIStyleContext.h"
|
|
#include "nsHTMLAtoms.h"
|
|
#include "nsIPresContext.h"
|
|
#include "nsILinkHandler.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIHTMLTableCellElement.h"
|
|
#include "nsTableColFrame.h"
|
|
#include "nsTableFrame.h"
|
|
#include "nsHTMLIIDs.h"
|
|
#include "nsIStyleFrameConstruction.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIViewManager.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsTableOuterFrame.h"
|
|
|
|
static NS_DEFINE_IID(kIHTMLStyleSheetIID, NS_IHTML_STYLE_SHEET_IID);
|
|
static NS_DEFINE_IID(kIStyleSheetIID, NS_ISTYLE_SHEET_IID);
|
|
static NS_DEFINE_IID(kIStyleRuleIID, NS_ISTYLE_RULE_IID);
|
|
static NS_DEFINE_IID(kIStyleFrameConstructionIID, NS_ISTYLE_FRAME_CONSTRUCTION_IID);
|
|
static NS_DEFINE_IID(kIHTMLTableCellElementIID, NS_IHTMLTABLECELLELEMENT_IID);
|
|
|
|
|
|
class HTMLAnchorRule : public nsIStyleRule {
|
|
public:
|
|
HTMLAnchorRule();
|
|
~HTMLAnchorRule();
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD Equals(const nsIStyleRule* aRule, PRBool& aValue) const;
|
|
NS_IMETHOD HashValue(PRUint32& aValue) const;
|
|
// Strength is an out-of-band weighting, always 0 here
|
|
NS_IMETHOD GetStrength(PRInt32& aStrength);
|
|
|
|
NS_IMETHOD MapStyleInto(nsIStyleContext* aContext, nsIPresContext* aPresContext);
|
|
|
|
NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const;
|
|
|
|
nscolor mColor;
|
|
};
|
|
|
|
HTMLAnchorRule::HTMLAnchorRule()
|
|
{
|
|
NS_INIT_REFCNT();
|
|
}
|
|
|
|
HTMLAnchorRule::~HTMLAnchorRule()
|
|
{
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(HTMLAnchorRule, kIStyleRuleIID);
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorRule::Equals(const nsIStyleRule* aRule, PRBool& aResult) const
|
|
{
|
|
aResult = PRBool(this == aRule);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorRule::HashValue(PRUint32& aValue) const
|
|
{
|
|
aValue = (PRUint32)(mColor);
|
|
return NS_OK;
|
|
}
|
|
|
|
// Strength is an out-of-band weighting, always 0 here
|
|
NS_IMETHODIMP
|
|
HTMLAnchorRule::GetStrength(PRInt32& aStrength)
|
|
{
|
|
aStrength = 0;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorRule::MapStyleInto(nsIStyleContext* aContext, nsIPresContext* aPresContext)
|
|
{
|
|
nsStyleColor* styleColor = (nsStyleColor*)(aContext->GetMutableStyleData(eStyleStruct_Color));
|
|
|
|
if (nsnull != styleColor) {
|
|
styleColor->mColor = mColor;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLAnchorRule::List(FILE* out, PRInt32 aIndent) const
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
// -----------------------------------------------------------
|
|
|
|
class AttributeKey: public nsHashKey
|
|
{
|
|
public:
|
|
AttributeKey(nsMapAttributesFunc aMapFunc, nsIHTMLAttributes* aAttributes);
|
|
virtual ~AttributeKey(void);
|
|
|
|
PRBool Equals(const nsHashKey* aOther) const;
|
|
PRUint32 HashValue(void) const;
|
|
nsHashKey* Clone(void) const;
|
|
|
|
private:
|
|
AttributeKey(void);
|
|
AttributeKey(const AttributeKey& aCopy);
|
|
AttributeKey& operator=(const AttributeKey& aCopy);
|
|
|
|
public:
|
|
nsMapAttributesFunc mMapFunc;
|
|
nsIHTMLAttributes* mAttributes;
|
|
PRUint32 mHashSet: 1;
|
|
PRUint32 mHashCode: 31;
|
|
};
|
|
|
|
AttributeKey::AttributeKey(nsMapAttributesFunc aMapFunc, nsIHTMLAttributes* aAttributes)
|
|
: mMapFunc(aMapFunc),
|
|
mAttributes(aAttributes)
|
|
{
|
|
NS_ADDREF(mAttributes);
|
|
mHashSet = 0;
|
|
mHashCode = 0;
|
|
}
|
|
|
|
AttributeKey::~AttributeKey(void)
|
|
{
|
|
NS_RELEASE(mAttributes);
|
|
}
|
|
|
|
PRBool AttributeKey::Equals(const nsHashKey* aOther) const
|
|
{
|
|
const AttributeKey* other = (const AttributeKey*)aOther;
|
|
if (mMapFunc == other->mMapFunc) {
|
|
PRBool equals;
|
|
mAttributes->Equals(other->mAttributes, equals);
|
|
return equals;
|
|
}
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRUint32 AttributeKey::HashValue(void) const
|
|
{
|
|
if (0 == mHashSet) {
|
|
AttributeKey* self = (AttributeKey*)this; // break const
|
|
PRUint32 hash;
|
|
mAttributes->HashValue(hash);
|
|
self->mHashCode = (0x7FFFFFFF & hash);
|
|
self->mHashCode |= (0x7FFFFFFF & PRUint32(mMapFunc));
|
|
self->mHashSet = 1;
|
|
}
|
|
return mHashCode;
|
|
}
|
|
|
|
nsHashKey* AttributeKey::Clone(void) const
|
|
{
|
|
AttributeKey* clown = new AttributeKey(mMapFunc, mAttributes);
|
|
if (nsnull != clown) {
|
|
clown->mHashSet = mHashSet;
|
|
clown->mHashCode = mHashCode;
|
|
}
|
|
return clown;
|
|
}
|
|
|
|
// -----------------------------------------------------------
|
|
|
|
class HTMLStyleSheetImpl : public nsIHTMLStyleSheet,
|
|
public nsIStyleFrameConstruction {
|
|
public:
|
|
void* operator new(size_t size);
|
|
void* operator new(size_t size, nsIArena* aArena);
|
|
void operator delete(void* ptr);
|
|
|
|
HTMLStyleSheetImpl(nsIURL* aURL);
|
|
|
|
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
|
|
NS_IMETHOD_(nsrefcnt) AddRef();
|
|
NS_IMETHOD_(nsrefcnt) Release();
|
|
|
|
virtual PRInt32 RulesMatching(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsISupportsArray* aResults);
|
|
|
|
virtual PRInt32 RulesMatching(nsIPresContext* aPresContext,
|
|
nsIAtom* aPseudoTag,
|
|
nsIFrame* aParentFrame,
|
|
nsISupportsArray* aResults);
|
|
|
|
virtual nsIURL* GetURL(void);
|
|
|
|
NS_IMETHOD SetLinkColor(nscolor aColor);
|
|
NS_IMETHOD SetActiveLinkColor(nscolor aColor);
|
|
NS_IMETHOD SetVisitedLinkColor(nscolor aColor);
|
|
|
|
// Attribute management methods, aAttributes is an in/out param
|
|
NS_IMETHOD SetAttributesFor(nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
NS_IMETHOD SetIDFor(nsIAtom* aID, nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
NS_IMETHOD SetClassFor(nsIAtom* aClass, nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
NS_IMETHOD SetAttributeFor(nsIAtom* aAttribute, const nsString& aValue,
|
|
nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
NS_IMETHOD SetAttributeFor(nsIAtom* aAttribute, const nsHTMLValue& aValue,
|
|
nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
NS_IMETHOD UnsetAttributeFor(nsIAtom* aAttribute, nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
|
|
NS_IMETHOD ConstructFrame(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIFrame*& aFrameSubTree);
|
|
|
|
NS_IMETHOD ContentAppended(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
PRInt32 aNewIndexInContainer);
|
|
|
|
NS_IMETHOD ContentInserted(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
PRInt32 aIndexInContainer);
|
|
|
|
NS_IMETHOD ContentReplaced(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
nsIContent* aOldChild,
|
|
nsIContent* aNewChild,
|
|
PRInt32 aIndexInContainer);
|
|
|
|
NS_IMETHOD ContentRemoved(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
PRInt32 aIndexInContainer);
|
|
|
|
NS_IMETHOD ContentChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsISupports* aSubContent);
|
|
NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIAtom* aAttribute,
|
|
PRInt32 aHint);
|
|
|
|
// XXX style rule enumerations
|
|
|
|
virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const;
|
|
|
|
private:
|
|
// These are not supported and are not implemented!
|
|
HTMLStyleSheetImpl(const HTMLStyleSheetImpl& aCopy);
|
|
HTMLStyleSheetImpl& operator=(const HTMLStyleSheetImpl& aCopy);
|
|
|
|
protected:
|
|
virtual ~HTMLStyleSheetImpl();
|
|
|
|
NS_IMETHOD EnsureSingleAttributes(nsIHTMLAttributes*& aAttributes,
|
|
nsMapAttributesFunc aMapFunc,
|
|
PRBool aCreate,
|
|
nsIHTMLAttributes*& aSingleAttrs);
|
|
NS_IMETHOD UniqueAttributes(nsIHTMLAttributes*& aSingleAttrs,
|
|
nsMapAttributesFunc aMapFunc,
|
|
PRInt32 aAttrCount,
|
|
nsIHTMLAttributes*& aAttributes);
|
|
|
|
nsresult ConstructRootFrame(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame);
|
|
|
|
nsresult ConstructTableFrame(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame);
|
|
|
|
nsresult ConstructFrameByTag(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIAtom* aTag,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame);
|
|
|
|
nsresult ConstructFrameByDisplayType(nsIPresContext* aPresContext,
|
|
const nsStyleDisplay* aDisplay,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame);
|
|
|
|
nsresult GetAdjustedParentFrame(nsIFrame* aCurrentParentFrame,
|
|
PRUint8 aChildDisplayType,
|
|
nsIFrame*& aNewParentFrame);
|
|
|
|
|
|
nsresult ProcessChildren(nsIPresContext* aPresContext,
|
|
nsIFrame* aFrame,
|
|
nsIContent* aContent,
|
|
nsIFrame*& aChildList);
|
|
|
|
nsresult CreateInputFrame(nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIFrame*& aFrame);
|
|
|
|
PRBool IsScrollable(nsIFrame* aFrame, const nsStyleDisplay* aDisplay);
|
|
|
|
protected:
|
|
PRUint32 mInHeap : 1;
|
|
PRUint32 mRefCnt : 31;
|
|
|
|
nsIURL* mURL;
|
|
HTMLAnchorRule* mLinkRule;
|
|
HTMLAnchorRule* mVisitedRule;
|
|
HTMLAnchorRule* mActiveRule;
|
|
nsHashtable mAttrTable;
|
|
nsIHTMLAttributes* mRecycledAttrs;
|
|
};
|
|
|
|
|
|
void* HTMLStyleSheetImpl::operator new(size_t size)
|
|
{
|
|
HTMLStyleSheetImpl* rv = (HTMLStyleSheetImpl*) ::operator new(size);
|
|
#ifdef NS_DEBUG
|
|
if (nsnull != rv) {
|
|
nsCRT::memset(rv, 0xEE, size);
|
|
}
|
|
#endif
|
|
rv->mInHeap = 1;
|
|
return (void*) rv;
|
|
}
|
|
|
|
void* HTMLStyleSheetImpl::operator new(size_t size, nsIArena* aArena)
|
|
{
|
|
HTMLStyleSheetImpl* rv = (HTMLStyleSheetImpl*) aArena->Alloc(PRInt32(size));
|
|
#ifdef NS_DEBUG
|
|
if (nsnull != rv) {
|
|
nsCRT::memset(rv, 0xEE, size);
|
|
}
|
|
#endif
|
|
rv->mInHeap = 0;
|
|
return (void*) rv;
|
|
}
|
|
|
|
void HTMLStyleSheetImpl::operator delete(void* ptr)
|
|
{
|
|
HTMLStyleSheetImpl* sheet = (HTMLStyleSheetImpl*) ptr;
|
|
if (nsnull != sheet) {
|
|
if (sheet->mInHeap) {
|
|
::delete ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
HTMLStyleSheetImpl::HTMLStyleSheetImpl(nsIURL* aURL)
|
|
: nsIHTMLStyleSheet(),
|
|
mURL(aURL),
|
|
mLinkRule(nsnull),
|
|
mVisitedRule(nsnull),
|
|
mActiveRule(nsnull),
|
|
mRecycledAttrs(nsnull)
|
|
{
|
|
NS_INIT_REFCNT();
|
|
NS_ADDREF(mURL);
|
|
}
|
|
|
|
HTMLStyleSheetImpl::~HTMLStyleSheetImpl()
|
|
{
|
|
NS_RELEASE(mURL);
|
|
NS_IF_RELEASE(mLinkRule);
|
|
NS_IF_RELEASE(mVisitedRule);
|
|
NS_IF_RELEASE(mActiveRule);
|
|
NS_IF_RELEASE(mRecycledAttrs);
|
|
}
|
|
|
|
NS_IMPL_ADDREF(HTMLStyleSheetImpl)
|
|
NS_IMPL_RELEASE(HTMLStyleSheetImpl)
|
|
|
|
nsresult HTMLStyleSheetImpl::QueryInterface(const nsIID& aIID,
|
|
void** aInstancePtrResult)
|
|
{
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
if (nsnull == aInstancePtrResult) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
if (aIID.Equals(kIHTMLStyleSheetIID)) {
|
|
*aInstancePtrResult = (void*) ((nsIHTMLStyleSheet*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIStyleSheetIID)) {
|
|
*aInstancePtrResult = (void*) ((nsIStyleSheet*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kIStyleFrameConstructionIID)) {
|
|
*aInstancePtrResult = (void*) ((nsIStyleFrameConstruction*)this);
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
if (aIID.Equals(kISupportsIID)) {
|
|
*aInstancePtrResult = (void*) this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
struct AppendData
|
|
{
|
|
AppendData(PRInt32 aBackstopCount, PRInt32 aInsertPoint, nsISupportsArray* aResults)
|
|
: mCount(0),
|
|
mBackstop(aBackstopCount),
|
|
mInsert(aInsertPoint),
|
|
mResults(aResults)
|
|
{}
|
|
|
|
PRInt32 mCount;
|
|
PRInt32 mBackstop;
|
|
PRInt32 mInsert;
|
|
nsISupportsArray* mResults;
|
|
};
|
|
|
|
PRBool AppendFunc(nsISupports* aElement, void *aData)
|
|
{
|
|
AppendData* data = (AppendData*)aData;
|
|
if (data->mCount < data->mBackstop) {
|
|
data->mResults->InsertElementAt(aElement, data->mInsert++);
|
|
}
|
|
else {
|
|
data->mResults->AppendElement(aElement);
|
|
}
|
|
data->mCount++;
|
|
return PR_TRUE;
|
|
}
|
|
|
|
PRInt32 AppendRulesFrom(nsIFrame* aFrame, nsIPresContext* aPresContext, PRInt32& aInsertPoint, nsISupportsArray* aResults)
|
|
{
|
|
PRInt32 count = 0;
|
|
nsIStyleContext* context;
|
|
aFrame->GetStyleContext(aPresContext, context);
|
|
if (nsnull != context) {
|
|
count = context->GetStyleRuleCount();
|
|
if (0 < count) {
|
|
PRInt32 backstopCount = context->GetBackstopStyleRuleCount();
|
|
nsISupportsArray* rules = context->GetStyleRules();
|
|
|
|
AppendData data(backstopCount, aInsertPoint, aResults);
|
|
rules->EnumerateForwards(AppendFunc, &data);
|
|
aInsertPoint = data.mInsert;
|
|
NS_RELEASE(rules);
|
|
}
|
|
NS_RELEASE(context);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
PRInt32 HTMLStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsISupportsArray* aResults)
|
|
{
|
|
NS_PRECONDITION(nsnull != aPresContext, "null arg");
|
|
NS_PRECONDITION(nsnull != aContent, "null arg");
|
|
// NS_PRECONDITION(nsnull != aParentFrame, "null arg");
|
|
NS_PRECONDITION(nsnull != aResults, "null arg");
|
|
|
|
PRInt32 matchCount = 0;
|
|
|
|
nsIContent* parentContent = nsnull;
|
|
if (nsnull != aParentFrame) {
|
|
aParentFrame->GetContent(parentContent);
|
|
}
|
|
|
|
if (aContent != parentContent) { // if not a pseudo frame...
|
|
nsIHTMLContent* htmlContent;
|
|
if (NS_OK == aContent->QueryInterface(kIHTMLContentIID, (void**)&htmlContent)) {
|
|
nsIAtom* tag;
|
|
htmlContent->GetTag(tag);
|
|
// if we have anchor colors, check if this is an anchor with an href
|
|
if (tag == nsHTMLAtoms::a) {
|
|
if ((nsnull != mLinkRule) || (nsnull != mVisitedRule) || (nsnull != mActiveRule)) {
|
|
// test link state
|
|
nsILinkHandler* linkHandler;
|
|
|
|
if ((NS_OK == aPresContext->GetLinkHandler(&linkHandler)) &&
|
|
(nsnull != linkHandler)) {
|
|
nsAutoString base, href; // XXX base??
|
|
nsresult attrState = htmlContent->GetAttribute("href", href);
|
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == attrState) {
|
|
nsIURL* docURL = nsnull;
|
|
nsIDocument* doc = nsnull;
|
|
aContent->GetDocument(doc);
|
|
if (nsnull != doc) {
|
|
docURL = doc->GetDocumentURL();
|
|
NS_RELEASE(doc);
|
|
}
|
|
|
|
nsAutoString absURLSpec;
|
|
nsresult rv = NS_MakeAbsoluteURL(docURL, base, href, absURLSpec);
|
|
NS_IF_RELEASE(docURL);
|
|
|
|
nsLinkState state;
|
|
if (NS_OK == linkHandler->GetLinkState(absURLSpec, state)) {
|
|
switch (state) {
|
|
case eLinkState_Unvisited:
|
|
if (nsnull != mLinkRule) {
|
|
aResults->AppendElement(mLinkRule);
|
|
matchCount++;
|
|
}
|
|
break;
|
|
case eLinkState_Visited:
|
|
if (nsnull != mVisitedRule) {
|
|
aResults->AppendElement(mVisitedRule);
|
|
matchCount++;
|
|
}
|
|
break;
|
|
case eLinkState_Active:
|
|
if (nsnull != mActiveRule) {
|
|
aResults->AppendElement(mActiveRule);
|
|
matchCount++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
NS_RELEASE(linkHandler);
|
|
}
|
|
}
|
|
} // end A tag
|
|
else if ((tag == nsHTMLAtoms::td) || (tag == nsHTMLAtoms::th)) {
|
|
// propogate row/col style rules
|
|
// XXX: this approach has a few caveats
|
|
// behavior is bound to HTML content
|
|
// makes table cells process attributes from other content
|
|
// inherit based style (ie: font-size: 110%) can double on row & cell
|
|
PRInt32 backstopInsertPoint = 0;
|
|
|
|
nsIFrame* rowFrame = aParentFrame;
|
|
nsIFrame* rowGroupFrame;
|
|
nsIFrame* tableFrame;
|
|
|
|
rowFrame->GetContentParent(rowGroupFrame);
|
|
rowGroupFrame->GetContentParent(tableFrame);
|
|
|
|
nsIHTMLTableCellElement* cell=nsnull;
|
|
nsresult rv = aContent->QueryInterface(kIHTMLTableCellElementIID,
|
|
(void **)&cell); // cell: REFCNT++
|
|
if (NS_SUCCEEDED(rv)) {
|
|
PRInt32 colIndex;
|
|
rv = cell->GetColIndex(&colIndex);
|
|
nsTableColFrame* colFrame;
|
|
nsIFrame* colGroupFrame;
|
|
|
|
// XXX CONSTRUCTION.
|
|
// Unfortunately the table's children haven't been added yet...
|
|
#if 0
|
|
((nsTableFrame*)tableFrame)->GetColumnFrame(colIndex, colFrame);
|
|
colFrame->GetContentParent(colGroupFrame);
|
|
|
|
matchCount += AppendRulesFrom(colGroupFrame, aPresContext, backstopInsertPoint, aResults);
|
|
matchCount += AppendRulesFrom(colFrame, aPresContext, backstopInsertPoint, aResults);
|
|
#endif
|
|
NS_RELEASE(cell); // cell: REFCNT--
|
|
}
|
|
matchCount += AppendRulesFrom(rowGroupFrame, aPresContext, backstopInsertPoint, aResults);
|
|
matchCount += AppendRulesFrom(rowFrame, aPresContext, backstopInsertPoint, aResults);
|
|
} // end TD/TH tag
|
|
|
|
// just get the one and only style rule from the content
|
|
nsIStyleRule* rule;
|
|
htmlContent->GetStyleRule(rule);
|
|
if (nsnull != rule) {
|
|
aResults->AppendElement(rule);
|
|
NS_RELEASE(rule);
|
|
matchCount++;
|
|
}
|
|
|
|
NS_IF_RELEASE(tag);
|
|
NS_RELEASE(htmlContent);
|
|
}
|
|
}
|
|
NS_IF_RELEASE(parentContent);
|
|
|
|
return matchCount;
|
|
}
|
|
|
|
PRInt32 HTMLStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
|
|
nsIAtom* aPseudoTag,
|
|
nsIFrame* aParentFrame,
|
|
nsISupportsArray* aResults)
|
|
{
|
|
// no pseudo frame style
|
|
return 0;
|
|
}
|
|
|
|
|
|
nsIURL* HTMLStyleSheetImpl::GetURL(void)
|
|
{
|
|
NS_ADDREF(mURL);
|
|
return mURL;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetLinkColor(nscolor aColor)
|
|
{
|
|
if (nsnull == mLinkRule) {
|
|
mLinkRule = new HTMLAnchorRule();
|
|
if (nsnull == mLinkRule) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
NS_ADDREF(mLinkRule);
|
|
}
|
|
mLinkRule->mColor = aColor;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetActiveLinkColor(nscolor aColor)
|
|
{
|
|
if (nsnull == mActiveRule) {
|
|
mActiveRule = new HTMLAnchorRule();
|
|
if (nsnull == mActiveRule) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
NS_ADDREF(mActiveRule);
|
|
}
|
|
mActiveRule->mColor = aColor;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetVisitedLinkColor(nscolor aColor)
|
|
{
|
|
if (nsnull == mVisitedRule) {
|
|
mVisitedRule = new HTMLAnchorRule();
|
|
if (nsnull == mVisitedRule) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
NS_ADDREF(mVisitedRule);
|
|
}
|
|
mVisitedRule->mColor = aColor;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetAttributesFor(nsIHTMLContent* aContent, nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsIHTMLAttributes* attrs = aAttributes;
|
|
|
|
if (nsnull != attrs) {
|
|
nsMapAttributesFunc mapFunc;
|
|
aContent->GetAttributeMappingFunction(mapFunc);
|
|
AttributeKey key(mapFunc, attrs);
|
|
nsIHTMLAttributes* sharedAttrs = (nsIHTMLAttributes*)mAttrTable.Get(&key);
|
|
if (nsnull == sharedAttrs) { // we have a new unique set
|
|
mAttrTable.Put(&key, attrs);
|
|
}
|
|
else { // found existing set
|
|
if (sharedAttrs != aAttributes) {
|
|
aAttributes->ReleaseContentRef();
|
|
NS_RELEASE(aAttributes); // release content's ref
|
|
|
|
aAttributes = sharedAttrs;
|
|
aAttributes->AddContentRef();
|
|
NS_ADDREF(aAttributes); // add ref for content
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetIDFor(nsIAtom* aID, nsIHTMLContent* aContent, nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsresult result = NS_OK;
|
|
nsIHTMLAttributes* attrs;
|
|
PRBool hasValue = PRBool(nsnull != aID);
|
|
nsMapAttributesFunc mapFunc;
|
|
|
|
aContent->GetAttributeMappingFunction(mapFunc);
|
|
|
|
result = EnsureSingleAttributes(aAttributes, mapFunc, hasValue, attrs);
|
|
|
|
if ((NS_OK == result) && (nsnull != attrs)) {
|
|
PRInt32 count;
|
|
attrs->SetID(aID, count);
|
|
|
|
result = UniqueAttributes(attrs, mapFunc, count, aAttributes);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetClassFor(nsIAtom* aClass, nsIHTMLContent* aContent, nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsresult result = NS_OK;
|
|
nsIHTMLAttributes* attrs;
|
|
PRBool hasValue = PRBool(nsnull != aClass);
|
|
nsMapAttributesFunc mapFunc;
|
|
|
|
aContent->GetAttributeMappingFunction(mapFunc);
|
|
|
|
result = EnsureSingleAttributes(aAttributes, mapFunc, hasValue, attrs);
|
|
|
|
if ((NS_OK == result) && (nsnull != attrs)) {
|
|
PRInt32 count;
|
|
attrs->SetClass(aClass, count);
|
|
|
|
result = UniqueAttributes(attrs, mapFunc, count, aAttributes);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetAttributeFor(nsIAtom* aAttribute,
|
|
const nsString& aValue,
|
|
nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsresult result = NS_OK;
|
|
nsIHTMLAttributes* attrs;
|
|
nsMapAttributesFunc mapFunc;
|
|
|
|
aContent->GetAttributeMappingFunction(mapFunc);
|
|
|
|
result = EnsureSingleAttributes(aAttributes, mapFunc, PR_TRUE, attrs);
|
|
|
|
if ((NS_OK == result) && (nsnull != attrs)) {
|
|
PRInt32 count;
|
|
attrs->SetAttribute(aAttribute, aValue, count);
|
|
|
|
result = UniqueAttributes(attrs, mapFunc, count, aAttributes);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::EnsureSingleAttributes(nsIHTMLAttributes*& aAttributes,
|
|
nsMapAttributesFunc aMapFunc,
|
|
PRBool aCreate,
|
|
nsIHTMLAttributes*& aSingleAttrs)
|
|
{
|
|
nsresult result = NS_OK;
|
|
PRInt32 contentRefCount;
|
|
|
|
if (nsnull == aAttributes) {
|
|
if (PR_TRUE == aCreate) {
|
|
if (nsnull != mRecycledAttrs) {
|
|
aSingleAttrs = mRecycledAttrs;
|
|
mRecycledAttrs = nsnull;
|
|
aSingleAttrs->SetMappingFunction(aMapFunc);
|
|
}
|
|
else {
|
|
result = NS_NewHTMLAttributes(&aSingleAttrs, aMapFunc);
|
|
}
|
|
}
|
|
else {
|
|
aSingleAttrs = nsnull;
|
|
}
|
|
contentRefCount = 0;
|
|
}
|
|
else {
|
|
aSingleAttrs = aAttributes;
|
|
aSingleAttrs->GetContentRefCount(contentRefCount);
|
|
NS_ASSERTION(0 < contentRefCount, "bad content ref count");
|
|
}
|
|
|
|
if (NS_OK == result) {
|
|
if (1 < contentRefCount) { // already shared, copy it
|
|
result = aSingleAttrs->Clone(&aSingleAttrs);
|
|
if (NS_OK != result) {
|
|
aSingleAttrs = nsnull;
|
|
return result;
|
|
}
|
|
contentRefCount = 0;
|
|
aAttributes->ReleaseContentRef();
|
|
NS_RELEASE(aAttributes);
|
|
}
|
|
else { // one content ref, ok to use, remove from table because hash may change
|
|
if (1 == contentRefCount) {
|
|
AttributeKey key(aMapFunc, aSingleAttrs);
|
|
mAttrTable.Remove(&key);
|
|
NS_ADDREF(aSingleAttrs); // add a local ref so we match up
|
|
}
|
|
}
|
|
// at this point, content ref count is 0 or 1, and we hold a local ref
|
|
// attrs is also unique and not in the table
|
|
NS_ASSERTION(((0 == contentRefCount) && (nsnull == aAttributes)) ||
|
|
((1 == contentRefCount) && (aSingleAttrs == aAttributes)), "this is broken");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::UniqueAttributes(nsIHTMLAttributes*& aSingleAttrs,
|
|
nsMapAttributesFunc aMapFunc,
|
|
PRInt32 aAttrCount,
|
|
nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsresult result = NS_OK;
|
|
|
|
if (0 < aAttrCount) {
|
|
AttributeKey key(aMapFunc, aSingleAttrs);
|
|
nsIHTMLAttributes* sharedAttrs = (nsIHTMLAttributes*)mAttrTable.Get(&key);
|
|
if (nsnull == sharedAttrs) { // we have a new unique set
|
|
mAttrTable.Put(&key, aSingleAttrs);
|
|
if (aSingleAttrs != aAttributes) {
|
|
NS_ASSERTION(nsnull == aAttributes, "this is broken");
|
|
aAttributes = aSingleAttrs;
|
|
aAttributes->AddContentRef();
|
|
NS_ADDREF(aAttributes); // add ref for content
|
|
}
|
|
}
|
|
else { // found existing set
|
|
NS_ASSERTION (sharedAttrs != aAttributes, "should never happen");
|
|
if (nsnull != aAttributes) {
|
|
aAttributes->ReleaseContentRef();
|
|
NS_RELEASE(aAttributes); // release content's ref
|
|
}
|
|
aAttributes = sharedAttrs;
|
|
aAttributes->AddContentRef();
|
|
NS_ADDREF(aAttributes); // add ref for content
|
|
|
|
if (nsnull == mRecycledAttrs) {
|
|
mRecycledAttrs = aSingleAttrs;
|
|
NS_ADDREF(mRecycledAttrs);
|
|
mRecycledAttrs->Reset();
|
|
}
|
|
}
|
|
}
|
|
else { // no attributes to store
|
|
if (nsnull != aAttributes) {
|
|
aAttributes->ReleaseContentRef();
|
|
NS_RELEASE(aAttributes);
|
|
}
|
|
if ((nsnull != aSingleAttrs) && (nsnull == mRecycledAttrs)) {
|
|
mRecycledAttrs = aSingleAttrs;
|
|
NS_ADDREF(mRecycledAttrs);
|
|
mRecycledAttrs->Reset();
|
|
}
|
|
}
|
|
NS_IF_RELEASE(aSingleAttrs);
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::SetAttributeFor(nsIAtom* aAttribute,
|
|
const nsHTMLValue& aValue,
|
|
nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsresult result = NS_OK;
|
|
nsIHTMLAttributes* attrs;
|
|
PRBool hasValue = PRBool(eHTMLUnit_Null != aValue.GetUnit());
|
|
nsMapAttributesFunc mapFunc;
|
|
|
|
aContent->GetAttributeMappingFunction(mapFunc);
|
|
|
|
result = EnsureSingleAttributes(aAttributes, mapFunc, hasValue, attrs);
|
|
|
|
if ((NS_OK == result) && (nsnull != attrs)) {
|
|
PRInt32 count;
|
|
attrs->SetAttribute(aAttribute, aValue, count);
|
|
|
|
result = UniqueAttributes(attrs, mapFunc, count, aAttributes);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
NS_IMETHODIMP HTMLStyleSheetImpl::UnsetAttributeFor(nsIAtom* aAttribute,
|
|
nsIHTMLContent* aContent,
|
|
nsIHTMLAttributes*& aAttributes)
|
|
{
|
|
nsresult result = NS_OK;
|
|
nsIHTMLAttributes* attrs;
|
|
nsMapAttributesFunc mapFunc;
|
|
|
|
aContent->GetAttributeMappingFunction(mapFunc);
|
|
|
|
result = EnsureSingleAttributes(aAttributes, mapFunc, PR_FALSE, attrs);
|
|
|
|
if ((NS_OK == result) && (nsnull != attrs)) {
|
|
PRInt32 count;
|
|
attrs->UnsetAttribute(aAttribute, count);
|
|
|
|
result = UniqueAttributes(attrs, mapFunc, count, aAttributes);
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::ProcessChildren(nsIPresContext* aPresContext,
|
|
nsIFrame* aFrame,
|
|
nsIContent* aContent,
|
|
nsIFrame*& aChildList)
|
|
{
|
|
// Initialize OUT parameter
|
|
aChildList = nsnull;
|
|
|
|
// Iterate the child content objects and construct a frame
|
|
nsIFrame* lastChildFrame = nsnull;
|
|
PRInt32 count;
|
|
aContent->ChildCount(count);
|
|
for (PRInt32 i = 0; i < count; i++) {
|
|
nsIContent* childContent;
|
|
aContent->ChildAt(i, childContent);
|
|
|
|
if (nsnull != childContent) {
|
|
nsIFrame* childFrame;
|
|
|
|
// Construct a child frame
|
|
ConstructFrame(aPresContext, childContent, aFrame, childFrame);
|
|
|
|
if (nsnull != childFrame) {
|
|
// Link the frame into the child list
|
|
if (nsnull == lastChildFrame) {
|
|
aChildList = childFrame;
|
|
} else {
|
|
lastChildFrame->SetNextSibling(childFrame);
|
|
}
|
|
lastChildFrame = childFrame;
|
|
}
|
|
|
|
NS_RELEASE(childContent);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::CreateInputFrame(nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIFrame*& aFrame)
|
|
{
|
|
nsresult rv;
|
|
|
|
// Figure out which type of input frame to create
|
|
nsAutoString val;
|
|
if (NS_OK == aContent->GetAttribute(nsAutoString("type"), val)) {
|
|
if (val.EqualsIgnoreCase("submit")) {
|
|
rv = NS_NewButtonControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("reset")) {
|
|
rv = NS_NewButtonControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("button")) {
|
|
rv = NS_NewButtonControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("checkbox")) {
|
|
rv = NS_NewCheckboxControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("file")) {
|
|
rv = NS_NewFileControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("hidden")) {
|
|
rv = NS_NewButtonControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("image")) {
|
|
rv = NS_NewButtonControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("password")) {
|
|
rv = NS_NewTextControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("radio")) {
|
|
rv = NS_NewRadioControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else if (val.EqualsIgnoreCase("text")) {
|
|
rv = NS_NewTextControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
else {
|
|
rv = NS_NewTextControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
} else {
|
|
rv = NS_NewTextControlFrame(aContent, aParentFrame, aFrame);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::ConstructTableFrame(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame)
|
|
{
|
|
nsIFrame* childList;
|
|
nsIFrame* innerFrame;
|
|
nsIFrame* innerChildList = nsnull;
|
|
nsIFrame* captionFrame = nsnull;
|
|
|
|
// Create an anonymous table outer frame which holds the caption and the
|
|
// table frame
|
|
NS_NewTableOuterFrame(aContent, aParentFrame, aNewFrame);
|
|
aNewFrame->SetStyleContext(aPresContext, aStyleContext);
|
|
|
|
// Create the inner table frame
|
|
NS_NewTableFrame(aContent, aNewFrame, innerFrame);
|
|
childList = innerFrame;
|
|
|
|
// Have the inner table frame use the same style context as the outer table frame
|
|
innerFrame->SetStyleContext(aPresContext, aStyleContext);
|
|
|
|
// Iterate the child content
|
|
nsIFrame* lastChildFrame = nsnull;
|
|
PRInt32 count;
|
|
aContent->ChildCount(count);
|
|
for (PRInt32 i = 0; i < count; i++) {
|
|
nsIContent* childContent;
|
|
aContent->ChildAt(i, childContent);
|
|
|
|
if (nsnull != childContent) {
|
|
nsIFrame* frame = nsnull;
|
|
nsIStyleContext* childStyleContext;
|
|
|
|
// Resolve the style context
|
|
childStyleContext = aPresContext->ResolveStyleContextFor(childContent, aNewFrame);
|
|
|
|
// See how it should be displayed
|
|
const nsStyleDisplay* styleDisplay = (const nsStyleDisplay*)
|
|
childStyleContext->GetStyleData(eStyleStruct_Display);
|
|
|
|
switch (styleDisplay->mDisplay) {
|
|
case NS_STYLE_DISPLAY_TABLE_CAPTION:
|
|
// Have we already created a caption? If so, ignore this caption
|
|
if (nsnull == captionFrame) {
|
|
NS_NewBodyFrame(childContent, aNewFrame, captionFrame,
|
|
NS_BODY_NO_AUTO_MARGINS);
|
|
captionFrame->SetStyleContext(aPresContext, childStyleContext);
|
|
// Process the caption's child content and initialize it
|
|
nsIFrame* captionChildList;
|
|
ProcessChildren(aPresContext, captionFrame, childContent, captionChildList);
|
|
captionFrame->Init(*aPresContext, captionChildList);
|
|
|
|
// Prepend the caption frame to the outer frame's child list
|
|
innerFrame->SetNextSibling(captionFrame);
|
|
}
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_HEADER_GROUP:
|
|
case NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP:
|
|
case NS_STYLE_DISPLAY_TABLE_ROW_GROUP:
|
|
NS_NewTableRowGroupFrame(childContent, innerFrame, frame);
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_COLUMN:
|
|
NS_NewTableColFrame(childContent, innerFrame, frame);
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP:
|
|
NS_NewTableColGroupFrame(childContent, innerFrame, frame);
|
|
break;
|
|
|
|
default:
|
|
// XXX For the time being ignore everything else. We should deal with
|
|
// things like table cells and create anonymous frames...
|
|
break;
|
|
}
|
|
|
|
// If it's not a caption frame, then set the style context and link the
|
|
// frame into the inner frame's child list
|
|
if (nsnull != frame) {
|
|
frame->SetStyleContext(aPresContext, childStyleContext);
|
|
|
|
// Process the children, and initialize the frame
|
|
nsIFrame* childChildList;
|
|
ProcessChildren(aPresContext, frame, childContent, childChildList);
|
|
frame->Init(*aPresContext, childChildList);
|
|
|
|
// Link the frame into the child list
|
|
if (nsnull == lastChildFrame) {
|
|
innerChildList = frame;
|
|
} else {
|
|
lastChildFrame->SetNextSibling(frame);
|
|
}
|
|
lastChildFrame = frame;
|
|
}
|
|
|
|
NS_RELEASE(childStyleContext);
|
|
NS_RELEASE(childContent);
|
|
}
|
|
}
|
|
|
|
// Initialize the inner table with its child list
|
|
innerFrame->Init(*aPresContext, innerChildList);
|
|
|
|
// Initialize the anonymous table outer frame
|
|
aNewFrame->Init(*aPresContext, childList);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::ConstructRootFrame(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame)
|
|
{
|
|
// This should only be the case for the root content object.
|
|
#ifdef NS_DEBUG
|
|
nsIDocument* doc;
|
|
nsIContent* rootContent;
|
|
|
|
// Verify it's the root content object
|
|
aContent->GetDocument(doc);
|
|
rootContent = doc->GetRootContent();
|
|
NS_RELEASE(doc);
|
|
NS_ASSERTION(rootContent == aContent, "unexpected content");
|
|
NS_RELEASE(rootContent);
|
|
#endif
|
|
|
|
// Create the root frame
|
|
nsresult rv = NS_NewHTMLFrame(aContent, nsnull, aNewFrame);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// Bind root frame to root view (and root window)
|
|
nsIPresShell* presShell = aPresContext->GetShell();
|
|
nsIViewManager* viewManager = presShell->GetViewManager();
|
|
nsIView* rootView;
|
|
|
|
NS_RELEASE(presShell);
|
|
viewManager->GetRootView(rootView);
|
|
aNewFrame->SetView(rootView);
|
|
NS_RELEASE(viewManager);
|
|
|
|
// Set the style context
|
|
aNewFrame->SetStyleContext(aPresContext, aStyleContext);
|
|
|
|
// Process the child content, and initialize the frame
|
|
nsIFrame* childList;
|
|
|
|
rv = ProcessChildren(aPresContext, aNewFrame, aContent, childList);
|
|
aNewFrame->Init(*aPresContext, childList);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::ConstructFrameByTag(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIAtom* aTag,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame)
|
|
{
|
|
PRBool processChildren = PR_FALSE; // whether we should process child content
|
|
nsresult rv = NS_OK;
|
|
|
|
// Initialize OUT parameter
|
|
aNewFrame = nsnull;
|
|
|
|
if (nsnull == aTag) {
|
|
rv = NS_NewTextFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::img == aTag) {
|
|
rv = NS_NewImageFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::hr == aTag) {
|
|
rv = NS_NewHRFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::br == aTag) {
|
|
rv = NS_NewBRFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::wbr == aTag) {
|
|
rv = NS_NewWBRFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::input == aTag) {
|
|
rv = CreateInputFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::textarea == aTag) {
|
|
rv = NS_NewTextControlFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::select == aTag) {
|
|
rv = NS_NewSelectControlFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::applet == aTag) {
|
|
rv = NS_NewObjectFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::embed == aTag) {
|
|
rv = NS_NewObjectFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::fieldset == aTag) {
|
|
rv = NS_NewFieldSetFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
else if (nsHTMLAtoms::legend == aTag) {
|
|
rv = NS_NewLegendFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
else if (nsHTMLAtoms::object == aTag) {
|
|
rv = NS_NewObjectFrame(aContent, aParentFrame, aNewFrame);
|
|
// processChildren = PR_TRUE;
|
|
}
|
|
else if (nsHTMLAtoms::body == aTag) {
|
|
rv = NS_NewBodyFrame(aContent, aParentFrame, aNewFrame,
|
|
NS_BODY_THE_BODY|NS_BODY_NO_AUTO_MARGINS);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
else if (nsHTMLAtoms::form == aTag) {
|
|
rv = NS_NewFormFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::frameset == aTag) {
|
|
rv = NS_NewHTMLFramesetFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::iframe == aTag) {
|
|
rv = NS_NewHTMLFrameOuterFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::spacer == aTag) {
|
|
rv = NS_NewSpacerFrame(aContent, aParentFrame, aNewFrame);
|
|
}
|
|
else if (nsHTMLAtoms::button == aTag) {
|
|
rv = NS_NewHTMLButtonControlFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
else if (nsHTMLAtoms::label == aTag) {
|
|
rv = NS_NewLabelFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
|
|
// If we succeeded in creating a frame then set its style context,
|
|
// process its children (if requested), and initialize the frame
|
|
if (NS_SUCCEEDED(rv) && (nsnull != aNewFrame)) {
|
|
aNewFrame->SetStyleContext(aPresContext, aStyleContext);
|
|
|
|
// Process the child content if requested
|
|
nsIFrame* childList = nsnull;
|
|
if (processChildren) {
|
|
rv = ProcessChildren(aPresContext, aNewFrame, aContent, childList);
|
|
}
|
|
|
|
// Initialize the frame
|
|
aNewFrame->Init(*aPresContext, childList);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::ConstructFrameByDisplayType(nsIPresContext* aPresContext,
|
|
const nsStyleDisplay* aDisplay,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aNewFrame)
|
|
{
|
|
PRBool processChildren = PR_FALSE; // whether we should process child content
|
|
nsresult rv = NS_OK;
|
|
|
|
// Initialize OUT parameter
|
|
aNewFrame = nsnull;
|
|
|
|
switch (aDisplay->mDisplay) {
|
|
case NS_STYLE_DISPLAY_BLOCK:
|
|
case NS_STYLE_DISPLAY_LIST_ITEM:
|
|
rv = NS_NewBlockFrame(aContent, aParentFrame, aNewFrame, PR_FALSE);
|
|
processChildren = PR_TRUE;
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_INLINE:
|
|
rv = NS_NewInlineFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE:
|
|
rv = ConstructTableFrame(aPresContext, aContent, aParentFrame,
|
|
aStyleContext, aNewFrame);
|
|
// Note: table construction function takes care of setting the style context,
|
|
// processing children, and calling Init()
|
|
return rv;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_ROW_GROUP:
|
|
case NS_STYLE_DISPLAY_TABLE_HEADER_GROUP:
|
|
case NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP:
|
|
// XXX We should check for being inside of a table. If there's a missing
|
|
// table then create an anonynmous table frame
|
|
{
|
|
nsIFrame *parentFrame;
|
|
rv = GetAdjustedParentFrame(aParentFrame, aDisplay->mDisplay, parentFrame);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
rv = NS_NewTableRowGroupFrame(aContent, parentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_COLUMN:
|
|
// XXX We should check for being inside of a table column group...
|
|
rv = NS_NewTableColFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP:
|
|
// XXX We should check for being inside of a table...
|
|
{
|
|
nsIFrame *parentFrame;
|
|
rv = GetAdjustedParentFrame(aParentFrame, aDisplay->mDisplay, parentFrame);
|
|
if (NS_SUCCEEDED(rv))
|
|
{
|
|
rv = NS_NewTableColGroupFrame(aContent, parentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_ROW:
|
|
// XXX We should check for being inside of a table row group...
|
|
rv = NS_NewTableRowFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_CELL:
|
|
// XXX We should check for being inside of a table row frame...
|
|
rv = NS_NewTableCellFrame(aContent, aParentFrame, aNewFrame);
|
|
processChildren = PR_TRUE;
|
|
break;
|
|
|
|
case NS_STYLE_DISPLAY_TABLE_CAPTION:
|
|
// XXX We should check for being inside of a table row frame...
|
|
rv = NS_NewBodyFrame(aContent, aParentFrame, aNewFrame, NS_BODY_NO_AUTO_MARGINS);
|
|
processChildren = PR_TRUE;
|
|
break;
|
|
|
|
default:
|
|
// Don't create any frame for content that's not displayed...
|
|
break;
|
|
}
|
|
|
|
// If we succeeded in creating a frame then set its style context,
|
|
// process children (if requested), and initialize the frame
|
|
if (NS_SUCCEEDED(rv) && (nsnull != aNewFrame)) {
|
|
aNewFrame->SetStyleContext(aPresContext, aStyleContext);
|
|
|
|
// Process the child content if requested
|
|
nsIFrame* childList = nsnull;
|
|
if (processChildren) {
|
|
rv = ProcessChildren(aPresContext, aNewFrame, aContent, childList);
|
|
}
|
|
|
|
// Initialize the frame
|
|
aNewFrame->Init(*aPresContext, childList);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
HTMLStyleSheetImpl::GetAdjustedParentFrame(nsIFrame* aCurrentParentFrame,
|
|
PRUint8 aChildDisplayType,
|
|
nsIFrame*& aNewParentFrame)
|
|
{
|
|
NS_PRECONDITION(nsnull!=aCurrentParentFrame, "bad arg aCurrentParentFrame");
|
|
|
|
nsresult rv=NS_OK;
|
|
// by default, the new parent frame is the given current parent frame
|
|
aNewParentFrame=aCurrentParentFrame;
|
|
if (nsnull!=aCurrentParentFrame)
|
|
{
|
|
const nsStyleDisplay* currentParentDisplay;
|
|
aCurrentParentFrame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct *&)currentParentDisplay);
|
|
if (NS_STYLE_DISPLAY_TABLE==currentParentDisplay->mDisplay)
|
|
{
|
|
if (NS_STYLE_DISPLAY_TABLE_CAPTION!=aChildDisplayType)
|
|
{
|
|
nsIFrame *innerTableFrame=nsnull;
|
|
aCurrentParentFrame->FirstChild(innerTableFrame);
|
|
if (nsnull!=innerTableFrame)
|
|
{
|
|
const nsStyleDisplay* innerTableDisplay;
|
|
innerTableFrame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct *&)innerTableDisplay);
|
|
if (NS_STYLE_DISPLAY_TABLE==innerTableDisplay->mDisplay)
|
|
{ // we were given the outer table frame, use the inner table frame
|
|
aNewParentFrame=innerTableFrame;
|
|
}
|
|
// else we were already given the inner table frame
|
|
}
|
|
// else the current parent has no children and cannot be an outer table frame
|
|
}
|
|
// else the child is a caption and really belongs to the outer table frame
|
|
}
|
|
else
|
|
{
|
|
if (NS_STYLE_DISPLAY_TABLE_CAPTION ==aChildDisplayType ||
|
|
NS_STYLE_DISPLAY_TABLE_ROW_GROUP ==aChildDisplayType ||
|
|
NS_STYLE_DISPLAY_TABLE_HEADER_GROUP==aChildDisplayType ||
|
|
NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP==aChildDisplayType ||
|
|
NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP==aChildDisplayType)
|
|
{ // we need to create an anonymous table frame (outer and inner) around the new frame
|
|
NS_NOTYETIMPLEMENTED("anonymous table frame as parent of table content not yet implemented.");
|
|
rv = NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
|
|
NS_POSTCONDITION(nsnull!=aNewParentFrame, "bad result null aNewParentFrame");
|
|
return rv;
|
|
}
|
|
|
|
PRBool
|
|
HTMLStyleSheetImpl::IsScrollable(nsIFrame* aFrame,
|
|
const nsStyleDisplay* aDisplay)
|
|
{
|
|
// If the overflow property is scroll then it's scrollable regardless
|
|
// of whether the content overflows the block.
|
|
// XXX This isn't correct. Only do this if the height is not allowed to
|
|
// grow to accomodate its child frames...
|
|
if (NS_STYLE_OVERFLOW_SCROLL == aDisplay->mOverflow) {
|
|
return PR_TRUE;
|
|
}
|
|
|
|
#if 0
|
|
if ((NS_STYLE_OVERFLOW_SCROLL == aDisplay->mOverflow) ||
|
|
// If the element has a fixed height (it isn't auto) and an overflow
|
|
// property of scroll or auto, then it's potentially scrollable.
|
|
// XXX Deal with width considerations, too
|
|
(NS_STYLE_OVERFLOW_AUTO == aDisplay->mOverflow)) {
|
|
#endif
|
|
return PR_FALSE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::ConstructFrame(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParentFrame,
|
|
nsIFrame*& aFrameSubTree)
|
|
{
|
|
nsresult rv;
|
|
|
|
// Get the tag
|
|
nsIAtom* tag;
|
|
aContent->GetTag(tag);
|
|
|
|
// Resolve the style context.
|
|
// XXX Cheesy hack for text
|
|
nsIStyleContext* styleContext;
|
|
if (nsnull == tag) {
|
|
styleContext = aPresContext->ResolvePseudoStyleContextFor(nsHTMLAtoms::text, aParentFrame);
|
|
} else {
|
|
styleContext = aPresContext->ResolveStyleContextFor(aContent, aParentFrame);
|
|
}
|
|
// XXX bad api - no nsresult returned!
|
|
if (nsnull == styleContext) {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
else {
|
|
// Pre-check for display "none" - if we find that, don't create
|
|
// any frame at all.
|
|
const nsStyleDisplay* display = (const nsStyleDisplay*)
|
|
styleContext->GetStyleData(eStyleStruct_Display);
|
|
if (NS_STYLE_DISPLAY_NONE == display->mDisplay) {
|
|
aFrameSubTree = nsnull;
|
|
rv = NS_OK;
|
|
}
|
|
else {
|
|
// Create a frame.
|
|
if (nsnull == aParentFrame) {
|
|
// Construct the root frame object
|
|
rv = ConstructRootFrame(aPresContext, aContent, styleContext,
|
|
aFrameSubTree);
|
|
|
|
} else {
|
|
// Handle specific frame types
|
|
rv = ConstructFrameByTag(aPresContext, aContent, aParentFrame,
|
|
tag, styleContext, aFrameSubTree);
|
|
|
|
if (NS_SUCCEEDED(rv) && (nsnull == aFrameSubTree)) {
|
|
// When there is no explicit frame to create, assume it's a
|
|
// container and let display style dictate the rest
|
|
rv = ConstructFrameByDisplayType(aPresContext, display,
|
|
aContent, aParentFrame,
|
|
styleContext, aFrameSubTree);
|
|
|
|
|
|
}
|
|
|
|
// If the frame is a block-level frame and is scrollable then wrap it
|
|
// in a scroll frame.
|
|
// XXX Applies to replaced elements, too, but how to tell if the element
|
|
// is replaced?
|
|
if (nsnull != aFrameSubTree) {
|
|
if (display->IsBlockLevel() && IsScrollable(aFrameSubTree, display)) {
|
|
nsIFrame* scrollFrame;
|
|
|
|
if NS_SUCCEEDED(NS_NewScrollFrame(aContent, aParentFrame, scrollFrame)) {
|
|
// The scroll frame gets the original style context, and the scrolled
|
|
// frame gets a SCROLLED-CONTENT pseudo element style context.
|
|
scrollFrame->SetStyleContext(aPresContext, styleContext);
|
|
|
|
nsIStyleContext* pseudoStyle;
|
|
pseudoStyle = aPresContext->ResolvePseudoStyleContextFor(nsHTMLAtoms::scrolledContentPseudo,
|
|
scrollFrame);
|
|
aFrameSubTree->SetStyleContext(aPresContext, pseudoStyle);
|
|
NS_RELEASE(pseudoStyle);
|
|
|
|
// Initialize the scroll frame
|
|
scrollFrame->Init(*aPresContext, aFrameSubTree);
|
|
aFrameSubTree = scrollFrame;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
NS_RELEASE(styleContext);
|
|
}
|
|
|
|
NS_IF_RELEASE(tag);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::ContentAppended(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
PRInt32 aNewIndexInContainer)
|
|
{
|
|
nsIPresShell* shell = aPresContext->GetShell();
|
|
nsIFrame* parentFrame = shell->FindFrameWithContent(aContainer);
|
|
|
|
#ifdef NS_DEBUG
|
|
if (nsnull == parentFrame) {
|
|
NS_WARNING("Ignoring content-appended notification with no matching frame...");
|
|
}
|
|
#endif
|
|
if (nsnull != parentFrame) {
|
|
// Get the parent frame's last-in-flow
|
|
nsIFrame* nextInFlow = parentFrame;
|
|
while (nsnull != nextInFlow) {
|
|
parentFrame->GetNextInFlow(nextInFlow);
|
|
if (nsnull != nextInFlow) {
|
|
parentFrame = nextInFlow;
|
|
}
|
|
}
|
|
|
|
// Create some new frames
|
|
PRInt32 count;
|
|
nsIFrame* lastChildFrame = nsnull;
|
|
nsIFrame* firstAppendedFrame = nsnull;
|
|
|
|
aContainer->ChildCount(count);
|
|
|
|
for (PRInt32 i = aNewIndexInContainer; i < count; i++) {
|
|
nsIContent* child;
|
|
nsIFrame* frame;
|
|
|
|
aContainer->ChildAt(i, child);
|
|
ConstructFrame(aPresContext, child, parentFrame, frame);
|
|
|
|
if (nsnull != frame) {
|
|
// Link the frame into the child frame list
|
|
if (nsnull == lastChildFrame) {
|
|
firstAppendedFrame = frame;
|
|
} else {
|
|
lastChildFrame->SetNextSibling(frame);
|
|
}
|
|
|
|
lastChildFrame = frame;
|
|
}
|
|
NS_RELEASE(child);
|
|
}
|
|
|
|
// adjust parent frame for table inner/outer frame
|
|
// we need to do this here because we need both the parent frame and the constructed frame
|
|
nsresult result = NS_OK;
|
|
nsIFrame *adjustedParentFrame=parentFrame;
|
|
if (nsnull!=firstAppendedFrame)
|
|
{
|
|
const nsStyleDisplay* firstAppendedFrameDisplay;
|
|
firstAppendedFrame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct *&)firstAppendedFrameDisplay);
|
|
result = GetAdjustedParentFrame(parentFrame, firstAppendedFrameDisplay->mDisplay, adjustedParentFrame);
|
|
}
|
|
|
|
// Notify the parent frame with a reflow command, passing it the list of
|
|
// new frames.
|
|
if (NS_SUCCEEDED(result)) {
|
|
nsIReflowCommand* reflowCmd;
|
|
result = NS_NewHTMLReflowCommand(&reflowCmd, adjustedParentFrame,
|
|
nsIReflowCommand::FrameAppended,
|
|
firstAppendedFrame);
|
|
if (NS_SUCCEEDED(result)) {
|
|
shell->AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
return NS_OK;
|
|
}
|
|
|
|
static nsIFrame*
|
|
FindPreviousSibling(nsIPresShell* aPresShell,
|
|
nsIContent* aContainer,
|
|
PRInt32 aIndexInContainer)
|
|
{
|
|
nsIFrame* prevSibling = nsnull;
|
|
|
|
// Note: not all content objects are associated with a frame so
|
|
// keep looking until we find a previous frame
|
|
for (PRInt32 index = aIndexInContainer - 1; index >= 0; index--) {
|
|
nsIContent* precedingContent;
|
|
aContainer->ChildAt(index, precedingContent);
|
|
prevSibling = aPresShell->FindFrameWithContent(precedingContent);
|
|
NS_RELEASE(precedingContent);
|
|
|
|
if (nsnull != prevSibling) {
|
|
// The frame may have a next-in-flow. Get the last-in-flow
|
|
nsIFrame* nextInFlow;
|
|
do {
|
|
prevSibling->GetNextInFlow(nextInFlow);
|
|
if (nsnull != nextInFlow) {
|
|
prevSibling = nextInFlow;
|
|
}
|
|
} while (nsnull != nextInFlow);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return prevSibling;
|
|
}
|
|
|
|
static nsIFrame*
|
|
FindNextSibling(nsIPresShell* aPresShell,
|
|
nsIContent* aContainer,
|
|
PRInt32 aIndexInContainer)
|
|
{
|
|
nsIFrame* nextSibling = nsnull;
|
|
|
|
// Note: not all content objects are associated with a frame so
|
|
// keep looking until we find a next frame
|
|
PRInt32 count;
|
|
aContainer->ChildCount(count);
|
|
for (PRInt32 index = aIndexInContainer + 1; index < count; index++) {
|
|
nsIContent* nextContent;
|
|
aContainer->ChildAt(index, nextContent);
|
|
nextSibling = aPresShell->FindFrameWithContent(nextContent);
|
|
NS_RELEASE(nextContent);
|
|
|
|
if (nsnull != nextSibling) {
|
|
// The frame may have a next-in-flow. Get the last-in-flow
|
|
nsIFrame* nextInFlow;
|
|
do {
|
|
nextSibling->GetNextInFlow(nextInFlow);
|
|
if (nsnull != nextInFlow) {
|
|
nextSibling = nextInFlow;
|
|
}
|
|
} while (nsnull != nextInFlow);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return nextSibling;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::ContentInserted(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
PRInt32 aIndexInContainer)
|
|
{
|
|
nsIPresShell* shell = aPresContext->GetShell();
|
|
|
|
// Find the frame that precedes the insertion point.
|
|
nsIFrame* prevSibling = FindPreviousSibling(shell, aContainer, aIndexInContainer);
|
|
nsIFrame* nextSibling = nsnull;
|
|
PRBool isAppend = PR_FALSE;
|
|
|
|
// If there is no previous sibling, then find the frame that follows
|
|
if (nsnull == prevSibling) {
|
|
nextSibling = FindNextSibling(shell, aContainer, aIndexInContainer);
|
|
}
|
|
|
|
// Get the geometric parent.
|
|
nsIFrame* parentFrame;
|
|
if ((nsnull == prevSibling) && (nsnull == nextSibling)) {
|
|
// No previous or next sibling so treat this like an appended frame.
|
|
// XXX This won't always be true if there's auto-generated before/after
|
|
// content
|
|
isAppend = PR_TRUE;
|
|
parentFrame = shell->FindFrameWithContent(aContainer);
|
|
|
|
} else {
|
|
// Use the prev sibling if we have it; otherwise use the next sibling.
|
|
// Note that we use the content parent, and not the geometric parent,
|
|
// in case the frame has been moved out of the flow...
|
|
if (nsnull != prevSibling) {
|
|
prevSibling->GetContentParent(parentFrame);
|
|
} else {
|
|
nextSibling->GetContentParent(parentFrame);
|
|
}
|
|
}
|
|
|
|
// Construct a new frame
|
|
nsresult rv = NS_OK;
|
|
if (nsnull != parentFrame) {
|
|
nsIFrame* newFrame;
|
|
rv = ConstructFrame(aPresContext, aChild, parentFrame, newFrame);
|
|
|
|
if (NS_SUCCEEDED(rv) && (nsnull != newFrame)) {
|
|
nsIReflowCommand* reflowCmd = nsnull;
|
|
|
|
// Notify the parent frame with a reflow command.
|
|
if (isAppend) {
|
|
// Generate a FrameAppended reflow command
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, parentFrame,
|
|
nsIReflowCommand::FrameAppended, newFrame);
|
|
} else {
|
|
// Generate a FrameInserted reflow command
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, parentFrame, newFrame, prevSibling);
|
|
}
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
shell->AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::ContentReplaced(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
nsIContent* aOldChild,
|
|
nsIContent* aNewChild,
|
|
PRInt32 aIndexInContainer)
|
|
{
|
|
NS_NOTYETIMPLEMENTED("content replaced");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::ContentRemoved(nsIPresContext* aPresContext,
|
|
nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
PRInt32 aIndexInContainer)
|
|
{
|
|
nsIPresShell* shell = aPresContext->GetShell();
|
|
nsresult rv = NS_OK;
|
|
|
|
// Find the child frame
|
|
nsIFrame* childFrame = shell->FindFrameWithContent(aChild);
|
|
|
|
if (nsnull != childFrame) {
|
|
// Get the parent frame.
|
|
// Note that we use the content parent, and not the geometric parent,
|
|
// in case the frame has been moved out of the flow...
|
|
nsIFrame* parentFrame;
|
|
childFrame->GetContentParent(parentFrame);
|
|
NS_ASSERTION(nsnull != parentFrame, "null content parent frame");
|
|
|
|
// Notify the parent frame with a reflow command.
|
|
nsIReflowCommand* reflowCmd;
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, parentFrame,
|
|
nsIReflowCommand::FrameRemoved, childFrame);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
shell->AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
return rv;
|
|
}
|
|
|
|
static void
|
|
RemapStyleInTree(nsIPresContext* aPresContext,
|
|
nsIFrame* aFrame)
|
|
{
|
|
nsIStyleContext* sc;
|
|
aFrame->GetStyleContext(nsnull, sc);
|
|
if (nsnull != sc) {
|
|
sc->RemapStyle(aPresContext);
|
|
|
|
// Update the children too...
|
|
nsIFrame* kid;
|
|
aFrame->FirstChild(kid);
|
|
while (nsnull != kid) {
|
|
RemapStyleInTree(aPresContext, kid);
|
|
kid->GetNextSibling(kid);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ApplyStyleChangeToTree(nsIPresContext* aPresContext,
|
|
nsIFrame* aFrame)
|
|
{
|
|
nsIContent* content;
|
|
nsIFrame* geometricParent;
|
|
aFrame->GetGeometricParent(geometricParent);
|
|
aFrame->GetContent(content);
|
|
|
|
if (nsnull != content) {
|
|
PRBool onlyRemap = PR_FALSE;
|
|
nsIStyleContext* oldSC;
|
|
aFrame->GetStyleContext(nsnull, oldSC);
|
|
nsIStyleContext* newSC =
|
|
aPresContext->ResolveStyleContextFor(content, geometricParent);
|
|
if (newSC == oldSC) {
|
|
// Force cached style data to be recomputed
|
|
newSC->RemapStyle(aPresContext);
|
|
onlyRemap = PR_TRUE;
|
|
}
|
|
else {
|
|
// Switch to new style context
|
|
aFrame->SetStyleContext(aPresContext, newSC);
|
|
}
|
|
NS_IF_RELEASE(oldSC);
|
|
NS_RELEASE(newSC);
|
|
NS_RELEASE(content);
|
|
|
|
// Update the children too...
|
|
nsIFrame* kid;
|
|
aFrame->FirstChild(kid);
|
|
if (onlyRemap) {
|
|
while (nsnull != kid) {
|
|
RemapStyleInTree(aPresContext, kid);
|
|
kid->GetNextSibling(kid);
|
|
}
|
|
}
|
|
else {
|
|
while (nsnull != kid) {
|
|
ApplyStyleChangeToTree(aPresContext, kid);
|
|
kid->GetNextSibling(kid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ApplyRenderingChangeToTree(nsIPresContext* aPresContext,
|
|
nsIFrame* aFrame)
|
|
{
|
|
nsIViewManager* viewManager = nsnull;
|
|
|
|
// Trigger rendering updates by damaging this frame and any
|
|
// continuations of this frame.
|
|
while (nsnull != aFrame) {
|
|
// Get the frame's bounding rect
|
|
nsRect r;
|
|
aFrame->GetRect(r);
|
|
r.x = 0;
|
|
r.y = 0;
|
|
|
|
// Get view if this frame has one and trigger an update. If the
|
|
// frame doesn't have a view, find the nearest containing view
|
|
// (adjusting r's coordinate system to reflect the nesting) and
|
|
// update there.
|
|
nsIView* view;
|
|
aFrame->GetView(view);
|
|
if (nsnull != view) {
|
|
} else {
|
|
nsPoint offset;
|
|
aFrame->GetOffsetFromView(offset, view);
|
|
NS_ASSERTION(nsnull != view, "no view");
|
|
r += offset;
|
|
}
|
|
if (nsnull == viewManager) {
|
|
view->GetViewManager(viewManager);
|
|
}
|
|
viewManager->UpdateView(view, r, NS_VMREFRESH_NO_SYNC);
|
|
|
|
aFrame->GetNextInFlow(aFrame);
|
|
}
|
|
|
|
if (nsnull != viewManager) {
|
|
viewManager->Composite();
|
|
NS_RELEASE(viewManager);
|
|
}
|
|
}
|
|
|
|
static void
|
|
StyleChangeReflow(nsIPresContext* aPresContext,
|
|
nsIFrame* aFrame)
|
|
{
|
|
nsIPresShell* shell;
|
|
shell = aPresContext->GetShell();
|
|
|
|
nsIReflowCommand* reflowCmd;
|
|
nsresult rv = NS_NewHTMLReflowCommand(&reflowCmd, aFrame,
|
|
nsIReflowCommand::StyleChanged);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
shell->AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::ContentChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsISupports* aSubContent)
|
|
{
|
|
nsIPresShell* shell = aPresContext->GetShell();
|
|
nsresult rv = NS_OK;
|
|
|
|
// Find the child frame
|
|
nsIFrame* frame = shell->FindFrameWithContent(aContent);
|
|
|
|
// Notify the first frame that maps the content. It will generate a reflow
|
|
// command
|
|
|
|
// It's possible the frame whose content changed isn't inserted into the
|
|
// frame hierarchy yet, or that there is no frame that maps the content
|
|
if (nsnull != frame) {
|
|
#if 0
|
|
NS_FRAME_LOG(NS_FRAME_TRACE_CALLS,
|
|
("nsHTMLStyleSheet::ContentChanged: content=%p[%s] subcontent=%p frame=%p",
|
|
aContent, ContentTag(aContent, 0),
|
|
aSubContent, frame));
|
|
#endif
|
|
frame->ContentChanged(aPresContext, aContent, aSubContent);
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLStyleSheetImpl::AttributeChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIAtom* aAttribute,
|
|
PRInt32 aHint)
|
|
{
|
|
nsresult result = NS_OK;
|
|
|
|
nsIPresShell* shell = aPresContext->GetShell();
|
|
nsIFrame* frame = shell->FindFrameWithContent(aContent);
|
|
|
|
if (nsnull != frame) {
|
|
PRBool restyle = PR_FALSE;
|
|
PRBool reflow = PR_FALSE;
|
|
PRBool reframe = PR_FALSE;
|
|
PRBool render = PR_FALSE;
|
|
|
|
#if 0
|
|
NS_FRAME_LOG(NS_FRAME_TRACE_CALLS,
|
|
("HTMLStyleSheet::AttributeChanged: content=%p[%s] frame=%p",
|
|
aContent, ContentTag(aContent, 0), frame));
|
|
#endif
|
|
|
|
nsIHTMLContent* htmlContent;
|
|
result = aContent->QueryInterface(kIHTMLContentIID, (void**)&htmlContent);
|
|
|
|
if (NS_OK == result) {
|
|
nsIAtom* tag;
|
|
htmlContent->GetTag(tag);
|
|
|
|
// handle specific attributes by tag
|
|
if (tag == nsHTMLAtoms::img) {
|
|
if ((nsHTMLAtoms::width == aAttribute) ||
|
|
(nsHTMLAtoms::height == aAttribute)) {
|
|
restyle = PR_TRUE;
|
|
reflow = PR_TRUE;
|
|
}
|
|
}
|
|
else if (tag == nsHTMLAtoms::hr) {
|
|
if (nsHTMLAtoms::noshade == aAttribute) {
|
|
render = PR_TRUE;
|
|
}
|
|
}
|
|
else {
|
|
}
|
|
|
|
// handle general attributes
|
|
if (nsHTMLAtoms::style == aAttribute) {
|
|
switch (aHint) {
|
|
default:
|
|
case NS_STYLE_HINT_UNKNOWN:
|
|
case NS_STYLE_HINT_FRAMECHANGE:
|
|
reframe = PR_TRUE;
|
|
case NS_STYLE_HINT_REFLOW:
|
|
reflow = PR_TRUE;
|
|
case NS_STYLE_HINT_VISUAL:
|
|
render = PR_TRUE;
|
|
case NS_STYLE_HINT_CONTENT:
|
|
restyle = PR_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else if (nsHTMLAtoms::color == aAttribute) {
|
|
restyle = PR_TRUE;
|
|
render = PR_TRUE;
|
|
}
|
|
else if (nsHTMLAtoms::face == aAttribute) {
|
|
restyle = PR_TRUE;
|
|
reflow = PR_TRUE;
|
|
}
|
|
|
|
|
|
NS_IF_RELEASE(tag);
|
|
NS_RELEASE(htmlContent);
|
|
}
|
|
|
|
// apply changes
|
|
if (PR_TRUE == restyle) {
|
|
ApplyStyleChangeToTree(aPresContext, frame);
|
|
}
|
|
if (PR_TRUE == reframe) {
|
|
NS_NOTYETIMPLEMENTED("frame change reflow");
|
|
}
|
|
else if (PR_TRUE == reflow) {
|
|
StyleChangeReflow(aPresContext, frame);
|
|
}
|
|
else if (PR_TRUE == render) {
|
|
ApplyRenderingChangeToTree(aPresContext, frame);
|
|
}
|
|
else { // let the frame deal with it, since we don't know how to
|
|
frame->AttributeChanged(aPresContext, aContent, aAttribute, aHint);
|
|
}
|
|
}
|
|
|
|
NS_RELEASE(shell);
|
|
return result;
|
|
}
|
|
|
|
|
|
void HTMLStyleSheetImpl::List(FILE* out, PRInt32 aIndent) const
|
|
{
|
|
nsAutoString buffer;
|
|
|
|
// Indent
|
|
for (PRInt32 index = aIndent; --index >= 0; ) fputs(" ", out);
|
|
|
|
fputs("HTML Style Sheet: ", out);
|
|
mURL->ToString(buffer);
|
|
fputs(buffer, out);
|
|
fputs("\n", out);
|
|
|
|
}
|
|
|
|
NS_HTML nsresult
|
|
NS_NewHTMLStyleSheet(nsIHTMLStyleSheet** aInstancePtrResult, nsIURL* aURL)
|
|
{
|
|
if (aInstancePtrResult == nsnull) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
HTMLStyleSheetImpl *it = new HTMLStyleSheetImpl(aURL);
|
|
|
|
if (nsnull == it) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
return it->QueryInterface(kIHTMLStyleSheetIID, (void **) aInstancePtrResult);
|
|
}
|