83278ae0639edc07606826fb978ac3f6123193d0
[WebKit-https.git] / WebCore / khtml / ecma / kjs_css.h
1  // -*- c-basic-offset: 2 -*-
2 /*
3  *  This file is part of the KDE libraries
4  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
5  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
6  *  Copyright (C) 2004 Apple Computer, Inc.
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Lesser 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  *  Lesser General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Lesser General Public
19  *  License along with this library; if not, write to the Free Software
20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #ifndef _KJS_CSS_H_
24 #define _KJS_CSS_H_
25
26 #include "kjs_binding.h"
27
28 #include "Color.h"
29
30 namespace DOM {
31     class CounterImpl;
32     class CSSPrimitiveValueImpl;
33     class CSSRuleImpl;
34     class CSSRuleListImpl;
35     class CSSStyleDeclarationImpl;
36     class CSSStyleSheetImpl;
37     class CSSValueImpl;
38     class CSSValueListImpl;
39     class MediaListImpl;
40     class RectImpl;
41     class StyleSheetImpl;
42     class StyleSheetListImpl;
43 }
44
45 namespace KJS {
46
47   class DOMCSSStyleDeclaration : public DOMObject {
48   public:
49     DOMCSSStyleDeclaration(ExecState *exec, DOM::CSSStyleDeclarationImpl *s);
50     virtual ~DOMCSSStyleDeclaration();
51     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
52     virtual void put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr = None);
53     JSValue *getValueProperty(ExecState *exec, int token);
54
55     virtual const ClassInfo *classInfo() const { return &info; }
56     static const ClassInfo info;
57     enum { CssText, Length, ParentRule };
58     enum { GetPropertyValue, GetPropertyCSSValue, RemoveProperty, 
59            GetPropertyPriority, GetPropertyShorthand, IsPropertyImplicit, SetProperty, Item };
60     DOM::CSSStyleDeclarationImpl *impl() const { return m_impl.get(); }
61   private:
62     static JSValue *indexGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
63     static JSValue *cssPropertyGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
64
65     RefPtr<DOM::CSSStyleDeclarationImpl> m_impl;
66   };
67
68   JSValue *getDOMCSSStyleDeclaration(ExecState *exec, DOM::CSSStyleDeclarationImpl *d);
69
70   class DOMStyleSheet : public DOMObject {
71   public:
72     DOMStyleSheet(ExecState *, DOM::StyleSheetImpl *ss) : m_impl(ss) { }
73     virtual ~DOMStyleSheet();
74     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
75     JSValue *getValueProperty(ExecState *exec, int token) const;
76     virtual void put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr = None);
77     virtual bool toBoolean(ExecState *) const { return true; }
78     virtual const ClassInfo* classInfo() const { return &info; }
79     static const ClassInfo info;
80     enum { Type, Disabled, OwnerNode, ParentStyleSheet, Href, Title, Media };
81     DOM::StyleSheetImpl *impl() const { return m_impl.get(); }
82   protected:
83     // Constructor for derived classes; doesn't set up a prototype.
84     DOMStyleSheet(DOM::StyleSheetImpl *ss) : m_impl(ss) { }
85   private:
86     RefPtr<DOM::StyleSheetImpl> m_impl;
87   };
88
89   JSValue* getDOMStyleSheet(ExecState*, PassRefPtr<WebCore::StyleSheetImpl>);
90
91   class DOMStyleSheetList : public DOMObject {
92   public:
93     DOMStyleSheetList(ExecState *, DOM::StyleSheetListImpl *ssl, DOM::DocumentImpl *doc)
94       : m_impl(ssl), m_doc(doc) { }
95     virtual ~DOMStyleSheetList();
96     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
97     JSValue *getValueProperty(ExecState *exec, int token) const;
98     // no put - all read-only
99     virtual const ClassInfo* classInfo() const { return &info; }
100     virtual bool toBoolean(ExecState* ) const { return true; }
101     static const ClassInfo info;
102     DOM::StyleSheetListImpl *impl() const { return m_impl.get(); }
103     enum { Item, Length };
104   private:
105     static JSValue *indexGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
106     static JSValue *nameGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
107
108     RefPtr<DOM::StyleSheetListImpl> m_impl;
109     RefPtr<DOM::DocumentImpl> m_doc;
110   };
111
112   // The document is only used for get-stylesheet-by-name (make optional if necessary)
113   JSValue *getDOMStyleSheetList(ExecState *exec, DOM::StyleSheetListImpl *ss, DOM::DocumentImpl *doc);
114
115   class DOMMediaList : public DOMObject {
116   public:
117     DOMMediaList(ExecState *, DOM::MediaListImpl *ml);
118     virtual ~DOMMediaList();
119     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
120     JSValue *getValueProperty(ExecState *exec, int token);
121     virtual void put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr = None);
122     virtual const ClassInfo* classInfo() const { return &info; }
123     virtual bool toBoolean(ExecState* ) const { return true; }
124     static const ClassInfo info;
125     enum { MediaText, Length,
126            Item, DeleteMedium, AppendMedium };
127     DOM::MediaListImpl *impl() const { return m_impl.get(); }
128   private:
129     static JSValue *indexGetter(ExecState *exec, JSObject *, const Identifier&, const PropertySlot& slot);
130     RefPtr<DOM::MediaListImpl> m_impl;
131   };
132
133   JSValue *getDOMMediaList(ExecState *exec, DOM::MediaListImpl *ml);
134
135   class DOMCSSStyleSheet : public DOMStyleSheet {
136   public:
137     DOMCSSStyleSheet(ExecState *exec, DOM::CSSStyleSheetImpl *ss);
138     virtual ~DOMCSSStyleSheet();
139     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
140     JSValue *getValueProperty(ExecState *exec, int token) const;
141     // no put - all read-only
142     virtual const ClassInfo* classInfo() const { return &info; }
143     static const ClassInfo info;
144     enum { OwnerRule, CssRules, Rules, InsertRule, DeleteRule, AddRule, RemoveRule };
145   };
146
147   class DOMCSSRuleList : public DOMObject {
148   public:
149     DOMCSSRuleList(ExecState *, DOM::CSSRuleListImpl *rl) : m_impl(rl) { }
150     virtual ~DOMCSSRuleList();
151     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
152     JSValue *getValueProperty(ExecState *exec, int token) const;
153     // no put - all read-only
154     virtual const ClassInfo* classInfo() const { return &info; }
155     static const ClassInfo info;
156     enum { Item, Length };
157     DOM::CSSRuleListImpl *impl() const { return m_impl.get(); }
158   private:
159     static JSValue *indexGetter(ExecState *exec, JSObject *, const Identifier&, const PropertySlot& slot);
160
161     RefPtr<DOM::CSSRuleListImpl> m_impl;
162   };
163
164   JSValue *getDOMCSSRuleList(ExecState *exec, DOM::CSSRuleListImpl *rl);
165
166   class DOMCSSRule : public DOMObject {
167   public:
168     DOMCSSRule(ExecState *, DOM::CSSRuleImpl *r) : m_impl(r) { }
169     virtual ~DOMCSSRule();
170     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
171     JSValue *getValueProperty(ExecState *exec, int token) const;
172     virtual void put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr = None);
173     void putValueProperty(ExecState *exec, int token, JSValue *value, int attr);
174     virtual const ClassInfo* classInfo() const;
175     static const ClassInfo info;
176     static const ClassInfo style_info, media_info, fontface_info, page_info, import_info, charset_info;
177     enum { ParentStyleSheet, Type, CssText, ParentRule, Style_SelectorText, Style_Style,
178            Media_Media, Media_InsertRule, Media_DeleteRule, Media_CssRules,
179            FontFace_Style, Page_SelectorText, Page_Style,
180            Import_Href, Import_Media, Import_StyleSheet, Charset_Encoding };
181     DOM::CSSRuleImpl *impl() const { return m_impl.get(); }
182   private:
183     RefPtr<DOM::CSSRuleImpl> m_impl;
184   };
185
186   JSValue *getDOMCSSRule(ExecState *exec, DOM::CSSRuleImpl *r);
187
188   // Constructor for CSSRule - currently only used for some global values
189   class CSSRuleConstructor : public DOMObject {
190   public:
191     CSSRuleConstructor(ExecState *) { }
192     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
193     JSValue *getValueProperty(ExecState *exec, int token) const;
194     // no put - all read-only
195     virtual const ClassInfo* classInfo() const { return &info; }
196     static const ClassInfo info;
197     enum { UNKNOWN_RULE, STYLE_RULE, CHARSET_RULE, IMPORT_RULE, MEDIA_RULE, FONT_FACE_RULE, PAGE_RULE };
198   };
199
200   JSValue *getCSSRuleConstructor(ExecState *exec);
201
202   class DOMCSSValue : public DOMObject {
203   public:
204     DOMCSSValue(ExecState *, DOM::CSSValueImpl *v) : m_impl(v) { }
205     virtual ~DOMCSSValue();
206     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
207     JSValue *getValueProperty(ExecState *exec, int token) const;
208     virtual void put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr = None);
209     virtual const ClassInfo* classInfo() const { return &info; }
210     static const ClassInfo info;
211     enum { CssText, CssValueType };
212     DOM::CSSValueImpl *impl() const { return m_impl.get(); }
213   protected:
214     // Constructor for derived classes; doesn't set up a prototype.
215     DOMCSSValue(DOM::CSSValueImpl *v) : m_impl(v) { }
216   private:
217     RefPtr<DOM::CSSValueImpl> m_impl;
218   };
219
220   JSValue *getDOMCSSValue(ExecState *exec, DOM::CSSValueImpl *v);
221
222   // Constructor for CSSValue - currently only used for some global values
223   class CSSValueConstructor : public DOMObject {
224   public:
225     CSSValueConstructor(ExecState *) { }
226     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
227     JSValue *getValueProperty(ExecState *exec, int token) const;
228     // no put - all read-only
229     virtual const ClassInfo* classInfo() const { return &info; }
230     static const ClassInfo info;
231     enum { CSS_VALUE_LIST, CSS_PRIMITIVE_VALUE, CSS_CUSTOM, CSS_INHERIT };
232   };
233
234   JSValue *getCSSValueConstructor(ExecState *exec);
235
236   class DOMCSSPrimitiveValue : public DOMCSSValue {
237   public:
238     DOMCSSPrimitiveValue(ExecState *exec, DOM::CSSPrimitiveValueImpl *v);
239     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
240     JSValue *getValueProperty(ExecState *exec, int token);
241     // no put - all read-only
242     virtual const ClassInfo* classInfo() const { return &info; }
243     static const ClassInfo info;
244     enum { PrimitiveType, SetFloatValue, GetFloatValue, SetStringValue, GetStringValue,
245            GetCounterValue, GetRectValue, GetRGBColorValue };
246   };
247
248   // Constructor for CSSPrimitiveValue - currently only used for some global values
249   class CSSPrimitiveValueConstructor : public CSSValueConstructor {
250   public:
251     CSSPrimitiveValueConstructor(ExecState *exec) : CSSValueConstructor(exec) { }
252     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
253     JSValue *getValueProperty(ExecState *exec, int token) const;
254     // no put - all read-only
255     virtual const ClassInfo* classInfo() const { return &info; }
256     static const ClassInfo info;
257   };
258
259   JSValue *getCSSPrimitiveValueConstructor(ExecState *exec);
260
261   class DOMCSSValueList : public DOMCSSValue {
262   public:
263     DOMCSSValueList(ExecState *exec, DOM::CSSValueListImpl *l);
264     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
265     JSValue *getValueProperty(ExecState *exec, int token) const;
266     // no put - all read-only
267     virtual const ClassInfo* classInfo() const { return &info; }
268     static const ClassInfo info;
269     enum { Length, Item };
270   private:
271     static JSValue *indexGetter(ExecState *exec, JSObject *, const Identifier&, const PropertySlot& slot);
272   };
273
274   class DOMRGBColor : public DOMObject {
275   public:
276     DOMRGBColor(unsigned color) : m_color(color) { }
277     ~DOMRGBColor();
278     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
279     JSValue *getValueProperty(ExecState *exec, int token) const;
280     // no put - all read-only
281     virtual const ClassInfo* classInfo() const { return &info; }
282     static const ClassInfo info;
283     enum { Red, Green, Blue };
284   private:
285     unsigned m_color;
286   };
287
288   JSValue *getDOMRGBColor(ExecState *exec, unsigned color);
289
290   class DOMRect : public DOMObject {
291   public:
292     DOMRect(ExecState *, DOM::RectImpl *r) : m_rect(r) { }
293     ~DOMRect();
294     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
295     JSValue *getValueProperty(ExecState *exec, int token) const;
296     // no put - all read-only
297     virtual const ClassInfo* classInfo() const { return &info; }
298     static const ClassInfo info;
299     enum { Top, Right, Bottom, Left };
300   private:
301     RefPtr<DOM::RectImpl> m_rect;
302   };
303
304   JSValue *getDOMRect(ExecState *exec, DOM::RectImpl *r);
305
306   class DOMCounter : public DOMObject {
307   public:
308     DOMCounter(ExecState *, DOM::CounterImpl *c) : m_counter(c) { }
309     ~DOMCounter();
310     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
311     JSValue *getValueProperty(ExecState *exec, int token) const;
312     // no put - all read-only
313     virtual const ClassInfo* classInfo() const { return &info; }
314     static const ClassInfo info;
315     enum { identifier, listStyle, separator };
316   protected:
317     RefPtr<DOM::CounterImpl> m_counter;
318   };
319
320   JSValue *getDOMCounter(ExecState *exec, DOM::CounterImpl *c);
321
322 } // namespace
323
324 #endif