cssstyleselector.h

00001 /*
00002  * This file is part of the CSS implementation for KDE.
00003  *
00004  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
00005  * Copyright (C) 2003, 2005, 2006 Apple Computer, Inc.
00006  *
00007  * This library is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Library General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2 of the License, or (at your option) any later version.
00011  *
00012  * This library is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Library General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Library General Public License
00018  * along with this library; see the file COPYING.LIB.  If not, write to
00019  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00020  * Boston, MA 02110-1301, USA.
00021  *
00022  */
00023 #ifndef _CSS_cssstyleselector_h_
00024 #define _CSS_cssstyleselector_h_
00025 
00026 #include <qptrlist.h>
00027 #include <qvaluevector.h>
00028 
00029 #include "rendering/render_style.h"
00030 #include "dom/dom_string.h"
00031 
00032 class KHTMLSettings;
00033 class KHTMLView;
00034 class KHTMLPart;
00035 class KHTMLFactory;
00036 class KURL;
00037 
00038 namespace DOM {
00039     class DocumentImpl;
00040     class NodeImpl;
00041     class ElementImpl;
00042     class StyleSheetImpl;
00043     class CSSStyleRuleImpl;
00044     class CSSStyleSheetImpl;
00045     class CSSSelector;
00046     class CSSStyleDeclarationImpl;
00047     class CSSProperty;
00048     class StyleSheetListImpl;
00049     class CSSValueImpl;
00050 }
00051 
00052 namespace khtml
00053 {
00054     class CSSStyleSelectorList;
00055     class CSSOrderedRule;
00056     class CSSOrderedProperty;
00057     class CSSOrderedPropertyList;
00058     class RenderStyle;
00059 
00060     /*
00061      * to remember the source where a rule came from. Differentiates between
00062      * important and not important rules. This is ordered in the order they have to be applied
00063      * to the RenderStyle.
00064      */
00065     enum Source {
00066     Default = 0,
00067     NonCSSHint = 1,
00068     User = 2,
00069     Author = 3,
00070     Inline = 4,
00071     AuthorImportant = 5,
00072     InlineImportant = 6,
00073     UserImportant =7
00074     };
00075 
00082     class StyleSelector
00083     {
00084     public:
00085     StyleSelector() {}
00086 
00087     /* as nobody has implemented a second style selector up to now comment out
00088        the virtual methods until then, so the class has no vptr.
00089     */
00090 //  virtual ~StyleSelector() {}
00091 //  virtual RenderStyle *styleForElement(DOM::ElementImpl *e) = 0;
00092 
00093     enum State {
00094         None = 0x00,
00095         Hover = 0x01,
00096         Focus = 0x02,
00097         Active = 0x04
00098     };
00099     };
00100 
00101 
00105     class CSSStyleSelector : public StyleSelector
00106     {
00107     public:
00116     CSSStyleSelector( DOM::DocumentImpl* doc, QString userStyleSheet, DOM::StyleSheetListImpl *styleSheets, const KURL &url,
00117                           bool _strictParsing );
00121     CSSStyleSelector( DOM::CSSStyleSheetImpl *sheet );
00122 
00123     ~CSSStyleSelector();
00124 
00125     void addSheet( DOM::CSSStyleSheetImpl *sheet );
00126         KDE_EXPORT static void clear();
00127         static void reparseConfiguration();
00128 
00129     static void loadDefaultStyle(const KHTMLSettings *s, DOM::DocumentImpl *doc);
00130 
00131     RenderStyle *styleForElement(DOM::ElementImpl *e);
00132 
00133         QValueVector<int> fontSizes() const { return m_fontSizes; }
00134     QValueVector<int> fixedFontSizes() const { return m_fixedFontSizes; }
00135 
00136     bool strictParsing;
00137     struct Encodedurl {
00138         QString host; //also contains protocol
00139         QString path;
00140         QString file;
00141     } encodedurl;
00142 
00143         void computeFontSizes(QPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor);
00144     void computeFontSizesFor(QPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor, QValueVector<int>& fontSizes, bool isFixed);
00145 
00146     static void precomputeAttributeDependencies(DOM::DocumentImpl* doc, DOM::CSSSelector* sel);
00147     protected:
00148 
00149     DOM::NodeImpl* checkSubSelectors(DOM::CSSSelector *sel, DOM::NodeImpl *n, bool isAncestor);
00150 
00151     /* checks if the complete selector (which can be build up from a few CSSSelector's
00152         with given relationships matches the given Element */
00153     void checkSelector(int selector, DOM::ElementImpl *e);
00154     /* checks if the selector matches the given Element */
00155     bool checkOneSelector(DOM::CSSSelector *selector, DOM::ElementImpl *e, bool isAncestor, bool isSubSelector=false);
00156 
00157 #ifdef APPLE_CHANGES
00158     /* This function fixes up the default font size if it detects that the
00159        current generic font family has changed. -dwh */
00160     void checkForGenericFamilyChange(RenderStyle* aStyle, RenderStyle* aParentStyle);
00161 #endif
00162 
00163     /* builds up the selectors and properties lists from the CSSStyleSelectorList's */
00164     void buildLists();
00165     void clearLists();
00166 
00167         void adjustRenderStyle(RenderStyle* style, DOM::ElementImpl *e);
00168 
00169         unsigned int addInlineDeclarations(DOM::ElementImpl* e, DOM::CSSStyleDeclarationImpl *decl,
00170                    unsigned int numProps);
00171 
00172     static DOM::CSSStyleSheetImpl *s_defaultSheet;
00173     static DOM::CSSStyleSheetImpl *s_quirksSheet;
00174     static CSSStyleSelectorList *s_defaultStyle;
00175     static CSSStyleSelectorList *s_defaultQuirksStyle;
00176     static CSSStyleSelectorList *s_defaultPrintStyle;
00177         static RenderStyle* styleNotYetAvailable;
00178 
00179     CSSStyleSelectorList *defaultStyle;
00180     CSSStyleSelectorList *defaultQuirksStyle;
00181     CSSStyleSelectorList *defaultPrintStyle;
00182 
00183     CSSStyleSelectorList *authorStyle;
00184         CSSStyleSelectorList *userStyle;
00185         DOM::CSSStyleSheetImpl *userSheet;
00186 
00187 public:
00188 
00189     private:
00190         void init(const KHTMLSettings* settings, DOM::DocumentImpl* doc);
00191 
00192         void mapBackgroundAttachment(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00193         void mapBackgroundClip(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00194         void mapBackgroundOrigin(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00195         void mapBackgroundImage(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00196         void mapBackgroundRepeat(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00197         void mapBackgroundSize(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00198         void mapBackgroundXPosition(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00199         void mapBackgroundYPosition(BackgroundLayer* layer, DOM::CSSValueImpl* value);
00200 
00201     public: // we need to make the enum public for SelectorCache
00202     enum SelectorState {
00203         Unknown = 0,
00204         Applies,
00205         AppliesPseudo,
00206         Invalid
00207     };
00208 
00209         enum SelectorMedia {
00210             MediaAural = 1,
00211             MediaBraille,
00212             MediaEmboss,
00213             MediaHandheld,
00214             MediaPrint,
00215             MediaProjection,
00216             MediaScreen,
00217             MediaTTY,
00218             MediaTV
00219         };
00220     protected:
00221 
00222         struct SelectorCache {
00223             SelectorState state;
00224             unsigned int props_size;
00225             int *props;
00226         };
00227 
00228     unsigned int selectors_size;
00229     DOM::CSSSelector **selectors;
00230     SelectorCache *selectorCache;
00231     unsigned int properties_size;
00232     CSSOrderedProperty **properties;
00233     QMemArray<CSSOrderedProperty> inlineProps;
00234         QString m_medium;
00235     CSSOrderedProperty **propsToApply;
00236     CSSOrderedProperty **pseudoProps;
00237     unsigned int propsToApplySize;
00238     unsigned int pseudoPropsSize;
00239 
00240 
00241     RenderStyle::PseudoId dynamicPseudo;
00242 
00243     RenderStyle *style;
00244     RenderStyle *parentStyle;
00245     DOM::ElementImpl *element;
00246     DOM::NodeImpl *parentNode;
00247     KHTMLView *view;
00248     KHTMLPart *part;
00249     const KHTMLSettings *settings;
00250     QPaintDeviceMetrics *paintDeviceMetrics;
00251         QValueVector<int>     m_fontSizes;
00252     QValueVector<int>     m_fixedFontSizes;
00253 
00254     bool fontDirty;
00255 
00256     void applyRule(int id, DOM::CSSValueImpl *value);
00257     };
00258 
00259     /*
00260      * List of properties that get applied to the Element. We need to collect them first
00261      * and then apply them one by one, because we have to change the apply order.
00262      * Some properties depend on other one already being applied (for example all properties specifying
00263      * some length need to have already the correct font size. Same applies to color
00264      *
00265      * While sorting them, we have to take care not to mix up the original order.
00266      */
00267     class CSSOrderedProperty
00268     {
00269     public:
00270     CSSOrderedProperty(DOM::CSSProperty *_prop, uint _selector,
00271                bool first, Source source, unsigned int specificity,
00272                unsigned int _position )
00273         : prop ( _prop ), pseudoId( RenderStyle::NOPSEUDO ), selector( _selector ),
00274           position( _position )
00275     {
00276         priority = (!first << 30) | (source << 24) | specificity;
00277     }
00278 
00279     bool operator < ( const CSSOrderedProperty &other ) const {
00280              if (priority < other.priority) return true;
00281              if (priority > other.priority) return false;
00282              if (position < other.position) return true;
00283              return false;
00284     }
00285 
00286     DOM::CSSProperty *prop;
00287     RenderStyle::PseudoId pseudoId;
00288     unsigned int selector;
00289     unsigned int position;
00290 
00291     Q_UINT32 priority;
00292     };
00293 
00294     /*
00295      * This is the list we will collect all properties we need to apply in.
00296      * It will get sorted once before applying.
00297      */
00298     class CSSOrderedPropertyList : public QPtrList<CSSOrderedProperty>
00299     {
00300     public:
00301     virtual int compareItems(QPtrCollection::Item i1, QPtrCollection::Item i2);
00302     void append(DOM::CSSStyleDeclarationImpl *decl, uint selector, uint specificity,
00303             Source regular, Source important );
00304     };
00305 
00306     class CSSOrderedRule
00307     {
00308     public:
00309     CSSOrderedRule(DOM::CSSStyleRuleImpl *r, DOM::CSSSelector *s, int _index);
00310     ~CSSOrderedRule();
00311 
00312     DOM::CSSSelector *selector;
00313     DOM::CSSStyleRuleImpl *rule;
00314     int index;
00315     };
00316 
00317     class CSSStyleSelectorList : public QPtrList<CSSOrderedRule>
00318     {
00319     public:
00320     CSSStyleSelectorList();
00321     virtual ~CSSStyleSelectorList();
00322 
00323     void append( DOM::CSSStyleSheetImpl *sheet,
00324              const DOM::DOMString &medium = "screen" );
00325 
00326     void collect( QPtrList<DOM::CSSSelector> *selectorList, CSSOrderedPropertyList *propList,
00327               Source regular, Source important );
00328     };
00329 
00330 }
00331 #endif
KDE Home | KDE Accessibility Home | Description of Access Keys