khtml/css/css_valueimpl.h

   1 /*
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
   5  *           (C) 2004, 2005, 2006 Apple Computer, Inc.
   6  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  *
  23  */
  24 #ifndef _CSS_css_valueimpl_h_
  25 #define _CSS_css_valueimpl_h_
  26
  27 #include "dom/css_value.h"
  28 #include "dom/dom_string.h"
  29 #include "css/css_base.h"
  30 #include "misc/loader_client.h"
  31 #include "misc/shared.h"
  32
  33 namespace khtml {
  34     class RenderStyle;
  35     class CachedImage;
  36 }
  37
  38
  39 namespace DOM {
  40
  41 class CSSRuleImpl;
  42 class CSSValueImpl;
  43 class NodeImpl;
  44 class CounterImpl;
  45 class PairImpl;
  46
  47
  48 class CSSStyleDeclarationImpl : public StyleBaseImpl
  49 {
  50 public:
  51     CSSStyleDeclarationImpl(CSSRuleImpl *parentRule);
  52     CSSStyleDeclarationImpl(CSSRuleImpl *parentRule, QList<CSSProperty*> *lstValues);
  53     virtual ~CSSStyleDeclarationImpl();
  54
  55     CSSStyleDeclarationImpl& operator=( const CSSStyleDeclarationImpl&);
  56
  57     virtual unsigned long length() const;
  58     CSSRuleImpl *parentRule() const;
  59     virtual void removeProperty(int propertyID, DOM::DOMString* old = 0);
  60     virtual void removePropertiesInSet(const int* set, unsigned length);
  61     virtual bool setProperty ( int propertyId, const DOM::DOMString &value, bool important, int &ec);
  62     virtual bool setProperty ( int propertyId, const DOM::DOMString &value, bool important = false);
  63     virtual void setProperty ( int propertyId, int value, bool important = false);
  64     virtual void clear();
  65     // this treats integers as pixels!
  66     // needed for conversion of html attributes
  67     virtual void setLengthProperty(int id, const DOM::DOMString &value, bool important, bool multiLength = false);
  68
  69     void setProperty(const DOMString &propertyName, const DOMString &value, const DOMString &priority);
  70     DOMString removeProperty(const DOMString &propertyName);
  71
  72     // add a whole, unparsed property
  73     virtual void setProperty ( const DOMString &propertyString);
  74     virtual DOM::DOMString item ( unsigned long index ) const;
  75
  76     DOM::DOMString cssText() const;
  77     void setCssText(const DOM::DOMString& str);
  78
  79     virtual bool isStyleDeclaration() const { return true; }
  80     virtual bool parseString( const DOMString &string, bool = false );
  81
  82     CSSValueImpl *getPropertyCSSValue(const DOMString &propertyName) const;
  83     DOMString getPropertyValue(const DOMString &propertyName) const ;
  84     DOMString getPropertyPriority(const DOMString &propertyName) const;
  85
  86     virtual CSSValueImpl *getPropertyCSSValue( int propertyID ) const;
  87     virtual DOMString getPropertyValue( int propertyID ) const;
  88     virtual bool getPropertyPriority( int propertyID ) const;
  89
  90     QList<CSSProperty*> *values() const { return m_lstValues; }
  91     void setNode(NodeImpl *_node) { m_node = _node; }
  92
  93     void setChanged();
  94
  95     void removeCSSHints();
  96
  97 protected:
  98     DOMString getShortHandValue( const int* properties, int number ) const;
  99     DOMString getCommonValue(const int* properties, int number) const;
 100     DOMString getLayeredShortHandValue(const int* properties, unsigned number) const;
 101     DOMString get4Values( const int* properties ) const;
 102
 103     QList<CSSProperty*> *m_lstValues;
 104     NodeImpl *m_node;
 105
 106 private:
 107     // currently not needed - make sure its not used
 108     CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl& o);
 109 };
 110
 111 class CSSValueImpl : public StyleBaseImpl
 112 {
 113 public:
 114     CSSValueImpl() : StyleBaseImpl() {}
 115
 116     virtual unsigned short cssValueType() const = 0;
 117
 118     virtual DOM::DOMString cssText() const = 0;
 119     void setCssText(const DOM::DOMString&) { } // FIXME: Not implemented.
 120
 121     virtual bool isValue() const { return true; }
 122     virtual bool isFontValue() const { return false; }
 123     virtual bool isImplicitInitialValue() const { return false; }
 124 };
 125
 126 class CSSInheritedValueImpl : public CSSValueImpl
 127 {
 128 public:
 129     CSSInheritedValueImpl() : CSSValueImpl() {}
 130     virtual ~CSSInheritedValueImpl() {}
 131
 132     virtual unsigned short cssValueType() const;
 133     virtual DOM::DOMString cssText() const;
 134 };
 135
 136 class CSSInitialValueImpl : public CSSValueImpl
 137 {
 138 public:
 139     CSSInitialValueImpl(bool implicit)
 140      :m_implicit(implicit)
 141     {}
 142     virtual unsigned short cssValueType() const;
 143     virtual DOM::DOMString cssText() const;
 144
 145     virtual bool isImplicitInitialValue() const { return m_implicit; }
 146 private:
 147     bool m_implicit;
 148 };
 149
 150 class CSSValueListImpl : public CSSValueImpl
 151 {
 152 public:
 153     CSSValueListImpl() : CSSValueImpl() {}
 154
 155     virtual ~CSSValueListImpl();
 156
 157     unsigned long length() const { return m_values.count(); }
 158     CSSValueImpl *item ( unsigned long index ) { return m_values.at(index); }
 159
 160     virtual bool isValueList() const { return true; }
 161
 162     virtual unsigned short cssValueType() const;
 163
 164     void append(CSSValueImpl *val);
 165     virtual DOM::DOMString cssText() const;
 166
 167 protected:
 168     QList<CSSValueImpl*> m_values;
 169 };
 170
 171
 172 class Counter;
 173 class RGBColor;
 174 class Rect;
 175
 176 class CSSPrimitiveValueImpl : public CSSValueImpl
 177 {
 178 public:
 179     CSSPrimitiveValueImpl();
 180     CSSPrimitiveValueImpl(int ident);
 181     CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type);
 182     CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type);
 183     CSSPrimitiveValueImpl(CounterImpl *c);
 184     CSSPrimitiveValueImpl( RectImpl *r);
 185     CSSPrimitiveValueImpl(QRgb color);
 186     CSSPrimitiveValueImpl(PairImpl *p);
 187
 188     virtual ~CSSPrimitiveValueImpl();
 189
 190     void cleanup();
 191
 192     unsigned short primitiveType() const { return m_type; }
 193
 194     /*
 195      * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
 196      * the fontinfo in case val is defined in em or ex.
 197      *
 198      * The metrics have to be a bit different for screen and printer output.
 199      * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
 200      *
 201      * this is screen/printer dependent, so we probably need a config option for this,
 202      * and some tool to calibrate.
 203      */
 204     int computeLength( khtml::RenderStyle *style, int logicalDpiY);
 205
 206     double computeLengthFloat( khtml::RenderStyle *style, int logicalDpiY);
 207
 208     // Retrieves an explicit resolution from the CSSValue if it contains one.
 209     // This is specific to the CSS3 Media Queries module's resolution feature.
 210     int getDPIResolution() const;
 211
 212     // use with care!!!
 213     void setPrimitiveType(unsigned short type) { m_type = type; }
 214     void setFloatValue ( unsigned short unitType, double floatValue, int &exceptioncode );
 215     double floatValue ( unsigned short unitType = CSSPrimitiveValue::CSS_UNKNOWN) const { (void)unitType; return m_value.num; }
 216
 217     void setStringValue ( unsigned short stringType, const DOM::DOMString &stringValue, int &exceptioncode );
 218     DOM::DOMStringImpl *getStringValue () const {
 219         return ( ( m_type < CSSPrimitiveValue::CSS_STRING ||
 220                    m_type > CSSPrimitiveValue::CSS_ATTR ||
 221                    m_type == CSSPrimitiveValue::CSS_IDENT ) ? // fix IDENT
 222                  0 : m_value.string );
 223     }
 224     CounterImpl *getCounterValue () const {
 225         return ( m_type != CSSPrimitiveValue::CSS_COUNTER ? 0 : m_value.counter );
 226     }
 227
 228     RectImpl *getRectValue () const {
 229         return ( m_type != CSSPrimitiveValue::CSS_RECT ? 0 : m_value.rect );
 230     }
 231
 232     QRgb getRGBColorValue () const {
 233         return ( m_type != CSSPrimitiveValue::CSS_RGBCOLOR ? 0 : m_value.rgbcolor );
 234     }
 235
 236     PairImpl* getPairValue() const {
 237         return (m_type != CSSPrimitiveValue::CSS_PAIR ? 0 : m_value.pair);
 238     }
 239
 240     virtual bool isPrimitiveValue() const { return true; }
 241     virtual unsigned short cssValueType() const;
 242
 243     int getIdent();
 244
 245     virtual bool parseString( const DOMString &string, bool = false);
 246     virtual DOM::DOMString cssText() const;
 247
 248     virtual bool isQuirkValue() const { return false; }
 249
 250 protected:
 251     int m_type;
 252     union {
 253         int ident;
 254         double num;
 255         DOM::DOMStringImpl *string;
 256         CounterImpl *counter;
 257         RectImpl *rect;
 258         QRgb rgbcolor;
 259         PairImpl* pair;
 260     } m_value;
 261 };
 262
 263 // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
 264 // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em
 265 // in a stylesheet.  When the quirky value is used, if you're in quirks mode, the margin will
 266 // collapse away inside a table cell.
 267 class CSSQuirkPrimitiveValueImpl : public CSSPrimitiveValueImpl
 268 {
 269 public:
 270     CSSQuirkPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
 271       :CSSPrimitiveValueImpl(num, type) {}
 272
 273     virtual ~CSSQuirkPrimitiveValueImpl() {}
 274
 275     virtual bool isQuirkValue() const { return true; }
 276 };
 277
 278 class CounterImpl : public khtml::Shared<CounterImpl> {
 279 public:
 280     CounterImpl() : m_listStyle(0) { }
 281     DOMString identifier() const { return m_identifier; }
 282     unsigned int listStyle() const { return m_listStyle; }
 283     DOMString separator() const { return m_separator; }
 284
 285     DOMString m_identifier;
 286     unsigned int m_listStyle;
 287     DOMString m_separator;
 288 };
 289
 290 class RectImpl : public khtml::Shared<RectImpl> {
 291 public:
 292     RectImpl();
 293     ~RectImpl();
 294
 295     CSSPrimitiveValueImpl *top() const { return m_top; }
 296     CSSPrimitiveValueImpl *right() const { return m_right; }
 297     CSSPrimitiveValueImpl *bottom() const { return m_bottom; }
 298     CSSPrimitiveValueImpl *left() const { return m_left; }
 299
 300     void setTop( CSSPrimitiveValueImpl *top );
 301     void setRight( CSSPrimitiveValueImpl *right );
 302     void setBottom( CSSPrimitiveValueImpl *bottom );
 303     void setLeft( CSSPrimitiveValueImpl *left );
 304 protected:
 305     CSSPrimitiveValueImpl *m_top;
 306     CSSPrimitiveValueImpl *m_right;
 307     CSSPrimitiveValueImpl *m_bottom;
 308     CSSPrimitiveValueImpl *m_left;
 309 };
 310
 311 // A primitive value representing a pair.  This is useful for properties like border-radius, background-size/position,
 312 // and border-spacing (all of which are space-separated sets of two values).  At the moment we are only using it for
 313 // border-radius and background-size, but (FIXME) border-spacing and background-position could be converted over to use
 314 // it (eliminating some extra -webkit- internal properties).
 315 class PairImpl : public khtml::Shared<PairImpl> {
 316 public:
 317     PairImpl() : m_first(0), m_second(0) { }
 318     PairImpl(CSSPrimitiveValueImpl* first, CSSPrimitiveValueImpl* second)
 319         : m_first(first), m_second(second) { if (first) first->ref(); if (second) second->ref(); }
 320     virtual ~PairImpl();
 321
 322     CSSPrimitiveValueImpl* first() const { return m_first; }
 323     CSSPrimitiveValueImpl* second() const { return m_second; }
 324
 325     void setFirst(CSSPrimitiveValueImpl* first);
 326     void setSecond(CSSPrimitiveValueImpl* second);
 327
 328 protected:
 329     CSSPrimitiveValueImpl* m_first;
 330     CSSPrimitiveValueImpl* m_second;
 331 };
 332
 333
 334 class CSSImageValueImpl : public CSSPrimitiveValueImpl, public khtml::CachedObjectClient
 335 {
 336 public:
 337     CSSImageValueImpl(const DOMString &url, const StyleBaseImpl *style);
 338     CSSImageValueImpl();
 339     virtual ~CSSImageValueImpl();
 340
 341     khtml::CachedImage *image() { return m_image; }
 342 protected:
 343     khtml::CachedImage *m_image;
 344 };
 345
 346 class FontFamilyValueImpl : public CSSPrimitiveValueImpl
 347 {
 348 public:
 349     FontFamilyValueImpl( const QString &string);
 350     const QString &fontName() const { return parsedFontName; }
 351     int genericFamilyType() const { return _genericFamilyType; }
 352 protected:
 353     QString parsedFontName;
 354 private:
 355     int _genericFamilyType;
 356 };
 357
 358 class FontValueImpl : public CSSValueImpl
 359 {
 360 public:
 361     FontValueImpl();
 362     virtual ~FontValueImpl();
 363
 364     virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
 365
 366     virtual DOM::DOMString cssText() const;
 367
 368     virtual bool isFontValue() const { return true; }
 369
 370     CSSPrimitiveValueImpl *style;
 371     CSSPrimitiveValueImpl *variant;
 372     CSSPrimitiveValueImpl *weight;
 373     CSSPrimitiveValueImpl *size;
 374     CSSPrimitiveValueImpl *lineHeight;
 375     CSSValueListImpl *family;
 376 };
 377
 378 // Used for quotes
 379 class QuotesValueImpl : public CSSValueImpl
 380 {
 381 public:
 382     QuotesValueImpl();
 383 //    virtual ~QuotesValueImpl();
 384
 385     virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
 386     virtual DOM::DOMString cssText() const;
 387
 388     void addLevel(const QString& open, const QString& close);
 389     QString openQuote(int level) const;
 390     QString closeQuote(int level) const;
 391
 392     unsigned int levels;
 393     QStringList data;
 394 };
 395
 396 // Used for text-shadow and box-shadow
 397 class ShadowValueImpl : public CSSValueImpl
 398 {
 399 public:
 400     ShadowValueImpl(CSSPrimitiveValueImpl* _x, CSSPrimitiveValueImpl* _y,
 401                     CSSPrimitiveValueImpl* _blur, CSSPrimitiveValueImpl* _color);
 402     virtual ~ShadowValueImpl();
 403
 404     virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
 405
 406     virtual DOM::DOMString cssText() const;
 407
 408     CSSPrimitiveValueImpl* x;
 409     CSSPrimitiveValueImpl* y;
 410     CSSPrimitiveValueImpl* blur;
 411     CSSPrimitiveValueImpl* color;
 412 };
 413
 414 // Used for counter-reset and counter-increment
 415 class CounterActImpl : public CSSValueImpl {
 416     public:
 417         CounterActImpl(const DOMString &c, short v) : m_counter(c), m_value(v) { }
 418         virtual ~CounterActImpl() {}
 419
 420         virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
 421         virtual DOM::DOMString cssText() const;
 422
 423         const DOMString& counter() const { return m_counter; }
 424         short value() const { return m_value; }
 425         void setValue( const short v ) { m_value = v; }
 426
 427         DOM::DOMString m_counter;
 428         short m_value;
 429 };
 430
 431
 432 // ------------------------------------------------------------------------------
 433
 434 // another helper class
 435 class CSSProperty
 436 {
 437 public:
 438     CSSProperty()
 439     {
 440         m_id = -1;
 441         m_important = false;
 442         m_value = 0;
 443     }
 444     CSSProperty(const CSSProperty& o)
 445     {
 446         m_id = o.m_id;
 447         m_important = o.m_important;
 448         m_value = o.m_value;
 449         if (m_value) m_value->ref();
 450     }
 451     ~CSSProperty() {
 452         if(m_value) m_value->deref();
 453     }
 454
 455     void setValue(CSSValueImpl *val) {
 456         if ( val != m_value ) {
 457             if(m_value) m_value->deref();
 458             m_value = val;
 459             if(m_value) m_value->ref();
 460         }
 461     }
 462
 463     int id() const { return m_id; }
 464
 465     bool isImportant() const { return m_important; }
 466
 467     CSSValueImpl *value() const { return m_value; }
 468
 469     DOM::DOMString cssText() const;
 470
 471     // make sure the following fits in 4 bytes.
 472     signed int  m_id   : 29;
 473     bool m_important   : 1;
 474 protected:
 475     CSSValueImpl *m_value;
 476 };
 477
 478
 479 } // namespace
 480
 481 #endif