diff options
Diffstat (limited to 'tdehtml/ecma/kjs_css.cpp')
| -rw-r--r-- | tdehtml/ecma/kjs_css.cpp | 1302 |
1 files changed, 1302 insertions, 0 deletions
diff --git a/tdehtml/ecma/kjs_css.cpp b/tdehtml/ecma/kjs_css.cpp new file mode 100644 index 000000000..b42f9dd02 --- /dev/null +++ b/tdehtml/ecma/kjs_css.cpp @@ -0,0 +1,1302 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * Copyright (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "kjs_css.h" +#include "kjs_css.lut.h" + +#include <dom/html_head.h> // for HTMLStyleElement + +#include <css/css_base.h> +#include "kjs_dom.h" + + +#include <kdebug.h> + +namespace KJS { + +static TQString cssPropertyName( const Identifier &p, bool& hadPixelPrefix ) +{ + TQString prop = p.qstring(); + int i = prop.length(); + while ( --i ) { + char c = prop[i].latin1(); + if ( c >= 'A' && c <= 'Z' ) + prop.insert( i, '-' ); + } + + prop = prop.lower(); + hadPixelPrefix = false; + + if (prop.startsWith("css-")) { + prop = prop.mid(4); + } else if (prop.startsWith("pixel-")) { + prop = prop.mid(6); + hadPixelPrefix = true; + } else if (prop.startsWith("pos-")) { + prop = prop.mid(4); + hadPixelPrefix = true; + } + + return prop; +} + +/* +@begin DOMCSSStyleDeclarationProtoTable 7 + getPropertyValue DOMCSSStyleDeclaration::GetPropertyValue DontDelete|Function 1 + getPropertyCSSValue DOMCSSStyleDeclaration::GetPropertyCSSValue DontDelete|Function 1 + removeProperty DOMCSSStyleDeclaration::RemoveProperty DontDelete|Function 1 + getPropertyPriority DOMCSSStyleDeclaration::GetPropertyPriority DontDelete|Function 1 + setProperty DOMCSSStyleDeclaration::SetProperty DontDelete|Function 3 + item DOMCSSStyleDeclaration::Item DontDelete|Function 1 +# IE names for it (#36063) + getAttribute DOMCSSStyleDeclaration::GetPropertyValue DontDelete|Function 1 + removeAttribute DOMCSSStyleDeclaration::RemoveProperty DontDelete|Function 1 + setAttribute DOMCSSStyleDeclaration::SetProperty DontDelete|Function 3 +@end +@begin DOMCSSStyleDeclarationTable 3 + cssText DOMCSSStyleDeclaration::CssText DontDelete + length DOMCSSStyleDeclaration::Length DontDelete|ReadOnly + parentRule DOMCSSStyleDeclaration::ParentRule DontDelete|ReadOnly +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMCSSStyleDeclarationProto) +IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleDeclarationProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMCSSStyleDeclaration", DOMCSSStyleDeclarationProto, DOMCSSStyleDeclarationProtoFunc) + +IMPLEMENT_PSEUDO_CONSTRUCTOR(CSSStyleDeclarationPseudoCtor, "DOMCSSStyleDeclaration",DOMCSSStyleDeclarationProto) + +const ClassInfo DOMCSSStyleDeclaration::info = { "CSSStyleDeclaration", 0, &DOMCSSStyleDeclarationTable, 0 }; + +DOMCSSStyleDeclaration::DOMCSSStyleDeclaration(ExecState *exec, const DOM::CSSStyleDeclaration& s) + : DOMObject(DOMCSSStyleDeclarationProto::self(exec)), styleDecl(s) +{ } + +DOMCSSStyleDeclaration::~DOMCSSStyleDeclaration() +{ + ScriptInterpreter::forgetDOMObject(styleDecl.handle()); +} + +bool DOMCSSStyleDeclaration::hasProperty(ExecState *exec, const Identifier &p) const +{ + bool hadPixelPrefix; + TQString cssprop = cssPropertyName(p, hadPixelPrefix); + if (DOM::getPropertyID(cssprop.latin1(), cssprop.length())) + return true; + + return ObjectImp::hasProperty(exec, p); +} + +Value DOMCSSStyleDeclaration::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMCSSStyleDeclaration::tryGet " << propertyName.qstring() << endl; +#endif + const HashEntry* entry = Lookup::findEntry(&DOMCSSStyleDeclarationTable, propertyName); + if (entry) + switch (entry->value) { + case CssText: + return String(styleDecl.cssText()); + case Length: + return Number(styleDecl.length()); + case ParentRule: + return getDOMCSSRule(exec,styleDecl.parentRule()); + default: + break; + } + + // Look in the prototype (for functions) before assuming it's a name + Object proto = Object::dynamicCast(prototype()); + if (proto.isValid() && proto.hasProperty(exec,propertyName)) + return proto.get(exec,propertyName); + + bool ok; + long unsigned int u = propertyName.toULong(&ok); + if (ok) + return String(DOM::CSSStyleDeclaration(styleDecl).item(u)); + + // pixelTop returns "CSS Top" as number value in unit pixels + // posTop returns "CSS top" as number value in unit pixels _if_ its a + // positioned element. if it is not a positioned element, return 0 + // from MSIE documentation ### IMPLEMENT THAT (Dirk) + bool asNumber; + TQString p = cssPropertyName(propertyName, asNumber); + +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMCSSStyleDeclaration: converting to css property name: " << p << ( asNumber ? "px" : "" ) << endl; +#endif + + if (asNumber) { + DOM::CSSValue v = styleDecl.getPropertyCSSValue(p); + if ( !v.isNull() && v.cssValueType() == DOM::CSSValue::CSS_PRIMITIVE_VALUE) + return Number(static_cast<DOM::CSSPrimitiveValue>(v).getFloatValue(DOM::CSSPrimitiveValue::CSS_PX)); + } + + DOM::DOMString str = const_cast<DOM::CSSStyleDeclaration &>( styleDecl ).getPropertyValue(p); + if (!str.isNull()) + return String(str); + + // see if we know this css property, return empty then + if (DOM::getPropertyID(p.latin1(), p.length())) + return String(DOM::DOMString("")); + + return DOMObject::tryGet(exec, propertyName); +} + + +void DOMCSSStyleDeclaration::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr ) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMCSSStyleDeclaration::tryPut " << propertyName.qstring() << endl; +#endif + if (propertyName == "cssText") { + styleDecl.setCssText(value.toString(exec).string()); + } + else { + bool pxSuffix; + TQString prop = cssPropertyName(propertyName, pxSuffix); + TQString propvalue = value.toString(exec).qstring(); + + if (pxSuffix) + propvalue += "px"; +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMCSSStyleDeclaration: prop=" << prop << " propvalue=" << propvalue << endl; +#endif + // Look whether the property is known.d In that case add it as a CSS property. + if (DOM::getPropertyID(prop.latin1(), prop.length())) { + if (propvalue.isEmpty()) + styleDecl.removeProperty(prop); + else { + int important = propvalue.find("!important", 0, false); + if (important == -1) + styleDecl.setProperty(prop, DOM::DOMString(propvalue), ""); + else + styleDecl.setProperty(prop, DOM::DOMString(propvalue.left(important - 1)), "important"); + } + } + else + // otherwise add it as a JS property + DOMObject::tryPut( exec, propertyName, value, attr ); + } +} + +Value DOMCSSStyleDeclarationProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCSSStyleDeclaration, thisObj ); + DOM::CSSStyleDeclaration styleDecl = static_cast<DOMCSSStyleDeclaration *>(thisObj.imp())->toStyleDecl(); + String str = args[0].toString(exec); + DOM::DOMString s = str.value().string(); + + switch (id) { + case DOMCSSStyleDeclaration::GetPropertyValue: + return String(styleDecl.getPropertyValue(s)); + case DOMCSSStyleDeclaration::GetPropertyCSSValue: + return getDOMCSSValue(exec,styleDecl.getPropertyCSSValue(s)); + case DOMCSSStyleDeclaration::RemoveProperty: + return String(styleDecl.removeProperty(s)); + case DOMCSSStyleDeclaration::GetPropertyPriority: + return String(styleDecl.getPropertyPriority(s)); + case DOMCSSStyleDeclaration::SetProperty: + styleDecl.setProperty(args[0].toString(exec).string(), + args[1].toString(exec).string(), + args[2].toString(exec).string()); + return Undefined(); + case DOMCSSStyleDeclaration::Item: + return String(styleDecl.item(args[0].toInteger(exec))); + default: + return Undefined(); + } +} + +Value getDOMCSSStyleDeclaration(ExecState *exec, const DOM::CSSStyleDeclaration& s) +{ + return cacheDOMObject<DOM::CSSStyleDeclaration, KJS::DOMCSSStyleDeclaration>(exec, s); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMStyleSheet::info = { "StyleSheet", 0, &DOMStyleSheetTable, 0 }; +/* +@begin DOMStyleSheetTable 7 + type DOMStyleSheet::Type DontDelete|ReadOnly + disabled DOMStyleSheet::Disabled DontDelete + ownerNode DOMStyleSheet::OwnerNode DontDelete|ReadOnly + parentStyleSheet DOMStyleSheet::ParentStyleSheet DontDelete|ReadOnly + href DOMStyleSheet::Href DontDelete|ReadOnly + title DOMStyleSheet::Title DontDelete|ReadOnly + media DOMStyleSheet::Media DontDelete|ReadOnly +@end +*/ + +DOMStyleSheet::DOMStyleSheet(ExecState* exec, const DOM::StyleSheet& ss) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), styleSheet(ss) +{ +} + +DOMStyleSheet::~DOMStyleSheet() +{ + ScriptInterpreter::forgetDOMObject(styleSheet.handle()); +} + +Value DOMStyleSheet::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + return DOMObjectLookupGetValue<DOMStyleSheet,DOMObject>(exec,propertyName,&DOMStyleSheetTable,this); +} + +Value DOMStyleSheet::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Type: + return String(styleSheet.type()); + case Disabled: + return Boolean(styleSheet.disabled()); + case OwnerNode: + return getDOMNode(exec,styleSheet.ownerNode()); + case ParentStyleSheet: + return getDOMStyleSheet(exec,styleSheet.parentStyleSheet()); + case Href: + return String(styleSheet.href()); + case Title: + return String(styleSheet.title()); + case Media: + return getDOMMediaList(exec, styleSheet.media()); + } + return Value(); +} + +void DOMStyleSheet::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + if (propertyName == "disabled") { + styleSheet.setDisabled(value.toBoolean(exec)); + } + else + DOMObject::tryPut(exec, propertyName, value, attr); +} + +Value getDOMStyleSheet(ExecState *exec, const DOM::StyleSheet& ss) +{ + DOMObject *ret; + if (ss.isNull()) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + if ((ret = interp->getDOMObject(ss.handle()))) + return Value(ret); + else { + if (ss.isCSSStyleSheet()) { + DOM::CSSStyleSheet cs; + cs = ss; + ret = new DOMCSSStyleSheet(exec,cs); + } + else + ret = new DOMStyleSheet(exec,ss); + interp->putDOMObject(ss.handle(),ret); + return Value(ret); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMStyleSheetList::info = { "StyleSheetList", 0, &DOMStyleSheetListTable, 0 }; + +/* +@begin DOMStyleSheetListTable 2 + length DOMStyleSheetList::Length DontDelete|ReadOnly + item DOMStyleSheetList::Item DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMStyleSheetListFunc) // not really a proto, but doesn't matter + +DOMStyleSheetList::DOMStyleSheetList(ExecState *exec, const DOM::StyleSheetList& ssl, const DOM::Document& doc) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), styleSheetList(ssl), m_doc(doc) +{ +} + +DOMStyleSheetList::~DOMStyleSheetList() +{ + ScriptInterpreter::forgetDOMObject(styleSheetList.handle()); +} + +Value DOMStyleSheetList::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMStyleSheetList::tryGet " << p.qstring() << endl; +#endif + if (p == lengthPropertyName) + return Number(styleSheetList.length()); + else if (p == "item") + return lookupOrCreateFunction<DOMStyleSheetListFunc>(exec,p,this,DOMStyleSheetList::Item,1,DontDelete|Function); + + // Retrieve stylesheet by index + bool ok; + long unsigned int u = p.toULong(&ok); + if (ok) + return getDOMStyleSheet(exec, DOM::StyleSheetList(styleSheetList).item(u)); + + // IE also supports retrieving a stylesheet by name, using the name/id of the <style> tag + // (this is consistent with all the other collections) +#if 0 + // Bad implementation because DOM::StyleSheet doesn't inherit DOM::Node + // so we can't use DOMNamedNodesCollection..... + // We could duplicate it for stylesheets though - worth it ? + // Other problem of this implementation: it doesn't look for the ID attribute! + DOM::NameNodeListImpl namedList( m_doc.documentElement().handle(), p.string() ); + int len = namedList.length(); + if ( len ) { + TQValueList<DOM::Node> styleSheets; + for ( int i = 0 ; i < len ; ++i ) { + DOM::HTMLStyleElement elem = DOM::Node(namedList.item(i)); + if (!elem.isNull()) + styleSheets.append(elem.sheet()); + } + if ( styleSheets.count() == 1 ) // single result + return getDOMStyleSheet(exec, styleSheets[0]); + else if ( styleSheets.count() > 1 ) { + return new DOMNamedItemsCollection(exec,styleSheets); + } + } +#endif + // ### Bad implementation because returns a single element (are IDs always unique?) + // and doesn't look for name attribute (see implementation above). + // But unicity of stylesheet ids is good practice anyway ;) + DOM::DOMString pstr = p.string(); + DOM::HTMLStyleElement styleElem = m_doc.getElementById( pstr ); + if (!styleElem.isNull()) + return getDOMStyleSheet(exec, styleElem.sheet()); + + return DOMObject::tryGet(exec, p); +} + +Value KJS::DOMStyleSheetList::call(ExecState *exec, Object &thisObj, const List &args) +{ + // This code duplication is necessary, DOMStyleSheetList isn't a DOMFunction + Value val; + try { + val = tryCall(exec, thisObj, args); + } + // pity there's no way to distinguish between these in JS code + catch (...) { + Object err = Error::create(exec, GeneralError, "Exception from DOMStyleSheetList"); + exec->setException(err); + } + return val; +} + +Value DOMStyleSheetList::tryCall(ExecState *exec, Object & /*thisObj*/, const List &args) +{ + if (args.size() == 1) { + // support for styleSheets(<index>) and styleSheets(<name>) + return tryGet( exec, Identifier(args[0].toString(exec)) ); + } + return Undefined(); +} + +Value getDOMStyleSheetList(ExecState *exec, const DOM::StyleSheetList& ssl, const DOM::Document& doc) +{ + // Can't use the cacheDOMObject macro because of the doc argument + DOMObject *ret; + if (ssl.isNull()) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + if ((ret = interp->getDOMObject(ssl.handle()))) + return Value(ret); + else { + ret = new DOMStyleSheetList(exec, ssl, doc); + interp->putDOMObject(ssl.handle(),ret); + return Value(ret); + } +} + +Value DOMStyleSheetListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMStyleSheetList, thisObj ); + DOM::StyleSheetList styleSheetList = static_cast<DOMStyleSheetList *>(thisObj.imp())->toStyleSheetList(); + if (id == DOMStyleSheetList::Item) + return getDOMStyleSheet(exec, styleSheetList.item(args[0].toInteger(exec))); + return Undefined(); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMMediaList::info = { "MediaList", 0, &DOMMediaListTable, 0 }; + +/* +@begin DOMMediaListTable 2 + mediaText DOMMediaList::MediaText DontDelete|ReadOnly + length DOMMediaList::Length DontDelete|ReadOnly +@end +@begin DOMMediaListProtoTable 3 + item DOMMediaList::Item DontDelete|Function 1 + deleteMedium DOMMediaList::DeleteMedium DontDelete|Function 1 + appendMedium DOMMediaList::AppendMedium DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMMediaListProto) +IMPLEMENT_PROTOFUNC_DOM(DOMMediaListProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMMediaList", DOMMediaListProto, DOMMediaListProtoFunc) + +DOMMediaList::DOMMediaList(ExecState *exec, const DOM::MediaList& ml) + : DOMObject(DOMMediaListProto::self(exec)), mediaList(ml) { } + +DOMMediaList::~DOMMediaList() +{ + ScriptInterpreter::forgetDOMObject(mediaList.handle()); +} + +Value DOMMediaList::tryGet(ExecState *exec, const Identifier &p) const +{ + if (p == "mediaText") + return String(mediaList.mediaText()); + else if (p == lengthPropertyName) + return Number(mediaList.length()); + + bool ok; + long unsigned int u = p.toULong(&ok); + if (ok) + return String(mediaList.item(u)); + + return DOMObject::tryGet(exec, p); +} + +void DOMMediaList::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + if (propertyName == "mediaText") + mediaList.setMediaText(value.toString(exec).string()); + else + DOMObject::tryPut(exec, propertyName, value, attr); +} + +Value getDOMMediaList(ExecState *exec, const DOM::MediaList& ml) +{ + return cacheDOMObject<DOM::MediaList, KJS::DOMMediaList>(exec, ml); +} + +Value KJS::DOMMediaListProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMMediaList, thisObj ); + DOM::MediaList mediaList = static_cast<DOMMediaList *>(thisObj.imp())->toMediaList(); + switch (id) { + case DOMMediaList::Item: + return String(mediaList.item(args[0].toInteger(exec))); + case DOMMediaList::DeleteMedium: + mediaList.deleteMedium(args[0].toString(exec).string()); + return Undefined(); + case DOMMediaList::AppendMedium: + mediaList.appendMedium(args[0].toString(exec).string()); + return Undefined(); + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCSSStyleSheet::info = { "CSSStyleSheet", 0, &DOMCSSStyleSheetTable, 0 }; + +/* +@begin DOMCSSStyleSheetTable 2 + ownerRule DOMCSSStyleSheet::OwnerRule DontDelete|ReadOnly + cssRules DOMCSSStyleSheet::CssRules DontDelete|ReadOnly +# MSIE extension + rules DOMCSSStyleSheet::Rules DontDelete|ReadOnly +@end +@begin DOMCSSStyleSheetProtoTable 2 + insertRule DOMCSSStyleSheet::InsertRule DontDelete|Function 2 + deleteRule DOMCSSStyleSheet::DeleteRule DontDelete|Function 1 +# IE extensions + addRule DOMCSSStyleSheet::AddRule DontDelete|Function 3 + removeRule DOMCSSStyleSheet::RemoveRule DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMCSSStyleSheetProto) +IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleSheetProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMCSSStyleSheet",DOMCSSStyleSheetProto,DOMCSSStyleSheetProtoFunc) // warning, use _WITH_PARENT if DOMStyleSheet gets a proto + +DOMCSSStyleSheet::DOMCSSStyleSheet(ExecState *exec, const DOM::CSSStyleSheet& ss) + : DOMStyleSheet(DOMCSSStyleSheetProto::self(exec),ss) { } + +DOMCSSStyleSheet::~DOMCSSStyleSheet() +{ +} + +Value DOMCSSStyleSheet::tryGet(ExecState *exec, const Identifier &p) const +{ + DOM::CSSStyleSheet cssStyleSheet = static_cast<DOM::CSSStyleSheet>(styleSheet); + if (p == "ownerRule") + return getDOMCSSRule(exec,cssStyleSheet.ownerRule()); + else if (p == "cssRules" || p == "rules" /* MSIE extension */) + return getDOMCSSRuleList(exec,cssStyleSheet.cssRules()); + return DOMStyleSheet::tryGet(exec,p); +} + +Value DOMCSSStyleSheetProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCSSStyleSheet, thisObj ); + DOM::CSSStyleSheet styleSheet = static_cast<DOMCSSStyleSheet *>(thisObj.imp())->toCSSStyleSheet(); + + switch (id) { + case DOMCSSStyleSheet::InsertRule: + return Number(styleSheet.insertRule(args[0].toString(exec).string(),(long unsigned int)args[1].toInteger(exec))); + case DOMCSSStyleSheet::DeleteRule: + styleSheet.deleteRule(args[0].toInteger(exec)); + return Undefined(); + // IE extensions + case DOMCSSStyleSheet::AddRule: { + //Unpassed/-1 means append. Since insertRule is picky (throws exceptions) + //we adjust it to the desired length + unsigned long index = args[2].toInteger(exec); + unsigned long length = styleSheet.cssRules().length(); + if (args[2].type() == UndefinedType) index = length; + if (index > length) index = length; + DOM::DOMString str = args[0].toString(exec).string() + " { " + args[1].toString(exec).string() + " } "; + return Number(styleSheet.insertRule(str,index)); + } + case DOMCSSStyleSheet::RemoveRule: { + int index = args.size() > 0 ? args[0].toInteger(exec) : 0 /*first one*/; + styleSheet.deleteRule(index); + return Undefined(); + } + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCSSRuleList::info = { "CSSRuleList", 0, &DOMCSSRuleListTable, 0 }; +/* +@begin DOMCSSRuleListTable 3 + length DOMCSSRuleList::Length DontDelete|ReadOnly + item DOMCSSRuleList::Item DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleListFunc) // not really a proto, but doesn't matter + +DOMCSSRuleList::DOMCSSRuleList(ExecState* exec, const DOM::CSSRuleList& rl) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRuleList(rl) +{ +} + +DOMCSSRuleList::~DOMCSSRuleList() +{ + ScriptInterpreter::forgetDOMObject(cssRuleList.handle()); +} + +Value DOMCSSRuleList::tryGet(ExecState *exec, const Identifier &p) const +{ + Value result; + if (p == lengthPropertyName) + return Number(cssRuleList.length()); + else if (p == "item") + return lookupOrCreateFunction<DOMCSSRuleListFunc>(exec,p,this,DOMCSSRuleList::Item,1,DontDelete|Function); + + bool ok; + long unsigned int u = p.toULong(&ok); + if (ok) + return getDOMCSSRule(exec,DOM::CSSRuleList(cssRuleList).item(u)); + + return DOMObject::tryGet(exec,p); +} + +Value DOMCSSRuleListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCSSRuleList, thisObj ); + DOM::CSSRuleList cssRuleList = static_cast<DOMCSSRuleList *>(thisObj.imp())->toCSSRuleList(); + switch (id) { + case DOMCSSRuleList::Item: + return getDOMCSSRule(exec,cssRuleList.item(args[0].toInteger(exec))); + default: + return Undefined(); + } +} + +Value getDOMCSSRuleList(ExecState *exec, const DOM::CSSRuleList& rl) +{ + return cacheDOMObject<DOM::CSSRuleList, KJS::DOMCSSRuleList>(exec, rl); +} + +// ------------------------------------------------------------------------- + +IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleFunc) // Not a proto, but doesn't matter + +DOMCSSRule::DOMCSSRule(ExecState* exec, const DOM::CSSRule& r) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRule(r) +{ +} + +DOMCSSRule::~DOMCSSRule() +{ + ScriptInterpreter::forgetDOMObject(cssRule.handle()); +} + +const ClassInfo DOMCSSRule::info = { "CSSRule", 0, &DOMCSSRuleTable, 0 }; +const ClassInfo DOMCSSRule::style_info = { "CSSStyleRule", &DOMCSSRule::info, &DOMCSSStyleRuleTable, 0 }; +const ClassInfo DOMCSSRule::media_info = { "CSSMediaRule", &DOMCSSRule::info, &DOMCSSMediaRuleTable, 0 }; +const ClassInfo DOMCSSRule::fontface_info = { "CSSFontFaceRule", &DOMCSSRule::info, &DOMCSSFontFaceRuleTable, 0 }; +const ClassInfo DOMCSSRule::page_info = { "CSSPageRule", &DOMCSSRule::info, &DOMCSSPageRuleTable, 0 }; +const ClassInfo DOMCSSRule::import_info = { "CSSImportRule", &DOMCSSRule::info, &DOMCSSImportRuleTable, 0 }; +const ClassInfo DOMCSSRule::charset_info = { "CSSCharsetRule", &DOMCSSRule::info, &DOMCSSCharsetRuleTable, 0 }; + +const ClassInfo* DOMCSSRule::classInfo() const +{ + switch (cssRule.type()) { + case DOM::CSSRule::STYLE_RULE: + return &style_info; + case DOM::CSSRule::MEDIA_RULE: + return &media_info; + case DOM::CSSRule::FONT_FACE_RULE: + return &fontface_info; + case DOM::CSSRule::PAGE_RULE: + return &page_info; + case DOM::CSSRule::IMPORT_RULE: + return &import_info; + case DOM::CSSRule::CHARSET_RULE: + return &charset_info; + case DOM::CSSRule::UNKNOWN_RULE: + default: + return &info; + } +} +/* +@begin DOMCSSRuleTable 4 + type DOMCSSRule::Type DontDelete|ReadOnly + cssText DOMCSSRule::CssText DontDelete|ReadOnly + parentStyleSheet DOMCSSRule::ParentStyleSheet DontDelete|ReadOnly + parentRule DOMCSSRule::ParentRule DontDelete|ReadOnly +@end +@begin DOMCSSStyleRuleTable 2 + selectorText DOMCSSRule::Style_SelectorText DontDelete + style DOMCSSRule::Style_Style DontDelete|ReadOnly +@end +@begin DOMCSSMediaRuleTable 4 + media DOMCSSRule::Media_Media DontDelete|ReadOnly + cssRules DOMCSSRule::Media_CssRules DontDelete|ReadOnly + insertRule DOMCSSRule::Media_InsertRule DontDelete|Function 2 + deleteRule DOMCSSRule::Media_DeleteRule DontDelete|Function 1 +@end +@begin DOMCSSFontFaceRuleTable 1 + style DOMCSSRule::FontFace_Style DontDelete|ReadOnly +@end +@begin DOMCSSPageRuleTable 2 + selectorText DOMCSSRule::Page_SelectorText DontDelete + style DOMCSSRule::Page_Style DontDelete|ReadOnly +@end +@begin DOMCSSImportRuleTable 3 + href DOMCSSRule::Import_Href DontDelete|ReadOnly + media DOMCSSRule::Import_Media DontDelete|ReadOnly + styleSheet DOMCSSRule::Import_StyleSheet DontDelete|ReadOnly +@end +@begin DOMCSSCharsetRuleTable 1 + encoding DOMCSSRule::Charset_Encoding DontDelete +@end +*/ +Value DOMCSSRule::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMCSSRule::tryGet " << propertyName.qstring() << endl; +#endif + const HashTable* table = classInfo()->propHashTable; // get the right hashtable + const HashEntry* entry = Lookup::findEntry(table, propertyName); + if (entry) { + if (entry->attr & Function) + return lookupOrCreateFunction<DOMCSSRuleFunc>(exec, propertyName, this, entry->value, entry->params, entry->attr); + return getValueProperty(exec, entry->value); + } + + // Base CSSRule stuff or parent class forward, as usual + return DOMObjectLookupGet<DOMCSSRuleFunc, DOMCSSRule, DOMObject>(exec, propertyName, &DOMCSSRuleTable, this); +} + +Value DOMCSSRule::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Type: + return Number(cssRule.type()); + case CssText: + return String(cssRule.cssText()); + case ParentStyleSheet: + return getDOMStyleSheet(exec,cssRule.parentStyleSheet()); + case ParentRule: + return getDOMCSSRule(exec,cssRule.parentRule()); + + // for DOM::CSSRule::STYLE_RULE: + case Style_SelectorText: + return String(static_cast<DOM::CSSStyleRule>(cssRule).selectorText()); + case Style_Style: + return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSStyleRule>(cssRule).style()); + + // for DOM::CSSRule::MEDIA_RULE: + case Media_Media: + return getDOMMediaList(exec,static_cast<DOM::CSSMediaRule>(cssRule).media()); + case Media_CssRules: + return getDOMCSSRuleList(exec,static_cast<DOM::CSSMediaRule>(cssRule).cssRules()); + + // for DOM::CSSRule::FONT_FACE_RULE: + case FontFace_Style: + return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSFontFaceRule>(cssRule).style()); + + // for DOM::CSSRule::PAGE_RULE: + case Page_SelectorText: + return String(static_cast<DOM::CSSPageRule>(cssRule).selectorText()); + case Page_Style: + return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSPageRule>(cssRule).style()); + + // for DOM::CSSRule::IMPORT_RULE: + case Import_Href: + return String(static_cast<DOM::CSSImportRule>(cssRule).href()); + case Import_Media: + return getDOMMediaList(exec,static_cast<DOM::CSSImportRule>(cssRule).media()); + case Import_StyleSheet: + return getDOMStyleSheet(exec,static_cast<DOM::CSSImportRule>(cssRule).styleSheet()); + + // for DOM::CSSRule::CHARSET_RULE: + case Charset_Encoding: + return String(static_cast<DOM::CSSCharsetRule>(cssRule).encoding()); + + default: + kdDebug(6070) << "WARNING: DOMCSSRule::getValueProperty unhandled token " << token << endl; + } + return Undefined(); +} + +void DOMCSSRule::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + const HashTable* table = classInfo()->propHashTable; // get the right hashtable + const HashEntry* entry = Lookup::findEntry(table, propertyName); + if (entry) { + if (entry->attr & Function) // function: put as override property + { + ObjectImp::put(exec, propertyName, value, attr); + return; + } + else if ((entry->attr & ReadOnly) == 0) // let DOMObjectLookupPut print the warning if not + { + putValueProperty(exec, entry->value, value, attr); + return; + } + } + DOMObjectLookupPut<DOMCSSRule, DOMObject>(exec, propertyName, value, attr, &DOMCSSRuleTable, this); +} + +void DOMCSSRule::putValueProperty(ExecState *exec, int token, const Value& value, int) +{ + switch (token) { + // for DOM::CSSRule::STYLE_RULE: + case Style_SelectorText: + static_cast<DOM::CSSStyleRule>(cssRule).setSelectorText(value.toString(exec).string()); + return; + + // for DOM::CSSRule::PAGE_RULE: + case Page_SelectorText: + static_cast<DOM::CSSPageRule>(cssRule).setSelectorText(value.toString(exec).string()); + return; + + // for DOM::CSSRule::CHARSET_RULE: + case Charset_Encoding: + static_cast<DOM::CSSCharsetRule>(cssRule).setEncoding(value.toString(exec).string()); + return; + + default: + kdDebug(6070) << "WARNING: DOMCSSRule::putValueProperty unhandled token " << token << endl; + } +} + +Value DOMCSSRuleFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCSSRule, thisObj ); + DOM::CSSRule cssRule = static_cast<DOMCSSRule *>(thisObj.imp())->toCSSRule(); + + if (cssRule.type() == DOM::CSSRule::MEDIA_RULE) { + DOM::CSSMediaRule rule = static_cast<DOM::CSSMediaRule>(cssRule); + if (id == DOMCSSRule::Media_InsertRule) + return Number(rule.insertRule(args[0].toString(exec).string(),args[1].toInteger(exec))); + else if (id == DOMCSSRule::Media_DeleteRule) + rule.deleteRule(args[0].toInteger(exec)); + } + + return Undefined(); +} + +Value getDOMCSSRule(ExecState *exec, const DOM::CSSRule& r) +{ + return cacheDOMObject<DOM::CSSRule, KJS::DOMCSSRule>(exec, r); +} + +// ------------------------------------------------------------------------- + + +DOM::CSSRule toCSSRule(const Value& val) +{ + Object obj = Object::dynamicCast(val); + if (!obj.isValid() || !obj.inherits(&DOMCSSRule::info)) + return DOM::CSSRule(); + + const DOMCSSRule *dobj = static_cast<const DOMCSSRule*>(obj.imp()); + return dobj->toCSSRule(); +} + +// ------------------------------------------------------------------------- + +const ClassInfo CSSRuleConstructor::info = { "CSSRuleConstructor", 0, &CSSRuleConstructorTable, 0 }; +/* +@begin CSSRuleConstructorTable 7 + UNKNOWN_RULE CSSRuleConstructor::UNKNOWN_RULE DontDelete|ReadOnly + STYLE_RULE CSSRuleConstructor::STYLE_RULE DontDelete|ReadOnly + CHARSET_RULE CSSRuleConstructor::CHARSET_RULE DontDelete|ReadOnly + IMPORT_RULE CSSRuleConstructor::IMPORT_RULE DontDelete|ReadOnly + MEDIA_RULE CSSRuleConstructor::MEDIA_RULE DontDelete|ReadOnly + FONT_FACE_RULE CSSRuleConstructor::FONT_FACE_RULE DontDelete|ReadOnly + PAGE_RULE CSSRuleConstructor::PAGE_RULE DontDelete|ReadOnly +@end +*/ + +CSSRuleConstructor::CSSRuleConstructor(ExecState *exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{ +} + +Value CSSRuleConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<CSSRuleConstructor,DOMObject>(exec,p,&CSSRuleConstructorTable,this); +} + +Value CSSRuleConstructor::getValueProperty(ExecState *, int token) const +{ + switch (token) { + case UNKNOWN_RULE: + return Number(DOM::CSSRule::UNKNOWN_RULE); + case STYLE_RULE: + return Number(DOM::CSSRule::STYLE_RULE); + case CHARSET_RULE: + return Number(DOM::CSSRule::CHARSET_RULE); + case IMPORT_RULE: + return Number(DOM::CSSRule::IMPORT_RULE); + case MEDIA_RULE: + return Number(DOM::CSSRule::MEDIA_RULE); + case FONT_FACE_RULE: + return Number(DOM::CSSRule::FONT_FACE_RULE); + case PAGE_RULE: + return Number(DOM::CSSRule::PAGE_RULE); + } + return Value(); +} + +Value getCSSRuleConstructor(ExecState *exec) +{ + return cacheGlobalObject<CSSRuleConstructor>( exec, "[[cssRule.constructor]]" ); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCSSValue::info = { "CSSValue", 0, &DOMCSSValueTable, 0 }; + +/* +@begin DOMCSSValueTable 2 + cssText DOMCSSValue::CssText DontDelete|ReadOnly + cssValueType DOMCSSValue::CssValueType DontDelete|ReadOnly +@end +*/ + +DOMCSSValue::DOMCSSValue(ExecState* exec, const DOM::CSSValue& val) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), cssValue(val) +{ +} + +DOMCSSValue::~DOMCSSValue() +{ + ScriptInterpreter::forgetDOMObject(cssValue.handle()); +} + +Value DOMCSSValue::tryGet(ExecState *exec, const Identifier &p) const +{ + if (p == "cssText") + return String(cssValue.cssText()); + else if (p == "cssValueType") + return Number(cssValue.cssValueType()); + return DOMObject::tryGet(exec,p); +} + +void DOMCSSValue::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + if (propertyName == "cssText") + cssValue.setCssText(value.toString(exec).string()); + else + DOMObject::tryPut(exec, propertyName, value, attr); +} + +Value getDOMCSSValue(ExecState *exec, const DOM::CSSValue& v) +{ + DOMObject *ret; + if (v.isNull()) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + if ((ret = interp->getDOMObject(v.handle()))) + return Value(ret); + else { + if (v.isCSSValueList()) + ret = new DOMCSSValueList(exec,v); + else if (v.isCSSPrimitiveValue()) + ret = new DOMCSSPrimitiveValue(exec,v); + else + ret = new DOMCSSValue(exec,v); + interp->putDOMObject(v.handle(),ret); + return Value(ret); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo CSSValueConstructor::info = { "CSSValueConstructor", 0, &CSSValueConstructorTable, 0 }; +/* +@begin CSSValueConstructorTable 5 + CSS_INHERIT CSSValueConstructor::CSS_INHERIT DontDelete|ReadOnly + CSS_PRIMITIVE_VALUE CSSValueConstructor::CSS_PRIMITIVE_VALUE DontDelete|ReadOnly + CSS_VALUE_LIST CSSValueConstructor::CSS_VALUE_LIST DontDelete|ReadOnly + CSS_CUSTOM CSSValueConstructor::CSS_CUSTOM DontDelete|ReadOnly +@end +*/ + +CSSValueConstructor::CSSValueConstructor(ExecState *exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{ +} + +Value CSSValueConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<CSSValueConstructor,DOMObject>(exec,p,&CSSValueConstructorTable,this); +} + +Value CSSValueConstructor::getValueProperty(ExecState *, int token) const +{ + switch (token) { + case CSS_INHERIT: + return Number(DOM::CSSValue::CSS_INHERIT); + case CSS_PRIMITIVE_VALUE: + return Number(DOM::CSSValue::CSS_PRIMITIVE_VALUE); + case CSS_VALUE_LIST: + return Number(DOM::CSSValue::CSS_VALUE_LIST); + case CSS_CUSTOM: + return Number(DOM::CSSValue::CSS_CUSTOM); + } + return Value(); +} + +Value getCSSValueConstructor(ExecState *exec) +{ + return cacheGlobalObject<CSSValueConstructor>( exec, "[[cssValue.constructor]]" ); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCSSPrimitiveValue::info = { "CSSPrimitiveValue", 0, &DOMCSSPrimitiveValueTable, 0 }; +/* +@begin DOMCSSPrimitiveValueTable 1 + primitiveType DOMCSSPrimitiveValue::PrimitiveType DontDelete|ReadOnly +@end +@begin DOMCSSPrimitiveValueProtoTable 3 + setFloatValue DOMCSSPrimitiveValue::SetFloatValue DontDelete|Function 2 + getFloatValue DOMCSSPrimitiveValue::GetFloatValue DontDelete|Function 1 + setStringValue DOMCSSPrimitiveValue::SetStringValue DontDelete|Function 2 + getStringValue DOMCSSPrimitiveValue::GetStringValue DontDelete|Function 0 + getCounterValue DOMCSSPrimitiveValue::GetCounterValue DontDelete|Function 0 + getRectValue DOMCSSPrimitiveValue::GetRectValue DontDelete|Function 0 + getRGBColorValue DOMCSSPrimitiveValue::GetRGBColorValue DontDelete|Function 0 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMCSSPrimitiveValueProto) +IMPLEMENT_PROTOFUNC_DOM(DOMCSSPrimitiveValueProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMCSSPrimitiveValue",DOMCSSPrimitiveValueProto,DOMCSSPrimitiveValueProtoFunc) + +DOMCSSPrimitiveValue::DOMCSSPrimitiveValue(ExecState *exec, const DOM::CSSPrimitiveValue& v) + : DOMCSSValue(DOMCSSPrimitiveValueProto::self(exec), v) { } + +Value DOMCSSPrimitiveValue::tryGet(ExecState *exec, const Identifier &p) const +{ + if (p=="primitiveType") + return Number(static_cast<DOM::CSSPrimitiveValue>(cssValue).primitiveType()); + return DOMObject::tryGet(exec,p); +} + +Value DOMCSSPrimitiveValueProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCSSPrimitiveValue, thisObj ); + DOM::CSSPrimitiveValue val = static_cast<DOMCSSPrimitiveValue *>(thisObj.imp())->toCSSPrimitiveValue(); + switch (id) { + case DOMCSSPrimitiveValue::SetFloatValue: + val.setFloatValue(args[0].toInteger(exec),args[1].toNumber(exec)); + return Undefined(); + case DOMCSSPrimitiveValue::GetFloatValue: + return Number(val.getFloatValue(args[0].toInteger(exec))); + case DOMCSSPrimitiveValue::SetStringValue: + val.setStringValue(args[0].toInteger(exec),args[1].toString(exec).string()); + return Undefined(); + case DOMCSSPrimitiveValue::GetStringValue: + return String(val.getStringValue()); + case DOMCSSPrimitiveValue::GetCounterValue: + return getDOMCounter(exec,val.getCounterValue()); + case DOMCSSPrimitiveValue::GetRectValue: + return getDOMRect(exec,val.getRectValue()); + case DOMCSSPrimitiveValue::GetRGBColorValue: + return getDOMRGBColor(exec,val.getRGBColorValue()); + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo CSSPrimitiveValueConstructor::info = { "CSSPrimitiveValueConstructor", 0, &CSSPrimitiveValueConstructorTable, 0 }; + +/* +@begin CSSPrimitiveValueConstructorTable 27 + CSS_UNKNOWN DOM::CSSPrimitiveValue::CSS_UNKNOWN DontDelete|ReadOnly + CSS_NUMBER DOM::CSSPrimitiveValue::CSS_NUMBER DontDelete|ReadOnly + CSS_PERCENTAGE DOM::CSSPrimitiveValue::CSS_PERCENTAGE DontDelete|ReadOnly + CSS_EMS DOM::CSSPrimitiveValue::CSS_EMS DontDelete|ReadOnly + CSS_EXS DOM::CSSPrimitiveValue::CSS_EXS DontDelete|ReadOnly + CSS_PX DOM::CSSPrimitiveValue::CSS_PX DontDelete|ReadOnly + CSS_CM DOM::CSSPrimitiveValue::CSS_CM DontDelete|ReadOnly + CSS_MM DOM::CSSPrimitiveValue::CSS_MM DontDelete|ReadOnly + CSS_IN DOM::CSSPrimitiveValue::CSS_IN DontDelete|ReadOnly + CSS_PT DOM::CSSPrimitiveValue::CSS_PT DontDelete|ReadOnly + CSS_PC DOM::CSSPrimitiveValue::CSS_PC DontDelete|ReadOnly + CSS_DEG DOM::CSSPrimitiveValue::CSS_DEG DontDelete|ReadOnly + CSS_RAD DOM::CSSPrimitiveValue::CSS_RAD DontDelete|ReadOnly + CSS_GRAD DOM::CSSPrimitiveValue::CSS_GRAD DontDelete|ReadOnly + CSS_MS DOM::CSSPrimitiveValue::CSS_MS DontDelete|ReadOnly + CSS_S DOM::CSSPrimitiveValue::CSS_S DontDelete|ReadOnly + CSS_HZ DOM::CSSPrimitiveValue::CSS_HZ DontDelete|ReadOnly + CSS_KHZ DOM::CSSPrimitiveValue::CSS_KHZ DontDelete|ReadOnly + CSS_DIMENSION DOM::CSSPrimitiveValue::CSS_DIMENSION DontDelete|ReadOnly + CSS_STRING DOM::CSSPrimitiveValue::CSS_STRING DontDelete|ReadOnly + CSS_URI DOM::CSSPrimitiveValue::CSS_URI DontDelete|ReadOnly + CSS_IDENT DOM::CSSPrimitiveValue::CSS_IDENT DontDelete|ReadOnly + CSS_ATTR DOM::CSSPrimitiveValue::CSS_ATTR DontDelete|ReadOnly + CSS_COUNTER DOM::CSSPrimitiveValue::CSS_COUNTER DontDelete|ReadOnly + CSS_RECT DOM::CSSPrimitiveValue::CSS_RECT DontDelete|ReadOnly + CSS_RGBCOLOR DOM::CSSPrimitiveValue::CSS_RGBCOLOR DontDelete|ReadOnly +@end +*/ + +Value CSSPrimitiveValueConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<CSSPrimitiveValueConstructor,CSSValueConstructor>(exec,p,&CSSPrimitiveValueConstructorTable,this); +} + +Value CSSPrimitiveValueConstructor::getValueProperty(ExecState *, int token) const +{ + // We use the token as the value to return directly + return Number(token); +} + +Value getCSSPrimitiveValueConstructor(ExecState *exec) +{ + return cacheGlobalObject<CSSPrimitiveValueConstructor>( exec, "[[cssPrimitiveValue.constructor]]" ); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCSSValueList::info = { "CSSValueList", 0, &DOMCSSValueListTable, 0 }; + +/* +@begin DOMCSSValueListTable 3 + length DOMCSSValueList::Length DontDelete|ReadOnly + item DOMCSSValueList::Item DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMCSSValueListFunc) // not really a proto, but doesn't matter + +DOMCSSValueList::DOMCSSValueList(ExecState *exec, const DOM::CSSValueList& v) + : DOMCSSValue(exec, v) { } + +Value DOMCSSValueList::tryGet(ExecState *exec, const Identifier &p) const +{ + Value result; + DOM::CSSValueList valueList = static_cast<DOM::CSSValueList>(cssValue); + + if (p == lengthPropertyName) + return Number(valueList.length()); + else if (p == "item") + return lookupOrCreateFunction<DOMCSSValueListFunc>(exec,p,this,DOMCSSValueList::Item,1,DontDelete|Function); + + bool ok; + long unsigned int u = p.toULong(&ok); + if (ok) + return getDOMCSSValue(exec,valueList.item(u)); + + return DOMCSSValue::tryGet(exec,p); +} + +Value DOMCSSValueListFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCSSValueList, thisObj ); + DOM::CSSValueList valueList = static_cast<DOMCSSValueList *>(thisObj.imp())->toValueList(); + switch (id) { + case DOMCSSValueList::Item: + return getDOMCSSValue(exec,valueList.item(args[0].toInteger(exec))); + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMRGBColor::info = { "RGBColor", 0, &DOMRGBColorTable, 0 }; + +/* +@begin DOMRGBColorTable 3 + red DOMRGBColor::Red DontDelete|ReadOnly + green DOMRGBColor::Green DontDelete|ReadOnly + blue DOMRGBColor::Blue DontDelete|ReadOnly +@end +*/ + +DOMRGBColor::DOMRGBColor(ExecState* exec, const DOM::RGBColor& c) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), rgbColor(c) +{ +} + +DOMRGBColor::~DOMRGBColor() +{ + //rgbColors.remove(rgbColor.handle()); +} + +Value DOMRGBColor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMRGBColor,DOMObject>(exec, p, + &DOMRGBColorTable, + this); +} + +Value DOMRGBColor::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Red: + return getDOMCSSValue(exec, rgbColor.red()); + case Green: + return getDOMCSSValue(exec, rgbColor.green()); + case Blue: + return getDOMCSSValue(exec, rgbColor.blue()); + default: + return Value(); + } +} + +Value getDOMRGBColor(ExecState *exec, const DOM::RGBColor& c) +{ + // ### implement equals for RGBColor since they're not refcounted objects + return Value(new DOMRGBColor(exec, c)); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMRect::info = { "Rect", 0, &DOMRectTable, 0 }; +/* +@begin DOMRectTable 4 + top DOMRect::Top DontDelete|ReadOnly + right DOMRect::Right DontDelete|ReadOnly + bottom DOMRect::Bottom DontDelete|ReadOnly + left DOMRect::Left DontDelete|ReadOnly +@end +*/ + +DOMRect::DOMRect(ExecState *exec, const DOM::Rect& r) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), rect(r) +{ +} + +DOMRect::~DOMRect() +{ + ScriptInterpreter::forgetDOMObject(rect.handle()); +} + +Value DOMRect::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMRect,DOMObject>(exec, p, + &DOMRectTable, this); +} + +Value DOMRect::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Top: + return getDOMCSSValue(exec, rect.top()); + case Right: + return getDOMCSSValue(exec, rect.right()); + case Bottom: + return getDOMCSSValue(exec, rect.bottom()); + case Left: + return getDOMCSSValue(exec, rect.left()); + default: + return Value(); + } +} + +Value getDOMRect(ExecState *exec, const DOM::Rect& r) +{ + return cacheDOMObject<DOM::Rect, KJS::DOMRect>(exec, r); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCounter::info = { "Counter", 0, &DOMCounterTable, 0 }; +/* +@begin DOMCounterTable 3 + identifier DOMCounter::identifier DontDelete|ReadOnly + listStyle DOMCounter::listStyle DontDelete|ReadOnly + separator DOMCounter::separator DontDelete|ReadOnly +@end +*/ +DOMCounter::DOMCounter(ExecState *exec, const DOM::Counter& c) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), counter(c) +{ +} + +DOMCounter::~DOMCounter() +{ + ScriptInterpreter::forgetDOMObject(counter.handle()); +} + +Value DOMCounter::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMCounter,DOMObject>(exec, p, + &DOMCounterTable, this); +} + +Value DOMCounter::getValueProperty(ExecState *, int token) const +{ + switch (token) { + case identifier: + return String(counter.identifier()); + case listStyle: + return String(counter.listStyle()); + case separator: + return String(counter.separator()); + default: + return Value(); + } +} + +Value getDOMCounter(ExecState *exec, const DOM::Counter& c) +{ + return cacheDOMObject<DOM::Counter, KJS::DOMCounter>(exec, c); +} + +} //namespace KJS |