WebCore/khtml/css/css_valueimpl.h

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