wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
c449d1e403
gecko/layout/style/nsCSSStruct.h

732 lines
20 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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/
*
* 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.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Daniel Glazman <glazman@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* 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"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* temporary (expanded) representation of the property-value pairs
* within a CSS declaration using during parsing and mutation, and
* representation of complex values for CSS properties
*/
#ifndef nsCSSStruct_h___
#define nsCSSStruct_h___
#include "nsCSSValue.h"
#include "nsStyleConsts.h"
// Prefer nsCSSValue::Array for lists of fixed size.
struct nsCSSValueList {
nsCSSValueList() : mNext(nsnull) { MOZ_COUNT_CTOR(nsCSSValueList); }
~nsCSSValueList();
nsCSSValueList* Clone() const; // makes a deep copy
void AppendToString(nsCSSProperty aProperty, nsAString& aResult) const;
bool operator==(nsCSSValueList const& aOther) const; // deep comparison
bool operator!=(const nsCSSValueList& aOther) const
{ return !(*this == aOther); }
nsCSSValue mValue;
nsCSSValueList* mNext;
private:
nsCSSValueList(const nsCSSValueList& aCopy) // makes a shallow copy
: mValue(aCopy.mValue), mNext(nsnull)
{
MOZ_COUNT_CTOR(nsCSSValueList);
}
};
struct nsCSSRect {
nsCSSRect(void);
nsCSSRect(const nsCSSRect& aCopy);
~nsCSSRect();
void AppendToString(nsCSSProperty aProperty, nsAString& aResult) const;
PRBool operator==(const nsCSSRect& aOther) const {
return mTop == aOther.mTop &&
mRight == aOther.mRight &&
mBottom == aOther.mBottom &&
mLeft == aOther.mLeft;
}
PRBool operator!=(const nsCSSRect& aOther) const {
return mTop != aOther.mTop ||
mRight != aOther.mRight ||
mBottom != aOther.mBottom ||
mLeft != aOther.mLeft;
}
void SetAllSidesTo(const nsCSSValue& aValue);
void Reset() {
mTop.Reset();
mRight.Reset();
mBottom.Reset();
mLeft.Reset();
}
PRBool HasValue() const {
return
mTop.GetUnit() != eCSSUnit_Null ||
mRight.GetUnit() != eCSSUnit_Null ||
mBottom.GetUnit() != eCSSUnit_Null ||
mLeft.GetUnit() != eCSSUnit_Null;
}
nsCSSValue mTop;
nsCSSValue mRight;
nsCSSValue mBottom;
nsCSSValue mLeft;
typedef nsCSSValue nsCSSRect::*side_type;
static const side_type sides[4];
};
struct nsCSSValuePair {
nsCSSValuePair()
{
MOZ_COUNT_CTOR(nsCSSValuePair);
}
nsCSSValuePair(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
: mXValue(aXValue), mYValue(aYValue)
{
MOZ_COUNT_CTOR(nsCSSValuePair);
}
nsCSSValuePair(const nsCSSValuePair& aCopy)
: mXValue(aCopy.mXValue), mYValue(aCopy.mYValue)
{
MOZ_COUNT_CTOR(nsCSSValuePair);
}
~nsCSSValuePair()
{
MOZ_COUNT_DTOR(nsCSSValuePair);
}
PRBool operator==(const nsCSSValuePair& aOther) const {
return mXValue == aOther.mXValue &&
mYValue == aOther.mYValue;
}
PRBool operator!=(const nsCSSValuePair& aOther) const {
return mXValue != aOther.mXValue ||
mYValue != aOther.mYValue;
}
void SetBothValuesTo(const nsCSSValue& aValue) {
mXValue = aValue;
mYValue = aValue;
}
void Reset() {
mXValue.Reset();
mYValue.Reset();
}
PRBool HasValue() const {
return mXValue.GetUnit() != eCSSUnit_Null ||
mYValue.GetUnit() != eCSSUnit_Null;
}
void AppendToString(nsCSSProperty aProperty, nsAString& aResult) const;
nsCSSValue mXValue;
nsCSSValue mYValue;
};
struct nsCSSCornerSizes {
nsCSSCornerSizes(void);
nsCSSCornerSizes(const nsCSSCornerSizes& aCopy);
~nsCSSCornerSizes();
// argument is a "full corner" constant from nsStyleConsts.h
nsCSSValuePair const & GetFullCorner(PRUint32 aCorner) const {
return (this->*corners[aCorner]);
}
nsCSSValuePair & GetFullCorner(PRUint32 aCorner) {
return (this->*corners[aCorner]);
}
// argument is a "half corner" constant from nsStyleConsts.h
const nsCSSValue& GetHalfCorner(PRUint32 hc) const {
nsCSSValuePair const & fc = this->*corners[NS_HALF_TO_FULL_CORNER(hc)];
return NS_HALF_CORNER_IS_X(hc) ? fc.mXValue : fc.mYValue;
}
nsCSSValue & GetHalfCorner(PRUint32 hc) {
nsCSSValuePair& fc = this->*corners[NS_HALF_TO_FULL_CORNER(hc)];
return NS_HALF_CORNER_IS_X(hc) ? fc.mXValue : fc.mYValue;
}
PRBool operator==(const nsCSSCornerSizes& aOther) const {
NS_FOR_CSS_FULL_CORNERS(corner) {
if (this->GetFullCorner(corner) != aOther.GetFullCorner(corner))
return PR_FALSE;
}
return PR_TRUE;
}
PRBool operator!=(const nsCSSCornerSizes& aOther) const {
NS_FOR_CSS_FULL_CORNERS(corner) {
if (this->GetFullCorner(corner) != aOther.GetFullCorner(corner))
return PR_TRUE;
}
return PR_FALSE;
}
PRBool HasValue() const {
NS_FOR_CSS_FULL_CORNERS(corner) {
if (this->GetFullCorner(corner).HasValue())
return PR_TRUE;
}
return PR_FALSE;
}
void Reset();
nsCSSValuePair mTopLeft;
nsCSSValuePair mTopRight;
nsCSSValuePair mBottomRight;
nsCSSValuePair mBottomLeft;
protected:
typedef nsCSSValuePair nsCSSCornerSizes::*corner_type;
static const corner_type corners[4];
};
struct nsCSSValueListRect {
nsCSSValueListRect(void);
nsCSSValueListRect(const nsCSSValueListRect& aCopy);
~nsCSSValueListRect();
nsCSSValueList* mTop;
nsCSSValueList* mRight;
nsCSSValueList* mBottom;
nsCSSValueList* mLeft;
typedef nsCSSValueList* nsCSSValueListRect::*side_type;
static const side_type sides[4];
};
// Maybe should be replaced with nsCSSValueList and nsCSSValue::Array?
struct nsCSSValuePairList {
nsCSSValuePairList() : mNext(nsnull) { MOZ_COUNT_CTOR(nsCSSValuePairList); }
~nsCSSValuePairList();
nsCSSValuePairList* Clone() const; // makes a deep copy
void AppendToString(nsCSSProperty aProperty, nsAString& aResult) const;
bool operator==(const nsCSSValuePairList& aOther) const; // deep comparison
bool operator!=(const nsCSSValuePairList& aOther) const
{ return !(*this == aOther); }
nsCSSValue mXValue;
nsCSSValue mYValue;
nsCSSValuePairList* mNext;
private:
nsCSSValuePairList(const nsCSSValuePairList& aCopy) // makes a shallow copy
: mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mNext(nsnull)
{
MOZ_COUNT_CTOR(nsCSSValuePairList);
}
};
/****************************************************************************/
struct nsCSSStruct {
// EMPTY on purpose. ABSTRACT with no virtuals (typedef void nsCSSStruct?)
};
// We use the nsCSS* structures for storing css::Declaration's
// *temporary* data during parsing and modification. (They are too big
// for permanent storage.) We also use them for nsRuleData, with some
// additions of things that the style system must cascade, but that
// aren't CSS properties. Thus we use typedefs and inheritance
// (forwards, when the rule data needs extra data) to make the rule data
// structs from the declaration structs.
// NOTE: For compilation speed, this typedef also appears in nsRuleNode.h
typedef nsCSSStruct nsRuleDataStruct;
struct nsCSSFont : public nsCSSStruct {
nsCSSFont(void);
~nsCSSFont(void);
nsCSSValue mSystemFont;
nsCSSValue mFamily;
nsCSSValue mStyle;
nsCSSValue mVariant;
nsCSSValue mWeight;
nsCSSValue mSize;
nsCSSValue mSizeAdjust; // NEW
nsCSSValue mStretch; // NEW
nsCSSValue mFontFeatureSettings;
nsCSSValue mFontLanguageOverride;
#ifdef MOZ_MATHML
nsCSSValue mScriptLevel; // Integer values mean "relative", Number values mean "absolute"
nsCSSValue mScriptSizeMultiplier;
nsCSSValue mScriptMinSize;
#endif
private:
nsCSSFont(const nsCSSFont& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataFont : public nsCSSFont {
PRBool mFamilyFromHTML; // Is the family from an HTML FONT element
nsRuleDataFont() {}
private:
nsRuleDataFont(const nsRuleDataFont& aOther); // NOT IMPLEMENTED
};
struct nsCSSColor : public nsCSSStruct {
nsCSSColor(void);
~nsCSSColor(void);
nsCSSValue mColor;
nsCSSValue mBackColor;
nsCSSValueList* mBackImage;
nsCSSValueList* mBackRepeat;
nsCSSValueList* mBackAttachment;
nsCSSValuePairList* mBackPosition;
nsCSSValuePairList* mBackSize;
nsCSSValueList* mBackClip;
nsCSSValueList* mBackOrigin;
nsCSSValue mBackInlinePolicy;
private:
nsCSSColor(const nsCSSColor& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataColor : public nsCSSColor {
nsRuleDataColor() {}
// A little bit of a hack here: now that background-image is
// represented by a value list, attribute mapping code needs a place
// to store one item in a value list in order to map a simple value.
nsCSSValueList mTempBackImage;
private:
nsRuleDataColor(const nsRuleDataColor& aOther); // NOT IMPLEMENTED
};
struct nsCSSText : public nsCSSStruct {
nsCSSText(void);
~nsCSSText(void);
nsCSSValue mTabSize;
nsCSSValue mWordSpacing;
nsCSSValue mLetterSpacing;
nsCSSValue mVerticalAlign;
nsCSSValue mTextTransform;
nsCSSValue mTextAlign;
nsCSSValue mTextIndent;
nsCSSValue mDecoration;
nsCSSValueList* mTextShadow; // NEW
nsCSSValue mUnicodeBidi; // NEW
nsCSSValue mLineHeight;
nsCSSValue mWhiteSpace;
nsCSSValue mWordWrap;
private:
nsCSSText(const nsCSSText& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataText : public nsCSSText {
nsRuleDataText() {}
private:
nsRuleDataText(const nsRuleDataText& aOther); // NOT IMPLEMENTED
};
struct nsCSSDisplay : public nsCSSStruct {
nsCSSDisplay(void);
~nsCSSDisplay(void);
nsCSSValue mDirection;
nsCSSValue mDisplay;
nsCSSValue mBinding;
nsCSSValue mAppearance;
nsCSSValue mPosition;
nsCSSValue mFloat;
nsCSSValue mClear;
nsCSSRect mClip;
nsCSSValue mOverflowX;
nsCSSValue mOverflowY;
nsCSSValue mResize;
nsCSSValue mPointerEvents;
nsCSSValue mVisibility;
nsCSSValue mOpacity;
nsCSSValueList *mTransform; // List of Arrays containing transform information
nsCSSValuePair mTransformOrigin;
nsCSSValueList* mTransitionProperty;
nsCSSValueList* mTransitionDuration;
nsCSSValueList* mTransitionTimingFunction;
nsCSSValueList* mTransitionDelay;
// temp fix for bug 24000
nsCSSValue mBreakBefore;
nsCSSValue mBreakAfter;
// end temp fix
private:
nsCSSDisplay(const nsCSSDisplay& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataDisplay : public nsCSSDisplay {
nsCSSValue mLang;
nsRuleDataDisplay() {}
private:
nsRuleDataDisplay(const nsRuleDataDisplay& aOther); // NOT IMPLEMENTED
};
struct nsCSSMargin : public nsCSSStruct {
nsCSSMargin(void);
~nsCSSMargin(void);
nsCSSRect mMargin;
nsCSSValue mMarginStart;
nsCSSValue mMarginEnd;
nsCSSValue mMarginLeftLTRSource;
nsCSSValue mMarginLeftRTLSource;
nsCSSValue mMarginRightLTRSource;
nsCSSValue mMarginRightRTLSource;
nsCSSRect mPadding;
nsCSSValue mPaddingStart;
nsCSSValue mPaddingEnd;
nsCSSValue mPaddingLeftLTRSource;
nsCSSValue mPaddingLeftRTLSource;
nsCSSValue mPaddingRightLTRSource;
nsCSSValue mPaddingRightRTLSource;
nsCSSRect mBorderWidth;
nsCSSValue mBorderStartWidth;
nsCSSValue mBorderEndWidth;
nsCSSValue mBorderLeftWidthLTRSource;
nsCSSValue mBorderLeftWidthRTLSource;
nsCSSValue mBorderRightWidthLTRSource;
nsCSSValue mBorderRightWidthRTLSource;
nsCSSRect mBorderColor;
nsCSSValue mBorderStartColor;
nsCSSValue mBorderEndColor;
nsCSSValue mBorderLeftColorLTRSource;
nsCSSValue mBorderLeftColorRTLSource;
nsCSSValue mBorderRightColorLTRSource;
nsCSSValue mBorderRightColorRTLSource;
nsCSSValueListRect mBorderColors;
nsCSSRect mBorderStyle;
nsCSSValue mBorderStartStyle;
nsCSSValue mBorderEndStyle;
nsCSSValue mBorderLeftStyleLTRSource;
nsCSSValue mBorderLeftStyleRTLSource;
nsCSSValue mBorderRightStyleLTRSource;
nsCSSValue mBorderRightStyleRTLSource;
nsCSSCornerSizes mBorderRadius;
nsCSSValue mOutlineWidth;
nsCSSValue mOutlineColor;
nsCSSValue mOutlineStyle;
nsCSSValue mOutlineOffset;
nsCSSCornerSizes mOutlineRadius;
nsCSSValue mFloatEdge; // NEW
nsCSSValue mBorderImage;
nsCSSValueList* mBoxShadow;
private:
nsCSSMargin(const nsCSSMargin& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataMargin : public nsCSSMargin {
nsRuleDataMargin() {}
private:
nsRuleDataMargin(const nsRuleDataMargin& aOther); // NOT IMPLEMENTED
};
struct nsCSSPosition : public nsCSSStruct {
nsCSSPosition(void);
~nsCSSPosition(void);
nsCSSValue mWidth;
nsCSSValue mMinWidth;
nsCSSValue mMaxWidth;
nsCSSValue mHeight;
nsCSSValue mMinHeight;
nsCSSValue mMaxHeight;
nsCSSValue mBoxSizing; // NEW
nsCSSRect mOffset;
nsCSSValue mZIndex;
private:
nsCSSPosition(const nsCSSPosition& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataPosition : public nsCSSPosition {
nsRuleDataPosition() {}
private:
nsRuleDataPosition(const nsRuleDataPosition& aOther); // NOT IMPLEMENTED
};
struct nsCSSList : public nsCSSStruct {
nsCSSList(void);
~nsCSSList(void);
nsCSSValue mType;
nsCSSValue mImage;
nsCSSValue mPosition;
nsCSSRect mImageRegion;
private:
nsCSSList(const nsCSSList& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataList : public nsCSSList {
nsRuleDataList() {}
private:
nsRuleDataList(const nsRuleDataList& aOther); // NOT IMPLEMENTED
};
struct nsCSSTable : public nsCSSStruct { // NEW
nsCSSTable(void);
~nsCSSTable(void);
nsCSSValue mBorderCollapse;
nsCSSValuePair mBorderSpacing;
nsCSSValue mCaptionSide;
nsCSSValue mEmptyCells;
nsCSSValue mLayout;
nsCSSValue mSpan; // Not mappable via CSS, only using HTML4 table attrs.
nsCSSValue mCols; // Not mappable via CSS, only using HTML4 table attrs.
private:
nsCSSTable(const nsCSSTable& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataTable : public nsCSSTable {
nsRuleDataTable() {}
private:
nsRuleDataTable(const nsRuleDataTable& aOther); // NOT IMPLEMENTED
};
struct nsCSSBreaks : public nsCSSStruct { // NEW
nsCSSBreaks(void);
~nsCSSBreaks(void);
nsCSSValue mOrphans;
nsCSSValue mWidows;
nsCSSValue mPage;
// temp fix for bug 24000
//nsCSSValue mPageBreakAfter;
//nsCSSValue mPageBreakBefore;
nsCSSValue mPageBreakInside;
private:
nsCSSBreaks(const nsCSSBreaks& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataBreaks : public nsCSSBreaks {
nsRuleDataBreaks() {}
private:
nsRuleDataBreaks(const nsRuleDataBreaks& aOther); // NOT IMPLEMENTED
};
struct nsCSSPage : public nsCSSStruct { // NEW
nsCSSPage(void);
~nsCSSPage(void);
nsCSSValue mMarks;
nsCSSValuePair mSize;
private:
nsCSSPage(const nsCSSPage& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataPage : public nsCSSPage {
nsRuleDataPage() {}
private:
nsRuleDataPage(const nsRuleDataPage& aOther); // NOT IMPLEMENTED
};
struct nsCSSContent : public nsCSSStruct {
nsCSSContent(void);
~nsCSSContent(void);
nsCSSValueList* mContent;
nsCSSValuePairList* mCounterIncrement;
nsCSSValuePairList* mCounterReset;
nsCSSValue mMarkerOffset;
nsCSSValuePairList* mQuotes;
private:
nsCSSContent(const nsCSSContent& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataContent : public nsCSSContent {
nsRuleDataContent() {}
private:
nsRuleDataContent(const nsRuleDataContent& aOther); // NOT IMPLEMENTED
};
struct nsCSSUserInterface : public nsCSSStruct { // NEW
nsCSSUserInterface(void);
~nsCSSUserInterface(void);
nsCSSValue mUserInput;
nsCSSValue mUserModify;
nsCSSValue mUserSelect;
nsCSSValue mUserFocus;
nsCSSValueList* mCursor;
nsCSSValue mForceBrokenImageIcon;
nsCSSValue mIMEMode;
nsCSSValue mWindowShadow;
private:
nsCSSUserInterface(const nsCSSUserInterface& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataUserInterface : public nsCSSUserInterface {
nsRuleDataUserInterface() {}
private:
nsRuleDataUserInterface(const nsRuleDataUserInterface& aOther); // NOT IMPLEMENTED
};
struct nsCSSAural : public nsCSSStruct { // NEW
nsCSSAural(void);
~nsCSSAural(void);
nsCSSValue mAzimuth;
nsCSSValue mElevation;
nsCSSValue mCueAfter;
nsCSSValue mCueBefore;
nsCSSValue mPauseAfter;
nsCSSValue mPauseBefore;
nsCSSValue mPitch;
nsCSSValue mPitchRange;
nsCSSValue mRichness;
nsCSSValue mSpeak;
nsCSSValue mSpeakHeader;
nsCSSValue mSpeakNumeral;
nsCSSValue mSpeakPunctuation;
nsCSSValue mSpeechRate;
nsCSSValue mStress;
nsCSSValue mVoiceFamily;
nsCSSValue mVolume;
private:
nsCSSAural(const nsCSSAural& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataAural : public nsCSSAural {
nsRuleDataAural() {}
private:
nsRuleDataAural(const nsRuleDataAural& aOther); // NOT IMPLEMENTED
};
struct nsCSSXUL : public nsCSSStruct {
nsCSSXUL(void);
~nsCSSXUL(void);
nsCSSValue mBoxAlign;
nsCSSValue mBoxDirection;
nsCSSValue mBoxFlex;
nsCSSValue mBoxOrient;
nsCSSValue mBoxPack;
nsCSSValue mBoxOrdinal;
nsCSSValue mStackSizing;
private:
nsCSSXUL(const nsCSSXUL& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataXUL : public nsCSSXUL {
nsRuleDataXUL() {}
private:
nsRuleDataXUL(const nsRuleDataXUL& aOther); // NOT IMPLEMENTED
};
struct nsCSSColumn : public nsCSSStruct {
nsCSSColumn(void);
~nsCSSColumn(void);
nsCSSValue mColumnCount;
nsCSSValue mColumnWidth;
nsCSSValue mColumnGap;
nsCSSValue mColumnRuleColor;
nsCSSValue mColumnRuleWidth;
nsCSSValue mColumnRuleStyle;
private:
nsCSSColumn(const nsCSSColumn& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataColumn : public nsCSSColumn {
nsRuleDataColumn() {}
private:
nsRuleDataColumn(const nsRuleDataColumn& aOther); // NOT IMPLEMENTED
};
struct nsCSSSVG : public nsCSSStruct {
nsCSSSVG(void);
~nsCSSSVG(void);
nsCSSValue mClipPath;
nsCSSValue mClipRule;
nsCSSValue mColorInterpolation;
nsCSSValue mColorInterpolationFilters;
nsCSSValue mDominantBaseline;
nsCSSValuePair mFill;
nsCSSValue mFillOpacity;
nsCSSValue mFillRule;
nsCSSValue mFilter;
nsCSSValue mFloodColor;
nsCSSValue mFloodOpacity;
nsCSSValue mImageRendering;
nsCSSValue mLightingColor;
nsCSSValue mMarkerEnd;
nsCSSValue mMarkerMid;
nsCSSValue mMarkerStart;
nsCSSValue mMask;
nsCSSValue mShapeRendering;
nsCSSValue mStopColor;
nsCSSValue mStopOpacity;
nsCSSValuePair mStroke;
nsCSSValueList *mStrokeDasharray;
nsCSSValue mStrokeDashoffset;
nsCSSValue mStrokeLinecap;
nsCSSValue mStrokeLinejoin;
nsCSSValue mStrokeMiterlimit;
nsCSSValue mStrokeOpacity;
nsCSSValue mStrokeWidth;
nsCSSValue mTextAnchor;
nsCSSValue mTextRendering;
private:
nsCSSSVG(const nsCSSSVG& aOther); // NOT IMPLEMENTED
};
struct nsRuleDataSVG : public nsCSSSVG {
nsRuleDataSVG() {}
private:
nsRuleDataSVG(const nsRuleDataSVG& aOther); // NOT IMPLEMENTED
};
#endif /* nsCSSStruct_h___ */
Reference in New Issue View Git Blame Copy Permalink