khtml Library API Documentation

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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 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 // Look in the prototype (for functions) before assuming it's a name 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 // 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 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 // 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 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 @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 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 @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 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 @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 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 /*first one*/; 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 @begin DOMCSSRuleListTable 3 00571 length DOMCSSRuleList::Length DontDelete|ReadOnly 00572 item DOMCSSRuleList::Item DontDelete|Function 1 00573 @end 00574 */ 00575 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleListFunc) // not really a proto, but doesn't matter 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) // Not a proto, but doesn't matter 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 @begin DOMCSSRuleTable 4 00664 type DOMCSSRule::Type DontDelete|ReadOnly 00665 cssText DOMCSSRule::CssText DontDelete|ReadOnly 00666 parentStyleSheet DOMCSSRule::ParentStyleSheet DontDelete|ReadOnly 00667 parentRule DOMCSSRule::ParentRule DontDelete|ReadOnly 00668 @end 00669 @begin DOMCSSStyleRuleTable 2 00670 selectorText DOMCSSRule::Style_SelectorText DontDelete 00671 style DOMCSSRule::Style_Style DontDelete|ReadOnly 00672 @end 00673 @begin DOMCSSMediaRuleTable 4 00674 media DOMCSSRule::Media_Media DontDelete|ReadOnly 00675 cssRules DOMCSSRule::Media_CssRules DontDelete|ReadOnly 00676 insertRule DOMCSSRule::Media_InsertRule DontDelete|Function 2 00677 deleteRule DOMCSSRule::Media_DeleteRule DontDelete|Function 1 00678 @end 00679 @begin DOMCSSFontFaceRuleTable 1 00680 style DOMCSSRule::FontFace_Style DontDelete|ReadOnly 00681 @end 00682 @begin DOMCSSPageRuleTable 2 00683 selectorText DOMCSSRule::Page_SelectorText DontDelete 00684 style DOMCSSRule::Page_Style DontDelete|ReadOnly 00685 @end 00686 @begin DOMCSSImportRuleTable 3 00687 href DOMCSSRule::Import_Href DontDelete|ReadOnly 00688 media DOMCSSRule::Import_Media DontDelete|ReadOnly 00689 styleSheet DOMCSSRule::Import_StyleSheet DontDelete|ReadOnly 00690 @end 00691 @begin DOMCSSCharsetRuleTable 1 00692 encoding DOMCSSRule::Charset_Encoding DontDelete 00693 @end 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; // get the right hashtable 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 // Base CSSRule stuff or parent class forward, as usual 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 // for DOM::CSSRule::STYLE_RULE: 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 // for DOM::CSSRule::MEDIA_RULE: 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 // for DOM::CSSRule::FONT_FACE_RULE: 00737 case FontFace_Style: 00738 return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSFontFaceRule>(cssRule).style()); 00739 00740 // for DOM::CSSRule::PAGE_RULE: 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 // for DOM::CSSRule::IMPORT_RULE: 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 // for DOM::CSSRule::CHARSET_RULE: 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; // get the right hashtable 00767 const HashEntry* entry = Lookup::findEntry(table, propertyName); 00768 if (entry) { 00769 if (entry->attr & Function) // function: put as override property 00770 { 00771 ObjectImp::put(exec, propertyName, value, attr); 00772 return; 00773 } 00774 else if ((entry->attr & ReadOnly) == 0) // let DOMObjectLookupPut print the warning if not 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 // for DOM::CSSRule::STYLE_RULE: 00787 case Style_SelectorText: 00788 static_cast<DOM::CSSStyleRule>(cssRule).setSelectorText(value.toString(exec).string()); 00789 return; 00790 00791 // for DOM::CSSRule::PAGE_RULE: 00792 case Page_SelectorText: 00793 static_cast<DOM::CSSPageRule>(cssRule).setSelectorText(value.toString(exec).string()); 00794 return; 00795 00796 // for DOM::CSSRule::CHARSET_RULE: 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 @begin CSSRuleConstructorTable 7 00845 UNKNOWN_RULE CSSRuleConstructor::UNKNOWN_RULE DontDelete|ReadOnly 00846 STYLE_RULE CSSRuleConstructor::STYLE_RULE DontDelete|ReadOnly 00847 CHARSET_RULE CSSRuleConstructor::CHARSET_RULE DontDelete|ReadOnly 00848 IMPORT_RULE CSSRuleConstructor::IMPORT_RULE DontDelete|ReadOnly 00849 MEDIA_RULE CSSRuleConstructor::MEDIA_RULE DontDelete|ReadOnly 00850 FONT_FACE_RULE CSSRuleConstructor::FONT_FACE_RULE DontDelete|ReadOnly 00851 PAGE_RULE CSSRuleConstructor::PAGE_RULE DontDelete|ReadOnly 00852 @end 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 @begin DOMCSSValueTable 2 00897 cssText DOMCSSValue::CssText DontDelete|ReadOnly 00898 cssValueType DOMCSSValue::CssValueType DontDelete|ReadOnly 00899 @end 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 @begin CSSValueConstructorTable 5 00954 CSS_INHERIT CSSValueConstructor::CSS_INHERIT DontDelete|ReadOnly 00955 CSS_PRIMITIVE_VALUE CSSValueConstructor::CSS_PRIMITIVE_VALUE DontDelete|ReadOnly 00956 CSS_VALUE_LIST CSSValueConstructor::CSS_VALUE_LIST DontDelete|ReadOnly 00957 CSS_CUSTOM CSSValueConstructor::CSS_CUSTOM DontDelete|ReadOnly 00958 @end 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 @begin DOMCSSPrimitiveValueTable 1 00996 primitiveType DOMCSSPrimitiveValue::PrimitiveType DontDelete|ReadOnly 00997 @end 00998 @begin DOMCSSPrimitiveValueProtoTable 3 00999 setFloatValue DOMCSSPrimitiveValue::SetFloatValue DontDelete|Function 2 01000 getFloatValue DOMCSSPrimitiveValue::GetFloatValue DontDelete|Function 1 01001 setStringValue DOMCSSPrimitiveValue::SetStringValue DontDelete|Function 2 01002 getStringValue DOMCSSPrimitiveValue::GetStringValue DontDelete|Function 0 01003 getCounterValue DOMCSSPrimitiveValue::GetCounterValue DontDelete|Function 0 01004 getRectValue DOMCSSPrimitiveValue::GetRectValue DontDelete|Function 0 01005 getRGBColorValue DOMCSSPrimitiveValue::GetRGBColorValue DontDelete|Function 0 01006 @end 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 @begin CSSPrimitiveValueConstructorTable 27 01054 CSS_UNKNOWN DOM::CSSPrimitiveValue::CSS_UNKNOWN DontDelete|ReadOnly 01055 CSS_NUMBER DOM::CSSPrimitiveValue::CSS_NUMBER DontDelete|ReadOnly 01056 CSS_PERCENTAGE DOM::CSSPrimitiveValue::CSS_PERCENTAGE DontDelete|ReadOnly 01057 CSS_EMS DOM::CSSPrimitiveValue::CSS_EMS DontDelete|ReadOnly 01058 CSS_EXS DOM::CSSPrimitiveValue::CSS_EXS DontDelete|ReadOnly 01059 CSS_PX DOM::CSSPrimitiveValue::CSS_PX DontDelete|ReadOnly 01060 CSS_CM DOM::CSSPrimitiveValue::CSS_CM DontDelete|ReadOnly 01061 CSS_MM DOM::CSSPrimitiveValue::CSS_MM DontDelete|ReadOnly 01062 CSS_IN DOM::CSSPrimitiveValue::CSS_IN DontDelete|ReadOnly 01063 CSS_PT DOM::CSSPrimitiveValue::CSS_PT DontDelete|ReadOnly 01064 CSS_PC DOM::CSSPrimitiveValue::CSS_PC DontDelete|ReadOnly 01065 CSS_DEG DOM::CSSPrimitiveValue::CSS_DEG DontDelete|ReadOnly 01066 CSS_RAD DOM::CSSPrimitiveValue::CSS_RAD DontDelete|ReadOnly 01067 CSS_GRAD DOM::CSSPrimitiveValue::CSS_GRAD DontDelete|ReadOnly 01068 CSS_MS DOM::CSSPrimitiveValue::CSS_MS DontDelete|ReadOnly 01069 CSS_S DOM::CSSPrimitiveValue::CSS_S DontDelete|ReadOnly 01070 CSS_HZ DOM::CSSPrimitiveValue::CSS_HZ DontDelete|ReadOnly 01071 CSS_KHZ DOM::CSSPrimitiveValue::CSS_KHZ DontDelete|ReadOnly 01072 CSS_DIMENSION DOM::CSSPrimitiveValue::CSS_DIMENSION DontDelete|ReadOnly 01073 CSS_STRING DOM::CSSPrimitiveValue::CSS_STRING DontDelete|ReadOnly 01074 CSS_URI DOM::CSSPrimitiveValue::CSS_URI DontDelete|ReadOnly 01075 CSS_IDENT DOM::CSSPrimitiveValue::CSS_IDENT DontDelete|ReadOnly 01076 CSS_ATTR DOM::CSSPrimitiveValue::CSS_ATTR DontDelete|ReadOnly 01077 CSS_COUNTER DOM::CSSPrimitiveValue::CSS_COUNTER DontDelete|ReadOnly 01078 CSS_RECT DOM::CSSPrimitiveValue::CSS_RECT DontDelete|ReadOnly 01079 CSS_RGBCOLOR DOM::CSSPrimitiveValue::CSS_RGBCOLOR DontDelete|ReadOnly 01080 @end 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 // We use the token as the value to return directly 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 @begin DOMCSSValueListTable 3 01105 length DOMCSSValueList::Length DontDelete|ReadOnly 01106 item DOMCSSValueList::Item DontDelete|Function 1 01107 @end 01108 */ 01109 IMPLEMENT_PROTOFUNC_DOM(DOMCSSValueListFunc) // not really a proto, but doesn't matter 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 @begin DOMRGBColorTable 3 01150 red DOMRGBColor::Red DontDelete|ReadOnly 01151 green DOMRGBColor::Green DontDelete|ReadOnly 01152 blue DOMRGBColor::Blue DontDelete|ReadOnly 01153 @end 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 //rgbColors.remove(rgbColor.handle()); 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 // ### implement equals for RGBColor since they're not refcounted objects 01190 return Value(new DOMRGBColor(exec, c)); 01191 } 01192 01193 // ------------------------------------------------------------------------- 01194 01195 const ClassInfo DOMRect::info = { "Rect", 0, &DOMRectTable, 0 }; 01196 /* 01197 @begin DOMRectTable 4 01198 top DOMRect::Top DontDelete|ReadOnly 01199 right DOMRect::Right DontDelete|ReadOnly 01200 bottom DOMRect::Bottom DontDelete|ReadOnly 01201 left DOMRect::Left DontDelete|ReadOnly 01202 @end 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 @begin DOMCounterTable 3 01247 identifier DOMCounter::identifier DontDelete|ReadOnly 01248 listStyle DOMCounter::listStyle DontDelete|ReadOnly 01249 separator DOMCounter::separator DontDelete|ReadOnly 01250 @end 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 }
KDE Logo
This file is part of the documentation for khtml Library Version 3.3.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sun Oct 17 11:34:00 2004 by doxygen 1.3.8 written by Dimitri van Heesch, © 1997-2003