00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "kjs_css.h"
00024 #include "kjs_css.lut.h"
00025
00026 #include <dom/html_head.h>
00027
00028 #include <css/css_base.h>
00029 #include "kjs_dom.h"
00030
00031 using namespace KJS;
00032 #include <kdebug.h>
00033
00034 static QString cssPropertyName( const Identifier &p, bool& hadPixelPrefix )
00035 {
00036 QString prop = p.qstring();
00037 int i = prop.length();
00038 while ( --i ) {
00039 char c = prop[i].latin1();
00040 if ( c >= 'A' && c <= 'Z' )
00041 prop.insert( i, '-' );
00042 }
00043
00044 prop = prop.lower();
00045 hadPixelPrefix = false;
00046
00047 if (prop.startsWith("css-")) {
00048 prop = prop.mid(4);
00049 } else if (prop.startsWith("pixel-")) {
00050 prop = prop.mid(6);
00051 hadPixelPrefix = true;
00052 } else if (prop.startsWith("pos-")) {
00053 prop = prop.mid(4);
00054 hadPixelPrefix = true;
00055 }
00056
00057 return prop;
00058 }
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079 DEFINE_PROTOTYPE("DOMCSSStyleDeclaration", DOMCSSStyleDeclarationProto)
00080 IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleDeclarationProtoFunc)
00081 IMPLEMENT_PROTOTYPE(DOMCSSStyleDeclarationProto, DOMCSSStyleDeclarationProtoFunc)
00082
00083 const ClassInfo DOMCSSStyleDeclaration::info = { "CSSStyleDeclaration", 0, &DOMCSSStyleDeclarationTable, 0 };
00084
00085 DOMCSSStyleDeclaration::DOMCSSStyleDeclaration(ExecState *exec, const DOM::CSSStyleDeclaration& s)
00086 : DOMObject(DOMCSSStyleDeclarationProto::self(exec)), styleDecl(s)
00087 { }
00088
00089 DOMCSSStyleDeclaration::~DOMCSSStyleDeclaration()
00090 {
00091 ScriptInterpreter::forgetDOMObject(styleDecl.handle());
00092 }
00093
00094 bool DOMCSSStyleDeclaration::hasProperty(ExecState *exec, const Identifier &p) const
00095 {
00096 bool hadPixelPrefix;
00097 QString cssprop = cssPropertyName(p, hadPixelPrefix);
00098 if (DOM::getPropertyID(cssprop.latin1(), cssprop.length()))
00099 return true;
00100
00101 return ObjectImp::hasProperty(exec, p);
00102 }
00103
00104 Value DOMCSSStyleDeclaration::tryGet(ExecState *exec, const Identifier &propertyName) const
00105 {
00106 #ifdef KJS_VERBOSE
00107 kdDebug(6070) << "DOMCSSStyleDeclaration::tryGet " << propertyName.qstring() << endl;
00108 #endif
00109 const HashEntry* entry = Lookup::findEntry(&DOMCSSStyleDeclarationTable, propertyName);
00110 if (entry)
00111 switch (entry->value) {
00112 case CssText:
00113 return String(styleDecl.cssText());
00114 case Length:
00115 return Number(styleDecl.length());
00116 case ParentRule:
00117 return getDOMCSSRule(exec,styleDecl.parentRule());
00118 default:
00119 break;
00120 }
00121
00122
00123 Object proto = Object::dynamicCast(prototype());
00124 if (proto.isValid() && proto.hasProperty(exec,propertyName))
00125 return proto.get(exec,propertyName);
00126
00127 bool ok;
00128 long unsigned int u = propertyName.toULong(&ok);
00129 if (ok)
00130 return String(DOM::CSSStyleDeclaration(styleDecl).item(u));
00131
00132
00133
00134
00135
00136 bool asNumber;
00137 QString p = cssPropertyName(propertyName, asNumber);
00138
00139 #ifdef KJS_VERBOSE
00140 kdDebug(6070) << "DOMCSSStyleDeclaration: converting to css property name: " << p << ( asNumber ? "px" : "" ) << endl;
00141 #endif
00142
00143 if (asNumber) {
00144 DOM::CSSValue v = styleDecl.getPropertyCSSValue(p);
00145 if ( !v.isNull() && v.cssValueType() == DOM::CSSValue::CSS_PRIMITIVE_VALUE)
00146 return Number(static_cast<DOM::CSSPrimitiveValue>(v).getFloatValue(DOM::CSSPrimitiveValue::CSS_PX));
00147 }
00148
00149 DOM::DOMString str = const_cast<DOM::CSSStyleDeclaration &>( styleDecl ).getPropertyValue(p);
00150 if (!str.isNull())
00151 return String(str);
00152
00153
00154 if (DOM::getPropertyID(p.latin1(), p.length()))
00155 return String(DOM::DOMString(""));
00156
00157 return DOMObject::tryGet(exec, propertyName);
00158 }
00159
00160
00161 void DOMCSSStyleDeclaration::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr )
00162 {
00163 #ifdef KJS_VERBOSE
00164 kdDebug(6070) << "DOMCSSStyleDeclaration::tryPut " << propertyName.qstring() << endl;
00165 #endif
00166 if (propertyName == "cssText") {
00167 styleDecl.setCssText(value.toString(exec).string());
00168 }
00169 else {
00170 bool pxSuffix;
00171 QString prop = cssPropertyName(propertyName, pxSuffix);
00172 QString propvalue = value.toString(exec).qstring();
00173
00174 if (pxSuffix)
00175 propvalue += "px";
00176 #ifdef KJS_VERBOSE
00177 kdDebug(6070) << "DOMCSSStyleDeclaration: prop=" << prop << " propvalue=" << propvalue << endl;
00178 #endif
00179
00180 if (DOM::getPropertyID(prop.latin1(), prop.length())) {
00181 if (propvalue.isEmpty())
00182 styleDecl.removeProperty(prop);
00183 else
00184 styleDecl.setProperty(prop,DOM::DOMString(propvalue),"");
00185 }
00186 else
00187
00188 DOMObject::tryPut( exec, propertyName, value, attr );
00189 }
00190 }
00191
00192 Value DOMCSSStyleDeclarationProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00193 {
00194 KJS_CHECK_THIS( KJS::DOMCSSStyleDeclaration, thisObj );
00195 DOM::CSSStyleDeclaration styleDecl = static_cast<DOMCSSStyleDeclaration *>(thisObj.imp())->toStyleDecl();
00196 String str = args[0].toString(exec);
00197 DOM::DOMString s = str.value().string();
00198
00199 switch (id) {
00200 case DOMCSSStyleDeclaration::GetPropertyValue:
00201 return String(styleDecl.getPropertyValue(s));
00202 case DOMCSSStyleDeclaration::GetPropertyCSSValue:
00203 return getDOMCSSValue(exec,styleDecl.getPropertyCSSValue(s));
00204 case DOMCSSStyleDeclaration::RemoveProperty:
00205 return String(styleDecl.removeProperty(s));
00206 case DOMCSSStyleDeclaration::GetPropertyPriority:
00207 return String(styleDecl.getPropertyPriority(s));
00208 case DOMCSSStyleDeclaration::SetProperty:
00209 styleDecl.setProperty(args[0].toString(exec).string(),
00210 args[1].toString(exec).string(),
00211 args[2].toString(exec).string());
00212 return Undefined();
00213 case DOMCSSStyleDeclaration::Item:
00214 return String(styleDecl.item(args[0].toInteger(exec)));
00215 default:
00216 return Undefined();
00217 }
00218 }
00219
00220 Value KJS::getDOMCSSStyleDeclaration(ExecState *exec, const DOM::CSSStyleDeclaration& s)
00221 {
00222 return cacheDOMObject<DOM::CSSStyleDeclaration, KJS::DOMCSSStyleDeclaration>(exec, s);
00223 }
00224
00225
00226
00227 const ClassInfo DOMStyleSheet::info = { "StyleSheet", 0, &DOMStyleSheetTable, 0 };
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240 DOMStyleSheet::DOMStyleSheet(ExecState* exec, const DOM::StyleSheet& ss)
00241 : DOMObject(exec->interpreter()->builtinObjectPrototype()), styleSheet(ss)
00242 {
00243 }
00244
00245 DOMStyleSheet::~DOMStyleSheet()
00246 {
00247 ScriptInterpreter::forgetDOMObject(styleSheet.handle());
00248 }
00249
00250 Value DOMStyleSheet::tryGet(ExecState *exec, const Identifier &propertyName) const
00251 {
00252 return DOMObjectLookupGetValue<DOMStyleSheet,DOMObject>(exec,propertyName,&DOMStyleSheetTable,this);
00253 }
00254
00255 Value DOMStyleSheet::getValueProperty(ExecState *exec, int token) const
00256 {
00257 switch (token) {
00258 case Type:
00259 return String(styleSheet.type());
00260 case Disabled:
00261 return Boolean(styleSheet.disabled());
00262 case OwnerNode:
00263 return getDOMNode(exec,styleSheet.ownerNode());
00264 case ParentStyleSheet:
00265 return getDOMStyleSheet(exec,styleSheet.parentStyleSheet());
00266 case Href:
00267 return String(styleSheet.href());
00268 case Title:
00269 return String(styleSheet.title());
00270 case Media:
00271 return getDOMMediaList(exec, styleSheet.media());
00272 }
00273 return Value();
00274 }
00275
00276 void DOMStyleSheet::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00277 {
00278 if (propertyName == "disabled") {
00279 styleSheet.setDisabled(value.toBoolean(exec));
00280 }
00281 else
00282 DOMObject::tryPut(exec, propertyName, value, attr);
00283 }
00284
00285 Value KJS::getDOMStyleSheet(ExecState *exec, const DOM::StyleSheet& ss)
00286 {
00287 DOMObject *ret;
00288 if (ss.isNull())
00289 return Null();
00290 ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00291 if ((ret = interp->getDOMObject(ss.handle())))
00292 return Value(ret);
00293 else {
00294 if (ss.isCSSStyleSheet()) {
00295 DOM::CSSStyleSheet cs;
00296 cs = ss;
00297 ret = new DOMCSSStyleSheet(exec,cs);
00298 }
00299 else
00300 ret = new DOMStyleSheet(exec,ss);
00301 interp->putDOMObject(ss.handle(),ret);
00302 return Value(ret);
00303 }
00304 }
00305
00306
00307
00308 const ClassInfo DOMStyleSheetList::info = { "StyleSheetList", 0, &DOMStyleSheetListTable, 0 };
00309
00310
00311
00312
00313
00314
00315
00316 IMPLEMENT_PROTOFUNC_DOM(DOMStyleSheetListFunc)
00317
00318 DOMStyleSheetList::DOMStyleSheetList(ExecState *exec, const DOM::StyleSheetList& ssl, const DOM::Document& doc)
00319 : DOMObject(exec->interpreter()->builtinObjectPrototype()), styleSheetList(ssl), m_doc(doc)
00320 {
00321 }
00322
00323 DOMStyleSheetList::~DOMStyleSheetList()
00324 {
00325 ScriptInterpreter::forgetDOMObject(styleSheetList.handle());
00326 }
00327
00328 Value DOMStyleSheetList::tryGet(ExecState *exec, const Identifier &p) const
00329 {
00330 #ifdef KJS_VERBOSE
00331 kdDebug(6070) << "DOMStyleSheetList::tryGet " << p.qstring() << endl;
00332 #endif
00333 if (p == lengthPropertyName)
00334 return Number(styleSheetList.length());
00335 else if (p == "item")
00336 return lookupOrCreateFunction<DOMStyleSheetListFunc>(exec,p,this,DOMStyleSheetList::Item,1,DontDelete|Function);
00337
00338
00339 bool ok;
00340 long unsigned int u = p.toULong(&ok);
00341 if (ok)
00342 return getDOMStyleSheet(exec, DOM::StyleSheetList(styleSheetList).item(u));
00343
00344
00345
00346 #if 0
00347
00348
00349
00350
00351 DOM::NameNodeListImpl namedList( m_doc.documentElement().handle(), p.string() );
00352 int len = namedList.length();
00353 if ( len ) {
00354 QValueList<DOM::Node> styleSheets;
00355 for ( int i = 0 ; i < len ; ++i ) {
00356 DOM::HTMLStyleElement elem = DOM::Node(namedList.item(i));
00357 if (!elem.isNull())
00358 styleSheets.append(elem.sheet());
00359 }
00360 if ( styleSheets.count() == 1 )
00361 return getDOMStyleSheet(exec, styleSheets[0]);
00362 else if ( styleSheets.count() > 1 ) {
00363 return new DOMNamedItemsCollection(exec,styleSheets);
00364 }
00365 }
00366 #endif
00367
00368
00369
00370 DOM::DOMString pstr = p.string();
00371 DOM::HTMLStyleElement styleElem = m_doc.getElementById( pstr );
00372 if (!styleElem.isNull())
00373 return getDOMStyleSheet(exec, styleElem.sheet());
00374
00375 return DOMObject::tryGet(exec, p);
00376 }
00377
00378 Value KJS::DOMStyleSheetList::call(ExecState *exec, Object &thisObj, const List &args)
00379 {
00380
00381 Value val;
00382 try {
00383 val = tryCall(exec, thisObj, args);
00384 }
00385
00386 catch (...) {
00387 Object err = Error::create(exec, GeneralError, "Exception from DOMStyleSheetList");
00388 exec->setException(err);
00389 }
00390 return val;
00391 }
00392
00393 Value DOMStyleSheetList::tryCall(ExecState *exec, Object & , const List &args)
00394 {
00395 if (args.size() == 1) {
00396
00397 return tryGet( exec, Identifier(args[0].toString(exec)) );
00398 }
00399 return Undefined();
00400 }
00401
00402 Value KJS::getDOMStyleSheetList(ExecState *exec, const DOM::StyleSheetList& ssl, const DOM::Document& doc)
00403 {
00404
00405 DOMObject *ret;
00406 if (ssl.isNull())
00407 return Null();
00408 ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00409 if ((ret = interp->getDOMObject(ssl.handle())))
00410 return Value(ret);
00411 else {
00412 ret = new DOMStyleSheetList(exec, ssl, doc);
00413 interp->putDOMObject(ssl.handle(),ret);
00414 return Value(ret);
00415 }
00416 }
00417
00418 Value DOMStyleSheetListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00419 {
00420 KJS_CHECK_THIS( KJS::DOMStyleSheetList, thisObj );
00421 DOM::StyleSheetList styleSheetList = static_cast<DOMStyleSheetList *>(thisObj.imp())->toStyleSheetList();
00422 if (id == DOMStyleSheetList::Item)
00423 return getDOMStyleSheet(exec, styleSheetList.item(args[0].toInteger(exec)));
00424 return Undefined();
00425 }
00426
00427
00428
00429 const ClassInfo DOMMediaList::info = { "MediaList", 0, &DOMMediaListTable, 0 };
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442 DEFINE_PROTOTYPE("DOMMediaList", DOMMediaListProto)
00443 IMPLEMENT_PROTOFUNC_DOM(DOMMediaListProtoFunc)
00444 IMPLEMENT_PROTOTYPE(DOMMediaListProto, DOMMediaListProtoFunc)
00445
00446 DOMMediaList::DOMMediaList(ExecState *exec, const DOM::MediaList& ml)
00447 : DOMObject(DOMMediaListProto::self(exec)), mediaList(ml) { }
00448
00449 DOMMediaList::~DOMMediaList()
00450 {
00451 ScriptInterpreter::forgetDOMObject(mediaList.handle());
00452 }
00453
00454 Value DOMMediaList::tryGet(ExecState *exec, const Identifier &p) const
00455 {
00456 if (p == "mediaText")
00457 return String(mediaList.mediaText());
00458 else if (p == lengthPropertyName)
00459 return Number(mediaList.length());
00460
00461 bool ok;
00462 long unsigned int u = p.toULong(&ok);
00463 if (ok)
00464 return String(mediaList.item(u));
00465
00466 return DOMObject::tryGet(exec, p);
00467 }
00468
00469 void DOMMediaList::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00470 {
00471 if (propertyName == "mediaText")
00472 mediaList.setMediaText(value.toString(exec).string());
00473 else
00474 DOMObject::tryPut(exec, propertyName, value, attr);
00475 }
00476
00477 Value KJS::getDOMMediaList(ExecState *exec, const DOM::MediaList& ml)
00478 {
00479 return cacheDOMObject<DOM::MediaList, KJS::DOMMediaList>(exec, ml);
00480 }
00481
00482 Value KJS::DOMMediaListProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00483 {
00484 KJS_CHECK_THIS( KJS::DOMMediaList, thisObj );
00485 DOM::MediaList mediaList = static_cast<DOMMediaList *>(thisObj.imp())->toMediaList();
00486 switch (id) {
00487 case DOMMediaList::Item:
00488 return String(mediaList.item(args[0].toInteger(exec)));
00489 case DOMMediaList::DeleteMedium:
00490 mediaList.deleteMedium(args[0].toString(exec).string());
00491 return Undefined();
00492 case DOMMediaList::AppendMedium:
00493 mediaList.appendMedium(args[0].toString(exec).string());
00494 return Undefined();
00495 default:
00496 return Undefined();
00497 }
00498 }
00499
00500
00501
00502 const ClassInfo DOMCSSStyleSheet::info = { "CSSStyleSheet", 0, &DOMCSSStyleSheetTable, 0 };
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 DEFINE_PROTOTYPE("DOMCSSStyleSheet",DOMCSSStyleSheetProto)
00520 IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleSheetProtoFunc)
00521 IMPLEMENT_PROTOTYPE(DOMCSSStyleSheetProto,DOMCSSStyleSheetProtoFunc)
00522
00523 DOMCSSStyleSheet::DOMCSSStyleSheet(ExecState *exec, const DOM::CSSStyleSheet& ss)
00524 : DOMStyleSheet(DOMCSSStyleSheetProto::self(exec),ss) { }
00525
00526 DOMCSSStyleSheet::~DOMCSSStyleSheet()
00527 {
00528 }
00529
00530 Value DOMCSSStyleSheet::tryGet(ExecState *exec, const Identifier &p) const
00531 {
00532 DOM::CSSStyleSheet cssStyleSheet = static_cast<DOM::CSSStyleSheet>(styleSheet);
00533 if (p == "ownerRule")
00534 return getDOMCSSRule(exec,cssStyleSheet.ownerRule());
00535 else if (p == "cssRules" || p == "rules" )
00536 return getDOMCSSRuleList(exec,cssStyleSheet.cssRules());
00537 return DOMStyleSheet::tryGet(exec,p);
00538 }
00539
00540 Value DOMCSSStyleSheetProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00541 {
00542 KJS_CHECK_THIS( KJS::DOMCSSStyleSheet, thisObj );
00543 DOM::CSSStyleSheet styleSheet = static_cast<DOMCSSStyleSheet *>(thisObj.imp())->toCSSStyleSheet();
00544
00545 switch (id) {
00546 case DOMCSSStyleSheet::InsertRule:
00547 return Number(styleSheet.insertRule(args[0].toString(exec).string(),(long unsigned int)args[1].toInteger(exec)));
00548 case DOMCSSStyleSheet::DeleteRule:
00549 styleSheet.deleteRule(args[0].toInteger(exec));
00550 return Undefined();
00551
00552 case DOMCSSStyleSheet::AddRule: {
00553
00554
00555 unsigned long index = args[2].toInteger(exec);
00556 unsigned long length = styleSheet.cssRules().length();
00557 if (args[2].type() == UndefinedType) index = length;
00558 if (index > length) index = length;
00559 DOM::DOMString str = args[0].toString(exec).string() + " { " + args[1].toString(exec).string() + " } ";
00560 return Number(styleSheet.insertRule(str,index));
00561 }
00562 case DOMCSSStyleSheet::RemoveRule: {
00563 int index = args.size() > 0 ? args[0].toInteger(exec) : 0 ;
00564 styleSheet.deleteRule(index);
00565 return Undefined();
00566 }
00567 default:
00568 return Undefined();
00569 }
00570 }
00571
00572
00573
00574 const ClassInfo DOMCSSRuleList::info = { "CSSRuleList", 0, &DOMCSSRuleListTable, 0 };
00575
00576
00577
00578
00579
00580
00581 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleListFunc)
00582
00583 DOMCSSRuleList::DOMCSSRuleList(ExecState* exec, const DOM::CSSRuleList& rl)
00584 : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRuleList(rl)
00585 {
00586 }
00587
00588 DOMCSSRuleList::~DOMCSSRuleList()
00589 {
00590 ScriptInterpreter::forgetDOMObject(cssRuleList.handle());
00591 }
00592
00593 Value DOMCSSRuleList::tryGet(ExecState *exec, const Identifier &p) const
00594 {
00595 Value result;
00596 if (p == lengthPropertyName)
00597 return Number(cssRuleList.length());
00598 else if (p == "item")
00599 return lookupOrCreateFunction<DOMCSSRuleListFunc>(exec,p,this,DOMCSSRuleList::Item,1,DontDelete|Function);
00600
00601 bool ok;
00602 long unsigned int u = p.toULong(&ok);
00603 if (ok)
00604 return getDOMCSSRule(exec,DOM::CSSRuleList(cssRuleList).item(u));
00605
00606 return DOMObject::tryGet(exec,p);
00607 }
00608
00609 Value DOMCSSRuleListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00610 {
00611 KJS_CHECK_THIS( KJS::DOMCSSRuleList, thisObj );
00612 DOM::CSSRuleList cssRuleList = static_cast<DOMCSSRuleList *>(thisObj.imp())->toCSSRuleList();
00613 switch (id) {
00614 case DOMCSSRuleList::Item:
00615 return getDOMCSSRule(exec,cssRuleList.item(args[0].toInteger(exec)));
00616 default:
00617 return Undefined();
00618 }
00619 }
00620
00621 Value KJS::getDOMCSSRuleList(ExecState *exec, const DOM::CSSRuleList& rl)
00622 {
00623 return cacheDOMObject<DOM::CSSRuleList, KJS::DOMCSSRuleList>(exec, rl);
00624 }
00625
00626
00627
00628 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleFunc)
00629
00630 DOMCSSRule::DOMCSSRule(ExecState* exec, const DOM::CSSRule& r)
00631 : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRule(r)
00632 {
00633 }
00634
00635 DOMCSSRule::~DOMCSSRule()
00636 {
00637 ScriptInterpreter::forgetDOMObject(cssRule.handle());
00638 }
00639
00640 const ClassInfo DOMCSSRule::info = { "CSSRule", 0, &DOMCSSRuleTable, 0 };
00641 const ClassInfo DOMCSSRule::style_info = { "CSSStyleRule", &DOMCSSRule::info, &DOMCSSStyleRuleTable, 0 };
00642 const ClassInfo DOMCSSRule::media_info = { "CSSMediaRule", &DOMCSSRule::info, &DOMCSSMediaRuleTable, 0 };
00643 const ClassInfo DOMCSSRule::fontface_info = { "CSSFontFaceRule", &DOMCSSRule::info, &DOMCSSFontFaceRuleTable, 0 };
00644 const ClassInfo DOMCSSRule::page_info = { "CSSPageRule", &DOMCSSRule::info, &DOMCSSPageRuleTable, 0 };
00645 const ClassInfo DOMCSSRule::import_info = { "CSSImportRule", &DOMCSSRule::info, &DOMCSSImportRuleTable, 0 };
00646 const ClassInfo DOMCSSRule::charset_info = { "CSSCharsetRule", &DOMCSSRule::info, &DOMCSSCharsetRuleTable, 0 };
00647
00648 const ClassInfo* DOMCSSRule::classInfo() const
00649 {
00650 switch (cssRule.type()) {
00651 case DOM::CSSRule::STYLE_RULE:
00652 return &style_info;
00653 case DOM::CSSRule::MEDIA_RULE:
00654 return &media_info;
00655 case DOM::CSSRule::FONT_FACE_RULE:
00656 return &fontface_info;
00657 case DOM::CSSRule::PAGE_RULE:
00658 return &page_info;
00659 case DOM::CSSRule::IMPORT_RULE:
00660 return &import_info;
00661 case DOM::CSSRule::CHARSET_RULE:
00662 return &charset_info;
00663 case DOM::CSSRule::UNKNOWN_RULE:
00664 default:
00665 return &info;
00666 }
00667 }
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701 Value DOMCSSRule::tryGet(ExecState *exec, const Identifier &propertyName) const
00702 {
00703 #ifdef KJS_VERBOSE
00704 kdDebug(6070) << "DOMCSSRule::tryGet " << propertyName.qstring() << endl;
00705 #endif
00706 const HashTable* table = classInfo()->propHashTable;
00707 const HashEntry* entry = Lookup::findEntry(table, propertyName);
00708 if (entry) {
00709 if (entry->attr & Function)
00710 return lookupOrCreateFunction<DOMCSSRuleFunc>(exec, propertyName, this, entry->value, entry->params, entry->attr);
00711 return getValueProperty(exec, entry->value);
00712 }
00713
00714
00715 return DOMObjectLookupGet<DOMCSSRuleFunc, DOMCSSRule, DOMObject>(exec, propertyName, &DOMCSSRuleTable, this);
00716 }
00717
00718 Value DOMCSSRule::getValueProperty(ExecState *exec, int token) const
00719 {
00720 switch (token) {
00721 case Type:
00722 return Number(cssRule.type());
00723 case CssText:
00724 return String(cssRule.cssText());
00725 case ParentStyleSheet:
00726 return getDOMStyleSheet(exec,cssRule.parentStyleSheet());
00727 case ParentRule:
00728 return getDOMCSSRule(exec,cssRule.parentRule());
00729
00730
00731 case Style_SelectorText:
00732 return String(static_cast<DOM::CSSStyleRule>(cssRule).selectorText());
00733 case Style_Style:
00734 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSStyleRule>(cssRule).style());
00735
00736
00737 case Media_Media:
00738 return getDOMMediaList(exec,static_cast<DOM::CSSMediaRule>(cssRule).media());
00739 case Media_CssRules:
00740 return getDOMCSSRuleList(exec,static_cast<DOM::CSSMediaRule>(cssRule).cssRules());
00741
00742
00743 case FontFace_Style:
00744 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSFontFaceRule>(cssRule).style());
00745
00746
00747 case Page_SelectorText:
00748 return String(static_cast<DOM::CSSPageRule>(cssRule).selectorText());
00749 case Page_Style:
00750 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSPageRule>(cssRule).style());
00751
00752
00753 case Import_Href:
00754 return String(static_cast<DOM::CSSImportRule>(cssRule).href());
00755 case Import_Media:
00756 return getDOMMediaList(exec,static_cast<DOM::CSSImportRule>(cssRule).media());
00757 case Import_StyleSheet:
00758 return getDOMStyleSheet(exec,static_cast<DOM::CSSImportRule>(cssRule).styleSheet());
00759
00760
00761 case Charset_Encoding:
00762 return String(static_cast<DOM::CSSCharsetRule>(cssRule).encoding());
00763
00764 default:
00765 kdDebug(6070) << "WARNING: DOMCSSRule::getValueProperty unhandled token " << token << endl;
00766 }
00767 return Undefined();
00768 }
00769
00770 void DOMCSSRule::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00771 {
00772 const HashTable* table = classInfo()->propHashTable;
00773 const HashEntry* entry = Lookup::findEntry(table, propertyName);
00774 if (entry) {
00775 if (entry->attr & Function)
00776 {
00777 ObjectImp::put(exec, propertyName, value, attr);
00778 return;
00779 }
00780 else if ((entry->attr & ReadOnly) == 0)
00781 {
00782 putValueProperty(exec, entry->value, value, attr);
00783 return;
00784 }
00785 }
00786 DOMObjectLookupPut<DOMCSSRule, DOMObject>(exec, propertyName, value, attr, &DOMCSSRuleTable, this);
00787 }
00788
00789 void DOMCSSRule::putValueProperty(ExecState *exec, int token, const Value& value, int)
00790 {
00791 switch (token) {
00792
00793 case Style_SelectorText:
00794 static_cast<DOM::CSSStyleRule>(cssRule).setSelectorText(value.toString(exec).string());
00795 return;
00796
00797
00798 case Page_SelectorText:
00799 static_cast<DOM::CSSPageRule>(cssRule).setSelectorText(value.toString(exec).string());
00800 return;
00801
00802
00803 case Charset_Encoding:
00804 static_cast<DOM::CSSCharsetRule>(cssRule).setEncoding(value.toString(exec).string());
00805 return;
00806
00807 default:
00808 kdDebug(6070) << "WARNING: DOMCSSRule::putValueProperty unhandled token " << token << endl;
00809 }
00810 }
00811
00812 Value DOMCSSRuleFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00813 {
00814 KJS_CHECK_THIS( KJS::DOMCSSRule, thisObj );
00815 DOM::CSSRule cssRule = static_cast<DOMCSSRule *>(thisObj.imp())->toCSSRule();
00816
00817 if (cssRule.type() == DOM::CSSRule::MEDIA_RULE) {
00818 DOM::CSSMediaRule rule = static_cast<DOM::CSSMediaRule>(cssRule);
00819 if (id == DOMCSSRule::Media_InsertRule)
00820 return Number(rule.insertRule(args[0].toString(exec).string(),args[1].toInteger(exec)));
00821 else if (id == DOMCSSRule::Media_DeleteRule)
00822 rule.deleteRule(args[0].toInteger(exec));
00823 }
00824
00825 return Undefined();
00826 }
00827
00828 Value KJS::getDOMCSSRule(ExecState *exec, const DOM::CSSRule& r)
00829 {
00830 return cacheDOMObject<DOM::CSSRule, KJS::DOMCSSRule>(exec, r);
00831 }
00832
00833
00834
00835
00836 DOM::CSSRule KJS::toCSSRule(const Value& val)
00837 {
00838 Object obj = Object::dynamicCast(val);
00839 if (!obj.isValid() || !obj.inherits(&DOMCSSRule::info))
00840 return DOM::CSSRule();
00841
00842 const DOMCSSRule *dobj = static_cast<const DOMCSSRule*>(obj.imp());
00843 return dobj->toCSSRule();
00844 }
00845
00846
00847
00848 const ClassInfo CSSRuleConstructor::info = { "CSSRuleConstructor", 0, &CSSRuleConstructorTable, 0 };
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861 CSSRuleConstructor::CSSRuleConstructor(ExecState *exec)
00862 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00863 {
00864 }
00865
00866 Value CSSRuleConstructor::tryGet(ExecState *exec, const Identifier &p) const
00867 {
00868 return DOMObjectLookupGetValue<CSSRuleConstructor,DOMObject>(exec,p,&CSSRuleConstructorTable,this);
00869 }
00870
00871 Value CSSRuleConstructor::getValueProperty(ExecState *, int token) const
00872 {
00873 switch (token) {
00874 case UNKNOWN_RULE:
00875 return Number(DOM::CSSRule::UNKNOWN_RULE);
00876 case STYLE_RULE:
00877 return Number(DOM::CSSRule::STYLE_RULE);
00878 case CHARSET_RULE:
00879 return Number(DOM::CSSRule::CHARSET_RULE);
00880 case IMPORT_RULE:
00881 return Number(DOM::CSSRule::IMPORT_RULE);
00882 case MEDIA_RULE:
00883 return Number(DOM::CSSRule::MEDIA_RULE);
00884 case FONT_FACE_RULE:
00885 return Number(DOM::CSSRule::FONT_FACE_RULE);
00886 case PAGE_RULE:
00887 return Number(DOM::CSSRule::PAGE_RULE);
00888 }
00889 return Value();
00890 }
00891
00892 Value KJS::getCSSRuleConstructor(ExecState *exec)
00893 {
00894 return cacheGlobalObject<CSSRuleConstructor>( exec, "[[cssRule.constructor]]" );
00895 }
00896
00897
00898
00899 const ClassInfo DOMCSSValue::info = { "CSSValue", 0, &DOMCSSValueTable, 0 };
00900
00901
00902
00903
00904
00905
00906
00907
00908 DOMCSSValue::DOMCSSValue(ExecState* exec, const DOM::CSSValue& val)
00909 : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssValue(val)
00910 {
00911 }
00912
00913 DOMCSSValue::~DOMCSSValue()
00914 {
00915 ScriptInterpreter::forgetDOMObject(cssValue.handle());
00916 }
00917
00918 Value DOMCSSValue::tryGet(ExecState *exec, const Identifier &p) const
00919 {
00920 if (p == "cssText")
00921 return String(cssValue.cssText());
00922 else if (p == "cssValueType")
00923 return Number(cssValue.cssValueType());
00924 return DOMObject::tryGet(exec,p);
00925 }
00926
00927 void DOMCSSValue::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00928 {
00929 if (propertyName == "cssText")
00930 cssValue.setCssText(value.toString(exec).string());
00931 else
00932 DOMObject::tryPut(exec, propertyName, value, attr);
00933 }
00934
00935 Value KJS::getDOMCSSValue(ExecState *exec, const DOM::CSSValue& v)
00936 {
00937 DOMObject *ret;
00938 if (v.isNull())
00939 return Null();
00940 ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00941 if ((ret = interp->getDOMObject(v.handle())))
00942 return Value(ret);
00943 else {
00944 if (v.isCSSValueList())
00945 ret = new DOMCSSValueList(exec,v);
00946 else if (v.isCSSPrimitiveValue())
00947 ret = new DOMCSSPrimitiveValue(exec,v);
00948 else
00949 ret = new DOMCSSValue(exec,v);
00950 interp->putDOMObject(v.handle(),ret);
00951 return Value(ret);
00952 }
00953 }
00954
00955
00956
00957 const ClassInfo CSSValueConstructor::info = { "CSSValueConstructor", 0, &CSSValueConstructorTable, 0 };
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967 CSSValueConstructor::CSSValueConstructor(ExecState *exec)
00968 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00969 {
00970 }
00971
00972 Value CSSValueConstructor::tryGet(ExecState *exec, const Identifier &p) const
00973 {
00974 return DOMObjectLookupGetValue<CSSValueConstructor,DOMObject>(exec,p,&CSSValueConstructorTable,this);
00975 }
00976
00977 Value CSSValueConstructor::getValueProperty(ExecState *, int token) const
00978 {
00979 switch (token) {
00980 case CSS_INHERIT:
00981 return Number(DOM::CSSValue::CSS_INHERIT);
00982 case CSS_PRIMITIVE_VALUE:
00983 return Number(DOM::CSSValue::CSS_PRIMITIVE_VALUE);
00984 case CSS_VALUE_LIST:
00985 return Number(DOM::CSSValue::CSS_VALUE_LIST);
00986 case CSS_CUSTOM:
00987 return Number(DOM::CSSValue::CSS_CUSTOM);
00988 }
00989 return Value();
00990 }
00991
00992 Value KJS::getCSSValueConstructor(ExecState *exec)
00993 {
00994 return cacheGlobalObject<CSSValueConstructor>( exec, "[[cssValue.constructor]]" );
00995 }
00996
00997
00998
00999 const ClassInfo DOMCSSPrimitiveValue::info = { "CSSPrimitiveValue", 0, &DOMCSSPrimitiveValueTable, 0 };
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014 DEFINE_PROTOTYPE("DOMCSSPrimitiveValue",DOMCSSPrimitiveValueProto)
01015 IMPLEMENT_PROTOFUNC_DOM(DOMCSSPrimitiveValueProtoFunc)
01016 IMPLEMENT_PROTOTYPE(DOMCSSPrimitiveValueProto,DOMCSSPrimitiveValueProtoFunc)
01017
01018 DOMCSSPrimitiveValue::DOMCSSPrimitiveValue(ExecState *exec, const DOM::CSSPrimitiveValue& v)
01019 : DOMCSSValue(DOMCSSPrimitiveValueProto::self(exec), v) { }
01020
01021 Value DOMCSSPrimitiveValue::tryGet(ExecState *exec, const Identifier &p) const
01022 {
01023 if (p=="primitiveType")
01024 return Number(static_cast<DOM::CSSPrimitiveValue>(cssValue).primitiveType());
01025 return DOMObject::tryGet(exec,p);
01026 }
01027
01028 Value DOMCSSPrimitiveValueProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01029 {
01030 KJS_CHECK_THIS( KJS::DOMCSSPrimitiveValue, thisObj );
01031 DOM::CSSPrimitiveValue val = static_cast<DOMCSSPrimitiveValue *>(thisObj.imp())->toCSSPrimitiveValue();
01032 switch (id) {
01033 case DOMCSSPrimitiveValue::SetFloatValue:
01034 val.setFloatValue(args[0].toInteger(exec),args[1].toNumber(exec));
01035 return Undefined();
01036 case DOMCSSPrimitiveValue::GetFloatValue:
01037 return Number(val.getFloatValue(args[0].toInteger(exec)));
01038 case DOMCSSPrimitiveValue::SetStringValue:
01039 val.setStringValue(args[0].toInteger(exec),args[1].toString(exec).string());
01040 return Undefined();
01041 case DOMCSSPrimitiveValue::GetStringValue:
01042 return String(val.getStringValue());
01043 case DOMCSSPrimitiveValue::GetCounterValue:
01044 return getDOMCounter(exec,val.getCounterValue());
01045 case DOMCSSPrimitiveValue::GetRectValue:
01046 return getDOMRect(exec,val.getRectValue());
01047 case DOMCSSPrimitiveValue::GetRGBColorValue:
01048 return getDOMRGBColor(exec,val.getRGBColorValue());
01049 default:
01050 return Undefined();
01051 }
01052 }
01053
01054
01055
01056 const ClassInfo CSSPrimitiveValueConstructor::info = { "CSSPrimitiveValueConstructor", 0, &CSSPrimitiveValueConstructorTable, 0 };
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089 Value CSSPrimitiveValueConstructor::tryGet(ExecState *exec, const Identifier &p) const
01090 {
01091 return DOMObjectLookupGetValue<CSSPrimitiveValueConstructor,CSSValueConstructor>(exec,p,&CSSPrimitiveValueConstructorTable,this);
01092 }
01093
01094 Value CSSPrimitiveValueConstructor::getValueProperty(ExecState *, int token) const
01095 {
01096
01097 return Number(token);
01098 }
01099
01100 Value KJS::getCSSPrimitiveValueConstructor(ExecState *exec)
01101 {
01102 return cacheGlobalObject<CSSPrimitiveValueConstructor>( exec, "[[cssPrimitiveValue.constructor]]" );
01103 }
01104
01105
01106
01107 const ClassInfo DOMCSSValueList::info = { "CSSValueList", 0, &DOMCSSValueListTable, 0 };
01108
01109
01110
01111
01112
01113
01114
01115 IMPLEMENT_PROTOFUNC_DOM(DOMCSSValueListFunc)
01116
01117 DOMCSSValueList::DOMCSSValueList(ExecState *exec, const DOM::CSSValueList& v)
01118 : DOMCSSValue(exec, v) { }
01119
01120 Value DOMCSSValueList::tryGet(ExecState *exec, const Identifier &p) const
01121 {
01122 Value result;
01123 DOM::CSSValueList valueList = static_cast<DOM::CSSValueList>(cssValue);
01124
01125 if (p == lengthPropertyName)
01126 return Number(valueList.length());
01127 else if (p == "item")
01128 return lookupOrCreateFunction<DOMCSSValueListFunc>(exec,p,this,DOMCSSValueList::Item,1,DontDelete|Function);
01129
01130 bool ok;
01131 long unsigned int u = p.toULong(&ok);
01132 if (ok)
01133 return getDOMCSSValue(exec,valueList.item(u));
01134
01135 return DOMCSSValue::tryGet(exec,p);
01136 }
01137
01138 Value DOMCSSValueListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01139 {
01140 KJS_CHECK_THIS( KJS::DOMCSSValueList, thisObj );
01141 DOM::CSSValueList valueList = static_cast<DOMCSSValueList *>(thisObj.imp())->toValueList();
01142 switch (id) {
01143 case DOMCSSValueList::Item:
01144 return getDOMCSSValue(exec,valueList.item(args[0].toInteger(exec)));
01145 default:
01146 return Undefined();
01147 }
01148 }
01149
01150
01151
01152 const ClassInfo DOMRGBColor::info = { "RGBColor", 0, &DOMRGBColorTable, 0 };
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162 DOMRGBColor::DOMRGBColor(ExecState* exec, const DOM::RGBColor& c)
01163 : DOMObject(exec->interpreter()->builtinObjectPrototype()), rgbColor(c)
01164 {
01165 }
01166
01167 DOMRGBColor::~DOMRGBColor()
01168 {
01169
01170 }
01171
01172 Value DOMRGBColor::tryGet(ExecState *exec, const Identifier &p) const
01173 {
01174 return DOMObjectLookupGetValue<DOMRGBColor,DOMObject>(exec, p,
01175 &DOMRGBColorTable,
01176 this);
01177 }
01178
01179 Value DOMRGBColor::getValueProperty(ExecState *exec, int token) const
01180 {
01181 switch (token) {
01182 case Red:
01183 return getDOMCSSValue(exec, rgbColor.red());
01184 case Green:
01185 return getDOMCSSValue(exec, rgbColor.green());
01186 case Blue:
01187 return getDOMCSSValue(exec, rgbColor.blue());
01188 default:
01189 return Value();
01190 }
01191 }
01192
01193 Value KJS::getDOMRGBColor(ExecState *exec, const DOM::RGBColor& c)
01194 {
01195
01196 return Value(new DOMRGBColor(exec, c));
01197 }
01198
01199
01200
01201 const ClassInfo DOMRect::info = { "Rect", 0, &DOMRectTable, 0 };
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211 DOMRect::DOMRect(ExecState *exec, const DOM::Rect& r)
01212 : DOMObject(exec->interpreter()->builtinObjectPrototype()), rect(r)
01213 {
01214 }
01215
01216 DOMRect::~DOMRect()
01217 {
01218 ScriptInterpreter::forgetDOMObject(rect.handle());
01219 }
01220
01221 Value DOMRect::tryGet(ExecState *exec, const Identifier &p) const
01222 {
01223 return DOMObjectLookupGetValue<DOMRect,DOMObject>(exec, p,
01224 &DOMRectTable, this);
01225 }
01226
01227 Value DOMRect::getValueProperty(ExecState *exec, int token) const
01228 {
01229 switch (token) {
01230 case Top:
01231 return getDOMCSSValue(exec, rect.top());
01232 case Right:
01233 return getDOMCSSValue(exec, rect.right());
01234 case Bottom:
01235 return getDOMCSSValue(exec, rect.bottom());
01236 case Left:
01237 return getDOMCSSValue(exec, rect.left());
01238 default:
01239 return Value();
01240 }
01241 }
01242
01243 Value KJS::getDOMRect(ExecState *exec, const DOM::Rect& r)
01244 {
01245 return cacheDOMObject<DOM::Rect, KJS::DOMRect>(exec, r);
01246 }
01247
01248
01249
01250 const ClassInfo DOMCounter::info = { "Counter", 0, &DOMCounterTable, 0 };
01251
01252
01253
01254
01255
01256
01257
01258 DOMCounter::DOMCounter(ExecState *exec, const DOM::Counter& c)
01259 : DOMObject(exec->interpreter()->builtinObjectPrototype()), counter(c)
01260 {
01261 }
01262
01263 DOMCounter::~DOMCounter()
01264 {
01265 ScriptInterpreter::forgetDOMObject(counter.handle());
01266 }
01267
01268 Value DOMCounter::tryGet(ExecState *exec, const Identifier &p) const
01269 {
01270 return DOMObjectLookupGetValue<DOMCounter,DOMObject>(exec, p,
01271 &DOMCounterTable, this);
01272 }
01273
01274 Value DOMCounter::getValueProperty(ExecState *, int token) const
01275 {
01276 switch (token) {
01277 case identifier:
01278 return String(counter.identifier());
01279 case listStyle:
01280 return String(counter.listStyle());
01281 case separator:
01282 return String(counter.separator());
01283 default:
01284 return Value();
01285 }
01286 }
01287
01288 Value KJS::getDOMCounter(ExecState *exec, const DOM::Counter& c)
01289 {
01290 return cacheDOMObject<DOM::Counter, KJS::DOMCounter>(exec, c);
01291 }