00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
#include "kjs_css.h"
00024
#include "kjs_css.lut.h"
00025
00026
#include <dom/html_head.h>
00027
00028
#include <css/css_base.h>
00029
#include "kjs_dom.h"
00030
00031
using namespace KJS;
00032
#include <kdebug.h>
00033
00034
static QString cssPropertyName(
const Identifier &p,
bool& hadPixelPrefix )
00035 {
00036
QString prop = p.qstring();
00037
int i = prop.length();
00038
while ( --i ) {
00039
char c = prop[i].latin1();
00040
if ( c >=
'A' && c <=
'Z' )
00041 prop.insert( i,
'-' );
00042 }
00043
00044 prop = prop.lower();
00045 hadPixelPrefix =
false;
00046
00047
if (prop.startsWith(
"css-")) {
00048 prop = prop.mid(4);
00049 }
else if (prop.startsWith(
"pixel-")) {
00050 prop = prop.mid(6);
00051 hadPixelPrefix =
true;
00052 }
else if (prop.startsWith(
"pos-")) {
00053 prop = prop.mid(4);
00054 hadPixelPrefix =
true;
00055 }
00056
00057
return prop;
00058 }
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079 DEFINE_PROTOTYPE(
"DOMCSSStyleDeclaration", DOMCSSStyleDeclarationProto)
00080 IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleDeclarationProtoFunc)
00081 IMPLEMENT_PROTOTYPE(DOMCSSStyleDeclarationProto, DOMCSSStyleDeclarationProtoFunc)
00082
00083 const ClassInfo DOMCSSStyleDeclaration::info = {
"CSSStyleDeclaration", 0, &DOMCSSStyleDeclarationTable, 0 };
00084
00085 DOMCSSStyleDeclaration::DOMCSSStyleDeclaration(ExecState *exec,
const DOM::CSSStyleDeclaration& s)
00086 :
DOMObject(DOMCSSStyleDeclarationProto::self(exec)), styleDecl(s)
00087 { }
00088
00089 DOMCSSStyleDeclaration::~DOMCSSStyleDeclaration()
00090 {
00091 ScriptInterpreter::forgetDOMObject(styleDecl.handle());
00092 }
00093
00094
bool DOMCSSStyleDeclaration::hasProperty(ExecState *exec,
const Identifier &p)
const
00095
{
00096
bool hadPixelPrefix;
00097
QString cssprop = cssPropertyName(p, hadPixelPrefix);
00098
if (DOM::getPropertyID(cssprop.latin1(), cssprop.length()))
00099
return true;
00100
00101
return ObjectImp::hasProperty(exec, p);
00102 }
00103
00104 Value DOMCSSStyleDeclaration::tryGet(ExecState *exec,
const Identifier &propertyName)
const
00105
{
00106
#ifdef KJS_VERBOSE
00107
kdDebug(6070) <<
"DOMCSSStyleDeclaration::tryGet " << propertyName.qstring() <<
endl;
00108
#endif
00109
const HashEntry* entry = Lookup::findEntry(&DOMCSSStyleDeclarationTable, propertyName);
00110
if (entry)
00111
switch (entry->value) {
00112
case CssText:
00113
return String(styleDecl.cssText());
00114
case Length:
00115
return Number(styleDecl.length());
00116
case ParentRule:
00117
return getDOMCSSRule(exec,styleDecl.parentRule());
00118
default:
00119
break;
00120 }
00121
00122
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 String(
DOM::CSSStyleDeclaration(styleDecl).item(u));
00131
00132
00133
00134
00135
00136
bool asNumber;
00137
QString p = cssPropertyName(propertyName, asNumber);
00138
00139
#ifdef KJS_VERBOSE
00140
kdDebug(6070) <<
"DOMCSSStyleDeclaration: converting to css property name: " << p << ( asNumber ?
"px" :
"" ) <<
endl;
00141
#endif
00142
00143
if (asNumber) {
00144
DOM::CSSValue v = styleDecl.
getPropertyCSSValue(p);
00145
if ( !v.
isNull() && v.
cssValueType() == DOM::CSSValue::CSS_PRIMITIVE_VALUE)
00146
return Number(static_cast<DOM::CSSPrimitiveValue>(v).getFloatValue(DOM::CSSPrimitiveValue::CSS_PX));
00147 }
00148
00149
DOM::DOMString str = const_cast<DOM::CSSStyleDeclaration &>( styleDecl ).getPropertyValue(p);
00150
if (!str.
isNull())
00151
return String(str);
00152
00153
00154
if (DOM::getPropertyID(p.latin1(), p.length()))
00155
return String(
DOM::DOMString(
""));
00156
00157
return DOMObject::tryGet(exec, propertyName);
00158 }
00159
00160
00161
void DOMCSSStyleDeclaration::tryPut(ExecState *exec,
const Identifier &propertyName,
const Value& value,
int attr )
00162 {
00163
#ifdef KJS_VERBOSE
00164
kdDebug(6070) <<
"DOMCSSStyleDeclaration::tryPut " << propertyName.qstring() <<
endl;
00165
#endif
00166
if (propertyName ==
"cssText") {
00167 styleDecl.
setCssText(value.toString(exec).string());
00168 }
00169
else {
00170
bool pxSuffix;
00171
QString prop = cssPropertyName(propertyName, pxSuffix);
00172
QString propvalue = value.toString(exec).qstring();
00173
00174
if (pxSuffix)
00175 propvalue +=
"px";
00176
#ifdef KJS_VERBOSE
00177
kdDebug(6070) <<
"DOMCSSStyleDeclaration: prop=" << prop <<
" propvalue=" << propvalue <<
endl;
00178
#endif
00179
00180
if (DOM::getPropertyID(prop.latin1(), prop.length())) {
00181
if (propvalue.isEmpty())
00182 styleDecl.
removeProperty(prop);
00183
else
00184 styleDecl.
setProperty(prop,
DOM::DOMString(propvalue),
"");
00185 }
00186
else
00187
00188 DOMObject::tryPut( exec, propertyName, value, attr );
00189 }
00190 }
00191
00192 Value DOMCSSStyleDeclarationProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00193 {
00194 KJS_CHECK_THIS( KJS::DOMCSSStyleDeclaration, thisObj );
00195
DOM::CSSStyleDeclaration styleDecl = static_cast<DOMCSSStyleDeclaration *>(thisObj.imp())->toStyleDecl();
00196 String str = args[0].toString(exec);
00197
DOM::DOMString s = str.value().string();
00198
00199
switch (
id) {
00200
case DOMCSSStyleDeclaration::GetPropertyValue:
00201
return String(styleDecl.
getPropertyValue(s));
00202
case DOMCSSStyleDeclaration::GetPropertyCSSValue:
00203
return getDOMCSSValue(exec,styleDecl.
getPropertyCSSValue(s));
00204
case DOMCSSStyleDeclaration::RemoveProperty:
00205
return String(styleDecl.
removeProperty(s));
00206
case DOMCSSStyleDeclaration::GetPropertyPriority:
00207
return String(styleDecl.
getPropertyPriority(s));
00208
case DOMCSSStyleDeclaration::SetProperty:
00209 styleDecl.
setProperty(args[0].toString(exec).string(),
00210 args[1].toString(exec).string(),
00211 args[2].toString(exec).string());
00212
return Undefined();
00213
case DOMCSSStyleDeclaration::Item:
00214
return String(styleDecl.
item(args[0].toInteger(exec)));
00215
default:
00216
return Undefined();
00217 }
00218 }
00219
00220 Value KJS::getDOMCSSStyleDeclaration(ExecState *exec,
const DOM::CSSStyleDeclaration& s)
00221 {
00222
return cacheDOMObject<DOM::CSSStyleDeclaration, KJS::DOMCSSStyleDeclaration>(exec, s);
00223 }
00224
00225
00226
00227
const ClassInfo DOMStyleSheet::info = {
"StyleSheet", 0, &DOMStyleSheetTable, 0 };
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240 DOMStyleSheet::DOMStyleSheet(ExecState* exec,
const DOM::StyleSheet& ss)
00241 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), styleSheet(ss)
00242 {
00243 }
00244
00245 DOMStyleSheet::~DOMStyleSheet()
00246 {
00247 ScriptInterpreter::forgetDOMObject(styleSheet.handle());
00248 }
00249
00250 Value DOMStyleSheet::tryGet(ExecState *exec,
const Identifier &propertyName)
const
00251
{
00252
return DOMObjectLookupGetValue<DOMStyleSheet,DOMObject>(exec,propertyName,&DOMStyleSheetTable,
this);
00253 }
00254
00255 Value DOMStyleSheet::getValueProperty(ExecState *exec,
int token)
const
00256
{
00257
switch (token) {
00258
case Type:
00259
return String(styleSheet.type());
00260
case Disabled:
00261
return Boolean(styleSheet.disabled());
00262
case OwnerNode:
00263
return getDOMNode(exec,styleSheet.ownerNode());
00264
case ParentStyleSheet:
00265
return getDOMStyleSheet(exec,styleSheet.parentStyleSheet());
00266
case Href:
00267
return String(styleSheet.href());
00268
case Title:
00269
return String(styleSheet.title());
00270
case Media:
00271
return getDOMMediaList(exec, styleSheet.media());
00272 }
00273
return Value();
00274 }
00275
00276
void DOMStyleSheet::tryPut(ExecState *exec,
const Identifier &propertyName,
const Value& value,
int attr)
00277 {
00278
if (propertyName ==
"disabled") {
00279 styleSheet.setDisabled(value.toBoolean(exec));
00280 }
00281
else
00282 DOMObject::tryPut(exec, propertyName, value, attr);
00283 }
00284
00285 Value KJS::getDOMStyleSheet(ExecState *exec,
const DOM::StyleSheet& ss)
00286 {
00287
DOMObject *ret;
00288
if (ss.
isNull())
00289
return Null();
00290
ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00291
if ((ret = interp->
getDOMObject(ss.
handle())))
00292
return Value(ret);
00293
else {
00294
if (ss.
isCSSStyleSheet()) {
00295
DOM::CSSStyleSheet cs;
00296 cs = ss;
00297 ret =
new DOMCSSStyleSheet(exec,cs);
00298 }
00299
else
00300 ret =
new DOMStyleSheet(exec,ss);
00301 interp->
putDOMObject(ss.
handle(),ret);
00302
return Value(ret);
00303 }
00304 }
00305
00306
00307
00308
const ClassInfo DOMStyleSheetList::info = {
"StyleSheetList", 0, &DOMStyleSheetListTable, 0 };
00309
00310
00311
00312
00313
00314
00315
00316 IMPLEMENT_PROTOFUNC_DOM(DOMStyleSheetListFunc)
00317
00318 DOMStyleSheetList::DOMStyleSheetList(ExecState *exec, const DOM::
StyleSheetList& ssl, const DOM::
Document& doc)
00319 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), styleSheetList(ssl), m_doc(doc)
00320 {
00321 }
00322
00323 DOMStyleSheetList::~DOMStyleSheetList()
00324 {
00325 ScriptInterpreter::forgetDOMObject(styleSheetList.handle());
00326 }
00327
00328 Value DOMStyleSheetList::tryGet(ExecState *exec,
const Identifier &p)
const
00329
{
00330
#ifdef KJS_VERBOSE
00331
kdDebug(6070) <<
"DOMStyleSheetList::tryGet " << p.qstring() <<
endl;
00332
#endif
00333
if (p == lengthPropertyName)
00334
return Number(styleSheetList.length());
00335
else if (p ==
"item")
00336
return lookupOrCreateFunction<DOMStyleSheetListFunc>(exec,p,
this,DOMStyleSheetList::Item,1,DontDelete|Function);
00337
00338
00339
bool ok;
00340
long unsigned int u = p.toULong(&ok);
00341
if (ok)
00342
return getDOMStyleSheet(exec,
DOM::StyleSheetList(styleSheetList).item(u));
00343
00344
00345
00346
#if 0
00347
00348
00349
00350
00351 DOM::NameNodeListImpl namedList( m_doc.documentElement().handle(), p.string() );
00352
int len = namedList.length();
00353
if ( len ) {
00354
QValueList<DOM::Node> styleSheets;
00355
for (
int i = 0 ; i < len ; ++i ) {
00356
DOM::HTMLStyleElement elem =
DOM::Node(namedList.item(i));
00357
if (!elem.
isNull())
00358 styleSheets.append(elem.
sheet());
00359 }
00360
if ( styleSheets.count() == 1 )
00361
return getDOMStyleSheet(exec, styleSheets[0]);
00362
else if ( styleSheets.count() > 1 ) {
00363
return new DOMNamedItemsCollection(exec,styleSheets);
00364 }
00365 }
00366
#endif
00367
00368
00369
00370
DOM::DOMString pstr = p.string();
00371
DOM::HTMLStyleElement styleElem = m_doc.getElementById( pstr );
00372
if (!styleElem.
isNull())
00373
return getDOMStyleSheet(exec, styleElem.
sheet());
00374
00375
return DOMObject::tryGet(exec, p);
00376 }
00377
00378 Value KJS::DOMStyleSheetList::call(ExecState *exec, Object &thisObj,
const List &args)
00379 {
00380
00381 Value val;
00382
try {
00383 val = tryCall(exec, thisObj, args);
00384 }
00385
00386
catch (...) {
00387 Object err = Error::create(exec, GeneralError,
"Exception from DOMStyleSheetList");
00388 exec->setException(err);
00389 }
00390
return val;
00391 }
00392
00393 Value DOMStyleSheetList::tryCall(ExecState *exec, Object & ,
const List &args)
00394 {
00395
if (args.size() == 1) {
00396
00397
return tryGet( exec, Identifier(args[0].toString(exec)) );
00398 }
00399
return Undefined();
00400 }
00401
00402 Value KJS::getDOMStyleSheetList(ExecState *exec,
const DOM::StyleSheetList& ssl,
const DOM::Document& doc)
00403 {
00404
00405
DOMObject *ret;
00406
if (ssl.
isNull())
00407
return Null();
00408
ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00409
if ((ret = interp->
getDOMObject(ssl.
handle())))
00410
return Value(ret);
00411
else {
00412 ret =
new DOMStyleSheetList(exec, ssl, doc);
00413 interp->
putDOMObject(ssl.
handle(),ret);
00414
return Value(ret);
00415 }
00416 }
00417
00418 Value DOMStyleSheetListFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00419 {
00420 KJS_CHECK_THIS( KJS::DOMStyleSheetList, thisObj );
00421
DOM::StyleSheetList styleSheetList = static_cast<DOMStyleSheetList *>(thisObj.imp())->toStyleSheetList();
00422
if (
id == DOMStyleSheetList::Item)
00423
return getDOMStyleSheet(exec, styleSheetList.
item(args[0].toInteger(exec)));
00424
return Undefined();
00425 }
00426
00427
00428
00429
const ClassInfo DOMMediaList::info = {
"MediaList", 0, &DOMMediaListTable, 0 };
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442 DEFINE_PROTOTYPE(
"DOMMediaList", DOMMediaListProto)
00443 IMPLEMENT_PROTOFUNC_DOM(DOMMediaListProtoFunc)
00444 IMPLEMENT_PROTOTYPE(DOMMediaListProto, DOMMediaListProtoFunc)
00445
00446 DOMMediaList::DOMMediaList(ExecState *exec, const DOM::
MediaList& ml)
00447 :
DOMObject(DOMMediaListProto::self(exec)), mediaList(ml) { }
00448
00449 DOMMediaList::~DOMMediaList()
00450 {
00451 ScriptInterpreter::forgetDOMObject(mediaList.handle());
00452 }
00453
00454 Value DOMMediaList::tryGet(ExecState *exec,
const Identifier &p)
const
00455
{
00456
if (p ==
"mediaText")
00457
return String(mediaList.mediaText());
00458
else if (p == lengthPropertyName)
00459
return Number(mediaList.length());
00460
00461
bool ok;
00462
long unsigned int u = p.toULong(&ok);
00463
if (ok)
00464
return String(mediaList.item(u));
00465
00466
return DOMObject::tryGet(exec, p);
00467 }
00468
00469
void DOMMediaList::tryPut(ExecState *exec,
const Identifier &propertyName,
const Value& value,
int attr)
00470 {
00471
if (propertyName ==
"mediaText")
00472 mediaList.setMediaText(value.toString(exec).string());
00473
else
00474 DOMObject::tryPut(exec, propertyName, value, attr);
00475 }
00476
00477 Value KJS::getDOMMediaList(ExecState *exec,
const DOM::MediaList& ml)
00478 {
00479
return cacheDOMObject<DOM::MediaList, KJS::DOMMediaList>(exec, ml);
00480 }
00481
00482 Value KJS::DOMMediaListProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00483 {
00484 KJS_CHECK_THIS( KJS::DOMMediaList, thisObj );
00485
DOM::MediaList mediaList = static_cast<DOMMediaList *>(thisObj.imp())->toMediaList();
00486
switch (
id) {
00487
case DOMMediaList::Item:
00488
return String(mediaList.
item(args[0].toInteger(exec)));
00489
case DOMMediaList::DeleteMedium:
00490 mediaList.
deleteMedium(args[0].toString(exec).string());
00491
return Undefined();
00492
case DOMMediaList::AppendMedium:
00493 mediaList.
appendMedium(args[0].toString(exec).string());
00494
return Undefined();
00495
default:
00496
return Undefined();
00497 }
00498 }
00499
00500
00501
00502
const ClassInfo DOMCSSStyleSheet::info = {
"CSSStyleSheet", 0, &DOMCSSStyleSheetTable, 0 };
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 DEFINE_PROTOTYPE(
"DOMCSSStyleSheet",DOMCSSStyleSheetProto)
00520 IMPLEMENT_PROTOFUNC_DOM(DOMCSSStyleSheetProtoFunc)
00521 IMPLEMENT_PROTOTYPE(DOMCSSStyleSheetProto,DOMCSSStyleSheetProtoFunc)
00522
00523 DOMCSSStyleSheet::DOMCSSStyleSheet(ExecState *exec, const DOM::
CSSStyleSheet& ss)
00524 : DOMStyleSheet(DOMCSSStyleSheetProto::self(exec),ss) { }
00525
00526 DOMCSSStyleSheet::~DOMCSSStyleSheet()
00527 {
00528 }
00529
00530 Value DOMCSSStyleSheet::tryGet(ExecState *exec,
const Identifier &p)
const
00531
{
00532
DOM::CSSStyleSheet cssStyleSheet = static_cast<DOM::CSSStyleSheet>(styleSheet);
00533
if (p ==
"ownerRule")
00534
return getDOMCSSRule(exec,cssStyleSheet.
ownerRule());
00535
else if (p ==
"cssRules" || p ==
"rules" )
00536
return getDOMCSSRuleList(exec,cssStyleSheet.
cssRules());
00537
return DOMStyleSheet::tryGet(exec,p);
00538 }
00539
00540 Value DOMCSSStyleSheetProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00541 {
00542 KJS_CHECK_THIS( KJS::DOMCSSStyleSheet, thisObj );
00543
DOM::CSSStyleSheet styleSheet = static_cast<DOMCSSStyleSheet *>(thisObj.imp())->toCSSStyleSheet();
00544
00545
switch (
id) {
00546
case DOMCSSStyleSheet::InsertRule:
00547
return Number(styleSheet.
insertRule(args[0].toString(exec).string(),(
long unsigned int)args[1].toInteger(exec)));
00548
case DOMCSSStyleSheet::DeleteRule:
00549 styleSheet.
deleteRule(args[0].toInteger(exec));
00550
return Undefined();
00551
00552
case DOMCSSStyleSheet::AddRule: {
00553
DOM::DOMString str = args[0].toString(exec).string() +
" { " + args[1].toString(exec).
string() +
" } ";
00554
return Number(styleSheet.
insertRule(str,(
long unsigned int)args[2].toInteger(exec)));
00555 }
00556
case DOMCSSStyleSheet::RemoveRule: {
00557
int index = args.size() > 0 ? args[0].toInteger(exec) : 0 ;
00558 styleSheet.
deleteRule(index);
00559
return Undefined();
00560 }
00561
default:
00562
return Undefined();
00563 }
00564 }
00565
00566
00567
00568
const ClassInfo DOMCSSRuleList::info = {
"CSSRuleList", 0, &DOMCSSRuleListTable, 0 };
00569
00570
00571
00572
00573
00574
00575 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleListFunc)
00576
00577 DOMCSSRuleList::DOMCSSRuleList(ExecState* exec, const DOM::
CSSRuleList& rl)
00578 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRuleList(rl)
00579 {
00580 }
00581
00582 DOMCSSRuleList::~DOMCSSRuleList()
00583 {
00584 ScriptInterpreter::forgetDOMObject(cssRuleList.handle());
00585 }
00586
00587 Value DOMCSSRuleList::tryGet(ExecState *exec,
const Identifier &p)
const
00588
{
00589 Value result;
00590
if (p == lengthPropertyName)
00591
return Number(cssRuleList.length());
00592
else if (p ==
"item")
00593
return lookupOrCreateFunction<DOMCSSRuleListFunc>(exec,p,
this,DOMCSSRuleList::Item,1,DontDelete|Function);
00594
00595
bool ok;
00596
long unsigned int u = p.toULong(&ok);
00597
if (ok)
00598
return getDOMCSSRule(exec,
DOM::CSSRuleList(cssRuleList).item(u));
00599
00600
return DOMObject::tryGet(exec,p);
00601 }
00602
00603 Value DOMCSSRuleListFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00604 {
00605 KJS_CHECK_THIS( KJS::DOMCSSRuleList, thisObj );
00606
DOM::CSSRuleList cssRuleList = static_cast<DOMCSSRuleList *>(thisObj.imp())->toCSSRuleList();
00607
switch (
id) {
00608
case DOMCSSRuleList::Item:
00609
return getDOMCSSRule(exec,cssRuleList.
item(args[0].toInteger(exec)));
00610
default:
00611
return Undefined();
00612 }
00613 }
00614
00615 Value KJS::getDOMCSSRuleList(ExecState *exec,
const DOM::CSSRuleList& rl)
00616 {
00617
return cacheDOMObject<DOM::CSSRuleList, KJS::DOMCSSRuleList>(exec, rl);
00618 }
00619
00620
00621
00622 IMPLEMENT_PROTOFUNC_DOM(DOMCSSRuleFunc)
00623
00624 DOMCSSRule::DOMCSSRule(ExecState* exec, const DOM::
CSSRule& r)
00625 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), cssRule(r)
00626 {
00627 }
00628
00629 DOMCSSRule::~DOMCSSRule()
00630 {
00631 ScriptInterpreter::forgetDOMObject(cssRule.handle());
00632 }
00633
00634
const ClassInfo DOMCSSRule::info = {
"CSSRule", 0, &DOMCSSRuleTable, 0 };
00635
const ClassInfo DOMCSSRule::style_info = {
"CSSStyleRule", &DOMCSSRule::info, &DOMCSSStyleRuleTable, 0 };
00636
const ClassInfo DOMCSSRule::media_info = {
"CSSMediaRule", &DOMCSSRule::info, &DOMCSSMediaRuleTable, 0 };
00637
const ClassInfo DOMCSSRule::fontface_info = {
"CSSFontFaceRule", &DOMCSSRule::info, &DOMCSSFontFaceRuleTable, 0 };
00638
const ClassInfo DOMCSSRule::page_info = {
"CSSPageRule", &DOMCSSRule::info, &DOMCSSPageRuleTable, 0 };
00639
const ClassInfo DOMCSSRule::import_info = {
"CSSImportRule", &DOMCSSRule::info, &DOMCSSImportRuleTable, 0 };
00640
const ClassInfo DOMCSSRule::charset_info = {
"CSSCharsetRule", &DOMCSSRule::info, &DOMCSSCharsetRuleTable, 0 };
00641
00642
const ClassInfo* DOMCSSRule::classInfo()
const
00643
{
00644
switch (cssRule.type()) {
00645
case DOM::CSSRule::STYLE_RULE:
00646
return &style_info;
00647
case DOM::CSSRule::MEDIA_RULE:
00648
return &media_info;
00649
case DOM::CSSRule::FONT_FACE_RULE:
00650
return &fontface_info;
00651
case DOM::CSSRule::PAGE_RULE:
00652
return &page_info;
00653
case DOM::CSSRule::IMPORT_RULE:
00654
return &import_info;
00655
case DOM::CSSRule::CHARSET_RULE:
00656
return &charset_info;
00657
case DOM::CSSRule::UNKNOWN_RULE:
00658
default:
00659
return &info;
00660 }
00661 }
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695 Value DOMCSSRule::tryGet(ExecState *exec,
const Identifier &propertyName)
const
00696
{
00697
#ifdef KJS_VERBOSE
00698
kdDebug(6070) <<
"DOMCSSRule::tryGet " << propertyName.qstring() <<
endl;
00699
#endif
00700
const HashTable* table = classInfo()->propHashTable;
00701
const HashEntry* entry = Lookup::findEntry(table, propertyName);
00702
if (entry) {
00703
if (entry->attr & Function)
00704
return lookupOrCreateFunction<DOMCSSRuleFunc>(exec, propertyName,
this, entry->value, entry->params, entry->attr);
00705
return getValueProperty(exec, entry->value);
00706 }
00707
00708
00709
return DOMObjectLookupGet<DOMCSSRuleFunc, DOMCSSRule, DOMObject>(exec, propertyName, &DOMCSSRuleTable,
this);
00710 }
00711
00712 Value DOMCSSRule::getValueProperty(ExecState *exec,
int token)
const
00713
{
00714
switch (token) {
00715
case Type:
00716
return Number(cssRule.type());
00717
case CssText:
00718
return String(cssRule.cssText());
00719
case ParentStyleSheet:
00720
return getDOMStyleSheet(exec,cssRule.parentStyleSheet());
00721
case ParentRule:
00722
return getDOMCSSRule(exec,cssRule.parentRule());
00723
00724
00725
case Style_SelectorText:
00726
return String(static_cast<DOM::CSSStyleRule>(cssRule).selectorText());
00727
case Style_Style:
00728
return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSStyleRule>(cssRule).style());
00729
00730
00731
case Media_Media:
00732
return getDOMMediaList(exec,static_cast<DOM::CSSMediaRule>(cssRule).media());
00733
case Media_CssRules:
00734
return getDOMCSSRuleList(exec,static_cast<DOM::CSSMediaRule>(cssRule).cssRules());
00735
00736
00737
case FontFace_Style:
00738
return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSFontFaceRule>(cssRule).style());
00739
00740
00741
case Page_SelectorText:
00742
return String(static_cast<DOM::CSSPageRule>(cssRule).selectorText());
00743
case Page_Style:
00744
return getDOMCSSStyleDeclaration(exec,static_cast<DOM::CSSPageRule>(cssRule).style());
00745
00746
00747
case Import_Href:
00748
return String(static_cast<DOM::CSSImportRule>(cssRule).href());
00749
case Import_Media:
00750
return getDOMMediaList(exec,static_cast<DOM::CSSImportRule>(cssRule).media());
00751
case Import_StyleSheet:
00752
return getDOMStyleSheet(exec,static_cast<DOM::CSSImportRule>(cssRule).styleSheet());
00753
00754
00755
case Charset_Encoding:
00756
return String(static_cast<DOM::CSSCharsetRule>(cssRule).encoding());
00757
00758
default:
00759
kdDebug(6070) <<
"WARNING: DOMCSSRule::getValueProperty unhandled token " << token <<
endl;
00760 }
00761
return Undefined();
00762 }
00763
00764
void DOMCSSRule::tryPut(ExecState *exec,
const Identifier &propertyName,
const Value& value,
int attr)
00765 {
00766
const HashTable* table = classInfo()->propHashTable;
00767
const HashEntry* entry = Lookup::findEntry(table, propertyName);
00768
if (entry) {
00769
if (entry->attr & Function)
00770 {
00771 ObjectImp::put(exec, propertyName, value, attr);
00772
return;
00773 }
00774
else if ((entry->attr & ReadOnly) == 0)
00775 {
00776 putValueProperty(exec, entry->value, value, attr);
00777
return;
00778 }
00779 }
00780 DOMObjectLookupPut<DOMCSSRule, DOMObject>(exec, propertyName, value, attr, &DOMCSSRuleTable,
this);
00781 }
00782
00783
void DOMCSSRule::putValueProperty(ExecState *exec,
int token,
const Value& value,
int)
00784 {
00785
switch (token) {
00786
00787
case Style_SelectorText:
00788 static_cast<DOM::CSSStyleRule>(cssRule).setSelectorText(value.toString(exec).string());
00789
return;
00790
00791
00792
case Page_SelectorText:
00793 static_cast<DOM::CSSPageRule>(cssRule).setSelectorText(value.toString(exec).string());
00794
return;
00795
00796
00797
case Charset_Encoding:
00798 static_cast<DOM::CSSCharsetRule>(cssRule).setEncoding(value.toString(exec).string());
00799
return;
00800
00801
default:
00802
kdDebug(6070) <<
"WARNING: DOMCSSRule::putValueProperty unhandled token " << token <<
endl;
00803 }
00804 }
00805
00806 Value DOMCSSRuleFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
00807 {
00808 KJS_CHECK_THIS( KJS::DOMCSSRule, thisObj );
00809
DOM::CSSRule cssRule = static_cast<DOMCSSRule *>(thisObj.imp())->toCSSRule();
00810
00811
if (cssRule.
type() == DOM::CSSRule::MEDIA_RULE) {
00812
DOM::CSSMediaRule rule = static_cast<DOM::CSSMediaRule>(cssRule);
00813
if (
id == DOMCSSRule::Media_InsertRule)
00814
return Number(rule.
insertRule(args[0].toString(exec).string(),args[1].toInteger(exec)));
00815
else if (
id == DOMCSSRule::Media_DeleteRule)
00816 rule.
deleteRule(args[0].toInteger(exec));
00817 }
00818
00819
return Undefined();
00820 }
00821
00822 Value KJS::getDOMCSSRule(ExecState *exec,
const DOM::CSSRule& r)
00823 {
00824
return cacheDOMObject<DOM::CSSRule, KJS::DOMCSSRule>(exec, r);
00825 }
00826
00827
00828
00829
00830
DOM::CSSRule KJS::toCSSRule(
const Value& val)
00831 {
00832 Object obj = Object::dynamicCast(val);
00833
if (obj.isNull() || !obj.inherits(&DOMCSSRule::info))
00834
return DOM::CSSRule();
00835
00836
const DOMCSSRule *dobj = static_cast<const DOMCSSRule*>(obj.imp());
00837
return dobj->toCSSRule();
00838 }
00839
00840
00841
00842
const ClassInfo CSSRuleConstructor::info = {
"CSSRuleConstructor", 0, &CSSRuleConstructorTable, 0 };
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855 CSSRuleConstructor::CSSRuleConstructor(ExecState *exec)
00856 :
DOMObject(exec->interpreter()->builtinObjectPrototype())
00857 {
00858 }
00859
00860 Value CSSRuleConstructor::tryGet(ExecState *exec,
const Identifier &p)
const
00861
{
00862
return DOMObjectLookupGetValue<CSSRuleConstructor,DOMObject>(exec,p,&CSSRuleConstructorTable,
this);
00863 }
00864
00865 Value CSSRuleConstructor::getValueProperty(ExecState *,
int token)
const
00866
{
00867
switch (token) {
00868
case UNKNOWN_RULE:
00869
return Number(DOM::CSSRule::UNKNOWN_RULE);
00870
case STYLE_RULE:
00871
return Number(DOM::CSSRule::STYLE_RULE);
00872
case CHARSET_RULE:
00873
return Number(DOM::CSSRule::CHARSET_RULE);
00874
case IMPORT_RULE:
00875
return Number(DOM::CSSRule::IMPORT_RULE);
00876
case MEDIA_RULE:
00877
return Number(DOM::CSSRule::MEDIA_RULE);
00878
case FONT_FACE_RULE:
00879
return Number(DOM::CSSRule::FONT_FACE_RULE);
00880
case PAGE_RULE:
00881
return Number(DOM::CSSRule::PAGE_RULE);
00882 }
00883
return Value();
00884 }
00885
00886 Value KJS::getCSSRuleConstructor(ExecState *exec)
00887 {
00888
return cacheGlobalObject<CSSRuleConstructor>( exec,
"[[cssRule.constructor]]" );
00889 }
00890
00891
00892
00893
const ClassInfo DOMCSSValue::info = {
"CSSValue", 0, &DOMCSSValueTable, 0 };
00894
00895
00896
00897
00898
00899
00900
00901
00902 DOMCSSValue::DOMCSSValue(ExecState* exec,
const DOM::CSSValue& val)
00903 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), cssValue(val)
00904 {
00905 }
00906
00907 DOMCSSValue::~DOMCSSValue()
00908 {
00909 ScriptInterpreter::forgetDOMObject(cssValue.handle());
00910 }
00911
00912 Value DOMCSSValue::tryGet(ExecState *exec,
const Identifier &p)
const
00913
{
00914
if (p ==
"cssText")
00915
return String(cssValue.cssText());
00916
else if (p ==
"cssValueType")
00917
return Number(cssValue.cssValueType());
00918
return DOMObject::tryGet(exec,p);
00919 }
00920
00921
void DOMCSSValue::tryPut(ExecState *exec,
const Identifier &propertyName,
const Value& value,
int attr)
00922 {
00923
if (propertyName ==
"cssText")
00924 cssValue.setCssText(value.toString(exec).string());
00925
else
00926 DOMObject::tryPut(exec, propertyName, value, attr);
00927 }
00928
00929 Value KJS::getDOMCSSValue(ExecState *exec,
const DOM::CSSValue& v)
00930 {
00931
DOMObject *ret;
00932
if (v.
isNull())
00933
return Null();
00934
ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
00935
if ((ret = interp->
getDOMObject(v.
handle())))
00936
return Value(ret);
00937
else {
00938
if (v.
isCSSValueList())
00939 ret =
new DOMCSSValueList(exec,v);
00940
else if (v.
isCSSPrimitiveValue())
00941 ret =
new DOMCSSPrimitiveValue(exec,v);
00942
else
00943 ret =
new DOMCSSValue(exec,v);
00944 interp->
putDOMObject(v.
handle(),ret);
00945
return Value(ret);
00946 }
00947 }
00948
00949
00950
00951
const ClassInfo CSSValueConstructor::info = {
"CSSValueConstructor", 0, &CSSValueConstructorTable, 0 };
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961 CSSValueConstructor::CSSValueConstructor(ExecState *exec)
00962 :
DOMObject(exec->interpreter()->builtinObjectPrototype())
00963 {
00964 }
00965
00966 Value CSSValueConstructor::tryGet(ExecState *exec,
const Identifier &p)
const
00967
{
00968
return DOMObjectLookupGetValue<CSSValueConstructor,DOMObject>(exec,p,&CSSValueConstructorTable,
this);
00969 }
00970
00971 Value CSSValueConstructor::getValueProperty(ExecState *,
int token)
const
00972
{
00973
switch (token) {
00974
case CSS_INHERIT:
00975
return Number(DOM::CSSValue::CSS_INHERIT);
00976
case CSS_PRIMITIVE_VALUE:
00977
return Number(DOM::CSSValue::CSS_PRIMITIVE_VALUE);
00978
case CSS_VALUE_LIST:
00979
return Number(DOM::CSSValue::CSS_VALUE_LIST);
00980
case CSS_CUSTOM:
00981
return Number(DOM::CSSValue::CSS_CUSTOM);
00982 }
00983
return Value();
00984 }
00985
00986 Value KJS::getCSSValueConstructor(ExecState *exec)
00987 {
00988
return cacheGlobalObject<CSSValueConstructor>( exec,
"[[cssValue.constructor]]" );
00989 }
00990
00991
00992
00993
const ClassInfo DOMCSSPrimitiveValue::info = {
"CSSPrimitiveValue", 0, &DOMCSSPrimitiveValueTable, 0 };
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008 DEFINE_PROTOTYPE(
"DOMCSSPrimitiveValue",DOMCSSPrimitiveValueProto)
01009 IMPLEMENT_PROTOFUNC_DOM(DOMCSSPrimitiveValueProtoFunc)
01010 IMPLEMENT_PROTOTYPE(DOMCSSPrimitiveValueProto,DOMCSSPrimitiveValueProtoFunc)
01011
01012 DOMCSSPrimitiveValue::DOMCSSPrimitiveValue(ExecState *exec, const DOM::CSSPrimitiveValue& v)
01013 : DOMCSSValue(DOMCSSPrimitiveValueProto::self(exec), v) { }
01014
01015 Value DOMCSSPrimitiveValue::tryGet(ExecState *exec,
const Identifier &p)
const
01016
{
01017
if (p==
"primitiveType")
01018
return Number(static_cast<DOM::CSSPrimitiveValue>(cssValue).primitiveType());
01019
return DOMObject::tryGet(exec,p);
01020 }
01021
01022 Value DOMCSSPrimitiveValueProtoFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
01023 {
01024 KJS_CHECK_THIS( KJS::DOMCSSPrimitiveValue, thisObj );
01025
DOM::CSSPrimitiveValue val = static_cast<DOMCSSPrimitiveValue *>(thisObj.imp())->toCSSPrimitiveValue();
01026
switch (
id) {
01027
case DOMCSSPrimitiveValue::SetFloatValue:
01028 val.
setFloatValue(args[0].toInteger(exec),args[1].toNumber(exec));
01029
return Undefined();
01030
case DOMCSSPrimitiveValue::GetFloatValue:
01031
return Number(val.
getFloatValue(args[0].toInteger(exec)));
01032
case DOMCSSPrimitiveValue::SetStringValue:
01033 val.
setStringValue(args[0].toInteger(exec),args[1].toString(exec).string());
01034
return Undefined();
01035
case DOMCSSPrimitiveValue::GetStringValue:
01036
return String(val.
getStringValue());
01037
case DOMCSSPrimitiveValue::GetCounterValue:
01038
return getDOMCounter(exec,val.
getCounterValue());
01039
case DOMCSSPrimitiveValue::GetRectValue:
01040
return getDOMRect(exec,val.
getRectValue());
01041
case DOMCSSPrimitiveValue::GetRGBColorValue:
01042
return getDOMRGBColor(exec,val.
getRGBColorValue());
01043
default:
01044
return Undefined();
01045 }
01046 }
01047
01048
01049
01050
const ClassInfo CSSPrimitiveValueConstructor::info = {
"CSSPrimitiveValueConstructor", 0, &CSSPrimitiveValueConstructorTable, 0 };
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080
01081
01082
01083 Value CSSPrimitiveValueConstructor::tryGet(ExecState *exec,
const Identifier &p)
const
01084
{
01085
return DOMObjectLookupGetValue<CSSPrimitiveValueConstructor,CSSValueConstructor>(exec,p,&CSSPrimitiveValueConstructorTable,
this);
01086 }
01087
01088 Value CSSPrimitiveValueConstructor::getValueProperty(ExecState *,
int token)
const
01089
{
01090
01091
return Number(token);
01092 }
01093
01094 Value KJS::getCSSPrimitiveValueConstructor(ExecState *exec)
01095 {
01096
return cacheGlobalObject<CSSPrimitiveValueConstructor>( exec,
"[[cssPrimitiveValue.constructor]]" );
01097 }
01098
01099
01100
01101
const ClassInfo DOMCSSValueList::info = {
"CSSValueList", 0, &DOMCSSValueListTable, 0 };
01102
01103
01104
01105
01106
01107
01108
01109 IMPLEMENT_PROTOFUNC_DOM(DOMCSSValueListFunc)
01110
01111 DOMCSSValueList::DOMCSSValueList(ExecState *exec, const DOM::
CSSValueList& v)
01112 : DOMCSSValue(exec, v) { }
01113
01114 Value DOMCSSValueList::tryGet(ExecState *exec,
const Identifier &p)
const
01115
{
01116 Value result;
01117
DOM::CSSValueList valueList = static_cast<DOM::CSSValueList>(cssValue);
01118
01119
if (p == lengthPropertyName)
01120
return Number(valueList.
length());
01121
else if (p ==
"item")
01122
return lookupOrCreateFunction<DOMCSSValueListFunc>(exec,p,
this,DOMCSSValueList::Item,1,DontDelete|Function);
01123
01124
bool ok;
01125
long unsigned int u = p.toULong(&ok);
01126
if (ok)
01127
return getDOMCSSValue(exec,valueList.
item(u));
01128
01129
return DOMCSSValue::tryGet(exec,p);
01130 }
01131
01132 Value DOMCSSValueListFunc::tryCall(ExecState *exec, Object &thisObj,
const List &args)
01133 {
01134 KJS_CHECK_THIS( KJS::DOMCSSValueList, thisObj );
01135
DOM::CSSValueList valueList = static_cast<DOMCSSValueList *>(thisObj.imp())->toValueList();
01136
switch (
id) {
01137
case DOMCSSValueList::Item:
01138
return getDOMCSSValue(exec,valueList.
item(args[0].toInteger(exec)));
01139
default:
01140
return Undefined();
01141 }
01142 }
01143
01144
01145
01146
const ClassInfo DOMRGBColor::info = {
"RGBColor", 0, &DOMRGBColorTable, 0 };
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156 DOMRGBColor::DOMRGBColor(ExecState* exec,
const DOM::RGBColor& c)
01157 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), rgbColor(c)
01158 {
01159 }
01160
01161 DOMRGBColor::~DOMRGBColor()
01162 {
01163
01164 }
01165
01166 Value DOMRGBColor::tryGet(ExecState *exec,
const Identifier &p)
const
01167
{
01168
return DOMObjectLookupGetValue<DOMRGBColor,DOMObject>(exec, p,
01169 &DOMRGBColorTable,
01170
this);
01171 }
01172
01173 Value DOMRGBColor::getValueProperty(ExecState *exec,
int token)
const
01174
{
01175
switch (token) {
01176
case Red:
01177
return getDOMCSSValue(exec, rgbColor.red());
01178
case Green:
01179
return getDOMCSSValue(exec, rgbColor.green());
01180
case Blue:
01181
return getDOMCSSValue(exec, rgbColor.blue());
01182
default:
01183
return Value();
01184 }
01185 }
01186
01187 Value KJS::getDOMRGBColor(ExecState *exec,
const DOM::RGBColor& c)
01188 {
01189
01190
return Value(
new DOMRGBColor(exec, c));
01191 }
01192
01193
01194
01195
const ClassInfo DOMRect::info = {
"Rect", 0, &DOMRectTable, 0 };
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205 DOMRect::DOMRect(ExecState *exec,
const DOM::Rect& r)
01206 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), rect(r)
01207 {
01208 }
01209
01210 DOMRect::~DOMRect()
01211 {
01212 ScriptInterpreter::forgetDOMObject(rect.handle());
01213 }
01214
01215 Value DOMRect::tryGet(ExecState *exec,
const Identifier &p)
const
01216
{
01217
return DOMObjectLookupGetValue<DOMRect,DOMObject>(exec, p,
01218 &DOMRectTable,
this);
01219 }
01220
01221 Value DOMRect::getValueProperty(ExecState *exec,
int token)
const
01222
{
01223
switch (token) {
01224
case Top:
01225
return getDOMCSSValue(exec, rect.top());
01226
case Right:
01227
return getDOMCSSValue(exec, rect.right());
01228
case Bottom:
01229
return getDOMCSSValue(exec, rect.bottom());
01230
case Left:
01231
return getDOMCSSValue(exec, rect.left());
01232
default:
01233
return Value();
01234 }
01235 }
01236
01237 Value KJS::getDOMRect(ExecState *exec,
const DOM::Rect& r)
01238 {
01239
return cacheDOMObject<DOM::Rect, KJS::DOMRect>(exec, r);
01240 }
01241
01242
01243
01244
const ClassInfo DOMCounter::info = {
"Counter", 0, &DOMCounterTable, 0 };
01245
01246
01247
01248
01249
01250
01251
01252 DOMCounter::DOMCounter(ExecState *exec,
const DOM::Counter& c)
01253 :
DOMObject(exec->interpreter()->builtinObjectPrototype()), counter(c)
01254 {
01255 }
01256
01257 DOMCounter::~DOMCounter()
01258 {
01259 ScriptInterpreter::forgetDOMObject(counter.handle());
01260 }
01261
01262 Value DOMCounter::tryGet(ExecState *exec,
const Identifier &p)
const
01263
{
01264
return DOMObjectLookupGetValue<DOMCounter,DOMObject>(exec, p,
01265 &DOMCounterTable,
this);
01266 }
01267
01268 Value DOMCounter::getValueProperty(ExecState *,
int token)
const
01269
{
01270
switch (token) {
01271
case identifier:
01272
return String(counter.identifier());
01273
case listStyle:
01274
return String(counter.listStyle());
01275
case separator:
01276
return String(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 }