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