LCOV - app.info - layout/style/nsStyleSet.h

LCOV - code coverage report
| Current view: | directory - layout/style - nsStyleSet.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 29 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 14 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Daniel Glazman <glazman@netscape.com>
          24                 :  *   Brian Ryner    <bryner@brianryner.com>
          25                 :  *   L. David Baron <dbaron@dbaron.org>, Mozilla Corporation
          26                 :  *
          27                 :  * Alternatively, the contents of this file may be used under the terms of
          28                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          29                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          30                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          31                 :  * of those above. If you wish to allow use of your version of this file only
          32                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          33                 :  * use your version of this file under the terms of the MPL, indicate your
          34                 :  * decision by deleting the provisions above and replace them with the notice
          35                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          36                 :  * the provisions above, a recipient may use your version of this file under
          37                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          38                 :  *
          39                 :  * ***** END LICENSE BLOCK ***** */
          40                 :
          41                 : /*
          42                 :  * the container for the style sheets that apply to a presentation, and
          43                 :  * the internal API that the style system exposes for creating (and
          44                 :  * potentially re-creating) style contexts
          45                 :  */
          46                 :
          47                 : #ifndef nsStyleSet_h_
          48                 : #define nsStyleSet_h_
          49                 :
          50                 : #include "mozilla/Attributes.h"
          51                 :
          52                 : #include "nsIStyleRuleProcessor.h"
          53                 : #include "nsCSSStyleSheet.h"
          54                 : #include "nsBindingManager.h"
          55                 : #include "nsRuleNode.h"
          56                 : #include "nsTArray.h"
          57                 : #include "nsCOMArray.h"
          58                 : #include "nsAutoPtr.h"
          59                 : #include "nsIStyleRule.h"
          60                 : #include "nsCSSPseudoElements.h"
          61                 : #include "nsCSSAnonBoxes.h"
          62                 :
          63                 : class nsIURI;
          64                 : class nsCSSFontFaceRule;
          65                 : class nsCSSKeyframesRule;
          66                 : class nsRuleWalker;
          67                 : struct RuleProcessorData;
          68                 : struct TreeMatchContext;
          69                 :
          70                 : class nsEmptyStyleRule : public nsIStyleRule
          71               0 : {
          72                 :   NS_DECL_ISUPPORTS
          73                 :   virtual void MapRuleInfoInto(nsRuleData* aRuleData);
          74                 : #ifdef DEBUG
          75                 :   virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const;
          76                 : #endif
          77                 : };
          78                 :
          79                 : class nsInitialStyleRule : public nsIStyleRule
          80               0 : {
          81                 :   NS_DECL_ISUPPORTS
          82                 :   virtual void MapRuleInfoInto(nsRuleData* aRuleData);
          83                 : #ifdef DEBUG
          84                 :   virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const;
          85                 : #endif
          86                 : };
          87                 :
          88                 : // The style set object is created by the document viewer and ownership is
          89                 : // then handed off to the PresShell.  Only the PresShell should delete a
          90                 : // style set.
          91                 :
          92                 : class nsStyleSet
          93               0 : {
          94                 :  public:
          95                 :   nsStyleSet();
          96                 :
          97                 :   size_t SizeOfIncludingThis(nsMallocSizeOfFun aMallocSizeOf) const;
          98                 :
          99                 :   // Initialize the object.  You must check the return code and not use
         100                 :   // the nsStyleSet if Init() fails.
         101                 :
         102                 :   nsresult Init(nsPresContext *aPresContext);
         103                 :
         104                 :   // For getting the cached default data in case we hit out-of-memory.
         105                 :   // To be used only by nsRuleNode.
         106               0 :   nsCachedStyleData* DefaultStyleData() { return &mDefaultStyleData; }
         107                 :
         108               0 :   nsRuleNode* GetRuleTree() { return mRuleTree; }
         109                 :
         110                 :   // enable / disable the Quirk style sheet
         111                 :   void EnableQuirkStyleSheet(bool aEnable);
         112                 :
         113                 :   // get a style context for a non-pseudo frame.
         114                 :   already_AddRefed<nsStyleContext>
         115                 :   ResolveStyleFor(mozilla::dom::Element* aElement,
         116                 :                   nsStyleContext* aParentContext);
         117                 :
         118                 :   already_AddRefed<nsStyleContext>
         119                 :   ResolveStyleFor(mozilla::dom::Element* aElement,
         120                 :                   nsStyleContext* aParentContext,
         121                 :                   TreeMatchContext& aTreeMatchContext);
         122                 :
         123                 :   // Get a style context (with the given parent) for the
         124                 :   // sequence of style rules in the |aRules| array.
         125                 :   already_AddRefed<nsStyleContext>
         126                 :   ResolveStyleForRules(nsStyleContext* aParentContext,
         127                 :                        const nsCOMArray<nsIStyleRule> &aRules);
         128                 :
         129                 :   // Get a style context that represents aBaseContext, but as though
         130                 :   // it additionally matched the rules in the aRules array (in that
         131                 :   // order, as more specific than any other rules).
         132                 :   already_AddRefed<nsStyleContext>
         133                 :   ResolveStyleByAddingRules(nsStyleContext* aBaseContext,
         134                 :                             const nsCOMArray<nsIStyleRule> &aRules);
         135                 :
         136                 :   // Get a style context for a non-element (which no rules will match),
         137                 :   // such as text nodes, placeholder frames, and the nsFirstLetterFrame
         138                 :   // for everything after the first letter.
         139                 :   //
         140                 :   // Perhaps this should go away and we shouldn't even create style
         141                 :   // contexts for such content nodes.  However, not doing any rule
         142                 :   // matching for them is a first step.
         143                 :   already_AddRefed<nsStyleContext>
         144                 :   ResolveStyleForNonElement(nsStyleContext* aParentContext);
         145                 :
         146                 :   // Get a style context for a pseudo-element.  aParentElement must be
         147                 :   // non-null.  aPseudoID is the nsCSSPseudoElements::Type for the
         148                 :   // pseudo-element.
         149                 :   already_AddRefed<nsStyleContext>
         150                 :   ResolvePseudoElementStyle(mozilla::dom::Element* aParentElement,
         151                 :                             nsCSSPseudoElements::Type aType,
         152                 :                             nsStyleContext* aParentContext);
         153                 :
         154                 :   // This functions just like ResolvePseudoElementStyle except that it will
         155                 :   // return nsnull if there are no explicit style rules for that
         156                 :   // pseudo element.
         157                 :   already_AddRefed<nsStyleContext>
         158                 :   ProbePseudoElementStyle(mozilla::dom::Element* aParentElement,
         159                 :                           nsCSSPseudoElements::Type aType,
         160                 :                           nsStyleContext* aParentContext);
         161                 :   already_AddRefed<nsStyleContext>
         162                 :   ProbePseudoElementStyle(mozilla::dom::Element* aParentElement,
         163                 :                           nsCSSPseudoElements::Type aType,
         164                 :                           nsStyleContext* aParentContext,
         165                 :                           TreeMatchContext& aTreeMatchContext);
         166                 :
         167                 :   // Get a style context for an anonymous box.  aPseudoTag is the
         168                 :   // pseudo-tag to use and must be non-null.
         169                 :   already_AddRefed<nsStyleContext>
         170                 :   ResolveAnonymousBoxStyle(nsIAtom* aPseudoTag, nsStyleContext* aParentContext);
         171                 :
         172                 : #ifdef MOZ_XUL
         173                 :   // Get a style context for a XUL tree pseudo.  aPseudoTag is the
         174                 :   // pseudo-tag to use and must be non-null.  aParentContent must be
         175                 :   // non-null.  aComparator must be non-null.
         176                 :   already_AddRefed<nsStyleContext>
         177                 :   ResolveXULTreePseudoStyle(mozilla::dom::Element* aParentElement,
         178                 :                             nsIAtom* aPseudoTag,
         179                 :                             nsStyleContext* aParentContext,
         180                 :                             nsICSSPseudoComparator* aComparator);
         181                 : #endif
         182                 :
         183                 :   // Append all the currently-active font face rules to aArray.  Return
         184                 :   // true for success and false for failure.
         185                 :   bool AppendFontFaceRules(nsPresContext* aPresContext,
         186                 :                              nsTArray<nsFontFaceRuleContainer>& aArray);
         187                 :
         188                 :   // Append all the currently-active keyframes rules to aArray.  Return
         189                 :   // true for success and false for failure.
         190                 :   bool AppendKeyframesRules(nsPresContext* aPresContext,
         191                 :                               nsTArray<nsCSSKeyframesRule*>& aArray);
         192                 :
         193                 :   // Begin ignoring style context destruction, to avoid lots of unnecessary
         194                 :   // work on document teardown.
         195                 :   void BeginShutdown(nsPresContext* aPresContext);
         196                 :
         197                 :   // Free all of the data associated with this style set.
         198                 :   void Shutdown(nsPresContext* aPresContext);
         199                 :
         200                 :   // Notification that a style context is being destroyed.
         201                 :   void NotifyStyleContextDestroyed(nsPresContext* aPresContext,
         202                 :                                    nsStyleContext* aStyleContext);
         203                 :
         204                 :   // Get a new style context that lives in a different parent
         205                 :   // The new context will be the same as the old if the new parent is the
         206                 :   // same as the old parent.
         207                 :   // aElement should be non-null if this is a style context for an
         208                 :   // element or pseudo-element; in the latter case it should be the
         209                 :   // real element the pseudo-element is for.
         210                 :   already_AddRefed<nsStyleContext>
         211                 :   ReparentStyleContext(nsStyleContext* aStyleContext,
         212                 :                        nsStyleContext* aNewParentContext,
         213                 :                        mozilla::dom::Element* aElement);
         214                 :
         215                 :   // Test if style is dependent on a document state.
         216                 :   bool HasDocumentStateDependentStyle(nsPresContext* aPresContext,
         217                 :                                         nsIContent*    aContent,
         218                 :                                         nsEventStates  aStateMask);
         219                 :
         220                 :   // Test if style is dependent on content state
         221                 :   nsRestyleHint HasStateDependentStyle(nsPresContext* aPresContext,
         222                 :                                        mozilla::dom::Element* aElement,
         223                 :                                        nsEventStates aStateMask);
         224                 :
         225                 :   // Test if style is dependent on the presence of an attribute.
         226                 :   nsRestyleHint HasAttributeDependentStyle(nsPresContext* aPresContext,
         227                 :                                            mozilla::dom::Element* aElement,
         228                 :                                            nsIAtom*       aAttribute,
         229                 :                                            PRInt32        aModType,
         230                 :                                            bool           aAttrHasChanged);
         231                 :
         232                 :   /*
         233                 :    * Do any processing that needs to happen as a result of a change in
         234                 :    * the characteristics of the medium, and return whether style rules
         235                 :    * may have changed as a result.
         236                 :    */
         237                 :   bool MediumFeaturesChanged(nsPresContext* aPresContext);
         238                 :
         239                 :   // APIs for registering objects that can supply additional
         240                 :   // rules during processing.
         241               0 :   void SetBindingManager(nsBindingManager* aBindingManager)
         242                 :   {
         243               0 :     mBindingManager = aBindingManager;
         244               0 :   }
         245                 :
         246                 :   // The "origins" of the CSS cascade, from lowest precedence to
         247                 :   // highest (for non-!important rules).
         248                 :   enum sheetType {
         249                 :     eAgentSheet, // CSS
         250                 :     eUserSheet, // CSS
         251                 :     ePresHintSheet,
         252                 :     eDocSheet, // CSS
         253                 :     eStyleAttrSheet,
         254                 :     eOverrideSheet, // CSS
         255                 :     eAnimationSheet,
         256                 :     eTransitionSheet,
         257                 :     eSheetTypeCount
         258                 :     // be sure to keep the number of bits in |mDirty| below and in
         259                 :     // NS_RULE_NODE_LEVEL_MASK updated when changing the number of sheet
         260                 :     // types
         261                 :   };
         262                 :
         263                 :   // APIs to manipulate the style sheet lists.  The sheets in each
         264                 :   // list are stored with the most significant sheet last.
         265                 :   nsresult AppendStyleSheet(sheetType aType, nsIStyleSheet *aSheet);
         266                 :   nsresult PrependStyleSheet(sheetType aType, nsIStyleSheet *aSheet);
         267                 :   nsresult RemoveStyleSheet(sheetType aType, nsIStyleSheet *aSheet);
         268                 :   nsresult ReplaceSheets(sheetType aType,
         269                 :                          const nsCOMArray<nsIStyleSheet> &aNewSheets);
         270                 :
         271                 :   // Enable/Disable entire author style level (Doc & PresHint levels)
         272                 :   bool GetAuthorStyleDisabled();
         273                 :   nsresult SetAuthorStyleDisabled(bool aStyleDisabled);
         274                 :
         275               0 :   PRInt32 SheetCount(sheetType aType) const {
         276               0 :     return mSheets[aType].Count();
         277                 :   }
         278                 :
         279               0 :   nsIStyleSheet* StyleSheetAt(sheetType aType, PRInt32 aIndex) const {
         280               0 :     return mSheets[aType].ObjectAt(aIndex);
         281                 :   }
         282                 :
         283                 :   nsresult AddDocStyleSheet(nsIStyleSheet* aSheet, nsIDocument* aDocument);
         284                 :
         285                 :   void     BeginUpdate();
         286                 :   nsresult EndUpdate();
         287                 :
         288                 :   // Methods for reconstructing the tree; BeginReconstruct basically moves the
         289                 :   // old rule tree root and style context roots out of the way,
         290                 :   // and EndReconstruct destroys the old rule tree when we're done
         291                 :   nsresult BeginReconstruct();
         292                 :   // Note: EndReconstruct should not be called if BeginReconstruct fails
         293                 :   void EndReconstruct();
         294                 :
         295                 :   // Let the style set know that a particular sheet is the quirks sheet.  This
         296                 :   // sheet must already have been added to the UA sheets.  The pointer must not
         297                 :   // be null.  This should only be called once for a given style set.
         298                 :   void SetQuirkStyleSheet(nsIStyleSheet* aQuirkStyleSheet);
         299                 :
         300                 :   // Return whether the rule tree has cached data such that we need to
         301                 :   // do dynamic change handling for changes that change the results of
         302                 :   // media queries or require rebuilding all style data.
         303                 :   // We don't care whether we have cached rule processors or whether
         304                 :   // they have cached rule cascades; getting the rule cascades again in
         305                 :   // order to do rule matching will get the correct rule cascade.
         306               0 :   bool HasCachedStyleData() const {
         307               0 :     return (mRuleTree && mRuleTree->TreeHasCachedData()) || !mRoots.IsEmpty();
         308                 :   }
         309                 :
         310                 :   // Notify the style set that a rulenode is no longer in use, or was
         311                 :   // just created and is not in use yet.
         312               0 :   void RuleNodeUnused() {
         313               0 :     ++mUnusedRuleNodeCount;
         314               0 :   }
         315                 :
         316                 :   // Notify the style set that a rulenode that wasn't in use now is
         317               0 :   void RuleNodeInUse() {
         318               0 :     --mUnusedRuleNodeCount;
         319               0 :   }
         320                 :
         321                 :   nsCSSStyleSheet::EnsureUniqueInnerResult EnsureUniqueInnerOnCSSSheets();
         322                 :
         323                 :   nsIStyleRule* InitialStyleRule();
         324                 :
         325                 :  private:
         326                 :   nsStyleSet(const nsStyleSet& aCopy) MOZ_DELETE;
         327                 :   nsStyleSet& operator=(const nsStyleSet& aCopy) MOZ_DELETE;
         328                 :
         329                 :   // Returns false on out-of-memory.
         330                 :   bool BuildDefaultStyleData(nsPresContext* aPresContext);
         331                 :
         332                 :   // Run mark-and-sweep GC on mRuleTree and mOldRuleTrees, based on mRoots.
         333                 :   void GCRuleTrees();
         334                 :
         335                 :   // Update the rule processor list after a change to the style sheet list.
         336                 :   nsresult GatherRuleProcessors(sheetType aType);
         337                 :
         338                 :   void AddImportantRules(nsRuleNode* aCurrLevelNode,
         339                 :                          nsRuleNode* aLastPrevLevelNode,
         340                 :                          nsRuleWalker* aRuleWalker);
         341                 :
         342                 :   // Move aRuleWalker forward by the appropriate rule if we need to add
         343                 :   // a rule due to property restrictions on pseudo-elements.
         344                 :   void WalkRestrictionRule(nsCSSPseudoElements::Type aPseudoType,
         345                 :                            nsRuleWalker* aRuleWalker);
         346                 :
         347                 : #ifdef DEBUG
         348                 :   // Just like AddImportantRules except it doesn't actually add anything; it
         349                 :   // just asserts that there are no important rules between aCurrLevelNode and
         350                 :   // aLastPrevLevelNode.
         351                 :   void AssertNoImportantRules(nsRuleNode* aCurrLevelNode,
         352                 :                               nsRuleNode* aLastPrevLevelNode);
         353                 :
         354                 :   // Just like AddImportantRules except it doesn't actually add anything; it
         355                 :   // just asserts that there are no CSS rules between aCurrLevelNode and
         356                 :   // aLastPrevLevelNode.  Mostly useful for the preshint level.
         357                 :   void AssertNoCSSRules(nsRuleNode* aCurrLevelNode,
         358                 :                         nsRuleNode* aLastPrevLevelNode);
         359                 : #endif
         360                 :
         361                 :   // Enumerate the rules in a way that cares about the order of the
         362                 :   // rules.
         363                 :   // aContent is the node the rules are for.  It might be null.  aData
         364                 :   // is the closure to pass to aCollectorFunc.  If aContent is not null,
         365                 :   // aData must be a RuleProcessorData*
         366                 :   void FileRules(nsIStyleRuleProcessor::EnumFunc aCollectorFunc,
         367                 :                  void* aData, nsIContent* aContent, nsRuleWalker* aRuleWalker);
         368                 :
         369                 :   // Enumerate all the rules in a way that doesn't care about the order
         370                 :   // of the rules and break out if the enumeration is halted.
         371                 :   void WalkRuleProcessors(nsIStyleRuleProcessor::EnumFunc aFunc,
         372                 :                           RuleProcessorData* aData,
         373                 :                           bool aWalkAllXBLStylesheets);
         374                 :
         375                 :   already_AddRefed<nsStyleContext>
         376                 :   GetContext(nsStyleContext* aParentContext,
         377                 :              nsRuleNode* aRuleNode,
         378                 :              nsRuleNode* aVisitedRuleNode,
         379                 :              bool aIsLink,
         380                 :              bool aIsVisitedLink,
         381                 :              nsIAtom* aPseudoTag,
         382                 :              nsCSSPseudoElements::Type aPseudoType,
         383                 :              bool aDoAnimation,
         384                 :              mozilla::dom::Element* aElementForAnimation);
         385                 :
         386               0 :   nsPresContext* PresContext() { return mRuleTree->GetPresContext(); }
         387                 :
         388                 :   // The sheets in each array in mSheets are stored with the most significant
         389                 :   // sheet last.
         390                 :   nsCOMArray<nsIStyleSheet> mSheets[eSheetTypeCount];
         391                 :
         392                 :   nsCOMPtr<nsIStyleRuleProcessor> mRuleProcessors[eSheetTypeCount];
         393                 :
         394                 :   // cached instance for enabling/disabling
         395                 :   nsCOMPtr<nsIStyleSheet> mQuirkStyleSheet;
         396                 :
         397                 :   nsRefPtr<nsBindingManager> mBindingManager;
         398                 :
         399                 :   // To be used only in case of emergency, such as being out of memory
         400                 :   // or operating on a deleted rule node.  The latter should never
         401                 :   // happen, of course.
         402                 :   nsCachedStyleData mDefaultStyleData;
         403                 :
         404                 :   nsRuleNode* mRuleTree; // This is the root of our rule tree.  It is a
         405                 :                          // lexicographic tree of matched rules that style
         406                 :                          // contexts use to look up properties.
         407                 :
         408                 :   PRUint32 mUnusedRuleNodeCount; // used to batch rule node GC
         409                 :   nsTArray<nsStyleContext*> mRoots; // style contexts with no parent
         410                 :
         411                 :   // Empty style rules to force things that restrict which properties
         412                 :   // apply into different branches of the rule tree.
         413                 :   nsRefPtr<nsEmptyStyleRule> mFirstLineRule, mFirstLetterRule;
         414                 :
         415                 :   // Style rule which sets all properties to their initial values for
         416                 :   // determining when context-sensitive values are in use.
         417                 :   nsRefPtr<nsInitialStyleRule> mInitialStyleRule;
         418                 :
         419                 :   PRUint16 mBatching;
         420                 :
         421                 :   // Old rule trees, which should only be non-empty between
         422                 :   // BeginReconstruct and EndReconstruct, but in case of bugs that cause
         423                 :   // style contexts to exist too long, may last longer.
         424                 :   nsTArray<nsRuleNode*> mOldRuleTrees;
         425                 :
         426                 :   unsigned mInShutdown : 1;
         427                 :   unsigned mAuthorStyleDisabled: 1;
         428                 :   unsigned mInReconstruct : 1;
         429                 :   unsigned mDirty : 8;  // one dirty bit is used per sheet type
         430                 :
         431                 : };
         432                 :
         433                 : #ifdef _IMPL_NS_LAYOUT
         434                 : inline
         435               0 : void nsRuleNode::AddRef()
         436                 : {
         437               0 :   if (mRefCnt++ == 0 && !IsRoot()) {
         438               0 :     mPresContext->StyleSet()->RuleNodeInUse();
         439                 :   }
         440               0 : }
         441                 :
         442                 : inline
         443               0 : void nsRuleNode::Release()
         444                 : {
         445               0 :   if (--mRefCnt == 0 && !IsRoot()) {
         446               0 :     mPresContext->StyleSet()->RuleNodeUnused();
         447                 :   }
         448               0 : }
         449                 : #endif
         450                 :
         451                 : #endif

Generated by: LCOV version 1.7