WebCore:
[WebKit-https.git] / WebCore / kwq / DOM-CSS.mm
1 /*
2  * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source exceptionCode must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #import "DOMCSS.h"
27
28 #include <objc/objc-class.h>
29
30 #import <css/css_base.h>
31 #import <css/css_ruleimpl.h>
32 #import <css/css_stylesheetimpl.h>
33 #import <css/css_valueimpl.h>
34 #import <dom/css_value.h>
35 #import <dom/dom_string.h>
36 #import <qcolor.h>
37 #import <shared.h>
38 #import <xml/dom_stringimpl.h>
39
40 #import "DOMInternal.h"
41 #import "KWQAssertions.h"
42
43 using DOM::CounterImpl;
44 using DOM::CSSCharsetRuleImpl;
45 using DOM::CSSFontFaceRuleImpl;
46 using DOM::CSSImportRuleImpl;
47 using DOM::CSSMediaRuleImpl;
48 using DOM::CSSPageRuleImpl;
49 using DOM::CSSPrimitiveValueImpl;
50 using DOM::CSSRuleImpl;
51 using DOM::CSSRuleListImpl;
52 using DOM::CSSStyleDeclarationImpl;
53 using DOM::CSSStyleRuleImpl;
54 using DOM::CSSStyleSheetImpl;
55 using DOM::CSSValueImpl;
56 using DOM::CSSValueListImpl;
57 using DOM::DOMString;
58 using DOM::MediaListImpl;
59 using DOM::RectImpl;
60 using DOM::StyleSheetImpl;
61 using DOM::StyleSheetListImpl;
62
63 @interface DOMStyleSheet (WebCoreInternal)
64 + (DOMStyleSheet *)_DOMStyleSheetWithImpl:(StyleSheetImpl *)impl;
65 @end
66
67 @interface DOMMediaList (WebCoreInternal)
68 + (DOMMediaList *)_mediaListWithImpl:(MediaListImpl *)impl;
69 @end
70
71 @interface DOMCSSRuleList (WebCoreInternal)
72 + (DOMCSSRuleList *)_ruleListWithImpl:(CSSRuleListImpl *)impl;
73 @end
74
75 @interface DOMCSSRule (WebCoreInternal)
76 + (DOMCSSRule *)_ruleWithImpl:(CSSRuleImpl *)impl;
77 @end
78
79 @interface DOMCSSValue (WebCoreInternal)
80 + (DOMCSSValue *)_valueWithImpl:(CSSValueImpl *)impl;
81 @end
82
83 @interface DOMRGBColor (WebCoreInternal)
84 + (DOMRGBColor *)_RGBColorWithRGB:(QRgb)value;
85 @end
86
87 @interface DOMRect (WebCoreInternal)
88 + (DOMRect *)_rectWithImpl:(RectImpl *)impl;
89 @end
90
91 @interface DOMCounter (WebCoreInternal)
92 + (DOMCounter *)_counterWithImpl:(CounterImpl *)impl;
93 @end
94
95 static inline int getPropertyID(NSString *string)
96 {
97     const char *s = [string UTF8String];
98     return DOM::getPropertyID(s, strlen(s));
99 }
100
101 //------------------------------------------------------------------------------------------
102 // DOMStyleSheet
103
104 @implementation DOMStyleSheet
105
106 - (void)dealloc
107 {
108     if (_internal) {
109         reinterpret_cast<StyleSheetImpl *>(_internal)->deref();
110     }
111     [super dealloc];
112 }
113
114 - (StyleSheetImpl *)_DOMStyleSheetImpl
115 {
116     return reinterpret_cast<StyleSheetImpl *>(_internal);
117 }
118
119 - (NSString *)type
120 {
121     return [self _DOMStyleSheetImpl]->type();
122 }
123
124 - (BOOL)disabled
125 {
126     return [self _DOMStyleSheetImpl]->disabled();
127 }
128
129 - (void)setDisabled:(BOOL)disabled
130 {
131     [self _DOMStyleSheetImpl]->setDisabled(disabled);
132 }
133
134 - (DOMNode *)ownerNode
135 {
136     return [DOMNode _nodeWithImpl:[self _DOMStyleSheetImpl]->ownerNode()];
137 }
138
139 - (DOMStyleSheet *)parentStyleSheet
140 {
141     return [DOMStyleSheet _DOMStyleSheetWithImpl:[self _DOMStyleSheetImpl]->parentStyleSheet()];
142 }
143
144 - (NSString *)href
145 {
146     return [self _DOMStyleSheetImpl]->href();
147 }
148
149 - (NSString *)title
150 {
151     return [self _DOMStyleSheetImpl]->title();
152 }
153
154 - (DOMMediaList *)media
155 {
156     return nil;
157 }
158
159 @end
160
161 @implementation DOMStyleSheet (WebCoreInternal)
162
163 - (id)_initWithDOMStyleSheetImpl:(StyleSheetImpl *)impl
164 {
165     [super _init];
166     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
167     impl->ref();
168     setDOMWrapperForImpl(self, impl);
169     return self;
170 }
171
172 + (DOMStyleSheet *)_DOMStyleSheetWithImpl:(StyleSheetImpl *)impl
173 {
174     if (!impl)
175         return nil;
176     
177     id cachedInstance;
178     cachedInstance = getDOMWrapperForImpl(impl);
179     if (cachedInstance)
180         return [[cachedInstance retain] autorelease];
181     
182     return [[[self alloc] _initWithDOMStyleSheetImpl:impl] autorelease];
183 }
184
185 @end
186
187 //------------------------------------------------------------------------------------------
188 // DOMStyleSheetList
189
190 @implementation DOMStyleSheetList
191
192 - (void)dealloc
193 {
194     if (_internal) {
195         reinterpret_cast<StyleSheetListImpl *>(_internal)->deref();
196     }
197     [super dealloc];
198 }
199
200 - (StyleSheetListImpl *)_styleSheetListImpl
201 {
202     return reinterpret_cast<StyleSheetListImpl *>(_internal);
203 }
204
205 - (unsigned long)length
206 {
207     return [self _styleSheetListImpl]->length();
208 }
209
210 - (DOMStyleSheet *)item:(unsigned long)index
211 {
212     return [DOMStyleSheet _DOMStyleSheetWithImpl:[self _styleSheetListImpl]->item(index)];
213 }
214
215 @end
216
217 @implementation DOMStyleSheetList (WebCoreInternal)
218
219 - (id)_initWithStyleSheetListImpl:(StyleSheetListImpl *)impl
220 {
221     [super _init];
222     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
223     impl->ref();
224     setDOMWrapperForImpl(self, impl);
225     return self;
226 }
227
228 + (DOMStyleSheetList *)_styleSheetListWithImpl:(StyleSheetListImpl *)impl
229 {
230     if (!impl)
231         return nil;
232     
233     id cachedInstance;
234     cachedInstance = getDOMWrapperForImpl(impl);
235     if (cachedInstance)
236         return [[cachedInstance retain] autorelease];
237     
238     return [[[self alloc] _initWithStyleSheetListImpl:impl] autorelease];
239 }
240
241 @end
242
243 //------------------------------------------------------------------------------------------
244 // DOMCSSStyleSheet
245
246 @implementation DOMCSSStyleSheet
247
248 - (CSSStyleSheetImpl *)_CSSStyleSheetImpl
249 {
250     return reinterpret_cast<CSSStyleSheetImpl *>(_internal);
251 }
252
253 - (DOMCSSRule *)ownerRule
254 {
255     return [DOMCSSRule _ruleWithImpl:[self _CSSStyleSheetImpl]->ownerRule()];
256 }
257
258 - (DOMCSSRuleList *)cssRules
259 {
260     return [DOMCSSRuleList _ruleListWithImpl:[self _CSSStyleSheetImpl]->cssRules().handle()];
261 }
262
263 - (unsigned long)insertRule:(NSString *)rule :(unsigned long)index
264 {
265     int exceptionCode;
266     unsigned long result = [self _CSSStyleSheetImpl]->insertRule(rule, index, exceptionCode);
267     raiseOnDOMError(exceptionCode);
268     return result;
269 }
270
271 - (void)deleteRule:(unsigned long)index
272 {
273     int exceptionCode;
274     [self _CSSStyleSheetImpl]->deleteRule(index, exceptionCode);
275     raiseOnDOMError(exceptionCode);
276 }
277
278 @end
279
280 @implementation DOMCSSStyleSheet (WebCoreInternal)
281
282 - (id)_initWithCSSStyleSheetImpl:(CSSStyleSheetImpl *)impl
283 {
284     [super _init];
285     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
286     impl->ref();
287     setDOMWrapperForImpl(self, impl);
288     return self;
289 }
290
291 + (DOMCSSStyleSheet *)_CSSStyleSheetWithImpl:(CSSStyleSheetImpl *)impl
292 {
293     if (!impl)
294         return nil;
295     
296     id cachedInstance;
297     cachedInstance = getDOMWrapperForImpl(impl);
298     if (cachedInstance)
299         return [[cachedInstance retain] autorelease];
300     
301     return [[[self alloc] _initWithCSSStyleSheetImpl:impl] autorelease];
302 }
303
304 @end
305
306 //------------------------------------------------------------------------------------------
307 // DOMMediaList
308
309 @implementation DOMMediaList
310
311 - (void)dealloc
312 {
313     if (_internal) {
314         reinterpret_cast<MediaListImpl *>(_internal)->deref();
315     }
316     [super dealloc];
317 }
318
319 - (MediaListImpl *)_mediaListImpl
320 {
321     return reinterpret_cast<MediaListImpl *>(_internal);
322 }
323
324 - (NSString *)mediaText
325 {
326     return [self _mediaListImpl]->mediaText();
327 }
328
329 - (void)setMediaText:(NSString *)mediaText
330 {
331     [self _mediaListImpl]->setMediaText(mediaText);
332 }
333
334 - (unsigned long)length
335 {
336     return [self _mediaListImpl]->length();
337 }
338
339 - (NSString *)item:(unsigned long)index
340 {
341     return [self _mediaListImpl]->item(index);
342 }
343
344 - (void)deleteMedium:(NSString *)oldMedium
345 {
346     [self _mediaListImpl]->deleteMedium(oldMedium);
347 }
348
349 - (void)appendMedium:(NSString *)newMedium
350 {
351     [self _mediaListImpl]->appendMedium(newMedium);
352 }
353
354 @end
355
356 @implementation DOMMediaList (WebCoreInternal)
357
358 - (id)_initWithMediaListImpl:(MediaListImpl *)impl
359 {
360     [super _init];
361     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
362     impl->ref();
363     setDOMWrapperForImpl(self, impl);
364     return self;
365 }
366
367 + (DOMMediaList *)_mediaListWithImpl:(MediaListImpl *)impl
368 {
369     if (!impl)
370         return nil;
371     
372     id cachedInstance;
373     cachedInstance = getDOMWrapperForImpl(impl);
374     if (cachedInstance)
375         return [[cachedInstance retain] autorelease];
376     
377     return [[[self alloc] _initWithMediaListImpl:impl] autorelease];
378 }
379
380 @end
381
382 //------------------------------------------------------------------------------------------
383 // DOMCSSRuleList
384
385 @implementation DOMCSSRuleList
386
387 - (void)dealloc
388 {
389     if (_internal) {
390         reinterpret_cast<CSSRuleListImpl *>(_internal)->deref();
391     }
392     [super dealloc];
393 }
394
395 - (CSSRuleListImpl *)_ruleListImpl
396 {
397     return reinterpret_cast<CSSRuleListImpl *>(_internal);
398 }
399
400 - (unsigned long)length
401 {
402     return [self _ruleListImpl]->length();
403 }
404
405 - (DOMCSSRule *)item:(unsigned long)index
406 {
407     return [DOMCSSRule _ruleWithImpl:[self _ruleListImpl]->item(index)];
408 }
409
410 @end
411
412 @implementation DOMCSSRuleList (WebCoreInternal)
413
414 - (id)_initWithRuleListImpl:(CSSRuleListImpl *)impl
415 {
416     [super _init];
417     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
418     impl->ref();
419     setDOMWrapperForImpl(self, impl);
420     return self;
421 }
422
423 + (DOMCSSRuleList *)_ruleListWithImpl:(CSSRuleListImpl *)impl
424 {
425     if (!impl)
426         return nil;
427     
428     id cachedInstance;
429     cachedInstance = getDOMWrapperForImpl(impl);
430     if (cachedInstance)
431         return [[cachedInstance retain] autorelease];
432     
433     return [[[self alloc] _initWithRuleListImpl:impl] autorelease];
434 }
435
436 @end
437
438 //------------------------------------------------------------------------------------------
439 // DOMCSSRule
440
441 @implementation DOMCSSRule
442
443 - (void)dealloc
444 {
445     if (_internal) {
446         reinterpret_cast<CSSRuleImpl *>(_internal)->deref();
447     }
448     [super dealloc];
449 }
450
451 - (CSSRuleImpl *)_ruleImpl
452 {
453     return reinterpret_cast<CSSRuleImpl *>(_internal);
454 }
455
456 - (unsigned short)type
457 {
458     return [self _ruleImpl]->type();
459 }
460
461 - (NSString *)cssText
462 {
463     return [self _ruleImpl]->cssText();
464 }
465
466 - (void)setCssText:(NSString *)cssText
467 {
468     [self _ruleImpl]->setCssText(cssText);
469 }
470
471 - (DOMCSSStyleSheet *)parentStyleSheet
472 {
473     return [DOMCSSStyleSheet _CSSStyleSheetWithImpl:[self _ruleImpl]->parentStyleSheet()];
474 }
475
476 - (DOMCSSRule *)parentRule
477 {
478     return [DOMCSSRule _ruleWithImpl:[self _ruleImpl]->parentRule()];
479 }
480
481 @end
482
483 @implementation DOMCSSRule (WebCoreInternal)
484
485 - (id)_initWithRuleImpl:(CSSRuleImpl *)impl
486 {
487     [super _init];
488     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
489     impl->ref();
490     setDOMWrapperForImpl(self, impl);
491     return self;
492 }
493
494 + (DOMCSSRule *)_ruleWithImpl:(CSSRuleImpl *)impl
495 {
496     if (!impl)
497         return nil;
498     
499     id cachedInstance;
500     cachedInstance = getDOMWrapperForImpl(impl);
501     if (cachedInstance)
502         return [[cachedInstance retain] autorelease];
503
504     Class wrapperClass = nil;
505     switch (impl->type()) {
506         case DOM_UNKNOWN_RULE:
507             wrapperClass = [DOMCSSRule class];
508             break;
509         case DOM_STYLE_RULE:
510             wrapperClass = [DOMCSSStyleRule class];
511             break;
512         case DOM_CHARSET_RULE:
513             wrapperClass = [DOMCSSCharsetRule class];
514             break;
515         case DOM_IMPORT_RULE:
516             wrapperClass = [DOMCSSImportRule class];
517             break;
518         case DOM_MEDIA_RULE:
519             wrapperClass = [DOMCSSMediaRule class];
520             break;
521         case DOM_FONT_FACE_RULE:
522             wrapperClass = [DOMCSSFontFaceRule class];
523             break;
524         case DOM_PAGE_RULE:
525             wrapperClass = [DOMCSSPageRule class];
526             break;
527     }
528     return [[[wrapperClass alloc] _initWithRuleImpl:impl] autorelease];
529 }
530
531 @end
532
533 //------------------------------------------------------------------------------------------
534 // DOMCSSStyleRule
535
536 @implementation DOMCSSStyleRule
537
538 - (CSSStyleRuleImpl *)_styleRuleImpl
539 {
540     return reinterpret_cast<CSSStyleRuleImpl *>(_internal);
541 }
542
543 - (NSString *)selectorText
544 {
545     return [self _styleRuleImpl]->selectorText();
546 }
547
548 - (void)setSelectorText:(NSString *)selectorText
549 {
550     [self _styleRuleImpl]->setSelectorText(selectorText);
551 }
552
553 - (DOMCSSStyleDeclaration *)style
554 {
555     return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:[self _styleRuleImpl]->style()];
556 }
557
558 @end
559
560 //------------------------------------------------------------------------------------------
561 // DOMCSSMediaRule
562
563 @implementation DOMCSSMediaRule
564
565 - (CSSMediaRuleImpl *)_mediaRuleImpl
566 {
567     return reinterpret_cast<CSSMediaRuleImpl *>(_internal);
568 }
569
570 - (DOMMediaList *)media
571 {
572     return [DOMMediaList _mediaListWithImpl:[self _mediaRuleImpl]->media()];
573 }
574
575 - (DOMCSSRuleList *)cssRules
576 {
577     return [DOMCSSRuleList _ruleListWithImpl:[self _mediaRuleImpl]->cssRules()];
578 }
579
580 - (unsigned long)insertRule:(NSString *)rule :(unsigned long)index
581 {
582     return [self _mediaRuleImpl]->insertRule(rule, index);
583 }
584
585 - (void)deleteRule:(unsigned long)index
586 {
587     [self _mediaRuleImpl]->deleteRule(index);
588 }
589
590 @end
591
592 //------------------------------------------------------------------------------------------
593 // DOMCSSFontFaceRule
594
595 @implementation DOMCSSFontFaceRule
596
597 - (CSSFontFaceRuleImpl *)_fontFaceRuleImpl
598 {
599     return reinterpret_cast<CSSFontFaceRuleImpl *>(_internal);
600 }
601
602 - (DOMCSSStyleDeclaration *)style
603 {
604     return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:[self _fontFaceRuleImpl]->style()];
605 }
606
607 @end
608
609 //------------------------------------------------------------------------------------------
610 // DOMCSSPageRule
611
612 @implementation DOMCSSPageRule
613
614 - (CSSPageRuleImpl *)_pageRuleImpl
615 {
616     return reinterpret_cast<CSSPageRuleImpl *>(_internal);
617 }
618
619 - (NSString *)selectorText
620 {
621     return [self _pageRuleImpl]->selectorText();
622 }
623
624 - (void)setSelectorText:(NSString *)selectorText
625 {
626     [self _pageRuleImpl]->setSelectorText(selectorText);
627 }
628
629 - (DOMCSSStyleDeclaration *)style
630 {
631     return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:[self _pageRuleImpl]->style()];
632 }
633
634 @end
635
636 //------------------------------------------------------------------------------------------
637 // DOMCSSImportRule
638
639 @implementation DOMCSSImportRule
640
641 - (CSSImportRuleImpl *)_importRuleImpl
642 {
643     return reinterpret_cast<CSSImportRuleImpl *>(_internal);
644 }
645
646 - (DOMMediaList *)media
647 {
648     return [DOMMediaList _mediaListWithImpl:[self _importRuleImpl]->media()];
649 }
650
651 - (NSString *)href
652 {
653     return [self _importRuleImpl]->href();
654 }
655
656 - (DOMCSSStyleSheet *)styleSheet
657 {
658     return [DOMCSSStyleSheet _CSSStyleSheetWithImpl:[self _importRuleImpl]->styleSheet()];
659 }
660
661 @end
662
663 //------------------------------------------------------------------------------------------
664 // DOMCSSCharsetRule
665
666 @implementation DOMCSSCharsetRule
667
668 - (CSSCharsetRuleImpl *)_importRuleImpl
669 {
670     return reinterpret_cast<CSSCharsetRuleImpl *>(_internal);
671 }
672
673 - (NSString *)encoding
674 {
675     return [self _importRuleImpl]->encoding();
676 }
677
678 @end
679
680 //------------------------------------------------------------------------------------------
681 // DOMCSSStyleDeclaration
682
683 @implementation DOMCSSStyleDeclaration
684
685 - (void)dealloc
686 {
687     if (_internal) {
688         reinterpret_cast<CSSStyleDeclarationImpl *>(_internal)->deref();
689     }
690     [super dealloc];
691 }
692
693 - (CSSStyleDeclarationImpl *)_styleDeclarationImpl
694 {
695     return reinterpret_cast<CSSStyleDeclarationImpl *>(_internal);
696 }
697
698 - (NSString *)cssText
699 {
700     return [self _styleDeclarationImpl]->cssText();
701 }
702
703 - (void)setCssText:(NSString *)cssText
704 {
705     [self _styleDeclarationImpl]->setCssText(cssText);
706 }
707
708 - (NSString *)getPropertyValue:(NSString *)propertyName
709 {
710     int propid = getPropertyID(propertyName);
711     if (!propid) 
712         return nil;
713     return [self _styleDeclarationImpl]->getPropertyValue(propid);
714 }
715
716 - (DOMCSSValue *)getPropertyCSSValue:(NSString *)propertyName
717 {
718     int propid = getPropertyID(propertyName);
719     if (!propid) 
720         return nil;
721     return [DOMCSSValue _valueWithImpl:[self _styleDeclarationImpl]->getPropertyCSSValue(propid)];
722 }
723
724 - (NSString *)removeProperty:(NSString *)propertyName
725 {
726     int propid = getPropertyID(propertyName);
727     if (!propid) 
728         return nil;
729     return [self _styleDeclarationImpl]->removeProperty(propid);
730 }
731
732 - (NSString *)getPropertyPriority:(NSString *)propertyName
733 {
734     int propid = getPropertyID(propertyName);
735     if (!propid) 
736         return nil;
737     if ([self _styleDeclarationImpl]->getPropertyPriority(propid))
738         return @"important";
739     else
740         return @"";
741 }
742
743 - (void)setProperty:(NSString *)propertyName :(NSString *)value :(NSString *)priority
744 {
745     int propid = getPropertyID(propertyName);
746     if (!propid) 
747         return;
748     [self _styleDeclarationImpl]->setProperty(propid, value, priority);
749 }
750
751 - (unsigned long)length
752 {
753     return [self _styleDeclarationImpl]->length();
754 }
755
756 - (NSString *)item:(unsigned long)index
757 {
758     return [self _styleDeclarationImpl]->item(index);
759 }
760
761 - (DOMCSSRule *)parentRule
762 {
763     return [DOMCSSRule _ruleWithImpl:[self _styleDeclarationImpl]->parentRule()];
764 }
765
766 @end
767
768 @implementation DOMCSSStyleDeclaration (WebCoreInternal)
769
770 - (id)_initWithStyleDeclarationImpl:(CSSStyleDeclarationImpl *)impl
771 {
772     [super _init];
773     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
774     impl->ref();
775     setDOMWrapperForImpl(self, impl);
776     return self;
777 }
778
779 + (DOMCSSStyleDeclaration *)_styleDeclarationWithImpl:(CSSStyleDeclarationImpl *)impl
780 {
781     if (!impl)
782         return nil;
783     
784     id cachedInstance;
785     cachedInstance = getDOMWrapperForImpl(impl);
786     if (cachedInstance)
787         return [[cachedInstance retain] autorelease];
788     
789     return [[[self alloc] _initWithStyleDeclarationImpl:impl] autorelease];
790 }
791
792 @end
793
794 //------------------------------------------------------------------------------------------
795 // DOMCSSValue
796
797 @implementation DOMCSSValue
798
799 - (void)dealloc
800 {
801     if (_internal) {
802         reinterpret_cast<CSSValueImpl *>(_internal)->deref();
803     }
804     [super dealloc];
805 }
806
807 - (CSSValueImpl *)_valueImpl
808 {
809     return reinterpret_cast<CSSValueImpl *>(_internal);
810 }
811
812 - (NSString *)cssText
813 {
814     return [self _valueImpl]->cssText();
815 }
816
817 - (void)setCssText:(NSString *)cssText
818 {
819     ERROR("unimplemented");
820 }
821
822 - (unsigned short)cssValueType
823 {
824     return [self _valueImpl]->cssValueType();
825 }
826
827 @end
828
829 @implementation DOMCSSValue (WebCoreInternal)
830
831 - (id)_initWithValueImpl:(CSSValueImpl *)impl
832 {
833     [super _init];
834     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
835     impl->ref();
836     setDOMWrapperForImpl(self, impl);
837     return self;
838 }
839
840 + (DOMCSSValue *)_valueWithImpl:(CSSValueImpl *)impl
841 {
842     if (!impl)
843         return nil;
844     
845     id cachedInstance;
846     cachedInstance = getDOMWrapperForImpl(impl);
847     if (cachedInstance)
848         return [[cachedInstance retain] autorelease];
849     
850     Class wrapperClass = nil;
851     switch (impl->cssValueType()) {
852         case DOM_CSS_INHERIT:
853             wrapperClass = [DOMCSSValue class];
854             break;
855         case DOM_CSS_PRIMITIVE_VALUE:
856             wrapperClass = [DOMCSSPrimitiveValue class];
857             break;
858         case DOM_CSS_VALUE_LIST:
859             wrapperClass = [DOMCSSValueList class];
860             break;
861         case DOM_CSS_CUSTOM:
862             wrapperClass = [DOMCSSValue class];
863             break;
864     }
865     return [[[wrapperClass alloc] _initWithValueImpl:impl] autorelease];
866 }
867
868 @end
869
870 //------------------------------------------------------------------------------------------
871 // DOMCSSPrimitiveValue
872
873 @implementation DOMCSSPrimitiveValue
874
875 - (CSSPrimitiveValueImpl *)_primitiveValueImpl
876 {
877     return static_cast<CSSPrimitiveValueImpl *>(reinterpret_cast<CSSValueImpl *>(_internal));
878 }
879
880 - (unsigned short)primitiveType
881 {
882     return [self _primitiveValueImpl]->primitiveType();
883 }
884
885 - (void)setFloatValue:(unsigned short)unitType :(float)floatValue
886 {
887     int exceptionCode;
888     [self _primitiveValueImpl]->setFloatValue(unitType, floatValue, exceptionCode);
889     raiseOnDOMError(exceptionCode);
890 }
891
892 - (float)getFloatValue:(unsigned short)unitType
893 {
894     return [self _primitiveValueImpl]->getFloatValue(unitType);
895 }
896
897 - (void)setStringValue:(unsigned short)stringType :(NSString *)stringValue
898 {
899     int exceptionCode;
900     DOMString string(stringValue);
901     [self _primitiveValueImpl]->setStringValue(stringType, string, exceptionCode);
902     raiseOnDOMError(exceptionCode);
903 }
904
905 - (NSString *)getStringValue
906 {
907     return DOMString([self _primitiveValueImpl]->getStringValue());
908 }
909
910 - (DOMCounter *)getCounterValue
911 {
912     return [DOMCounter _counterWithImpl:[self _primitiveValueImpl]->getCounterValue()];
913 }
914
915 - (DOMRect *)getRectValue
916 {
917     return [DOMRect _rectWithImpl:[self _primitiveValueImpl]->getRectValue()];
918 }
919
920 - (DOMRGBColor *)getRGBColorValue
921 {
922     return [DOMRGBColor _RGBColorWithRGB:[self _primitiveValueImpl]->getRGBColorValue()];
923 }
924
925 @end
926
927 //------------------------------------------------------------------------------------------
928 // DOMCSSValueList
929
930 @implementation DOMCSSValueList
931
932 - (CSSValueListImpl *)_valueListImpl
933 {
934     return static_cast<CSSValueListImpl *>(reinterpret_cast<CSSValueImpl *>(_internal));
935 }
936
937 - (unsigned long)length
938 {
939     return [self _valueListImpl]->length();
940 }
941
942 - (DOMCSSValue *)item:(unsigned long)index
943 {
944     return [DOMCSSValue _valueWithImpl:[self _valueListImpl]->item(index)];
945 }
946
947 @end
948
949 //------------------------------------------------------------------------------------------
950 // DOMRGBColor
951
952 static CFMutableDictionaryRef wrapperCache = NULL;
953
954 id getWrapperForRGB(QRgb value)
955 {
956     if (!wrapperCache)
957         return nil;
958     return (id)CFDictionaryGetValue(wrapperCache, reinterpret_cast<const void *>(value));
959 }
960
961 void setWrapperForRGB(id wrapper, QRgb value)
962 {
963     if (!wrapperCache) {
964         // No need to retain/free either impl key, or id value.  Items will be removed
965         // from the cache in dealloc methods.
966         wrapperCache = CFDictionaryCreateMutable(NULL, 0, NULL, NULL);
967     }
968     CFDictionarySetValue(wrapperCache, reinterpret_cast<const void *>(value), wrapper);
969 }
970
971 void removeWrapperForRGB(QRgb value)
972 {
973     if (!wrapperCache)
974         return;
975     CFDictionaryRemoveValue(wrapperCache, reinterpret_cast<const void *>(value));
976 }
977
978 @implementation DOMRGBColor
979
980 - (void)dealloc
981 {
982     removeWrapperForRGB(reinterpret_cast<QRgb>(_internal));
983     [super dealloc];
984 }
985
986 - (DOMCSSPrimitiveValue *)red
987 {
988     QRgb rgb = reinterpret_cast<QRgb>(_internal);
989     int value = (rgb >> 16) & 0xFF;
990     return [DOMCSSPrimitiveValue _valueWithImpl:new CSSPrimitiveValueImpl(value, DOM::CSSPrimitiveValue::CSS_NUMBER)];
991 }
992
993 - (DOMCSSPrimitiveValue *)green
994 {
995     QRgb rgb = reinterpret_cast<QRgb>(_internal);
996     int value = (rgb >> 8) & 0xFF;
997     return [DOMCSSPrimitiveValue _valueWithImpl:new CSSPrimitiveValueImpl(value, DOM::CSSPrimitiveValue::CSS_NUMBER)];
998 }
999
1000 - (DOMCSSPrimitiveValue *)blue
1001 {
1002     QRgb rgb = reinterpret_cast<QRgb>(_internal);
1003     int value = rgb & 0xFF;
1004     return [DOMCSSPrimitiveValue _valueWithImpl:new CSSPrimitiveValueImpl(value, DOM::CSSPrimitiveValue::CSS_NUMBER)];
1005 }
1006
1007 - (id)copyWithZone:(NSZone *)zone
1008 {
1009     return [self retain];
1010 }
1011
1012 @end
1013
1014 @implementation DOMRGBColor (WebCoreInternal)
1015
1016 - (id)_initWithRGB:(QRgb)value
1017 {
1018     [super _init];
1019     _internal = reinterpret_cast<DOMObjectInternal *>(value);
1020     setWrapperForRGB(self, value);
1021     return self;
1022 }
1023
1024 + (DOMRGBColor *)_RGBColorWithRGB:(QRgb)value
1025 {
1026     id cachedInstance;
1027     cachedInstance = getWrapperForRGB(value);
1028     if (cachedInstance)
1029         return [[cachedInstance retain] autorelease];
1030     
1031     return [[[self alloc] _initWithRGB:value] autorelease];
1032 }
1033
1034 @end
1035
1036 //------------------------------------------------------------------------------------------
1037 // DOMRect
1038
1039 @implementation DOMRect
1040
1041 - (void)dealloc
1042 {
1043     if (_internal) {
1044         reinterpret_cast<RectImpl *>(_internal)->deref();
1045     }
1046     [super dealloc];
1047 }
1048
1049 - (RectImpl *)_rectImpl
1050 {
1051     return reinterpret_cast<RectImpl *>(_internal);
1052 }
1053
1054 - (DOMCSSPrimitiveValue *)top
1055 {
1056     return [DOMCSSPrimitiveValue _valueWithImpl:[self _rectImpl]->top()];
1057 }
1058
1059 - (DOMCSSPrimitiveValue *)right
1060 {
1061     return [DOMCSSPrimitiveValue _valueWithImpl:[self _rectImpl]->right()];
1062 }
1063
1064 - (DOMCSSPrimitiveValue *)bottom
1065 {
1066     return [DOMCSSPrimitiveValue _valueWithImpl:[self _rectImpl]->bottom()];
1067 }
1068
1069 - (DOMCSSPrimitiveValue *)left
1070 {
1071     return [DOMCSSPrimitiveValue _valueWithImpl:[self _rectImpl]->left()];
1072 }
1073
1074 - (id)copyWithZone:(NSZone *)zone
1075 {
1076     return [self retain];
1077 }
1078
1079 @end
1080
1081 @implementation DOMRect (WebCoreInternal)
1082
1083 - (id)_initWithRectImpl:(RectImpl *)impl
1084 {
1085     [super _init];
1086     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
1087     impl->ref();
1088     setDOMWrapperForImpl(self, impl);
1089     return self;
1090 }
1091
1092 + (DOMRect *)_rectWithImpl:(RectImpl *)impl
1093 {
1094     if (!impl)
1095         return nil;
1096     
1097     id cachedInstance;
1098     cachedInstance = getDOMWrapperForImpl(impl);
1099     if (cachedInstance)
1100         return [[cachedInstance retain] autorelease];
1101     
1102     return [[[self alloc] _initWithRectImpl:impl] autorelease];
1103 }
1104
1105 @end
1106
1107 //------------------------------------------------------------------------------------------
1108 // DOMCounter
1109
1110 @implementation DOMCounter
1111
1112 - (void)dealloc
1113 {
1114     if (_internal) {
1115         reinterpret_cast<CounterImpl *>(_internal)->deref();
1116     }
1117     [super dealloc];
1118 }
1119
1120 - (CounterImpl *)_counterImpl
1121 {
1122     return reinterpret_cast<CounterImpl *>(_internal);
1123 }
1124
1125 - (NSString *)identifier
1126 {
1127     return [self _counterImpl]->identifier();
1128 }
1129
1130 - (NSString *)listStyle
1131 {
1132     return [self _counterImpl]->listStyle();
1133 }
1134
1135 - (NSString *)separator
1136 {
1137     return [self _counterImpl]->separator();
1138 }
1139
1140 - (id)copyWithZone:(NSZone *)zone
1141 {
1142     return [self retain];
1143 }
1144
1145 @end
1146
1147 @implementation DOMCounter (WebCoreInternal)
1148
1149 - (id)_initWithCounterImpl:(CounterImpl *)impl
1150 {
1151     [super _init];
1152     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
1153     impl->ref();
1154     setDOMWrapperForImpl(self, impl);
1155     return self;
1156 }
1157
1158 + (DOMCounter *)_counterWithImpl:(CounterImpl *)impl
1159 {
1160     if (!impl)
1161         return nil;
1162     
1163     id cachedInstance;
1164     cachedInstance = getDOMWrapperForImpl(impl);
1165     if (cachedInstance)
1166         return [[cachedInstance retain] autorelease];
1167     
1168     return [[[self alloc] _initWithCounterImpl:impl] autorelease];
1169 }
1170
1171 @end
1172
1173 //------------------------------------------------------------------------------------------