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 getString(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.isNull() && 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 getString(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 getString(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 getString(styleDecl.getPropertyValue(s));
00202 case DOMCSSStyleDeclaration::GetPropertyCSSValue:
00203 return getDOMCSSValue(exec,styleDecl.getPropertyCSSValue(s));
00204 case DOMCSSStyleDeclaration::RemoveProperty:
00205 return getString(styleDecl.removeProperty(s));
00206 case DOMCSSStyleDeclaration::GetPropertyPriority:
00207 return getString(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 getString(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 getString(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 getString(styleSheet.href());
00268 case Title:
00269 return getString(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 getString(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 getString(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 getString(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 DOM::DOMString str = args[0].toString(exec).string() + " { " + args[1].toString(exec).string() + " } ";
00554 return Number(styleSheet.insertRule(str,(long unsigned int)args[2].toInteger(exec)));
00555 }
00556 case DOMCSSStyleSheet::RemoveRule: {
00557 int index = args.size() > 0 ? args[0].toInteger(exec) : 0 ;
00558 styleSheet.deleteRule(index);
00559 return Undefined();
00560 }
00561 default:
00562 return Undefined();
00563 }
00564 }
00565
00566
00567
00568 const ClassInfo DOMCSSRuleList::info = { "CSSRuleList", 0, &DOMCSSRuleListTable, 0 };
00569
00570
00571
00572
00573
00574
00575 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleListFunc)
00576
00577 DOMCSSRuleList::DOMCSSRuleList(ExecState* exec, const DOM::CSSRuleList& rl)
00578 : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRuleList(rl)
00579 {
00580 }
00581
00582 DOMCSSRuleList::~DOMCSSRuleList()
00583 {
00584 ScriptInterpreter::forgetDOMObject(cssRuleList.handle());
00585 }
00586
00587 Value DOMCSSRuleList::tryGet(ExecState *exec, const Identifier &p) const
00588 {
00589 Value result;
00590 if (p == lengthPropertyName)
00591 return Number(cssRuleList.length());
00592 else if (p == "item")
00593 return lookupOrCreateFunction<DOMCSSRuleListFunc>(exec,p,this,DOMCSSRuleList::Item,1,DontDelete|Function);
00594
00595 bool ok;
00596 long unsigned int u = p.toULong(&ok);
00597 if (ok)
00598 return getDOMCSSRule(exec,DOM::CSSRuleList(cssRuleList).item(u));
00599
00600 return DOMObject::tryGet(exec,p);
00601 }
00602
00603 Value DOMCSSRuleListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00604 {
00605 KJS_CHECK_THIS( KJS::DOMCSSRuleList, thisObj );
00606 DOM::CSSRuleList cssRuleList = static_cast<DOMCSSRuleList *>(thisObj.imp())->toCSSRuleList();
00607 switch (id) {
00608 case DOMCSSRuleList::Item:
00609 return getDOMCSSRule(exec,cssRuleList.item(args[0].toInteger(exec)));
00610 default:
00611 return Undefined();
00612 }
00613 }
00614
00615 Value KJS::getDOMCSSRuleList(ExecState *exec, const DOM::CSSRuleList& rl)
00616 {
00617 return cacheDOMObject<DOM::CSSRuleList, KJS::DOMCSSRuleList>(exec, rl);
00618 }
00619
00620
00621
00622 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleFunc)
00623
00624 DOMCSSRule::DOMCSSRule(ExecState* exec, const DOM::CSSRule& r)
00625 : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRule(r)
00626 {
00627 }
00628
00629 DOMCSSRule::~DOMCSSRule()
00630 {
00631 ScriptInterpreter::forgetDOMObject(cssRule.handle());
00632 }
00633
00634 const ClassInfo DOMCSSRule::info = { "CSSRule", 0, &DOMCSSRuleTable, 0 };
00635 const ClassInfo DOMCSSRule::style_info = { "CSSStyleRule", &DOMCSSRule::info, &DOMCSSStyleRuleTable, 0 };
00636 const ClassInfo DOMCSSRule::media_info = { "CSSMediaRule", &DOMCSSRule::info, &DOMCSSMediaRuleTable, 0 };
00637 const ClassInfo DOMCSSRule::fontface_info = { "CSSFontFaceRule", &DOMCSSRule::info, &DOMCSSFontFaceRuleTable, 0 };
00638 const ClassInfo DOMCSSRule::page_info = { "CSSPageRule", &DOMCSSRule::info, &DOMCSSPageRuleTable, 0 };
00639 const ClassInfo DOMCSSRule::import_info = { "CSSImportRule", &DOMCSSRule::info, &DOMCSSImportRuleTable, 0 };
00640 const ClassInfo DOMCSSRule::charset_info = { "CSSCharsetRule", &DOMCSSRule::info, &DOMCSSCharsetRuleTable, 0 };
00641
00642 const ClassInfo* DOMCSSRule::classInfo() const
00643 {
00644 switch (cssRule.type()) {
00645 case DOM::CSSRule::STYLE_RULE:
00646 return &style_info;
00647 case DOM::CSSRule::MEDIA_RULE:
00648 return &media_info;
00649 case DOM::CSSRule::FONT_FACE_RULE:
00650 return &fontface_info;
00651 case DOM::CSSRule::PAGE_RULE:
00652 return &page_info;
00653 case DOM::CSSRule::IMPORT_RULE:
00654 return &import_info;
00655 case DOM::CSSRule::CHARSET_RULE:
00656 return &charset_info;
00657 case DOM::CSSRule::UNKNOWN_RULE:
00658 default:
00659 return &info;
00660 }
00661 }
00662
00663
00664
00665
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 Value DOMCSSRule::tryGet(ExecState *exec, const Identifier &propertyName) const
00696 {
00697 #ifdef KJS_VERBOSE
00698 kdDebug(6070) << "DOMCSSRule::tryGet " << propertyName.qstring() << endl;
00699 #endif
00700 const HashTable* table = classInfo()->propHashTable;
00701 const HashEntry* entry = Lookup::findEntry(table, propertyName);
00702 if (entry) {
00703 if (entry->attr & Function)
00704 return lookupOrCreateFunction<DOMCSSRuleFunc>(exec, propertyName, this, entry->value, entry->params, entry->attr);
00705 return getValueProperty(exec, entry->value);
00706 }
00707
00708
00709 return DOMObjectLookupGet<DOMCSSRuleFunc, DOMCSSRule, DOMObject>(exec, propertyName, &DOMCSSRuleTable, this);
00710 }
00711
00712 Value DOMCSSRule::getValueProperty(ExecState *exec, int token) const
00713 {
00714 switch (token) {
00715 case Type:
00716 return Number(cssRule.type());
00717 case CssText:
00718 return getString(cssRule.cssText());
00719 case ParentStyleSheet:
00720 return getDOMStyleSheet(exec,cssRule.parentStyleSheet());
00721 case ParentRule:
00722 return getDOMCSSRule(exec,cssRule.parentRule());
00723
00724
00725 case Style_SelectorText:
00726 return getString(static_cast<DOM::CSSStyleRule>(cssRule).selectorText());
00727 case Style_Style:
00728 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSStyleRule>(cssRule).style());
00729
00730
00731 case Media_Media:
00732 return getDOMMediaList(exec,static_cast<DOM::CSSMediaRule>(cssRule).media());
00733 case Media_CssRules:
00734 return getDOMCSSRuleList(exec,static_cast<DOM::CSSMediaRule>(cssRule).cssRules());
00735
00736
00737 case FontFace_Style:
00738 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSFontFaceRule>(cssRule).style());
00739
00740
00741 case Page_SelectorText:
00742 return getString(static_cast<DOM::CSSPageRule>(cssRule).selectorText());
00743 case Page_Style:
00744 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSPageRule>(cssRule).style());
00745
00746
00747 case Import_Href:
00748 return getString(static_cast<DOM::CSSImportRule>(cssRule).href());
00749 case Import_Media:
00750 return getDOMMediaList(exec,static_cast<DOM::CSSImportRule>(cssRule).media());
00751 case Import_StyleSheet:
00752 return getDOMStyleSheet(exec,static_cast<DOM::CSSImportRule>(cssRule).styleSheet());
00753
00754
00755 case Charset_Encoding:
00756 return getString(static_cast<DOM::CSSCharsetRule>(cssRule).encoding());
00757
00758 default:
00759 kdDebug(6070) << "WARNING: DOMCSSRule::getValueProperty unhandled token " << token << endl;
00760 }
00761 return Undefined();
00762 }
00763
00764 void DOMCSSRule::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00765 {
00766 const HashTable* table = classInfo()->propHashTable;
00767 const HashEntry* entry = Lookup::findEntry(table, propertyName);
00768 if (entry) {
00769 if (entry->attr & Function)
00770 {
00771 ObjectImp::put(exec, propertyName, value, attr);
00772 return;
00773 }
00774 else if ((entry->attr & ReadOnly) == 0)
00775 {
00776 putValueProperty(exec, entry->value, value, attr);
00777 return;
00778 }
00779 }
00780 DOMObjectLookupPut<DOMCSSRule, DOMObject>(exec, propertyName, value, attr, &DOMCSSRuleTable, this);
00781 }
00782
00783 void DOMCSSRule::putValueProperty(ExecState *exec, int token, const Value& value, int)
00784 {
00785 switch (token) {
00786
00787 case Style_SelectorText:
00788 static_cast<DOM::CSSStyleRule>(cssRule).setSelectorText(value.toString(exec).string());
00789 return;
00790
00791
00792 case Page_SelectorText:
00793 static_cast<DOM::CSSPageRule>(cssRule).setSelectorText(value.toString(exec).string());
00794 return;
00795
00796
00797 case Charset_Encoding:
00798 static_cast<DOM::CSSCharsetRule>(cssRule).setEncoding(value.toString(exec).string());
00799 return;
00800
00801 default:
00802 kdDebug(6070) << "WARNING: DOMCSSRule::putValueProperty unhandled token " << token << endl;
00803 }
00804 }
00805
00806 Value DOMCSSRuleFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00807 {
00808 KJS_CHECK_THIS( KJS::DOMCSSRule, thisObj );
00809 DOM::CSSRule cssRule = static_cast<DOMCSSRule *>(thisObj.imp())->toCSSRule();
00810
00811 if (cssRule.type() == DOM::CSSRule::MEDIA_RULE) {
00812 DOM::CSSMediaRule rule = static_cast<DOM::CSSMediaRule>(cssRule);
00813 if (id == DOMCSSRule::Media_InsertRule)
00814 return Number(rule.insertRule(args[0].toString(exec).string(),args[1].toInteger(exec)));
00815 else if (id == DOMCSSRule::Media_DeleteRule)
00816 rule.deleteRule(args[0].toInteger(exec));
00817 }
00818
00819 return Undefined();
00820 }
00821
00822 Value KJS::getDOMCSSRule(ExecState *exec, const DOM::CSSRule& r)
00823 {
00824 return cacheDOMObject<DOM::CSSRule, KJS::DOMCSSRule>(exec, r);
00825 }
00826
00827
00828
00829
00830 DOM::CSSRule KJS::toCSSRule(const Value& val)
00831 {
00832 Object obj = Object::dynamicCast(val);
00833 if (obj.isNull() || !obj.inherits(&DOMCSSRule::info))
00834 return DOM::CSSRule();
00835
00836 const DOMCSSRule *dobj = static_cast<const DOMCSSRule*>(obj.imp());
00837 return dobj->toCSSRule();
00838 }
00839
00840
00841
00842 const ClassInfo CSSRuleConstructor::info = { "CSSRuleConstructor", 0, &CSSRuleConstructorTable, 0 };
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855 CSSRuleConstructor::CSSRuleConstructor(ExecState *exec)
00856 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00857 {
00858 }
00859
00860 Value CSSRuleConstructor::tryGet(ExecState *exec, const Identifier &p) const
00861 {
00862 return DOMObjectLookupGetValue<CSSRuleConstructor,DOMObject>(exec,p,&CSSRuleConstructorTable,this);
00863 }
00864
00865 Value CSSRuleConstructor::getValueProperty(ExecState *, int token) const
00866 {
00867 switch (token) {
00868 case UNKNOWN_RULE:
00869 return Number(DOM::CSSRule::UNKNOWN_RULE);
00870 case STYLE_RULE:
00871 return Number(DOM::CSSRule::STYLE_RULE);
00872 case CHARSET_RULE:
00873 return Number(DOM::CSSRule::CHARSET_RULE);
00874 case IMPORT_RULE:
00875 return Number(DOM::CSSRule::IMPORT_RULE);
00876 case MEDIA_RULE:
00877 return Number(DOM::CSSRule::MEDIA_RULE);
00878 case FONT_FACE_RULE:
00879 return Number(DOM::CSSRule::FONT_FACE_RULE);
00880 case PAGE_RULE:
00881 return Number(DOM::CSSRule::PAGE_RULE);
00882 }
00883 return Value();
00884 }
00885
00886 Value KJS::getCSSRuleConstructor(ExecState *exec)
00887 {
00888 return cacheGlobalObject<CSSRuleConstructor>( exec, "[[cssRule.constructor]]" );
00889 }
00890
00891
00892
00893 const ClassInfo DOMCSSValue::info = { "CSSValue", 0, &DOMCSSValueTable, 0 };
00894
00895
00896
00897
00898
00899
00900
00901
00902 DOMCSSValue::DOMCSSValue(ExecState* exec, const DOM::CSSValue& val)
00903 : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssValue(val)
00904 {
00905 }
00906
00907 DOMCSSValue::~DOMCSSValue()
00908 {
00909 ScriptInterpreter::forgetDOMObject(cssValue.handle());
00910 }
00911
00912 Value DOMCSSValue::tryGet(ExecState *exec, const Identifier &p) const
00913 {
00914 if (p == "cssText")
00915 return getString(cssValue.cssText());
00916 else if (p == "cssValueType")
00917 return Number(cssValue.cssValueType());
00918 return DOMObject::tryGet(exec,p);
00919 }
00920
00921 void DOMCSSValue::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr)
00922 {
00923 if (propertyName == "cssText")
00924 cssValue.setCssText(value.toString(exec).string());
00925 else
00926 DOMObject::tryPut(exec, propertyName, value, attr);
00927 }
00928
00929 Value KJS::getDOMCSSValue(ExecState *exec, const DOM::CSSValue& v)
00930 {
00931 DOMObject *ret;
00932 if (v.isNull())
00933 return Null();
00934 ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00935 if ((ret = interp->getDOMObject(v.handle())))
00936 return Value(ret);
00937 else {
00938 if (v.isCSSValueList())
00939 ret = new DOMCSSValueList(exec,v);
00940 else if (v.isCSSPrimitiveValue())
00941 ret = new DOMCSSPrimitiveValue(exec,v);
00942 else
00943 ret = new DOMCSSValue(exec,v);
00944 interp->putDOMObject(v.handle(),ret);
00945 return Value(ret);
00946 }
00947 }
00948
00949
00950
00951 const ClassInfo CSSValueConstructor::info = { "CSSValueConstructor", 0, &CSSValueConstructorTable, 0 };
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961 CSSValueConstructor::CSSValueConstructor(ExecState *exec)
00962 : DOMObject(exec->interpreter()->builtinObjectPrototype())
00963 {
00964 }
00965
00966 Value CSSValueConstructor::tryGet(ExecState *exec, const Identifier &p) const
00967 {
00968 return DOMObjectLookupGetValue<CSSValueConstructor,DOMObject>(exec,p,&CSSValueConstructorTable,this);
00969 }
00970
00971 Value CSSValueConstructor::getValueProperty(ExecState *, int token) const
00972 {
00973 switch (token) {
00974 case CSS_INHERIT:
00975 return Number(DOM::CSSValue::CSS_INHERIT);
00976 case CSS_PRIMITIVE_VALUE:
00977 return Number(DOM::CSSValue::CSS_PRIMITIVE_VALUE);
00978 case CSS_VALUE_LIST:
00979 return Number(DOM::CSSValue::CSS_VALUE_LIST);
00980 case CSS_CUSTOM:
00981 return Number(DOM::CSSValue::CSS_CUSTOM);
00982 }
00983 return Value();
00984 }
00985
00986 Value KJS::getCSSValueConstructor(ExecState *exec)
00987 {
00988 return cacheGlobalObject<CSSValueConstructor>( exec, "[[cssValue.constructor]]" );
00989 }
00990
00991
00992
00993 const ClassInfo DOMCSSPrimitiveValue::info = { "CSSPrimitiveValue", 0, &DOMCSSPrimitiveValueTable, 0 };
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008 DEFINE_PROTOTYPE("DOMCSSPrimitiveValue",DOMCSSPrimitiveValueProto)
01009 IMPLEMENT_PROTOFUNC_DOM(DOMCSSPrimitiveValueProtoFunc)
01010 IMPLEMENT_PROTOTYPE(DOMCSSPrimitiveValueProto,DOMCSSPrimitiveValueProtoFunc)
01011
01012 DOMCSSPrimitiveValue::DOMCSSPrimitiveValue(ExecState *exec, const DOM::CSSPrimitiveValue& v)
01013 : DOMCSSValue(DOMCSSPrimitiveValueProto::self(exec), v) { }
01014
01015 Value DOMCSSPrimitiveValue::tryGet(ExecState *exec, const Identifier &p) const
01016 {
01017 if (p=="primitiveType")
01018 return Number(static_cast<DOM::CSSPrimitiveValue>(cssValue).primitiveType());
01019 return DOMObject::tryGet(exec,p);
01020 }
01021
01022 Value DOMCSSPrimitiveValueProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01023 {
01024 KJS_CHECK_THIS( KJS::DOMCSSPrimitiveValue, thisObj );
01025 DOM::CSSPrimitiveValue val = static_cast<DOMCSSPrimitiveValue *>(thisObj.imp())->toCSSPrimitiveValue();
01026 switch (id) {
01027 case DOMCSSPrimitiveValue::SetFloatValue:
01028 val.setFloatValue(args[0].toInteger(exec),args[1].toNumber(exec));
01029 return Undefined();
01030 case DOMCSSPrimitiveValue::GetFloatValue:
01031 return Number(val.getFloatValue(args[0].toInteger(exec)));
01032 case DOMCSSPrimitiveValue::SetStringValue:
01033 val.setStringValue(args[0].toInteger(exec),args[1].toString(exec).string());
01034 return Undefined();
01035 case DOMCSSPrimitiveValue::GetStringValue:
01036 return getString(val.getStringValue());
01037 case DOMCSSPrimitiveValue::GetCounterValue:
01038 return getDOMCounter(exec,val.getCounterValue());
01039 case DOMCSSPrimitiveValue::GetRectValue:
01040 return getDOMRect(exec,val.getRectValue());
01041 case DOMCSSPrimitiveValue::GetRGBColorValue:
01042 return getDOMRGBColor(exec,val.getRGBColorValue());
01043 default:
01044 return Undefined();
01045 }
01046 }
01047
01048
01049
01050 const ClassInfo CSSPrimitiveValueConstructor::info = { "CSSPrimitiveValueConstructor", 0, &CSSPrimitiveValueConstructorTable, 0 };
01051
01052
01053
01054
01055
01056
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 Value CSSPrimitiveValueConstructor::tryGet(ExecState *exec, const Identifier &p) const
01084 {
01085 return DOMObjectLookupGetValue<CSSPrimitiveValueConstructor,CSSValueConstructor>(exec,p,&CSSPrimitiveValueConstructorTable,this);
01086 }
01087
01088 Value CSSPrimitiveValueConstructor::getValueProperty(ExecState *, int token) const
01089 {
01090
01091 return Number(token);
01092 }
01093
01094 Value KJS::getCSSPrimitiveValueConstructor(ExecState *exec)
01095 {
01096 return cacheGlobalObject<CSSPrimitiveValueConstructor>( exec, "[[cssPrimitiveValue.constructor]]" );
01097 }
01098
01099
01100
01101 const ClassInfo DOMCSSValueList::info = { "CSSValueList", 0, &DOMCSSValueListTable, 0 };
01102
01103
01104
01105
01106
01107
01108
01109 IMPLEMENT_PROTOFUNC_DOM(DOMCSSValueListFunc)
01110
01111 DOMCSSValueList::DOMCSSValueList(ExecState *exec, const DOM::CSSValueList& v)
01112 : DOMCSSValue(exec, v) { }
01113
01114 Value DOMCSSValueList::tryGet(ExecState *exec, const Identifier &p) const
01115 {
01116 Value result;
01117 DOM::CSSValueList valueList = static_cast<DOM::CSSValueList>(cssValue);
01118
01119 if (p == lengthPropertyName)
01120 return Number(valueList.length());
01121 else if (p == "item")
01122 return lookupOrCreateFunction<DOMCSSValueListFunc>(exec,p,this,DOMCSSValueList::Item,1,DontDelete|Function);
01123
01124 bool ok;
01125 long unsigned int u = p.toULong(&ok);
01126 if (ok)
01127 return getDOMCSSValue(exec,valueList.item(u));
01128
01129 return DOMCSSValue::tryGet(exec,p);
01130 }
01131
01132 Value DOMCSSValueListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01133 {
01134 KJS_CHECK_THIS( KJS::DOMCSSValueList, thisObj );
01135 DOM::CSSValueList valueList = static_cast<DOMCSSValueList *>(thisObj.imp())->toValueList();
01136 switch (id) {
01137 case DOMCSSValueList::Item:
01138 return getDOMCSSValue(exec,valueList.item(args[0].toInteger(exec)));
01139 default:
01140 return Undefined();
01141 }
01142 }
01143
01144
01145
01146 const ClassInfo DOMRGBColor::info = { "RGBColor", 0, &DOMRGBColorTable, 0 };
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156 DOMRGBColor::DOMRGBColor(ExecState* exec, const DOM::RGBColor& c)
01157 : DOMObject(exec->interpreter()->builtinObjectPrototype()), rgbColor(c)
01158 {
01159 }
01160
01161 DOMRGBColor::~DOMRGBColor()
01162 {
01163
01164 }
01165
01166 Value DOMRGBColor::tryGet(ExecState *exec, const Identifier &p) const
01167 {
01168 return DOMObjectLookupGetValue<DOMRGBColor,DOMObject>(exec, p,
01169 &DOMRGBColorTable,
01170 this);
01171 }
01172
01173 Value DOMRGBColor::getValueProperty(ExecState *exec, int token) const
01174 {
01175 switch (token) {
01176 case Red:
01177 return getDOMCSSValue(exec, rgbColor.red());
01178 case Green:
01179 return getDOMCSSValue(exec, rgbColor.green());
01180 case Blue:
01181 return getDOMCSSValue(exec, rgbColor.blue());
01182 default:
01183 return Value();
01184 }
01185 }
01186
01187 Value KJS::getDOMRGBColor(ExecState *exec, const DOM::RGBColor& c)
01188 {
01189
01190 return Value(new DOMRGBColor(exec, c));
01191 }
01192
01193
01194
01195 const ClassInfo DOMRect::info = { "Rect", 0, &DOMRectTable, 0 };
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205 DOMRect::DOMRect(ExecState *exec, const DOM::Rect& r)
01206 : DOMObject(exec->interpreter()->builtinObjectPrototype()), rect(r)
01207 {
01208 }
01209
01210 DOMRect::~DOMRect()
01211 {
01212 ScriptInterpreter::forgetDOMObject(rect.handle());
01213 }
01214
01215 Value DOMRect::tryGet(ExecState *exec, const Identifier &p) const
01216 {
01217 return DOMObjectLookupGetValue<DOMRect,DOMObject>(exec, p,
01218 &DOMRectTable, this);
01219 }
01220
01221 Value DOMRect::getValueProperty(ExecState *exec, int token) const
01222 {
01223 switch (token) {
01224 case Top:
01225 return getDOMCSSValue(exec, rect.top());
01226 case Right:
01227 return getDOMCSSValue(exec, rect.right());
01228 case Bottom:
01229 return getDOMCSSValue(exec, rect.bottom());
01230 case Left:
01231 return getDOMCSSValue(exec, rect.left());
01232 default:
01233 return Value();
01234 }
01235 }
01236
01237 Value KJS::getDOMRect(ExecState *exec, const DOM::Rect& r)
01238 {
01239 return cacheDOMObject<DOM::Rect, KJS::DOMRect>(exec, r);
01240 }
01241
01242
01243
01244 const ClassInfo DOMCounter::info = { "Counter", 0, &DOMCounterTable, 0 };
01245
01246
01247
01248
01249
01250
01251
01252 DOMCounter::DOMCounter(ExecState *exec, const DOM::Counter& c)
01253 : DOMObject(exec->interpreter()->builtinObjectPrototype()), counter(c)
01254 {
01255 }
01256
01257 DOMCounter::~DOMCounter()
01258 {
01259 ScriptInterpreter::forgetDOMObject(counter.handle());
01260 }
01261
01262 Value DOMCounter::tryGet(ExecState *exec, const Identifier &p) const
01263 {
01264 return DOMObjectLookupGetValue<DOMCounter,DOMObject>(exec, p,
01265 &DOMCounterTable, this);
01266 }
01267
01268 Value DOMCounter::getValueProperty(ExecState *, int token) const
01269 {
01270 switch (token) {
01271 case identifier:
01272 return getString(counter.identifier());
01273 case listStyle:
01274 return getString(counter.listStyle());
01275 case separator:
01276 return getString(counter.separator());
01277 default:
01278 return Value();
01279 }
01280 }
01281
01282 Value KJS::getDOMCounter(ExecState *exec, const DOM::Counter& c)
01283 {
01284 return cacheDOMObject<DOM::Counter, KJS::DOMCounter>(exec, c);
01285 }