kjs_css.cpp

00001 // -*- c-basic-offset: 2 -*-
00002 /*
00003  *  This file is part of the KDE libraries
00004  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
00005  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
00006  *  Copyright (C) 2003 Apple Computer, Inc.
00007  *
00008  *  This library is free software; you can redistribute it and/or
00009  *  modify it under the terms of the GNU Library General Public
00010  *  License as published by the Free Software Foundation; either
00011  *  version 2 of the License, or (at your option) any later version.
00012  *
00013  *  This library is distributed in the hope that it will be useful,
00014  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  *  Library General Public License for more details.
00017  *
00018  *  You should have received a copy of the GNU Library General Public
00019  *  License along with this library; if not, write to the Free Software
00020  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00021  */
00022 
00023 #include "kjs_css.h"
00024 #include "kjs_css.lut.h"
00025 
00026 #include <dom/html_head.h> // for HTMLStyleElement
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 @begin DOMCSSStyleDeclarationProtoTable 7
00062   getPropertyValue  DOMCSSStyleDeclaration::GetPropertyValue    DontDelete|Function 1
00063   getPropertyCSSValue   DOMCSSStyleDeclaration::GetPropertyCSSValue DontDelete|Function 1
00064   removeProperty    DOMCSSStyleDeclaration::RemoveProperty      DontDelete|Function 1
00065   getPropertyPriority   DOMCSSStyleDeclaration::GetPropertyPriority DontDelete|Function 1
00066   setProperty       DOMCSSStyleDeclaration::SetProperty     DontDelete|Function 3
00067   item          DOMCSSStyleDeclaration::Item            DontDelete|Function 1
00068 # IE names for it (#36063)
00069   getAttribute          DOMCSSStyleDeclaration::GetPropertyValue    DontDelete|Function 1
00070   removeAttribute       DOMCSSStyleDeclaration::RemoveProperty      DontDelete|Function 1
00071   setAttribute      DOMCSSStyleDeclaration::SetProperty     DontDelete|Function 3
00072 @end
00073 @begin DOMCSSStyleDeclarationTable 3
00074   cssText       DOMCSSStyleDeclaration::CssText     DontDelete
00075   length        DOMCSSStyleDeclaration::Length      DontDelete|ReadOnly
00076   parentRule        DOMCSSStyleDeclaration::ParentRule  DontDelete|ReadOnly
00077 @end
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   // Look in the prototype (for functions) before assuming it's a name
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   // pixelTop returns "CSS Top" as number value in unit pixels
00133   // posTop returns "CSS top" as number value in unit pixels _if_ its a
00134   // positioned element. if it is not a positioned element, return 0
00135   // from MSIE documentation ### IMPLEMENT THAT (Dirk)
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   // see if we know this css property, return empty then
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     // Look whether the property is known.d In that case add it as a CSS property.
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),""); // ### is "" ok for priority?
00185     }
00186     else
00187       // otherwise add it as a JS property
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 @begin DOMStyleSheetTable 7
00230   type      DOMStyleSheet::Type     DontDelete|ReadOnly
00231   disabled  DOMStyleSheet::Disabled     DontDelete
00232   ownerNode DOMStyleSheet::OwnerNode    DontDelete|ReadOnly
00233   parentStyleSheet DOMStyleSheet::ParentStyleSheet  DontDelete|ReadOnly
00234   href      DOMStyleSheet::Href     DontDelete|ReadOnly
00235   title     DOMStyleSheet::Title        DontDelete|ReadOnly
00236   media     DOMStyleSheet::Media        DontDelete|ReadOnly
00237 @end
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 @begin DOMStyleSheetListTable 2
00312   length    DOMStyleSheetList::Length   DontDelete|ReadOnly
00313   item      DOMStyleSheetList::Item     DontDelete|Function 1
00314 @end
00315 */
00316 IMPLEMENT_PROTOFUNC_DOM(DOMStyleSheetListFunc) // not really a proto, but doesn't matter
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   // Retrieve stylesheet by index
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   // IE also supports retrieving a stylesheet by name, using the name/id of the <style> tag
00345   // (this is consistent with all the other collections)
00346 #if 0
00347   // Bad implementation because DOM::StyleSheet doesn't inherit DOM::Node
00348   // so we can't use DOMNamedNodesCollection.....
00349   // We could duplicate it for stylesheets though - worth it ?
00350   // Other problem of this implementation: it doesn't look for the ID attribute!
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 ) // single result
00361       return getDOMStyleSheet(exec, styleSheets[0]);
00362     else if ( styleSheets.count() > 1 ) {
00363       return new DOMNamedItemsCollection(exec,styleSheets);
00364     }
00365   }
00366 #endif
00367   // ### Bad implementation because returns a single element (are IDs always unique?)
00368   // and doesn't look for name attribute (see implementation above).
00369   // But unicity of stylesheet ids is good practice anyway ;)
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   // This code duplication is necessary, DOMStyleSheetList isn't a DOMFunction
00381   Value val;
00382   try {
00383     val = tryCall(exec, thisObj, args);
00384   }
00385   // pity there's no way to distinguish between these in JS code
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 & /*thisObj*/, const List &args)
00394 {
00395   if (args.size() == 1) {
00396     // support for styleSheets(<index>) and styleSheets(<name>)
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   // Can't use the cacheDOMObject macro because of the doc argument
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 @begin DOMMediaListTable 2
00433   mediaText DOMMediaList::MediaText     DontDelete|ReadOnly
00434   length    DOMMediaList::Length        DontDelete|ReadOnly
00435 @end
00436 @begin DOMMediaListProtoTable 3
00437   item      DOMMediaList::Item      DontDelete|Function 1
00438   deleteMedium  DOMMediaList::DeleteMedium  DontDelete|Function 1
00439   appendMedium  DOMMediaList::AppendMedium  DontDelete|Function 1
00440 @end
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 @begin DOMCSSStyleSheetTable 2
00506   ownerRule DOMCSSStyleSheet::OwnerRule DontDelete|ReadOnly
00507   cssRules  DOMCSSStyleSheet::CssRules  DontDelete|ReadOnly
00508 # MSIE extension
00509   rules     DOMCSSStyleSheet::Rules     DontDelete|ReadOnly
00510 @end
00511 @begin DOMCSSStyleSheetProtoTable 2
00512   insertRule    DOMCSSStyleSheet::InsertRule    DontDelete|Function 2
00513   deleteRule    DOMCSSStyleSheet::DeleteRule    DontDelete|Function 1
00514 # IE extensions
00515   addRule   DOMCSSStyleSheet::AddRule   DontDelete|Function 3
00516   removeRule    DOMCSSStyleSheet::RemoveRule    DontDelete|Function 1
00517 @end
00518 */
00519 DEFINE_PROTOTYPE("DOMCSSStyleSheet",DOMCSSStyleSheetProto)
00520 IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleSheetProtoFunc)
00521 IMPLEMENT_PROTOTYPE(DOMCSSStyleSheetProto,DOMCSSStyleSheetProtoFunc) // warning, use _WITH_PARENT if DOMStyleSheet gets a proto
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" /* MSIE extension */)
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     // IE extensions
00552     case DOMCSSStyleSheet::AddRule: {
00553       //Unpassed/-1 means append. Since insertRule is picky (throws exceptions)
00554       //we adjust it to the desired length
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 /*first one*/;
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 @begin DOMCSSRuleListTable 3
00577   length        DOMCSSRuleList::Length      DontDelete|ReadOnly
00578   item          DOMCSSRuleList::Item        DontDelete|Function 1
00579 @end
00580 */
00581 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleListFunc) // not really a proto, but doesn't matter
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) // Not a proto, but doesn't matter
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 @begin DOMCSSRuleTable 4
00670   type          DOMCSSRule::Type    DontDelete|ReadOnly
00671   cssText       DOMCSSRule::CssText DontDelete|ReadOnly
00672   parentStyleSheet  DOMCSSRule::ParentStyleSheet    DontDelete|ReadOnly
00673   parentRule        DOMCSSRule::ParentRule  DontDelete|ReadOnly
00674 @end
00675 @begin DOMCSSStyleRuleTable 2
00676   selectorText      DOMCSSRule::Style_SelectorText  DontDelete
00677   style         DOMCSSRule::Style_Style     DontDelete|ReadOnly
00678 @end
00679 @begin DOMCSSMediaRuleTable 4
00680   media         DOMCSSRule::Media_Media     DontDelete|ReadOnly
00681   cssRules      DOMCSSRule::Media_CssRules  DontDelete|ReadOnly
00682   insertRule        DOMCSSRule::Media_InsertRule    DontDelete|Function 2
00683   deleteRule        DOMCSSRule::Media_DeleteRule    DontDelete|Function 1
00684 @end
00685 @begin DOMCSSFontFaceRuleTable 1
00686   style         DOMCSSRule::FontFace_Style  DontDelete|ReadOnly
00687 @end
00688 @begin DOMCSSPageRuleTable 2
00689   selectorText      DOMCSSRule::Page_SelectorText   DontDelete
00690   style         DOMCSSRule::Page_Style      DontDelete|ReadOnly
00691 @end
00692 @begin DOMCSSImportRuleTable 3
00693   href          DOMCSSRule::Import_Href     DontDelete|ReadOnly
00694   media         DOMCSSRule::Import_Media    DontDelete|ReadOnly
00695   styleSheet        DOMCSSRule::Import_StyleSheet   DontDelete|ReadOnly
00696 @end
00697 @begin DOMCSSCharsetRuleTable 1
00698   encoding      DOMCSSRule::Charset_Encoding    DontDelete
00699 @end
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; // get the right hashtable
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   // Base CSSRule stuff or parent class forward, as usual
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   // for DOM::CSSRule::STYLE_RULE:
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   // for DOM::CSSRule::MEDIA_RULE:
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   // for DOM::CSSRule::FONT_FACE_RULE:
00743   case FontFace_Style:
00744     return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSFontFaceRule>(cssRule).style());
00745 
00746   // for DOM::CSSRule::PAGE_RULE:
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   // for DOM::CSSRule::IMPORT_RULE:
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   // for DOM::CSSRule::CHARSET_RULE:
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; // get the right hashtable
00773   const HashEntry* entry = Lookup::findEntry(table, propertyName);
00774   if (entry) {
00775     if (entry->attr & Function) // function: put as override property
00776     {
00777       ObjectImp::put(exec, propertyName, value, attr);
00778       return;
00779     }
00780     else if ((entry->attr & ReadOnly) == 0) // let DOMObjectLookupPut print the warning if not
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   // for DOM::CSSRule::STYLE_RULE:
00793   case Style_SelectorText:
00794     static_cast<DOM::CSSStyleRule>(cssRule).setSelectorText(value.toString(exec).string());
00795     return;
00796 
00797   // for DOM::CSSRule::PAGE_RULE:
00798   case Page_SelectorText:
00799     static_cast<DOM::CSSPageRule>(cssRule).setSelectorText(value.toString(exec).string());
00800     return;
00801 
00802   // for DOM::CSSRule::CHARSET_RULE:
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 @begin CSSRuleConstructorTable 7
00851   UNKNOWN_RULE  CSSRuleConstructor::UNKNOWN_RULE    DontDelete|ReadOnly
00852   STYLE_RULE    CSSRuleConstructor::STYLE_RULE      DontDelete|ReadOnly
00853   CHARSET_RULE  CSSRuleConstructor::CHARSET_RULE    DontDelete|ReadOnly
00854   IMPORT_RULE   CSSRuleConstructor::IMPORT_RULE     DontDelete|ReadOnly
00855   MEDIA_RULE    CSSRuleConstructor::MEDIA_RULE      DontDelete|ReadOnly
00856   FONT_FACE_RULE CSSRuleConstructor::FONT_FACE_RULE DontDelete|ReadOnly
00857   PAGE_RULE CSSRuleConstructor::PAGE_RULE       DontDelete|ReadOnly
00858 @end
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 @begin DOMCSSValueTable 2
00903   cssText   DOMCSSValue::CssText        DontDelete|ReadOnly
00904   cssValueType  DOMCSSValue::CssValueType   DontDelete|ReadOnly
00905 @end
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 @begin CSSValueConstructorTable 5
00960   CSS_INHERIT       CSSValueConstructor::CSS_INHERIT        DontDelete|ReadOnly
00961   CSS_PRIMITIVE_VALUE   CSSValueConstructor::CSS_PRIMITIVE_VALUE    DontDelete|ReadOnly
00962   CSS_VALUE_LIST    CSSValueConstructor::CSS_VALUE_LIST     DontDelete|ReadOnly
00963   CSS_CUSTOM        CSSValueConstructor::CSS_CUSTOM         DontDelete|ReadOnly
00964 @end
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 @begin DOMCSSPrimitiveValueTable 1
01002   primitiveType     DOMCSSPrimitiveValue::PrimitiveType DontDelete|ReadOnly
01003 @end
01004 @begin DOMCSSPrimitiveValueProtoTable 3
01005   setFloatValue     DOMCSSPrimitiveValue::SetFloatValue DontDelete|Function 2
01006   getFloatValue     DOMCSSPrimitiveValue::GetFloatValue DontDelete|Function 1
01007   setStringValue    DOMCSSPrimitiveValue::SetStringValue    DontDelete|Function 2
01008   getStringValue    DOMCSSPrimitiveValue::GetStringValue    DontDelete|Function 0
01009   getCounterValue   DOMCSSPrimitiveValue::GetCounterValue   DontDelete|Function 0
01010   getRectValue      DOMCSSPrimitiveValue::GetRectValue  DontDelete|Function 0
01011   getRGBColorValue  DOMCSSPrimitiveValue::GetRGBColorValue  DontDelete|Function 0
01012 @end
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 @begin CSSPrimitiveValueConstructorTable 27
01060   CSS_UNKNOWN       DOM::CSSPrimitiveValue::CSS_UNKNOWN DontDelete|ReadOnly
01061   CSS_NUMBER        DOM::CSSPrimitiveValue::CSS_NUMBER  DontDelete|ReadOnly
01062   CSS_PERCENTAGE    DOM::CSSPrimitiveValue::CSS_PERCENTAGE  DontDelete|ReadOnly
01063   CSS_EMS           DOM::CSSPrimitiveValue::CSS_EMS     DontDelete|ReadOnly
01064   CSS_EXS           DOM::CSSPrimitiveValue::CSS_EXS     DontDelete|ReadOnly
01065   CSS_PX            DOM::CSSPrimitiveValue::CSS_PX      DontDelete|ReadOnly
01066   CSS_CM            DOM::CSSPrimitiveValue::CSS_CM      DontDelete|ReadOnly
01067   CSS_MM            DOM::CSSPrimitiveValue::CSS_MM      DontDelete|ReadOnly
01068   CSS_IN            DOM::CSSPrimitiveValue::CSS_IN      DontDelete|ReadOnly
01069   CSS_PT            DOM::CSSPrimitiveValue::CSS_PT      DontDelete|ReadOnly
01070   CSS_PC            DOM::CSSPrimitiveValue::CSS_PC      DontDelete|ReadOnly
01071   CSS_DEG           DOM::CSSPrimitiveValue::CSS_DEG     DontDelete|ReadOnly
01072   CSS_RAD           DOM::CSSPrimitiveValue::CSS_RAD     DontDelete|ReadOnly
01073   CSS_GRAD          DOM::CSSPrimitiveValue::CSS_GRAD    DontDelete|ReadOnly
01074   CSS_MS            DOM::CSSPrimitiveValue::CSS_MS      DontDelete|ReadOnly
01075   CSS_S         DOM::CSSPrimitiveValue::CSS_S       DontDelete|ReadOnly
01076   CSS_HZ            DOM::CSSPrimitiveValue::CSS_HZ      DontDelete|ReadOnly
01077   CSS_KHZ           DOM::CSSPrimitiveValue::CSS_KHZ     DontDelete|ReadOnly
01078   CSS_DIMENSION     DOM::CSSPrimitiveValue::CSS_DIMENSION   DontDelete|ReadOnly
01079   CSS_STRING        DOM::CSSPrimitiveValue::CSS_STRING  DontDelete|ReadOnly
01080   CSS_URI           DOM::CSSPrimitiveValue::CSS_URI     DontDelete|ReadOnly
01081   CSS_IDENT         DOM::CSSPrimitiveValue::CSS_IDENT   DontDelete|ReadOnly
01082   CSS_ATTR          DOM::CSSPrimitiveValue::CSS_ATTR    DontDelete|ReadOnly
01083   CSS_COUNTER       DOM::CSSPrimitiveValue::CSS_COUNTER DontDelete|ReadOnly
01084   CSS_RECT          DOM::CSSPrimitiveValue::CSS_RECT    DontDelete|ReadOnly
01085   CSS_RGBCOLOR      DOM::CSSPrimitiveValue::CSS_RGBCOLOR    DontDelete|ReadOnly
01086 @end
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   // We use the token as the value to return directly
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 @begin DOMCSSValueListTable 3
01111   length        DOMCSSValueList::Length     DontDelete|ReadOnly
01112   item          DOMCSSValueList::Item       DontDelete|Function 1
01113 @end
01114 */
01115 IMPLEMENT_PROTOFUNC_DOM(DOMCSSValueListFunc) // not really a proto, but doesn't matter
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 @begin DOMRGBColorTable 3
01156   red   DOMRGBColor::Red    DontDelete|ReadOnly
01157   green DOMRGBColor::Green  DontDelete|ReadOnly
01158   blue  DOMRGBColor::Blue   DontDelete|ReadOnly
01159 @end
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   //rgbColors.remove(rgbColor.handle());
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   // ### implement equals for RGBColor since they're not refcounted objects
01196   return Value(new DOMRGBColor(exec, c));
01197 }
01198 
01199 // -------------------------------------------------------------------------
01200 
01201 const ClassInfo DOMRect::info = { "Rect", 0, &DOMRectTable, 0 };
01202 /*
01203 @begin DOMRectTable 4
01204   top   DOMRect::Top    DontDelete|ReadOnly
01205   right DOMRect::Right  DontDelete|ReadOnly
01206   bottom DOMRect::Bottom DontDelete|ReadOnly
01207   left  DOMRect::Left   DontDelete|ReadOnly
01208 @end
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 @begin DOMCounterTable 3
01253   identifier    DOMCounter::identifier  DontDelete|ReadOnly
01254   listStyle DOMCounter::listStyle   DontDelete|ReadOnly
01255   separator DOMCounter::separator   DontDelete|ReadOnly
01256 @end
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 }
KDE Home | KDE Accessibility Home | Description of Access Keys