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 }