4f0259fa4a526d1ea5a9adeea7ef3ef0ba7549bc
[WebKit-https.git] / 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) 2004 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 = 0);
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     void diff(CSSStyleDeclarationImpl *) const;
90
91     CSSStyleDeclarationImpl *copyBlockProperties() const;
92
93     void setChanged();
94
95 protected:
96     DOMString getShortHandValue( const int* properties, int number ) const;
97     DOMString get4Values( const int* properties ) const;
98
99     CSSStyleDeclarationImpl *copyPropertiesInSet(const int *set, unsigned length) const;
100
101     QPtrList<CSSProperty> *m_lstValues;
102     NodeImpl *m_node;
103
104 private:
105     // currently not needed - make sure its not used
106     CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl& o);
107 };
108
109 class CSSValueImpl : public StyleBaseImpl
110 {
111 public:
112     CSSValueImpl();
113
114     virtual ~CSSValueImpl();
115
116     virtual unsigned short cssValueType() const = 0;
117
118     virtual DOMString cssText() const = 0;
119
120     virtual bool isValue() { return true; }
121     virtual bool isFontValue() { return false; }
122 };
123
124 class CSSInheritedValueImpl : public CSSValueImpl
125 {
126 public:
127     CSSInheritedValueImpl() : CSSValueImpl() {}
128     virtual ~CSSInheritedValueImpl() {}
129
130     virtual unsigned short cssValueType() const;
131     virtual DOMString cssText() const;
132 };
133
134 class CSSInitialValueImpl : public CSSValueImpl
135 {
136 public:
137     virtual unsigned short cssValueType() const;
138     virtual DOMString cssText() const;
139 };
140
141 class CSSValueListImpl : public CSSValueImpl
142 {
143 public:
144     CSSValueListImpl();
145
146     virtual ~CSSValueListImpl();
147
148     unsigned long length() const { return m_values.count(); }
149     CSSValueImpl *item ( unsigned long index ) { return m_values.at(index); }
150
151     virtual bool isValueList() { return true; }
152
153     virtual unsigned short cssValueType() const;
154
155     void append(CSSValueImpl *val);
156     virtual DOMString cssText() const;
157
158 protected:
159     QPtrList<CSSValueImpl> m_values;
160 };
161
162
163 class Counter;
164 class RGBColor;
165 class Rect;
166 class DashboardRegionImpl;
167
168 class CSSPrimitiveValueImpl : public CSSValueImpl
169 {
170 public:
171     CSSPrimitiveValueImpl();
172     CSSPrimitiveValueImpl(int ident);
173     CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type);
174     CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type);
175     CSSPrimitiveValueImpl(const Counter &c);
176     CSSPrimitiveValueImpl( RectImpl *r);
177     CSSPrimitiveValueImpl( DashboardRegionImpl *r);
178     CSSPrimitiveValueImpl(QRgb color);
179
180     virtual ~CSSPrimitiveValueImpl();
181
182     void cleanup();
183
184     unsigned short primitiveType() const {
185             return m_type;
186     }
187
188     /*
189      * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
190      * the fontinfo in case val is defined in em or ex.
191      *
192      * The metrics have to be a bit different for screen and printer output.
193      * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
194      *
195      * this is screen/printer dependent, so we probably need a config option for this,
196      * and some tool to calibrate.
197      */
198     int computeLength( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics );
199     int computeLength( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics, double multiplier );
200     double computeLengthFloat( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics,
201                                bool applyZoomFactor = true );
202
203     // use with care!!!
204     void setPrimitiveType(unsigned short type) { m_type = type; }
205     void setFloatValue ( unsigned short unitType, double floatValue, int &exceptioncode );
206     double getFloatValue ( unsigned short/* unitType */) const {
207         return m_value.num;
208     }
209
210     void setStringValue ( unsigned short stringType, const DOM::DOMString &stringValue, int &exceptioncode );
211     DOM::DOMString getStringValue() const;
212     
213     CounterImpl *getCounterValue () const {
214         return ( m_type != CSSPrimitiveValue::CSS_COUNTER ? 0 : m_value.counter );
215     }
216
217     RectImpl *getRectValue () const {
218         return ( m_type != CSSPrimitiveValue::CSS_RECT ? 0 : m_value.rect );
219     }
220
221     QRgb getRGBColorValue () const {
222         return ( m_type != CSSPrimitiveValue::CSS_RGBCOLOR ? 0 : m_value.rgbcolor );
223     }
224
225 #if APPLE_CHANGES
226     DashboardRegionImpl *getDashboardRegionValue () const {
227         return ( m_type != CSSPrimitiveValue::CSS_DASHBOARD_REGION ? 0 : m_value.region );
228     }
229 #endif
230
231     virtual bool isPrimitiveValue() const { return true; }
232     virtual unsigned short cssValueType() const;
233
234     int getIdent();
235
236     virtual bool parseString( const DOMString &string, bool = false);
237     virtual DOMString cssText() const;
238
239     virtual bool isQuirkValue() { return false; }
240
241 protected:
242     int m_type;
243     union {
244         int ident;
245         double num;
246         DOMStringImpl *string;
247         CounterImpl *counter;
248         RectImpl *rect;
249         QRgb rgbcolor;
250         DashboardRegionImpl *region;
251     } m_value;
252 };
253
254 // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
255 // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em
256 // in a stylesheet.  When the quirky value is used, if you're in quirks mode, the margin will
257 // collapse away inside a table cell.
258 class CSSQuirkPrimitiveValueImpl : public CSSPrimitiveValueImpl
259 {
260 public:
261     CSSQuirkPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
262       :CSSPrimitiveValueImpl(num, type) {}
263
264     virtual ~CSSQuirkPrimitiveValueImpl() {}
265
266     virtual bool isQuirkValue() { return true; }
267 };
268
269 class CounterImpl : public khtml::Shared<CounterImpl> {
270 public:
271     CounterImpl() { }
272     DOMString identifier() const { return m_identifier; }
273     DOMString listStyle() const { return m_listStyle; }
274     DOMString separator() const { return m_separator; }
275
276     DOMString m_identifier;
277     DOMString m_listStyle;
278     DOMString m_separator;
279 };
280
281 class RectImpl : public khtml::Shared<RectImpl> {
282 public:
283     RectImpl();
284     ~RectImpl();
285
286     CSSPrimitiveValueImpl *top() { return m_top; }
287     CSSPrimitiveValueImpl *right() { return m_right; }
288     CSSPrimitiveValueImpl *bottom() { return m_bottom; }
289     CSSPrimitiveValueImpl *left() { return m_left; }
290
291     void setTop( CSSPrimitiveValueImpl *top );
292     void setRight( CSSPrimitiveValueImpl *right );
293     void setBottom( CSSPrimitiveValueImpl *bottom );
294     void setLeft( CSSPrimitiveValueImpl *left );
295 protected:
296     CSSPrimitiveValueImpl *m_top;
297     CSSPrimitiveValueImpl *m_right;
298     CSSPrimitiveValueImpl *m_bottom;
299     CSSPrimitiveValueImpl *m_left;
300 };
301
302 #if APPLE_CHANGES
303 class DashboardRegionImpl : public RectImpl {
304 public:
305     DashboardRegionImpl() : RectImpl(), m_next(0), m_isCircle(0), m_isRectangle(0) { };
306     ~DashboardRegionImpl() {
307         if (m_next)
308             m_next->deref();
309     };
310
311     void setNext (DashboardRegionImpl *next) {
312         if (m_next) m_next->deref();
313         if (next) next->ref();
314         m_next = next;
315     };
316     
317 public:
318     DashboardRegionImpl *m_next;
319     QString m_label;
320     QString m_geometryType;
321     unsigned int m_isCircle:1;
322     unsigned int m_isRectangle:1;
323 };
324 #endif
325
326 class CSSImageValueImpl : public CSSPrimitiveValueImpl, public khtml::CachedObjectClient
327 {
328 public:
329     CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style);
330     CSSImageValueImpl();
331     virtual ~CSSImageValueImpl();
332
333     khtml::CachedImage *image(khtml::DocLoader* loader);
334
335 protected:
336     khtml::CachedImage* m_image;
337     bool m_accessedImage;
338 };
339
340 class FontFamilyValueImpl : public CSSPrimitiveValueImpl
341 {
342 public:
343     FontFamilyValueImpl( const QString &string);
344     const QString &fontName() const { return parsedFontName; }
345     int genericFamilyType() const { return _genericFamilyType; }
346
347     virtual DOMString cssText() const;
348
349     QString parsedFontName;
350 private:
351     int _genericFamilyType;
352 };
353
354 class FontValueImpl : public CSSValueImpl
355 {
356 public:
357     FontValueImpl();
358     virtual ~FontValueImpl();
359
360     virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
361     
362     virtual DOMString cssText() const;
363     
364     virtual bool isFontValue() { return true; }
365
366     CSSPrimitiveValueImpl *style;
367     CSSPrimitiveValueImpl *variant;
368     CSSPrimitiveValueImpl *weight;
369     CSSPrimitiveValueImpl *size;
370     CSSPrimitiveValueImpl *lineHeight;
371     CSSValueListImpl *family;
372 };
373
374 // Used for text-shadow and box-shadow
375 class ShadowValueImpl : public CSSValueImpl
376 {
377 public:
378     ShadowValueImpl(CSSPrimitiveValueImpl* _x, CSSPrimitiveValueImpl* _y,
379                     CSSPrimitiveValueImpl* _blur, CSSPrimitiveValueImpl* _color);
380     virtual ~ShadowValueImpl();
381
382     virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
383
384     virtual DOMString cssText() const;
385
386     CSSPrimitiveValueImpl* x;
387     CSSPrimitiveValueImpl* y;
388     CSSPrimitiveValueImpl* blur;
389     CSSPrimitiveValueImpl* color;
390 };
391
392 // Used by box-flex-group-transition
393 class FlexGroupTransitionValueImpl : public CSSValueImpl
394 {
395 public:
396     FlexGroupTransitionValueImpl();
397     FlexGroupTransitionValueImpl(unsigned int _group1, 
398                                  unsigned int _group2,
399                                  CSSPrimitiveValueImpl* _length);
400     virtual ~FlexGroupTransitionValueImpl();
401     
402     virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
403     
404     virtual DOMString cssText() const;
405     
406     bool isAuto() const { return autoValue; }
407
408     bool autoValue;
409     unsigned int group1;
410     unsigned int group2;
411     CSSPrimitiveValueImpl* length;
412 };
413
414 // ------------------------------------------------------------------------------
415
416 // another helper class
417 class CSSProperty
418 {
419 public:
420     CSSProperty()
421     {
422         m_id = -1;
423         m_bImportant = false;
424         m_value = 0;
425     }
426     CSSProperty(const CSSProperty& o)
427     {
428         m_id = o.m_id;
429         m_bImportant = o.m_bImportant;
430         m_value = o.m_value;
431         if (m_value) m_value->ref();
432     }
433     ~CSSProperty() {
434         if(m_value) m_value->deref();
435     }
436
437     void setValue(CSSValueImpl *val) {
438         if ( val != m_value ) {
439             if(m_value) m_value->deref();
440             m_value = val;
441             if(m_value) m_value->ref();
442         }
443     }
444
445     int id() const { return m_id; }
446     bool isImportant() const { return m_bImportant; }
447     
448     CSSValueImpl *value() const { return m_value; }
449     
450     DOMString cssText() const;
451
452     // make sure the following fits in 4 bytes.
453     int  m_id;
454     bool m_bImportant;
455 protected:
456     CSSValueImpl *m_value;
457
458 private:
459     CSSProperty &operator=(const CSSProperty&);
460 };
461
462 typedef CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
463
464 } // namespace
465
466 #endif