diff options
Diffstat (limited to 'tdehtml/ecma')
40 files changed, 18689 insertions, 0 deletions
diff --git a/tdehtml/ecma/AUTHORS b/tdehtml/ecma/AUTHORS new file mode 100644 index 000000000..2a129330d --- /dev/null +++ b/tdehtml/ecma/AUTHORS @@ -0,0 +1,4 @@ +Harri Porten <porten@kde.org> +Peter Kelly <pmk@post.com> +Dirk Mueller <mueller@kde.org> +Daniel Molkentin <molkentin@kde.org> diff --git a/tdehtml/ecma/CMakeLists.txt b/tdehtml/ecma/CMakeLists.txt new file mode 100644 index 000000000..eddd99f1e --- /dev/null +++ b/tdehtml/ecma/CMakeLists.txt @@ -0,0 +1,61 @@ +################################################# +# +# (C) 2010 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +include_directories( + ${TQT_INCLUDE_DIRS} + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_BINARY_DIR} + ${CMAKE_BINARY_DIR}/kjs + ${CMAKE_BINARY_DIR}/tdecore + ${CMAKE_SOURCE_DIR} + ${CMAKE_SOURCE_DIR}/tdehtml + ${CMAKE_SOURCE_DIR}/dcop + ${CMAKE_SOURCE_DIR}/tdefx + ${CMAKE_SOURCE_DIR}/tdecore + ${CMAKE_SOURCE_DIR}/tdeui + ${CMAKE_SOURCE_DIR}/kio + ${CMAKE_SOURCE_DIR}/kio/kio + ${CMAKE_SOURCE_DIR}/kio/bookmarks + ${CMAKE_SOURCE_DIR}/kjs + ${CMAKE_SOURCE_DIR}/tdewallet/client + ${CMAKE_SOURCE_DIR}/tdeutils +) + +link_directories( + ${TQT_LIBRARY_DIRS} +) + + +##### kjs_html-static ########################### + +set( target kjs_html ) + +set( ${target}_SRCS + kjs_binding.cpp kjs_dom.cpp kjs_html.cpp kjs_window.cpp + kjs_navigator.cpp kjs_proxy.cpp kjs_css.cpp + kjs_range.cpp kjs_traversal.cpp kjs_events.cpp + kjs_views.cpp kjs_debugwin.cpp kjs_mozilla.cpp + xmlhttprequest.cpp xmlserializer.cpp domparser.cpp +) + +set( ${target}_LUTS + kjs_dom.cpp kjs_html.cpp kjs_css.cpp kjs_events.cpp + kjs_navigator.cpp kjs_mozilla.cpp kjs_range.cpp + kjs_traversal.cpp kjs_views.cpp kjs_window.cpp + xmlhttprequest.cpp xmlserializer.cpp domparser.cpp +) + +tde_add_luts( ${${target}_LUTS} ) + +tde_add_library( ${target} STATIC_PIC AUTOMOC + SOURCES ${${target}_SRCS} +) + diff --git a/tdehtml/ecma/Makefile.am b/tdehtml/ecma/Makefile.am new file mode 100644 index 000000000..d69ff807b --- /dev/null +++ b/tdehtml/ecma/Makefile.am @@ -0,0 +1,90 @@ +# This file is part of the KDE libraries +# Copyright (C) 1999 Harri Porten (porten@kde.org) + +# 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; see the file COPYING.LIB. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +# Boston, MA 02110-1301, USA. + +INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/kio -I$(top_srcdir)/kio/bookmarks -I$(top_srcdir)/tdehtml -I$(top_srcdir)/tdehtml/java -I$(top_srcdir)/tdewallet/client -I$(top_srcdir)/tdeutils -I$(top_builddir)/kjs $(all_includes) + +KDE_CXXFLAGS = $(USE_EXCEPTIONS) + +noinst_LTLIBRARIES = libkjs_html.la + +noinst_HEADERS = kjs_html.h kjs_dom.h kjs_window.h kjs_navigator.h \ + kjs_binding.h kjs_proxy.h kjs_css.h kjs_range.h \ + kjs_traversal.h kjs_events.h kjs_views.h kjs_debugwin.h + +libkjs_html_la_SOURCES = kjs_binding.cpp kjs_dom.cpp kjs_html.cpp kjs_window.cpp \ + kjs_navigator.cpp kjs_proxy.cpp \ + kjs_css.cpp kjs_range.cpp kjs_traversal.cpp kjs_events.cpp \ + kjs_views.cpp kjs_debugwin.cpp kjs_mozilla.cpp xmlhttprequest.cpp \ + xmlserializer.cpp domparser.cpp +#libkjs_html_la_LDFLAGS = -module -avoid-version $(all_libraries) +libkjs_html_la_LIBADD = $(top_builddir)/kjs/libkjs.la # ../libtdehtml.la +libkjs_html_la_METASOURCES = AUTO + +LUT_FILES = kjs_dom.lut.h kjs_html.lut.h kjs_css.lut.h kjs_events.lut.h kjs_navigator.lut.h \ + kjs_mozilla.lut.h kjs_range.lut.h kjs_traversal.lut.h kjs_views.lut.h kjs_window.lut.h + +CREATE_HASH_TABLE = $(top_srcdir)/kjs/create_hash_table + +kjs_dom.lut.h : $(srcdir)/kjs_dom.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_dom.cpp > $@ +kjs_dom.lo: kjs_dom.lut.h +kjs_html.lut.h : $(srcdir)/kjs_html.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_html.cpp > $@ +kjs_html.lo: kjs_html.lut.h +kjs_css.lut.h : $(srcdir)/kjs_css.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_css.cpp > $@ +kjs_css.lo: kjs_css.lut.h +kjs_events.lut.h : $(srcdir)/kjs_events.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_events.cpp > $@ +kjs_events.lo: kjs_events.lut.h +kjs_navigator.lut.h : $(srcdir)/kjs_navigator.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_navigator.cpp > $@ +kjs_navigator.lo: kjs_navigator.lut.h +kjs_mozilla.lut.h : $(srcdir)/kjs_mozilla.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_mozilla.cpp > $@ +kjs_mozilla.lo: kjs_mozilla.lut.h +kjs_range.lut.h : $(srcdir)/kjs_range.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_range.cpp > $@ +kjs_range.lo: kjs_range.lut.h +kjs_traversal.lut.h : $(srcdir)/kjs_traversal.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_traversal.cpp > $@ +kjs_traversal.lo: kjs_traversal.lut.h +kjs_views.lut.h : $(srcdir)/kjs_views.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_views.cpp > $@ +kjs_views.lo: kjs_views.lut.h +kjs_window.lut.h : $(srcdir)/kjs_window.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/kjs_window.cpp > $@ +kjs_window.lo: kjs_window.lut.h +xmlhttprequest.lut.h : $(srcdir)/xmlhttprequest.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/xmlhttprequest.cpp > $@ +xmlhttprequest.lo: xmlhttprequest.lut.h +xmlserializer.lut.h : $(srcdir)/xmlserializer.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/xmlserializer.cpp > $@ +xmlserializer.lo: xmlserializer.lut.h +domparser.lut.h : $(srcdir)/domparser.cpp $(CREATE_HASH_TABLE) + $(PERL) $(CREATE_HASH_TABLE) $(srcdir)/domparser.cpp > $@ +domparser.lo: domparser.lut.h + + +CLEANFILES = $(LUT_FILES) + +# interactive test program +#check_PROGRAMS = testecma +#testecma_SOURCES = testecma.cpp +#testecma_LDADD = ../libtdehtml.la $(top_builddir)/kjs/libkjs.la + diff --git a/tdehtml/ecma/README b/tdehtml/ecma/README new file mode 100644 index 000000000..4c341699a --- /dev/null +++ b/tdehtml/ecma/README @@ -0,0 +1,21 @@ +This module contains the ECMAScript a.k.a. JavaScript language bindings for +the KHTML Part. + +The module is loaded into KHTML's address space on demand. + +To test the non-HTML DOM functions you may compile a little interactive +interpreter called 'testecma' with 'make check' (see testecma.cpp for +further details). + +Harri Porten <porten@kde.org> + +======================================================================== +Appendix A: Web sites with useful tests + +http://oucsace.cs.ohiou.edu/~ywang/JavaScript +http://www.xs4all.nl/~ppk/js/index.html?version5.html + +Appendix B: References for HTML JavaScript bindings + +http://msdn.microsoft.com/workshop/author/dhtml/reference/objects.asp +http://docs.sun.com/source/816-6408-10/ diff --git a/tdehtml/ecma/THANKS b/tdehtml/ecma/THANKS new file mode 100644 index 000000000..b21dce741 --- /dev/null +++ b/tdehtml/ecma/THANKS @@ -0,0 +1,9 @@ +Vadim Plessky <lucy-ples@mtu-net.ru> for dissecting an endless number +of bug reports and therefore taking quite some load of our shoulders. + +Ferdinand Gassauer <f.gassauer@aon.at> for numerous useful bug reports +and keeping track of them later. + +David Faure <faure@kde.org> for taking some time off from Konqueror +and making a lotto site working fixing bugs along the way. + diff --git a/tdehtml/ecma/TODO b/tdehtml/ecma/TODO new file mode 100644 index 000000000..16a7152c5 --- /dev/null +++ b/tdehtml/ecma/TODO @@ -0,0 +1,12 @@ +Has to be done +============== +- frame[] correct search and sorting order (DONE ?) +- optional error message output +- change KParts::WindowArgs && friends + that we can detect if a locationbar is on/or not + +Could be done +============= +- Make the graphical debugger useable +- Improve internal structures to give a really useful + output on errors (i.e. improve backtrance capabilities) diff --git a/tdehtml/ecma/domparser.cpp b/tdehtml/ecma/domparser.cpp new file mode 100644 index 000000000..672754a45 --- /dev/null +++ b/tdehtml/ecma/domparser.cpp @@ -0,0 +1,112 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2005 Anders Carlsson (andersca@mac.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 "domparser.h" +#include "domparser.lut.h" + +#include "kjs_dom.h" +#include "kjs_window.h" +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" + +#include "html/html_documentimpl.h" + +using DOM::DocumentImpl; + +////////////////////// DOMParser Object //////////////////////// + +/* Source for DOMParserProtoTable. +@begin DOMParserProtoTable 1 + parseFromString DOMParser::ParseFromString DontDelete|Function 2 +@end +*/ + + +namespace KJS { + +KJS_DEFINE_PROTOTYPE(DOMParserProto) +IMPLEMENT_PROTOFUNC_DOM(DOMParserProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMParser", DOMParserProto, DOMParserProtoFunc) + + +DOMParserConstructorImp::DOMParserConstructorImp(ExecState *, DOM::DocumentImpl *d) + : doc(d) +{ +} + +bool DOMParserConstructorImp::implementsConstruct() const +{ + return true; +} + +Object DOMParserConstructorImp::construct(ExecState *exec, const List &) +{ + return Object(new DOMParser(exec, doc.get())); +} + +const ClassInfo DOMParser::info = { "DOMParser", 0, 0 /* &DOMParserTable*/, 0 }; + + +DOMParser::DOMParser(ExecState *exec, DOM::DocumentImpl *d) + : DOMObject(DOMParserProto::self(exec)), doc(d) +{ +// setPrototype(DOMParserProto::self(exec)); +} + + +Value DOMParserProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + if (!thisObj.inherits(&DOMParser::info)) { + Object err = Error::create(exec,TypeError); + exec->setException(err); + return err; + } + + DOMParser *parser = static_cast<DOMParser *>(thisObj.imp()); + + switch (id) { + case DOMParser::ParseFromString: + { + if (args.size() != 2) { + return Undefined(); + } + + TQString str = args[0].toString(exec).qstring(); + TQString contentType = args[1].toString(exec).qstring().stripWhiteSpace(); + + if (contentType == "text/xml" || contentType == "application/xml" || contentType == "application/xhtml+xml") { + DocumentImpl *docImpl = parser->doc->implementation()->createDocument(); + + docImpl->open(); + docImpl->write(str); + docImpl->finishParsing(); + docImpl->close(); + + return getDOMNode(exec, docImpl); + } + } + } + + return Undefined(); +} + +} // end namespace + + diff --git a/tdehtml/ecma/domparser.h b/tdehtml/ecma/domparser.h new file mode 100644 index 000000000..13a880837 --- /dev/null +++ b/tdehtml/ecma/domparser.h @@ -0,0 +1,58 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2005 Anders Carlsson (andersca@mac.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 + */ + +#ifndef DOMPARSER_H +#define DOMPARSER_H + +#include <tqguardedptr.h> +#include <kjs/object.h> +#include <kjs/interpreter.h> +#include <misc/shared.h> + +#include "kjs_dom.h" + +namespace KJS { + + class DOMParserConstructorImp : public ObjectImp { + public: + DOMParserConstructorImp(ExecState *, DOM::DocumentImpl *d); + virtual bool implementsConstruct() const; + virtual Object construct(ExecState *exec, const List &args); +private: + tdehtml::SharedPtr<DOM::DocumentImpl> doc; + }; + + class DOMParser : public DOMObject { + public: + DOMParser(ExecState *, DOM::DocumentImpl *d); + virtual bool toBoolean(ExecState *) const { return true; } + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { ParseFromString }; + + private: + TQGuardedPtr<DOM::DocumentImpl> doc; + + friend class DOMParserProtoFunc; + }; + +} // namespace + +#endif diff --git a/tdehtml/ecma/jsk.html b/tdehtml/ecma/jsk.html new file mode 100644 index 000000000..917c083e8 --- /dev/null +++ b/tdehtml/ecma/jsk.html @@ -0,0 +1,113 @@ +<html> +<!-- +Javascript Konsole (c) 2001 Till Krech <till@snafu.de> +Dieser Code unterliegt den Bedingungen der Gnu Public License Version 2. +--> +<head> +<title>Javascript Konsole</title> +<style type="text/css"> +code { + color:#444488; +} +em { + font-weight: bold; +} +</style> +<script language="JavaScript"> + +function do_eval() { + var fo = document.forms.fo; + fo.restyp.value = ""; + fo.field.value = ""; + var fo = document.fo; + var expr = fo.zeile.value; + var result = eval(expr); + fo.restyp.value = typeof(result); + var tuedel = ""; + if (typeof(result) == "string") { + tuedel = '"'; + } + fo.field.value = tuedel + result + tuedel; +} + +function do_properties() { + var fo = document.forms.fo; + fo.restyp.value = ""; + fo.field.value = ""; + var fo = document.fo; + var expr = fo.zeile.value; + var result = eval(expr); + var i; + fo.restyp.value = typeof(result); + var fieldvalue = ""; + if (typeof(result) != "undefined") { + for (i in result) { + var tuedel = ""; + var propval = result[i]; + if (typeof(propval) == "string") { + tuedel = '"'; + } + fieldvalue += + i + + " [" + typeof(propval) + "] = " + + tuedel + propval + tuedel + "\n"; + } + fo.field.value = fieldvalue; + } +} + + +</script> +</head> +<body bgcolor="#dddddd"> +<h1>JavaScript Konsole</h1> +<form name="fo"> +<table bgcolor="#cccccc" cellspacing="1" cellpadding="8"> + <tr bgcolor="#ffeeee"><th height="40" align="right">Expression</th><td><input name="zeile" type="text" size="60"></td></tr> + <tr bgcolor="#eeeeee"><th align="right">Result Type</th><td><input name="restyp" readonly type="text" size="60"></td></tr> + <tr bgcolor="#eeeeee"><th align="right">Result(s)</th><td><textarea readonly name="field" rows="10" cols="60"></textarea></td></tr> +<tr bgcolor="#ffeeee"><td> </td><td> + <input type="button" value="list properties" onclick="do_properties()"> + <input type="button" value="evaluate" onclick="do_eval()"> + <input type="reset" value="clear fields" +</td></tr> +</table> +</form> +<h2>Explanation</h2> +<h3>Operation</h3> +<blockquote> +When <em>evaluate</em> is pressed, the given expression is evaluated and the result is displayed in the result(s) field. +In case of <em>list properties</em> being pressed, the result of the expression is taken as an object +and the objects properties are displayed with their type and value in the the result(s) field. +</blockquote> +<h3>Expression</h3> +<blockquote> +Expression must be a valid javascript expression, e.g.<br><code>window</code> +<br>or<br><code>document.body.innerHTML</code><br>or<br> +<code>"Today: " + (new Date()).toString()</code><br> +or<br> +<code>"Cablecar".match(/ab.*c/)</code> +<br>It is also possible to assign a value, +e.g.<br><code>document.getElementsByTagName('H1').item(0).innerText="Hello World"</code><br> +You may execute these examples by pasting them into the expression field. +</blockquote> +<h3>Result Type</h3> +<blockquote> +The type of the result of the given expression. +</blockquote> +<h3>Result(s)</h3> +<blockquote> +The result of the expression is implicitly converted to a primitive type by the javascript interpreter, +if <em>evaluate</em> was pressed. When <em>list properties</em> was pressed, a <code>for (var i in obj)</code> loop +is executed to list the properties. These object properties are in turn evaluated and their types and values +are displayed. +</blockquote> +<p> +<a href="mailto:till@snafu.de?subject=JavaScript%20Konsole">Till Krech</a> +</p> +<p> +<br> +</p> + +</body> +</html> diff --git a/tdehtml/ecma/kjs_binding.cpp b/tdehtml/ecma/kjs_binding.cpp new file mode 100644 index 000000000..09961fbb5 --- /dev/null +++ b/tdehtml/ecma/kjs_binding.cpp @@ -0,0 +1,467 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 1999-2003 Harri Porten (porten@kde.org) + * Copyright (C) 2001-2003 David Faure (faure@kde.org) + * 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_binding.h" +#include "kjs_dom.h" + +#include "dom/dom_exception.h" +#include "dom/dom2_range.h" +#include "xml/dom2_eventsimpl.h" +#include "tdehtmlpart_p.h" + +#include <kdebug.h> +#include <tdeparts/browserextension.h> + +#include <assert.h> + +using namespace KJS; + +/* TODO: + * The catch all (...) clauses below shouldn't be necessary. + * But they helped to view for example www.faz.net in an stable manner. + * Those unknown exceptions should be treated as severe bugs and be fixed. + * + * these may be CSS exceptions - need to check - pmk + */ + +Value DOMObject::get(ExecState *exec, const Identifier &p) const +{ + Value result; + try { + result = tryGet(exec,p); + } + catch (DOM::DOMException e) { + // ### translate code into readable string ? + // ### oh, and s/QString/i18n or I18N_NOOP (the code in kjs uses I18N_NOOP... but where is it translated ?) + // and where does it appear to the user ? + Object err = Error::create(exec, GeneralError, TQString(TQString("DOM exception %1").arg(e.code)).local8Bit()); + exec->setException( err ); + result = Undefined(); + } + catch (...) { + kdError(6070) << "Unknown exception in DOMObject::get()" << endl; + result = String("Unknown exception"); + } + + return result; +} + +void DOMObject::put(ExecState *exec, const Identifier &propertyName, + const Value &value, int attr) +{ + try { + tryPut(exec, propertyName, value, attr); + } + catch (DOM::DOMException e) { + Object err = Error::create(exec, GeneralError, TQString(TQString("DOM exception %1").arg(e.code)).local8Bit()); + exec->setException(err); + } + catch (...) { + kdError(6070) << "Unknown exception in DOMObject::put()" << endl; + } +} + +void DOMObject::tryPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr) +{ + static_cast<ScriptInterpreter*>(exec->dynamicInterpreter())->customizedDOMObject(this); + ObjectImp::put(exec,propertyName,value,attr); +} + +UString DOMObject::toString(ExecState *) const +{ + return "[object " + className() + "]"; +} + +Boolean DOMObject::hasInstance(ExecState *exec, const Value &value) +{ + if (value.type() != ObjectType) + return Boolean(false); + + Value prot = get(exec,prototypePropertyName); + if (prot.type() != ObjectType && prot.type() != NullType) { + Object err = Error::create(exec, TypeError, "Invalid prototype encountered " + "in instanceof operation."); + exec->setException(err); + return Boolean(false); + } + + Object v = Object(static_cast<ObjectImp*>(value.imp())); + while ((v = Object::dynamicCast(v.prototype())).imp()) { + if (v.imp() == prot.imp()) + return Boolean(true); + } + return Boolean(false); +} + + +Value DOMFunction::get(ExecState *exec, const Identifier &propertyName) const +{ + try { + return tryGet(exec, propertyName); + } + catch (DOM::DOMException e) { + Object err = Error::create(exec, GeneralError, TQString(TQString("DOM exception %1").arg(e.code)).local8Bit()); + exec->setException(err); + return Undefined(); + } + catch (...) { + kdError(6070) << "Unknown exception in DOMFunction::get()" << endl; + return String("Unknown exception"); + } +} + +Value DOMFunction::call(ExecState *exec, Object &thisObj, const List &args) +{ + try { + return tryCall(exec, thisObj, args); + } + // pity there's no way to distinguish between these in JS code + // ### Look into setting prototypes of these & the use of instanceof so the exception + // type can be determined. See what other browsers do. + catch (DOM::DOMException e) { + Object err = Error::create(exec, GeneralError, TQString(TQString("DOM Exception %1").arg(e.code)).local8Bit()); + err.put(exec, "code", Number(e.code)); + exec->setException(err); + return Undefined(); + } + catch (DOM::RangeException e) { + Object err = Error::create(exec, GeneralError, TQString(TQString("DOM Range Exception %1").arg(e.code)).local8Bit()); + err.put(exec, "code", Number(e.code)); + exec->setException(err); + return Undefined(); + } + catch (DOM::CSSException e) { + Object err = Error::create(exec, GeneralError, TQString(TQString("CSS Exception %1").arg(e.code)).local8Bit()); + err.put(exec, "code", Number(e.code)); + exec->setException(err); + return Undefined(); + } + catch (DOM::EventException e) { + Object err = Error::create(exec, GeneralError, TQString(TQString("DOM Event Exception %1").arg(e.code)).local8Bit()); + err.put(exec, "code", Number(e.code)); + exec->setException(err); + return Undefined(); + } + catch (...) { + kdError(6070) << "Unknown exception in DOMFunction::call()" << endl; + Object err = Error::create(exec, GeneralError, "Unknown exception"); + exec->setException(err); + return Undefined(); + } +} + +typedef TQPtrList<ScriptInterpreter> InterpreterList; +static InterpreterList *interpreterList; + +ScriptInterpreter::ScriptInterpreter( const Object &global, tdehtml::ChildFrame* frame ) + : Interpreter( global ), m_frame( frame ), m_domObjects(1021), + m_evt( 0L ), m_inlineCode(false), m_timerCallback(false) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "ScriptInterpreter::ScriptInterpreter " << this << " for part=" << m_frame << endl; +#endif + if ( !interpreterList ) + interpreterList = new InterpreterList; + interpreterList->append( this ); +} + +ScriptInterpreter::~ScriptInterpreter() +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "ScriptInterpreter::~ScriptInterpreter " << this << " for part=" << m_frame << endl; +#endif + assert( interpreterList && interpreterList->contains( this ) ); + interpreterList->remove( this ); + if ( interpreterList->isEmpty() ) { + delete interpreterList; + interpreterList = 0; + } +} + +void ScriptInterpreter::forgetDOMObject( void* objectHandle ) +{ + if( !interpreterList ) return; + + TQPtrListIterator<ScriptInterpreter> it( *interpreterList ); + while ( it.current() ) { + (*it)->deleteDOMObject( objectHandle ); + ++it; + } +} + +void ScriptInterpreter::mark() +{ + Interpreter::mark(); +#ifdef KJS_VERBOSE + kdDebug(6070) << "ScriptInterpreter::mark " << this << " marking " << m_customizedDomObjects.count() << " DOM objects" << endl; +#endif + TQPtrDictIterator<void> it( m_customizedDomObjects ); + for( ; it.current(); ++it ) + static_cast<DOMObject*>(it.currentKey())->mark(); +} + +KParts::ReadOnlyPart* ScriptInterpreter::part() const { + return m_frame->m_part; +} + +bool ScriptInterpreter::isWindowOpenAllowed() const +{ + if ( m_evt ) + { + int id = m_evt->handle()->id(); + bool eventOk = ( // mouse events + id == DOM::EventImpl::CLICK_EVENT || + id == DOM::EventImpl::MOUSEUP_EVENT || id == DOM::EventImpl::MOUSEDOWN_EVENT || + id == DOM::EventImpl::KHTML_ECMA_CLICK_EVENT || id == DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT || + // keyboard events + id == DOM::EventImpl::KEYDOWN_EVENT || id == DOM::EventImpl::KEYPRESS_EVENT || + id == DOM::EventImpl::KEYUP_EVENT || + // other accepted events + id == DOM::EventImpl::SELECT_EVENT || id == DOM::EventImpl::CHANGE_EVENT || + id == DOM::EventImpl::SUBMIT_EVENT ); + kdDebug(6070) << "Window.open, smart policy: id=" << id << " eventOk=" << eventOk << endl; + if (eventOk) + return true; + } else // no event + { + if ( m_inlineCode && !m_timerCallback ) + { + // This is the <a href="javascript:window.open('...')> case -> we let it through + return true; + kdDebug(6070) << "Window.open, smart policy, no event, inline code -> ok" << endl; + } + else // This is the <script>window.open(...)</script> case or a timer callback -> block it + kdDebug(6070) << "Window.open, smart policy, no event, <script> tag -> refused" << endl; + } + return false; +} + + +UString::UString(const TQString &d) +{ + unsigned int len = d.length(); + UChar *dat = new UChar[len]; + memcpy(dat, d.unicode(), len * sizeof(UChar)); + rep = UString::Rep::create(dat, len); +} + +UString::UString(const DOM::DOMString &d) +{ + if (d.isNull()) { + // we do a conversion here as null DOMStrings shouldn't cross + // the boundary to kjs. They should either be empty strings + // or explicitly converted to KJS::Null via getString(). + attach(&Rep::empty); + return; + } + + unsigned int len = d.length(); + UChar *dat = new UChar[len]; + memcpy(dat, d.unicode(), len * sizeof(UChar)); + rep = UString::Rep::create(dat, len); +} + +DOM::DOMString UString::string() const +{ + return DOM::DOMString((TQChar*) data(), size()); +} + +TQString UString::qstring() const +{ + return TQString((TQChar*) data(), size()); +} + +TQConstString UString::qconststring() const +{ + return TQConstString((TQChar*) data(), size()); +} + +DOM::DOMString Identifier::string() const +{ + return DOM::DOMString((TQChar*) data(), size()); +} + +TQString Identifier::qstring() const +{ + return TQString((TQChar*) data(), size()); +} + +DOM::Node KJS::toNode(const Value& val) +{ + Object obj = Object::dynamicCast(val); + if (!obj.isValid() || !obj.inherits(&DOMNode::info)) + return DOM::Node(); + + const DOMNode *dobj = static_cast<const DOMNode*>(obj.imp()); + return dobj->toNode(); +} + +Value KJS::getString(DOM::DOMString s) +{ + if (s.isNull()) + return Null(); + else + return String(s); +} + +TQVariant KJS::ValueToVariant(ExecState* exec, const Value &val) { + TQVariant res; + switch (val.type()) { + case BooleanType: + res = TQVariant(val.toBoolean(exec), 0); + break; + case NumberType: + res = TQVariant(val.toNumber(exec)); + break; + case StringType: + res = TQVariant(val.toString(exec).qstring()); + break; + default: + // everything else will be 'invalid' + break; + } + return res; +} + +class EmbedLiveConnect : public ObjectImp +{ + friend Value KJS::getLiveConnectValue(KParts::LiveConnectExtension *lc, const TQString & name, const int type, const TQString & value, int id); + EmbedLiveConnect(KParts::LiveConnectExtension *lc, UString n, KParts::LiveConnectExtension::Type t, int id); +public: + ~EmbedLiveConnect(); + + virtual Value get(ExecState *, const Identifier & prop) const; + virtual void put(ExecState * exec, const Identifier &prop, const Value & value, int=None); + virtual Value call(ExecState * exec, Object &, const List &args); + virtual bool implementsCall() const; + virtual bool toBoolean(ExecState *) const; + virtual Value toPrimitive(ExecState *exec, Type) const; + virtual UString toString(ExecState *) const; + +private: + EmbedLiveConnect(const EmbedLiveConnect &); + TQGuardedPtr<KParts::LiveConnectExtension> m_liveconnect; + UString name; + KParts::LiveConnectExtension::Type objtype; + unsigned long objid; +}; + +Value KJS::getLiveConnectValue(KParts::LiveConnectExtension *lc, const TQString & name, const int type, const TQString & value, int id) +{ + KParts::LiveConnectExtension::Type t=(KParts::LiveConnectExtension::Type)type; + switch(t) { + case KParts::LiveConnectExtension::TypeBool: { + bool ok; + int i = value.toInt(&ok); + if (ok) + return Boolean(i); + return Boolean(!strcasecmp(value.latin1(), "true")); + } + case KParts::LiveConnectExtension::TypeObject: + case KParts::LiveConnectExtension::TypeFunction: + return Value(new EmbedLiveConnect(lc, name, t, id)); + case KParts::LiveConnectExtension::TypeNumber: { + bool ok; + int i = value.toInt(&ok); + if (ok) + return Number(i); + else + return Number(value.toDouble(&ok)); + } + case KParts::LiveConnectExtension::TypeString: + return String(value); + case KParts::LiveConnectExtension::TypeVoid: + default: + return Undefined(); + } +} + +/* only with gcc > 3.4 KDE_NO_EXPORT */ +EmbedLiveConnect::EmbedLiveConnect(KParts::LiveConnectExtension *lc, UString n, KParts::LiveConnectExtension::Type t, int id) + : m_liveconnect (lc), name(n), objtype(t), objid(id) +{} + +/* only with gcc > 3.4 KDE_NO_EXPORT */ +EmbedLiveConnect::~EmbedLiveConnect() { + if (m_liveconnect) + m_liveconnect->unregister(objid); +} + +KDE_NO_EXPORT +Value EmbedLiveConnect::get(ExecState *, const Identifier & prop) const +{ + if (m_liveconnect) { + KParts::LiveConnectExtension::Type rettype; + TQString retval; + unsigned long retobjid; + if (m_liveconnect->get(objid, prop.qstring(), rettype, retobjid, retval)) + return getLiveConnectValue(m_liveconnect, prop.qstring(), rettype, retval, retobjid); + } + return Undefined(); +} + +KDE_NO_EXPORT +void EmbedLiveConnect::put(ExecState * exec, const Identifier &prop, const Value & value, int) +{ + if (m_liveconnect) + m_liveconnect->put(objid, prop.qstring(), value.toString(exec).qstring()); +} + +KDE_NO_EXPORT +bool EmbedLiveConnect::implementsCall() const { + return objtype == KParts::LiveConnectExtension::TypeFunction; +} + +KDE_NO_EXPORT +Value EmbedLiveConnect::call(ExecState *exec, Object&, const List &args) +{ + if (m_liveconnect) { + TQStringList qargs; + for (ListIterator i = args.begin(); i != args.end(); ++i) + qargs.append((*i).toString(exec).qstring()); + KParts::LiveConnectExtension::Type rtype; + TQString rval; + unsigned long robjid; + if (m_liveconnect->call(objid, name.qstring(), qargs, rtype, robjid, rval)) + return getLiveConnectValue(m_liveconnect, name.qstring(), rtype, rval, robjid); + } + return Undefined(); +} + +KDE_NO_EXPORT +bool EmbedLiveConnect::toBoolean(ExecState *) const { + return true; +} + +KDE_NO_EXPORT +Value EmbedLiveConnect::toPrimitive(ExecState *exec, Type) const { + return String(toString(exec)); +} + +KDE_NO_EXPORT +UString EmbedLiveConnect::toString(ExecState *) const { + TQString str; + const char *type = objtype == KParts::LiveConnectExtension::TypeFunction ? "Function" : "Object"; + str.sprintf("[object %s ref=%d]", type, (int) objid); + return UString(str); +} diff --git a/tdehtml/ecma/kjs_binding.h b/tdehtml/ecma/kjs_binding.h new file mode 100644 index 000000000..9b69284ba --- /dev/null +++ b/tdehtml/ecma/kjs_binding.h @@ -0,0 +1,409 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 1999-2001 Harri Porten (porten@kde.org) + * 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 + */ + +#ifndef _KJS_BINDING_H_ +#define _KJS_BINDING_H_ + +#include <kjs/interpreter.h> +#include <kjs/function_object.h> /// for FunctionPrototypeImp + +#include <dom/dom_node.h> +#include <tqvariant.h> +#include <tqptrdict.h> +#include <kurl.h> +#include <kjs/lookup.h> + +namespace KParts { + class ReadOnlyPart; + class LiveConnectExtension; +} + +namespace tdehtml { + class ChildFrame; +} + +namespace KJS { + + /** + * Base class for all objects in this binding - get() and put() run + * tryGet() and tryPut() respectively, and catch exceptions if they + * occur. + */ + class DOMObject : public ObjectImp { + public: + DOMObject(const Object &proto) : ObjectImp(proto) {} + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const + { return ObjectImp::get(exec, propertyName); } + virtual bool implementsHasInstance() const { return true; } + virtual Boolean hasInstance(ExecState *exec, const Value &value); + virtual void put(ExecState *exec, const Identifier &propertyName, + const Value &value, int attr = None); + virtual void tryPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr = None); + + virtual UString toString(ExecState *exec) const; + }; + + /** + * Base class for all functions in this binding - get() and call() run + * tryGet() and tryCall() respectively, and catch exceptions if they + * occur. + */ + class DOMFunction : public InternalFunctionImp { + public: + DOMFunction(ExecState* exec) : InternalFunctionImp( + static_cast<FunctionPrototypeImp*>(exec->interpreter()->builtinFunctionPrototype().imp()) + ) {} + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const + { return ObjectImp::get(exec, propertyName); } + + virtual bool implementsCall() const { return true; } + virtual Value call(ExecState *exec, Object &thisObj, const List &args); + + virtual Value tryCall(ExecState *exec, Object &thisObj, const List&args) + { return ObjectImp::call(exec, thisObj, args); } + virtual bool toBoolean(ExecState *) const { return true; } + }; + + /** + * We inherit from Interpreter, to save a pointer to the HTML part + * that the interpreter runs for. + * The interpreter also stores the DOM object - >KJS::DOMObject cache. + */ + class KDE_EXPORT ScriptInterpreter : public Interpreter + { + public: + ScriptInterpreter( const Object &global, tdehtml::ChildFrame* frame ); + virtual ~ScriptInterpreter(); + + DOMObject* getDOMObject( void* objectHandle ) const { + return m_domObjects[objectHandle]; + } + void putDOMObject( void* objectHandle, DOMObject* obj ) { + m_domObjects.insert( objectHandle, obj ); + } + void customizedDOMObject( DOMObject* obj ) { + m_customizedDomObjects.replace( obj, this ); + } + bool deleteDOMObject( void* objectHandle ) { + DOMObject* obj = m_domObjects.take( objectHandle ); + if (obj) { + m_customizedDomObjects.remove( obj ); + return true; + } + else + return false; + } + void clear() { + m_customizedDomObjects.clear(); + m_domObjects.clear(); + } + /** + * Static method. Makes all interpreters forget about the object + */ + static void forgetDOMObject( void* objectHandle ); + + /** + * Mark objects in the DOMObject cache. + */ + virtual void mark(); + KParts::ReadOnlyPart* part() const; + + virtual int rtti() { return 1; } + + /** + * Set the event that is triggering the execution of a script, if any + */ + void setCurrentEvent( DOM::Event *evt ) { m_evt = evt; } + void setInlineCode( bool inlineCode ) { m_inlineCode = inlineCode; } + void setProcessingTimerCallback( bool timerCallback ) { m_timerCallback = timerCallback; } + /** + * "Smart" window.open policy + */ + bool isWindowOpenAllowed() const; + + private: + tdehtml::ChildFrame* m_frame; + TQPtrDict<DOMObject> m_domObjects; + TQPtrDict<void> m_customizedDomObjects; //Objects which had custom properties set, + //and should not be GC'd. key is DOMObject* + DOM::Event *m_evt; + bool m_inlineCode; + bool m_timerCallback; + }; + /** + * Retrieve from cache, or create, a KJS object around a DOM object + */ + template<class DOMObj, class KJSDOMObj> + inline Value cacheDOMObject(ExecState *exec, DOMObj domObj) + { + DOMObject *ret; + if (domObj.isNull()) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + if ((ret = interp->getDOMObject(domObj.handle()))) + return Value(ret); + else { + ret = new KJSDOMObj(exec, domObj); + interp->putDOMObject(domObj.handle(),ret); + return Value(ret); + } + } + + /** + * Convert an object to a Node. Returns a null Node if not possible. + */ + DOM::Node toNode(const Value&); + /** + * Get a String object, or Null() if s is null + */ + Value getString(DOM::DOMString s); + + /** + * Convery a KJS value into a QVariant + */ + TQVariant ValueToVariant(ExecState* exec, const Value& val); + + /** + * We need a modified version of lookupGet because + * we call tryGet instead of get, in DOMObjects. + */ + template <class FuncImp, class ThisImp, class ParentImp> + inline Value DOMObjectLookupGet(ExecState *exec, const Identifier &propertyName, + const HashTable* table, const ThisImp* thisObj) + { + const HashEntry* entry = Lookup::findEntry(table, propertyName); + + if (!entry) // not found, forward to parent + return thisObj->ParentImp::tryGet(exec, propertyName); + + if (entry->attr & Function) { + return lookupOrCreateFunction<FuncImp>(exec, propertyName, thisObj, entry->value, entry->params, entry->attr); + } + return thisObj->getValueProperty(exec, entry->value); + } + + /** + * Simplified version of DOMObjectLookupGet in case there are no + * functions, only "values". + */ + template <class ThisImp, class ParentImp> + inline Value DOMObjectLookupGetValue(ExecState *exec, const Identifier &propertyName, + const HashTable* table, const ThisImp* thisObj) + { + const HashEntry* entry = Lookup::findEntry(table, propertyName); + + if (!entry) // not found, forward to parent + return thisObj->ParentImp::tryGet(exec, propertyName); + + if (entry->attr & Function) + fprintf(stderr, "Function bit set! Shouldn't happen in lookupValue!\n" ); + return thisObj->getValueProperty(exec, entry->value); + } + + /** + * We need a modified version of lookupPut because + * we call tryPut instead of put, in DOMObjects. + */ + template <class ThisImp, class ParentImp> + inline void DOMObjectLookupPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr, + const HashTable* table, ThisImp* thisObj) + { + const HashEntry* entry = Lookup::findEntry(table, propertyName); + + if (!entry) // not found: forward to parent + thisObj->ParentImp::tryPut(exec, propertyName, value, attr); + else if (entry->attr & Function) // function: put as override property + thisObj->ObjectImp::put(exec, propertyName, value, attr); + else if (entry->attr & ReadOnly) // readonly! Can't put! +#ifdef KJS_VERBOSE + fprintf(stderr,"WARNING: Attempt to change value of readonly property '%s'\n",propertyName.ascii()); +#else + ; // do nothing +#endif + else + thisObj->putValueProperty(exec, entry->value, value, attr); + } + +// Versions of prototype functions that properly support instanceof, +// and are compatible with trunk. +#define KJS_DEFINE_PROTOTYPE_IMP(ClassProto,ProtoCode) \ + class ClassProto : public ObjectImp { \ + friend Object cacheGlobalObject<ClassProto>(ExecState *exec, const Identifier &propertyName); \ + public: \ + static Object self(ExecState *exec); \ + virtual const ClassInfo *classInfo() const { return &info; } \ + static const ClassInfo info; \ + Value get(ExecState *exec, const Identifier &propertyName) const; \ + protected: \ + ClassProto( ExecState *exec ) \ + : ObjectImp( ProtoCode ) {} \ + \ + static Identifier* s_name; \ + static Identifier* name(); \ + }; + +#define KJS_DEFINE_PROTOTYPE(ClassProto) \ + KJS_DEFINE_PROTOTYPE_IMP(ClassProto, exec->interpreter()->builtinObjectPrototype()) + +#define KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(ClassProto, ClassProtoProto) \ + KJS_DEFINE_PROTOTYPE_IMP(ClassProto, ClassProtoProto::self(exec)) + +#define KJS_EMPTY_PROTOTYPE_IMP(ClassName, ClassProto, ProtoCode) \ + class ClassProto : public ObjectImp { \ + friend Object cacheGlobalObject<ClassProto>(ExecState *exec, const Identifier &propertyName); \ + public: \ + static Object self(ExecState *exec) { \ + return cacheGlobalObject<ClassProto>(exec, *name()); \ + } \ + virtual const ClassInfo *classInfo() const { return &info; } \ + static const ClassInfo info; \ + protected: \ + ClassProto( ExecState *exec ) \ + : ObjectImp( ProtoCode ) {} \ + \ + static Identifier* s_name; \ + static Identifier* name() { \ + if (!s_name) s_name = new Identifier("[[" ClassName ".prototype]]"); \ + return s_name; \ + }\ + }; \ + Identifier* ClassProto::s_name = 0; \ + const ClassInfo ClassProto::info = { ClassName, 0, 0, 0 }; + +#define KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE(ClassName, ClassProto, ClassProtoProto) \ + KJS_EMPTY_PROTOTYPE_IMP(ClassName, ClassProto, ClassProtoProto::self(exec)) + +//### this doesn't implement hasProperty, but stuff in lookup.h didn't +//either (just did the forward) +#define KJS_IMPLEMENT_PROTOTYPE(ClassName, ClassProto, ClassFunc) \ + const ClassInfo ClassProto::info = { ClassName, 0, &ClassProto##Table, 0 }; \ + Identifier* ClassProto::s_name = 0; \ + Object ClassProto::self(ExecState *exec) \ + { \ + return cacheGlobalObject<ClassProto>(exec, *name()); \ + } \ + Value ClassProto::get(ExecState *exec, const Identifier &propertyName) const \ + { \ + /*fprintf( stderr, "%sProto::get(%s) [in macro, no parent]\n", info.className, propertyName.ascii());*/ \ + return lookupGetFunction<ClassFunc,ObjectImp>(exec, propertyName, &ClassProto##Table, this ); \ + } \ + Identifier* ClassProto::name() \ + { \ + if (!s_name) s_name = new Identifier("[[" ClassName ".prototype]]"); \ + return s_name; \ + } + + // Modified version of IMPLEMENT_PROTOFUNC, to use DOMFunction and tryCall +#define IMPLEMENT_PROTOFUNC_DOM(ClassFunc) \ + class ClassFunc : public DOMFunction { \ + public: \ + ClassFunc(ExecState *exec, int i, int len) \ + : DOMFunction( exec ), id(i) { \ + Value protect(this); \ + put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum); \ + } \ + /** You need to implement that one */ \ + virtual Value tryCall(ExecState *exec, Object &thisObj, const List &args); \ + private: \ + int id; \ + }; + + Value getLiveConnectValue(KParts::LiveConnectExtension *lc, const TQString & name, const int type, const TQString & value, int id); + + +// This is used to create pseudo-constructor objects, like Mozillaish +// Element, HTMLDocument, etc., which do not act like real constructors, +// but do have the prototype property pointing to prototype of "instances" +#define DEFINE_PSEUDO_CONSTRUCTOR(ClassName) \ + class ClassName : public DOMObject { \ + public: \ + ClassName(ExecState *); \ + virtual const ClassInfo* classInfo() const { return &info; } \ + static const ClassInfo info; \ + static Object self(ExecState *exec); \ + }; + +#define IMPLEMENT_PSEUDO_CONSTRUCTOR_IMP(Class,ClassName,ProtoClass,ParentProto) \ + const ClassInfo Class::info = { ClassName, 0, 0, 0 }; \ + Class::Class(ExecState* exec): DOMObject(ParentProto) {\ + Object proto = ProtoClass::self(exec); \ + putDirect(prototypePropertyName, proto.imp(), DontDelete|ReadOnly); \ + }\ + Object Class::self(ExecState *exec) { \ + return Object(cacheGlobalObject<Class>(exec, "[[" ClassName ".constructor]]")); \ + } + +#define IMPLEMENT_PSEUDO_CONSTRUCTOR(Class,ClassName,ProtoClass) \ + IMPLEMENT_PSEUDO_CONSTRUCTOR_IMP(Class,ClassName,ProtoClass,exec->lexicalInterpreter()->builtinObjectPrototype()) + +#define IMPLEMENT_PSEUDO_CONSTRUCTOR_WITH_PARENT(Class,ClassName,ProtoClass,ParentProtoClass) \ + IMPLEMENT_PSEUDO_CONSTRUCTOR_IMP(Class,ClassName,ProtoClass,ParentProtoClass::self(exec)) + +// This declares a constant table, which merely maps everything in its +// table to its token value. Can be used as a prototype +#define DEFINE_CONSTANT_TABLE(Class) \ + class Class : public DOMObject { \ + public: \ + Class(ExecState *exec): DOMObject(exec->lexicalInterpreter()->builtinObjectPrototype()) {} \ + \ + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const;\ + Value getValueProperty(ExecState * /*exec*/, int token) const; \ + virtual const ClassInfo* classInfo() const { return &info; } \ + static const ClassInfo info; \ + static Object self(ExecState *exec);\ + static Identifier* s_name; \ + static Identifier* name(); \ + }; + +// Emits an implementation of a constant table +#define IMPLEMENT_CONSTANT_TABLE(Class,ClassName) \ + Value Class::tryGet(ExecState *exec, const Identifier &propertyName) const { \ + return DOMObjectLookupGetValue<Class, DOMObject>(exec, propertyName, &Class##Table, this);\ + } \ + Value Class::getValueProperty(ExecState * /*exec*/, int token) const { \ + /* We use the token as the value to return directly*/ \ + return Number((unsigned int)token); \ + } \ + Object Class::self(ExecState *exec) { \ + return cacheGlobalObject<Class>(exec, *name()); \ + } \ + Identifier* Class::s_name = 0; \ + Identifier* Class::name() { \ + if (!s_name) s_name = new Identifier("[[" ClassName ".constant_table]]"); \ + return s_name; \ + } \ + const ClassInfo Class::info = { ClassName, 0, &Class##Table, 0 }; + + +// Hide some of the stuff in lookup.h.. +#undef PUBLIC_DEFINE_PROTOTYPE +#undef DEFINE_PROTOTYPE +#undef IMPLEMENT_PROTOTYPE +#undef PUBLIC_IMPLEMENT_PROTOTYPE +#undef IMPLEMENT_PROTOTYPE_WITH_PARENT + +} // namespace + +#endif 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 diff --git a/tdehtml/ecma/kjs_css.h b/tdehtml/ecma/kjs_css.h new file mode 100644 index 000000000..2b7d14712 --- /dev/null +++ b/tdehtml/ecma/kjs_css.h @@ -0,0 +1,304 @@ +// -*- 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 + */ + +#ifndef _KJS_CSS_H_ +#define _KJS_CSS_H_ + +#include <dom/dom_node.h> +#include <dom/dom_doc.h> +#include <kjs/object.h> +#include <dom/css_value.h> +#include <dom/css_stylesheet.h> +#include <dom/css_rule.h> +#include "kjs_binding.h" + +namespace KJS { + + class DOMCSSStyleDeclaration : public DOMObject { + public: + DOMCSSStyleDeclaration(ExecState *exec, const DOM::CSSStyleDeclaration& s); + virtual ~DOMCSSStyleDeclaration(); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + virtual bool hasProperty(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo *classInfo() const { return &info; } + static const ClassInfo info; + enum { CssText, Length, ParentRule, + GetPropertyValue, GetPropertyCSSValue, RemoveProperty, GetPropertyPriority, + SetProperty, Item }; + DOM::CSSStyleDeclaration toStyleDecl() const { return styleDecl; } + protected: + DOM::CSSStyleDeclaration styleDecl; + }; + + DEFINE_PSEUDO_CONSTRUCTOR(CSSStyleDeclarationPseudoCtor) + + Value getDOMCSSStyleDeclaration(ExecState *exec, const DOM::CSSStyleDeclaration& n); + + class DOMStyleSheet : public DOMObject { + public: + // Build a DOMStyleSheet + DOMStyleSheet(ExecState *, const DOM::StyleSheet& ss); + // Constructor for inherited classes + DOMStyleSheet(const Object& proto, const DOM::StyleSheet& ss) : DOMObject(proto), styleSheet(ss) { } + virtual ~DOMStyleSheet(); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + virtual bool toBoolean(ExecState *) const { return true; } + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Type, Disabled, OwnerNode, ParentStyleSheet, Href, Title, Media }; + protected: + DOM::StyleSheet styleSheet; + }; + + Value getDOMStyleSheet(ExecState *exec, const DOM::StyleSheet& ss); + + class DOMStyleSheetList : public DOMObject { + public: + DOMStyleSheetList(ExecState *, const DOM::StyleSheetList& ssl, const DOM::Document& doc); + virtual ~DOMStyleSheetList(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + virtual Value call(ExecState *exec, Object &thisObj, const List &args); + Value tryCall(ExecState *exec, Object &thisObj, const List &args); + virtual bool implementsCall() const { return true; } + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + virtual bool toBoolean(ExecState* ) const { return true; } + static const ClassInfo info; + DOM::StyleSheetList toStyleSheetList() const { return styleSheetList; } + enum { Item, Length }; + private: + DOM::StyleSheetList styleSheetList; + DOM::Document m_doc; + }; + + // The document is only used for get-stylesheet-by-name (make optional if necessary) + Value getDOMStyleSheetList(ExecState *exec, const DOM::StyleSheetList& ss, const DOM::Document& doc); + + class DOMMediaList : public DOMObject { + public: + DOMMediaList(ExecState *, const DOM::MediaList& ml); + virtual ~DOMMediaList(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + virtual const ClassInfo* classInfo() const { return &info; } + virtual bool toBoolean(ExecState* ) const { return true; } + static const ClassInfo info; + enum { MediaText, Length, + Item, DeleteMedium, AppendMedium }; + DOM::MediaList toMediaList() const { return mediaList; } + private: + DOM::MediaList mediaList; + }; + + Value getDOMMediaList(ExecState *exec, const DOM::MediaList& ss); + + class DOMCSSStyleSheet : public DOMStyleSheet { + public: + DOMCSSStyleSheet(ExecState *exec, const DOM::CSSStyleSheet& ss); + virtual ~DOMCSSStyleSheet(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { OwnerRule, CssRules, Rules, + InsertRule, DeleteRule, AddRule, RemoveRule }; + DOM::CSSStyleSheet toCSSStyleSheet() const { return static_cast<DOM::CSSStyleSheet>(styleSheet); } + }; + + class DOMCSSRuleList : public DOMObject { + public: + DOMCSSRuleList(ExecState *, const DOM::CSSRuleList& rl); + virtual ~DOMCSSRuleList(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Item, Length }; + DOM::CSSRuleList toCSSRuleList() const { return cssRuleList; } + protected: + DOM::CSSRuleList cssRuleList; + }; + + Value getDOMCSSRuleList(ExecState *exec, const DOM::CSSRuleList& rl); + + class DOMCSSRule : public DOMObject { + public: + DOMCSSRule(ExecState *, const DOM::CSSRule& r); + virtual ~DOMCSSRule(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + void putValueProperty(ExecState *exec, int token, const Value& value, int attr); + virtual const ClassInfo* classInfo() const; + static const ClassInfo info; + static const ClassInfo style_info, media_info, fontface_info, page_info, import_info, charset_info; + enum { ParentStyleSheet, Type, CssText, ParentRule, + Style_SelectorText, Style_Style, + Media_Media, Media_InsertRule, Media_DeleteRule, Media_CssRules, + FontFace_Style, Page_SelectorText, Page_Style, + Import_Href, Import_Media, Import_StyleSheet, Charset_Encoding }; + DOM::CSSRule toCSSRule() const { return cssRule; } + protected: + DOM::CSSRule cssRule; + }; + + Value getDOMCSSRule(ExecState *exec, const DOM::CSSRule& r); + + /** + * Convert an object to a CSSRule. Returns a null CSSRule if not possible. + */ + DOM::CSSRule toCSSRule(const Value&); + + // Constructor for CSSRule - currently only used for some global values + class CSSRuleConstructor : public DOMObject { + public: + CSSRuleConstructor(ExecState *); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { UNKNOWN_RULE, STYLE_RULE, CHARSET_RULE, IMPORT_RULE, MEDIA_RULE, FONT_FACE_RULE, PAGE_RULE }; + }; + + Value getCSSRuleConstructor(ExecState *exec); + + class DOMCSSValue : public DOMObject { + public: + DOMCSSValue(ExecState *, const DOM::CSSValue& v); + DOMCSSValue(const Object& proto, const DOM::CSSValue& v) : DOMObject(proto), cssValue(v) { } + virtual ~DOMCSSValue(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { CssText, CssValueType }; + protected: + DOM::CSSValue cssValue; + }; + + Value getDOMCSSValue(ExecState *exec, const DOM::CSSValue& v); + + // Constructor for CSSValue - currently only used for some global values + class CSSValueConstructor : public DOMObject { + public: + CSSValueConstructor(ExecState *exec); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { CSS_VALUE_LIST, CSS_PRIMITIVE_VALUE, CSS_CUSTOM, CSS_INHERIT }; + }; + + Value getCSSValueConstructor(ExecState *exec); + + class DOMCSSPrimitiveValue : public DOMCSSValue { + public: + DOMCSSPrimitiveValue(ExecState *exec, const DOM::CSSPrimitiveValue& v); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + DOM::CSSPrimitiveValue toCSSPrimitiveValue() const { return static_cast<DOM::CSSPrimitiveValue>(cssValue); } + enum { PrimitiveType, SetFloatValue, GetFloatValue, SetStringValue, GetStringValue, + GetCounterValue, GetRectValue, GetRGBColorValue }; + }; + + // Constructor for CSSPrimitiveValue - currently only used for some global values + class CSSPrimitiveValueConstructor : public CSSValueConstructor { + public: + CSSPrimitiveValueConstructor(ExecState *exec) : CSSValueConstructor(exec) { } + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + Value getCSSPrimitiveValueConstructor(ExecState *exec); + + class DOMCSSValueList : public DOMCSSValue { + public: + DOMCSSValueList(ExecState *exec, const DOM::CSSValueList& v); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Item, Length }; + DOM::CSSValueList toValueList() const { return static_cast<DOM::CSSValueList>(cssValue); } + }; + + class DOMRGBColor : public DOMObject { + public: + DOMRGBColor(ExecState*, const DOM::RGBColor& c); + ~DOMRGBColor(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Red, Green, Blue }; + protected: + DOM::RGBColor rgbColor; + }; + + Value getDOMRGBColor(ExecState *exec, const DOM::RGBColor& c); + + class DOMRect : public DOMObject { + public: + DOMRect(ExecState *, const DOM::Rect& r); + ~DOMRect(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Top, Right, Bottom, Left }; + protected: + DOM::Rect rect; + }; + + Value getDOMRect(ExecState *exec, const DOM::Rect& r); + + class DOMCounter : public DOMObject { + public: + DOMCounter(ExecState *, const DOM::Counter& c); + ~DOMCounter(); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { identifier, listStyle, separator }; + protected: + DOM::Counter counter; + }; + + Value getDOMCounter(ExecState *exec, const DOM::Counter& c); + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_debugwin.cpp b/tdehtml/ecma/kjs_debugwin.cpp new file mode 100644 index 000000000..4830c1108 --- /dev/null +++ b/tdehtml/ecma/kjs_debugwin.cpp @@ -0,0 +1,1139 @@ +/* + * This file is part of the KDE libraries + * Copyright (C) 2000-2001 Harri Porten (porten@kde.org) + * Copyright (C) 2001,2003 Peter Kelly (pmk@post.com) + * + * 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_debugwin.h" +#include "kjs_proxy.h" + +#ifdef KJS_DEBUGGER + +#include <assert.h> +#include <stdlib.h> +#include <tqlayout.h> +#include <tqpushbutton.h> +#include <tqtextedit.h> +#include <tqlistbox.h> +#include <tqmultilineedit.h> +#include <tqapplication.h> +#include <tqsplitter.h> +#include <tqcombobox.h> +#include <tqbitmap.h> +#include <tqwidgetlist.h> +#include <tqlabel.h> +#include <tqdatastream.h> +#include <tqcstring.h> +#include <tqpainter.h> +#include <tqscrollbar.h> + +#include <klocale.h> +#include <kdebug.h> +#include <kiconloader.h> +#include <kglobal.h> +#include <kmessagebox.h> +#include <kguiitem.h> +#include <kpopupmenu.h> +#include <kmenubar.h> +#include <kaction.h> +#include <kactioncollection.h> +#include <kglobalsettings.h> +#include <kshortcut.h> +#include <kconfig.h> +#include <kconfigbase.h> +#include <kapplication.h> +#include <dcop/dcopclient.h> +#include <kstringhandler.h> + +#include "kjs_dom.h" +#include "kjs_binding.h" +#include "tdehtml_part.h" +#include "tdehtmlview.h" +#include "tdehtml_pagecache.h" +#include "tdehtml_settings.h" +#include "tdehtml_factory.h" +#include "misc/decoder.h" +#include <kjs/ustring.h> +#include <kjs/object.h> +#include <kjs/function.h> +#include <kjs/interpreter.h> + +using namespace KJS; +using namespace tdehtml; + +SourceDisplay::SourceDisplay(KJSDebugWin *debugWin, TQWidget *parent, const char *name) + : TQScrollView(parent,name), m_currentLine(-1), m_sourceFile(0), m_debugWin(debugWin), + m_font(TDEGlobalSettings::fixedFont()) +{ + verticalScrollBar()->setLineStep(TQFontMetrics(m_font).height()); + viewport()->setBackgroundMode(TQt::NoBackground); + m_breakpointIcon = TDEGlobal::iconLoader()->loadIcon("stop",KIcon::Small); +} + +SourceDisplay::~SourceDisplay() +{ + if (m_sourceFile) { + m_sourceFile->deref(); + m_sourceFile = 0L; + } +} + +void SourceDisplay::setSource(SourceFile *sourceFile) +{ + if ( sourceFile ) + sourceFile->ref(); + if (m_sourceFile) + m_sourceFile->deref(); + m_sourceFile = sourceFile; + if ( m_sourceFile ) + m_sourceFile->ref(); + + if (!m_sourceFile || !m_debugWin->isVisible()) { + return; + } + + TQString code = sourceFile->getCode(); + const TQChar *chars = code.unicode(); + uint len = code.length(); + TQChar newLine('\n'); + TQChar cr('\r'); + TQChar tab('\t'); + TQString tabstr(" "); + TQString line; + m_lines.clear(); + int width = 0; + TQFontMetrics metrics(m_font); + + for (uint pos = 0; pos < len; pos++) { + TQChar c = chars[pos]; + if (c == cr) { + if (pos < len-1 && chars[pos+1] == newLine) + continue; + else + c = newLine; + } + if (c == newLine) { + m_lines.append(line); + int lineWidth = metrics.width(line); + if (lineWidth > width) + width = lineWidth; + line = ""; + } + else if (c == tab) { + line += tabstr; + } + else { + line += c; + } + } + if (line.length()) { + m_lines.append(line); + int lineWidth = metrics.width(line); + if (lineWidth > width) + width = lineWidth; + } + + int linenoDisplayWidth = metrics.width("888888"); + resizeContents(linenoDisplayWidth+4+width,metrics.height()*m_lines.count()); + update(); + sourceFile->deref(); +} + +void SourceDisplay::setCurrentLine(int lineno, bool doCenter) +{ + m_currentLine = lineno; + + if (doCenter && m_currentLine >= 0) { + TQFontMetrics metrics(m_font); + int height = metrics.height(); + center(0,height*m_currentLine+height/2); + } + + updateContents(); +} + +void SourceDisplay::contentsMousePressEvent(TQMouseEvent *e) +{ + TQScrollView::mouseDoubleClickEvent(e); + TQFontMetrics metrics(m_font); + int lineno = e->y()/metrics.height(); + emit lineDoubleClicked(lineno+1); // line numbers start from 1 +} + +void SourceDisplay::showEvent(TQShowEvent *) +{ + setSource(m_sourceFile); +} + +void SourceDisplay::drawContents(TQPainter *p, int clipx, int clipy, int clipw, int cliph) +{ + if (!m_sourceFile) { + p->fillRect(clipx,clipy,clipw,cliph,palette().active().base()); + return; + } + + TQFontMetrics metrics(m_font); + int height = metrics.height(); + + int bottom = clipy + cliph; + int right = clipx + clipw; + + int firstLine = clipy/height-1; + if (firstLine < 0) + firstLine = 0; + int lastLine = bottom/height+2; + if (lastLine > (int)m_lines.count()) + lastLine = m_lines.count(); + + p->setFont(m_font); + + int linenoWidth = metrics.width("888888"); + + for (int lineno = firstLine; lineno <= lastLine; lineno++) { + TQString linenoStr = TQString().sprintf("%d",lineno+1); + + + p->fillRect(0,height*lineno,linenoWidth,height,palette().active().mid()); + + p->setPen(palette().active().text()); + p->drawText(0,height*lineno,linenoWidth,height,Qt::AlignRight,linenoStr); + + TQColor bgColor; + TQColor textColor; + + if (lineno == m_currentLine) { + bgColor = palette().active().highlight(); + textColor = palette().active().highlightedText(); + } + else if (m_debugWin->haveBreakpoint(m_sourceFile,lineno+1,lineno+1)) { + bgColor = palette().active().text(); + textColor = palette().active().base(); + p->drawPixmap(2,height*lineno+height/2-m_breakpointIcon.height()/2,m_breakpointIcon); + } + else { + bgColor = palette().active().base(); + textColor = palette().active().text(); + } + + p->fillRect(linenoWidth,height*lineno,right-linenoWidth,height,bgColor); + p->setPen(textColor); + p->drawText(linenoWidth+4,height*lineno,contentsWidth()-linenoWidth-4,height, + Qt::AlignLeft,m_lines[lineno]); + } + + int remainingTop = height*(lastLine+1); + p->fillRect(0,remainingTop,linenoWidth,bottom-remainingTop,palette().active().mid()); + + p->fillRect(linenoWidth,remainingTop, + right-linenoWidth,bottom-remainingTop,palette().active().base()); +} + +//------------------------------------------------------------------------- + +KJSDebugWin * KJSDebugWin::kjs_html_debugger = 0; + +TQString SourceFile::getCode() +{ + if (interpreter) { + KHTMLPart *part = ::tqqt_cast<KHTMLPart*>(static_cast<ScriptInterpreter*>(interpreter)->part()); + if (part && url == part->url().url() && KHTMLPageCache::self()->isValid(part->cacheId())) { + Decoder *decoder = part->createDecoder(); + TQByteArray data; + TQDataStream stream(data,IO_WriteOnly); + KHTMLPageCache::self()->saveData(part->cacheId(),&stream); + TQString str; + if (data.size() == 0) + str = ""; + else + str = decoder->decode(data.data(),data.size()) + decoder->flush(); + delete decoder; + return str; + } + } + + return code; +} + +//------------------------------------------------------------------------- + +SourceFragment::SourceFragment(int sid, int bl, int el, SourceFile *sf) +{ + sourceId = sid; + baseLine = bl; + errorLine = el; + sourceFile = sf; + sourceFile->ref(); +} + +SourceFragment::~SourceFragment() +{ + sourceFile->deref(); + sourceFile = 0L; +} + +//------------------------------------------------------------------------- + +KJSErrorDialog::KJSErrorDialog(TQWidget *parent, const TQString& errorMessage, bool showDebug) + : KDialogBase(parent,0,true,i18n("JavaScript Error"), + showDebug ? KDialogBase::Ok|KDialogBase::User1 : KDialogBase::Ok, + KDialogBase::Ok,false,KGuiItem("&Debug","gear")) +{ + TQWidget *page = new TQWidget(this); + setMainWidget(page); + + TQLabel *iconLabel = new TQLabel("",page); + iconLabel->setPixmap(TDEGlobal::iconLoader()->loadIcon("messagebox_critical", + KIcon::NoGroup,KIcon::SizeMedium, + KIcon::DefaultState,0,true)); + + TQWidget *contents = new TQWidget(page); + TQLabel *label = new TQLabel(errorMessage,contents); + m_dontShowAgainCb = new TQCheckBox(i18n("&Do not show this message again"),contents); + + TQVBoxLayout *vl = new TQVBoxLayout(contents,0,spacingHint()); + vl->addWidget(label); + vl->addWidget(m_dontShowAgainCb); + + TQHBoxLayout *topLayout = new TQHBoxLayout(page,0,spacingHint()); + topLayout->addWidget(iconLabel); + topLayout->addWidget(contents); + topLayout->addStretch(10); + + m_debugSelected = false; +} + +KJSErrorDialog::~KJSErrorDialog() +{ +} + +void KJSErrorDialog::slotUser1() +{ + m_debugSelected = true; + close(); +} + +//------------------------------------------------------------------------- +EvalMultiLineEdit::EvalMultiLineEdit(TQWidget *parent) + : TQMultiLineEdit(parent) { +} + +void EvalMultiLineEdit::keyPressEvent(TQKeyEvent * e) +{ + if (e->key() == Qt::Key_Return) { + if (hasSelectedText()) { + m_code = selectedText(); + } else { + int para, index; + getCursorPosition(¶, &index); + m_code = text(para); + } + end(); + } + TQMultiLineEdit::keyPressEvent(e); +} +//------------------------------------------------------------------------- +KJSDebugWin::KJSDebugWin(TQWidget *parent, const char *name) + : KMainWindow(parent, name, (WFlags)WType_TopLevel), TDEInstance("kjs_debugger") +{ + m_breakpoints = 0; + m_breakpointCount = 0; + + m_curSourceFile = 0; + m_mode = Continue; + m_nextSourceUrl = ""; + m_nextSourceBaseLine = 1; + m_execs = 0; + m_execsCount = 0; + m_execsAlloc = 0; + m_steppingDepth = 0; + + m_stopIcon = TDEGlobal::iconLoader()->loadIcon("stop",KIcon::Small); + m_emptyIcon = TQPixmap(m_stopIcon.width(),m_stopIcon.height()); + TQBitmap emptyMask(m_stopIcon.width(),m_stopIcon.height(),true); + m_emptyIcon.setMask(emptyMask); + + setCaption(i18n("JavaScript Debugger")); + + TQWidget *mainWidget = new TQWidget(this); + setCentralWidget(mainWidget); + + TQVBoxLayout *vl = new TQVBoxLayout(mainWidget,5); + + // frame list & code + TQSplitter *hsplitter = new TQSplitter(Qt::Vertical,mainWidget); + TQSplitter *vsplitter = new TQSplitter(hsplitter); + TQFont font(TDEGlobalSettings::fixedFont()); + + TQWidget *contextContainer = new TQWidget(vsplitter); + + TQLabel *contextLabel = new TQLabel(i18n("Call stack"),contextContainer); + TQWidget *contextListContainer = new TQWidget(contextContainer); + m_contextList = new TQListBox(contextListContainer); + m_contextList->setMinimumSize(100,200); + connect(m_contextList,TQT_SIGNAL(highlighted(int)),this,TQT_SLOT(slotShowFrame(int))); + + TQHBoxLayout *clistLayout = new TQHBoxLayout(contextListContainer); + clistLayout->addWidget(m_contextList); + clistLayout->addSpacing(KDialog::spacingHint()); + + TQVBoxLayout *contextLayout = new TQVBoxLayout(contextContainer); + contextLayout->addWidget(contextLabel); + contextLayout->addSpacing(KDialog::spacingHint()); + contextLayout->addWidget(contextListContainer); + + // source selection & display + TQWidget *sourceSelDisplay = new TQWidget(vsplitter); + TQVBoxLayout *ssdvl = new TQVBoxLayout(sourceSelDisplay); + + m_sourceSel = new TQComboBox(toolBar()); + connect(m_sourceSel,TQT_SIGNAL(activated(int)),this,TQT_SLOT(slotSourceSelected(int))); + + m_sourceDisplay = new SourceDisplay(this,sourceSelDisplay); + ssdvl->addWidget(m_sourceDisplay); + connect(m_sourceDisplay,TQT_SIGNAL(lineDoubleClicked(int)),TQT_SLOT(slotToggleBreakpoint(int))); + + TQValueList<int> vsplitSizes; + vsplitSizes.insert(vsplitSizes.end(),120); + vsplitSizes.insert(vsplitSizes.end(),480); + vsplitter->setSizes(vsplitSizes); + + // evaluate + + TQWidget *evalContainer = new TQWidget(hsplitter); + + TQLabel *evalLabel = new TQLabel(i18n("JavaScript console"),evalContainer); + m_evalEdit = new EvalMultiLineEdit(evalContainer); + m_evalEdit->setWordWrap(TQMultiLineEdit::NoWrap); + m_evalEdit->setFont(font); + connect(m_evalEdit,TQT_SIGNAL(returnPressed()),TQT_SLOT(slotEval())); + m_evalDepth = 0; + + TQVBoxLayout *evalLayout = new TQVBoxLayout(evalContainer); + evalLayout->addSpacing(KDialog::spacingHint()); + evalLayout->addWidget(evalLabel); + evalLayout->addSpacing(KDialog::spacingHint()); + evalLayout->addWidget(m_evalEdit); + + TQValueList<int> hsplitSizes; + hsplitSizes.insert(hsplitSizes.end(),400); + hsplitSizes.insert(hsplitSizes.end(),200); + hsplitter->setSizes(hsplitSizes); + + vl->addWidget(hsplitter); + + // actions + KPopupMenu *debugMenu = new KPopupMenu(this); + menuBar()->insertItem("&Debug",debugMenu); + + m_actionCollection = new KActionCollection(this); + m_actionCollection->setInstance(this); + + // Venkman use F12, KDevelop F10 + KShortcut scNext = KShortcut(KKeySequence(KKey(Qt::Key_F12))); + scNext.append(KKeySequence(KKey(Qt::Key_F10))); + m_nextAction = new KAction(i18n("Next breakpoint","&Next"),"dbgnext",scNext,TQT_TQOBJECT(this),TQT_SLOT(slotNext()), + m_actionCollection,"next"); + m_stepAction = new KAction(i18n("&Step"),"dbgstep",KShortcut(Qt::Key_F11),TQT_TQOBJECT(this),TQT_SLOT(slotStep()), + m_actionCollection,"step"); + // Venkman use F5, Kdevelop F9 + KShortcut scCont = KShortcut(KKeySequence(KKey(Qt::Key_F5))); + scCont.append(KKeySequence(KKey(Qt::Key_F9))); + m_continueAction = new KAction(i18n("&Continue"),"dbgrun",scCont,TQT_TQOBJECT(this),TQT_SLOT(slotContinue()), + m_actionCollection,"cont"); + m_stopAction = new KAction(i18n("St&op"),"stop",KShortcut(Qt::Key_F4),TQT_TQOBJECT(this),TQT_SLOT(slotStop()), + m_actionCollection,"stop"); + m_breakAction = new KAction(i18n("&Break at Next Statement"),"dbgrunto",KShortcut(Qt::Key_F8),TQT_TQOBJECT(this),TQT_SLOT(slotBreakNext()), + m_actionCollection,"breaknext"); + + + m_nextAction->setToolTip(i18n("Next breakpoint","Next")); + m_stepAction->setToolTip(i18n("Step")); + m_continueAction->setToolTip(i18n("Continue")); + m_stopAction->setToolTip(i18n("Stop")); + m_breakAction->setToolTip("Break at next Statement"); + + m_nextAction->setEnabled(false); + m_stepAction->setEnabled(false); + m_continueAction->setEnabled(false); + m_stopAction->setEnabled(false); + m_breakAction->setEnabled(true); + + m_nextAction->plug(debugMenu); + m_stepAction->plug(debugMenu); + m_continueAction->plug(debugMenu); +// m_stopAction->plug(debugMenu); ### disabled until DebuggerImp::stop() works reliably + m_breakAction->plug(debugMenu); + + m_nextAction->plug(toolBar()); + m_stepAction->plug(toolBar()); + m_continueAction->plug(toolBar()); +// m_stopAction->plug(toolBar()); ### + m_breakAction->plug(toolBar()); + + toolBar()->insertWidget(1,300,m_sourceSel); + toolBar()->setItemAutoSized(1); + + updateContextList(); + setMinimumSize(300,200); + resize(600,450); + +} + +KJSDebugWin::~KJSDebugWin() +{ + free(m_breakpoints); + free(m_execs); +} + +KJSDebugWin *KJSDebugWin::createInstance() +{ + assert(!kjs_html_debugger); + kjs_html_debugger = new KJSDebugWin(); + return kjs_html_debugger; +} + +void KJSDebugWin::destroyInstance() +{ + assert(kjs_html_debugger); + kjs_html_debugger->hide(); + delete kjs_html_debugger; +} + +void KJSDebugWin::slotNext() +{ + m_mode = Next; + leaveSession(); +} + +void KJSDebugWin::slotStep() +{ + m_mode = Step; + leaveSession(); +} + +void KJSDebugWin::slotContinue() +{ + m_mode = Continue; + leaveSession(); +} + +void KJSDebugWin::slotStop() +{ + m_mode = Stop; + while (!m_execStates.isEmpty()) + leaveSession(); +} + +void KJSDebugWin::slotBreakNext() +{ + m_mode = Step; +} + +void KJSDebugWin::slotToggleBreakpoint(int lineno) +{ + if (m_sourceSel->currentItem() < 0) + return; + + SourceFile *sourceFile = m_sourceSelFiles.at(m_sourceSel->currentItem()); + + // Find the source fragment containing the selected line (if any) + int sourceId = -1; + int highestBaseLine = -1; + TQMap<int,SourceFragment*>::Iterator it; + + for (it = m_sourceFragments.begin(); it != m_sourceFragments.end(); ++it) { + SourceFragment *sourceFragment = it.data(); + if (sourceFragment && + sourceFragment->sourceFile == sourceFile && + sourceFragment->baseLine <= lineno && + sourceFragment->baseLine > highestBaseLine) { + + sourceId = sourceFragment->sourceId; + highestBaseLine = sourceFragment->baseLine; + } + } + + if (sourceId < 0) + return; + + // Update the source code display with the appropriate icon + int fragmentLineno = lineno-highestBaseLine+1; + if (!setBreakpoint(sourceId,fragmentLineno)) // was already set + deleteBreakpoint(sourceId,fragmentLineno); + + m_sourceDisplay->updateContents(); +} + +void KJSDebugWin::slotShowFrame(int frameno) +{ + if (frameno < 0 || frameno >= m_execsCount) + return; + + Context ctx = m_execs[frameno]->context(); + setSourceLine(ctx.sourceId(),ctx.curStmtFirstLine()); +} + +void KJSDebugWin::slotSourceSelected(int sourceSelIndex) +{ + // A source file has been selected from the drop-down list - display the file + if (sourceSelIndex < 0 || sourceSelIndex >= (int)m_sourceSel->count()) + return; + SourceFile *sourceFile = m_sourceSelFiles.at(sourceSelIndex); + displaySourceFile(sourceFile,true); + + // If the currently selected context is in the current source file, then hilight + // the line it's on. + if (m_contextList->currentItem() >= 0) { + Context ctx = m_execs[m_contextList->currentItem()]->context(); + if (m_sourceFragments[ctx.sourceId()]->sourceFile == m_sourceSelFiles.at(sourceSelIndex)) + setSourceLine(ctx.sourceId(),ctx.curStmtFirstLine()); + } +} + +void KJSDebugWin::slotEval() +{ + // Work out which execution state to use. If we're currently in a debugging session, + // use the current context - otherwise, use the global execution state from the interpreter + // corresponding to the currently displayed source file. + ExecState *exec; + Object thisobj; + if (m_execStates.isEmpty()) { + if (m_sourceSel->currentItem() < 0) + return; + SourceFile *sourceFile = m_sourceSelFiles.at(m_sourceSel->currentItem()); + if (!sourceFile->interpreter) + return; + exec = sourceFile->interpreter->globalExec(); + thisobj = exec->interpreter()->globalObject(); + } + else { + exec = m_execStates.top(); + thisobj = exec->context().thisValue(); + } + + // Evaluate the js code from m_evalEdit + UString code(m_evalEdit->code()); + TQString msg; + + KJSCPUGuard guard; + guard.start(); + + Interpreter *interp = exec->interpreter(); + + Object obj = Object::dynamicCast(interp->globalObject().get(exec, "eval")); + List args; + args.append(String(code)); + + m_evalDepth++; + Value retval = obj.call(exec, thisobj, args); + m_evalDepth--; + guard.stop(); + + // Print the return value or exception message to the console + if (exec->hadException()) { + Value exc = exec->exception(); + exec->clearException(); + msg = "Exception: " + exc.toString(interp->globalExec()).qstring(); + } + else { + msg = retval.toString(interp->globalExec()).qstring(); + } + + m_evalEdit->insert(msg+"\n"); + updateContextList(); +} + +void KJSDebugWin::closeEvent(TQCloseEvent *e) +{ + while (!m_execStates.isEmpty()) // ### not sure if this will work + leaveSession(); + return TQWidget::closeEvent(e); +} + +bool KJSDebugWin::eventFilter(TQObject *o, TQEvent *e) +{ + switch (e->type()) { + case TQEvent::MouseButtonPress: + case TQEvent::MouseButtonRelease: + case TQEvent::MouseButtonDblClick: + case TQEvent::MouseMove: + case TQEvent::KeyPress: + case TQEvent::KeyRelease: + case TQEvent::Destroy: + case TQEvent::Close: + case TQEvent::Quit: + while (o->parent()) + o = TQT_TQOBJECT(o->parent()); + if (TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(this)) + return TQWidget::eventFilter(o,e); + else + return true; + break; + default: + return TQWidget::eventFilter(o,e); + } +} + +void KJSDebugWin::disableOtherWindows() +{ + TQWidgetList *widgets = TQApplication::allWidgets(); + TQWidgetListIt it(*widgets); + for (; it.current(); ++it) + it.current()->installEventFilter(this); +} + +void KJSDebugWin::enableOtherWindows() +{ + TQWidgetList *widgets = TQApplication::allWidgets(); + TQWidgetListIt it(*widgets); + for (; it.current(); ++it) + it.current()->removeEventFilter(this); +} + +bool KJSDebugWin::sourceParsed(KJS::ExecState *exec, int sourceId, + const KJS::UString &source, int errorLine) +{ + // Work out which source file this fragment is in + SourceFile *sourceFile = 0; + if (!m_nextSourceUrl.isEmpty()) + sourceFile = getSourceFile(exec->interpreter(),m_nextSourceUrl); + + int index; + if (!sourceFile) { + index = m_sourceSel->count(); + if (!m_nextSourceUrl.isEmpty()) { + + TQString code = source.qstring(); + KParts::ReadOnlyPart *part = static_cast<ScriptInterpreter*>(exec->interpreter())->part(); + if (m_nextSourceUrl == part->url().url()) { + // Only store the code here if it's not from the part's html page... in that + // case we can get it from KHTMLPageCache + code = TQString::null; + } + + sourceFile = new SourceFile(m_nextSourceUrl,code,exec->interpreter()); + setSourceFile(exec->interpreter(),m_nextSourceUrl,sourceFile); + m_sourceSelFiles.append(sourceFile); + m_sourceSel->insertItem(m_nextSourceUrl); + } + else { + // Sourced passed from somewhere else (possibly an eval call)... we don't know the url, + // but we still know the interpreter + sourceFile = new SourceFile("(unknown)",source.qstring(),exec->interpreter()); + m_sourceSelFiles.append(sourceFile); + m_sourceSel->insertItem(TQString::number(index) += "-???"); + } + } + else { + // Ensure that each source file to be displayed is associated with + // an appropriate interpreter + if (!sourceFile->interpreter) + sourceFile->interpreter = exec->interpreter(); + for (index = 0; index < m_sourceSel->count(); index++) { + if (m_sourceSelFiles.at(index) == sourceFile) + break; + } + assert(index < m_sourceSel->count()); + } + + SourceFragment *sf = new SourceFragment(sourceId,m_nextSourceBaseLine,errorLine,sourceFile); + m_sourceFragments[sourceId] = sf; + + if (m_sourceSel->currentItem() < 0) + m_sourceSel->setCurrentItem(index); + + if (m_sourceSel->currentItem() == index) { + displaySourceFile(sourceFile,true); + } + + m_nextSourceBaseLine = 1; + m_nextSourceUrl = ""; + + return (m_mode != Stop); +} + +bool KJSDebugWin::sourceUnused(KJS::ExecState *exec, int sourceId) +{ + // Verify that there aren't any contexts on the stack using the given sourceId + // This should never be the case because this function is only called when + // the interpreter has deleted all Node objects for the source. + for (int e = 0; e < m_execsCount; e++) + assert(m_execs[e]->context().sourceId() != sourceId); + + // Now remove the fragment (and the SourceFile, if it was the last fragment in that file) + SourceFragment *fragment = m_sourceFragments[sourceId]; + if (fragment) { + m_sourceFragments.erase(sourceId); + + SourceFile *sourceFile = fragment->sourceFile; + if (sourceFile->hasOneRef()) { + for (int i = 0; i < m_sourceSel->count(); i++) { + if (m_sourceSelFiles.at(i) == sourceFile) { + m_sourceSel->removeItem(i); + m_sourceSelFiles.remove(i); + break; + } + } + removeSourceFile(exec->interpreter(),sourceFile->url); + } + delete fragment; + } + + return (m_mode != Stop); +} + +bool KJSDebugWin::exception(ExecState *exec, const Value &value, bool inTryCatch) +{ + assert(value.isValid()); + + // Ignore exceptions that will be caught by the script + if (inTryCatch) + return true; + + KParts::ReadOnlyPart *part = static_cast<ScriptInterpreter*>(exec->interpreter())->part(); + KHTMLPart *tdehtmlpart = ::tqqt_cast<KHTMLPart*>(part); + if (tdehtmlpart && !tdehtmlpart->settings()->isJavaScriptErrorReportingEnabled()) + return true; + + TQWidget *dlgParent = (m_evalDepth == 0) ? (TQWidget*)part->widget() : (TQWidget*)this; + + TQString exceptionMsg = value.toString(exec).qstring(); + + // Syntax errors are a special case. For these we want to display the url & lineno, + // which isn't included in the exception messeage. So we work it out from the values + // passed to sourceParsed() + Object valueObj = Object::dynamicCast(value); + Object syntaxError = exec->interpreter()->builtinSyntaxError(); + if (valueObj.isValid() && valueObj.get(exec,"constructor").imp() == syntaxError.imp()) { + Value sidValue = valueObj.get(exec,"sid"); + if (sidValue.isA(NumberType)) { // sid is not set for Function() constructor + int sourceId = (int)sidValue.toNumber(exec); + assert(m_sourceFragments[sourceId]); + exceptionMsg = i18n("Parse error at %1 line %2") + .arg(m_sourceFragments[sourceId]->sourceFile->url) + .arg(m_sourceFragments[sourceId]->baseLine+m_sourceFragments[sourceId]->errorLine-1); + } + } + + bool dontShowAgain = false; + if (m_execsCount == 0) { + // An exception occurred and we're not currently executing any code... this can + // happen in some cases e.g. a parse error, or native code accessing funcitons like + // Object::put() + TQString msg = i18n("An error occurred while attempting to run a script on this page.\n\n%1") + .arg(exceptionMsg); + KJSErrorDialog dlg(dlgParent,msg,false); + dlg.exec(); + dontShowAgain = dlg.dontShowAgain(); + } + else { + Context ctx = m_execs[m_execsCount-1]->context(); + SourceFragment *sourceFragment = m_sourceFragments[ctx.sourceId()]; + TQString msg = i18n("An error occurred while attempting to run a script on this page.\n\n%1 line %2:\n%3") + .arg(KStringHandler::rsqueeze( sourceFragment->sourceFile->url,80), + TQString::number( sourceFragment->baseLine+ctx.curStmtFirstLine()-1), + exceptionMsg); + + KJSErrorDialog dlg(dlgParent,msg,true); + dlg.exec(); + dontShowAgain = dlg.dontShowAgain(); + + if (dlg.debugSelected()) { + m_mode = Next; + m_steppingDepth = m_execsCount-1; + enterSession(exec); + } + } + + if (dontShowAgain) { + TDEConfig *config = kapp->config(); + TDEConfigGroupSaver saver(config,TQString::fromLatin1("Java/JavaScript Settings")); + config->writeEntry("ReportJavaScriptErrors",TQVariant(false,0)); + config->sync(); + TQByteArray data; + kapp->dcopClient()->send( "konqueror*", "KonquerorIface", "reparseConfiguration()", data ); + } + + return (m_mode != Stop); +} + +bool KJSDebugWin::atStatement(KJS::ExecState *exec) +{ + assert(m_execsCount > 0); + assert(m_execs[m_execsCount-1] == exec); + checkBreak(exec); + return (m_mode != Stop); +} + +bool KJSDebugWin::enterContext(ExecState *exec) +{ + if (m_execsCount >= m_execsAlloc) { + m_execsAlloc += 10; + m_execs = (ExecState**)realloc(m_execs,m_execsAlloc*sizeof(ExecState*)); + } + m_execs[m_execsCount++] = exec; + + if (m_mode == Step) + m_steppingDepth = m_execsCount-1; + + checkBreak(exec); + return (m_mode != Stop); +} + +bool KJSDebugWin::exitContext(ExecState *exec, const Completion &/*completion*/) +{ + assert(m_execsCount > 0); + assert(m_execs[m_execsCount-1] == exec); + + checkBreak(exec); + + m_execsCount--; + if (m_steppingDepth > m_execsCount-1) + m_steppingDepth = m_execsCount-1; + if (m_execsCount == 0) + updateContextList(); + + return (m_mode != Stop); +} + +void KJSDebugWin::displaySourceFile(SourceFile *sourceFile, bool forceRefresh) +{ + if (m_curSourceFile == sourceFile && !forceRefresh) + return; + sourceFile->ref(); + m_sourceDisplay->setSource(sourceFile); + if (m_curSourceFile) + m_curSourceFile->deref(); + m_curSourceFile = sourceFile; +} + +void KJSDebugWin::setSourceLine(int sourceId, int lineno) +{ + SourceFragment *source = m_sourceFragments[sourceId]; + if (!source) + return; + + SourceFile *sourceFile = source->sourceFile; + if (m_curSourceFile != source->sourceFile) { + for (int i = 0; i < m_sourceSel->count(); i++) + if (m_sourceSelFiles.at(i) == sourceFile) + m_sourceSel->setCurrentItem(i); + displaySourceFile(sourceFile,false); + } + m_sourceDisplay->setCurrentLine(source->baseLine+lineno-2); +} + +void KJSDebugWin::setNextSourceInfo(TQString url, int baseLine) +{ + m_nextSourceUrl = url; + m_nextSourceBaseLine = baseLine; +} + +void KJSDebugWin::sourceChanged(Interpreter *interpreter, TQString url) +{ + SourceFile *sourceFile = getSourceFile(interpreter,url); + if (sourceFile && m_curSourceFile == sourceFile) + displaySourceFile(sourceFile,true); +} + +void KJSDebugWin::clearInterpreter(Interpreter *interpreter) +{ + TQMap<int,SourceFragment*>::Iterator it; + + for (it = m_sourceFragments.begin(); it != m_sourceFragments.end(); ++it) + if (it.data() && it.data()->sourceFile->interpreter == interpreter) + it.data()->sourceFile->interpreter = 0; +} + +SourceFile *KJSDebugWin::getSourceFile(Interpreter *interpreter, TQString url) +{ + TQString key = TQString("%1|%2").arg((long)interpreter).arg(url); + return m_sourceFiles[key]; +} + +void KJSDebugWin::setSourceFile(Interpreter *interpreter, TQString url, SourceFile *sourceFile) +{ + TQString key = TQString("%1|%2").arg((long)interpreter).arg(url); + sourceFile->ref(); + if (SourceFile* oldFile = m_sourceFiles[key]) + oldFile->deref(); + m_sourceFiles[key] = sourceFile; +} + +void KJSDebugWin::removeSourceFile(Interpreter *interpreter, TQString url) +{ + TQString key = TQString("%1|%2").arg((long)interpreter).arg(url); + if (SourceFile* oldFile = m_sourceFiles[key]) + oldFile->deref(); + m_sourceFiles.remove(key); +} + +void KJSDebugWin::checkBreak(ExecState *exec) +{ + if (m_breakpointCount > 0) { + Context ctx = m_execs[m_execsCount-1]->context(); + if (haveBreakpoint(ctx.sourceId(),ctx.curStmtFirstLine(),ctx.curStmtLastLine())) { + m_mode = Next; + m_steppingDepth = m_execsCount-1; + } + } + + if ((m_mode == Step || m_mode == Next) && m_steppingDepth == m_execsCount-1) + enterSession(exec); +} + +void KJSDebugWin::enterSession(ExecState *exec) +{ + // This "enters" a new debugging session, i.e. enables usage of the debugging window + // It re-enters the qt event loop here, allowing execution of other parts of the + // program to continue while the script is stopped. We have to be a bit careful here, + // i.e. make sure the user can't quit the app, and disable other event handlers which + // could interfere with the debugging session. + if (!isVisible()) + show(); + + m_mode = Continue; + + if (m_execStates.isEmpty()) { + disableOtherWindows(); + m_nextAction->setEnabled(true); + m_stepAction->setEnabled(true); + m_continueAction->setEnabled(true); + m_stopAction->setEnabled(true); + m_breakAction->setEnabled(false); + } + m_execStates.push(exec); + + updateContextList(); + + tqApp->enter_loop(); // won't return until leaveSession() is called +} + +void KJSDebugWin::leaveSession() +{ + // Disables debugging for this window and returns to execute the rest of the script + // (or aborts execution, if the user pressed stop). When this returns, the program + // will exit the qt event loop, i.e. return to whatever processing was being done + // before the debugger was stopped. + assert(!m_execStates.isEmpty()); + + m_execStates.pop(); + + if (m_execStates.isEmpty()) { + m_nextAction->setEnabled(false); + m_stepAction->setEnabled(false); + m_continueAction->setEnabled(false); + m_stopAction->setEnabled(false); + m_breakAction->setEnabled(true); + m_sourceDisplay->setCurrentLine(-1); + enableOtherWindows(); + } + + tqApp->exit_loop(); +} + +void KJSDebugWin::updateContextList() +{ + disconnect(m_contextList,TQT_SIGNAL(highlighted(int)),this,TQT_SLOT(slotShowFrame(int))); + + m_contextList->clear(); + for (int i = 0; i < m_execsCount; i++) + m_contextList->insertItem(contextStr(m_execs[i]->context())); + + if (m_execsCount > 0) { + m_contextList->setSelected(m_execsCount-1, true); + Context ctx = m_execs[m_execsCount-1]->context(); + setSourceLine(ctx.sourceId(),ctx.curStmtFirstLine()); + } + + connect(m_contextList,TQT_SIGNAL(highlighted(int)),this,TQT_SLOT(slotShowFrame(int))); +} + +TQString KJSDebugWin::contextStr(const Context &ctx) +{ + TQString str = ""; + SourceFragment *sourceFragment = m_sourceFragments[ctx.sourceId()]; + TQString url = sourceFragment->sourceFile->url; + int fileLineno = sourceFragment->baseLine+ctx.curStmtFirstLine()-1; + + switch (ctx.codeType()) { + case GlobalCode: + str = TQString("Global code at %1:%2").arg(url).arg(fileLineno); + break; + case EvalCode: + str = TQString("Eval code at %1:%2").arg(url).arg(fileLineno); + break; + case FunctionCode: + if (!ctx.functionName().isNull()) + str = TQString("%1() at %2:%3").arg(ctx.functionName().qstring()).arg(url).arg(fileLineno); + else + str = TQString("Anonymous function at %1:%2").arg(url).arg(fileLineno); + break; + } + + return str; +} + +bool KJSDebugWin::setBreakpoint(int sourceId, int lineno) +{ + if (haveBreakpoint(sourceId,lineno,lineno)) + return false; + + m_breakpointCount++; + m_breakpoints = static_cast<Breakpoint*>(realloc(m_breakpoints, + m_breakpointCount*sizeof(Breakpoint))); + m_breakpoints[m_breakpointCount-1].sourceId = sourceId; + m_breakpoints[m_breakpointCount-1].lineno = lineno; + + return true; +} + +bool KJSDebugWin::deleteBreakpoint(int sourceId, int lineno) +{ + for (int i = 0; i < m_breakpointCount; i++) { + if (m_breakpoints[i].sourceId == sourceId && m_breakpoints[i].lineno == lineno) { + + memmove(m_breakpoints+i,m_breakpoints+i+1,(m_breakpointCount-i-1)*sizeof(Breakpoint)); + m_breakpointCount--; + m_breakpoints = static_cast<Breakpoint*>(realloc(m_breakpoints, + m_breakpointCount*sizeof(Breakpoint))); + return true; + } + } + + return false; +} + +bool KJSDebugWin::haveBreakpoint(SourceFile *sourceFile, int line0, int line1) +{ + for (int i = 0; i < m_breakpointCount; i++) { + int sourceId = m_breakpoints[i].sourceId; + int lineno = m_breakpoints[i].lineno; + if (m_sourceFragments.contains(sourceId) && + m_sourceFragments[sourceId]->sourceFile == sourceFile) { + int absLineno = m_sourceFragments[sourceId]->baseLine+lineno-1; + if (absLineno >= line0 && absLineno <= line1) + return true; + } + } + + return false; +} + +#include "kjs_debugwin.moc" + +#endif // KJS_DEBUGGER diff --git a/tdehtml/ecma/kjs_debugwin.h b/tdehtml/ecma/kjs_debugwin.h new file mode 100644 index 000000000..dc2368ac2 --- /dev/null +++ b/tdehtml/ecma/kjs_debugwin.h @@ -0,0 +1,285 @@ +/* + * This file is part of the KDE libraries + * Copyright (C) 2000-2001 Harri Porten (porten@kde.org) + * Copyright (C) 2001,2003 Peter Kelly (pmk@post.com) + * + * 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 + */ + +#ifndef _KJS_DEBUGGER_H_ +#define _KJS_DEBUGGER_H_ + +#include <tqglobal.h> + +#define KJS_DEBUGGER + +#ifdef KJS_DEBUGGER + +#include <tqwidget.h> +#include <tqmultilineedit.h> +#include <tqpixmap.h> +#include <tqptrlist.h> +#include <tqptrstack.h> +#include <tqcheckbox.h> +#include <kdialogbase.h> +#include <kmainwindow.h> +#include <tqscrollview.h> + +#include <kjs/debugger.h> + +#include "dom/dom_misc.h" + +class TQListBox; +class TQComboBox; +class KActionCollection; +class KAction; + +namespace KJS { + class FunctionImp; + class List; + class Interpreter; + class KJSDebugWin; + + class SourceFile : public DOM::DomShared + { + public: + SourceFile(TQString u, TQString c, Interpreter *interp) + : url(u), code(c), interpreter(interp) {} + TQString getCode(); + TQString url; + TQString code; + Interpreter *interpreter; + }; + + /** + * @internal + * + * When kjs parses some code, it generates a source code fragment (or just "source"). + * This is referenced by its source id in future calls to functions such as atLine() + * and callEvent(). We keep a record of all source fragments parsed in order to display + * then to the user. + * + * For .js files, the source fragment will be the entire file. For js code included + * in html files, however, there may be multiple source fragments within the one file + * (e.g. multiple SCRIPT tags or onclick="..." attributes) + * + * In the case where a single file has multiple source fragments, the source objects + * for these fragments will all point to the same SourceFile for their code. + */ + class SourceFragment + { + public: + SourceFragment(int sid, int bl, int el, SourceFile *sf); + ~SourceFragment(); + + int sourceId; + int baseLine; + int errorLine; + SourceFile *sourceFile; + private: + SourceFragment(const SourceFragment& other); + SourceFragment& operator = (const SourceFragment& other); + }; + + class KJSErrorDialog : public KDialogBase { + Q_OBJECT + public: + KJSErrorDialog(TQWidget *parent, const TQString& errorMessage, bool showDebug); + virtual ~KJSErrorDialog(); + + bool debugSelected() const { return m_debugSelected; } + bool dontShowAgain() const { return m_dontShowAgainCb->isChecked(); } + + protected slots: + virtual void slotUser1(); + + private: + TQCheckBox *m_dontShowAgainCb; + bool m_debugSelected; + }; + + class EvalMultiLineEdit : public TQMultiLineEdit { + Q_OBJECT + public: + EvalMultiLineEdit(TQWidget *parent); + const TQString & code() const { return m_code; } + protected: + void keyPressEvent(TQKeyEvent * e); + private: + TQString m_code; + }; + + class SourceDisplay : public TQScrollView { + Q_OBJECT + public: + SourceDisplay(KJSDebugWin *debugWin, TQWidget *parent, const char *name = 0); + ~SourceDisplay(); + + void setSource(SourceFile *sourceFile); + void setCurrentLine(int lineno, bool doCenter = true); + + signals: + void lineDoubleClicked(int lineno); + + protected: + virtual void contentsMousePressEvent(TQMouseEvent *e); + virtual void showEvent(TQShowEvent *); + virtual void drawContents(TQPainter *p, int clipx, int clipy, int clipw, int cliph); + + TQString m_source; + int m_currentLine; + SourceFile *m_sourceFile; + TQStringList m_lines; + + KJSDebugWin *m_debugWin; + TQFont m_font; + TQPixmap m_breakpointIcon; + }; + + /** + * @internal + * + * KJSDebugWin represents the debugger window that is visible to the user. It contains + * a stack frame list, a code viewer and a source fragment selector, plus buttons + * to control execution including next, step and continue. + * + * There is only one debug window per program. This can be obtained by calling #instance + */ + class KJSDebugWin : public KMainWindow, public Debugger, public TDEInstance + { + Q_OBJECT + friend class SourceDisplay; + public: + KJSDebugWin(TQWidget *parent=0, const char *name=0); + virtual ~KJSDebugWin(); + + static KJSDebugWin *createInstance(); + static void destroyInstance(); + static KJSDebugWin *debugWindow() { return kjs_html_debugger; } + + enum Mode { Disabled = 0, // No break on any statements + Next = 1, // Will break on next statement in current context + Step = 2, // Will break on next statement in current or deeper context + Continue = 3, // Will continue until next breakpoint + Stop = 4 // The script will stop execution completely, + // as soon as possible + }; + + void setSourceLine(int sourceId, int lineno); + void setNextSourceInfo(TQString url, int baseLine); + void sourceChanged(Interpreter *interpreter, TQString url); + bool inSession() const { return !m_execStates.isEmpty(); } + void setMode(Mode m) { m_mode = m; } + void clearInterpreter(Interpreter *interpreter); + ExecState *getExecState() const { return m_execStates.top(); } + + // functions overridden from KJS:Debugger + bool sourceParsed(ExecState *exec, int sourceId, + const UString &source, int errorLine); + bool sourceUnused(ExecState * exec, int sourceId); + bool exception(ExecState *exec, const Value &value, bool inTryCatch); + bool atStatement(ExecState *exec); + bool enterContext(ExecState *exec); + bool exitContext(ExecState *exec, const Completion &completion); + + public slots: + void slotNext(); + void slotStep(); + void slotContinue(); + void slotStop(); + void slotBreakNext(); + void slotToggleBreakpoint(int lineno); + void slotShowFrame(int frameno); + void slotSourceSelected(int sourceSelIndex); + void slotEval(); + + protected: + + void closeEvent(TQCloseEvent *e); + bool eventFilter(TQObject *obj, TQEvent *evt); + void disableOtherWindows(); + void enableOtherWindows(); + + private: + + SourceFile *getSourceFile(Interpreter *interpreter, TQString url); + void setSourceFile(Interpreter *interpreter, TQString url, SourceFile *sourceFile); + void removeSourceFile(Interpreter *interpreter, TQString url); + + void checkBreak(ExecState *exec); + void enterSession(ExecState *exec); + void leaveSession(); + void displaySourceFile(SourceFile *sourceFile, bool forceRefresh); + void updateContextList(); + + TQString contextStr(const Context &ctx); + + struct Breakpoint { + int sourceId; + int lineno; + }; + Breakpoint *m_breakpoints; + int m_breakpointCount; + bool setBreakpoint(int sourceId, int lineno); + bool deleteBreakpoint(int sourceId, int lineno); + bool haveBreakpoint(SourceFile *sourceFile, int line0, int line1); + bool haveBreakpoint(int sourceId, int line0, int line1) const { + for (int i = 0; i < m_breakpointCount; i++) { + if (m_breakpoints[i].sourceId == sourceId && + m_breakpoints[i].lineno >= line0 && + m_breakpoints[i].lineno <= line1) + return true; + } + return false; + } + + SourceFile *m_curSourceFile; + Mode m_mode; + TQString m_nextSourceUrl; + int m_nextSourceBaseLine; + TQPtrStack<ExecState> m_execStates; + ExecState **m_execs; + int m_execsCount; + int m_execsAlloc; + int m_steppingDepth; + + TQMap<TQString,SourceFile*> m_sourceFiles; /* maps url->SourceFile */ + TQMap<int,SourceFragment*> m_sourceFragments; /* maps SourceId->SourceFragment */ + TQPtrList<SourceFile> m_sourceSelFiles; /* maps combobox index->SourceFile */ + + KActionCollection *m_actionCollection; + TQPixmap m_stopIcon; + TQPixmap m_emptyIcon; + SourceDisplay *m_sourceDisplay; + TQListBox *m_contextList; + + KAction *m_stepAction; + KAction *m_nextAction; + KAction *m_continueAction; + KAction *m_stopAction; + KAction *m_breakAction; + + TQComboBox *m_sourceSel; + EvalMultiLineEdit *m_evalEdit; + int m_evalDepth; + + static KJSDebugWin *kjs_html_debugger; + }; + +} // namespace + +#endif // KJS_DEBUGGER + +#endif // _KJS_DEBUGGER_H_ diff --git a/tdehtml/ecma/kjs_dom.cpp b/tdehtml/ecma/kjs_dom.cpp new file mode 100644 index 000000000..71e91d7ef --- /dev/null +++ b/tdehtml/ecma/kjs_dom.cpp @@ -0,0 +1,1849 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * 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 <tdehtmlview.h> +#include "xml/dom2_eventsimpl.h" +#include "rendering/render_canvas.h" +#include "rendering/render_layer.h" +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" +#include "misc/htmltags.h" // ID_* +#include "misc/htmlattrs.h" // ATTR_* +#include "html/html_baseimpl.h" +#include <kdebug.h> +#include <tdehtml_part.h> + +#include "kjs_dom.h" +#include "kjs_html.h" +#include "kjs_css.h" +#include "kjs_range.h" +#include "kjs_traversal.h" +#include "kjs_events.h" +#include "kjs_views.h" +#include "kjs_window.h" +#include "dom/dom_exception.h" +#include "kjs_dom.lut.h" +#include "tdehtmlpart_p.h" + +namespace KJS { + +// ------------------------------------------------------------------------- +/* Source for DOMNodeConstantsTable. +@begin DOMNodeConstantsTable 11 + ELEMENT_NODE DOM::Node::ELEMENT_NODE DontDelete|ReadOnly + ATTRIBUTE_NODE DOM::Node::ATTRIBUTE_NODE DontDelete|ReadOnly + TEXT_NODE DOM::Node::TEXT_NODE DontDelete|ReadOnly + CDATA_SECTION_NODE DOM::Node::CDATA_SECTION_NODE DontDelete|ReadOnly + ENTITY_REFERENCE_NODE DOM::Node::ENTITY_REFERENCE_NODE DontDelete|ReadOnly + ENTITY_NODE DOM::Node::ENTITY_NODE DontDelete|ReadOnly + PROCESSING_INSTRUCTION_NODE DOM::Node::PROCESSING_INSTRUCTION_NODE DontDelete|ReadOnly + COMMENT_NODE DOM::Node::COMMENT_NODE DontDelete|ReadOnly + DOCUMENT_NODE DOM::Node::DOCUMENT_NODE DontDelete|ReadOnly + DOCUMENT_TYPE_NODE DOM::Node::DOCUMENT_TYPE_NODE DontDelete|ReadOnly + DOCUMENT_FRAGMENT_NODE DOM::Node::DOCUMENT_FRAGMENT_NODE DontDelete|ReadOnly + NOTATION_NODE DOM::Node::NOTATION_NODE DontDelete|ReadOnly +@end +*/ +IMPLEMENT_CONSTANT_TABLE(DOMNodeConstants,"DOMNodeConstants") +// ------------------------------------------------------------------------- +/* Source for DOMNodeProtoTable. +@begin DOMNodeProtoTable 13 + insertBefore DOMNode::InsertBefore DontDelete|Function 2 + replaceChild DOMNode::ReplaceChild DontDelete|Function 2 + removeChild DOMNode::RemoveChild DontDelete|Function 1 + appendChild DOMNode::AppendChild DontDelete|Function 1 + hasAttributes DOMNode::HasAttributes DontDelete|Function 0 + hasChildNodes DOMNode::HasChildNodes DontDelete|Function 0 + cloneNode DOMNode::CloneNode DontDelete|Function 1 +# DOM2 + normalize DOMNode::Normalize DontDelete|Function 0 + isSupported DOMNode::IsSupported DontDelete|Function 2 +# from the EventTarget interface + addEventListener DOMNode::AddEventListener DontDelete|Function 3 + removeEventListener DOMNode::RemoveEventListener DontDelete|Function 3 + dispatchEvent DOMNode::DispatchEvent DontDelete|Function 1 +# IE extensions + contains DOMNode::Contains DontDelete|Function 1 + insertAdjacentHTML DOMNode::InsertAdjacentHTML DontDelete|Function 2 +# "DOM level 0" (from Gecko DOM reference; also in WinIE) + item DOMNode::Item DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMNodeProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMNode", DOMNodeProto, DOMNodeProtoFunc) + +const ClassInfo DOMNode::info = { "Node", 0, &DOMNodeTable, 0 }; + +DOMNode::DOMNode(ExecState *exec, const DOM::Node& n) + : DOMObject(DOMNodeProto::self(exec)), node(n) +{ +} + +DOMNode::DOMNode(const Object& proto, const DOM::Node& n) + : DOMObject(proto), node(n) +{ +} + +DOMNode::~DOMNode() +{ + ScriptInterpreter::forgetDOMObject(node.handle()); +} + +bool DOMNode::toBoolean(ExecState *) const +{ + return !node.isNull(); +} + +/* Source for DOMNodeTable. +@begin DOMNodeTable 53 + nodeName DOMNode::NodeName DontDelete|ReadOnly + nodeValue DOMNode::NodeValue DontDelete + nodeType DOMNode::NodeType DontDelete|ReadOnly + parentNode DOMNode::ParentNode DontDelete|ReadOnly + parentElement DOMNode::ParentElement DontDelete|ReadOnly + childNodes DOMNode::ChildNodes DontDelete|ReadOnly + firstChild DOMNode::FirstChild DontDelete|ReadOnly + lastChild DOMNode::LastChild DontDelete|ReadOnly + previousSibling DOMNode::PreviousSibling DontDelete|ReadOnly + nextSibling DOMNode::NextSibling DontDelete|ReadOnly + attributes DOMNode::Attributes DontDelete|ReadOnly + namespaceURI DOMNode::NamespaceURI DontDelete|ReadOnly +# DOM2 + prefix DOMNode::Prefix DontDelete + localName DOMNode::LocalName DontDelete|ReadOnly + ownerDocument DOMNode::OwnerDocument DontDelete|ReadOnly +# DOM3 + textContent DOMNode::TextContent DontDelete +# Event handlers +# IE also has: onactivate, onbefore*, oncontextmenu, oncontrolselect, oncut, +# ondeactivate, ondrag*, ondrop, onfocusin, onfocusout, onhelp, onmousewheel, +# onmove*, onpaste, onpropertychange, onreadystatechange, onresizeend/start, +# onselectionchange, onstop + onabort DOMNode::OnAbort DontDelete + onblur DOMNode::OnBlur DontDelete + onchange DOMNode::OnChange DontDelete + onclick DOMNode::OnClick DontDelete + ondblclick DOMNode::OnDblClick DontDelete + ondragdrop DOMNode::OnDragDrop DontDelete + onerror DOMNode::OnError DontDelete + onfocus DOMNode::OnFocus DontDelete + onkeydown DOMNode::OnKeyDown DontDelete + onkeypress DOMNode::OnKeyPress DontDelete + onkeyup DOMNode::OnKeyUp DontDelete + onload DOMNode::OnLoad DontDelete + onmousedown DOMNode::OnMouseDown DontDelete + onmousemove DOMNode::OnMouseMove DontDelete + onmouseout DOMNode::OnMouseOut DontDelete + onmouseover DOMNode::OnMouseOver DontDelete + onmouseup DOMNode::OnMouseUp DontDelete + onmove DOMNode::OnMove DontDelete + onreset DOMNode::OnReset DontDelete + onresize DOMNode::OnResize DontDelete + onselect DOMNode::OnSelect DontDelete + onsubmit DOMNode::OnSubmit DontDelete + onunload DOMNode::OnUnload DontDelete +# IE extensions + offsetLeft DOMNode::OffsetLeft DontDelete|ReadOnly + offsetTop DOMNode::OffsetTop DontDelete|ReadOnly + offsetWidth DOMNode::OffsetWidth DontDelete|ReadOnly + offsetHeight DOMNode::OffsetHeight DontDelete|ReadOnly + offsetParent DOMNode::OffsetParent DontDelete|ReadOnly + clientWidth DOMNode::ClientWidth DontDelete|ReadOnly + clientHeight DOMNode::ClientHeight DontDelete|ReadOnly + scrollLeft DOMNode::ScrollLeft DontDelete + scrollTop DOMNode::ScrollTop DontDelete + scrollWidth DOMNode::ScrollWidth DontDelete|ReadOnly + scrollHeight DOMNode::ScrollHeight DontDelete|ReadOnly + sourceIndex DOMNode::SourceIndex DontDelete|ReadOnly +@end +*/ +Value DOMNode::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMNode::tryGet " << propertyName.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMNode, DOMObject>(exec, propertyName, &DOMNodeTable, this); +} + +static tdehtml::RenderObject* handleBodyRootQuirk(const DOM::Node& node, tdehtml::RenderObject* rend, int token) +{ + //This emulates the quirks of various height/width properties on the viewport and root. Note that it + //is (mostly) IE-compatible in quirks, and mozilla-compatible in strict. + if (!rend) return 0; + + bool quirksMode = rend->style() && rend->style()->htmlHacks(); + + //There are a couple quirks here. One is that in quirks mode body is always forwarded to root... + //This is relevant for even the scrollTop/scrollLeft type properties. + if (quirksMode && node.handle()->id() == ID_BODY) { + while (rend->parent() && !rend->isRoot()) + rend = rend->parent(); + } + + //Also, some properties of the root are really done in terms of the viewport. + //These are {offset/client}{Height/Width}. The offset versions do it only in + //quirks mode, the client always. + if (!rend->isRoot()) return rend; //Don't care about non-root things here! + bool needViewport = false; + + switch (token) { + case DOMNode::OffsetHeight: + case DOMNode::OffsetWidth: + needViewport = quirksMode; + break; + case DOMNode::ClientHeight: + case DOMNode::ClientWidth: + needViewport = true; + break; + } + + if (needViewport) { + //Scan up to find the new target + while (rend->parent()) + rend = rend->parent(); + } + return rend; +} + +Value DOMNode::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case NodeName: + return String(node.nodeName()); + case NodeValue: + return getString(node.nodeValue()); // initially null, per domts/level1/core/hc_documentcreateelement.html + case NodeType: + return Number((unsigned int)node.nodeType()); + case ParentNode: + return getDOMNode(exec,node.parentNode()); + case ParentElement: // IE only apparently + return getDOMNode(exec,node.parentNode()); + case ChildNodes: + return getDOMNodeList(exec,node.childNodes()); + case FirstChild: + return getDOMNode(exec,node.firstChild()); + case LastChild: + return getDOMNode(exec,node.lastChild()); + case PreviousSibling: + return getDOMNode(exec,node.previousSibling()); + case NextSibling: + return getDOMNode(exec,node.nextSibling()); + case Attributes: + return getDOMNamedNodeMap(exec,node.attributes()); + case NamespaceURI: + return getString(node.namespaceURI()); // Moz returns null if not set (dom/namespaces.html) + case Prefix: + return getString(node.prefix()); // Moz returns null if not set (dom/namespaces.html) + case TextContent: + return getString(node.textContent()); //DOM3 says return null, but I really should test mozilla.. + case LocalName: + return getString(node.localName()); // Moz returns null if not set (dom/namespaces.html) + case OwnerDocument: + return getDOMNode(exec,node.ownerDocument()); + case OnAbort: + return getListener(DOM::EventImpl::ABORT_EVENT); + case OnBlur: + return getListener(DOM::EventImpl::BLUR_EVENT); + case OnChange: + return getListener(DOM::EventImpl::CHANGE_EVENT); + case OnClick: + return getListener(DOM::EventImpl::KHTML_ECMA_CLICK_EVENT); + case OnDblClick: + return getListener(DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT); + case OnDragDrop: + return getListener(DOM::EventImpl::KHTML_DRAGDROP_EVENT); + case OnError: + return getListener(DOM::EventImpl::ERROR_EVENT); + case OnFocus: + return getListener(DOM::EventImpl::FOCUS_EVENT); + case OnKeyDown: + return getListener(DOM::EventImpl::KEYDOWN_EVENT); + case OnKeyPress: + return getListener(DOM::EventImpl::KEYPRESS_EVENT); + case OnKeyUp: + return getListener(DOM::EventImpl::KEYUP_EVENT); + case OnLoad: + return getListener(DOM::EventImpl::LOAD_EVENT); + case OnMouseDown: + return getListener(DOM::EventImpl::MOUSEDOWN_EVENT); + case OnMouseMove: + return getListener(DOM::EventImpl::MOUSEMOVE_EVENT); + case OnMouseOut: + return getListener(DOM::EventImpl::MOUSEOUT_EVENT); + case OnMouseOver: + return getListener(DOM::EventImpl::MOUSEOVER_EVENT); + case OnMouseUp: + return getListener(DOM::EventImpl::MOUSEUP_EVENT); + case OnMove: + return getListener(DOM::EventImpl::KHTML_MOVE_EVENT); + case OnReset: + return getListener(DOM::EventImpl::RESET_EVENT); + case OnResize: + return getListener(DOM::EventImpl::RESIZE_EVENT); + case OnSelect: + return getListener(DOM::EventImpl::SELECT_EVENT); + case OnSubmit: + return getListener(DOM::EventImpl::SUBMIT_EVENT); + case OnUnload: + return getListener(DOM::EventImpl::UNLOAD_EVENT); + case SourceIndex: { + // Retrieves the ordinal position of the object, in source order, as the object + // appears in the document's all collection + // i.e. document.all[n.sourceIndex] == n + DOM::Document doc = node.ownerDocument(); + if (doc.isHTMLDocument()) { + DOM::HTMLCollection all = static_cast<DOM::HTMLDocument>(doc).all(); + unsigned long i = 0; + DOM::Node n = all.firstItem(); + for ( ; !n.isNull() && n != node; n = all.nextItem() ) + ++i; + Q_ASSERT( !n.isNull() ); // node not in document.all !? + return Number(i); + } + } + default: + // no DOM standard, found in IE only + + // Make sure our layout is up to date before we allow a query on these attributes. + DOM::DocumentImpl* docimpl = node.handle()->getDocument(); + if (docimpl) { + docimpl->updateLayout(); + } + + tdehtml::RenderObject *rend = node.handle()->renderer(); + + //In quirks mode, may need to forward if to body. + rend = handleBodyRootQuirk(node, rend, token); + + switch (token) { + case OffsetLeft: + return rend ? static_cast<Value>( Number( rend->offsetLeft() ) ) : Number(0); + case OffsetTop: + return rend ? static_cast<Value>( Number( rend->offsetTop() ) ) : Number(0); + case OffsetWidth: + return rend ? static_cast<Value>( Number( rend->offsetWidth() ) ) : Number(0); + case OffsetHeight: + return rend ? static_cast<Value>( Number( rend->offsetHeight() ) ) : Number(0); + case OffsetParent: + { + tdehtml::RenderObject* par = rend ? rend->offsetParent() : 0; + return getDOMNode( exec, par ? par->element() : 0 ); + } + case ClientWidth: + return rend ? static_cast<Value>( Number( rend->clientWidth() ) ) : Number(0); + case ClientHeight: + return rend ? static_cast<Value>( Number( rend->clientHeight() ) ) : Number(0); + case ScrollWidth: + return rend ? static_cast<Value>( Number(rend->scrollWidth()) ) : Number(0); + case ScrollHeight: + return rend ? static_cast<Value>( Number(rend->scrollHeight()) ) : Number(0); + case ScrollLeft: + if (rend && rend->layer()) { + if (rend->isRoot() && !rend->style()->hidesOverflow()) + return Number( node.ownerDocument().view() ? node.ownerDocument().view()->contentsX() : 0); + return Number( rend->layer()->scrollXOffset() ); + } + return Number( 0 ); + case ScrollTop: + if (rend && rend->layer()) { + if (rend->isRoot() && !rend->style()->hidesOverflow()) + return Number( node.ownerDocument().view() ? node.ownerDocument().view()->contentsY() : 0); + return Number( rend->layer()->scrollYOffset() ); + } + return Number( 0 ); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMNode::getValueProperty : " << token << endl; + break; + } + } + return Undefined(); +} + + +void DOMNode::tryPut(ExecState *exec, const Identifier& propertyName, const Value& value, int attr) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMNode::tryPut " << propertyName.qstring() << endl; +#endif + DOMObjectLookupPut<DOMNode,DOMObject>(exec, propertyName, value, attr, + &DOMNodeTable, this ); +} + +void DOMNode::putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/) +{ + switch (token) { + case NodeValue: + node.setNodeValue(value.toString(exec).string()); + break; + case Prefix: + node.setPrefix(value.toString(exec).string()); + break; + case TextContent: + node.setTextContent(value.toString(exec).string()); + break; + case OnAbort: + setListener(exec,DOM::EventImpl::ABORT_EVENT,value); + break; + case OnBlur: + setListener(exec,DOM::EventImpl::BLUR_EVENT,value); + break; + case OnChange: + setListener(exec,DOM::EventImpl::CHANGE_EVENT,value); + break; + case OnClick: + setListener(exec,DOM::EventImpl::KHTML_ECMA_CLICK_EVENT,value); + break; + case OnDblClick: + setListener(exec,DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT,value); + break; + case OnDragDrop: + setListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT,value); + break; + case OnError: + setListener(exec,DOM::EventImpl::ERROR_EVENT,value); + break; + case OnFocus: + setListener(exec,DOM::EventImpl::FOCUS_EVENT,value); + break; + case OnKeyDown: + setListener(exec,DOM::EventImpl::KEYDOWN_EVENT,value); + break; + case OnKeyPress: + setListener(exec,DOM::EventImpl::KEYPRESS_EVENT,value); + break; + case OnKeyUp: + setListener(exec,DOM::EventImpl::KEYUP_EVENT,value); + break; + case OnLoad: + setListener(exec,DOM::EventImpl::LOAD_EVENT,value); + break; + case OnMouseDown: + setListener(exec,DOM::EventImpl::MOUSEDOWN_EVENT,value); + break; + case OnMouseMove: + setListener(exec,DOM::EventImpl::MOUSEMOVE_EVENT,value); + break; + case OnMouseOut: + setListener(exec,DOM::EventImpl::MOUSEOUT_EVENT,value); + break; + case OnMouseOver: + setListener(exec,DOM::EventImpl::MOUSEOVER_EVENT,value); + break; + case OnMouseUp: + setListener(exec,DOM::EventImpl::MOUSEUP_EVENT,value); + break; + case OnMove: + setListener(exec,DOM::EventImpl::KHTML_MOVE_EVENT,value); + break; + case OnReset: + setListener(exec,DOM::EventImpl::RESET_EVENT,value); + break; + case OnResize: + setListener(exec,DOM::EventImpl::RESIZE_EVENT,value); + break; + case OnSelect: + setListener(exec,DOM::EventImpl::SELECT_EVENT,value); + break; + case OnSubmit: + setListener(exec,DOM::EventImpl::SUBMIT_EVENT,value); + break; + case OnUnload: + setListener(exec,DOM::EventImpl::UNLOAD_EVENT,value); + break; + default: + // Make sure our layout is up to date + DOM::DocumentImpl* docimpl = node.handle()->getDocument(); + if (docimpl) + docimpl->updateLayout(); + + tdehtml::RenderObject *rend = node.handle() ? node.handle()->renderer() : 0L; + + //In quirks mode, may need to forward. + rend = handleBodyRootQuirk(node, rend, token); + + switch (token) { + case ScrollLeft: + if (rend && rend->layer()) { + if (rend->style()->hidesOverflow()) + rend->layer()->scrollToXOffset(value.toInt32(exec)); + else if (rend->isRoot()) { + TQScrollView* sview = node.ownerDocument().view(); + if (sview) + sview->setContentsPos(value.toInt32(exec), sview->contentsY()); + } + } + break; + case ScrollTop: + if (rend && rend->layer()) { + if (rend->style()->hidesOverflow()) + rend->layer()->scrollToYOffset(value.toInt32(exec)); + else if (rend->isRoot()) { + TQScrollView* sview = node.ownerDocument().view(); + if (sview) + sview->setContentsPos(sview->contentsX(), value.toInt32(exec)); + } + } + break; + default: + kdDebug(6070) << "WARNING: DOMNode::putValueProperty unhandled token " << token << endl; + } + } +} + +Value DOMNode::toPrimitive(ExecState *exec, Type /*preferred*/) const +{ + if (node.isNull()) + return Null(); + + return String(toString(exec)); +} + +UString DOMNode::toString(ExecState *) const +{ + if (node.isNull()) + return "null"; + UString s; + + DOM::Element e = node; + if ( !e.isNull() ) { + s = static_cast<UString>(e.nodeName().string()); + } else + s = className(); // fallback + + return "[object " + s + "]"; +} + +void DOMNode::setListener(ExecState *exec, int eventId, const Value& func) const +{ + node.handle()->setHTMLEventListener(eventId,Window::retrieveActive(exec)->getJSEventListener(func,true)); +} + +Value DOMNode::getListener(int eventId) const +{ + DOM::EventListener *listener = node.handle()->getHTMLEventListener(eventId); + JSEventListener *jsListener = static_cast<JSEventListener*>(listener); + if ( jsListener && jsListener->listenerObjImp() ) + return jsListener->listenerObj(); + else + return Null(); +} + +void DOMNode::pushEventHandlerScope(ExecState *, ScopeChain &) const +{ +} + +Value DOMNodeProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( DOMNode, thisObj ); + DOM::Node node = static_cast<DOMNode *>( thisObj.imp() )->toNode(); + switch (id) { + case DOMNode::HasAttributes: + return Boolean(node.hasAttributes()); + case DOMNode::HasChildNodes: + return Boolean(node.hasChildNodes()); + case DOMNode::CloneNode: + return getDOMNode(exec,node.cloneNode(args[0].toBoolean(exec))); + case DOMNode::Normalize: + node.normalize(); + return Undefined(); + case DOMNode::IsSupported: + return Boolean(node.isSupported(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMNode::AddEventListener: { + JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]); + node.addEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec)); + return Undefined(); + } + case DOMNode::RemoveEventListener: { + JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]); + node.removeEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec)); + return Undefined(); + } + case DOMNode::DispatchEvent: + return Boolean(node.dispatchEvent(toEvent(args[0]))); + case DOMNode::AppendChild: + return getDOMNode(exec,node.appendChild(toNode(args[0]))); + case DOMNode::RemoveChild: + return getDOMNode(exec,node.removeChild(toNode(args[0]))); + case DOMNode::InsertBefore: + return getDOMNode(exec,node.insertBefore(toNode(args[0]), toNode(args[1]))); + case DOMNode::ReplaceChild: + return getDOMNode(exec,node.replaceChild(toNode(args[0]), toNode(args[1]))); + case DOMNode::Contains: + { + DOM::Node other = toNode(args[0]); + if (!other.isNull() && node.nodeType()==DOM::Node::ELEMENT_NODE) + { + DOM::NodeBaseImpl *impl = static_cast<DOM::NodeBaseImpl *>(node.handle()); + bool retval = other.handle()->isAncestor(impl); + return Boolean(retval); + } + return Undefined(); + } + case DOMNode::InsertAdjacentHTML: + { + // see http://www.faqts.com/knowledge_base/view.phtml/aid/5756 + // and http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/insertAdjacentHTML.asp + Range range = node.ownerDocument().createRange(); + + range.setStartBefore(node); + + DocumentFragment docFrag = range.createContextualFragment(args[1].toString(exec).string()); + + DOMString where = args[0].toString(exec).string(); + + if (where == "beforeBegin" || where == "BeforeBegin") + node.parentNode().insertBefore(docFrag, node); + else if (where == "afterBegin" || where == "AfterBegin") + node.insertBefore(docFrag, node.firstChild()); + else if (where == "beforeEnd" || where == "BeforeEnd") + return getDOMNode(exec, node.appendChild(docFrag)); + else if (where == "afterEnd" || where == "AfterEnd") + if (!node.nextSibling().isNull()) + node.parentNode().insertBefore(docFrag, node.nextSibling()); + else + node.parentNode().appendChild(docFrag); + + return Undefined(); + } + case DOMNode::Item: + return getDOMNode(exec, node.childNodes().item(static_cast<unsigned long>(args[0].toNumber(exec)))); + } + + return Undefined(); +} + +// ------------------------------------------------------------------------- + +/* +@begin DOMNodeListProtoTable 2 + item DOMNodeList::Item DontDelete|Function 1 +# IE extension (IE treats DOMNodeList like an HTMLCollection) + namedItem DOMNodeList::NamedItem DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMNodeListProto) +IMPLEMENT_PROTOFUNC_DOM(DOMNodeListProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMNodeList", DOMNodeListProto, DOMNodeListProtoFunc) + + +const ClassInfo DOMNodeList::info = { "NodeList", 0, 0, 0 }; + +DOMNodeList::DOMNodeList(ExecState *exec, const DOM::NodeList& l) + : DOMObject(DOMNodeListProto::self(exec)), list(l) { } + +DOMNodeList::~DOMNodeList() +{ + ScriptInterpreter::forgetDOMObject(list.handle()); +} + +// We have to implement hasProperty since we don't use a hashtable for 'length' +// ## this breaks "for (..in..)" though. +bool DOMNodeList::hasProperty(ExecState *exec, const Identifier &p) const +{ + if (p == lengthPropertyName) + return true; + + if (ObjectImp::hasProperty(exec, p)) + return true; + + bool ok; + unsigned long pos = p.toULong(&ok); + if (ok && pos < list.length()) + return true; + + // ## missing: accept p if item id... + return false; +} + +Value DOMNodeList::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMNodeList::tryGet " << p.ascii() << endl; +#endif + if (p == lengthPropertyName) + return Number(list.length()); + + // Look in the prototype (for functions) before assuming it's an item's name + Object proto = Object::dynamicCast(prototype()); + if (proto.isValid() && proto.hasProperty(exec,p)) + return proto.get(exec,p); + + Value result; + + // array index ? + bool ok; + long unsigned int idx = p.toULong(&ok); + if (ok) + result = getDOMNode(exec,list.item(idx)); + else { + // Find by ID + DOM::HTMLElement e; + unsigned long l = list.length(); + bool found = false; + + for ( unsigned long i = 0; i < l; i++ ) + if ( ( e = list.item( i ) ).id() == p.string() ) { + result = getDOMNode(exec, list.item( i ) ); + found = true; + break; + } + + if ( !found ) + result = ObjectImp::get(exec, p); + } + + return result; +} + +ReferenceList DOMNodeList::propList(ExecState *exec, bool recursive) +{ + ReferenceList properties = ObjectImp::propList(exec,recursive); + + for (unsigned i = 0; i < list.length(); ++i) { + if (!ObjectImp::hasProperty(exec,Identifier::from(i))) { + properties.append(Reference(this, i)); + } + } + + if (!ObjectImp::hasProperty(exec, lengthPropertyName)) + properties.append(Reference(this, lengthPropertyName)); + + return properties; +} + +// Need to support both get and call, so that list[0] and list(0) work. +Value DOMNodeList::call(ExecState *exec, Object &thisObj, const List &args) +{ + // This code duplication is necessary, DOMNodeList 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 DOMNodeList"); + exec->setException(err); + } + return val; +} + +Value DOMNodeList::tryCall(ExecState *exec, Object &, const List &args) +{ + // Do not use thisObj here. See HTMLCollection. + UString s = args[0].toString(exec); + + // index-based lookup? + bool ok; + unsigned int u = s.toULong(&ok); + if (ok) + return getDOMNode(exec,list.item(u)); + + // try lookup by name + // ### NodeList::namedItem() would be cool to have + // ### do we need to support the same two arg overload as in HTMLCollection? + Value result = tryGet(exec, Identifier(s)); + + if (result.isValid()) + return result; + + return Undefined(); +} + +// Not a prototype class currently, but should probably be converted to one +Value DOMNodeListProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMNodeList, thisObj ); + DOM::NodeList list = static_cast<DOMNodeList *>(thisObj.imp())->nodeList(); + switch (id) { + case KJS::DOMNodeList::Item: + return getDOMNode(exec, list.item(args[0].toInt32(exec))); + case KJS::DOMNodeList::NamedItem: + { + // Not a real namedItem implementation like the one HTMLCollection has. + // This is only an IE extension... + DOM::HTMLElement e; + unsigned long len = list.length(); + DOM::DOMString s = args[0].toString(exec).string(); + + for ( unsigned long i = 0; i < len; i++ ) + { + e = list.item( i ); + if ( !e.isNull() && ( + e.id() == s || static_cast<ElementImpl *>(e.handle())->getAttribute(ATTR_NAME) == s ) + ) + { + return getDOMNode(exec, e ); + } + } + return Null(); // see HTMLCollection::NamedItem implementation + } + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- + +//### FIXME: link to the node prototype. +const ClassInfo DOMAttr::info = { "Attr", &DOMNode::info, &DOMAttrTable, 0 }; + +/* Source for DOMAttrTable. +@begin DOMAttrTable 5 + name DOMAttr::Name DontDelete|ReadOnly + specified DOMAttr::Specified DontDelete|ReadOnly + value DOMAttr::ValueProperty DontDelete + ownerElement DOMAttr::OwnerElement DontDelete|ReadOnly +@end +*/ +Value DOMAttr::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMAttr::tryGet " << propertyName.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMAttr,DOMNode>(exec, propertyName, + &DOMAttrTable, this ); +} + +Value DOMAttr::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Name: + return String(static_cast<DOM::Attr>(node).name()); + case Specified: + return Boolean(static_cast<DOM::Attr>(node).specified()); + case ValueProperty: + return String(static_cast<DOM::Attr>(node).value()); + case OwnerElement: // DOM2 + return getDOMNode(exec,static_cast<DOM::Attr>(node).ownerElement()); + } + return Value(); // not reached +} + +void DOMAttr::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMAttr::tryPut " << propertyName.qstring() << endl; +#endif + DOMObjectLookupPut<DOMAttr,DOMNode>(exec, propertyName, value, attr, + &DOMAttrTable, this ); +} + +void DOMAttr::putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/) +{ + switch (token) { + case ValueProperty: + static_cast<DOM::Attr>(node).setValue(value.toString(exec).string()); + return; + default: + kdDebug(6070) << "WARNING: DOMAttr::putValueProperty unhandled token " << token << endl; + } +} + +// ------------------------------------------------------------------------- + +/* Source for DOMDocumentProtoTable. +@begin DOMDocumentProtoTable 23 + createElement DOMDocument::CreateElement DontDelete|Function 1 + createDocumentFragment DOMDocument::CreateDocumentFragment DontDelete|Function 1 + createTextNode DOMDocument::CreateTextNode DontDelete|Function 1 + createComment DOMDocument::CreateComment DontDelete|Function 1 + createCDATASection DOMDocument::CreateCDATASection DontDelete|Function 1 + createProcessingInstruction DOMDocument::CreateProcessingInstruction DontDelete|Function 1 + createAttribute DOMDocument::CreateAttribute DontDelete|Function 1 + createEntityReference DOMDocument::CreateEntityReference DontDelete|Function 1 + getElementsByTagName DOMDocument::GetElementsByTagName DontDelete|Function 1 + importNode DOMDocument::ImportNode DontDelete|Function 2 + createElementNS DOMDocument::CreateElementNS DontDelete|Function 2 + createAttributeNS DOMDocument::CreateAttributeNS DontDelete|Function 2 + getElementsByTagNameNS DOMDocument::GetElementsByTagNameNS DontDelete|Function 2 + getElementById DOMDocument::GetElementById DontDelete|Function 1 + createRange DOMDocument::CreateRange DontDelete|Function 0 + createNodeIterator DOMDocument::CreateNodeIterator DontDelete|Function 3 + createTreeWalker DOMDocument::CreateTreeWalker DontDelete|Function 4 + createEvent DOMDocument::CreateEvent DontDelete|Function 1 + getOverrideStyle DOMDocument::GetOverrideStyle DontDelete|Function 2 + abort DOMDocument::Abort DontDelete|Function 0 + load DOMDocument::Load DontDelete|Function 1 + loadXML DOMDocument::LoadXML DontDelete|Function 2 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMDocumentProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMDocument", DOMDocumentProto, DOMDocumentProtoFunc) +IMPLEMENT_PSEUDO_CONSTRUCTOR(DocumentPseudoCtor, "Document", DOMDocumentProto) + +const ClassInfo DOMDocument::info = { "Document", &DOMNode::info, &DOMDocumentTable, 0 }; + +/* Source for DOMDocumentTable. +@begin DOMDocumentTable 4 + doctype DOMDocument::DocType DontDelete|ReadOnly + implementation DOMDocument::Implementation DontDelete|ReadOnly + characterSet DOMDocument::CharacterSet DontDelete|ReadOnly + documentElement DOMDocument::DocumentElement DontDelete|ReadOnly + styleSheets DOMDocument::StyleSheets DontDelete|ReadOnly + preferredStylesheetSet DOMDocument::PreferredStylesheetSet DontDelete|ReadOnly + selectedStylesheetSet DOMDocument::SelectedStylesheetSet DontDelete + readyState DOMDocument::ReadyState DontDelete|ReadOnly + defaultView DOMDocument::DefaultView DontDelete|ReadOnly + async DOMDocument::Async DontDelete +@end +*/ + +DOMDocument::DOMDocument(ExecState *exec, const DOM::Document& d) + : DOMNode(DOMDocumentProto::self(exec), d) { } + +DOMDocument::DOMDocument(const Object& proto, const DOM::Document& d) + : DOMNode(proto, d) { } + +DOMDocument::~DOMDocument() +{ + ScriptInterpreter::forgetDOMObject(node.handle()); +} + +Value DOMDocument::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMDocument::tryGet " << propertyName.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMDocument, DOMNode>( + exec, propertyName, &DOMDocumentTable, this); +} + +Value DOMDocument::getValueProperty(ExecState *exec, int token) const +{ + DOM::Document doc = static_cast<DOM::Document>(node); + + switch(token) { + case DocType: + return getDOMNode(exec,doc.doctype()); + case Implementation: + return getDOMDOMImplementation(exec,doc.implementation()); + case DocumentElement: + return getDOMNode(exec,doc.documentElement()); + case CharacterSet: { + DOM::DocumentImpl* docImpl = static_cast<DOM::DocumentImpl*>(doc.handle()); + if (docImpl->part()) + return String(docImpl->part()->encoding()); + else + return Undefined(); + } + case StyleSheets: + //kdDebug() << "DOMDocument::StyleSheets, returning " << doc.styleSheets().length() << " stylesheets" << endl; + return getDOMStyleSheetList(exec, doc.styleSheets(), doc); + case DOMDocument::DefaultView: // DOM2 + { + KHTMLView *view = node.handle()->getDocument()->view(); + if (view) + return Window::retrieve(view->part()); + return getDOMAbstractView(exec, doc.defaultView()); + } + case PreferredStylesheetSet: + return String(doc.preferredStylesheetSet()); + case SelectedStylesheetSet: + return String(doc.selectedStylesheetSet()); + case ReadyState: + { + DOM::DocumentImpl* docimpl = node.handle()->getDocument(); + if ( docimpl && docimpl->view() ) + { + KHTMLPart* part = docimpl->view()->part(); + if ( part ) { + if (part->d->m_bComplete) return String("complete"); + if (docimpl->parsing()) return String("loading"); + return String("loaded"); + // What does the interactive value mean ? + // Missing support for "uninitialized" + } + } + return Undefined(); + } + case Async: + return Boolean(doc.async()); + default: + kdDebug(6070) << "WARNING: DOMDocument::getValueProperty unhandled token " << token << endl; + return Value(); + } +} + +void DOMDocument::tryPut(ExecState *exec, const Identifier& propertyName, const Value& value, int attr) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMDocument::tryPut " << propertyName.qstring() << endl; +#endif + DOMObjectLookupPut<DOMDocument,DOMNode>(exec, propertyName, value, attr, &DOMDocumentTable, this ); +} + +void DOMDocument::putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/) +{ + DOM::Document doc = static_cast<DOM::Document>(node); + switch (token) { + case SelectedStylesheetSet: { + doc.setSelectedStylesheetSet(value.toString(exec).string()); + break; + } + case Async: { + doc.setAsync(value.toBoolean(exec)); + break; + } + } +} + +Value DOMDocumentProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMDocument, thisObj ); + DOM::Node node = static_cast<DOMNode *>( thisObj.imp() )->toNode(); + DOM::Document doc = static_cast<DOM::Document>(node); + String str = args[0].toString(exec); + DOM::DOMString s = str.value().string(); + + switch(id) { + case DOMDocument::CreateElement: + return getDOMNode(exec,doc.createElement(s)); + case DOMDocument::CreateDocumentFragment: + return getDOMNode(exec,doc.createDocumentFragment()); + case DOMDocument::CreateTextNode: + return getDOMNode(exec,doc.createTextNode(s)); + case DOMDocument::CreateComment: + return getDOMNode(exec,doc.createComment(s)); + case DOMDocument::CreateCDATASection: + return getDOMNode(exec,doc.createCDATASection(s)); /* TODO: okay ? */ + case DOMDocument::CreateProcessingInstruction: + return getDOMNode(exec,doc.createProcessingInstruction(args[0].toString(exec).string(), + args[1].toString(exec).string())); + case DOMDocument::CreateAttribute: + return getDOMNode(exec,doc.createAttribute(s)); + case DOMDocument::CreateEntityReference: + return getDOMNode(exec,doc.createEntityReference(args[0].toString(exec).string())); + case DOMDocument::GetElementsByTagName: + return getDOMNodeList(exec,doc.getElementsByTagName(s)); + case DOMDocument::ImportNode: // DOM2 + return getDOMNode(exec,doc.importNode(toNode(args[0]), args[1].toBoolean(exec))); + case DOMDocument::CreateElementNS: // DOM2 + return getDOMNode(exec,doc.createElementNS(args[0].toString(exec).string(), args[1].toString(exec).string())); + case DOMDocument::CreateAttributeNS: // DOM2 + return getDOMNode(exec,doc.createAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMDocument::GetElementsByTagNameNS: // DOM2 + return getDOMNodeList(exec,doc.getElementsByTagNameNS(args[0].toString(exec).string(), + args[1].toString(exec).string())); + case DOMDocument::GetElementById: +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMDocument::GetElementById looking for " << args[0].toString(exec).string() << endl; +#endif + return getDOMNode(exec,doc.getElementById(args[0].toString(exec).string())); + case DOMDocument::CreateRange: + return getDOMRange(exec,doc.createRange()); + case DOMDocument::CreateNodeIterator: + if (args[2].isA(NullType)) { + DOM::NodeFilter filter; + return getDOMNodeIterator(exec, + doc.createNodeIterator(toNode(args[0]), + (long unsigned int)(args[1].toNumber(exec)), + filter,args[3].toBoolean(exec))); + } + else { + Object obj = Object::dynamicCast(args[2]); + if (obj.isValid()) + { + DOM::CustomNodeFilter *customFilter = new JSNodeFilter(obj); + DOM::NodeFilter filter = DOM::NodeFilter::createCustom(customFilter); + return getDOMNodeIterator(exec, + doc.createNodeIterator( + toNode(args[0]),(long unsigned int)(args[1].toNumber(exec)), + filter,args[3].toBoolean(exec))); + }// else? + } + case DOMDocument::CreateTreeWalker: + return getDOMTreeWalker(exec,doc.createTreeWalker(toNode(args[0]),(long unsigned int)(args[1].toNumber(exec)), + toNodeFilter(args[2]),args[3].toBoolean(exec))); + case DOMDocument::CreateEvent: + return getDOMEvent(exec,doc.createEvent(s)); + case DOMDocument::GetOverrideStyle: { + DOM::Node arg0 = toNode(args[0]); + if (arg0.nodeType() != DOM::Node::ELEMENT_NODE) + return Undefined(); // throw exception? + else + return getDOMCSSStyleDeclaration(exec,doc.getOverrideStyle(static_cast<DOM::Element>(arg0),args[1].toString(exec).string())); + } + case DOMDocument::Abort: + doc.abort(); + break; + case DOMDocument::Load: { + Window* active = Window::retrieveActive(exec); + // Complete the URL using the "active part" (running interpreter). We do this for the security + // check and to make sure we load exactly the same url as we have verified to be safe + KHTMLPart *tdehtmlpart = ::tqqt_cast<KHTMLPart *>(active->part()); + if (tdehtmlpart) { + // Security: only allow documents to be loaded from the same host + TQString dstUrl = tdehtmlpart->htmlDocument().completeURL(s).string(); + KParts::ReadOnlyPart *part = static_cast<KJS::ScriptInterpreter*>(exec->interpreter())->part(); + if (part->url().host() == KURL(dstUrl).host()) { + kdDebug(6070) << "JavaScript: access granted for document.load() of " << dstUrl << endl; + doc.load(dstUrl); + } + else { + kdDebug(6070) << "JavaScript: access denied for document.load() of " << dstUrl << endl; + } + } + break; + } + case DOMDocument::LoadXML: + doc.loadXML(s); + break; + default: + break; + } + + return Undefined(); +} + +// ------------------------------------------------------------------------- + +/* Source for DOMElementProtoTable. +@begin DOMElementProtoTable 17 + getAttribute DOMElement::GetAttribute DontDelete|Function 1 + setAttribute DOMElement::SetAttribute DontDelete|Function 2 + removeAttribute DOMElement::RemoveAttribute DontDelete|Function 1 + getAttributeNode DOMElement::GetAttributeNode DontDelete|Function 1 + setAttributeNode DOMElement::SetAttributeNode DontDelete|Function 2 + removeAttributeNode DOMElement::RemoveAttributeNode DontDelete|Function 1 + getElementsByTagName DOMElement::GetElementsByTagName DontDelete|Function 1 + hasAttribute DOMElement::HasAttribute DontDelete|Function 1 + getAttributeNS DOMElement::GetAttributeNS DontDelete|Function 2 + setAttributeNS DOMElement::SetAttributeNS DontDelete|Function 3 + removeAttributeNS DOMElement::RemoveAttributeNS DontDelete|Function 2 + getAttributeNodeNS DOMElement::GetAttributeNodeNS DontDelete|Function 2 + setAttributeNodeNS DOMElement::SetAttributeNodeNS DontDelete|Function 1 + getElementsByTagNameNS DOMElement::GetElementsByTagNameNS DontDelete|Function 2 + hasAttributeNS DOMElement::HasAttributeNS DontDelete|Function 2 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMElementProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMElement", DOMElementProto, DOMElementProtoFunc) + +IMPLEMENT_PSEUDO_CONSTRUCTOR(ElementPseudoCtor, "Element", DOMElementProto) + +const ClassInfo DOMElement::info = { "Element", &DOMNode::info, &DOMElementTable, 0 }; +/* Source for DOMElementTable. +@begin DOMElementTable 3 + tagName DOMElement::TagName DontDelete|ReadOnly + style DOMElement::Style DontDelete|ReadOnly +@end +*/ +DOMElement::DOMElement(ExecState *exec, const DOM::Element& e) + : DOMNode(DOMElementProto::self(exec), e) { } + +DOMElement::DOMElement(const Object& proto, const DOM::Element& e) + : DOMNode(proto, e) { } + +Value DOMElement::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMElement::tryGet " << propertyName.qstring() << endl; +#endif + DOM::Element element = static_cast<DOM::Element>(node); + + const HashEntry* entry = Lookup::findEntry(&DOMElementTable, propertyName); + if (entry) + { + switch( entry->value ) { + case TagName: + return String(element.tagName()); + case Style: + return getDOMCSSStyleDeclaration(exec,element.style()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMElement::tryGet : " << entry->value << endl; + break; + } + } + // We have to check in DOMNode before giving access to attributes, otherwise + // onload="..." would make onload return the string (attribute value) instead of + // the listener object (function). + if (DOMNode::hasProperty(exec, propertyName)) + return DOMNode::tryGet(exec, propertyName); + + DOM::DOMString attr = element.getAttribute( propertyName.string() ); + // Give access to attributes + if ( !attr.isNull() ) + return String( attr ); + + return Undefined(); +} + +Value DOMElementProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMNode, thisObj ); // node should be enough here, given the cast + DOM::Node node = static_cast<DOMNode *>( thisObj.imp() )->toNode(); + DOM::Element element = static_cast<DOM::Element>(node); + + switch(id) { + case DOMElement::GetAttribute: + /** In theory, we should not return null here, as per DOM. In practice, that + breaks websites + */ + return getString(element.getAttribute(args[0].toString(exec).string())); + case DOMElement::SetAttribute: + element.setAttribute(args[0].toString(exec).string(),args[1].toString(exec).string()); + return Undefined(); + case DOMElement::RemoveAttribute: + element.removeAttribute(args[0].toString(exec).string()); + return Undefined(); + case DOMElement::GetAttributeNode: + return getDOMNode(exec,element.getAttributeNode(args[0].toString(exec).string())); + case DOMElement::SetAttributeNode: + return getDOMNode(exec,element.setAttributeNode(KJS::toNode(args[0]))); + case DOMElement::RemoveAttributeNode: + return getDOMNode(exec,element.removeAttributeNode(KJS::toNode(args[0]))); + case DOMElement::GetElementsByTagName: + return getDOMNodeList(exec,element.getElementsByTagName(args[0].toString(exec).string())); + case DOMElement::HasAttribute: // DOM2 + return Boolean(element.hasAttribute(args[0].toString(exec).string())); + case DOMElement::GetAttributeNS: // DOM2 + return String(element.getAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMElement::SetAttributeNS: // DOM2 + element.setAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string(),args[2].toString(exec).string()); + return Undefined(); + case DOMElement::RemoveAttributeNS: // DOM2 + element.removeAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string()); + return Undefined(); + case DOMElement::GetAttributeNodeNS: // DOM2 + return getDOMNode(exec,element.getAttributeNodeNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMElement::SetAttributeNodeNS: // DOM2 + return getDOMNode(exec,element.setAttributeNodeNS(KJS::toNode(args[0]))); + case DOMElement::GetElementsByTagNameNS: // DOM2 + return getDOMNodeList(exec,element.getElementsByTagNameNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMElement::HasAttributeNS: // DOM2 + return Boolean(element.hasAttributeNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- + +/* Source for DOMDOMImplementationProtoTable. +@begin DOMDOMImplementationProtoTable 5 + hasFeature DOMDOMImplementation::HasFeature DontDelete|Function 2 + createCSSStyleSheet DOMDOMImplementation::CreateCSSStyleSheet DontDelete|Function 2 +# DOM2 + createDocumentType DOMDOMImplementation::CreateDocumentType DontDelete|Function 3 + createDocument DOMDOMImplementation::CreateDocument DontDelete|Function 3 + createHTMLDocument DOMDOMImplementation::CreateHTMLDocument DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMDOMImplementationProto) +IMPLEMENT_PROTOFUNC_DOM(DOMDOMImplementationProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMImplementation", DOMDOMImplementationProto, DOMDOMImplementationProtoFunc) + +const ClassInfo DOMDOMImplementation::info = { "DOMImplementation", 0, 0, 0 }; + +DOMDOMImplementation::DOMDOMImplementation(ExecState *exec, const DOM::DOMImplementation& i) + : DOMObject(DOMDOMImplementationProto::self(exec)), implementation(i) { } + +DOMDOMImplementation::~DOMDOMImplementation() +{ + ScriptInterpreter::forgetDOMObject(implementation.handle()); +} + +Value DOMDOMImplementationProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMDOMImplementation, thisObj ); + DOM::DOMImplementation implementation = static_cast<DOMDOMImplementation *>( thisObj.imp() )->toImplementation(); + + switch(id) { + case DOMDOMImplementation::HasFeature: + return Boolean(implementation.hasFeature(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMDOMImplementation::CreateDocumentType: // DOM2 + return getDOMNode(exec,implementation.createDocumentType(args[0].toString(exec).string(),args[1].toString(exec).string(),args[2].toString(exec).string())); + case DOMDOMImplementation::CreateDocument: { // DOM2 + // Initially set the URL to document of the creator... this is so that it resides in the same + // host/domain for security checks. The URL will be updated if Document.load() is called. + KHTMLPart *part = ::tqqt_cast<KHTMLPart*>(static_cast<KJS::ScriptInterpreter*>(exec->interpreter())->part()); + if (part) { + Document doc = implementation.createDocument(args[0].toString(exec).string(),args[1].toString(exec).string(),toNode(args[2])); + KURL url = static_cast<DocumentImpl*>(part->document().handle())->URL(); + static_cast<DocumentImpl*>(doc.handle())->setURL(url.url()); + return getDOMNode(exec,doc); + } + break; + } + case DOMDOMImplementation::CreateCSSStyleSheet: // DOM2 + return getDOMStyleSheet(exec,implementation.createCSSStyleSheet(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMDOMImplementation::CreateHTMLDocument: // DOM2-HTML + return getDOMNode(exec, implementation.createHTMLDocument(args[0].toString(exec).string())); + default: + break; + } + return Undefined(); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMDocumentType::info = { "DocumentType", &DOMNode::info, &DOMDocumentTypeTable, 0 }; + +/* Source for DOMDocumentTypeTable. +@begin DOMDocumentTypeTable 6 + name DOMDocumentType::Name DontDelete|ReadOnly + entities DOMDocumentType::Entities DontDelete|ReadOnly + notations DOMDocumentType::Notations DontDelete|ReadOnly +# DOM2 + publicId DOMDocumentType::PublicId DontDelete|ReadOnly + systemId DOMDocumentType::SystemId DontDelete|ReadOnly + internalSubset DOMDocumentType::InternalSubset DontDelete|ReadOnly +@end +*/ +DOMDocumentType::DOMDocumentType(ExecState *exec, const DOM::DocumentType& dt) + : DOMNode( /*### no proto yet*/exec, dt ) { } + +Value DOMDocumentType::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMDocumentType::tryGet " << propertyName.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMDocumentType, DOMNode>(exec, propertyName, &DOMDocumentTypeTable, this); +} + +Value DOMDocumentType::getValueProperty(ExecState *exec, int token) const +{ + DOM::DocumentType type = static_cast<DOM::DocumentType>(node); + switch (token) { + case Name: + return String(type.name()); + case Entities: + return getDOMNamedNodeMap(exec,type.entities()); + case Notations: + return getDOMNamedNodeMap(exec,type.notations()); + case PublicId: // DOM2 + return String(type.publicId()); + case SystemId: // DOM2 + return String(type.systemId()); + case InternalSubset: // DOM2 + return getString(type.internalSubset()); // can be null, see domts/level2/core/internalSubset01.html + default: + kdDebug(6070) << "WARNING: DOMDocumentType::getValueProperty unhandled token " << token << endl; + return Value(); + } +} + +// ------------------------------------------------------------------------- + +/* Source for DOMNamedNodeMapProtoTable. +@begin DOMNamedNodeMapProtoTable 7 + getNamedItem DOMNamedNodeMap::GetNamedItem DontDelete|Function 1 + setNamedItem DOMNamedNodeMap::SetNamedItem DontDelete|Function 1 + removeNamedItem DOMNamedNodeMap::RemoveNamedItem DontDelete|Function 1 + item DOMNamedNodeMap::Item DontDelete|Function 1 +# DOM2 + getNamedItemNS DOMNamedNodeMap::GetNamedItemNS DontDelete|Function 2 + setNamedItemNS DOMNamedNodeMap::SetNamedItemNS DontDelete|Function 1 + removeNamedItemNS DOMNamedNodeMap::RemoveNamedItemNS DontDelete|Function 2 +@end +@begin DOMNamedNodeMapTable 7 + length DOMNamedNodeMap::Length DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMNamedNodeMapProto) +IMPLEMENT_PROTOFUNC_DOM(DOMNamedNodeMapProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("NamedNodeMap", DOMNamedNodeMapProto, DOMNamedNodeMapProtoFunc) + +const ClassInfo DOMNamedNodeMap::info = { "NamedNodeMap", 0, &DOMNamedNodeMapTable, 0 }; + +DOMNamedNodeMap::DOMNamedNodeMap(ExecState *exec, const DOM::NamedNodeMap& m) + : DOMObject(DOMNamedNodeMapProto::self(exec)), map(m) { } + +DOMNamedNodeMap::~DOMNamedNodeMap() +{ + ScriptInterpreter::forgetDOMObject(map.handle()); +} + +bool DOMNamedNodeMap::hasProperty(ExecState *exec, const Identifier &p) const +{ + // ## missing? array index + return DOMObject::hasProperty(exec, p); +} + +Value DOMNamedNodeMap::tryGet(ExecState* exec, const Identifier &p) const +{ + if (p == lengthPropertyName) + return Number(map.length()); + + // array index ? + bool ok; + long unsigned int idx = p.toULong(&ok); + if (ok) + return getDOMNode(exec,map.item(idx)); + + // Anything else (including functions, defined in the prototype) + return DOMObject::tryGet(exec, p); +} + +Value DOMNamedNodeMapProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMNamedNodeMap, thisObj ); + DOM::NamedNodeMap map = static_cast<DOMNamedNodeMap *>(thisObj.imp())->toMap(); + + switch(id) { + case DOMNamedNodeMap::GetNamedItem: + return getDOMNode(exec, map.getNamedItem(args[0].toString(exec).string())); + case DOMNamedNodeMap::SetNamedItem: + return getDOMNode(exec, map.setNamedItem(KJS::toNode(args[0]))); + case DOMNamedNodeMap::RemoveNamedItem: + return getDOMNode(exec, map.removeNamedItem(args[0].toString(exec).string())); + case DOMNamedNodeMap::Item: + return getDOMNode(exec, map.item(args[0].toInt32(exec))); + case DOMNamedNodeMap::GetNamedItemNS: // DOM2 + return getDOMNode(exec, map.getNamedItemNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + case DOMNamedNodeMap::SetNamedItemNS: // DOM2 + return getDOMNode(exec, map.setNamedItemNS(toNode(args[0]))); + case DOMNamedNodeMap::RemoveNamedItemNS: // DOM2 + return getDOMNode(exec, map.removeNamedItemNS(args[0].toString(exec).string(),args[1].toString(exec).string())); + default: + break; + } + + return Undefined(); +} + +// ------------------------------------------------------------------------- +//### FIXME: proto +const ClassInfo DOMProcessingInstruction::info = { "ProcessingInstruction", &DOMNode::info, &DOMProcessingInstructionTable, 0 }; + +/* Source for DOMProcessingInstructionTable. +@begin DOMProcessingInstructionTable 3 + target DOMProcessingInstruction::Target DontDelete|ReadOnly + data DOMProcessingInstruction::Data DontDelete + sheet DOMProcessingInstruction::Sheet DontDelete|ReadOnly +@end +*/ +Value DOMProcessingInstruction::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + return DOMObjectLookupGetValue<DOMProcessingInstruction, DOMNode>(exec, propertyName, &DOMProcessingInstructionTable, this); +} + +Value DOMProcessingInstruction::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Target: + return String(static_cast<DOM::ProcessingInstruction>(node).target()); + case Data: + return String(static_cast<DOM::ProcessingInstruction>(node).data()); + case Sheet: + return getDOMStyleSheet(exec,static_cast<DOM::ProcessingInstruction>(node).sheet()); + default: + kdDebug(6070) << "WARNING: DOMProcessingInstruction::getValueProperty unhandled token " << token << endl; + return Value(); + } +} + +void DOMProcessingInstruction::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + // Not worth using the hashtable for this one ;) + if (propertyName == "data") + static_cast<DOM::ProcessingInstruction>(node).setData(value.toString(exec).string()); + else + DOMNode::tryPut(exec, propertyName,value,attr); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMNotation::info = { "Notation", &DOMNode::info, &DOMNotationTable, 0 }; + +/* Source for DOMNotationTable. +@begin DOMNotationTable 2 + publicId DOMNotation::PublicId DontDelete|ReadOnly + systemId DOMNotation::SystemId DontDelete|ReadOnly +@end +*/ +Value DOMNotation::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + return DOMObjectLookupGetValue<DOMNotation, DOMNode>(exec, propertyName, &DOMNotationTable, this); +} + +Value DOMNotation::getValueProperty(ExecState *, int token) const +{ + switch (token) { + case PublicId: + return String(static_cast<DOM::Notation>(node).publicId()); + case SystemId: + return String(static_cast<DOM::Notation>(node).systemId()); + default: + kdDebug(6070) << "WARNING: DOMNotation::getValueProperty unhandled token " << token << endl; + return Value(); + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMEntity::info = { "Entity", &DOMNode::info, 0, 0 }; + +/* Source for DOMEntityTable. +@begin DOMEntityTable 2 + publicId DOMEntity::PublicId DontDelete|ReadOnly + systemId DOMEntity::SystemId DontDelete|ReadOnly + notationName DOMEntity::NotationName DontDelete|ReadOnly +@end +*/ +Value DOMEntity::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + return DOMObjectLookupGetValue<DOMEntity, DOMNode>(exec, propertyName, &DOMEntityTable, this); +} + +Value DOMEntity::getValueProperty(ExecState *, int token) const +{ + switch (token) { + case PublicId: + return String(static_cast<DOM::Entity>(node).publicId()); + case SystemId: + return String(static_cast<DOM::Entity>(node).systemId()); + case NotationName: + return String(static_cast<DOM::Entity>(node).notationName()); + default: + kdDebug(6070) << "WARNING: DOMEntity::getValueProperty unhandled token " << token << endl; + return Value(); + } +} + +// ------------------------------------------------------------------------- + +bool checkNodeSecurity(ExecState *exec, const DOM::Node& n) +{ + // Check to see if the currently executing interpreter is allowed to access the specified node + if (n.isNull()) + return true; + KHTMLView *view = n.handle()->getDocument()->view(); + Window* win = view && view->part() ? Window::retrieveWindow(view->part()) : 0L; + if ( !win || !win->isSafeScript(exec) ) + return false; + return true; +} + +Value getDOMNode(ExecState *exec, const DOM::Node& n) +{ + DOMObject *ret = 0; + if (n.isNull()) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + if ((ret = interp->getDOMObject(n.handle()))) + return Value(ret); + + switch (n.nodeType()) { + case DOM::Node::ELEMENT_NODE: + if (static_cast<DOM::Element>(n).isHTMLElement()) + ret = new HTMLElement(exec, static_cast<DOM::HTMLElement>(n)); + else + ret = new DOMElement(exec, static_cast<DOM::Element>(n)); + break; + case DOM::Node::ATTRIBUTE_NODE: + ret = new DOMAttr(exec, static_cast<DOM::Attr>(n)); + break; + case DOM::Node::TEXT_NODE: + case DOM::Node::CDATA_SECTION_NODE: + ret = new DOMText(exec, static_cast<DOM::Text>(n)); + break; + case DOM::Node::ENTITY_REFERENCE_NODE: + ret = new DOMNode(exec, n); + break; + case DOM::Node::ENTITY_NODE: + ret = new DOMEntity(exec, static_cast<DOM::Entity>(n)); + break; + case DOM::Node::PROCESSING_INSTRUCTION_NODE: + ret = new DOMProcessingInstruction(exec, static_cast<DOM::ProcessingInstruction>(n)); + break; + case DOM::Node::COMMENT_NODE: + ret = new DOMCharacterData(exec, static_cast<DOM::CharacterData>(n)); + break; + case DOM::Node::DOCUMENT_NODE: + if (static_cast<DOM::Document>(n).isHTMLDocument()) + ret = new HTMLDocument(exec, static_cast<DOM::HTMLDocument>(n)); + else + ret = new DOMDocument(exec, static_cast<DOM::Document>(n)); + break; + case DOM::Node::DOCUMENT_TYPE_NODE: + ret = new DOMDocumentType(exec, static_cast<DOM::DocumentType>(n)); + break; + case DOM::Node::DOCUMENT_FRAGMENT_NODE: + ret = new DOMNode(exec, n); + break; + case DOM::Node::NOTATION_NODE: + ret = new DOMNotation(exec, static_cast<DOM::Notation>(n)); + break; + default: + ret = new DOMNode(exec, n); + } + interp->putDOMObject(n.handle(),ret); + + return Value(ret); +} + +Value getDOMNamedNodeMap(ExecState *exec, const DOM::NamedNodeMap& m) +{ + return Value(cacheDOMObject<DOM::NamedNodeMap, KJS::DOMNamedNodeMap>(exec, m)); +} + +Value getDOMNodeList(ExecState *exec, const DOM::NodeList& l) +{ + return Value(cacheDOMObject<DOM::NodeList, KJS::DOMNodeList>(exec, l)); +} + +Value getDOMDOMImplementation(ExecState *exec, const DOM::DOMImplementation& i) +{ + return Value(cacheDOMObject<DOM::DOMImplementation, KJS::DOMDOMImplementation>(exec, i)); +} + +// ------------------------------------------------------------------------- +IMPLEMENT_PSEUDO_CONSTRUCTOR_WITH_PARENT(NodeConstructor, "NodeConstructor", DOMNodeProto, DOMNodeConstants) +// ------------------------------------------------------------------------- + +const ClassInfo DOMExceptionConstructor::info = { "DOMExceptionConstructor", 0, 0, 0 }; + +/* Source for DOMExceptionConstructorTable. +@begin DOMExceptionConstructorTable 15 + INDEX_SIZE_ERR DOM::DOMException::INDEX_SIZE_ERR DontDelete|ReadOnly + DOMSTRING_SIZE_ERR DOM::DOMException::DOMSTRING_SIZE_ERR DontDelete|ReadOnly + HIERARCHY_REQUEST_ERR DOM::DOMException::HIERARCHY_REQUEST_ERR DontDelete|ReadOnly + WRONG_DOCUMENT_ERR DOM::DOMException::WRONG_DOCUMENT_ERR DontDelete|ReadOnly + INVALID_CHARACTER_ERR DOM::DOMException::INVALID_CHARACTER_ERR DontDelete|ReadOnly + NO_DATA_ALLOWED_ERR DOM::DOMException::NO_DATA_ALLOWED_ERR DontDelete|ReadOnly + NO_MODIFICATION_ALLOWED_ERR DOM::DOMException::NO_MODIFICATION_ALLOWED_ERR DontDelete|ReadOnly + NOT_FOUND_ERR DOM::DOMException::NOT_FOUND_ERR DontDelete|ReadOnly + NOT_SUPPORTED_ERR DOM::DOMException::NOT_SUPPORTED_ERR DontDelete|ReadOnly + INUSE_ATTRIBUTE_ERR DOM::DOMException::INUSE_ATTRIBUTE_ERR DontDelete|ReadOnly + INVALID_STATE_ERR DOM::DOMException::INVALID_STATE_ERR DontDelete|ReadOnly + SYNTAX_ERR DOM::DOMException::SYNTAX_ERR DontDelete|ReadOnly + INVALID_MODIFICATION_ERR DOM::DOMException::INVALID_MODIFICATION_ERR DontDelete|ReadOnly + NAMESPACE_ERR DOM::DOMException::NAMESPACE_ERR DontDelete|ReadOnly + INVALID_ACCESS_ERR DOM::DOMException::INVALID_ACCESS_ERR DontDelete|ReadOnly +@end +*/ + +DOMExceptionConstructor::DOMExceptionConstructor(ExecState* exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{ +} + +Value DOMExceptionConstructor::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + return DOMObjectLookupGetValue<DOMExceptionConstructor, DOMObject>(exec, propertyName, &DOMExceptionConstructorTable, this); +} + +Value DOMExceptionConstructor::getValueProperty(ExecState *, int token) const +{ + // We use the token as the value to return directly + return Number((unsigned int)token); +#if 0 + switch (token) { + case INDEX_SIZE_ERR: + return Number((unsigned int)DOM::DOMException::INDEX_SIZE_ERR); + case DOMSTRING_SIZE_ERR: + return Number((unsigned int)DOM::DOMException::DOMSTRING_SIZE_ERR); + case HIERARCHY_REQUEST_ERR: + return Number((unsigned int)DOM::DOMException::HIERARCHY_REQUEST_ERR); + case WRONG_DOCUMENT_ERR: + return Number((unsigned int)DOM::DOMException::WRONG_DOCUMENT_ERR); + case INVALID_CHARACTER_ERR: + return Number((unsigned int)DOM::DOMException::INVALID_CHARACTER_ERR); + case NO_DATA_ALLOWED_ERR: + return Number((unsigned int)DOM::DOMException::NO_DATA_ALLOWED_ERR); + case NO_MODIFICATION_ALLOWED_ERR: + return Number((unsigned int)DOM::DOMException::NO_MODIFICATION_ALLOWED_ERR); + case NOT_FOUND_ERR: + return Number((unsigned int)DOM::DOMException::NOT_FOUND_ERR); + case NOT_SUPPORTED_ERR: + return Number((unsigned int)DOM::DOMException::NOT_SUPPORTED_ERR); + case INUSE_ATTRIBUTE_ERR: + return Number((unsigned int)DOM::DOMException::INUSE_ATTRIBUTE_ERR); + case INVALID_STATE_ERR: + return Number((unsigned int)DOM::DOMException::INVALID_STATE_ERR); + case SYNTAX_ERR: + return Number((unsigned int)DOM::DOMException::SYNTAX_ERR); + case INVALID_MODIFICATION_ERR: + return Number((unsigned int)DOM::DOMException::INVALID_MODIFICATION_ERR); + case NAMESPACE_ERR: + return Number((unsigned int)DOM::DOMException::NAMESPACE_ERR); + case INVALID_ACCESS_ERR: + return Number((unsigned int)DOM::DOMException::INVALID_ACCESS_ERR); + default: + kdDebug(6070) << "WARNING: DOMExceptionConstructor::getValueProperty unhandled token " << token << endl; + return Value(); + } +#endif +} + +Object getDOMExceptionConstructor(ExecState *exec) +{ + return cacheGlobalObject<DOMExceptionConstructor>(exec, "[[DOMException.constructor]]"); +} + +// ------------------------------------------------------------------------- + +/* Source for DOMNamedNodesCollection. +@begin DOMNamedNodesCollectionTable 1 + length KJS::DOMNamedNodesCollection::Length DontDelete|ReadOnly +@end +*/ +const ClassInfo KJS::DOMNamedNodesCollection::info = { "DOMNamedNodesCollection", 0, &DOMNamedNodesCollectionTable, 0 }; + +// Such a collection is usually very short-lived, it only exists +// for constructs like document.forms.<name>[1], +// so it shouldn't be a problem that it's storing all the nodes (with the same name). (David) +DOMNamedNodesCollection::DOMNamedNodesCollection(ExecState *exec, const TQValueList<DOM::Node>& nodes ) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), + m_nodes(nodes) +{ + // Maybe we should ref (and deref in the dtor) the nodes, though ? +} + +Value DOMNamedNodesCollection::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + kdDebug(6070) << k_funcinfo << propertyName.ascii() << endl; + if (propertyName == lengthPropertyName) + return Number(m_nodes.count()); + // index? + bool ok; + unsigned int u = propertyName.toULong(&ok); + if (ok && u < m_nodes.count()) { + DOM::Node node = m_nodes[u]; + return getDOMNode(exec,node); + } + return DOMObject::tryGet(exec,propertyName); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMCharacterData::info = { "CharacterImp", + &DOMNode::info, &DOMCharacterDataTable, 0 }; +/* +@begin DOMCharacterDataTable 2 + data DOMCharacterData::Data DontDelete + length DOMCharacterData::Length DontDelete|ReadOnly +@end +@begin DOMCharacterDataProtoTable 7 + substringData DOMCharacterData::SubstringData DontDelete|Function 2 + appendData DOMCharacterData::AppendData DontDelete|Function 1 + insertData DOMCharacterData::InsertData DontDelete|Function 2 + deleteData DOMCharacterData::DeleteData DontDelete|Function 2 + replaceData DOMCharacterData::ReplaceData DontDelete|Function 2 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMCharacterDataProto, DOMNodeProto) +IMPLEMENT_PROTOFUNC_DOM(DOMCharacterDataProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMCharacterData", DOMCharacterDataProto, DOMCharacterDataProtoFunc) + +DOMCharacterData::DOMCharacterData(ExecState *exec, const DOM::CharacterData& d) + : DOMNode(DOMCharacterDataProto::self(exec), d) {} + +DOMCharacterData::DOMCharacterData(const Object& proto, const DOM::CharacterData& d) + : DOMNode(proto, d) {} + +Value DOMCharacterData::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070)<<"DOMCharacterData::tryGet "<<p.string().string()<<endl; +#endif + return DOMObjectLookupGetValue<DOMCharacterData,DOMNode>(exec,p,&DOMCharacterDataTable,this); +} + +Value DOMCharacterData::getValueProperty(ExecState *, int token) const +{ + DOM::CharacterData data = static_cast<DOM::CharacterData>(node); + switch (token) { + case Data: + return String(data.data()); + case Length: + return Number(data.length()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMCharacterData::getValueProperty : " << token << endl; + return Value(); + } +} + +void DOMCharacterData::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + if (propertyName == "data") + static_cast<DOM::CharacterData>(node).setData(value.toString(exec).string()); + else + DOMNode::tryPut(exec, propertyName,value,attr); +} + +Value DOMCharacterDataProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMCharacterData, thisObj ); + DOM::CharacterData data = static_cast<DOMCharacterData *>(thisObj.imp())->toData(); + switch(id) { + case DOMCharacterData::SubstringData: + return String(data.substringData(args[0].toInteger(exec),args[1].toInteger(exec))); + case DOMCharacterData::AppendData: + data.appendData(args[0].toString(exec).string()); + return Undefined(); + break; + case DOMCharacterData::InsertData: + data.insertData(args[0].toInteger(exec),args[1].toString(exec).string()); + return Undefined(); + break; + case DOMCharacterData::DeleteData: + data.deleteData(args[0].toInteger(exec),args[1].toInteger(exec)); + return Undefined(); + break; + case DOMCharacterData::ReplaceData: + data.replaceData(args[0].toInteger(exec),args[1].toInteger(exec),args[2].toString(exec).string()); + return Undefined(); + default: + break; + } + return Undefined(); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMText::info = { "Text", + &DOMCharacterData::info, 0, 0 }; +/* +@begin DOMTextProtoTable 1 + splitText DOMText::SplitText DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMTextProto, DOMCharacterDataProto) +IMPLEMENT_PROTOFUNC_DOM(DOMTextProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMText", DOMTextProto, DOMTextProtoFunc) + +DOMText::DOMText(ExecState *exec, const DOM::Text& t) + : DOMCharacterData(DOMTextProto::self(exec), t) { } + +Value DOMText::tryGet(ExecState *exec, const Identifier &p) const +{ + if (p.isEmpty()) + return Undefined(); // ### TODO + else + return DOMCharacterData::tryGet(exec, p); +} + +Value DOMTextProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMText, thisObj ); + DOM::Text text = static_cast<DOMText *>(thisObj.imp())->toText(); + switch(id) { + case DOMText::SplitText: + return getDOMNode(exec,text.splitText(args[0].toInteger(exec))); + default: + break; + } + return Undefined(); +} + +} diff --git a/tdehtml/ecma/kjs_dom.h b/tdehtml/ecma/kjs_dom.h new file mode 100644 index 000000000..b17488592 --- /dev/null +++ b/tdehtml/ecma/kjs_dom.h @@ -0,0 +1,299 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * 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 + */ + +#ifndef _KJS_DOM_H_ +#define _KJS_DOM_H_ + +#include "dom/dom_node.h" +#include "dom/dom_doc.h" +#include "dom/dom_element.h" +#include "dom/dom_xml.h" + +#include "ecma/kjs_binding.h" + + +namespace KJS { + + class DOMNode : public DOMObject { + public: + // Build a DOMNode + DOMNode(ExecState *exec, const DOM::Node& n); + // Constructor for inherited classes + DOMNode(const Object& proto, const DOM::Node& n); + ~DOMNode(); + virtual bool toBoolean(ExecState *) const; + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + void putValueProperty(ExecState *exec, int token, const Value& value, int attr); + virtual DOM::Node toNode() const { return node; } + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + + virtual Value toPrimitive(ExecState *exec, Type preferred = UndefinedType) const; + virtual UString toString(ExecState *exec) const; + void setListener(ExecState *exec, int eventId, const Value& func) const; + Value getListener(int eventId) const; + virtual void pushEventHandlerScope(ExecState *exec, ScopeChain &scope) const; + + enum { NodeName, NodeValue, NodeType, ParentNode, ParentElement, + ChildNodes, FirstChild, LastChild, PreviousSibling, NextSibling, Item, + Attributes, NamespaceURI, Prefix, LocalName, OwnerDocument, InsertBefore, + ReplaceChild, RemoveChild, AppendChild, HasAttributes, HasChildNodes, + CloneNode, Normalize, IsSupported, AddEventListener, RemoveEventListener, + DispatchEvent, Contains, InsertAdjacentHTML, + OnAbort, OnBlur, OnChange, OnClick, OnDblClick, OnDragDrop, OnError, + OnFocus, OnKeyDown, OnKeyPress, OnKeyUp, OnLoad, OnMouseDown, + OnMouseMove, OnMouseOut, OnMouseOver, OnMouseUp, OnMove, OnReset, + OnResize, OnSelect, OnSubmit, OnUnload, + OffsetLeft, OffsetTop, OffsetWidth, OffsetHeight, OffsetParent, + ClientWidth, ClientHeight, ScrollLeft, ScrollTop, + ScrollWidth, ScrollHeight, SourceIndex, TextContent }; + + protected: + DOM::Node node; + }; + + DEFINE_CONSTANT_TABLE(DOMNodeConstants) + KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMNodeProto, DOMNodeConstants) + DEFINE_PSEUDO_CONSTRUCTOR(NodeConstructor) + + class DOMNodeList : public DOMObject { + public: + DOMNodeList(ExecState *, const DOM::NodeList& l); + ~DOMNodeList(); + virtual bool hasProperty(ExecState *exec, const Identifier &p) const; + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual Value call(ExecState *exec, Object &thisObj, const List&args); + virtual Value tryCall(ExecState *exec, Object &thisObj, const List&args); + virtual bool implementsCall() const { return true; } + virtual ReferenceList propList(ExecState *exec, bool recursive); + + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + virtual bool toBoolean(ExecState *) const { return true; } + static const ClassInfo info; + DOM::NodeList nodeList() const { return list; } + enum { Item, NamedItem }; + private: + DOM::NodeList list; + }; + + class DOMDocument : public DOMNode { + public: + // Build a DOMDocument + DOMDocument(ExecState *exec, const DOM::Document& d); + // Constructor for inherited classes + DOMDocument(const Object& proto, const DOM::Document& d); + virtual ~DOMDocument(); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + void putValueProperty(ExecState *exec, int token, const Value& value, int attr); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { DocType, Implementation, DocumentElement, CharacterSet, + // Functions + CreateElement, CreateDocumentFragment, CreateTextNode, CreateComment, + CreateCDATASection, CreateProcessingInstruction, CreateAttribute, + CreateEntityReference, GetElementsByTagName, ImportNode, CreateElementNS, + CreateAttributeNS, GetElementsByTagNameNS, GetElementById, + CreateRange, CreateNodeIterator, CreateTreeWalker, DefaultView, + CreateEvent, StyleSheets, GetOverrideStyle, Abort, Load, LoadXML, + PreferredStylesheetSet, SelectedStylesheetSet, ReadyState, Async }; + }; + + KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMDocumentProto, DOMNodeProto) + + DEFINE_PSEUDO_CONSTRUCTOR(DocumentPseudoCtor) + + class DOMAttr : public DOMNode { + public: + DOMAttr(ExecState *exec, const DOM::Attr& a) : DOMNode(exec, a) { } + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + Value getValueProperty(ExecState *exec, int token) const; + void putValueProperty(ExecState *exec, int token, const Value& value, int attr); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Name, Specified, ValueProperty, OwnerElement }; + }; + + class DOMElement : public DOMNode { + public: + // Build a DOMElement + DOMElement(ExecState *exec, const DOM::Element& e); + // Constructor for inherited classes + DOMElement(const Object& proto, const DOM::Element& e); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { TagName, Style, + GetAttribute, SetAttribute, RemoveAttribute, GetAttributeNode, + SetAttributeNode, RemoveAttributeNode, GetElementsByTagName, + GetAttributeNS, SetAttributeNS, RemoveAttributeNS, GetAttributeNodeNS, + SetAttributeNodeNS, GetElementsByTagNameNS, HasAttribute, HasAttributeNS }; + }; + + KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMElementProto, DOMNodeProto) + DEFINE_PSEUDO_CONSTRUCTOR(ElementPseudoCtor) + + class DOMDOMImplementation : public DOMObject { + public: + // Build a DOMDOMImplementation + DOMDOMImplementation(ExecState *, const DOM::DOMImplementation& i); + ~DOMDOMImplementation(); + // no put - all functions + virtual const ClassInfo* classInfo() const { return &info; } + virtual bool toBoolean(ExecState *) const { return true; } + static const ClassInfo info; + enum { HasFeature, CreateDocumentType, CreateDocument, CreateCSSStyleSheet, CreateHTMLDocument }; + DOM::DOMImplementation toImplementation() const { return implementation; } + private: + DOM::DOMImplementation implementation; + }; + + class DOMDocumentType : public DOMNode { + public: + // Build a DOMDocumentType + DOMDocumentType(ExecState *exec, const DOM::DocumentType& dt); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Name, Entities, Notations, PublicId, SystemId, InternalSubset }; + }; + + class DOMNamedNodeMap : public DOMObject { + public: + DOMNamedNodeMap(ExecState *, const DOM::NamedNodeMap& m); + ~DOMNamedNodeMap(); + virtual bool hasProperty(ExecState *exec, const Identifier &p) const; + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + virtual bool toBoolean(ExecState *) const { return true; } + static const ClassInfo info; + enum { GetNamedItem, SetNamedItem, RemoveNamedItem, Item, Length, + GetNamedItemNS, SetNamedItemNS, RemoveNamedItemNS }; + DOM::NamedNodeMap toMap() const { return map; } + private: + DOM::NamedNodeMap map; + }; + + class DOMProcessingInstruction : public DOMNode { + public: + DOMProcessingInstruction(ExecState *exec, const DOM::ProcessingInstruction& pi) : DOMNode(exec, pi) { } + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Target, Data, Sheet }; + }; + + class DOMNotation : public DOMNode { + public: + DOMNotation(ExecState *exec, const DOM::Notation& n) : DOMNode(exec, n) { } + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { PublicId, SystemId }; + }; + + class DOMEntity : public DOMNode { + public: + DOMEntity(ExecState *exec, const DOM::Entity& e) : DOMNode(exec, e) { } + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { PublicId, SystemId, NotationName }; + }; + + // Constructor for DOMException - constructor stuff not implemented yet + class DOMExceptionConstructor : public DOMObject { + public: + DOMExceptionConstructor(ExecState *); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + bool checkNodeSecurity(ExecState *exec, const DOM::Node& n); + KDE_EXPORT Value getDOMNode(ExecState *exec, const DOM::Node& n); + Value getDOMNamedNodeMap(ExecState *exec, const DOM::NamedNodeMap& m); + Value getDOMNodeList(ExecState *exec, const DOM::NodeList& l); + Value getDOMDOMImplementation(ExecState *exec, const DOM::DOMImplementation& i); + Object getDOMExceptionConstructor(ExecState *exec); + + // Internal class, used for the collection return by e.g. document.forms.myinput + // when multiple nodes have the same name. + class DOMNamedNodesCollection : public DOMObject { + public: + DOMNamedNodesCollection(ExecState *exec, const TQValueList<DOM::Node>& nodes ); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + const TQValueList<DOM::Node>& nodes() const { return m_nodes; } + enum { Length }; + private: + TQValueList<DOM::Node> m_nodes; + }; + + class DOMCharacterData : public DOMNode { + public: + // Build a DOMCharacterData + DOMCharacterData(ExecState *exec, const DOM::CharacterData& d); + // Constructor for inherited classes + DOMCharacterData(const Object& proto, const DOM::CharacterData& d); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + DOM::CharacterData toData() const { return static_cast<DOM::CharacterData>(node); } + enum { Data, Length, + SubstringData, AppendData, InsertData, DeleteData, ReplaceData }; + }; + + class DOMText : public DOMCharacterData { + public: + DOMText(ExecState *exec, const DOM::Text& t); + virtual Value tryGet(ExecState *exec,const Identifier &propertyName) const; + Value getValueProperty(ExecState *, int token) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + DOM::Text toText() const { return static_cast<DOM::Text>(node); } + enum { SplitText }; + }; + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_events.cpp b/tdehtml/ecma/kjs_events.cpp new file mode 100644 index 000000000..7b6ff3cc1 --- /dev/null +++ b/tdehtml/ecma/kjs_events.cpp @@ -0,0 +1,993 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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_window.h" +#include "kjs_events.h" +#include "kjs_events.lut.h" +#include "kjs_views.h" +#include "kjs_proxy.h" +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" +#include "xml/dom2_eventsimpl.h" +#include "rendering/render_object.h" +#include "rendering/render_canvas.h" +#include "xml/dom2_eventsimpl.h" +#include "tdehtml_part.h" + +#include <kdebug.h> + +using namespace DOM; + +namespace KJS { + +// ------------------------------------------------------------------------- + +JSEventListener::JSEventListener(Object _listener, ObjectImp *_compareListenerImp, const Object &_win, bool _html) + : listener( _listener ), compareListenerImp( _compareListenerImp ), html( _html ), win( _win ) +{ + //fprintf(stderr,"JSEventListener::JSEventListener this=%p listener=%p\n",this,listener.imp()); + if (compareListenerImp) { + static_cast<Window*>(win.imp())->jsEventListeners.insert(compareListenerImp, this); + } +} + +JSEventListener::~JSEventListener() +{ + if (compareListenerImp) { + static_cast<Window*>(win.imp())->jsEventListeners.remove(compareListenerImp); + } + //fprintf(stderr,"JSEventListener::~JSEventListener this=%p listener=%p\n",this,listener.imp()); +} + +void JSEventListener::handleEvent(DOM::Event &evt) +{ +#ifdef KJS_DEBUGGER + if (KJSDebugWin::debugWindow() && KJSDebugWin::debugWindow()->inSession()) + return; +#endif + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(static_cast<Window*>(win.imp())->part()); + KJSProxy *proxy = 0L; + if (part) + proxy = part->jScript(); + + if (proxy && listener.isValid() && listener.implementsCall()) { + ref(); + + KJS::ScriptInterpreter *interpreter = static_cast<KJS::ScriptInterpreter *>(proxy->interpreter()); + ExecState *exec = interpreter->globalExec(); + + List args; + args.append(getDOMEvent(exec,evt)); + + // Set "this" to the event's current target + Object thisObj = Object::dynamicCast(getDOMNode(exec,evt.currentTarget())); + if ( !thisObj.isValid() ) { + // Window events (window.onload/window.onresize etc.) must have 'this' set to the window. + // DocumentImpl::defaultEventHandler sets currentTarget to 0 to mean 'window'. + thisObj = win; + } + + Window *window = static_cast<Window*>(win.imp()); + // Set the event we're handling in the Window object + window->setCurrentEvent( &evt ); + // ... and in the interpreter + interpreter->setCurrentEvent( &evt ); + + KJSCPUGuard guard; + guard.start(); + Value retval = listener.call(exec, thisObj, args); + guard.stop(); + + window->setCurrentEvent( 0 ); + interpreter->setCurrentEvent( 0 ); + if ( exec->hadException() ) + exec->clearException(); + else if (html) + { + TQVariant ret = ValueToVariant(exec, retval); + if (ret.type() == TQVariant::Bool && ret.toBool() == false) + evt.preventDefault(); + } + window->afterScriptExecution(); + deref(); + } +} + +DOM::DOMString JSEventListener::eventListenerType() +{ + if (html) + return "_tdehtml_HTMLEventListener"; + else + return "_tdehtml_JSEventListener"; +} + +Object JSEventListener::listenerObj() const +{ + return listener; +} + +JSLazyEventListener::JSLazyEventListener(const TQString &_code, const TQString &_name, const Object &_win, DOM::NodeImpl* _originalNode) + : JSEventListener(Object(), 0, _win, true), + code(_code), name(_name), + parsed(false) +{ + // We don't retain the original node, because we assume it + // will stay alive as long as this handler object is around + // and we need to avoid a reference cycle. If JS transfers + // this handler to another node, parseCode will be called and + // then originalNode is no longer needed. + + originalNode = _originalNode; +} + +JSLazyEventListener::~JSLazyEventListener() +{ + if (listener.isValid()) { + static_cast<Window*>(win.imp())->jsEventListeners.remove(listener.imp()); + } +} + +void JSLazyEventListener::handleEvent(DOM::Event &evt) +{ + parseCode(); + if (listener.isValid()) { + JSEventListener::handleEvent(evt); + } +} + + +Object JSLazyEventListener::listenerObj() const +{ + parseCode(); + return listener; +} + +void JSLazyEventListener::parseCode() const +{ + if (!parsed) { + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(static_cast<Window*>(win.imp())->part()); + KJSProxy *proxy = 0L; + if (part) + proxy = part->jScript(); + + if (proxy) { + KJS::ScriptInterpreter *interpreter = static_cast<KJS::ScriptInterpreter *>(proxy->interpreter()); + ExecState *exec = interpreter->globalExec(); + + //KJS::Constructor constr(KJS::Global::current().get("Function").imp()); + KJS::Object constr = interpreter->builtinFunction(); + KJS::List args; + + static KJS::String eventString("event"); + + args.append(eventString); + args.append(KJS::String(code)); + listener = constr.construct(exec, args); // ### is globalExec ok ? + + if (exec->hadException()) { + exec->clearException(); + + // failed to parse, so let's just make this listener a no-op + listener = Object(); + } else if (!listener.inherits(&DeclaredFunctionImp::info)) { + listener = Object();// Error creating function + } else { + DeclaredFunctionImp *declFunc = static_cast<DeclaredFunctionImp*>(listener.imp()); + declFunc->setName(Identifier(static_cast<UString>(name))); + + if (originalNode) + { + // Add the event's home element to the scope + // (and the document, and the form - see KJS::HTMLElement::eventHandlerScope) + ScopeChain scope = listener.scope(); + + Object thisObj = Object::dynamicCast(getDOMNode(exec, originalNode)); + + if (thisObj.isValid()) { + static_cast<DOMNode*>(thisObj.imp())->pushEventHandlerScope(exec, scope); + + listener.setScope(scope); + } + } + } + } + + // no more need to keep the unparsed code around + code = TQString(); + + if (listener.isValid()) { + static_cast<Window*>(win.imp())->jsEventListeners.insert(listener.imp(), + (KJS::JSEventListener *)(this)); + } + + parsed = true; + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMEvent::info = { "Event", 0, &DOMEventTable, 0 }; +/* +@begin DOMEventTable 7 + type DOMEvent::Type DontDelete|ReadOnly + target DOMEvent::Target DontDelete|ReadOnly + currentTarget DOMEvent::CurrentTarget DontDelete|ReadOnly + srcElement DOMEvent::SrcElement DontDelete|ReadOnly + eventPhase DOMEvent::EventPhase DontDelete|ReadOnly + bubbles DOMEvent::Bubbles DontDelete|ReadOnly + cancelable DOMEvent::Cancelable DontDelete|ReadOnly + timeStamp DOMEvent::TimeStamp DontDelete|ReadOnly + returnValue DOMEvent::ReturnValue DontDelete + cancelBubble DOMEvent::CancelBubble DontDelete +@end +@begin DOMEventProtoTable 3 + stopPropagation DOMEvent::StopPropagation DontDelete|Function 0 + preventDefault DOMEvent::PreventDefault DontDelete|Function 0 + initEvent DOMEvent::InitEvent DontDelete|Function 3 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMEventProto) +IMPLEMENT_PROTOFUNC_DOM(DOMEventProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMEvent", DOMEventProto, DOMEventProtoFunc) + +DOMEvent::DOMEvent(ExecState *exec, DOM::Event e) + : DOMObject(DOMEventProto::self(exec)), event(e) { } + +DOMEvent::DOMEvent(const Object &proto, DOM::Event e) + : DOMObject(proto), event(e) { } + +DOMEvent::~DOMEvent() +{ + ScriptInterpreter::forgetDOMObject(event.handle()); +} + +Value DOMEvent::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug() << "KJS::DOMEvent::tryGet " << p.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMEvent,DOMObject>(exec, p, &DOMEventTable, this ); +} + +Value DOMEvent::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case Type: + return String(event.type()); + case Target: + case SrcElement: /*MSIE extension - "the object that fired the event"*/ + return getDOMNode(exec,event.target()); + case CurrentTarget: + return getDOMNode(exec,event.currentTarget()); + case EventPhase: + return Number((unsigned int)event.eventPhase()); + case Bubbles: + return Boolean(event.bubbles()); + case Cancelable: + return Boolean(event.cancelable()); + case TimeStamp: + return Number((long unsigned int)event.timeStamp()); // ### long long ? + case ReturnValue: // MSIE extension + // return false == cancel, so this returns the -opposite- of defaultPrevented + return Boolean(!event.handle()->defaultPrevented()); + case CancelBubble: // MSIE extension + return Boolean(event.handle()->propagationStopped()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMEvent::getValueProperty : " << token << endl; + return Value(); + } +} + +Value DOMEvent::defaultValue(ExecState *exec, KJS::Type hint) const +{ + if (event.handle()->id() == EventImpl::ERROR_EVENT && !event.handle()->message().isNull()) { + return String(event.handle()->message()); + } + else + return DOMObject::defaultValue(exec,hint); +} + +void DOMEvent::tryPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr) +{ + DOMObjectLookupPut<DOMEvent, DOMObject>(exec, propertyName, value, attr, + &DOMEventTable, this); +} + +void DOMEvent::putValueProperty(ExecState *exec, int token, const Value& value, int) +{ + switch (token) { + case ReturnValue: // MSIE equivalent for "preventDefault" (but with a way to reset it) + // returnValue=false means "default action of the event on the source object is canceled", + // which means preventDefault(true). Hence the '!'. + event.handle()->preventDefault(!value.toBoolean(exec)); + break; + case CancelBubble: // MSIE equivalent for "stopPropagation" (but with a way to reset it) + event.handle()->stopPropagation(value.toBoolean(exec)); + break; + default: + break; + } +} + +Value DOMEventProtoFunc::tryCall(ExecState *exec, Object & thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMEvent, thisObj ); + DOM::Event event = static_cast<DOMEvent *>( thisObj.imp() )->toEvent(); + switch (id) { + case DOMEvent::StopPropagation: + event.stopPropagation(); + return Undefined(); + case DOMEvent::PreventDefault: + event.preventDefault(); + return Undefined(); + case DOMEvent::InitEvent: + event.initEvent(args[0].toString(exec).string(),args[1].toBoolean(exec),args[2].toBoolean(exec)); + return Undefined(); + }; + return Undefined(); +} + +Value getDOMEvent(ExecState *exec, DOM::Event e) +{ + DOM::EventImpl *ei = e.handle(); + if (!ei) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + DOMObject *ret = interp->getDOMObject(ei); + if (!ret) { + if (ei->isTextInputEvent()) + ret = new DOMTextEvent(exec, e); + else if (ei->isKeyboardEvent()) + ret = new DOMKeyboardEvent(exec, e); + else if (ei->isMouseEvent()) + ret = new DOMMouseEvent(exec, e); + else if (ei->isUIEvent()) + ret = new DOMUIEvent(exec, e); + else if (ei->isMutationEvent()) + ret = new DOMMutationEvent(exec, e); + else + ret = new DOMEvent(exec, e); + + interp->putDOMObject(ei, ret); + } + + return Value(ret); +} + +DOM::Event toEvent(const Value& val) +{ + Object obj = Object::dynamicCast(val); + if (!obj.isValid() || !obj.inherits(&DOMEvent::info)) + return DOM::Event(); + + const DOMEvent *dobj = static_cast<const DOMEvent*>(obj.imp()); + return dobj->toEvent(); +} + +// ------------------------------------------------------------------------- +/* +@begin EventConstantsTable 23 + CAPTURING_PHASE DOM::Event::CAPTURING_PHASE DontDelete|ReadOnly + AT_TARGET DOM::Event::AT_TARGET DontDelete|ReadOnly + BUBBLING_PHASE DOM::Event::BUBBLING_PHASE DontDelete|ReadOnly +# Reverse-engineered from Netscape + MOUSEDOWN 1 DontDelete|ReadOnly + MOUSEUP 2 DontDelete|ReadOnly + MOUSEOVER 4 DontDelete|ReadOnly + MOUSEOUT 8 DontDelete|ReadOnly + MOUSEMOVE 16 DontDelete|ReadOnly + MOUSEDRAG 32 DontDelete|ReadOnly + CLICK 64 DontDelete|ReadOnly + DBLCLICK 128 DontDelete|ReadOnly + KEYDOWN 256 DontDelete|ReadOnly + KEYUP 512 DontDelete|ReadOnly + KEYPRESS 1024 DontDelete|ReadOnly + DRAGDROP 2048 DontDelete|ReadOnly + FOCUS 4096 DontDelete|ReadOnly + BLUR 8192 DontDelete|ReadOnly + SELECT 16384 DontDelete|ReadOnly + CHANGE 32768 DontDelete|ReadOnly +@end +*/ +DEFINE_CONSTANT_TABLE(EventConstants) +IMPLEMENT_CONSTANT_TABLE(EventConstants, "EventConstants") + +IMPLEMENT_PSEUDO_CONSTRUCTOR_WITH_PARENT(EventConstructor, "EventConstructor", DOMEventProto, EventConstants) +// ------------------------------------------------------------------------- + + +const ClassInfo EventExceptionConstructor::info = { "EventExceptionConstructor", 0, &EventExceptionConstructorTable, 0 }; +/* +@begin EventExceptionConstructorTable 1 + UNSPECIFIED_EVENT_TYPE_ERR DOM::EventException::UNSPECIFIED_EVENT_TYPE_ERR DontDelete|ReadOnly +@end +*/ +EventExceptionConstructor::EventExceptionConstructor(ExecState *exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{ +} + +Value EventExceptionConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<EventExceptionConstructor, DOMObject>(exec,p,&EventExceptionConstructorTable,this); +} + +Value EventExceptionConstructor::getValueProperty(ExecState *, int token) const +{ + // We use the token as the value to return directly + return Number(token); +} + +Value getEventExceptionConstructor(ExecState *exec) +{ + return cacheGlobalObject<EventExceptionConstructor>(exec, "[[eventException.constructor]]"); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMUIEvent::info = { "UIEvent", &DOMEvent::info, &DOMUIEventTable, 0 }; +/* +@begin DOMUIEventTable 7 + view DOMUIEvent::View DontDelete|ReadOnly + detail DOMUIEvent::Detail DontDelete|ReadOnly + keyCode DOMUIEvent::KeyCode DontDelete|ReadOnly + charCode DOMUIEvent::CharCode DontDelete|ReadOnly + layerX DOMUIEvent::LayerX DontDelete|ReadOnly + layerY DOMUIEvent::LayerY DontDelete|ReadOnly + pageX DOMUIEvent::PageX DontDelete|ReadOnly + pageY DOMUIEvent::PageY DontDelete|ReadOnly + which DOMUIEvent::Which DontDelete|ReadOnly +@end +@begin DOMUIEventProtoTable 1 + initUIEvent DOMUIEvent::InitUIEvent DontDelete|Function 5 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMUIEventProto, DOMEventProto) +IMPLEMENT_PROTOFUNC_DOM(DOMUIEventProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMUIEvent", DOMUIEventProto, DOMUIEventProtoFunc) + +DOMUIEvent::DOMUIEvent(ExecState *exec, DOM::UIEvent ue) : + DOMEvent(DOMUIEventProto::self(exec), ue) {} + +DOMUIEvent::DOMUIEvent(const Object &proto, DOM::UIEvent ue) : + DOMEvent(proto, ue) {} + +DOMUIEvent::~DOMUIEvent() +{ +} + +Value DOMUIEvent::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMUIEvent,DOMEvent>(exec,p,&DOMUIEventTable,this); +} + +Value DOMUIEvent::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case View: + return getDOMAbstractView(exec,static_cast<DOM::UIEvent>(event).view()); + case Detail: + return Number(static_cast<DOM::UIEvent>(event).detail()); + case KeyCode: + // IE-compatibility + return Number(static_cast<DOM::UIEvent>(event).keyCode()); + case CharCode: + // IE-compatibility + return Number(static_cast<DOM::UIEvent>(event).charCode()); + case LayerX: + // NS-compatibility + return Number(static_cast<DOM::UIEvent>(event).layerX()); + case LayerY: + // NS-compatibility + return Number(static_cast<DOM::UIEvent>(event).layerY()); + case PageX: + // NS-compatibility + return Number(static_cast<DOM::UIEvent>(event).pageX()); + case PageY: + // NS-compatibility + return Number(static_cast<DOM::UIEvent>(event).pageY()); + case Which: + // NS-compatibility + return Number(static_cast<DOM::UIEvent>(event).which()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMUIEvent::getValueProperty : " << token << endl; + return Undefined(); + } +} + +Value DOMUIEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMUIEvent, thisObj ); + DOM::UIEvent uiEvent = static_cast<DOMUIEvent *>(thisObj.imp())->toUIEvent(); + switch (id) { + case DOMUIEvent::InitUIEvent: { + DOM::AbstractView v = toAbstractView(args[3]); + static_cast<DOM::UIEvent>(uiEvent).initUIEvent(args[0].toString(exec).string(), + args[1].toBoolean(exec), + args[2].toBoolean(exec), + v, + args[4].toInteger(exec)); + } + return Undefined(); + } + return Undefined(); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMMouseEvent::info = { "MouseEvent", &DOMUIEvent::info, &DOMMouseEventTable, 0 }; + +/* +@begin DOMMouseEventTable 2 + screenX DOMMouseEvent::ScreenX DontDelete|ReadOnly + screenY DOMMouseEvent::ScreenY DontDelete|ReadOnly + clientX DOMMouseEvent::ClientX DontDelete|ReadOnly + x DOMMouseEvent::X DontDelete|ReadOnly + clientY DOMMouseEvent::ClientY DontDelete|ReadOnly + y DOMMouseEvent::Y DontDelete|ReadOnly + offsetX DOMMouseEvent::OffsetX DontDelete|ReadOnly + offsetY DOMMouseEvent::OffsetY DontDelete|ReadOnly + ctrlKey DOMMouseEvent::CtrlKey DontDelete|ReadOnly + shiftKey DOMMouseEvent::ShiftKey DontDelete|ReadOnly + altKey DOMMouseEvent::AltKey DontDelete|ReadOnly + metaKey DOMMouseEvent::MetaKey DontDelete|ReadOnly + button DOMMouseEvent::Button DontDelete|ReadOnly + relatedTarget DOMMouseEvent::RelatedTarget DontDelete|ReadOnly + fromElement DOMMouseEvent::FromElement DontDelete|ReadOnly + toElement DOMMouseEvent::ToElement DontDelete|ReadOnly +@end +@begin DOMMouseEventProtoTable 1 + initMouseEvent DOMMouseEvent::InitMouseEvent DontDelete|Function 15 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMMouseEventProto, DOMUIEventProto) +IMPLEMENT_PROTOFUNC_DOM(DOMMouseEventProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMMouseEvent", DOMMouseEventProto, DOMMouseEventProtoFunc) + +DOMMouseEvent::DOMMouseEvent(ExecState *exec, DOM::MouseEvent me) : + DOMUIEvent(DOMMouseEventProto::self(exec), me) {} + +DOMMouseEvent::~DOMMouseEvent() +{ +} + +Value DOMMouseEvent::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMMouseEvent::tryGet " << p.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMMouseEvent,DOMUIEvent>(exec,p,&DOMMouseEventTable,this); +} + +Value DOMMouseEvent::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case ScreenX: + return Number(static_cast<DOM::MouseEvent>(event).screenX()); + case ScreenY: + return Number(static_cast<DOM::MouseEvent>(event).screenY()); + case ClientX: + case X: + return Number(static_cast<DOM::MouseEvent>(event).clientX()); + case ClientY: + case Y: + return Number(static_cast<DOM::MouseEvent>(event).clientY()); + case OffsetX: + case OffsetY: // MSIE extension + { + DOM::Node node = event.target(); + tdehtml::RenderObject *rend = 0; + if (node.handle()) { + node.handle()->getDocument()->updateRendering(); + rend = node.handle()->renderer(); + } + int x = static_cast<DOM::MouseEvent>(event).clientX(); + int y = static_cast<DOM::MouseEvent>(event).clientY(); + if ( rend ) { + int xPos, yPos; + if ( rend->absolutePosition( xPos, yPos ) ) { + //kdDebug() << "DOMMouseEvent::getValueProperty rend=" << rend << " xPos=" << xPos << " yPos=" << yPos << endl; + x -= xPos; + y -= yPos; + } + if ( rend->canvas() ) { + int cYPos, cXPos; + rend->canvas()->absolutePosition( cXPos, cYPos, true ); + x += cXPos; + y += cYPos; + } + } + return Number( token == OffsetX ? x : y ); + } + case CtrlKey: + return Boolean(static_cast<DOM::MouseEvent>(event).ctrlKey()); + case ShiftKey: + return Boolean(static_cast<DOM::MouseEvent>(event).shiftKey()); + case AltKey: + return Boolean(static_cast<DOM::MouseEvent>(event).altKey()); + case MetaKey: + return Boolean(static_cast<DOM::MouseEvent>(event).metaKey()); + case Button: + { + if ( exec->interpreter()->compatMode() == Interpreter::NetscapeCompat ) { + return Number(static_cast<DOM::MouseEvent>(event).button()); + } + // Tricky. The DOM (and tdehtml) use 0 for LMB, 1 for MMB and 2 for RMB + // but MSIE uses 1=LMB, 2=RMB, 4=MMB, as a bitfield + int domButton = static_cast<DOM::MouseEvent>(event).button(); + int button = domButton==0 ? 1 : domButton==1 ? 4 : domButton==2 ? 2 : 0; + return Number( (unsigned int)button ); + } + case ToElement: + // MSIE extension - "the object toward which the user is moving the mouse pointer" + if (event.handle()->id() == DOM::EventImpl::MOUSEOUT_EVENT) + return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).relatedTarget()); + return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).target()); + case FromElement: + // MSIE extension - "object from which activation + // or the mouse pointer is exiting during the event" (huh?) + if (event.handle()->id() == DOM::EventImpl::MOUSEOUT_EVENT) + return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).target()); + /* fall through */ + case RelatedTarget: + return getDOMNode(exec,static_cast<DOM::MouseEvent>(event).relatedTarget()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMMouseEvent::getValueProperty : " << token << endl; + return Value(); + } +} + +Value DOMMouseEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMMouseEvent, thisObj ); + DOM::MouseEvent mouseEvent = static_cast<DOMMouseEvent *>(thisObj.imp())->toMouseEvent(); + switch (id) { + case DOMMouseEvent::InitMouseEvent: + mouseEvent.initMouseEvent(args[0].toString(exec).string(), // typeArg + args[1].toBoolean(exec), // canBubbleArg + args[2].toBoolean(exec), // cancelableArg + toAbstractView(args[3]), // viewArg + args[4].toInteger(exec), // detailArg + args[5].toInteger(exec), // screenXArg + args[6].toInteger(exec), // screenYArg + args[7].toInteger(exec), // clientXArg + args[8].toInteger(exec), // clientYArg + args[9].toBoolean(exec), // ctrlKeyArg + args[10].toBoolean(exec), // altKeyArg + args[11].toBoolean(exec), // shiftKeyArg + args[12].toBoolean(exec), // metaKeyArg + args[13].toInteger(exec), // buttonArg + toNode(args[14])); // relatedTargetArg + return Undefined(); + } + return Undefined(); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMKeyEventBase::info = { "KeyEventBase", &DOMUIEvent::info, &DOMKeyEventBaseTable, 0 }; + +/* +@begin DOMKeyEventBaseTable 5 + keyVal DOMKeyEventBase::Key DontDelete|ReadOnly + virtKeyVal DOMKeyEventBase::VirtKey DontDelete|ReadOnly + ctrlKey DOMKeyEventBase::CtrlKey DontDelete|ReadOnly + altKey DOMKeyEventBase::AltKey DontDelete|ReadOnly + shiftKey DOMKeyEventBase::ShiftKey DontDelete|ReadOnly + altKey DOMKeyEventBase::AltKey DontDelete|ReadOnly +@end +*/ + +DOMKeyEventBase::DOMKeyEventBase(const Object &proto, DOM::TextEvent ke) : + DOMUIEvent(proto, ke) {} + +DOMKeyEventBase::~DOMKeyEventBase() +{} + +Value DOMKeyEventBase::tryGet(ExecState *exec,const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMKeyEventBase::tryGet " << p.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMKeyEventBase,DOMUIEvent>(exec,p,&DOMKeyEventBaseTable,this); +} + +Value DOMKeyEventBase::getValueProperty(ExecState *, int token) const +{ + DOM::KeyEventBaseImpl* tevent = impl(); + switch (token) { + case Key: + return Number(tevent->keyVal()); + case VirtKey: + return Number(tevent->virtKeyVal()); + // these modifier attributes actually belong into a KeyboardEvent interface, + // but we want them on "keypress" as well. + case CtrlKey: + return Boolean(tevent->ctrlKey()); + case ShiftKey: + return Boolean(tevent->shiftKey()); + case AltKey: + return Boolean(tevent->altKey()); + case MetaKey: + return Boolean(tevent->metaKey()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMTextEvent::getValueProperty : " << token << endl; + return KJS::Undefined(); + } +} + +// ------------------------------------------------------------------------- +const ClassInfo DOMTextEvent::info = { "TextEvent", &DOMKeyEventBase::info, &DOMTextEventTable, 0 }; + +/* +@begin DOMTextEventTable 1 + data DOMTextEvent::Data DontDelete|ReadOnly +@end +@begin DOMTextEventProtoTable 1 + initTextEvent DOMTextEvent::InitTextEvent DontDelete|Function 5 + # Missing: initTextEventNS +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMTextEventProto, DOMUIEventProto) //Note: no proto in KeyBase +IMPLEMENT_PROTOFUNC_DOM(DOMTextEventProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMTextEvent", DOMTextEventProto, DOMTextEventProtoFunc) + +DOMTextEvent::DOMTextEvent(ExecState *exec, DOM::TextEvent ke) : + DOMKeyEventBase(DOMTextEventProto::self(exec), ke) {} + +DOMTextEvent::~DOMTextEvent() +{ +} + +Value DOMTextEvent::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMTextEvent::tryGet " << p.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMTextEvent,DOMKeyEventBase>(exec,p,&DOMTextEventTable,this); +} + +Value DOMTextEvent::getValueProperty(ExecState *, int token) const +{ + DOM::TextEventImpl* tevent = impl(); + switch (token) { + case Data: + return String(tevent->data()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMTextEvent::getValueProperty : " << token << endl; + return KJS::Undefined(); + } +} + +Value DOMTextEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMTextEvent, thisObj ); + DOM::TextEventImpl* keyEvent = static_cast<DOMTextEvent *>(thisObj.imp())->impl(); + switch (id) { + case DOMTextEvent::InitTextEvent: + keyEvent->initTextEvent(args[0].toString(exec).string(), // typeArg + args[1].toBoolean(exec), // canBubbleArg + args[2].toBoolean(exec), // cancelableArg + toAbstractView(args[3]), // viewArg + args[4].toString(exec).string()); // dataArg + + return Undefined(); + } + return Undefined(); +} +// ------------------------------------------------------------------------- +const ClassInfo DOMKeyboardEvent::info = { "KeyboardEvent", &DOMKeyEventBase::info, &DOMKeyboardEventTable, 0 }; + +/* +@begin DOMKeyboardEventTable 2 + keyIdentifier DOMKeyboardEvent::KeyIdentifier DontDelete|ReadOnly + keyLocation DOMKeyboardEvent::KeyLocation DontDelete|ReadOnly +@end +@begin DOMKeyboardEventProtoTable 2 + initKeyboardEvent DOMKeyboardEvent::InitKeyboardEvent DontDelete|Function 7 + getModifierState DOMKeyboardEvent::GetModifierState DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMKeyboardEventProto, DOMUIEventProto) //Note: no proto in KeyBase +IMPLEMENT_PROTOFUNC_DOM(DOMKeyboardEventProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMKeyboardEvent", DOMKeyboardEventProto, DOMKeyboardEventProtoFunc) + +DOMKeyboardEvent::DOMKeyboardEvent(ExecState *exec, DOM::TextEvent ke) : + DOMKeyEventBase(DOMKeyboardEventProto::self(exec), ke) {} + +DOMKeyboardEvent::~DOMKeyboardEvent() +{ +} + +Value DOMKeyboardEvent::tryGet(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "DOMKeyboardEvent::tryGet " << p.qstring() << endl; +#endif + return DOMObjectLookupGetValue<DOMKeyboardEvent,DOMKeyEventBase>(exec,p,&DOMKeyboardEventTable,this); +} + +Value DOMKeyboardEvent::getValueProperty(ExecState *, int token) const +{ + DOM::KeyboardEventImpl* tevent = impl(); + switch (token) { + case KeyIdentifier: + return String(tevent->keyIdentifier()); + case KeyLocation: + return Number(tevent->keyLocation()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMKeyboardEvent::getValueProperty : " << token << endl; + return KJS::Undefined(); + } +} + +Value DOMKeyboardEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMKeyboardEvent, thisObj ); + DOM::KeyboardEventImpl* keyEvent = static_cast<DOMKeyboardEvent *>(thisObj.imp())->impl(); + switch (id) { + case DOMKeyboardEvent::InitKeyboardEvent: + keyEvent->initKeyboardEvent(args[0].toString(exec).string(), // typeArg + args[1].toBoolean(exec), // canBubbleArg + args[2].toBoolean(exec), // cancelableArg + toAbstractView(args[3]), // viewArg + args[4].toString(exec).string(), // keyIdentifierArg + args[5].toInteger(exec), // keyLocationArg + args[6].toString(exec).string()); //modifiersList + break; + case DOMKeyboardEvent::GetModifierState: + return Boolean(keyEvent->getModifierState(args[0].toString(exec).string())); + } + return Undefined(); +} + +// ------------------------------------------------------------------------- +const ClassInfo KeyboardEventConstructor::info = { "KeyboardEventConstructor", 0, &KeyboardEventConstructorTable, 0 }; +/* +@begin KeyboardEventConstructorTable 4 + DOM_KEY_LOCATION_STANDARD DOM::KeyboardEventImpl::DOM_KEY_LOCATION_STANDARD DontDelete|ReadOnly + DOM_KEY_LOCATION_LEFT DOM::KeyboardEventImpl::DOM_KEY_LOCATION_LEFT DontDelete|ReadOnly + DOM_KEY_LOCATION_RIGHT DOM::KeyboardEventImpl::DOM_KEY_LOCATION_RIGHT DontDelete|ReadOnly + DOM_KEY_LOCATION_NUMPAD DOM::KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD DontDelete|ReadOnly +@end +*/ +KeyboardEventConstructor::KeyboardEventConstructor(ExecState* exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{} + +Value KeyboardEventConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<KeyboardEventConstructor,DOMObject>(exec,p,&KeyboardEventConstructorTable,this); +} + +Value KeyboardEventConstructor::getValueProperty(ExecState *, int token) const +{ + // We use the token as the value to return directly + return Number(token); +} + +Value getKeyboardEventConstructor(ExecState *exec) +{ + return cacheGlobalObject<KeyboardEventConstructor>(exec, "[[keyboardEvent.constructor]]"); +} + + +// ------------------------------------------------------------------------- +const ClassInfo MutationEventConstructor::info = { "MutationEventConstructor", 0, &MutationEventConstructorTable, 0 }; +/* +@begin MutationEventConstructorTable 3 + MODIFICATION DOM::MutationEvent::MODIFICATION DontDelete|ReadOnly + ADDITION DOM::MutationEvent::ADDITION DontDelete|ReadOnly + REMOVAL DOM::MutationEvent::REMOVAL DontDelete|ReadOnly +@end +*/ +MutationEventConstructor::MutationEventConstructor(ExecState* exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{ +} + +Value MutationEventConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<MutationEventConstructor,DOMObject>(exec,p,&MutationEventConstructorTable,this); +} + +Value MutationEventConstructor::getValueProperty(ExecState *, int token) const +{ + // We use the token as the value to return directly + return Number(token); +} + +Value getMutationEventConstructor(ExecState *exec) +{ + return cacheGlobalObject<MutationEventConstructor>(exec, "[[mutationEvent.constructor]]"); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMMutationEvent::info = { "MutationEvent", &DOMEvent::info, &DOMMutationEventTable, 0 }; +/* +@begin DOMMutationEventTable 5 + relatedNode DOMMutationEvent::RelatedNode DontDelete|ReadOnly + prevValue DOMMutationEvent::PrevValue DontDelete|ReadOnly + newValue DOMMutationEvent::NewValue DontDelete|ReadOnly + attrName DOMMutationEvent::AttrName DontDelete|ReadOnly + attrChange DOMMutationEvent::AttrChange DontDelete|ReadOnly +@end +@begin DOMMutationEventProtoTable 1 + initMutationEvent DOMMutationEvent::InitMutationEvent DontDelete|Function 8 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(DOMMutationEventProto, DOMEventProto) +IMPLEMENT_PROTOFUNC_DOM(DOMMutationEventProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMMutationEvent", DOMMutationEventProto, DOMMutationEventProtoFunc) + +DOMMutationEvent::DOMMutationEvent(ExecState *exec, DOM::MutationEvent me) : + DOMEvent(DOMMutationEventProto::self(exec), me) {} + +DOMMutationEvent::~DOMMutationEvent() +{ +} + +Value DOMMutationEvent::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMMutationEvent,DOMEvent>(exec,p,&DOMMutationEventTable,this); +} + +Value DOMMutationEvent::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case RelatedNode: + return getDOMNode(exec,static_cast<DOM::MutationEvent>(event).relatedNode()); + case PrevValue: + return String(static_cast<DOM::MutationEvent>(event).prevValue()); + case NewValue: + return String(static_cast<DOM::MutationEvent>(event).newValue()); + case AttrName: + return String(static_cast<DOM::MutationEvent>(event).attrName()); + case AttrChange: + return Number((unsigned int)static_cast<DOM::MutationEvent>(event).attrChange()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMMutationEvent::getValueProperty : " << token << endl; + return Value(); + } +} + +Value DOMMutationEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMMutationEvent, thisObj ); + DOM::MutationEvent mutationEvent = static_cast<DOMMutationEvent *>(thisObj.imp())->toMutationEvent(); + switch (id) { + case DOMMutationEvent::InitMutationEvent: + mutationEvent.initMutationEvent(args[0].toString(exec).string(), // typeArg, + args[1].toBoolean(exec), // canBubbleArg + args[2].toBoolean(exec), // cancelableArg + toNode(args[3]), // relatedNodeArg + args[4].toString(exec).string(), // prevValueArg + args[5].toString(exec).string(), // newValueArg + args[6].toString(exec).string(), // attrNameArg + args[7].toInteger(exec)); // attrChangeArg + return Undefined(); + } + return Undefined(); +} + +} //namespace KJS diff --git a/tdehtml/ecma/kjs_events.h b/tdehtml/ecma/kjs_events.h new file mode 100644 index 000000000..e48276031 --- /dev/null +++ b/tdehtml/ecma/kjs_events.h @@ -0,0 +1,250 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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 + */ + +#ifndef _KJS_EVENTS_H_ +#define _KJS_EVENTS_H_ + +#include "ecma/kjs_dom.h" +#include "dom/dom2_events.h" +#include "dom/dom_misc.h" +#include "xml/dom2_eventsimpl.h" + +namespace KJS { + + class Window; + + class JSEventListener : public DOM::EventListener { + public: + /** + * @param _listener the function object, that will be called when the event is emitted + * @param _compareListenerImp Compare Listener implementation. + * @param _win Window object, for memory management and caching. + * @param _html \c true if it is HTML. + * Never create a JSEventListener directly, use Window::getJSEventListener. + */ + JSEventListener(Object _listener, ObjectImp *_compareListenerImp, const Object &_win, bool _html = false); + virtual ~JSEventListener(); + virtual void handleEvent(DOM::Event &evt); + virtual DOM::DOMString eventListenerType(); + // Return the KJS function object executed when this event is emitted + virtual Object listenerObj() const; + ObjectImp *listenerObjImp() const { return listenerObj().imp(); } + // for Window::clear(). This is a bad hack though. The JSEventListener might not get deleted + // if it was added to a DOM node in another frame (#61467). But calling removeEventListener on + // all nodes we're listening to is quite difficult. + void clear() { listener = Object(); } + bool isHTMLEventListener() const { return html; } + + protected: + mutable Object listener; + // Storing a different ObjectImp ptr is needed to support addEventListener(.. [Object] ..) calls + // In the real-life case (where a 'function' is passed to addEventListener) we can directly call + // the 'listener' object and can cache the 'listener.imp()'. If the event listener should be removed + // the implementation will call removeEventListener(.. [Function] ..), and we can lookup the event + // listener by the passed function's imp() ptr. + // In the only dom-approved way (passing an Object to add/removeEventListener), the 'listener' + // variable stores the function object 'passedListener.handleEvent'. But we need to cache + // the imp() ptr of the 'passedListener' function _object_, as the implementation will + // call removeEventListener(.. [Object ..] on removal, and now we can successfully lookup + // the correct event listener, as well as the 'listener.handleEvent' function, we need to call. + mutable ObjectImp *compareListenerImp; + bool html; + Object win; + }; + + class JSLazyEventListener : public JSEventListener { + public: + JSLazyEventListener(const TQString &_code, const TQString &_name, const Object &_win, DOM::NodeImpl* node); + ~JSLazyEventListener(); + virtual void handleEvent(DOM::Event &evt); + Object listenerObj() const; + private: + void parseCode() const; + + mutable TQString code; + mutable TQString name; + mutable bool parsed; + DOM::NodeImpl *originalNode; + }; + + // Constructor for Event - currently only used for some global vars + DEFINE_PSEUDO_CONSTRUCTOR(EventConstructor) + + class DOMEvent : public DOMObject { + public: + // Build a DOMEvent + DOMEvent(ExecState *exec, DOM::Event e); + // Constructor for inherited classes + DOMEvent(const Object &proto, DOM::Event e); + ~DOMEvent(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr = None); + virtual Value defaultValue(ExecState *exec, KJS::Type hint) const; + void putValueProperty(ExecState *exec, int token, const Value& value, int); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Type, Target, CurrentTarget, EventPhase, Bubbles, + Cancelable, TimeStamp, StopPropagation, PreventDefault, InitEvent, + // MS IE equivalents + SrcElement, ReturnValue, CancelBubble }; + DOM::Event toEvent() const { return event; } + protected: + DOM::Event event; + }; + + Value getDOMEvent(ExecState *exec, DOM::Event e); + + /** + * Convert an object to an Event. Returns a null Event if not possible. + */ + DOM::Event toEvent(const Value&); + + // Constructor object EventException + class EventExceptionConstructor : public DOMObject { + public: + EventExceptionConstructor(ExecState *); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + Value getEventExceptionConstructor(ExecState *exec); + + class DOMUIEvent : public DOMEvent { + public: + // Build a DOMUIEvent + DOMUIEvent(ExecState *exec, DOM::UIEvent ue); + // Constructor for inherited classes + DOMUIEvent(const Object &proto, DOM::UIEvent ue); + ~DOMUIEvent(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { View, Detail, KeyCode, CharCode, LayerX, LayerY, PageX, PageY, Which, InitUIEvent }; + DOM::UIEvent toUIEvent() const { return static_cast<DOM::UIEvent>(event); } + }; + + class DOMMouseEvent : public DOMUIEvent { + public: + DOMMouseEvent(ExecState *exec, DOM::MouseEvent me); + ~DOMMouseEvent(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { ScreenX, ScreenY, ClientX, X, ClientY, Y, OffsetX, OffsetY, + CtrlKey, ShiftKey, AltKey, + MetaKey, Button, RelatedTarget, FromElement, ToElement, + InitMouseEvent + }; + DOM::MouseEvent toMouseEvent() const { return static_cast<DOM::MouseEvent>(event); } + }; + + class DOMKeyEventBase : public DOMUIEvent { + public: + DOMKeyEventBase(const Object &proto, DOM::TextEvent ke); + ~DOMKeyEventBase(); + + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Key, VirtKey, CtrlKey, ShiftKey, AltKey, MetaKey }; + DOM::KeyEventBaseImpl* impl() const { return static_cast<DOM::KeyEventBaseImpl*>(event.handle()); } + }; + + class DOMTextEvent : public DOMKeyEventBase { + public: + DOMTextEvent(ExecState *exec, DOM::TextEvent ke); + ~DOMTextEvent(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum {Data, InitTextEvent}; + DOM::TextEventImpl* impl() const { return static_cast<DOM::TextEventImpl*>(event.handle()); } + }; + + class DOMKeyboardEvent : public DOMKeyEventBase { + public: + DOMKeyboardEvent(ExecState *exec, DOM::TextEvent ke); + ~DOMKeyboardEvent(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum {KeyIdentifier, KeyLocation, GetModifierState, InitKeyboardEvent}; + DOM::KeyboardEventImpl* impl() const { return static_cast<DOM::KeyboardEventImpl*>(event.handle()); } + }; + + // Constructor object KeyboardEvent + class KeyboardEventConstructor : public DOMObject { + public: + KeyboardEventConstructor(ExecState *); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + Value getKeyboardEventConstructor(ExecState *exec); + + // Constructor object MutationEvent + class MutationEventConstructor : public DOMObject { + public: + MutationEventConstructor(ExecState *); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + Value getMutationEventConstructor(ExecState *exec); + + class DOMMutationEvent : public DOMEvent { + public: + DOMMutationEvent(ExecState *exec, DOM::MutationEvent me); + ~DOMMutationEvent(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { AttrChange, RelatedNode, AttrName, PrevValue, NewValue, + InitMutationEvent }; + DOM::MutationEvent toMutationEvent() const { return static_cast<DOM::MutationEvent>(event); } + }; + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_html.cpp b/tdehtml/ecma/kjs_html.cpp new file mode 100644 index 000000000..37fd70754 --- /dev/null +++ b/tdehtml/ecma/kjs_html.cpp @@ -0,0 +1,3946 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 1999-2002 Harri Porten (porten@kde.org) + * Copyright (C) 2001-2003 David Faure (faure@kde.org) + * 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 "misc/loader.h" +#include "dom/html_block.h" +#include "dom/html_head.h" +#include "dom/html_image.h" +#include "dom/html_inline.h" +#include "dom/html_list.h" +#include "dom/html_table.h" +#include "dom/html_object.h" +#include "dom/dom_exception.h" + +// ### HACK +#include "html/html_baseimpl.h" +#include "html/html_documentimpl.h" +#include "html/html_formimpl.h" +#include "html/html_imageimpl.h" +#include "html/html_miscimpl.h" +#include "xml/dom2_eventsimpl.h" + +#include <tdeparts/browserextension.h> + +#include "tdehtml_part.h" +#include "tdehtmlview.h" + +#include "ecma/kjs_css.h" +#include "ecma/kjs_events.h" +#include "ecma/kjs_html.h" +#include "ecma/kjs_window.h" +#include "kjs_html.lut.h" + +#include "misc/htmltags.h" +#include "misc/htmlattrs.h" +#include "rendering/render_object.h" +#include "rendering/render_canvas.h" +#include "rendering/render_frames.h" +#include "rendering/render_layer.h" + +#include "kmessagebox.h" +#include <kstringhandler.h> +#include <klocale.h> + +#include <kdebug.h> + +namespace KJS { + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLDocumentProto, DOMDocumentProto) +IMPLEMENT_PROTOFUNC_DOM(HTMLDocFunction) +KJS_IMPLEMENT_PROTOTYPE("HTMLDocument", HTMLDocumentProto, HTMLDocFunction) + +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLDocumentPseudoCtor, "HTMLDocument", HTMLDocumentProto) + +/* Source for HTMLDocumentProtoTable. +@begin HTMLDocumentProtoTable 11 + clear HTMLDocument::Clear DontDelete|Function 0 + open HTMLDocument::Open DontDelete|Function 0 + close HTMLDocument::Close DontDelete|Function 0 + write HTMLDocument::Write DontDelete|Function 1 + writeln HTMLDocument::WriteLn DontDelete|Function 1 + getElementsByName HTMLDocument::GetElementsByName DontDelete|Function 1 + getSelection HTMLDocument::GetSelection DontDelete|Function 1 + captureEvents HTMLDocument::CaptureEvents DontDelete|Function 0 + releaseEvents HTMLDocument::ReleaseEvents DontDelete|Function 0 +@end +*/ + + +Value KJS::HTMLDocFunction::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( HTMLDocument, thisObj ); + + DOM::HTMLDocument doc = static_cast<KJS::HTMLDocument *>(thisObj.imp())->toDocument(); + + switch (id) { + case HTMLDocument::Clear: // even IE doesn't support that one... + //doc.clear(); // TODO + return Undefined(); + case HTMLDocument::Open: + if (args.size() >= 3) // IE extension for document.open: it means window.open if it has 3 args or more + { + KHTMLView *view = static_cast<DOM::DocumentImpl*>(doc.handle())->view(); + if ( view && view->part() ) { + Window* win = Window::retrieveWindow(view->part()); + if( win ) { + win->openWindow(exec, args); + } + } + } + + doc.open(); + return Undefined(); + case HTMLDocument::Close: + // see tdehtmltests/ecma/tokenizer-script-recursion.html + doc.close(); + return Undefined(); + case HTMLDocument::Write: + case HTMLDocument::WriteLn: { + // DOM only specifies single string argument, but NS & IE allow multiple + // or no arguments + UString str = ""; + for (int i = 0; i < args.size(); i++) + str += args[i].toString(exec); + if (id == HTMLDocument::WriteLn) + str += "\n"; +#ifdef KJS_VERBOSE + kdDebug(6070) << "document.write: " << str.string().string() << endl; +#endif + doc.write(str.string()); + return Undefined(); + } + case HTMLDocument::GetElementsByName: + return getDOMNodeList(exec,doc.getElementsByName(args[0].toString(exec).string())); + case HTMLDocument::GetSelection: { + // NS4 and Mozilla specific. IE uses document.selection.createRange() + // http://docs.sun.com/source/816-6408-10/document.htm#1195981 + KHTMLView *view = static_cast<DOM::DocumentImpl*>(doc.handle())->view(); + if ( view && view->part() ) + return String(view->part()->selectedText()); + else + return Undefined(); + } + case HTMLDocument::CaptureEvents: + case HTMLDocument::ReleaseEvents: + // Do nothing for now. These are NS-specific legacy calls. + break; + } + + return Undefined(); +} + +const ClassInfo KJS::HTMLDocument::info = + { "HTMLDocument", &DOMDocument::info, &HTMLDocumentTable, 0 }; +/* Source for HTMLDocumentTable. +@begin HTMLDocumentTable 31 + title HTMLDocument::Title DontDelete + referrer HTMLDocument::Referrer DontDelete|ReadOnly + domain HTMLDocument::Domain DontDelete + URL HTMLDocument::URL DontDelete|ReadOnly + body HTMLDocument::Body DontDelete + location HTMLDocument::Location DontDelete + cookie HTMLDocument::Cookie DontDelete + images HTMLDocument::Images DontDelete|ReadOnly + applets HTMLDocument::Applets DontDelete|ReadOnly + links HTMLDocument::Links DontDelete|ReadOnly + forms HTMLDocument::Forms DontDelete|ReadOnly + anchors HTMLDocument::Anchors DontDelete|ReadOnly + scripts HTMLDocument::Scripts DontDelete|ReadOnly + all HTMLDocument::All DontDelete|ReadOnly + bgColor HTMLDocument::BgColor DontDelete + fgColor HTMLDocument::FgColor DontDelete + alinkColor HTMLDocument::AlinkColor DontDelete + linkColor HTMLDocument::LinkColor DontDelete + vlinkColor HTMLDocument::VlinkColor DontDelete + lastModified HTMLDocument::LastModified DontDelete|ReadOnly + height HTMLDocument::Height DontDelete|ReadOnly + width HTMLDocument::Width DontDelete|ReadOnly + dir HTMLDocument::Dir DontDelete + compatMode HTMLDocument::CompatMode DontDelete|ReadOnly +#IE extension + frames HTMLDocument::Frames DontDelete|ReadOnly +#NS4 extension + layers HTMLDocument::Layers DontDelete|ReadOnly +#potentially obsolete array properties +# plugins +# tags +#potentially obsolete properties +# embeds +# ids +@end +*/ + +KJS::HTMLDocument::HTMLDocument(ExecState *exec, const DOM::HTMLDocument& d) + : DOMDocument(HTMLDocumentProto::self(exec), d) { } + +bool KJS::HTMLDocument::hasProperty(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + //kdDebug(6070) << "KJS::HTMLDocument::hasProperty " << p.qstring() << endl; +#endif + DOM::HTMLDocument doc = static_cast<DOM::HTMLDocument>(node); + DOM::DocumentImpl* docImpl = static_cast<DOM::DocumentImpl*>(doc.handle()); + KHTMLView *view = docImpl->view(); + Window* win = view && view->part() ? Window::retrieveWindow(view->part()) : 0L; + if ( !win || !win->isSafeScript(exec) ) + return false; + + + if ( docImpl->underDocNamedCache().contains( p.qstring() ) ) + return true; + + if ( view && view->part() ) + { + KHTMLPart *kp = view->part()->findFrame( p.qstring() ); + if (kp) + return true; + } + + return DOMDocument::hasProperty(exec, p); +} + +Value KJS::HTMLDocument::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLDocument::tryGet " << propertyName.qstring() << endl; +#endif + + DOM::HTMLDocument doc = static_cast<DOM::HTMLDocument>(node); + DOM::DocumentImpl* docImpl = static_cast<DOM::DocumentImpl*>(doc.handle()); + KHTMLView *view = docImpl->view(); + + Window* win = view && view->part() ? Window::retrieveWindow(view->part()) : 0L; + if ( !win || !win->isSafeScript(exec) ) + return Undefined(); + + //Check for images, forms, objects, etc. + ElementMappingCache::ItemInfo* info = docImpl->underDocNamedCache().get(propertyName.qstring()); + if (info) { + //May be a false positive, but we can try to avoid doing it the hard way in + //simpler cases. The trickiness here is that the cache is kept under both + //name and id, but we sometimes ignore id for IE compat + DOM::DOMString propertyDOMString = propertyName.string(); + + if (info->nd && DOM::HTMLMappedNameCollectionImpl::matchesName(info->nd, + HTMLCollectionImpl::DOCUMENT_NAMED_ITEMS, propertyDOMString)) { + return getDOMNode(exec, info->nd); + } else { + //Can't tell it just like that, so better go through collection and count stuff. This is the slow path... + DOM::HTMLMappedNameCollection coll(docImpl, HTMLCollectionImpl::DOCUMENT_NAMED_ITEMS, propertyDOMString); + + if (coll.length() == 1) { + DOM::Node node = coll.firstItem(); + return getDOMNode(exec, node); + } else if (coll.length() > 1) { + return getHTMLCollection(exec, coll); + } + } + } + + // Check for frames/iframes with name==propertyName + if ( view && view->part() ) + { + // ###### TODO return a collection in case several frames have the same name + // (IE does that). Hard to do with findFrame :} + KHTMLPart *kp = view->part()->findFrame( propertyName.qstring() ); + if (kp) + return Window::retrieve(kp); + } + + const HashEntry* entry = Lookup::findEntry(&HTMLDocumentTable, propertyName); + if (entry) { + switch (entry->value) { + case Title: + return String(doc.title()); + case Referrer: + return String(doc.referrer()); + case Domain: + return String(doc.domain()); + case URL: + return String(doc.URL()); + case Body: + return getDOMNode(exec,doc.body()); + case Location: + if (win) + return Value(win->location()); + else + return Undefined(); + case Cookie: + return String(doc.cookie()); + case Images: + return getHTMLCollection(exec,doc.images()); + case Applets: + return getHTMLCollection(exec,doc.applets()); + case Links: + return getHTMLCollection(exec,doc.links()); + case Forms: + return getHTMLCollection(exec,doc.forms()); + case Layers: + // ### Should not be hidden when we emulate Netscape4 + return getHTMLCollection(exec,doc.layers(), true); + case Anchors: + return getHTMLCollection(exec,doc.anchors()); + case Scripts: + return getHTMLCollection(exec,doc.scripts()); + case All: + // Disable document.all when we try to be Netscape-compatible + if ( exec->interpreter()->compatMode() == Interpreter::NetscapeCompat ) + return Undefined(); + else + if ( exec->interpreter()->compatMode() == Interpreter::IECompat ) + return getHTMLCollection(exec,doc.all()); + else // enabled but hidden + return getHTMLCollection(exec,doc.all(), true); + case CompatMode: + return String(static_cast<HTMLDocumentImpl *>(doc.handle())->parseMode() + == DocumentImpl::Compat ? "BackCompat" : "CSS1Compat"); + } + } + // Look for overrides + ValueImp * val = ObjectImp::getDirect(propertyName); + if (val) + return Value(val); + + DOM::HTMLBodyElement body = doc.body(); + if (entry) { + switch (entry->value) { + case BgColor: + return String(body.bgColor()); + case FgColor: + return String(body.text()); + case AlinkColor: + return String(body.aLink()); + case LinkColor: + return String(body.link()); + case VlinkColor: + return String(body.vLink()); + case LastModified: + return String(doc.lastModified()); + case Height: // NS-only, not available in IE + return Number(view ? view->contentsHeight() : 0); + case Width: // NS-only, not available in IE + return Number(view ? view->contentsWidth() : 0); + case Dir: + return String(body.dir()); + case Frames: + if ( win ) + return Value(win->frames(exec)); + else + return Undefined(); + } + } + return DOMDocument::tryGet(exec, propertyName); +} + +void KJS::HTMLDocument::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLDocument::tryPut " << propertyName.qstring() << endl; +#endif + KHTMLView *view = static_cast<DOM::DocumentImpl*>(node.handle())->view(); + + Window* win = view && view->part() ? Window::retrieveWindow(view->part()) : 0L; + if ( !win || !win->isSafeScript(exec) ) + return; + + DOMObjectLookupPut<HTMLDocument, DOMDocument>( exec, propertyName, value, attr, &HTMLDocumentTable, this ); +} + +void KJS::HTMLDocument::putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/) +{ + DOM::HTMLDocument doc = static_cast<DOM::HTMLDocument>(node); + + DOM::HTMLBodyElement body = doc.body(); + DOM::DOMString val = value.toString(exec).string(); + + switch (token) { + case Title: + if (doc.title() != val) doc.setTitle(val); + break; + case Body: { + DOMNode *node = new DOMNode(exec, KJS::toNode(value)); + // This is required to avoid leaking the node. + Value nodeValue(node); + doc.setBody(node->toNode()); + break; + } + case Domain: { // not part of the DOM + DOM::HTMLDocumentImpl* docimpl = static_cast<DOM::HTMLDocumentImpl*>(doc.handle()); + if (docimpl) + docimpl->setDomain(val); + break; + } + case Cookie: + doc.setCookie(val); + break; + case Location: + { + KHTMLView *view = static_cast<DOM::DocumentImpl*>(doc.handle())->view(); + if ( view ) + Window::retrieveWindow(view->part())->goURL(exec, value.toString(exec).qstring(), false /*don't lock history*/); + break; + } + case BgColor: + if (body.bgColor() != val) body.setBgColor(val); + break; + case FgColor: + if (body.text() != val) body.setText(val); + break; + case AlinkColor: + if (body.aLink() != val) body.setALink(val); + break; + case LinkColor: + if (body.link() != val) body.setLink(val); + break; + case VlinkColor: + if (body.vLink() != val) body.setVLink(val); + break; + case Dir: + body.setDir(val); + break; + default: + kdDebug(6070) << "WARNING: HTMLDocument::putValueProperty unhandled token " << token << endl; + } +} + +// ------------------------------------------------------------------------- + +const ClassInfo KJS::HTMLElement::info = { "HTMLElement", &DOMElement::info, &HTMLElementTable, 0 }; +const ClassInfo KJS::HTMLElement::html_info = { "HTMLHtmlElement", &KJS::HTMLElement::info, &HTMLHtmlElementTable, 0 }; +const ClassInfo KJS::HTMLElement::head_info = { "HTMLHeadElement", &KJS::HTMLElement::info, &HTMLHeadElementTable, 0 }; +const ClassInfo KJS::HTMLElement::link_info = { "HTMLLinkElement", &KJS::HTMLElement::info, &HTMLLinkElementTable, 0 }; +const ClassInfo KJS::HTMLElement::title_info = { "HTMLTitleElement", &KJS::HTMLElement::info, &HTMLTitleElementTable, 0 }; +const ClassInfo KJS::HTMLElement::meta_info = { "HTMLMetaElement", &KJS::HTMLElement::info, &HTMLMetaElementTable, 0 }; +const ClassInfo KJS::HTMLElement::base_info = { "HTMLBaseElement", &KJS::HTMLElement::info, &HTMLBaseElementTable, 0 }; +const ClassInfo KJS::HTMLElement::isIndex_info = { "HTMLIsIndexElement", &KJS::HTMLElement::info, &HTMLIsIndexElementTable, 0 }; +const ClassInfo KJS::HTMLElement::style_info = { "HTMLStyleElement", &KJS::HTMLElement::info, &HTMLStyleElementTable, 0 }; +const ClassInfo KJS::HTMLElement::body_info = { "HTMLBodyElement", &KJS::HTMLElement::info, &HTMLBodyElementTable, 0 }; +const ClassInfo KJS::HTMLElement::form_info = { "HTMLFormElement", &KJS::HTMLElement::info, &HTMLFormElementTable, 0 }; +const ClassInfo KJS::HTMLElement::select_info = { "HTMLSelectElement", &KJS::HTMLElement::info, &HTMLSelectElementTable, 0 }; +const ClassInfo KJS::HTMLElement::optGroup_info = { "HTMLOptGroupElement", &KJS::HTMLElement::info, &HTMLOptGroupElementTable, 0 }; +const ClassInfo KJS::HTMLElement::option_info = { "HTMLOptionElement", &KJS::HTMLElement::info, &HTMLOptionElementTable, 0 }; +const ClassInfo KJS::HTMLElement::input_info = { "HTMLInputElement", &KJS::HTMLElement::info, &HTMLInputElementTable, 0 }; +const ClassInfo KJS::HTMLElement::textArea_info = { "HTMLTextAreaElement", &KJS::HTMLElement::info, &HTMLTextAreaElementTable, 0 }; +const ClassInfo KJS::HTMLElement::button_info = { "HTMLButtonElement", &KJS::HTMLElement::info, &HTMLButtonElementTable, 0 }; +const ClassInfo KJS::HTMLElement::label_info = { "HTMLLabelElement", &KJS::HTMLElement::info, &HTMLLabelElementTable, 0 }; +const ClassInfo KJS::HTMLElement::fieldSet_info = { "HTMLFieldSetElement", &KJS::HTMLElement::info, &HTMLFieldSetElementTable, 0 }; +const ClassInfo KJS::HTMLElement::legend_info = { "HTMLLegendElement", &KJS::HTMLElement::info, &HTMLLegendElementTable, 0 }; +const ClassInfo KJS::HTMLElement::ul_info = { "HTMLUListElement", &KJS::HTMLElement::info, &HTMLUListElementTable, 0 }; +const ClassInfo KJS::HTMLElement::ol_info = { "HTMLOListElement", &KJS::HTMLElement::info, &HTMLOListElementTable, 0 }; +const ClassInfo KJS::HTMLElement::dl_info = { "HTMLDListElement", &KJS::HTMLElement::info, &HTMLDListElementTable, 0 }; +const ClassInfo KJS::HTMLElement::dir_info = { "HTMLDirectoryElement", &KJS::HTMLElement::info, &HTMLDirectoryElementTable, 0 }; +const ClassInfo KJS::HTMLElement::menu_info = { "HTMLMenuElement", &KJS::HTMLElement::info, &HTMLMenuElementTable, 0 }; +const ClassInfo KJS::HTMLElement::li_info = { "HTMLLIElement", &KJS::HTMLElement::info, &HTMLLIElementTable, 0 }; +const ClassInfo KJS::HTMLElement::div_info = { "HTMLDivElement", &KJS::HTMLElement::info, &HTMLDivElementTable, 0 }; +const ClassInfo KJS::HTMLElement::p_info = { "HTMLParagraphElement", &KJS::HTMLElement::info, &HTMLParagraphElementTable, 0 }; +const ClassInfo KJS::HTMLElement::heading_info = { "HTMLHeadingElement", &KJS::HTMLElement::info, &HTMLHeadingElementTable, 0 }; +const ClassInfo KJS::HTMLElement::blockQuote_info = { "HTMLBlockQuoteElement", &KJS::HTMLElement::info, &HTMLBlockQuoteElementTable, 0 }; +const ClassInfo KJS::HTMLElement::q_info = { "HTMLQuoteElement", &KJS::HTMLElement::info, &HTMLQuoteElementTable, 0 }; +const ClassInfo KJS::HTMLElement::pre_info = { "HTMLPreElement", &KJS::HTMLElement::info, &HTMLPreElementTable, 0 }; +const ClassInfo KJS::HTMLElement::br_info = { "HTMLBRElement", &KJS::HTMLElement::info, &HTMLBRElementTable, 0 }; +const ClassInfo KJS::HTMLElement::baseFont_info = { "HTMLBaseFontElement", &KJS::HTMLElement::info, &HTMLBaseFontElementTable, 0 }; +const ClassInfo KJS::HTMLElement::font_info = { "HTMLFontElement", &KJS::HTMLElement::info, &HTMLFontElementTable, 0 }; +const ClassInfo KJS::HTMLElement::hr_info = { "HTMLHRElement", &KJS::HTMLElement::info, &HTMLHRElementTable, 0 }; +const ClassInfo KJS::HTMLElement::mod_info = { "HTMLModElement", &KJS::HTMLElement::info, &HTMLModElementTable, 0 }; +const ClassInfo KJS::HTMLElement::a_info = { "HTMLAnchorElement", &KJS::HTMLElement::info, &HTMLAnchorElementTable, 0 }; +const ClassInfo KJS::HTMLElement::img_info = { "HTMLImageElement", &KJS::HTMLElement::info, &HTMLImageElementTable, 0 }; +const ClassInfo KJS::HTMLElement::object_info = { "HTMLObjectElement", &KJS::HTMLElement::info, &HTMLObjectElementTable, 0 }; +const ClassInfo KJS::HTMLElement::param_info = { "HTMLParamElement", &KJS::HTMLElement::info, &HTMLParamElementTable, 0 }; +const ClassInfo KJS::HTMLElement::applet_info = { "HTMLAppletElement", &KJS::HTMLElement::info, &HTMLAppletElementTable, 0 }; +const ClassInfo KJS::HTMLElement::map_info = { "HTMLMapElement", &KJS::HTMLElement::info, &HTMLMapElementTable, 0 }; +const ClassInfo KJS::HTMLElement::area_info = { "HTMLAreaElement", &KJS::HTMLElement::info, &HTMLAreaElementTable, 0 }; +const ClassInfo KJS::HTMLElement::script_info = { "HTMLScriptElement", &KJS::HTMLElement::info, &HTMLScriptElementTable, 0 }; +const ClassInfo KJS::HTMLElement::table_info = { "HTMLTableElement", &KJS::HTMLElement::info, &HTMLTableElementTable, 0 }; +const ClassInfo KJS::HTMLElement::caption_info = { "HTMLTableCaptionElement", &KJS::HTMLElement::info, &HTMLTableCaptionElementTable, 0 }; +const ClassInfo KJS::HTMLElement::col_info = { "HTMLTableColElement", &KJS::HTMLElement::info, &HTMLTableColElementTable, 0 }; +const ClassInfo KJS::HTMLElement::tablesection_info = { "HTMLTableSectionElement", &KJS::HTMLElement::info, &HTMLTableSectionElementTable, 0 }; +const ClassInfo KJS::HTMLElement::tr_info = { "HTMLTableRowElement", &KJS::HTMLElement::info, &HTMLTableRowElementTable, 0 }; +const ClassInfo KJS::HTMLElement::tablecell_info = { "HTMLTableCellElement", &KJS::HTMLElement::info, &HTMLTableCellElementTable, 0 }; +const ClassInfo KJS::HTMLElement::frameSet_info = { "HTMLFrameSetElement", &KJS::HTMLElement::info, &HTMLFrameSetElementTable, 0 }; +const ClassInfo KJS::HTMLElement::frame_info = { "HTMLFrameElement", &KJS::HTMLElement::info, &HTMLFrameElementTable, 0 }; +const ClassInfo KJS::HTMLElement::iFrame_info = { "HTMLIFrameElement", &KJS::HTMLElement::info, &HTMLIFrameElementTable, 0 }; +const ClassInfo KJS::HTMLElement::marquee_info = { "HTMLMarqueeElement", &KJS::HTMLElement::info, 0, 0 }; +const ClassInfo KJS::HTMLElement::layer_info = { "HTMLLayerElement", &KJS::HTMLElement::info, &HTMLLayerElementTable, 0 }; + +static Object prototypeForID(ExecState* exec, DOM::NodeImpl::Id id); + +KJS::HTMLElement::HTMLElement(ExecState *exec, const DOM::HTMLElement& e) : + DOMElement(prototypeForID(exec, e.elementId()), e) { } + +const ClassInfo* KJS::HTMLElement::classInfo() const +{ + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); + switch (element.elementId()) { + case ID_HTML: + return &html_info; + case ID_HEAD: + return &head_info; + case ID_LINK: + return &link_info; + case ID_TITLE: + return &title_info; + case ID_META: + return &meta_info; + case ID_BASE: + return &base_info; + case ID_ISINDEX: + return &isIndex_info; + case ID_STYLE: + return &style_info; + case ID_BODY: + return &body_info; + case ID_FORM: + return &form_info; + case ID_SELECT: + return &select_info; + case ID_OPTGROUP: + return &optGroup_info; + case ID_OPTION: + return &option_info; + case ID_INPUT: + return &input_info; + case ID_TEXTAREA: + return &textArea_info; + case ID_BUTTON: + return &button_info; + case ID_LABEL: + return &label_info; + case ID_FIELDSET: + return &fieldSet_info; + case ID_LEGEND: + return &legend_info; + case ID_UL: + return &ul_info; + case ID_OL: + return &ol_info; + case ID_DL: + return &dl_info; + case ID_DIR: + return &dir_info; + case ID_MENU: + return &menu_info; + case ID_LI: + return &li_info; + case ID_DIV: + return &div_info; + case ID_P: + return &p_info; + case ID_H1: + case ID_H2: + case ID_H3: + case ID_H4: + case ID_H5: + case ID_H6: + return &heading_info; + case ID_BLOCKQUOTE: + return &blockQuote_info; + case ID_Q: + return &q_info; + case ID_PRE: + return &pre_info; + case ID_BR: + return &br_info; + case ID_BASEFONT: + return &baseFont_info; + case ID_FONT: + return &font_info; + case ID_HR: + return &hr_info; + case ID_INS: + case ID_DEL: + return &mod_info; + case ID_A: + return &a_info; + case ID_IMG: + return &img_info; + case ID_OBJECT: + return &object_info; + case ID_PARAM: + return ¶m_info; + case ID_APPLET: + return &applet_info; + case ID_MAP: + return &map_info; + case ID_AREA: + return &area_info; + case ID_SCRIPT: + return &script_info; + case ID_TABLE: + return &table_info; + case ID_CAPTION: + return &caption_info; + case ID_COL: + case ID_COLGROUP: + return &col_info; + case ID_THEAD: + case ID_TBODY: + case ID_TFOOT: + return &tablesection_info; + case ID_TR: + return &tr_info; + case ID_TH: + case ID_TD: + return &tablecell_info; + case ID_FRAMESET: + return &frameSet_info; + case ID_FRAME: + return &frame_info; + case ID_IFRAME: + return &iFrame_info; + case ID_MARQUEE: + return &marquee_info; + case ID_LAYER: + return &layer_info; + default: + return &info; + } +} +/* +@begin HTMLElementTable 11 + id KJS::HTMLElement::ElementId DontDelete + title KJS::HTMLElement::ElementTitle DontDelete + lang KJS::HTMLElement::ElementLang DontDelete + dir KJS::HTMLElement::ElementDir DontDelete +### isn't this "class" in the HTML spec? + className KJS::HTMLElement::ElementClassName DontDelete + innerHTML KJS::HTMLElement::ElementInnerHTML DontDelete + innerText KJS::HTMLElement::ElementInnerText DontDelete + document KJS::HTMLElement::ElementDocument DontDelete|ReadOnly +# IE extension + children KJS::HTMLElement::ElementChildren DontDelete|ReadOnly + all KJS::HTMLElement::ElementAll DontDelete|ReadOnly +@end +@begin HTMLElementProtoTable 1 + scrollIntoView KJS::HTMLElement::ElementScrollIntoView DontDelete|Function 0 +@end +@begin HTMLHtmlElementTable 1 + version KJS::HTMLElement::HtmlVersion DontDelete +@end +@begin HTMLHeadElementTable 1 + profile KJS::HTMLElement::HeadProfile DontDelete +@end +@begin HTMLLinkElementTable 11 + disabled KJS::HTMLElement::LinkDisabled DontDelete + charset KJS::HTMLElement::LinkCharset DontDelete + href KJS::HTMLElement::LinkHref DontDelete + hreflang KJS::HTMLElement::LinkHrefLang DontDelete + media KJS::HTMLElement::LinkMedia DontDelete + rel KJS::HTMLElement::LinkRel DontDelete + rev KJS::HTMLElement::LinkRev DontDelete + target KJS::HTMLElement::LinkTarget DontDelete + type KJS::HTMLElement::LinkType DontDelete + sheet KJS::HTMLElement::LinkSheet DontDelete|ReadOnly +@end +@begin HTMLTitleElementTable 1 + text KJS::HTMLElement::TitleText DontDelete +@end +@begin HTMLMetaElementTable 4 + content KJS::HTMLElement::MetaContent DontDelete + httpEquiv KJS::HTMLElement::MetaHttpEquiv DontDelete + name KJS::HTMLElement::MetaName DontDelete + scheme KJS::HTMLElement::MetaScheme DontDelete +@end +@begin HTMLBaseElementTable 2 + href KJS::HTMLElement::BaseHref DontDelete + target KJS::HTMLElement::BaseTarget DontDelete +@end +@begin HTMLIsIndexElementTable 2 + form KJS::HTMLElement::IsIndexForm DontDelete|ReadOnly + prompt KJS::HTMLElement::IsIndexPrompt DontDelete +@end +@begin HTMLStyleElementTable 4 + disabled KJS::HTMLElement::StyleDisabled DontDelete + media KJS::HTMLElement::StyleMedia DontDelete + type KJS::HTMLElement::StyleType DontDelete + sheet KJS::HTMLElement::StyleSheet DontDelete|ReadOnly +@end +@begin HTMLBodyElementTable 8 + aLink KJS::HTMLElement::BodyALink DontDelete + background KJS::HTMLElement::BodyBackground DontDelete + bgColor KJS::HTMLElement::BodyBgColor DontDelete + link KJS::HTMLElement::BodyLink DontDelete + text KJS::HTMLElement::BodyText DontDelete + vLink KJS::HTMLElement::BodyVLink DontDelete +# IE extension + onload KJS::HTMLElement::BodyOnLoad DontDelete +@end +@begin HTMLBodyElementProtoTable 2 +# Mozilla'ish extension. Ideally we would want to support this on all elements. +# Not hard, but not an immediate need. + focus KJS::HTMLElement::BodyFocus DontDelete|Function 0 +@end +@begin HTMLFormElementTable 11 +# Also supported, by name/index + elements KJS::HTMLElement::FormElements DontDelete|ReadOnly + length KJS::HTMLElement::FormLength DontDelete|ReadOnly + name KJS::HTMLElement::FormName DontDelete + acceptCharset KJS::HTMLElement::FormAcceptCharset DontDelete + action KJS::HTMLElement::FormAction DontDelete + encoding KJS::HTMLElement::FormEncType DontDelete + enctype KJS::HTMLElement::FormEncType DontDelete + method KJS::HTMLElement::FormMethod DontDelete + target KJS::HTMLElement::FormTarget DontDelete +@end +@begin HTMLFormElementProtoTable 2 + submit KJS::HTMLElement::FormSubmit DontDelete|Function 0 + reset KJS::HTMLElement::FormReset DontDelete|Function 0 +@end +@begin HTMLSelectElementTable 11 +# Also supported, by index + type KJS::HTMLElement::SelectType DontDelete|ReadOnly + selectedIndex KJS::HTMLElement::SelectSelectedIndex DontDelete + value KJS::HTMLElement::SelectValue DontDelete + length KJS::HTMLElement::SelectLength DontDelete + form KJS::HTMLElement::SelectForm DontDelete|ReadOnly + options KJS::HTMLElement::SelectOptions DontDelete|ReadOnly + disabled KJS::HTMLElement::SelectDisabled DontDelete + multiple KJS::HTMLElement::SelectMultiple DontDelete + name KJS::HTMLElement::SelectName DontDelete + size KJS::HTMLElement::SelectSize DontDelete + tabIndex KJS::HTMLElement::SelectTabIndex DontDelete +@end +@begin HTMLSelectElementProtoTable 4 + add KJS::HTMLElement::SelectAdd DontDelete|Function 2 + remove KJS::HTMLElement::SelectRemove DontDelete|Function 1 + blur KJS::HTMLElement::SelectBlur DontDelete|Function 0 + focus KJS::HTMLElement::SelectFocus DontDelete|Function 0 +@end +@begin HTMLOptGroupElementTable 2 + disabled KJS::HTMLElement::OptGroupDisabled DontDelete + label KJS::HTMLElement::OptGroupLabel DontDelete +@end +@begin HTMLOptionElementTable 8 + form KJS::HTMLElement::OptionForm DontDelete|ReadOnly + defaultSelected KJS::HTMLElement::OptionDefaultSelected DontDelete + text KJS::HTMLElement::OptionText DontDelete + index KJS::HTMLElement::OptionIndex DontDelete|ReadOnly + disabled KJS::HTMLElement::OptionDisabled DontDelete + label KJS::HTMLElement::OptionLabel DontDelete + selected KJS::HTMLElement::OptionSelected DontDelete + value KJS::HTMLElement::OptionValue DontDelete +@end +@begin HTMLInputElementTable 25 + defaultValue KJS::HTMLElement::InputDefaultValue DontDelete + defaultChecked KJS::HTMLElement::InputDefaultChecked DontDelete + form KJS::HTMLElement::InputForm DontDelete|ReadOnly + accept KJS::HTMLElement::InputAccept DontDelete + accessKey KJS::HTMLElement::InputAccessKey DontDelete + align KJS::HTMLElement::InputAlign DontDelete + alt KJS::HTMLElement::InputAlt DontDelete + checked KJS::HTMLElement::InputChecked DontDelete + indeterminate KJS::HTMLElement::InputIndeterminate DontDelete + status KJS::HTMLElement::InputChecked DontDelete + disabled KJS::HTMLElement::InputDisabled DontDelete + maxLength KJS::HTMLElement::InputMaxLength DontDelete + name KJS::HTMLElement::InputName DontDelete + readOnly KJS::HTMLElement::InputReadOnly DontDelete + size KJS::HTMLElement::InputSize DontDelete + src KJS::HTMLElement::InputSrc DontDelete + tabIndex KJS::HTMLElement::InputTabIndex DontDelete + type KJS::HTMLElement::InputType DontDelete + useMap KJS::HTMLElement::InputUseMap DontDelete + value KJS::HTMLElement::InputValue DontDelete + selectionStart KJS::HTMLElement::InputSelectionStart DontDelete + selectionEnd KJS::HTMLElement::InputSelectionEnd DontDelete +@end +@begin HTMLInputElementProtoTable 5 + blur KJS::HTMLElement::InputBlur DontDelete|Function 0 + focus KJS::HTMLElement::InputFocus DontDelete|Function 0 + select KJS::HTMLElement::InputSelect DontDelete|Function 0 + click KJS::HTMLElement::InputClick DontDelete|Function 0 + setSelectionRange KJS::HTMLElement::InputSetSelectionRange DontDelete|Function 2 +@end +@begin HTMLTextAreaElementTable 13 + defaultValue KJS::HTMLElement::TextAreaDefaultValue DontDelete + form KJS::HTMLElement::TextAreaForm DontDelete|ReadOnly + accessKey KJS::HTMLElement::TextAreaAccessKey DontDelete + cols KJS::HTMLElement::TextAreaCols DontDelete + disabled KJS::HTMLElement::TextAreaDisabled DontDelete + name KJS::HTMLElement::TextAreaName DontDelete + readOnly KJS::HTMLElement::TextAreaReadOnly DontDelete + rows KJS::HTMLElement::TextAreaRows DontDelete + tabIndex KJS::HTMLElement::TextAreaTabIndex DontDelete + type KJS::HTMLElement::TextAreaType DontDelete|ReadOnly + value KJS::HTMLElement::TextAreaValue DontDelete + selectionStart KJS::HTMLElement::TextAreaSelectionStart DontDelete + selectionEnd KJS::HTMLElement::TextAreaSelectionEnd DontDelete + textLength KJS::HTMLElement::TextAreaTextLength DontDelete|ReadOnly +@end +@begin HTMLTextAreaElementProtoTable 4 + blur KJS::HTMLElement::TextAreaBlur DontDelete|Function 0 + focus KJS::HTMLElement::TextAreaFocus DontDelete|Function 0 + select KJS::HTMLElement::TextAreaSelect DontDelete|Function 0 + setSelectionRange KJS::HTMLElement::TextAreaSetSelectionRange DontDelete|Function 2 +@end +@begin HTMLButtonElementTable 9 + form KJS::HTMLElement::ButtonForm DontDelete|ReadOnly + accessKey KJS::HTMLElement::ButtonAccessKey DontDelete + disabled KJS::HTMLElement::ButtonDisabled DontDelete + name KJS::HTMLElement::ButtonName DontDelete + tabIndex KJS::HTMLElement::ButtonTabIndex DontDelete + type KJS::HTMLElement::ButtonType DontDelete|ReadOnly + value KJS::HTMLElement::ButtonValue DontDelete +@end +@begin HTMLButtonElementProtoTable 2 + blur KJS::HTMLElement::ButtonBlur DontDelete|Function 0 + focus KJS::HTMLElement::ButtonFocus DontDelete|Function 0 +@end +@begin HTMLLabelElementTable 3 + form KJS::HTMLElement::LabelForm DontDelete|ReadOnly + accessKey KJS::HTMLElement::LabelAccessKey DontDelete + htmlFor KJS::HTMLElement::LabelHtmlFor DontDelete +@end +@begin HTMLFieldSetElementTable 1 + form KJS::HTMLElement::FieldSetForm DontDelete|ReadOnly +@end +@begin HTMLLegendElementTable 3 + form KJS::HTMLElement::LegendForm DontDelete|ReadOnly + accessKey KJS::HTMLElement::LegendAccessKey DontDelete + align KJS::HTMLElement::LegendAlign DontDelete +@end +@begin HTMLUListElementTable 2 + compact KJS::HTMLElement::UListCompact DontDelete + type KJS::HTMLElement::UListType DontDelete +@end +@begin HTMLOListElementTable 3 + compact KJS::HTMLElement::OListCompact DontDelete + start KJS::HTMLElement::OListStart DontDelete + type KJS::HTMLElement::OListType DontDelete +@end +@begin HTMLDListElementTable 1 + compact KJS::HTMLElement::DListCompact DontDelete +@end +@begin HTMLDirectoryElementTable 1 + compact KJS::HTMLElement::DirectoryCompact DontDelete +@end +@begin HTMLMenuElementTable 1 + compact KJS::HTMLElement::MenuCompact DontDelete +@end +@begin HTMLLIElementTable 2 + type KJS::HTMLElement::LIType DontDelete + value KJS::HTMLElement::LIValue DontDelete +@end +@begin HTMLDivElementTable 1 + align KJS::HTMLElement::DivAlign DontDelete +@end +@begin HTMLParagraphElementTable 1 + align KJS::HTMLElement::ParagraphAlign DontDelete +@end +@begin HTMLHeadingElementTable 1 + align KJS::HTMLElement::HeadingAlign DontDelete +@end +@begin HTMLBlockQuoteElementTable 1 + cite KJS::HTMLElement::BlockQuoteCite DontDelete +@end +@begin HTMLQuoteElementTable 1 + cite KJS::HTMLElement::QuoteCite DontDelete +@end +@begin HTMLPreElementTable 1 + width KJS::HTMLElement::PreWidth DontDelete +@end +@begin HTMLBRElementTable 1 + clear KJS::HTMLElement::BRClear DontDelete +@end +@begin HTMLBaseFontElementTable 3 + color KJS::HTMLElement::BaseFontColor DontDelete + face KJS::HTMLElement::BaseFontFace DontDelete + size KJS::HTMLElement::BaseFontSize DontDelete +@end +@begin HTMLFontElementTable 3 + color KJS::HTMLElement::FontColor DontDelete + face KJS::HTMLElement::FontFace DontDelete + size KJS::HTMLElement::FontSize DontDelete +@end +@begin HTMLHRElementTable 4 + align KJS::HTMLElement::HRAlign DontDelete + noShade KJS::HTMLElement::HRNoShade DontDelete + size KJS::HTMLElement::HRSize DontDelete + width KJS::HTMLElement::HRWidth DontDelete +@end +@begin HTMLModElementTable 2 + cite KJS::HTMLElement::ModCite DontDelete + dateTime KJS::HTMLElement::ModDateTime DontDelete +@end +@begin HTMLAnchorElementTable 23 + accessKey KJS::HTMLElement::AnchorAccessKey DontDelete + charset KJS::HTMLElement::AnchorCharset DontDelete + coords KJS::HTMLElement::AnchorCoords DontDelete + href KJS::HTMLElement::AnchorHref DontDelete + hreflang KJS::HTMLElement::AnchorHrefLang DontDelete + hash KJS::HTMLElement::AnchorHash DontDelete|ReadOnly + host KJS::HTMLElement::AnchorHost DontDelete|ReadOnly + hostname KJS::HTMLElement::AnchorHostname DontDelete|ReadOnly + name KJS::HTMLElement::AnchorName DontDelete + pathname KJS::HTMLElement::AnchorPathName DontDelete|ReadOnly + port KJS::HTMLElement::AnchorPort DontDelete|ReadOnly + protocol KJS::HTMLElement::AnchorProtocol DontDelete|ReadOnly + rel KJS::HTMLElement::AnchorRel DontDelete + rev KJS::HTMLElement::AnchorRev DontDelete + search KJS::HTMLElement::AnchorSearch DontDelete + shape KJS::HTMLElement::AnchorShape DontDelete + tabIndex KJS::HTMLElement::AnchorTabIndex DontDelete + target KJS::HTMLElement::AnchorTarget DontDelete + text KJS::HTMLElement::AnchorText DontDelete|ReadOnly + type KJS::HTMLElement::AnchorType DontDelete +@end +@begin HTMLAnchorElementProtoTable 3 + blur KJS::HTMLElement::AnchorBlur DontDelete|Function 0 + focus KJS::HTMLElement::AnchorFocus DontDelete|Function 0 + click KJS::HTMLElement::AnchorClick DontDelete|Function 0 +@end +@begin HTMLImageElementTable 15 + name KJS::HTMLElement::ImageName DontDelete + align KJS::HTMLElement::ImageAlign DontDelete + alt KJS::HTMLElement::ImageAlt DontDelete + border KJS::HTMLElement::ImageBorder DontDelete + complete KJS::HTMLElement::ImageComplete DontDelete|ReadOnly + height KJS::HTMLElement::ImageHeight DontDelete + hspace KJS::HTMLElement::ImageHspace DontDelete + isMap KJS::HTMLElement::ImageIsMap DontDelete + longDesc KJS::HTMLElement::ImageLongDesc DontDelete + src KJS::HTMLElement::ImageSrc DontDelete + useMap KJS::HTMLElement::ImageUseMap DontDelete + vspace KJS::HTMLElement::ImageVspace DontDelete + width KJS::HTMLElement::ImageWidth DontDelete + x KJS::HTMLElement::ImageX DontDelete|ReadOnly + y KJS::HTMLElement::ImageY DontDelete|ReadOnly +@end +@begin HTMLObjectElementTable 20 + form KJS::HTMLElement::ObjectForm DontDelete|ReadOnly + code KJS::HTMLElement::ObjectCode DontDelete + align KJS::HTMLElement::ObjectAlign DontDelete + archive KJS::HTMLElement::ObjectArchive DontDelete + border KJS::HTMLElement::ObjectBorder DontDelete + codeBase KJS::HTMLElement::ObjectCodeBase DontDelete + codeType KJS::HTMLElement::ObjectCodeType DontDelete + contentDocument KJS::HTMLElement::ObjectContentDocument DontDelete|ReadOnly + data KJS::HTMLElement::ObjectData DontDelete + declare KJS::HTMLElement::ObjectDeclare DontDelete + height KJS::HTMLElement::ObjectHeight DontDelete + hspace KJS::HTMLElement::ObjectHspace DontDelete + name KJS::HTMLElement::ObjectName DontDelete + standby KJS::HTMLElement::ObjectStandby DontDelete + tabIndex KJS::HTMLElement::ObjectTabIndex DontDelete + type KJS::HTMLElement::ObjectType DontDelete + useMap KJS::HTMLElement::ObjectUseMap DontDelete + vspace KJS::HTMLElement::ObjectVspace DontDelete + width KJS::HTMLElement::ObjectWidth DontDelete +@end +@begin HTMLParamElementTable 4 + name KJS::HTMLElement::ParamName DontDelete + type KJS::HTMLElement::ParamType DontDelete + value KJS::HTMLElement::ParamValue DontDelete + valueType KJS::HTMLElement::ParamValueType DontDelete +@end +@begin HTMLAppletElementTable 11 + align KJS::HTMLElement::AppletAlign DontDelete + alt KJS::HTMLElement::AppletAlt DontDelete + archive KJS::HTMLElement::AppletArchive DontDelete + code KJS::HTMLElement::AppletCode DontDelete + codeBase KJS::HTMLElement::AppletCodeBase DontDelete + height KJS::HTMLElement::AppletHeight DontDelete + hspace KJS::HTMLElement::AppletHspace DontDelete + name KJS::HTMLElement::AppletName DontDelete + object KJS::HTMLElement::AppletObject DontDelete + vspace KJS::HTMLElement::AppletVspace DontDelete + width KJS::HTMLElement::AppletWidth DontDelete +@end +@begin HTMLMapElementTable 2 + areas KJS::HTMLElement::MapAreas DontDelete|ReadOnly + name KJS::HTMLElement::MapName DontDelete +@end +@begin HTMLAreaElementTable 15 + accessKey KJS::HTMLElement::AreaAccessKey DontDelete + alt KJS::HTMLElement::AreaAlt DontDelete + coords KJS::HTMLElement::AreaCoords DontDelete + href KJS::HTMLElement::AreaHref DontDelete + hash KJS::HTMLElement::AreaHash DontDelete|ReadOnly + host KJS::HTMLElement::AreaHost DontDelete|ReadOnly + hostname KJS::HTMLElement::AreaHostName DontDelete|ReadOnly + pathname KJS::HTMLElement::AreaPathName DontDelete|ReadOnly + port KJS::HTMLElement::AreaPort DontDelete|ReadOnly + protocol KJS::HTMLElement::AreaProtocol DontDelete|ReadOnly + search KJS::HTMLElement::AreaSearch DontDelete|ReadOnly + noHref KJS::HTMLElement::AreaNoHref DontDelete + shape KJS::HTMLElement::AreaShape DontDelete + tabIndex KJS::HTMLElement::AreaTabIndex DontDelete + target KJS::HTMLElement::AreaTarget DontDelete +@end +@begin HTMLScriptElementTable 7 + text KJS::HTMLElement::ScriptText DontDelete + htmlFor KJS::HTMLElement::ScriptHtmlFor DontDelete + event KJS::HTMLElement::ScriptEvent DontDelete + charset KJS::HTMLElement::ScriptCharset DontDelete + defer KJS::HTMLElement::ScriptDefer DontDelete + src KJS::HTMLElement::ScriptSrc DontDelete + type KJS::HTMLElement::ScriptType DontDelete +@end +@begin HTMLTableElementTable 23 + caption KJS::HTMLElement::TableCaption DontDelete + tHead KJS::HTMLElement::TableTHead DontDelete + tFoot KJS::HTMLElement::TableTFoot DontDelete + rows KJS::HTMLElement::TableRows DontDelete|ReadOnly + tBodies KJS::HTMLElement::TableTBodies DontDelete|ReadOnly + align KJS::HTMLElement::TableAlign DontDelete + bgColor KJS::HTMLElement::TableBgColor DontDelete + border KJS::HTMLElement::TableBorder DontDelete + cellPadding KJS::HTMLElement::TableCellPadding DontDelete + cellSpacing KJS::HTMLElement::TableCellSpacing DontDelete + frame KJS::HTMLElement::TableFrame DontDelete + rules KJS::HTMLElement::TableRules DontDelete + summary KJS::HTMLElement::TableSummary DontDelete + width KJS::HTMLElement::TableWidth DontDelete +@end +@begin HTMLTableElementProtoTable 8 + createTHead KJS::HTMLElement::TableCreateTHead DontDelete|Function 0 + deleteTHead KJS::HTMLElement::TableDeleteTHead DontDelete|Function 0 + createTFoot KJS::HTMLElement::TableCreateTFoot DontDelete|Function 0 + deleteTFoot KJS::HTMLElement::TableDeleteTFoot DontDelete|Function 0 + createCaption KJS::HTMLElement::TableCreateCaption DontDelete|Function 0 + deleteCaption KJS::HTMLElement::TableDeleteCaption DontDelete|Function 0 + insertRow KJS::HTMLElement::TableInsertRow DontDelete|Function 1 + deleteRow KJS::HTMLElement::TableDeleteRow DontDelete|Function 1 +@end +@begin HTMLTableCaptionElementTable 1 + align KJS::HTMLElement::TableCaptionAlign DontDelete +@end +@begin HTMLTableColElementTable 7 + align KJS::HTMLElement::TableColAlign DontDelete + ch KJS::HTMLElement::TableColCh DontDelete + chOff KJS::HTMLElement::TableColChOff DontDelete + span KJS::HTMLElement::TableColSpan DontDelete + vAlign KJS::HTMLElement::TableColVAlign DontDelete + width KJS::HTMLElement::TableColWidth DontDelete +@end +@begin HTMLTableSectionElementTable 7 + align KJS::HTMLElement::TableSectionAlign DontDelete + ch KJS::HTMLElement::TableSectionCh DontDelete + chOff KJS::HTMLElement::TableSectionChOff DontDelete + vAlign KJS::HTMLElement::TableSectionVAlign DontDelete + rows KJS::HTMLElement::TableSectionRows DontDelete|ReadOnly +@end +@begin HTMLTableSectionElementProtoTable 2 + insertRow KJS::HTMLElement::TableSectionInsertRow DontDelete|Function 1 + deleteRow KJS::HTMLElement::TableSectionDeleteRow DontDelete|Function 1 +@end +@begin HTMLTableRowElementTable 11 + rowIndex KJS::HTMLElement::TableRowRowIndex DontDelete|ReadOnly + sectionRowIndex KJS::HTMLElement::TableRowSectionRowIndex DontDelete|ReadOnly + cells KJS::HTMLElement::TableRowCells DontDelete|ReadOnly + align KJS::HTMLElement::TableRowAlign DontDelete + bgColor KJS::HTMLElement::TableRowBgColor DontDelete + ch KJS::HTMLElement::TableRowCh DontDelete + chOff KJS::HTMLElement::TableRowChOff DontDelete + vAlign KJS::HTMLElement::TableRowVAlign DontDelete +@end +@begin HTMLTableRowElementProtoTable 2 + insertCell KJS::HTMLElement::TableRowInsertCell DontDelete|Function 1 + deleteCell KJS::HTMLElement::TableRowDeleteCell DontDelete|Function 1 +@end +@begin HTMLTableCellElementTable 15 + cellIndex KJS::HTMLElement::TableCellCellIndex DontDelete|ReadOnly + abbr KJS::HTMLElement::TableCellAbbr DontDelete + align KJS::HTMLElement::TableCellAlign DontDelete + axis KJS::HTMLElement::TableCellAxis DontDelete + bgColor KJS::HTMLElement::TableCellBgColor DontDelete + ch KJS::HTMLElement::TableCellCh DontDelete + chOff KJS::HTMLElement::TableCellChOff DontDelete + colSpan KJS::HTMLElement::TableCellColSpan DontDelete + headers KJS::HTMLElement::TableCellHeaders DontDelete + height KJS::HTMLElement::TableCellHeight DontDelete + noWrap KJS::HTMLElement::TableCellNoWrap DontDelete + rowSpan KJS::HTMLElement::TableCellRowSpan DontDelete + scope KJS::HTMLElement::TableCellScope DontDelete + vAlign KJS::HTMLElement::TableCellVAlign DontDelete + width KJS::HTMLElement::TableCellWidth DontDelete +@end +@begin HTMLFrameSetElementTable 2 + cols KJS::HTMLElement::FrameSetCols DontDelete + rows KJS::HTMLElement::FrameSetRows DontDelete +@end +@begin HTMLLayerElementTable 6 + top KJS::HTMLElement::LayerTop DontDelete + left KJS::HTMLElement::LayerLeft DontDelete + visibility KJS::HTMLElement::LayerVisibility DontDelete + bgColor KJS::HTMLElement::LayerBgColor DontDelete + document KJS::HTMLElement::LayerDocument DontDelete|ReadOnly + clip KJS::HTMLElement::LayerClip DontDelete|ReadOnly + layers KJS::HTMLElement::LayerLayers DontDelete|ReadOnly +@end +@begin HTMLFrameElementTable 13 + contentDocument KJS::HTMLElement::FrameContentDocument DontDelete|ReadOnly + contentWindow KJS::HTMLElement::FrameContentWindow DontDelete|ReadOnly + frameBorder KJS::HTMLElement::FrameFrameBorder DontDelete + longDesc KJS::HTMLElement::FrameLongDesc DontDelete + marginHeight KJS::HTMLElement::FrameMarginHeight DontDelete + marginWidth KJS::HTMLElement::FrameMarginWidth DontDelete + name KJS::HTMLElement::FrameName DontDelete + noResize KJS::HTMLElement::FrameNoResize DontDelete + scrolling KJS::HTMLElement::FrameScrolling DontDelete + src KJS::HTMLElement::FrameSrc DontDelete + location KJS::HTMLElement::FrameLocation DontDelete +# IE extension + width KJS::HTMLElement::FrameWidth DontDelete|ReadOnly + height KJS::HTMLElement::FrameHeight DontDelete|ReadOnly +@end +@begin HTMLIFrameElementTable 12 + align KJS::HTMLElement::IFrameAlign DontDelete + contentDocument KJS::HTMLElement::IFrameContentDocument DontDelete|ReadOnly + contentWindow KJS::HTMLElement::IFrameContentWindow DontDelete|ReadOnly + frameBorder KJS::HTMLElement::IFrameFrameBorder DontDelete + height KJS::HTMLElement::IFrameHeight DontDelete + longDesc KJS::HTMLElement::IFrameLongDesc DontDelete + marginHeight KJS::HTMLElement::IFrameMarginHeight DontDelete + marginWidth KJS::HTMLElement::IFrameMarginWidth DontDelete + name KJS::HTMLElement::IFrameName DontDelete + scrolling KJS::HTMLElement::IFrameScrolling DontDelete + src KJS::HTMLElement::IFrameSrc DontDelete + width KJS::HTMLElement::IFrameWidth DontDelete +@end + +@begin HTMLMarqueeElementProtoTable 2 + start KJS::HTMLElement::MarqueeStart DontDelete|Function 0 + stop KJS::HTMLElement::MarqueeStop DontDelete|Function 0 +@end + +*/ + +static KParts::LiveConnectExtension *getLiveConnectExtension(const DOM::HTMLElement & element) +{ + DOM::HTMLDocument doc = element.ownerDocument(); + KHTMLView *view = static_cast<DOM::DocumentImpl*>(doc.handle())->view(); + if (view && element.handle()) + return view->part()->liveConnectExtension(static_cast<tdehtml::RenderPart*>(element.handle()->renderer())); + return 0L; +} + +Value KJS::HTMLElement::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLElement::tryGet " << propertyName.qstring() << " thisTag=" << element.tagName().string() << endl; +#endif + // First look at dynamic properties + switch (element.elementId()) { + case ID_FORM: { + DOM::HTMLFormElement form = element; + // Check if we're retrieving an element (by index or by name) + bool ok; + uint u = propertyName.toULong(&ok); + + if (ok) + return getDOMNode(exec,form.elements().item(u)); + KJS::HTMLCollection coll(exec, form.elements()); + Value namedItems = coll.getNamedItems(exec, propertyName); + if (namedItems.type() != UndefinedType) + return namedItems; + } + break; + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + bool ok; + uint u = propertyName.toULong(&ok); + if (ok) + return getDOMNode(exec,select.options().item(u)); // not specified by DOM(?) but supported in netscape/IE + } + break; + case ID_APPLET: + case ID_OBJECT: + case ID_EMBED: { + KParts::LiveConnectExtension *lc = getLiveConnectExtension(element); + TQString rvalue; + KParts::LiveConnectExtension::Type rtype; + unsigned long robjid; + if (lc && lc->get(0, propertyName.qstring(), rtype, robjid, rvalue)) + return getLiveConnectValue(lc, propertyName.qstring(), rtype, rvalue, robjid); + } + break; + default: + break; + } + + const HashTable* table = classInfo()->propHashTable; // get the right hashtable + const HashEntry* entry = table ? Lookup::findEntry(table, propertyName) : 0; + if (entry) { + if (entry->attr & Function) + return lookupOrCreateFunction<KJS::HTMLElementFunction>(exec, propertyName, this, entry->value, entry->params, entry->attr); + return getValueProperty(exec, entry->value); + } + + // Base HTMLElement stuff or parent class forward, as usual + return DOMObjectLookupGet<KJS::HTMLElementFunction, KJS::HTMLElement, DOMElement>(exec, propertyName, &KJS::HTMLElementTable, this); +} + +Value KJS::HTMLElement::getValueProperty(ExecState *exec, int token) const +{ + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); + switch (element.elementId()) { + case ID_HTML: { + DOM::HTMLHtmlElement html = element; + if (token == HtmlVersion) return String(html.version()); + } + break; + case ID_HEAD: { + DOM::HTMLHeadElement head = element; + if (token == HeadProfile) return String(head.profile()); + } + break; + case ID_LINK: { + DOM::HTMLLinkElement link = element; + switch (token) { + case LinkDisabled: return Boolean(link.disabled()); + case LinkCharset: return String(link.charset()); + case LinkHref: return String(link.href()); + case LinkHrefLang: return String(link.hreflang()); + case LinkMedia: return String(link.media()); + case LinkRel: return String(link.rel()); + case LinkRev: return String(link.rev()); + case LinkTarget: return String(link.target()); + case LinkType: return String(link.type()); + case LinkSheet: return getDOMStyleSheet(exec,static_cast<DOM::ProcessingInstruction>(node).sheet()); + } + } + break; + case ID_TITLE: { + DOM::HTMLTitleElement title = element; + switch (token) { + case TitleText: return String(title.text()); + } + } + break; + case ID_META: { + DOM::HTMLMetaElement meta = element; + switch (token) { + case MetaContent: return String(meta.content()); + case MetaHttpEquiv: return String(meta.httpEquiv()); + case MetaName: return String(meta.name()); + case MetaScheme: return String(meta.scheme()); + } + } + break; + case ID_BASE: { + DOM::HTMLBaseElement base = element; + switch (token) { + case BaseHref: return String(base.href()); + case BaseTarget: return String(base.target()); + } + } + break; + case ID_ISINDEX: { + DOM::HTMLIsIndexElement isindex = element; + switch (token) { + case IsIndexForm: return getDOMNode(exec,isindex.form()); // type HTMLFormElement + case IsIndexPrompt: return String(isindex.prompt()); + } + } + break; + case ID_STYLE: { + DOM::HTMLStyleElement style = element; + switch (token) { + case StyleDisabled: return Boolean(style.disabled()); + case StyleMedia: return String(style.media()); + case StyleType: return String(style.type()); + case StyleSheet: return getDOMStyleSheet(exec,style.sheet()); + } + } + break; + case ID_BODY: { + DOM::HTMLBodyElement body = element; + switch (token) { + case BodyALink: return String(body.aLink()); + case BodyBackground: return String(body.background()); + case BodyBgColor: return String(body.bgColor()); + case BodyLink: return String(body.link()); + case BodyText: return String(body.text()); + case BodyVLink: return String(body.vLink()); + case BodyOnLoad: { + DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl *>(node.ownerDocument().handle()); + if (!doc || !checkNodeSecurity(exec, node)) + return Undefined(); + DOMNode* kjsDocNode = new DOMNode(exec, doc); + // Need to create a Value wrapper to avoid leaking the KJS::DOMNode + Value nodeValue(kjsDocNode); + return kjsDocNode->getListener( DOM::EventImpl::LOAD_EVENT ); + } + } + } + break; + + case ID_FORM: { + DOM::HTMLFormElement form = element; + switch (token) { + case FormElements: return getHTMLCollection(exec,form.elements()); + case FormLength: return Number(form.length()); + case FormName: return String(form.name()); // NOT getString (IE gives empty string) + case FormAcceptCharset: return String(form.acceptCharset()); + case FormAction: return String(form.action()); + case FormEncType: return String(form.enctype()); + case FormMethod: return String(form.method()); + case FormTarget: return String(form.target()); + } + } + break; + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + switch (token) { + case SelectType: return String(select.type()); + case SelectSelectedIndex: return Number(select.selectedIndex()); + case SelectValue: return String(select.value()); + case SelectLength: return Number(select.length()); + case SelectForm: return getDOMNode(exec,select.form()); // type HTMLFormElement + case SelectOptions: return getSelectHTMLCollection(exec, select.options(), select); // type HTMLCollection + case SelectDisabled: return Boolean(select.disabled()); + case SelectMultiple: return Boolean(select.multiple()); + case SelectName: return String(select.name()); + case SelectSize: return Number(select.size()); + case SelectTabIndex: return Number(select.tabIndex()); + } + } + break; + case ID_OPTGROUP: { + DOM::HTMLOptGroupElement optgroup = element; + switch (token) { + case OptGroupDisabled: return Boolean(optgroup.disabled()); + case OptGroupLabel: return String(optgroup.label()); + } + } + break; + case ID_OPTION: { + DOM::HTMLOptionElement option = element; + switch (token) { + case OptionForm: return getDOMNode(exec,option.form()); // type HTMLFormElement + case OptionDefaultSelected: return Boolean(option.defaultSelected()); + case OptionText: return String(option.text()); + case OptionIndex: return Number(option.index()); + case OptionDisabled: return Boolean(option.disabled()); + case OptionLabel: return String(option.label()); + case OptionSelected: return Boolean(option.selected()); + case OptionValue: return String(option.value()); + } + } + break; + case ID_INPUT: { + DOM::HTMLInputElement input = element; + switch (token) { + case InputDefaultValue: return String(input.defaultValue()); + case InputDefaultChecked: return Boolean(input.defaultChecked()); + case InputForm: return getDOMNode(exec,input.form()); // type HTMLFormElement + case InputAccept: return String(input.accept()); + case InputAccessKey: return String(input.accessKey()); + case InputAlign: return String(input.align()); + case InputAlt: return String(input.alt()); + case InputChecked: return Boolean(input.checked()); + case InputIndeterminate: return Boolean(input.indeterminate()); + case InputDisabled: return Boolean(input.disabled()); + case InputMaxLength: return Number(input.maxLength()); + case InputName: return String(input.name()); // NOT getString (IE gives empty string) + case InputReadOnly: return Boolean(input.readOnly()); + case InputSize: return Number(input.getSize()); + case InputSrc: return String(input.src()); + case InputTabIndex: return Number(input.tabIndex()); + case InputType: return String(input.type()); + case InputUseMap: return String(input.useMap()); + case InputValue: return String(input.value()); + case InputSelectionStart: { + long val = input.selectionStart(); + if (val != -1) + return Number(val); + else + return Undefined(); + } + case InputSelectionEnd: { + long val = input.selectionEnd(); + if (val != -1) + return Number(val); + else + return Undefined(); + } + } + } + break; + case ID_TEXTAREA: { + DOM::HTMLTextAreaElement textarea = element; + switch (token) { + case TextAreaDefaultValue: return String(textarea.defaultValue()); + case TextAreaForm: return getDOMNode(exec,textarea.form()); // type HTMLFormElement + case TextAreaAccessKey: return String(textarea.accessKey()); + case TextAreaCols: return Number(textarea.cols()); + case TextAreaDisabled: return Boolean(textarea.disabled()); + case TextAreaName: return String(textarea.name()); + case TextAreaReadOnly: return Boolean(textarea.readOnly()); + case TextAreaRows: return Number(textarea.rows()); + case TextAreaTabIndex: return Number(textarea.tabIndex()); + case TextAreaType: return String(textarea.type()); + case TextAreaValue: return String(textarea.value()); + case TextAreaSelectionStart: return Number(textarea.selectionStart()); + case TextAreaSelectionEnd: return Number(textarea.selectionEnd()); + case TextAreaTextLength: return Number(textarea.textLength()); + } + } + break; + case ID_BUTTON: { + DOM::HTMLButtonElement button = element; + switch (token) { + case ButtonForm: return getDOMNode(exec,button.form()); // type HTMLFormElement + case ButtonAccessKey: return String(button.accessKey()); + case ButtonDisabled: return Boolean(button.disabled()); + case ButtonName: return String(button.name()); + case ButtonTabIndex: return Number(button.tabIndex()); + case ButtonType: return String(button.type()); + case ButtonValue: return String(button.value()); + } + } + break; + case ID_LABEL: { + DOM::HTMLLabelElement label = element; + switch (token) { + case LabelForm: return getDOMNode(exec,label.form()); // type HTMLFormElement + case LabelAccessKey: return String(label.accessKey()); + case LabelHtmlFor: return String(label.htmlFor()); + } + } + break; + case ID_FIELDSET: { + DOM::HTMLFieldSetElement fieldSet = element; + switch (token) { + case FieldSetForm: return getDOMNode(exec,fieldSet.form()); // type HTMLFormElement + } + } + break; + case ID_LEGEND: { + DOM::HTMLLegendElement legend = element; + switch (token) { + case LegendForm: return getDOMNode(exec,legend.form()); // type HTMLFormElement + case LegendAccessKey: return String(legend.accessKey()); + case LegendAlign: return String(legend.align()); + } + } + break; + case ID_UL: { + DOM::HTMLUListElement uList = element; + switch (token) { + case UListCompact: return Boolean(uList.compact()); + case UListType: return String(uList.type()); + } + } + break; + case ID_OL: { + DOM::HTMLOListElement oList = element; + switch (token) { + case OListCompact: return Boolean(oList.compact()); + case OListStart: return Number(oList.start()); + case OListType: return String(oList.type()); + } + } + break; + case ID_DL: { + DOM::HTMLDListElement dList = element; + switch (token) { + case DListCompact: return Boolean(dList.compact()); + } + } + break; + case ID_DIR: { + DOM::HTMLDirectoryElement directory = element; + switch (token) { + case DirectoryCompact: return Boolean(directory.compact()); + } + } + break; + case ID_MENU: { + DOM::HTMLMenuElement menu = element; + switch (token) { + case MenuCompact: return Boolean(menu.compact()); + } + } + break; + case ID_LI: { + DOM::HTMLLIElement li = element; + switch (token) { + case LIType: return String(li.type()); + case LIValue: return Number(li.value()); + } + } + break; + case ID_DIV: { + DOM::HTMLDivElement div = element; + switch (token) { + case DivAlign: return String(div.align()); + } + } + break; + case ID_P: { + DOM::HTMLParagraphElement paragraph = element; + switch (token) { + case ParagraphAlign: return String(paragraph.align()); + } + } + break; + case ID_H1: + case ID_H2: + case ID_H3: + case ID_H4: + case ID_H5: + case ID_H6: { + DOM::HTMLHeadingElement heading = element; + switch (token) { + case HeadingAlign: return String(heading.align()); + } + } + break; + case ID_BLOCKQUOTE: { + DOM::HTMLBlockquoteElement blockquote = element; + switch (token) { + case BlockQuoteCite: return String(blockquote.cite()); + } + } + case ID_Q: { + DOM::HTMLQuoteElement quote = element; + switch (token) { + case QuoteCite: return String(quote.cite()); + } + } + case ID_PRE: { + DOM::HTMLPreElement pre = element; + switch (token) { + case PreWidth: return Number(pre.width()); + } + } + break; + case ID_BR: { + DOM::HTMLBRElement br = element; + switch (token) { + case BRClear: return String(br.clear()); + } + } + break; + case ID_BASEFONT: { + DOM::HTMLBaseFontElement baseFont = element; + switch (token) { + case BaseFontColor: return String(baseFont.color()); + case BaseFontFace: return String(baseFont.face()); + case BaseFontSize: return Number(baseFont.getSize()); + } + } + break; + case ID_FONT: { + DOM::HTMLFontElement font = element; + switch (token) { + case FontColor: return String(font.color()); + case FontFace: return String(font.face()); + case FontSize: return String(font.size()); + } + } + break; + case ID_HR: { + DOM::HTMLHRElement hr = element; + switch (token) { + case HRAlign: return String(hr.align()); + case HRNoShade: return Boolean(hr.noShade()); + case HRSize: return String(hr.size()); + case HRWidth: return String(hr.width()); + } + } + break; + case ID_INS: + case ID_DEL: { + DOM::HTMLModElement mod = element; + switch (token) { + case ModCite: return String(mod.cite()); + case ModDateTime: return String(mod.dateTime()); + } + } + break; + case ID_A: { + DOM::HTMLAnchorElement anchor = element; + switch (token) { + case AnchorAccessKey: return String(anchor.accessKey()); + case AnchorCharset: return String(anchor.charset()); + case AnchorCoords: return String(anchor.coords()); + case AnchorHref: return String(anchor.href()); + case AnchorHrefLang: return String(anchor.hreflang()); + case AnchorHash: return String('#'+KURL(anchor.href().string()).ref()); + case AnchorHost: return String(KURL(anchor.href().string()).host()); + case AnchorHostname: { + KURL url(anchor.href().string()); + kdDebug(6070) << "anchor::hostname uses:" <<url.url()<<endl; + if (url.port()==0) + return String(url.host()); + else + return String(url.host() + ":" + TQString::number(url.port())); + } + case AnchorPathName: return String(KURL(anchor.href().string()).path()); + case AnchorPort: return String(TQString::number(KURL(anchor.href().string()).port())); + case AnchorProtocol: return String(KURL(anchor.href().string()).protocol()+":"); + case AnchorSearch: { KURL u(anchor.href().string()); + TQString q = u.query(); + if (q.length() == 1) + return String(); + return String(q); } + case AnchorName: return String(anchor.name()); + case AnchorRel: return String(anchor.rel()); + case AnchorRev: return String(anchor.rev()); + case AnchorShape: return String(anchor.shape()); + case AnchorTabIndex: return Number(anchor.tabIndex()); + case AnchorTarget: return String(anchor.target()); + // Not specified in http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/a.asp + // Mozilla returns the inner text. + case AnchorText: return String(anchor.innerText()); + case AnchorType: return String(anchor.type()); + } + } + break; + case ID_IMG: { + DOM::HTMLImageElement image = element; + switch (token) { + case ImageName: return String(image.name()); // NOT getString (IE gives empty string) + case ImageAlign: return String(image.align()); + case ImageAlt: return String(image.alt()); + case ImageBorder: return String(image.getBorder()); + case ImageComplete: return Boolean(static_cast<DOM::HTMLImageElementImpl*>( image.handle() )->complete()); + case ImageHeight: return Number(image.height()); + case ImageHspace: return Number(image.hspace()); + case ImageIsMap: return Boolean(image.isMap()); + case ImageLongDesc: return String(image.longDesc()); + case ImageSrc: return String(image.src()); + case ImageUseMap: return String(image.useMap()); + case ImageVspace: return Number(image.vspace()); + case ImageWidth: return Number(image.width()); + case ImageX: return Number(image.x()); + case ImageY: return Number(image.y()); + } + } + break; + case ID_OBJECT: { + DOM::HTMLObjectElement object = element; + switch (token) { + case ObjectForm: return getDOMNode(exec,object.form()); // type HTMLFormElement + case ObjectCode: return String(object.code()); + case ObjectAlign: return String(object.align()); + case ObjectArchive: return String(object.archive()); + case ObjectBorder: return String(object.border()); + case ObjectCodeBase: return String(object.codeBase()); + case ObjectCodeType: return String(object.codeType()); + case ObjectContentDocument: return checkNodeSecurity(exec,object.contentDocument()) ? + getDOMNode(exec, object.contentDocument()) : Undefined(); + case ObjectData: return String(object.data()); + case ObjectDeclare: return Boolean(object.declare()); + case ObjectHeight: return String(object.height()); + case ObjectHspace: return Number(object.getHspace()); + case ObjectName: return String(object.name()); + case ObjectStandby: return String(object.standby()); + case ObjectTabIndex: return Number(object.tabIndex()); + case ObjectType: return String(object.type()); + case ObjectUseMap: return String(object.useMap()); + case ObjectVspace: return Number(object.getVspace()); + case ObjectWidth: return String(object.width()); + } + } + break; + case ID_PARAM: { + DOM::HTMLParamElement param = element; + switch (token) { + case ParamName: return String(param.name()); + case ParamType: return String(param.type()); + case ParamValue: return String(param.value()); + case ParamValueType: return String(param.valueType()); + } + } + break; + case ID_APPLET: { + DOM::HTMLAppletElement applet = element; + switch (token) { + case AppletAlign: return String(applet.align()); + case AppletAlt: return String(applet.alt()); + case AppletArchive: return String(applet.archive()); + case AppletCode: return String(applet.code()); + case AppletCodeBase: return String(applet.codeBase()); + case AppletHeight: return String(applet.height()); + case AppletHspace: return Number(applet.getHspace()); + case AppletName: return String(applet.name()); + case AppletObject: return String(applet.object()); + case AppletVspace: return Number(applet.getVspace()); + case AppletWidth: return String(applet.width()); + } + } + break; + case ID_MAP: { + DOM::HTMLMapElement map = element; + switch (token) { + case MapAreas: return getHTMLCollection(exec, map.areas()); // type HTMLCollection + case MapName: return String(map.name()); + } + } + break; + case ID_AREA: { + DOM::HTMLAreaElement area = element; + switch (token) { + case AreaAccessKey: return String(area.accessKey()); + case AreaAlt: return String(area.alt()); + case AreaCoords: return String(area.coords()); + // Group everything that needs href + case AreaHref: + case AreaHash: + case AreaHost: + case AreaHostName: + case AreaPathName: + case AreaPort: + case AreaProtocol: + case AreaSearch: + { + DOM::Document doc = area.ownerDocument(); + DOM::DOMString href = area.href(); + KURL url; + if ( !href.isNull() ) { + url = doc.completeURL( href ).string(); + if ( href.isEmpty() ) + url.setFileName( TQString::null ); // href="" clears the filename (in IE) + } + switch(token) { + case AreaHref: + return String(url.url()); + case AreaHash: return String(url.isEmpty() ? "" : '#'+url.ref()); + case AreaHost: return String(url.host()); + case AreaHostName: { + if (url.port()==0) + return String(url.host()); + else + return String(url.host() + ":" + TQString::number(url.port())); + } + case AreaPathName: { + return String(url.path()); + } + case AreaPort: return String(TQString::number(url.port())); + case AreaProtocol: return String(url.isEmpty() ? "" : url.protocol()+":"); + case AreaSearch: return String(url.query()); + } + } + case AreaNoHref: return Boolean(area.noHref()); + case AreaShape: return String(area.shape()); + case AreaTabIndex: return Number(area.tabIndex()); + case AreaTarget: return String(area.target()); + } + } + break; + case ID_SCRIPT: { + DOM::HTMLScriptElement script = element; + switch (token) { + case ScriptText: return String(script.text()); + case ScriptHtmlFor: return String(script.htmlFor()); + case ScriptEvent: return String(script.event()); + case ScriptCharset: return String(script.charset()); + case ScriptDefer: return Boolean(script.defer()); + case ScriptSrc: return String(script.src()); + case ScriptType: return String(script.type()); + } + } + break; + case ID_TABLE: { + DOM::HTMLTableElement table = element; + switch (token) { + case TableCaption: return getDOMNode(exec,table.caption()); // type HTMLTableCaptionElement + case TableTHead: return getDOMNode(exec,table.tHead()); // type HTMLTableSectionElement + case TableTFoot: return getDOMNode(exec,table.tFoot()); // type HTMLTableSectionElement + case TableRows: return getHTMLCollection(exec,table.rows()); // type HTMLCollection + case TableTBodies: return getHTMLCollection(exec,table.tBodies()); // type HTMLCollection + case TableAlign: return String(table.align()); + case TableBgColor: return String(table.bgColor()); + case TableBorder: return String(table.border()); + case TableCellPadding: return String(table.cellPadding()); + case TableCellSpacing: return String(table.cellSpacing()); + case TableFrame: return String(table.frame()); + case TableRules: return String(table.rules()); + case TableSummary: return String(table.summary()); + case TableWidth: return String(table.width()); + } + } + break; + case ID_CAPTION: { + DOM::HTMLTableCaptionElement tableCaption = element; + switch (token) { + case TableCaptionAlign: return String(tableCaption.align()); + } + } + break; + case ID_COL: + case ID_COLGROUP: { + DOM::HTMLTableColElement tableCol = element; + switch (token) { + case TableColAlign: return String(tableCol.align()); + case TableColCh: return String(tableCol.ch()); + case TableColChOff: return String(tableCol.chOff()); + case TableColSpan: return Number(tableCol.span()); + case TableColVAlign: return String(tableCol.vAlign()); + case TableColWidth: return String(tableCol.width()); + } + } + break; + case ID_THEAD: + case ID_TBODY: + case ID_TFOOT: { + DOM::HTMLTableSectionElement tableSection = element; + switch (token) { + case TableSectionAlign: return String(tableSection.align()); + case TableSectionCh: return String(tableSection.ch()); + case TableSectionChOff: return String(tableSection.chOff()); + case TableSectionVAlign: return String(tableSection.vAlign()); + case TableSectionRows: return getHTMLCollection(exec,tableSection.rows()); // type HTMLCollection + } + } + break; + case ID_TR: { + DOM::HTMLTableRowElement tableRow = element; + switch (token) { + case TableRowRowIndex: return Number(tableRow.rowIndex()); + case TableRowSectionRowIndex: return Number(tableRow.sectionRowIndex()); + case TableRowCells: return getHTMLCollection(exec,tableRow.cells()); // type HTMLCollection + case TableRowAlign: return String(tableRow.align()); + case TableRowBgColor: return String(tableRow.bgColor()); + case TableRowCh: return String(tableRow.ch()); + case TableRowChOff: return String(tableRow.chOff()); + case TableRowVAlign: return String(tableRow.vAlign()); + } + } + break; + case ID_TH: + case ID_TD: { + DOM::HTMLTableCellElement tableCell = element; + switch (token) { + case TableCellCellIndex: return Number(tableCell.cellIndex()); + case TableCellAbbr: return String(tableCell.abbr()); + case TableCellAlign: return String(tableCell.align()); + case TableCellAxis: return String(tableCell.axis()); + case TableCellBgColor: return String(tableCell.bgColor()); + case TableCellCh: return String(tableCell.ch()); + case TableCellChOff: return String(tableCell.chOff()); + case TableCellColSpan: return Number(tableCell.colSpan()); + case TableCellHeaders: return String(tableCell.headers()); + case TableCellHeight: return String(tableCell.height()); + case TableCellNoWrap: return Boolean(tableCell.noWrap()); + case TableCellRowSpan: return Number(tableCell.rowSpan()); + case TableCellScope: return String(tableCell.scope()); + case TableCellVAlign: return String(tableCell.vAlign()); + case TableCellWidth: return String(tableCell.width()); + } + } + break; + case ID_FRAMESET: { + DOM::HTMLFrameSetElement frameSet = element; + switch (token) { + case FrameSetCols: return String(frameSet.cols()); + case FrameSetRows: return String(frameSet.rows()); + } + } + break; + case ID_LAYER: { + DOM::HTMLLayerElement layerElement = element; + switch (token) { + case LayerTop: return Number(layerElement.top()); + case LayerLeft: return Number(layerElement.left()); + case LayerVisibility: return getString(layerElement.visibility()); + case LayerBgColor: return getString(layerElement.bgColor()); + /*case LayerClip: return getLayerClip(exec, layerElement); */ + case LayerDocument: return Undefined(); + case LayerLayers: return getHTMLCollection(exec,layerElement.layers()); + } + } + break; + case ID_FRAME: { + DOM::HTMLFrameElement frameElement = element; + switch (token) { + case FrameContentDocument: return checkNodeSecurity(exec,frameElement.contentDocument()) ? + getDOMNode(exec, frameElement.contentDocument()) : Undefined(); + case FrameContentWindow: { + KHTMLPart* part = static_cast<DOM::HTMLFrameElementImpl*>(frameElement.handle())->contentPart(); + if (part) { + Window *w = Window::retrieveWindow(part); + if (w) + return Value(w); + } + return Undefined(); + } + case FrameFrameBorder: return String(frameElement.frameBorder()); + case FrameLongDesc: return String(frameElement.longDesc()); + case FrameMarginHeight: return String(frameElement.marginHeight()); + case FrameMarginWidth: return String(frameElement.marginWidth()); + case FrameName: return String(frameElement.name()); + case FrameNoResize: return Boolean(frameElement.noResize()); + case FrameScrolling: return String(frameElement.scrolling()); + case FrameSrc: + case FrameLocation: return String(frameElement.src()); + // IE only + case FrameWidth: + case FrameHeight: + { + frameElement.handle()->getDocument()->updateLayout(); + tdehtml::RenderObject* r = frameElement.handle()->renderer(); + return Number( r ? (token == FrameWidth ? r->width() : r->height()) : 0 ); + } + } + } + break; + case ID_IFRAME: { + DOM::HTMLIFrameElement iFrame = element; + switch (token) { + case IFrameAlign: return String(iFrame.align()); + case IFrameContentDocument: return checkNodeSecurity(exec,iFrame.contentDocument()) ? + getDOMNode(exec, iFrame.contentDocument()) : Undefined(); + case IFrameContentWindow: { + KHTMLPart* part = static_cast<DOM::HTMLIFrameElementImpl*>(iFrame.handle())->contentPart(); + if (part) { + Window *w = Window::retrieveWindow(part); + if (w) + return Value(w); + } + return Undefined(); + } + case IFrameFrameBorder: return String(iFrame.frameBorder()); + case IFrameHeight: return String(iFrame.height()); + case IFrameLongDesc: return String(iFrame.longDesc()); + case IFrameMarginHeight: return String(iFrame.marginHeight()); + case IFrameMarginWidth: return String(iFrame.marginWidth()); + case IFrameName: return String(iFrame.name()); + case IFrameScrolling: return String(iFrame.scrolling()); + case IFrameSrc: return String(iFrame.src()); + case IFrameWidth: return String(iFrame.width()); + } + break; + } + } // xemacs (or arnt) could be a bit smarter when it comes to indenting switch()es ;) + // its not arnt to blame - its the original Stroustrup style we like :) (Dirk) + + // generic properties + switch (token) { + case ElementId: + return String(element.id()); // String is wrong here. Other browsers return empty string if no id specified. + case ElementTitle: + return String(element.title()); + case ElementLang: + return String(element.lang()); + case ElementDir: + return String(element.dir()); + case ElementClassName: + return String(element.className()); + case ElementInnerHTML: + return String(element.innerHTML()); + case ElementInnerText: + return String(element.innerText()); + case ElementDocument: + return getDOMNode(exec,element.ownerDocument()); + case ElementChildren: + return getHTMLCollection(exec,element.children()); + case ElementAll: + // Disable element.all when we try to be Netscape-compatible + if ( exec->interpreter()->compatMode() == Interpreter::NetscapeCompat ) + return Undefined(); + else + if ( exec->interpreter()->compatMode() == Interpreter::IECompat ) + return getHTMLCollection(exec,element.all()); + else // Enabled but hidden by default + return getHTMLCollection(exec,element.all(), true); + // ### what about style? or is this used instead for DOM2 stylesheets? + } + kdError() << "HTMLElement::getValueProperty unhandled token " << token << endl; + return Undefined(); +} + +bool KJS::HTMLElement::hasProperty(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + //kdDebug(6070) << "HTMLElement::hasProperty " << propertyName.qstring() << endl; +#endif + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); + // First look at dynamic properties - keep this in sync with tryGet + switch (element.elementId()) { + case ID_FORM: { + DOM::HTMLFormElement form = element; + // Check if we're retrieving an element (by index or by name) + bool ok; + uint u = propertyName.toULong(&ok); + if (ok && !(form.elements().item(u).isNull())) + return true; + DOM::Node testnode = form.elements().namedItem(propertyName.string()); + if (!testnode.isNull()) + return true; + } + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + bool ok; + uint u = propertyName.toULong(&ok); + if (ok && !(select.options().item(u).isNull())) + return true; + } + default: + break; + } + + return DOMElement::hasProperty(exec, propertyName); +} + +UString KJS::HTMLElement::toString(ExecState *exec) const +{ + if (node.elementId() == ID_A) + return UString(static_cast<const DOM::HTMLAnchorElement&>(node).href()); + else if (node.elementId() == ID_APPLET) { + KParts::LiveConnectExtension *lc = getLiveConnectExtension(node); + TQStringList qargs; + TQString retvalue; + KParts::LiveConnectExtension::Type rettype; + unsigned long retobjid; + if (lc && lc->call(0, "hashCode", qargs, rettype, retobjid, retvalue)) { + TQString str("[object APPLET ref="); + return UString(str + retvalue + TQString("]")); + } + } else if (node.elementId() == ID_IMG) { + DOM::HTMLImageElement image(node); + if (!image.alt().isEmpty()) + return UString(image.alt()) + " " + DOMElement::toString(exec); + } + return DOMElement::toString(exec); +} + +static void getForm(DOM::HTMLFormElement* form, const DOM::HTMLElement& element) +{ + switch (element.elementId()) { + case ID_ISINDEX: { + DOM::HTMLIsIndexElement isindex = element; + *form = isindex.form(); + break; + } + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + *form = select.form(); + break; + } + case ID_OPTION: { + DOM::HTMLOptionElement option = element; + *form = option.form(); + break; + } + case ID_INPUT: { + DOM::HTMLInputElement input = element; + *form = input.form(); + break; + } + case ID_TEXTAREA: { + DOM::HTMLTextAreaElement textarea = element; + *form = textarea.form(); + break; + } + case ID_LABEL: { + DOM::HTMLLabelElement label = element; + *form = label.form(); + break; + } + case ID_FIELDSET: { + DOM::HTMLFieldSetElement fieldset = element; + *form = fieldset.form(); + break; + } + case ID_LEGEND: { + DOM::HTMLLegendElement legend = element; + *form = legend.form(); + break; + } + case ID_OBJECT: { + DOM::HTMLObjectElement object = element; + *form = object.form(); + break; + } + default: + break; + } +} + +void KJS::HTMLElement::pushEventHandlerScope(ExecState *exec, ScopeChain &scope) const +{ + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); + + // The document is put on first, fall back to searching it only after the element and form. + scope.push(static_cast<ObjectImp *>(getDOMNode(exec, element.ownerDocument()).imp())); + + // The form is next, searched before the document, but after the element itself. + DOM::HTMLFormElement formElt; + + // First try to obtain the form from the element itself. We do this to deal with + // the malformed case where <form>s aren't in our parent chain (e.g., when they were inside + // <table> or <tbody>. + getForm(&formElt, element); + if (!formElt.isNull()) + scope.push(static_cast<ObjectImp *>(getDOMNode(exec, formElt).imp())); + else { + DOM::Node form = element.parentNode(); + while (!form.isNull() && form.elementId() != ID_FORM) + form = form.parentNode(); + + if (!form.isNull()) + scope.push(static_cast<ObjectImp *>(getDOMNode(exec, form).imp())); + } + + // The element is on top, searched first. + scope.push(static_cast<ObjectImp *>(getDOMNode(exec, element).imp())); +} + +HTMLElementFunction::HTMLElementFunction(ExecState *exec, int i, int len) + : DOMFunction(exec), id(i) +{ + Value protect(this); + put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum); +} + +Value KJS::HTMLElementFunction::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( HTMLElement, thisObj ); + +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLElementFunction::tryCall " << endl; +#endif + DOM::HTMLElement element = static_cast<KJS::HTMLElement *>(thisObj.imp())->toElement(); + + switch (element.elementId()) { + case ID_FORM: { + DOM::HTMLFormElement form = element; + if (id == KJS::HTMLElement::FormSubmit) { + + + DOM::HTMLDocument doc = element.ownerDocument(); + KHTMLView *view = static_cast<DOM::DocumentImpl*>(doc.handle())->view(); + KHTMLSettings::KJSWindowOpenPolicy policy = KHTMLSettings::KJSWindowOpenAllow; + if (view) + policy = view->part()->settings()->windowOpenPolicy(view->part()->url().host()); + + bool block = false; + + if ( policy != KHTMLSettings::KJSWindowOpenAllow ) { + block = true; + + // if this is a form without a target, or a special target, don't block + TQString trg = form.target().lower().string(); + if( trg.isEmpty() || trg == "_top" || trg == "_self" || + trg == "_parent") + block = false; + + TQString caption; + + // if there is a frame with the target name, don't block + if ( view && view->part() ) { + if (!view->part()->url().host().isEmpty()) + caption = view->part()->url().host() + " - "; + // search all (possibly nested) framesets + KHTMLPart *currentPart = view->part()->parentPart(); + while( currentPart != 0L ) { + if( currentPart->frameExists( form.target().string() ) ) + block = false; + currentPart = currentPart->parentPart(); + } + } + + if ( block && policy == KHTMLSettings::KJSWindowOpenAsk && view ) { + if (view && view->part()) + emit view->part()->browserExtension()->requestFocus(view->part()); + caption += i18n( "Confirmation: JavaScript Popup" ); + if ( KMessageBox::questionYesNo(view, form.action().isEmpty() ? + i18n( "This site is submitting a form which will open up a new browser " + "window via JavaScript.\n" + "Do you want to allow the form to be submitted?" ) : + i18n( "<qt>This site is submitting a form which will open <p>%1</p> in a new browser window via JavaScript.<br />" + "Do you want to allow the form to be submitted?</qt>").arg(KStringHandler::csqueeze(form.action().string(), 100)), + caption, i18n("Allow"), i18n("Do Not Allow") ) == KMessageBox::Yes ) + block = false; + + } else if ( block && policy == KHTMLSettings::KJSWindowOpenSmart ) { + if( static_cast<KJS::ScriptInterpreter *>(exec->interpreter())->isWindowOpenAllowed() ) { + // This submission has been triggered by the user + block = false; + } + } + } + + if( !block ) + form.submit(); + + return Undefined(); + } + else if (id == KJS::HTMLElement::FormReset) { + form.reset(); + return Undefined(); + } + } + break; + case ID_BODY: { + if (id == KJS::HTMLElement::BodyFocus) { + // Just blur everything. Not perfect, but good enough for now + if (DOM::NodeImpl* impl = element.handle()) { + impl->getDocument()->setFocusNode(0); + } + } + } + break; + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + if (id == KJS::HTMLElement::SelectAdd) { + select.add(KJS::toNode(args[0]),KJS::toNode(args[1])); + return Undefined(); + } + else if (id == KJS::HTMLElement::SelectRemove) { + select.remove(int(args[0].toNumber(exec))); + return Undefined(); + } + else if (id == KJS::HTMLElement::SelectBlur) { + select.blur(); + return Undefined(); + } + else if (id == KJS::HTMLElement::SelectFocus) { + select.focus(); + return Undefined(); + } + } + break; + case ID_INPUT: { + DOM::HTMLInputElement input = element; + if (id == KJS::HTMLElement::InputBlur) { + input.blur(); + return Undefined(); + } + else if (id == KJS::HTMLElement::InputFocus) { + input.focus(); + return Undefined(); + } + else if (id == KJS::HTMLElement::InputSelect) { + input.select(); + return Undefined(); + } + else if (id == KJS::HTMLElement::InputClick) { + input.click(); + return Undefined(); + } + else if (id == KJS::HTMLElement::InputSetSelectionRange) { + input.setSelectionRange(args[0].toNumber(exec), args[1].toNumber(exec)); + return Undefined(); + } + } + break; + case ID_BUTTON: { + DOM::HTMLButtonElement button = element; + if (id == KJS::HTMLElement::ButtonBlur) { + button.blur(); + return Undefined(); + } + else if (id == KJS::HTMLElement::ButtonFocus) { + button.focus(); + return Undefined(); + } + } + break; + case ID_TEXTAREA: { + DOM::HTMLTextAreaElement textarea = element; + if (id == KJS::HTMLElement::TextAreaBlur) { + textarea.blur(); + return Undefined(); + } + else if (id == KJS::HTMLElement::TextAreaFocus) { + textarea.focus(); + return Undefined(); + } + else if (id == KJS::HTMLElement::TextAreaSelect) { + textarea.select(); + return Undefined(); + } + else if (id == KJS::HTMLElement::TextAreaSetSelectionRange) { + textarea.setSelectionRange(args[0].toNumber(exec), args[1].toNumber(exec)); + return Undefined(); + } + + } + break; + case ID_A: { + DOM::HTMLAnchorElement anchor = element; + if (id == KJS::HTMLElement::AnchorBlur) { + anchor.blur(); + return Undefined(); + } + else if (id == KJS::HTMLElement::AnchorFocus) { + anchor.focus(); + return Undefined(); + } + else if (id == KJS::HTMLElement::AnchorClick) { + static_cast<DOM::HTMLAnchorElementImpl*>(anchor.handle())->click(); + return Undefined(); + } + } + break; + case ID_TABLE: { + DOM::HTMLTableElement table = element; + if (id == KJS::HTMLElement::TableCreateTHead) + return getDOMNode(exec,table.createTHead()); + else if (id == KJS::HTMLElement::TableDeleteTHead) { + table.deleteTHead(); + return Undefined(); + } + else if (id == KJS::HTMLElement::TableCreateTFoot) + return getDOMNode(exec,table.createTFoot()); + else if (id == KJS::HTMLElement::TableDeleteTFoot) { + table.deleteTFoot(); + return Undefined(); + } + else if (id == KJS::HTMLElement::TableCreateCaption) + return getDOMNode(exec,table.createCaption()); + else if (id == KJS::HTMLElement::TableDeleteCaption) { + table.deleteCaption(); + return Undefined(); + } + else if (id == KJS::HTMLElement::TableInsertRow) + return getDOMNode(exec,table.insertRow(args[0].toInteger(exec))); + else if (id == KJS::HTMLElement::TableDeleteRow) { + table.deleteRow(args[0].toInteger(exec)); + return Undefined(); + } + } + break; + case ID_THEAD: + case ID_TBODY: + case ID_TFOOT: { + DOM::HTMLTableSectionElement tableSection = element; + if (id == KJS::HTMLElement::TableSectionInsertRow) + return getDOMNode(exec,tableSection.insertRow(args[0].toInteger(exec))); + else if (id == KJS::HTMLElement::TableSectionDeleteRow) { + tableSection.deleteRow(args[0].toInteger(exec)); + return Undefined(); + } + } + break; + case ID_TR: { + DOM::HTMLTableRowElement tableRow = element; + if (id == KJS::HTMLElement::TableRowInsertCell) + return getDOMNode(exec,tableRow.insertCell(args[0].toInteger(exec))); + else if (id == KJS::HTMLElement::TableRowDeleteCell) { + tableRow.deleteCell(args[0].toInteger(exec)); + return Undefined(); + } + break; + } + case ID_MARQUEE: { + if (id == KJS::HTMLElement::MarqueeStart && element.handle()->renderer() && + element.handle()->renderer()->layer() && + element.handle()->renderer()->layer()->marquee()) { + element.handle()->renderer()->layer()->marquee()->start(); + return Undefined(); + } + else if (id == KJS::HTMLElement::MarqueeStop && element.handle()->renderer() && + element.handle()->renderer()->layer() && + element.handle()->renderer()->layer()->marquee()) { + element.handle()->renderer()->layer()->marquee()->stop(); + return Undefined(); + } + break; + } + } + + if (id == HTMLElement::ElementScrollIntoView) { + bool alignToTop = true; + if (args.size() > 0) + alignToTop = args[0].toBoolean(exec); + static_cast<HTMLElementImpl*>(element.handle())->scrollIntoView(alignToTop); + return Undefined(); + } + + return Undefined(); +} + +void KJS::HTMLElement::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ +#ifdef KJS_VERBOSE + DOM::DOMString str = value.isA(NullType) ? DOM::DOMString() : value.toString(exec).string(); +#endif + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLElement::tryPut " << propertyName.qstring() + << " thisTag=" << element.tagName().string() + << " str=" << str.string() << endl; +#endif + // First look at dynamic properties + switch (element.elementId()) { + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + bool ok; + /*uint u =*/ propertyName.toULong(&ok); + if (ok) { + Object coll = Object::dynamicCast( getSelectHTMLCollection(exec, select.options(), select) ); + if ( coll.isValid() ) + coll.put(exec,propertyName,value); + return; + } + break; + } + case ID_APPLET: + case ID_OBJECT: + case ID_EMBED: { + KParts::LiveConnectExtension *lc = getLiveConnectExtension(element); + if (lc && lc->put(0, propertyName.qstring(), value.toString(exec).qstring())) + return; + break; + } + default: + break; + } + + const HashTable* table = classInfo()->propHashTable; // get the right hashtable + const HashEntry* entry = table ? Lookup::findEntry(table, propertyName) : 0; + 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<KJS::HTMLElement, DOMElement>(exec, propertyName, value, attr, &KJS::HTMLElementTable, this); +} + +void KJS::HTMLElement::putValueProperty(ExecState *exec, int token, const Value& value, int) +{ + DOM::DOMString str = value.isA(NullType) ? DOM::DOMString() : value.toString(exec).string(); + DOMNode *kjsNode = new DOMNode(exec, KJS::toNode(value)); + // Need to create a Value wrapper to avoid leaking the KJS::DOMNode + Value nodeValue(kjsNode); + DOM::Node n = kjsNode->toNode(); + DOM::HTMLElement element = static_cast<DOM::HTMLElement>(node); +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLElement::putValueProperty " + << " thisTag=" << element.tagName().string() + << " token=" << token << endl; +#endif + + switch (element.elementId()) { + case ID_HTML: { + DOM::HTMLHtmlElement html = element; + switch (token) { + case HtmlVersion: { html.setVersion(str); return; } + } + } + break; + case ID_HEAD: { + DOM::HTMLHeadElement head = element; + switch (token) { + case HeadProfile: { head.setProfile(str); return; } + } + } + break; + case ID_LINK: { + DOM::HTMLLinkElement link = element; + switch (token) { + case LinkDisabled: { link.setDisabled(value.toBoolean(exec)); return; } + case LinkCharset: { link.setCharset(str); return; } + case LinkHref: { link.setHref(str); return; } + case LinkHrefLang: { link.setHreflang(str); return; } + case LinkMedia: { link.setMedia(str); return; } + case LinkRel: { link.setRel(str); return; } + case LinkRev: { link.setRev(str); return; } + case LinkTarget: { link.setTarget(str); return; } + case LinkType: { link.setType(str); return; } + } + } + break; + case ID_TITLE: { + DOM::HTMLTitleElement title = element; + switch (token) { + case TitleText: { title.setText(str); return; } + } + } + break; + case ID_META: { + DOM::HTMLMetaElement meta = element; + switch (token) { + case MetaContent: { meta.setContent(str); return; } + case MetaHttpEquiv: { meta.setHttpEquiv(str); return; } + case MetaName: { meta.setName(str); return; } + case MetaScheme: { meta.setScheme(str); return; } + } + } + break; + case ID_BASE: { + DOM::HTMLBaseElement base = element; + switch (token) { + case BaseHref: { base.setHref(str); return; } + case BaseTarget: { base.setTarget(str); return; } + } + } + break; + case ID_ISINDEX: { + DOM::HTMLIsIndexElement isindex = element; + switch (token) { + // read-only: form + case IsIndexPrompt: { isindex.setPrompt(str); return; } + } + } + break; + case ID_STYLE: { + DOM::HTMLStyleElement style = element; + switch (token) { + case StyleDisabled: { style.setDisabled(value.toBoolean(exec)); return; } + case StyleMedia: { style.setMedia(str); return; } + case StyleType: { style.setType(str); return; } + } + } + break; + case ID_BODY: { + DOM::HTMLBodyElement body = element; + switch (token) { + case BodyALink: { body.setALink(str); return; } + case BodyBackground: { body.setBackground(str); return; } + case BodyBgColor: { body.setBgColor(str); return; } + case BodyLink: { body.setLink(str); return; } + case BodyText: { body.setText(str); return; } + case BodyVLink: { body.setVLink(str); return; } + case BodyOnLoad: + DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl *>(node.ownerDocument().handle()); + if (doc && checkNodeSecurity(exec, node)) + { + DOMNode* kjsDocNode = new DOMNode(exec, doc); + // Need to create a Value wrapper to avoid leaking the KJS::DOMNode + Value nodeValue(kjsDocNode); + kjsDocNode->setListener(exec,DOM::EventImpl::LOAD_EVENT,value); + } + return; + } + } + break; + case ID_FORM: { + DOM::HTMLFormElement form = element; + switch (token) { + // read-only: elements + // read-only: length + case FormName: { form.setName(str); return; } + case FormAcceptCharset: { form.setAcceptCharset(str); return; } + case FormAction: { form.setAction(str.string()); return; } + case FormEncType: { form.setEnctype(str); return; } + case FormMethod: { form.setMethod(str); return; } + case FormTarget: { form.setTarget(str); return; } + } + } + break; + case ID_SELECT: { + DOM::HTMLSelectElement select = element; + switch (token) { + // read-only: type + case SelectSelectedIndex: { select.setSelectedIndex(value.toInteger(exec)); return; } + case SelectValue: { select.setValue(str); return; } + case SelectLength: { // read-only according to the NS spec, but webpages need it writeable + Object coll = Object::dynamicCast( getSelectHTMLCollection(exec, select.options(), select) ); + if ( coll.isValid() ) + coll.put(exec,"length",value); + return; + } + // read-only: form + // read-only: options + case SelectDisabled: { select.setDisabled(value.toBoolean(exec)); return; } + case SelectMultiple: { select.setMultiple(value.toBoolean(exec)); return; } + case SelectName: { select.setName(str); return; } + case SelectSize: { select.setSize(value.toInteger(exec)); return; } + case SelectTabIndex: { select.setTabIndex(value.toInteger(exec)); return; } + } + } + break; + case ID_OPTGROUP: { + DOM::HTMLOptGroupElement optgroup = element; + switch (token) { + case OptGroupDisabled: { optgroup.setDisabled(value.toBoolean(exec)); return; } + case OptGroupLabel: { optgroup.setLabel(str); return; } + } + } + break; + case ID_OPTION: { + DOM::HTMLOptionElement option = element; + switch (token) { + // read-only: form + case OptionDefaultSelected: { option.setDefaultSelected(value.toBoolean(exec)); return; } + // read-only: text <--- According to the DOM, but JavaScript and JScript both allow changes. + // So, we'll do it here and not add it to our DOM headers. + case OptionText: { DOM::NodeList nl(option.childNodes()); + for (unsigned int i = 0; i < nl.length(); i++) { + if (nl.item(i).nodeType() == DOM::Node::TEXT_NODE) { + static_cast<DOM::Text>(nl.item(i)).setData(str); + return; + } + } + // No child text node found, creating one + DOM::Text t = option.ownerDocument().createTextNode(str); + try { option.appendChild(t); } + catch(DOM::DOMException& e) { + // #### exec->setException ? + } + + return; + } + // read-only: index + case OptionDisabled: { option.setDisabled(value.toBoolean(exec)); return; } + case OptionLabel: { option.setLabel(str); return; } + case OptionSelected: { option.setSelected(value.toBoolean(exec)); return; } + case OptionValue: { option.setValue(str); return; } + } + } + break; + case ID_INPUT: { + DOM::HTMLInputElement input = element; + switch (token) { + case InputDefaultValue: { input.setDefaultValue(str); return; } + case InputDefaultChecked: { input.setDefaultChecked(value.toBoolean(exec)); return; } + // read-only: form + case InputAccept: { input.setAccept(str); return; } + case InputAccessKey: { input.setAccessKey(str); return; } + case InputAlign: { input.setAlign(str); return; } + case InputAlt: { input.setAlt(str); return; } + case InputChecked: { input.setChecked(value.toBoolean(exec)); return; } + case InputIndeterminate: { input.setIndeterminate(value.toBoolean(exec)); return; } + case InputDisabled: { input.setDisabled(value.toBoolean(exec)); return; } + case InputMaxLength: { input.setMaxLength(value.toInteger(exec)); return; } + case InputName: { input.setName(str); return; } + case InputReadOnly: { input.setReadOnly(value.toBoolean(exec)); return; } + case InputSize: { input.setSize(value.toInteger(exec)); return; } + case InputSrc: { input.setSrc(str); return; } + case InputTabIndex: { input.setTabIndex(value.toInteger(exec)); return; } + case InputType: { input.setType(str); return; } + case InputUseMap: { input.setUseMap(str); return; } + case InputValue: { input.setValue(str); return; } + case InputSelectionStart: { input.setSelectionStart(value.toInteger(exec)); return; } + case InputSelectionEnd: { input.setSelectionEnd (value.toInteger(exec)); return; } + } + } + break; + case ID_TEXTAREA: { + DOM::HTMLTextAreaElement textarea = element; + switch (token) { + case TextAreaDefaultValue: { textarea.setDefaultValue(str); return; } + // read-only: form + case TextAreaAccessKey: { textarea.setAccessKey(str); return; } + case TextAreaCols: { textarea.setCols(value.toInteger(exec)); return; } + case TextAreaDisabled: { textarea.setDisabled(value.toBoolean(exec)); return; } + case TextAreaName: { textarea.setName(str); return; } + case TextAreaReadOnly: { textarea.setReadOnly(value.toBoolean(exec)); return; } + case TextAreaRows: { textarea.setRows(value.toInteger(exec)); return; } + case TextAreaTabIndex: { textarea.setTabIndex(value.toInteger(exec)); return; } + // read-only: type + case TextAreaValue: { textarea.setValue(str); return; } + case TextAreaSelectionStart: { textarea.setSelectionStart(value.toInteger(exec)); return; } + case TextAreaSelectionEnd: { textarea.setSelectionEnd (value.toInteger(exec)); return; } + } + } + break; + case ID_BUTTON: { + DOM::HTMLButtonElement button = element; + switch (token) { + // read-only: form + case ButtonAccessKey: { button.setAccessKey(str); return; } + case ButtonDisabled: { button.setDisabled(value.toBoolean(exec)); return; } + case ButtonName: { button.setName(str); return; } + case ButtonTabIndex: { button.setTabIndex(value.toInteger(exec)); return; } + // read-only: type + case ButtonValue: { button.setValue(str); return; } + } + } + break; + case ID_LABEL: { + DOM::HTMLLabelElement label = element; + switch (token) { + // read-only: form + case LabelAccessKey: { label.setAccessKey(str); return; } + case LabelHtmlFor: { label.setHtmlFor(str); return; } + } + } + break; +// case ID_FIELDSET: { +// DOM::HTMLFieldSetElement fieldSet = element; +// // read-only: form +// } +// break; + case ID_LEGEND: { + DOM::HTMLLegendElement legend = element; + switch (token) { + // read-only: form + case LegendAccessKey: { legend.setAccessKey(str); return; } + case LegendAlign: { legend.setAlign(str); return; } + } + } + break; + case ID_UL: { + DOM::HTMLUListElement uList = element; + switch (token) { + case UListCompact: { uList.setCompact(value.toBoolean(exec)); return; } + case UListType: { uList.setType(str); return; } + } + } + break; + case ID_OL: { + DOM::HTMLOListElement oList = element; + switch (token) { + case OListCompact: { oList.setCompact(value.toBoolean(exec)); return; } + case OListStart: { oList.setStart(value.toInteger(exec)); return; } + case OListType: { oList.setType(str); return; } + } + } + break; + case ID_DL: { + DOM::HTMLDListElement dList = element; + switch (token) { + case DListCompact: { dList.setCompact(value.toBoolean(exec)); return; } + } + } + break; + case ID_DIR: { + DOM::HTMLDirectoryElement directory = element; + switch (token) { + case DirectoryCompact: { directory.setCompact(value.toBoolean(exec)); return; } + } + } + break; + case ID_MENU: { + DOM::HTMLMenuElement menu = element; + switch (token) { + case MenuCompact: { menu.setCompact(value.toBoolean(exec)); return; } + } + } + break; + case ID_LI: { + DOM::HTMLLIElement li = element; + switch (token) { + case LIType: { li.setType(str); return; } + case LIValue: { li.setValue(value.toInteger(exec)); return; } + } + } + break; + case ID_DIV: { + DOM::HTMLDivElement div = element; + switch (token) { + case DivAlign: { div.setAlign(str); return; } + } + } + break; + case ID_P: { + DOM::HTMLParagraphElement paragraph = element; + switch (token) { + case ParagraphAlign: { paragraph.setAlign(str); return; } + } + } + break; + case ID_H1: + case ID_H2: + case ID_H3: + case ID_H4: + case ID_H5: + case ID_H6: { + DOM::HTMLHeadingElement heading = element; + switch (token) { + case HeadingAlign: { heading.setAlign(str); return; } + } + } + break; + case ID_BLOCKQUOTE: { + DOM::HTMLBlockquoteElement blockquote = element; + switch (token) { + case BlockQuoteCite: { blockquote.setCite(str); return; } + } + } + break; + case ID_Q: { + DOM::HTMLQuoteElement quote = element; + switch (token) { + case QuoteCite: { quote.setCite(str); return; } + } + } + break; + case ID_PRE: { + DOM::HTMLPreElement pre = element; + switch (token) { + case PreWidth: { pre.setWidth(value.toInteger(exec)); return; } + } + } + break; + case ID_BR: { + DOM::HTMLBRElement br = element; + switch (token) { + case BRClear: { br.setClear(str); return; } + } + } + break; + case ID_BASEFONT: { + DOM::HTMLBaseFontElement baseFont = element; + switch (token) { + case BaseFontColor: { baseFont.setColor(str); return; } + case BaseFontFace: { baseFont.setFace(str); return; } + case BaseFontSize: { baseFont.setSize(value.toInteger(exec)); return; } + } + } + break; + case ID_FONT: { + DOM::HTMLFontElement font = element; + switch (token) { + case FontColor: { font.setColor(str); return; } + case FontFace: { font.setFace(str); return; } + case FontSize: { font.setSize(str); return; } + } + } + break; + case ID_HR: { + DOM::HTMLHRElement hr = element; + switch (token) { + case HRAlign: { hr.setAlign(str); return; } + case HRNoShade: { hr.setNoShade(value.toBoolean(exec)); return; } + case HRSize: { hr.setSize(str); return; } + case HRWidth: { hr.setWidth(str); return; } + } + } + break; + case ID_INS: + case ID_DEL: { + DOM::HTMLModElement mod = element; + switch (token) { + case ModCite: { mod.setCite(str); return; } + case ModDateTime: { mod.setDateTime(str); return; } + } + } + break; + case ID_A: { + DOM::HTMLAnchorElement anchor = element; + switch (token) { + case AnchorAccessKey: { anchor.setAccessKey(str); return; } + case AnchorCharset: { anchor.setCharset(str); return; } + case AnchorCoords: { anchor.setCoords(str); return; } + case AnchorHref: { anchor.setHref(str); return; } + case AnchorHrefLang: { anchor.setHreflang(str); return; } + case AnchorSearch: { KURL href(anchor.href().string()); + TQString q = str.isEmpty() ? TQString() : str.string(); + href.setQuery(q); + anchor.setHref(href.url()); return; } + case AnchorName: { anchor.setName(str); return; } + case AnchorRel: { anchor.setRel(str); return; } + case AnchorRev: { anchor.setRev(str); return; } + case AnchorShape: { anchor.setShape(str); return; } + case AnchorTabIndex: { anchor.setTabIndex(value.toInteger(exec)); return; } + case AnchorTarget: { anchor.setTarget(str); return; } + case AnchorType: { anchor.setType(str); return; } + } + } + break; + case ID_IMG: { + DOM::HTMLImageElement image = element; + switch (token) { + case ImageName: { image.setName(str); return; } + case ImageAlign: { image.setAlign(str); return; } + case ImageAlt: { image.setAlt(str); return; } + case ImageBorder: { image.setBorder(str); return; } + case ImageHeight: { image.setHeight(value.toInteger(exec)); return; } + case ImageHspace: { image.setHspace(value.toInteger(exec)); return; } + case ImageIsMap: { image.setIsMap(value.toBoolean(exec)); return; } + case ImageLongDesc: { image.setLongDesc(str); return; } + case ImageSrc: { image.setSrc(str); return; } + case ImageUseMap: { image.setUseMap(str); return; } + case ImageVspace: { image.setVspace(value.toInteger(exec)); return; } + case ImageWidth: { image.setWidth(value.toInteger(exec)); return; } + } + } + break; + case ID_OBJECT: { + DOM::HTMLObjectElement object = element; + switch (token) { + // read-only: form + case ObjectCode: { object.setCode(str); return; } + case ObjectAlign: { object.setAlign(str); return; } + case ObjectArchive: { object.setArchive(str); return; } + case ObjectBorder: { object.setBorder(str); return; } + case ObjectCodeBase: { object.setCodeBase(str); return; } + case ObjectCodeType: { object.setCodeType(str); return; } + // read-only: ObjectContentDocument + case ObjectData: { object.setData(str); return; } + case ObjectDeclare: { object.setDeclare(value.toBoolean(exec)); return; } + case ObjectHeight: { object.setHeight(str); return; } + case ObjectHspace: { object.setHspace(value.toInteger(exec)); return; } + case ObjectName: { object.setName(str); return; } + case ObjectStandby: { object.setStandby(str); return; } + case ObjectTabIndex: { object.setTabIndex(value.toInteger(exec)); return; } + case ObjectType: { object.setType(str); return; } + case ObjectUseMap: { object.setUseMap(str); return; } + case ObjectVspace: { object.setVspace(value.toInteger(exec)); return; } + case ObjectWidth: { object.setWidth(str); return; } + } + } + break; + case ID_PARAM: { + DOM::HTMLParamElement param = element; + switch (token) { + case ParamName: { param.setName(str); return; } + case ParamType: { param.setType(str); return; } + case ParamValue: { param.setValue(str); return; } + case ParamValueType: { param.setValueType(str); return; } + } + } + break; + case ID_APPLET: { + DOM::HTMLAppletElement applet = element; + switch (token) { + case AppletAlign: { applet.setAlign(str); return; } + case AppletAlt: { applet.setAlt(str); return; } + case AppletArchive: { applet.setArchive(str); return; } + case AppletCode: { applet.setCode(str); return; } + case AppletCodeBase: { applet.setCodeBase(str); return; } + case AppletHeight: { applet.setHeight(str); return; } + case AppletHspace: { applet.setHspace(value.toInteger(exec)); return; } + case AppletName: { applet.setName(str); return; } + case AppletObject: { applet.setObject(str); return; } + case AppletVspace: { applet.setVspace(value.toInteger(exec)); return; } + case AppletWidth: { applet.setWidth(str); return; } + } + } + break; + case ID_MAP: { + DOM::HTMLMapElement map = element; + switch (token) { + // read-only: areas + case MapName: { map.setName(str); return; } + } + } + break; + case ID_AREA: { + DOM::HTMLAreaElement area = element; + switch (token) { + case AreaAccessKey: { area.setAccessKey(str); return; } + case AreaAlt: { area.setAlt(str); return; } + case AreaCoords: { area.setCoords(str); return; } + case AreaHref: { area.setHref(str); return; } + case AreaNoHref: { area.setNoHref(value.toBoolean(exec)); return; } + case AreaShape: { area.setShape(str); return; } + case AreaTabIndex: { area.setTabIndex(value.toInteger(exec)); return; } + case AreaTarget: { area.setTarget(str); return; } + } + } + break; + case ID_SCRIPT: { + DOM::HTMLScriptElement script = element; + switch (token) { + case ScriptText: { script.setText(str); return; } + case ScriptHtmlFor: { script.setHtmlFor(str); return; } + case ScriptEvent: { script.setEvent(str); return; } + case ScriptCharset: { script.setCharset(str); return; } + case ScriptDefer: { script.setDefer(value.toBoolean(exec)); return; } + case ScriptSrc: { script.setSrc(str); return; } + case ScriptType: { script.setType(str); return; } + } + } + break; + case ID_TABLE: { + DOM::HTMLTableElement table = element; + switch (token) { + case TableCaption: { table.setCaption(n); return; } // type HTMLTableCaptionElement + case TableTHead: { table.setTHead(n); return; } // type HTMLTableSectionElement + case TableTFoot: { table.setTFoot(n); return; } // type HTMLTableSectionElement + // read-only: rows + // read-only: tbodies + case TableAlign: { table.setAlign(str); return; } + case TableBgColor: { table.setBgColor(str); return; } + case TableBorder: { table.setBorder(str); return; } + case TableCellPadding: { table.setCellPadding(str); return; } + case TableCellSpacing: { table.setCellSpacing(str); return; } + case TableFrame: { table.setFrame(str); return; } + case TableRules: { table.setRules(str); return; } + case TableSummary: { table.setSummary(str); return; } + case TableWidth: { table.setWidth(str); return; } + } + } + break; + case ID_CAPTION: { + DOM::HTMLTableCaptionElement tableCaption = element; + switch (token) { + case TableCaptionAlign: { tableCaption.setAlign(str); return; } + } + } + break; + case ID_COL: + case ID_COLGROUP: { + DOM::HTMLTableColElement tableCol = element; + switch (token) { + case TableColAlign: { tableCol.setAlign(str); return; } + case TableColCh: { tableCol.setCh(str); return; } + case TableColChOff: { tableCol.setChOff(str); return; } + case TableColSpan: { tableCol.setSpan(value.toInteger(exec)); return; } + case TableColVAlign: { tableCol.setVAlign(str); return; } + case TableColWidth: { tableCol.setWidth(str); return; } + } + } + break; + case ID_THEAD: + case ID_TBODY: + case ID_TFOOT: { + DOM::HTMLTableSectionElement tableSection = element; + switch (token) { + case TableSectionAlign: { tableSection.setAlign(str); return; } + case TableSectionCh: { tableSection.setCh(str); return; } + case TableSectionChOff: { tableSection.setChOff(str); return; } + case TableSectionVAlign: { tableSection.setVAlign(str); return; } + // read-only: rows + } + } + break; + case ID_TR: { + DOM::HTMLTableRowElement tableRow = element; + switch (token) { + // read-only: rowIndex + // read-only: sectionRowIndex + // read-only: cells + case TableRowAlign: { tableRow.setAlign(str); return; } + case TableRowBgColor: { tableRow.setBgColor(str); return; } + case TableRowCh: { tableRow.setCh(str); return; } + case TableRowChOff: { tableRow.setChOff(str); return; } + case TableRowVAlign: { tableRow.setVAlign(str); return; } + } + } + break; + case ID_TH: + case ID_TD: { + DOM::HTMLTableCellElement tableCell = element; + switch (token) { + // read-only: cellIndex + case TableCellAbbr: { tableCell.setAbbr(str); return; } + case TableCellAlign: { tableCell.setAlign(str); return; } + case TableCellAxis: { tableCell.setAxis(str); return; } + case TableCellBgColor: { tableCell.setBgColor(str); return; } + case TableCellCh: { tableCell.setCh(str); return; } + case TableCellChOff: { tableCell.setChOff(str); return; } + case TableCellColSpan: { tableCell.setColSpan(value.toInteger(exec)); return; } + case TableCellHeaders: { tableCell.setHeaders(str); return; } + case TableCellHeight: { tableCell.setHeight(str); return; } + case TableCellNoWrap: { tableCell.setNoWrap(value.toBoolean(exec)); return; } + case TableCellRowSpan: { tableCell.setRowSpan(value.toInteger(exec)); return; } + case TableCellScope: { tableCell.setScope(str); return; } + case TableCellVAlign: { tableCell.setVAlign(str); return; } + case TableCellWidth: { tableCell.setWidth(str); return; } + } + } + break; + case ID_FRAMESET: { + DOM::HTMLFrameSetElement frameSet = element; + switch (token) { + case FrameSetCols: { frameSet.setCols(str); return; } + case FrameSetRows: { frameSet.setRows(str); return; } + } + } + break; + case ID_LAYER: { + DOM::HTMLLayerElement layerElement = element; + switch (token) { + case LayerTop: { layerElement.setTop(value.toInteger(exec)); return; } + case LayerLeft: { layerElement.setLeft(value.toInteger(exec)); return; } + case LayerVisibility: { layerElement.setVisibility(str); return; } + case LayerBgColor: { layerElement.setBgColor(str); return; } + // read-only: layers, clip + } + } + break; + case ID_FRAME: { + DOM::HTMLFrameElement frameElement = element; + switch (token) { + // read-only: FrameContentDocument: + case FrameFrameBorder: { frameElement.setFrameBorder(str); return; } + case FrameLongDesc: { frameElement.setLongDesc(str); return; } + case FrameMarginHeight: { frameElement.setMarginHeight(str); return; } + case FrameMarginWidth: { frameElement.setMarginWidth(str); return; } + case FrameName: { frameElement.setName(str); return; } + case FrameNoResize: { frameElement.setNoResize(value.toBoolean(exec)); return; } + case FrameScrolling: { frameElement.setScrolling(str); return; } + case FrameSrc: { frameElement.setSrc(str); return; } + case FrameLocation: { + static_cast<DOM::HTMLFrameElementImpl *>(frameElement.handle())->setLocation(str); + return; + } + } + } + break; + case ID_IFRAME: { + DOM::HTMLIFrameElement iFrame = element; + switch (token) { + case IFrameAlign: { iFrame.setAlign(str); return; } + // read-only: IFrameContentDocument + case IFrameFrameBorder: { iFrame.setFrameBorder(str); return; } + case IFrameHeight: { iFrame.setHeight(str); return; } + case IFrameLongDesc: { iFrame.setLongDesc(str); return; } + case IFrameMarginHeight: { iFrame.setMarginHeight(str); return; } + case IFrameMarginWidth: { iFrame.setMarginWidth(str); return; } + case IFrameName: { iFrame.setName(str); return; } + case IFrameScrolling: { iFrame.setScrolling(str); return; } + case IFrameSrc: { iFrame.setSrc(str); return; } + case IFrameWidth: { iFrame.setWidth(str); return; } + } + break; + } + } + + // generic properties + switch (token) { + case ElementId: + element.setId(str); + return; + case ElementTitle: + element.setTitle(str); + return; + case ElementLang: + element.setLang(str); + return; + case ElementDir: + element.setDir(str); + return; + case ElementClassName: + element.setClassName(str); + return; + case ElementInnerHTML: + element.setInnerHTML(str); + return; + case ElementInnerText: + element.setInnerText(str); + return; + default: + kdDebug(6070) << "WARNING: KJS::HTMLElement::putValueProperty unhandled token " << token << " thisTag=" << element.tagName().string() << " str=" << str.string() << endl; + } +} + +//Prototype mess for this... +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLElementProto, DOMElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLElement", HTMLElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLElementPseudoCtor, "HTMLElement", HTMLElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLHtmlElement", HTMLHtmlElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLHtmlElementPseudoCtor, "HTMLHtmlElement", HTMLHtmlElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLHeadElement", HTMLHeadElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLHeadElementPseudoCtor, "HTMLHeadElement", HTMLHeadElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLLinkElement", HTMLLinkElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLLinkElementPseudoCtor, "HTMLLinkElement", HTMLLinkElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLTitleElement", HTMLTitleElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTitleElementPseudoCtor, "HTMLTitleElement", HTMLTitleElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLMetaElement", HTMLMetaElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLMetaElementPseudoCtor, "HTMLMetaElement", HTMLMetaElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLBaseElement", HTMLBaseElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLBaseElementPseudoCtor, "HTMLBaseElement", HTMLBaseElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLIsIndexElement", HTMLIsIndexElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLIsIndexElementPseudoCtor, "HTMLIsIndexElement", HTMLIsIndexElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLStyleElement", HTMLStyleElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLStyleElementPseudoCtor, "HTMLStyleElement", HTMLStyleElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLBodyElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLBodyElement", HTMLBodyElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLBodyElementPseudoCtor, "HTMLBodyElement", HTMLBodyElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLFormElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLFormElement", HTMLFormElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLFormElementPseudoCtor, "HTMLFormElement", HTMLFormElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLSelectElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLSelectElement", HTMLSelectElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLSelectElementPseudoCtor, "HTMLSelectElement", HTMLSelectElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLOptGroupElement", HTMLOptGroupElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLOptGroupElementPseudoCtor, "HTMLOptGroupElement", HTMLOptGroupElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLOptionElement", HTMLOptionElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLOptionElementPseudoCtor, "HTMLOptionElement", HTMLOptionElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLInputElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLInputElement", HTMLInputElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLInputElementPseudoCtor, "HTMLInputElement", HTMLInputElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLTextAreaElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLTextAreaElement", HTMLTextAreaElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTextAreaElementPseudoCtor, "HTMLTextAreaElement", HTMLTextAreaElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLButtonElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLButtonElement", HTMLButtonElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLButtonElementPseudoCtor, "HTMLButtonElement", HTMLButtonElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLLabelElement", HTMLLabelElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLLabelElementPseudoCtor, "HTMLLabelElement", HTMLLabelElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLFieldSetElement", HTMLFieldSetElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLFieldSetElementPseudoCtor, "HTMLFieldSetElement", HTMLFieldSetElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLLegendElement", HTMLLegendElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLLegendElementPseudoCtor, "HTMLLegendElement", HTMLLegendElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLUListElement", HTMLUListElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLUListElementPseudoCtor, "HTMLUListElement", HTMLUListElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLOListElement", HTMLOListElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLOListElementPseudoCtor, "HTMLOListElement", HTMLOListElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLDListElement", HTMLDListElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLDListElementPseudoCtor, "HTMLDListElement", HTMLDListElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLDirectoryElement", HTMLDirectoryElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLDirectoryElementPseudoCtor, "HTMLDirectoryElement", HTMLDirectoryElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLMenuElement", HTMLMenuElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLMenuElementPseudoCtor, "HTMLMenuElement", HTMLMenuElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLLIElement", HTMLLIElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLLIElementPseudoCtor, "HTMLLIElement", HTMLLIElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLDivElement", HTMLDivElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLDivElementPseudoCtor, "HTMLDivElement", HTMLDivElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLParagraphElement", HTMLParagraphElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLParagraphElementPseudoCtor, "HTMLParagraphElement", HTMLParagraphElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLHeadingElement", HTMLHeadingElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLHeadingElementPseudoCtor, "HTMLHeadingElement", HTMLHeadingElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLBlockQuoteElement", HTMLBlockQuoteElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLBlockQuoteElementPseudoCtor, "HTMLBlockQuoteElement", HTMLBlockQuoteElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLQuoteElement", HTMLQuoteElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLQuoteElementPseudoCtor, "HTMLQuoteElement", HTMLQuoteElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLPreElement", HTMLPreElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLPreElementPseudoCtor, "HTMLPreElement", HTMLPreElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLBRElement", HTMLBRElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLBRElementPseudoCtor, "HTMLBRElement", HTMLBRElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLBaseFontElement", HTMLBaseFontElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLBaseFontElementPseudoCtor, "HTMLBaseFontElement", HTMLBaseFontElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLFontElement", HTMLFontElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLFontElementPseudoCtor, "HTMLFontElement", HTMLFontElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLHRElement", HTMLHRElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLHRElementPseudoCtor, "HTMLHRElement", HTMLHRElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLModElement", HTMLModElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLModElementPseudoCtor, "HTMLModElement", HTMLModElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLAnchorElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLAnchorElement", HTMLAnchorElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLAnchorElementPseudoCtor, "HTMLAnchorElement", HTMLAnchorElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLImageElement", HTMLImageElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLImageElementPseudoCtor, "HTMLImageElement", HTMLImageElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLObjectElement", HTMLObjectElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLObjectElementPseudoCtor, "HTMLObjectElement", HTMLObjectElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLParamElement", HTMLParamElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLParamElementPseudoCtor, "HTMLParamElement", HTMLParamElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLAppletElement", HTMLAppletElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLAppletElementPseudoCtor, "HTMLAppletElement", HTMLAppletElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLMapElement", HTMLMapElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLMapElementPseudoCtor, "HTMLMapElement", HTMLMapElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLAreaElement", HTMLAreaElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLAreaElementPseudoCtor, "HTMLAreaElement", HTMLAreaElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLScriptElement", HTMLScriptElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLScriptElementPseudoCtor, "HTMLScriptElement", HTMLScriptElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLTableElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLTableElement", HTMLTableElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTableElementPseudoCtor, "HTMLTableElement", HTMLTableElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLTableCaptionElement", HTMLTableCaptionElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTableCaptionElementPseudoCtor, "HTMLTableCaptionElement", HTMLTableCaptionElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLTableColElement", HTMLTableColElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTableColElementPseudoCtor, "HTMLTableColElement", HTMLTableColElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLTableSectionElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLTableSectionElement", HTMLTableSectionElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTableSectionElementPseudoCtor, "HTMLTableSectionElement", HTMLTableSectionElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLTableRowElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLTableRowElement", HTMLTableRowElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTableRowElementPseudoCtor, "HTMLTableRowElement", HTMLTableRowElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLTableCellElement", HTMLTableCellElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLTableCellElementPseudoCtor, "HTMLTableCellElement", HTMLTableCellElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLFrameSetElement", HTMLFrameSetElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLFrameSetElementPseudoCtor, "HTMLFrameSetElement", HTMLFrameSetElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLLayerElement", HTMLLayerElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLLayerElementPseudoCtor, "HTMLLayerElement", HTMLLayerElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLFrameElement", HTMLFrameElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLFrameElementPseudoCtor, "HTMLFrameElement", HTMLFrameElementProto) + +KJS_EMPTY_PROTOTYPE_WITH_PROTOTYPE("HTMLIFrameElement", HTMLIFrameElementProto, HTMLElementProto) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLIFrameElementPseudoCtor, "HTMLIFrameElement", HTMLIFrameElementProto) + +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLMarqueeElementProto, HTMLElementProto) +KJS_IMPLEMENT_PROTOTYPE("HTMLMarqueeElement", HTMLMarqueeElementProto, HTMLElementFunction) +IMPLEMENT_PSEUDO_CONSTRUCTOR(HTMLMarqueeElementPseudoCtor, "HTMLMarqueeElement", HTMLMarqueeElementProto) + +static Object prototypeForID(ExecState* exec, DOM::NodeImpl::Id id) { + switch (id) { + case ID_HTML: + return HTMLHtmlElementProto::self(exec); + case ID_HEAD: + return HTMLHeadElementProto::self(exec); + case ID_LINK: + return HTMLLinkElementProto::self(exec); + case ID_TITLE: + return HTMLTitleElementProto::self(exec); + case ID_META: + return HTMLMetaElementProto::self(exec); + case ID_BASE: + return HTMLBaseElementProto::self(exec); + case ID_ISINDEX: + return HTMLIsIndexElementProto::self(exec); + case ID_STYLE: + return HTMLStyleElementProto::self(exec); + case ID_BODY: + return HTMLBodyElementProto::self(exec); + case ID_FORM: + return HTMLFormElementProto::self(exec); + case ID_SELECT: + return HTMLSelectElementProto::self(exec); + case ID_OPTGROUP: + return HTMLOptGroupElementProto::self(exec); + case ID_OPTION: + return HTMLOptionElementProto::self(exec); + case ID_INPUT: + return HTMLInputElementProto::self(exec); + case ID_TEXTAREA: + return HTMLTextAreaElementProto::self(exec); + case ID_BUTTON: + return HTMLButtonElementProto::self(exec); + case ID_LABEL: + return HTMLLabelElementProto::self(exec); + case ID_FIELDSET: + return HTMLFieldSetElementProto::self(exec); + case ID_LEGEND: + return HTMLLegendElementProto::self(exec); + case ID_UL: + return HTMLUListElementProto::self(exec); + case ID_OL: + return HTMLOListElementProto::self(exec); + case ID_DL: + return HTMLDListElementProto::self(exec); + case ID_DIR: + return HTMLDirectoryElementProto::self(exec); + case ID_MENU: + return HTMLMenuElementProto::self(exec); + case ID_LI: + return HTMLLIElementProto::self(exec); + case ID_DIV: + return HTMLDivElementProto::self(exec); + case ID_P: + return HTMLParagraphElementProto::self(exec); + case ID_H1: + case ID_H2: + case ID_H3: + case ID_H4: + case ID_H5: + case ID_H6: + return HTMLHeadingElementProto::self(exec); + case ID_BLOCKQUOTE: + return HTMLBlockQuoteElementProto::self(exec); + case ID_Q: + return HTMLQuoteElementProto::self(exec); + case ID_PRE: + return HTMLPreElementProto::self(exec); + case ID_BR: + return HTMLBRElementProto::self(exec); + case ID_BASEFONT: + return HTMLBaseFontElementProto::self(exec); + case ID_FONT: + return HTMLFontElementProto::self(exec); + case ID_HR: + return HTMLHRElementProto::self(exec); + case ID_INS: + case ID_DEL: + return HTMLModElementProto::self(exec); + case ID_A: + return HTMLAnchorElementProto::self(exec); + case ID_IMG: + return HTMLImageElementProto::self(exec); + case ID_OBJECT: + return HTMLObjectElementProto::self(exec); + case ID_PARAM: + return HTMLParamElementProto::self(exec); + case ID_APPLET: + return HTMLAppletElementProto::self(exec); + case ID_MAP: + return HTMLMapElementProto::self(exec); + case ID_AREA: + return HTMLAreaElementProto::self(exec); + case ID_SCRIPT: + return HTMLScriptElementProto::self(exec); + case ID_TABLE: + return HTMLTableElementProto::self(exec); + case ID_CAPTION: + return HTMLTableCaptionElementProto::self(exec); + case ID_COL: + case ID_COLGROUP: + return HTMLTableColElementProto::self(exec); + case ID_THEAD: + case ID_TBODY: + case ID_TFOOT: + return HTMLTableSectionElementProto::self(exec); + case ID_TR: + return HTMLTableRowElementProto::self(exec); + case ID_TD: + case ID_TH: + return HTMLTableCellElementProto::self(exec); + case ID_FRAMESET: + return HTMLFrameSetElementProto::self(exec); + case ID_LAYER: + return HTMLLayerElementProto::self(exec); + case ID_FRAME: + return HTMLFrameElementProto::self(exec); + case ID_IFRAME: + return HTMLIFrameElementProto::self(exec); + case ID_MARQUEE: + return HTMLMarqueeElementProto::self(exec); + default: + return HTMLElementProto::self(exec); + } +} + +// ------------------------------------------------------------------------- +/* Source for HTMLCollectionProtoTable. +@begin HTMLCollectionProtoTable 3 + item HTMLCollection::Item DontDelete|Function 1 + namedItem HTMLCollection::NamedItem DontDelete|Function 1 + tags HTMLCollection::Tags DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(HTMLCollectionProto) +IMPLEMENT_PROTOFUNC_DOM(HTMLCollectionProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("HTMLCollection", HTMLCollectionProto,HTMLCollectionProtoFunc) + +const ClassInfo KJS::HTMLCollection::info = { "HTMLCollection", 0, 0, 0 }; + +KJS::HTMLCollection::HTMLCollection(ExecState *exec, const DOM::HTMLCollection& c) + : DOMObject(HTMLCollectionProto::self(exec)), collection(c), hidden(false) {} + +KJS::HTMLCollection::HTMLCollection(const KJS::Object& proto, const DOM::HTMLCollection& c) + : DOMObject(proto), collection(c), hidden(false) {} + +KJS::HTMLCollection::~HTMLCollection() +{ + ScriptInterpreter::forgetDOMObject(collection.handle()); +} + +bool KJS::HTMLCollection::toBoolean(ExecState *) const { + return !hidden; +} + +// We have to implement hasProperty since we don't use a hashtable for 'selectedIndex' and 'length', +// and for indices in "for (..in..)" +bool KJS::HTMLCollection::hasProperty(ExecState *exec, const Identifier &p) const +{ + if (p == lengthPropertyName) + return true; + if ( collection.handle()->getType() == HTMLCollectionImpl::SELECT_OPTIONS && + ( p == "selectedIndex" || p == "value" ) ) + return true; + + bool ok; + unsigned long pos = p.toULong(&ok); + if (ok && pos < collection.length()) + return true; + + return DOMObject::hasProperty(exec, p); +} + +ReferenceList KJS::HTMLCollection::propList(ExecState *exec, bool recursive) +{ + ReferenceList properties = ObjectImp::propList(exec,recursive); + + for (unsigned i = 0; i < collection.length(); ++i) { + if (!ObjectImp::hasProperty(exec,Identifier::from(i))) { + properties.append(Reference(this, i)); + } + } + + if (!ObjectImp::hasProperty(exec, lengthPropertyName)) + properties.append(Reference(this, lengthPropertyName)); + + return properties; +} + +Value KJS::HTMLCollection::tryGet(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLCollection::tryGet " << propertyName.ascii() << endl; +#endif + if (propertyName == lengthPropertyName) + { +#ifdef KJS_VERBOSE + kdDebug(6070) << " collection length is " << collection.length() << endl; +#endif + return Number(collection.length()); + } + + if (collection.handle()->getType() == HTMLCollectionImpl::SELECT_OPTIONS) { + DOM::HTMLSelectElement parentSelect = collection.base(); + if ( parentSelect.isNull() ) + return Undefined(); + if (propertyName == "selectedIndex") { + // NON-STANDARD options.selectedIndex + return Number(parentSelect.selectedIndex()); + } else if ( propertyName == "value" ) { + // NON-STANDARD options.value + return String(parentSelect.value()); + } + } + + // Look in the prototype (for functions) before assuming it's an item's name + Object proto = Object::dynamicCast(prototype()); + if (proto.isValid() && proto.hasProperty(exec,propertyName)) + return proto.get(exec,propertyName); + + // name or index ? + bool ok; + unsigned int u = propertyName.toULong(&ok); + if (ok) { + if ( u < collection.length() ) { + DOM::Node node = collection.item(u); + return getDOMNode(exec,node); + } else + return Undefined(); + } + else + return getNamedItems(exec,propertyName); +} + +// HTMLCollections are strange objects, they support both get and call, +// so that document.forms.item(0) and document.forms(0) both work. +Value KJS::HTMLCollection::call(ExecState *exec, Object &thisObj, const List &args) +{ + // This code duplication is necessary, HTMLCollection 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 HTMLCollection"); + exec->setException(err); + } + return val; +} + +Value KJS::HTMLCollection::tryCall(ExecState *exec, Object &, const List &args) +{ + // Do not use thisObj here. It can be the HTMLDocument, in the document.forms(i) case. + /*if( thisObj.imp() != this ) + { + kdDebug(6070) << "WARNING: thisObj.imp() != this in HTMLCollection::tryCall" << endl; + KJS::printInfo(exec,"KJS::HTMLCollection::tryCall thisObj",thisObj,-1); + KJS::printInfo(exec,"KJS::HTMLCollection::tryCall this",Value(this),-1); + }*/ + // Also, do we need the TypeError test here ? + + if (args.size() == 1) { + // support for document.all(<index>) etc. + bool ok; + UString s = args[0].toString(exec); + unsigned int u = s.toULong(&ok); + if (ok) { + DOM::Element element = collection.item(u); + return getDOMNode(exec,element); + } + // support for document.images('<name>') etc. + return getNamedItems(exec,Identifier(s)); + } + else if (args.size() >= 1) // the second arg, if set, is the index of the item we want + { + bool ok; + UString s = args[0].toString(exec); + unsigned int u = args[1].toString(exec).toULong(&ok); + if (ok) + { + DOM::DOMString pstr = s.string(); + DOM::Node node = collection.namedItem(pstr); + while (!node.isNull()) { + if (!u) + return getDOMNode(exec,node); + node = collection.nextNamedItem(pstr); + --u; + } + } + } + return Undefined(); +} + +Value KJS::HTMLCollection::getNamedItems(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLCollection::getNamedItems " << propertyName.ascii() << endl; +#endif + + DOM::DOMString pstr = propertyName.string(); + + TQValueList<DOM::NodeImpl*> matches = collection.handle()->namedItems(pstr); + + if (!matches.isEmpty()) { + if (matches.size() == 1) { + DOM::Node node(matches[0]); +#ifdef KJS_VERBOSE + kdDebug(6070) << "returning single node" << endl; +#endif + return getDOMNode(exec,node); + } + else { + // multiple items, return a collection + TQValueList<DOM::Node> nodes; + for (TQValueList<DOM::NodeImpl*>::const_iterator i = matches.begin(); + i != matches.end(); ++i) + nodes.append(DOM::Node(*i)); +#ifdef KJS_VERBOSE + kdDebug(6070) << "returning list of " << nodes.count() << " nodes" << endl; +#endif + return Value(new DOMNamedNodesCollection(exec, nodes)); + } + } +#ifdef KJS_VERBOSE + kdDebug(6070) << "not found" << endl; +#endif + return Undefined(); +} + +Value KJS::HTMLCollectionProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::HTMLCollection, thisObj ); + DOM::HTMLCollection coll = static_cast<KJS::HTMLCollection *>(thisObj.imp())->toCollection(); + + switch (id) { + case KJS::HTMLCollection::Item: + { + // support for item(<index>) (DOM) + bool ok; + UString s = args[0].toString(exec); + unsigned int u = s.toULong(&ok); + if (ok) { + return getDOMNode(exec,coll.item(u)); + } + // support for item('<name>') (IE only) + kdWarning() << "non-standard HTMLCollection.item('" << s.ascii() << "') called, use namedItem instead" << endl; + return getDOMNode(exec,coll.namedItem(s.string())); + } + case KJS::HTMLCollection::Tags: + { + DOM::DOMString tagName = args[0].toString(exec).string(); + DOM::NodeList list; + // getElementsByTagName exists in Document and in Element, pick up the right one + if ( coll.base().nodeType() == DOM::Node::DOCUMENT_NODE ) + { + DOM::Document doc = coll.base(); + list = doc.getElementsByTagName(tagName); +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLCollectionProtoFunc::tryCall document.tags(" << tagName.string() << ") -> " << list.length() << " items in node list" << endl; +#endif + } else + { + DOM::Element e = coll.base(); + list = e.getElementsByTagName(tagName); +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLCollectionProtoFunc::tryCall element.tags(" << tagName.string() << ") -> " << list.length() << " items in node list" << endl; +#endif + } + return getDOMNodeList(exec, list); + } + case KJS::HTMLCollection::NamedItem: + { + Value val = static_cast<HTMLCollection *>(thisObj.imp())->getNamedItems(exec, Identifier(args[0].toString(exec))); + // Must return null when asking for a named item that isn't in the collection + // (DOM2 testsuite, HTMLCollection12 test) + if ( val.type() == KJS::UndefinedType ) + return Null(); + else + return val; + } + default: + return Undefined(); + } +} + +// ------------------------------------------------------------------------- +/* Source for HTMLSelectCollectionProtoTable. +@begin HTMLSelectCollectionProtoTable 1 + add HTMLSelectCollection::Add DontDelete|Function 2 +@end +*/ +KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(HTMLSelectCollectionProto, HTMLCollectionProto) +IMPLEMENT_PROTOFUNC_DOM(HTMLSelectCollectionProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("HTMLOptionsCollection", HTMLSelectCollectionProto, HTMLSelectCollectionProtoFunc) + +const ClassInfo KJS::HTMLSelectCollection::info = { "HTMLOptionsCollection", &HTMLCollection::info, 0, 0 }; + +KJS::HTMLSelectCollection::HTMLSelectCollection(ExecState *exec, const DOM::HTMLCollection& c, + const DOM::HTMLSelectElement& e) + : HTMLCollection(HTMLSelectCollectionProto::self(exec), c), element(e) { } + +Value KJS::HTMLSelectCollection::tryGet(ExecState *exec, const Identifier &p) const +{ + if (p == "selectedIndex") + return Number(element.selectedIndex()); + + return HTMLCollection::tryGet(exec, p); +} + +void KJS::HTMLSelectCollection::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "KJS::HTMLSelectCollection::tryPut " << propertyName.qstring() << endl; +#endif + if ( propertyName == "selectedIndex" ) { + element.setSelectedIndex( value.toInteger( exec ) ); + return; + } + // resize ? + else if (propertyName == lengthPropertyName) { + unsigned newLen; + bool converted = value.toUInt32(newLen); + + if (!converted) { + return; + } + + long diff = element.length() - newLen; + + if (diff < 0) { // add dummy elements + do { + element.add(element.ownerDocument().createElement("OPTION"), DOM::HTMLElement()); + } while (++diff); + } + else // remove elements + while (diff-- > 0) + element.remove(newLen + diff); + + return; + } + // an index ? + bool ok; + unsigned int u = propertyName.toULong(&ok); + if (!ok) + return; + + if (value.isA(NullType) || value.isA(UndefinedType)) { + // null and undefined delete. others, too ? + element.remove(u); + return; + } + + // is v an option element ? + DOM::Node node = KJS::toNode(value); + if (node.isNull() || node.elementId() != ID_OPTION) + return; + + DOM::HTMLOptionElement option = static_cast<DOM::HTMLOptionElement>(node); + if ( option.ownerDocument() != element.ownerDocument() ) + option = static_cast<DOM::HTMLOptionElement>(element.ownerDocument().importNode(option, true)); + long diff = long(u) - element.length(); + DOM::HTMLElement before; + // out of array bounds ? first insert empty dummies + if (diff > 0) { + while (diff--) { + element.add(element.ownerDocument().createElement("OPTION"), before); + } + // replace an existing entry ? + } else if (diff < 0) { + before = element.options().item(u+1); + element.remove(u); + } + // finally add the new element + element.add(option, before); +} + + +Value KJS::HTMLSelectCollectionProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::HTMLSelectCollection, thisObj ); + DOM::HTMLSelectElement element = static_cast<KJS::HTMLSelectCollection *>(thisObj.imp())->toElement(); + + switch (id) { + case KJS::HTMLSelectCollection::Add: + { + //Non-standard select.options.add. + //The first argument is the item, 2nd is offset. + //IE and Mozilla are both quite picky here, too... + DOM::Node node = KJS::toNode(args[0]); + if (node.isNull() || node.elementId() != ID_OPTION) { + Object err = Error::create(exec, GeneralError, "Invalid argument to HTMLOptionsCollection::add"); + exec->setException(err); + return Undefined(); + } + + DOM::HTMLOptionElement option = static_cast<DOM::HTMLOptionElement>(node); + if ( option.ownerDocument() != element.ownerDocument() ) //### remove this once auto-adopt works... + option = static_cast<DOM::HTMLOptionElement>(element.ownerDocument().importNode(option, true)); + + int pos = 0; + //By default append, if not specified or null.. + if (args[1].isA(UndefinedType)) + pos = element.length(); + else + pos = (int)args[1].toNumber(exec); + + if (pos < 0) { + Object err = Error::create(exec, GeneralError, "Invalid index argument to HTMLOptionsCollection::add"); + exec->setException(err); + return Undefined(); + } + + if (pos >= element.length()) { + //Append + element.add(option, DOM::Node()); + } else { + //Find what to prepend before.. + DOM::HTMLSelectElementImpl* impl = static_cast<HTMLSelectElementImpl*>(element.handle()); + TQMemArray<HTMLGenericFormElementImpl*> items = impl->listItems(); + int dummy; + impl->insertBefore(option.handle(), items.at(pos), dummy); + } + return Undefined(); + break; + } + default: + break; + } + return Undefined(); +} + + +////////////////////// Option Object //////////////////////// + +OptionConstructorImp::OptionConstructorImp(ExecState *exec, const DOM::Document &d) + : ObjectImp(), doc(d) +{ + // ## isn't there some redundancy between ObjectImp::_proto and the "prototype" property ? + //put(exec,"prototype", ...,DontEnum|DontDelete|ReadOnly); + + // no. of arguments for constructor + // ## is 4 correct ? 0 to 4, it seems to be + put(exec,lengthPropertyName, Number(4), ReadOnly|DontDelete|DontEnum); +} + +bool OptionConstructorImp::implementsConstruct() const +{ + return true; +} + +Object OptionConstructorImp::construct(ExecState *exec, const List &args) +{ + DOM::Element el = doc.createElement("OPTION"); + DOM::HTMLOptionElement opt = static_cast<DOM::HTMLOptionElement>(el); + int sz = args.size(); + DOM::Text t = doc.createTextNode(""); + try { opt.appendChild(t); } + catch(DOM::DOMException& e) { + // #### exec->setException ? + } + if (sz > 0) + t.setData(args[0].toString(exec).string()); // set the text + if (sz > 1) + opt.setValue(args[1].toString(exec).string()); + if (sz > 2) + opt.setDefaultSelected(args[2].toBoolean(exec)); + if (sz > 3) + opt.setSelected(args[3].toBoolean(exec)); + + return Object::dynamicCast(getDOMNode(exec,opt)); +} + +////////////////////// Image Object //////////////////////// + +//Like in other browsers, we merely make a new HTMLImageElement +//not in tree for this. +ImageConstructorImp::ImageConstructorImp(ExecState *, const DOM::Document &d) + : ObjectImp(), doc(d) +{ +} + +bool ImageConstructorImp::implementsConstruct() const +{ + return true; +} + +Object ImageConstructorImp::construct(ExecState *exec, const List &list) +{ + bool widthSet = false, heightSet = false; + int width = 0, height = 0; + if (list.size() > 0) { + widthSet = true; + Value w = list.at(0); + width = w.toInt32(exec); + } + if (list.size() > 1) { + heightSet = true; + Value h = list.at(1); + height = h.toInt32(exec); + } + + HTMLImageElement image(doc.createElement("image")); + + if (widthSet) + image.setWidth(width); + + if (heightSet) + image.setHeight(height); + + return Object::dynamicCast(getDOMNode(exec,image)); +} + +Value getHTMLCollection(ExecState *exec, const DOM::HTMLCollection& c, bool hide) +{ + Value coll = cacheDOMObject<DOM::HTMLCollection, KJS::HTMLCollection>(exec, c); + if (hide) { + KJS::HTMLCollection *impl = static_cast<KJS::HTMLCollection*>(coll.imp()); + impl->hide(); + } + return coll; +} + +Value getSelectHTMLCollection(ExecState *exec, const DOM::HTMLCollection& c, const DOM::HTMLSelectElement& e) +{ + DOMObject *ret; + if (c.isNull()) + return Null(); + ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter()); + if ((ret = interp->getDOMObject(c.handle()))) + return Value(ret); + else { + ret = new HTMLSelectCollection(exec, c, e); + interp->putDOMObject(c.handle(),ret); + return Value(ret); + } +} + +} //namespace KJS diff --git a/tdehtml/ecma/kjs_html.h b/tdehtml/ecma/kjs_html.h new file mode 100644 index 000000000..53da38462 --- /dev/null +++ b/tdehtml/ecma/kjs_html.h @@ -0,0 +1,294 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 1999 Harri Porten (porten@kde.org) + * 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 + */ + +#ifndef _KJS_HTML_H_ +#define _KJS_HTML_H_ + +#include "dom/html_document.h" +#include "dom/html_base.h" +#include "dom/html_misc.h" +#include "dom/html_form.h" +#include "misc/loader_client.h" + +#include "ecma/kjs_binding.h" +#include "ecma/kjs_dom.h" +#include "xml/dom_nodeimpl.h" // for NodeImpl::Id + +namespace KJS { + + class HTMLElement; + + class HTMLDocument : public DOMDocument { + public: + HTMLDocument(ExecState *exec, const DOM::HTMLDocument& d); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + void putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/); + virtual bool hasProperty(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Title, Referrer, Domain, URL, Body, Location, Cookie, + Images, Applets, Links, Forms, Layers, Anchors, Scripts, All, Clear, Open, Close, + Write, WriteLn, GetElementsByName, GetSelection, CaptureEvents, ReleaseEvents, + BgColor, FgColor, AlinkColor, LinkColor, VlinkColor, LastModified, + Height, Width, Dir, Frames, CompatMode }; + DOM::Document toDocument() const { return static_cast<DOM::Document>( node ); } + }; + + DEFINE_PSEUDO_CONSTRUCTOR(HTMLDocumentPseudoCtor) + + class HTMLElement : public DOMElement { + public: + HTMLElement(ExecState *exec, const DOM::HTMLElement& e); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + void putValueProperty(ExecState *exec, int token, const Value& value, int); + virtual bool hasProperty(ExecState *exec, const Identifier &propertyName) const; + virtual UString toString(ExecState *exec) const; + virtual void pushEventHandlerScope(ExecState *exec, ScopeChain &scope) const; + virtual const ClassInfo* classInfo() const; + static const ClassInfo info; + + static const ClassInfo html_info, head_info, link_info, title_info, + meta_info, base_info, isIndex_info, style_info, body_info, form_info, + select_info, optGroup_info, option_info, input_info, textArea_info, + button_info, label_info, fieldSet_info, legend_info, ul_info, ol_info, + dl_info, dir_info, menu_info, li_info, div_info, p_info, heading_info, + blockQuote_info, q_info, pre_info, br_info, baseFont_info, font_info, + hr_info, mod_info, a_info, img_info, object_info, param_info, + applet_info, map_info, area_info, script_info, table_info, + caption_info, col_info, tablesection_info, tr_info, + tablecell_info, frameSet_info, frame_info, iFrame_info, marquee_info, layer_info; + + enum { HtmlVersion, HeadProfile, LinkHref, LinkRel, LinkMedia, + LinkCharset, LinkDisabled, LinkHrefLang, LinkRev, LinkTarget, LinkType, + LinkSheet, TitleText, MetaName, MetaHttpEquiv, MetaContent, MetaScheme, + BaseHref, BaseTarget, IsIndexForm, IsIndexPrompt, StyleDisabled, + StyleSheet, StyleType, StyleMedia, BodyBackground, BodyVLink, BodyText, + BodyLink, BodyALink, BodyBgColor, BodyOnLoad, BodyFocus, + FormAction, FormEncType, FormElements, FormLength, FormAcceptCharset, + FormReset, FormTarget, FormName, FormMethod, FormSubmit, SelectAdd, + SelectTabIndex, SelectValue, SelectSelectedIndex, SelectLength, + SelectRemove, SelectForm, SelectBlur, SelectType, SelectOptions, + SelectDisabled, SelectMultiple, SelectName, SelectSize, SelectFocus, + OptGroupDisabled, OptGroupLabel, OptionIndex, OptionSelected, + OptionForm, OptionText, OptionDefaultSelected, OptionDisabled, + OptionLabel, OptionValue, InputBlur, InputReadOnly, InputAccept, + InputSize, InputDefaultValue, InputTabIndex, InputValue, InputType, + InputFocus, InputMaxLength, InputDefaultChecked, InputDisabled, + InputChecked, InputIndeterminate, InputForm, InputAccessKey, InputAlign, InputAlt, + InputName, InputSrc, InputUseMap, InputSelect, InputClick, + InputSelectionStart, InputSelectionEnd, InputSetSelectionRange, + TextAreaAccessKey, TextAreaName, TextAreaDefaultValue, TextAreaSelect, + TextAreaCols, TextAreaDisabled, TextAreaForm, TextAreaType, + TextAreaTabIndex, TextAreaReadOnly, TextAreaRows, TextAreaValue, + TextAreaBlur, TextAreaFocus, TextAreaSelectionStart, TextAreaSelectionEnd, TextAreaSetSelectionRange, + TextAreaTextLength, ButtonBlur, ButtonFocus, ButtonForm, ButtonTabIndex, ButtonName, + ButtonDisabled, ButtonAccessKey, ButtonType, ButtonValue, LabelHtmlFor, + LabelForm, LabelAccessKey, FieldSetForm, LegendForm, LegendAccessKey, + LegendAlign, UListType, UListCompact, OListStart, OListCompact, + OListType, DListCompact, DirectoryCompact, MenuCompact, LIType, + LIValue, DivAlign, ParagraphAlign, HeadingAlign, BlockQuoteCite, + QuoteCite, PreWidth, BRClear, BaseFontColor, BaseFontSize, + BaseFontFace, FontColor, FontSize, FontFace, HRWidth, HRNoShade, + HRAlign, HRSize, ModCite, ModDateTime, AnchorShape, AnchorRel, + AnchorAccessKey, AnchorCoords, AnchorHref, AnchorProtocol, AnchorHost, + AnchorCharset, AnchorHrefLang, AnchorHostname, AnchorType, AnchorFocus, + AnchorPort, AnchorPathName, AnchorHash, AnchorSearch, AnchorName, + AnchorRev, AnchorTabIndex, AnchorTarget, AnchorText, AnchorBlur, AnchorClick, + ImageName, ImageAlign, ImageHspace, ImageVspace, ImageUseMap, ImageAlt, + ImageLowSrc, ImageWidth, ImageIsMap, ImageBorder, ImageHeight, + ImageLongDesc, ImageSrc, ImageX, ImageY, ImageComplete, ObjectHspace, ObjectHeight, ObjectAlign, + ObjectBorder, ObjectCode, ObjectType, ObjectVspace, ObjectArchive, + ObjectDeclare, ObjectForm, ObjectCodeBase, ObjectCodeType, ObjectData, + ObjectName, ObjectStandby, ObjectTabIndex, ObjectUseMap, ObjectWidth, ObjectContentDocument, + ParamName, ParamType, ParamValueType, ParamValue, AppletArchive, + AppletAlt, AppletCode, AppletWidth, AppletAlign, AppletCodeBase, + AppletName, AppletHeight, AppletHspace, AppletObject, AppletVspace, + MapAreas, MapName, AreaHash, AreaHref, AreaTarget, AreaPort, AreaShape, + AreaCoords, AreaAlt, AreaAccessKey, AreaNoHref, AreaHost, AreaProtocol, + AreaHostName, AreaPathName, AreaSearch, AreaTabIndex, ScriptEvent, + ScriptType, ScriptHtmlFor, ScriptText, ScriptSrc, ScriptCharset, + ScriptDefer, TableSummary, TableTBodies, TableTHead, TableCellPadding, + TableDeleteCaption, TableCreateCaption, TableCaption, TableWidth, + TableCreateTFoot, TableAlign, TableTFoot, TableDeleteRow, + TableCellSpacing, TableRows, TableBgColor, TableBorder, TableFrame, + TableRules, TableCreateTHead, TableDeleteTHead, TableDeleteTFoot, + TableInsertRow, TableCaptionAlign, TableColCh, TableColChOff, + TableColAlign, TableColSpan, TableColVAlign, TableColWidth, + TableSectionCh, TableSectionDeleteRow, TableSectionChOff, + TableSectionRows, TableSectionAlign, TableSectionVAlign, + TableSectionInsertRow, TableRowSectionRowIndex, TableRowRowIndex, + TableRowChOff, TableRowCells, TableRowVAlign, TableRowCh, + TableRowAlign, TableRowBgColor, TableRowDeleteCell, TableRowInsertCell, + TableCellColSpan, TableCellNoWrap, TableCellAbbr, TableCellHeight, + TableCellWidth, TableCellCellIndex, TableCellChOff, TableCellBgColor, + TableCellCh, TableCellVAlign, TableCellRowSpan, TableCellHeaders, + TableCellAlign, TableCellAxis, TableCellScope, FrameSetCols, + FrameSetRows, FrameSrc, FrameLocation, FrameFrameBorder, FrameScrolling, + FrameMarginWidth, FrameLongDesc, FrameMarginHeight, FrameName, + FrameContentDocument, FrameContentWindow, + FrameNoResize, FrameWidth, FrameHeight, IFrameLongDesc, IFrameAlign, + IFrameFrameBorder, IFrameSrc, IFrameName, IFrameHeight, + IFrameMarginHeight, IFrameMarginWidth, IFrameScrolling, IFrameWidth, + IFrameContentDocument, IFrameContentWindow, + MarqueeStart, MarqueeStop, + LayerTop, LayerLeft, LayerVisibility, LayerBgColor, LayerClip, LayerDocument, LayerLayers, + ElementInnerHTML, ElementTitle, ElementId, ElementDir, ElementLang, + ElementClassName, ElementInnerText, ElementDocument, + ElementChildren, ElementAll, ElementScrollIntoView }; + + DOM::HTMLElement toElement() const { return static_cast<DOM::HTMLElement>(node); } + }; + + class HTMLElementFunction : public DOMFunction { + public: + HTMLElementFunction(ExecState *exec, int i, int len); + virtual Value tryCall(ExecState *exec, Object &thisObj, const List&args); + private: + int id; + }; + + class HTMLCollection : public DOMObject { + public: + HTMLCollection(ExecState *exec, const DOM::HTMLCollection& c); + HTMLCollection(const KJS::Object& proto, const DOM::HTMLCollection& c); + ~HTMLCollection(); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual Value call(ExecState *exec, Object &thisObj, const List&args); + virtual Value tryCall(ExecState *exec, Object &thisObj, const List&args); + virtual bool implementsCall() const { return true; } + virtual bool toBoolean(ExecState *) const; + virtual bool hasProperty(ExecState *exec, const Identifier &p) const; + virtual ReferenceList propList(ExecState *exec, bool recursive); + enum { Item, NamedItem, Tags }; + Value getNamedItems(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + DOM::HTMLCollection toCollection() const { return collection; } + virtual void hide() { hidden = true; } + protected: + DOM::HTMLCollection collection; + bool hidden; + }; + + class HTMLSelectCollection : public HTMLCollection { + public: + enum { Add }; + HTMLSelectCollection(ExecState *exec, const DOM::HTMLCollection& c, const DOM::HTMLSelectElement& e); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + + DOM::HTMLSelectElement toElement() const { return element; } + private: + DOM::HTMLSelectElement element; + }; + + ////////////////////// Option Object //////////////////////// + + class OptionConstructorImp : public ObjectImp { + public: + OptionConstructorImp(ExecState *exec, const DOM::Document &d); + virtual bool implementsConstruct() const; + virtual Object construct(ExecState *exec, const List &args); + private: + DOM::Document doc; + }; + + ////////////////////// Image Object //////////////////////// + + class ImageConstructorImp : public ObjectImp { + public: + ImageConstructorImp(ExecState *exec, const DOM::Document &d); + virtual bool implementsConstruct() const; + virtual Object construct(ExecState *exec, const List &args); + private: + DOM::Document doc; + }; + + Value getHTMLCollection(ExecState *exec, const DOM::HTMLCollection& c, bool hide=false); + Value getSelectHTMLCollection(ExecState *exec, const DOM::HTMLCollection& c, const DOM::HTMLSelectElement& e); + + + //All the pseudo constructors.. + DEFINE_PSEUDO_CONSTRUCTOR(HTMLElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLHtmlElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLHeadElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLLinkElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTitleElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLMetaElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLBaseElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLIsIndexElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLStyleElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLBodyElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLFormElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLSelectElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLOptGroupElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLOptionElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLInputElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTextAreaElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLButtonElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLLabelElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLFieldSetElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLLegendElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLUListElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLOListElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLDListElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLDirectoryElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLMenuElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLLIElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLDivElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLParagraphElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLHeadingElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLBlockQuoteElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLQuoteElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLPreElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLBRElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLBaseFontElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLFontElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLHRElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLModElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLAnchorElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLImageElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLObjectElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLParamElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLAppletElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLMapElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLAreaElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLScriptElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTableElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTableCaptionElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTableColElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTableSectionElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTableRowElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLTableCellElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLFrameSetElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLLayerElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLFrameElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLIFrameElementPseudoCtor) + DEFINE_PSEUDO_CONSTRUCTOR(HTMLMarqueeElementPseudoCtor) +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_mozilla.cpp b/tdehtml/ecma/kjs_mozilla.cpp new file mode 100644 index 000000000..216fde26e --- /dev/null +++ b/tdehtml/ecma/kjs_mozilla.cpp @@ -0,0 +1,94 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (c) 2003 George Staikos (staikos@kde.org) + * + * 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 <klocale.h> +#include <kdebug.h> + +#include "kjs_mozilla.h" +#include "kjs/lookup.h" +#include "kjs_binding.h" +#include "tdehtml_part.h" +#include "kjs_mozilla.lut.h" + +using namespace KJS; + +namespace KJS { + +const ClassInfo MozillaSidebarExtension::info = { "sidebar", 0, &MozillaSidebarExtensionTable, 0 }; +/* +@begin MozillaSidebarExtensionTable 1 + addPanel MozillaSidebarExtension::addPanel DontDelete|Function 0 +@end +*/ +} +IMPLEMENT_PROTOFUNC_DOM(MozillaSidebarExtensionFunc) + +MozillaSidebarExtension::MozillaSidebarExtension(ExecState *exec, KHTMLPart *p) + : ObjectImp(exec->interpreter()->builtinObjectPrototype()), m_part(p) { } + +Value MozillaSidebarExtension::get(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "MozillaSidebarExtension::get " << propertyName.ascii() << endl; +#endif + return lookupGet<MozillaSidebarExtensionFunc,MozillaSidebarExtension,ObjectImp>(exec,propertyName,&MozillaSidebarExtensionTable,this); +} + +Value MozillaSidebarExtension::getValueProperty(ExecState *exec, int token) const +{ + Q_UNUSED(exec); + switch (token) { + default: + kdDebug(6070) << "WARNING: Unhandled token in MozillaSidebarExtension::getValueProperty : " << token << endl; + return Value(); + } +} + +Value MozillaSidebarExtensionFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::MozillaSidebarExtension, thisObj ); + MozillaSidebarExtension *mse = static_cast<MozillaSidebarExtension*>(thisObj.imp()); + + KHTMLPart *part = mse->part(); + if (!part) + return Undefined(); + + // addPanel() id == 0 + KParts::BrowserExtension *ext = part->browserExtension(); + if (ext) { + TQString url, name; + if (args.size() == 1) { // I've seen this, don't know if it's legal. + name = TQString::null; + url = args[0].toString(exec).qstring(); + } else if (args.size() == 2 || args.size() == 3) { + name = args[0].toString(exec).qstring(); + url = args[1].toString(exec).qstring(); + // 2 is the "CURL" which I don't understand and don't think we need. + } else { + return Boolean(false); + } + emit ext->addWebSideBar(KURL( url ), name); + return Boolean(true); + } + + return Undefined(); +} + + diff --git a/tdehtml/ecma/kjs_mozilla.h b/tdehtml/ecma/kjs_mozilla.h new file mode 100644 index 000000000..220094f63 --- /dev/null +++ b/tdehtml/ecma/kjs_mozilla.h @@ -0,0 +1,44 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2003 George Staikos (staikos@kde.org) + * + * 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 + */ + +#ifndef _KJS_MOZILLA_H_ +#define _KJS_MOZILLA_H_ + +#include <kjs/object.h> + +class KHTMLPart; + +namespace KJS { + + class MozillaSidebarExtension : public ObjectImp { + public: + MozillaSidebarExtension(ExecState *exec, KHTMLPart *p); + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { addPanel }; + KHTMLPart *part() const { return m_part; } + private: + KHTMLPart *m_part; + }; +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_navigator.cpp b/tdehtml/ecma/kjs_navigator.cpp new file mode 100644 index 000000000..222ef7902 --- /dev/null +++ b/tdehtml/ecma/kjs_navigator.cpp @@ -0,0 +1,670 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * Copyright (c) 2000 Daniel Molkentin (molkentin@kde.org) + * Copyright (c) 2000 Stefan Schimanski (schimmi@kde.org) + * 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 <klocale.h> + +#include <kstandarddirs.h> +#include <kconfig.h> +#include <kdebug.h> + +#include <kio/kprotocolmanager.h> +#include <kio/kmimetype.h> +#include <kio/kservice.h> +#include <kio/ktrader.h> +#include "kjs_navigator.h" +#include "kjs/lookup.h" +#include "kjs_binding.h" +#include "tdehtml_part.h" +#include <sys/utsname.h> +#include "kjs_navigator.lut.h" + +using namespace KJS; + +namespace KJS { + + // All objects that need plugin info must inherit from PluginBase + // Its ctor and dtor take care of the refcounting on the static lists. + class PluginBase : public ObjectImp { + public: + PluginBase(ExecState *exec, bool loadPluginInfo); + virtual ~PluginBase(); + + struct MimeClassInfo; + struct PluginInfo; + + struct MimeClassInfo { + TQString type; + TQString desc; + TQString suffixes; + PluginInfo *plugin; + }; + + struct PluginInfo { + TQString name; + TQString file; + TQString desc; + TQPtrList<MimeClassInfo> mimes; + }; + + static TQPtrList<PluginInfo> *plugins; + static TQPtrList<MimeClassInfo> *mimes; + + private: + static int m_refCount; + }; + + + class Plugins : public PluginBase { + public: + Plugins(ExecState *exec, bool pluginsEnabled) + : PluginBase(exec, pluginsEnabled), + m_pluginsEnabled(pluginsEnabled) {}; + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + Value pluginByName( ExecState* exec, const TQString& name ) const; + bool pluginsEnabled() const { return m_pluginsEnabled; }; + private: + bool m_pluginsEnabled; + }; + + + class MimeTypes : public PluginBase { + public: + MimeTypes(ExecState *exec, bool pluginsEnabled) + : PluginBase(exec, pluginsEnabled), + m_pluginsEnabled(pluginsEnabled) {}; + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + Value getValueProperty(ExecState *exec, int token) const; + Value mimeTypeByName( ExecState* exec, const TQString& name ) const; + bool pluginsEnabled() const { return m_pluginsEnabled; }; + private: + bool m_pluginsEnabled; + }; + + + class Plugin : public PluginBase { + public: + Plugin( ExecState *exec, PluginBase::PluginInfo *info ) + : PluginBase( exec, true ) + { m_info = info; }; + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + Value mimeByName(ExecState* exec, const TQString& name ) const; + Value getValueProperty(ExecState *exec, int token) const; + PluginBase::PluginInfo *pluginInfo() const { return m_info; } + private: + PluginBase::PluginInfo *m_info; + }; + + + class MimeType : public PluginBase { + public: + MimeType( ExecState *exec, PluginBase::MimeClassInfo *info ) + : PluginBase( exec, true ) + { m_info = info; }; + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + Value getValueProperty(ExecState *exec, int token) const; + private: + PluginBase::MimeClassInfo *m_info; + }; + +} + + +TQPtrList<PluginBase::PluginInfo> *KJS::PluginBase::plugins = 0; +TQPtrList<PluginBase::MimeClassInfo> *KJS::PluginBase::mimes = 0; +int KJS::PluginBase::m_refCount = 0; + +const ClassInfo Navigator::info = { "Navigator", 0, &NavigatorTable, 0 }; +/* +@begin NavigatorTable 12 + appCodeName Navigator::AppCodeName DontDelete|ReadOnly + appName Navigator::AppName DontDelete|ReadOnly + appVersion Navigator::AppVersion DontDelete|ReadOnly + language Navigator::Language DontDelete|ReadOnly + userAgent Navigator::UserAgent DontDelete|ReadOnly + userLanguage Navigator::UserLanguage DontDelete|ReadOnly + browserLanguage Navigator::BrowserLanguage DontDelete|ReadOnly + platform Navigator::Platform DontDelete|ReadOnly + cpuClass Navigator::CpuClass DontDelete|ReadOnly + plugins Navigator::_Plugins DontDelete|ReadOnly + mimeTypes Navigator::_MimeTypes DontDelete|ReadOnly + product Navigator::Product DontDelete|ReadOnly + vendor Navigator::Vendor DontDelete|ReadOnly + productSub Navigator::ProductSub DontDelete|ReadOnly + cookieEnabled Navigator::CookieEnabled DontDelete|ReadOnly + javaEnabled Navigator::JavaEnabled DontDelete|Function 0 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(NavigatorFunc) + +Navigator::Navigator(ExecState *exec, KHTMLPart *p) + : ObjectImp(exec->interpreter()->builtinObjectPrototype()), m_part(p) { } + +Value Navigator::get(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Navigator::get " << propertyName.ascii() << endl; +#endif + return lookupGet<NavigatorFunc,Navigator,ObjectImp>(exec,propertyName,&NavigatorTable,this); +} + +Value Navigator::getValueProperty(ExecState *exec, int token) const +{ + KURL url = m_part->url(); + TQString userAgent = url.host(); + if (userAgent.isEmpty()) + userAgent = "localhost"; + userAgent = KProtocolManager::userAgentForHost(userAgent); + switch (token) { + case AppCodeName: + return String("Mozilla"); + case AppName: + // If we find "Mozilla" but not "(compatible, ...)" we are a real Netscape + if (userAgent.find(TQString::fromLatin1("Mozilla")) >= 0 && + userAgent.find(TQString::fromLatin1("compatible")) == -1) + { + //kdDebug() << "appName -> Mozilla" << endl; + return String("Netscape"); + } + if (userAgent.find(TQString::fromLatin1("Microsoft")) >= 0 || + userAgent.find(TQString::fromLatin1("MSIE")) >= 0) + { + //kdDebug() << "appName -> IE" << endl; + return String("Microsoft Internet Explorer"); + } + //kdDebug() << "appName -> Konqueror" << endl; + return String("Konqueror"); + case AppVersion: + // We assume the string is something like Mozilla/version (properties) + return String(userAgent.mid(userAgent.find('/') + 1)); + case Product: + // We are pretending to be Mozilla or Safari + if (userAgent.find(TQString::fromLatin1("Mozilla")) >= 0 && + userAgent.find(TQString::fromLatin1("compatible")) == -1) + { + return String("Gecko"); + } + // When spoofing as IE, we use Undefined(). + if (userAgent.find(TQString::fromLatin1("Microsoft")) >= 0 || + userAgent.find(TQString::fromLatin1("MSIE")) >= 0) + { + return Undefined(); + } + // We are acting straight + return String("Konqueror/tdehtml"); + case ProductSub: + { + int ix = userAgent.find("Gecko"); + if (ix >= 0 && userAgent.length() >= (uint)ix+14 && userAgent.unicode()[ix+5] == TQChar('/') && + userAgent.find(TQRegExp("\\d{8}"), ix+6) == ix+6) + { + // We have Gecko/<productSub> in the UA string + return String(userAgent.mid(ix+6, 8)); + } + else if (ix >= 0) + { + return String("20040107"); + } + } + return Undefined(); + case Vendor: + return String("KDE"); + case BrowserLanguage: + case Language: + case UserLanguage: + return String(TDEGlobal::locale()->language()); + case UserAgent: + return String(userAgent); + case Platform: + // yet another evil hack, but necessary to spoof some sites... + if ( (userAgent.find(TQString::fromLatin1("Win"),0,false)>=0) ) + return String(TQString::fromLatin1("Win32")); + else if ( (userAgent.find(TQString::fromLatin1("Macintosh"),0,false)>=0) || + (userAgent.find(TQString::fromLatin1("Mac_PowerPC"),0,false)>=0) ) + return String(TQString::fromLatin1("MacPPC")); + else + { + struct utsname name; + int ret = uname(&name); + if ( ret >= 0 ) + return String(TQString(TQString::fromLatin1("%1 %1 X11").arg(name.sysname).arg(name.machine))); + else // can't happen + return String(TQString(TQString::fromLatin1("Unix X11"))); + } + case CpuClass: + { + struct utsname name; + int ret = uname(&name); + if ( ret >= 0 ) + return String(name.machine); + else // can't happen + return String("x86"); + } + case _Plugins: + return Value(new Plugins(exec, m_part->pluginsEnabled())); + case _MimeTypes: + return Value(new MimeTypes(exec, m_part->pluginsEnabled())); + case CookieEnabled: + return Boolean(true); /// ##### FIXME + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMEvent::getValueProperty : " << token << endl; + return Value(); + } +} + +/*******************************************************************/ + +PluginBase::PluginBase(ExecState *exec, bool loadPluginInfo) + : ObjectImp(exec->interpreter()->builtinObjectPrototype() ) +{ + if ( loadPluginInfo && !plugins ) { + plugins = new TQPtrList<PluginInfo>; + mimes = new TQPtrList<MimeClassInfo>; + plugins->setAutoDelete( true ); + mimes->setAutoDelete( true ); + + // read in using KTrader + KTrader::OfferList offers = KTrader::self()->query("Browser/View"); + KTrader::OfferList::iterator it; + for ( it = offers.begin(); it != offers.end(); ++it ) { + + TQVariant pluginsinfo = (**it).property( "X-TDE-BrowserView-PluginsInfo" ); + if ( !pluginsinfo.isValid() ) { + // <backwards compatible> + if ((**it).library() == TQString("libnsplugin")) + pluginsinfo = TQVariant("nsplugins/pluginsinfo"); + else + // </backwards compatible> + continue; + } + // read configuration + TDEConfig kc( locate ("data", pluginsinfo.toString()) ); + unsigned num = (unsigned int) kc.readNumEntry("number"); + for ( unsigned n = 0; n < num; n++ ) { + kc.setGroup( TQString::number(n) ); + PluginInfo *plugin = new PluginInfo; + + plugin->name = kc.readEntry("name"); + plugin->file = kc.readPathEntry("file"); + plugin->desc = kc.readEntry("description"); + + plugins->append( plugin ); + + // get mime types from string + TQStringList types = TQStringList::split( ';', kc.readEntry("mime") ); + TQStringList::Iterator type; + for ( type=types.begin(); type!=types.end(); ++type ) { + + // get mime information + TQStringList tokens = TQStringList::split(':', *type, true); + if ( tokens.count() < 3 ) // we need 3 items + continue; + + MimeClassInfo *mime = new MimeClassInfo; + TQStringList::Iterator token = tokens.begin(); + mime->type = (*token).lower(); + //kdDebug(6070) << "mime->type=" << mime->type << endl; + ++token; + + mime->suffixes = *token; + ++token; + + mime->desc = *token; + ++token; + + mime->plugin = plugin; + + mimes->append( mime ); + plugin->mimes.append( mime ); + + } + } + } + } + + m_refCount++; +} + +PluginBase::~PluginBase() +{ + m_refCount--; + if ( m_refCount==0 ) { + delete plugins; + delete mimes; + plugins = 0; + mimes = 0; + } +} + + +/*******************************************************************/ + +const ClassInfo Plugins::info = { "PluginArray", 0, &PluginsTable, 0 }; +/* +@begin PluginsTable 4 + length Plugins_Length DontDelete|ReadOnly + refresh Plugins_Refresh DontDelete|Function 0 + item Plugins_Item DontDelete|Function 1 + namedItem Plugins_NamedItem DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(PluginsFunc) + +Value Plugins::get(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Plugins::get " << propertyName.qstring() << endl; +#endif + if (!pluginsEnabled()) { + if (propertyName == lengthPropertyName ) + return Number(0); + } else { + if ( propertyName == lengthPropertyName ) + return Number(plugins->count()); + + // plugins[#] + bool ok; + unsigned int i = propertyName.toULong(&ok); + if( ok && i<plugins->count() ) + return Value( new Plugin( exec, plugins->at(i) ) ); + + // plugin[name] + Value val = pluginByName( exec, propertyName.qstring() ); + if (!val.isA(UndefinedType)) + return val; + } + + return lookupGet<PluginsFunc,Plugins,ObjectImp>(exec,propertyName,&PluginsTable,this); +} + +Value Plugins::pluginByName( ExecState* exec, const TQString& name ) const +{ + Q_ASSERT(plugins); + for ( PluginInfo *pl = plugins->first(); pl!=0; pl = plugins->next() ) { + if ( pl->name == name ) + return Value( new Plugin( exec, pl ) ); + } + return Undefined(); +} + +Value Plugins::getValueProperty(ExecState* /*exec*/, int token) const +{ + kdDebug(6070) << "WARNING: Unhandled token in Plugins::getValueProperty : " << token << endl; + return Undefined(); +} + +Value PluginsFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::Plugins, thisObj ); + KJS::Plugins* base = static_cast<KJS::Plugins *>(thisObj.imp()); + if (!base->pluginsEnabled()) { + if (id == Plugins_Refresh || //## TODO + id == Plugins_Item || + id == Plugins_NamedItem) + return Undefined(); + } else { + switch( id ) { + case Plugins_Refresh: + return Undefined(); //## TODO + case Plugins_Item: + { + bool ok; + unsigned int i = args[0].toString(exec).toArrayIndex(&ok); + if( ok && i<base->plugins->count() ) + return Value( new Plugin( exec, base->plugins->at(i) ) ); + return Undefined(); + } + case Plugins_NamedItem: + UString s = args[0].toString(exec); + return base->pluginByName( exec, s.qstring() ); + } + } + kdDebug(6070) << "WARNING: Unhandled token in PluginsFunc::tryCall : " << id << endl; + return Undefined(); +} + +/*******************************************************************/ + +const ClassInfo MimeTypes::info = { "MimeTypeArray", 0, &MimeTypesTable, 0 }; +/* +@begin MimeTypesTable 3 + length MimeTypes_Length DontDelete|ReadOnly + item MimeTypes_Item DontDelete|Function 1 + namedItem MimeTypes_NamedItem DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(MimeTypesFunc) + +Value MimeTypes::get(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "MimeTypes::get " << propertyName.qstring() << endl; +#endif + if (!pluginsEnabled()) { + if (propertyName == lengthPropertyName ) + return Number(0); + } else { + if( propertyName==lengthPropertyName ) + return Number( mimes->count() ); + + // mimeTypes[#] + bool ok; + unsigned int i = propertyName.toULong(&ok); + if( ok && i<mimes->count() ) + return Value( new MimeType( exec, mimes->at(i) ) ); + + // mimeTypes[name] + Value val = mimeTypeByName( exec, propertyName.qstring() ); + if (!val.isA(UndefinedType)) + return val; + } + + return lookupGet<MimeTypesFunc,MimeTypes,ObjectImp>(exec,propertyName,&MimeTypesTable,this); +} + +Value MimeTypes::mimeTypeByName( ExecState* exec, const TQString& name ) const +{ + //kdDebug(6070) << "MimeTypes[" << name << "]" << endl; + Q_ASSERT(mimes); + for ( MimeClassInfo *m = mimes->first(); m!=0; m = mimes->next() ) { + if ( m->type == name ) + return Value( new MimeType( exec, m ) ); + } + return Undefined(); +} + +Value MimeTypes::getValueProperty(ExecState* /*exec*/, int token) const +{ + kdDebug(6070) << "WARNING: Unhandled token in MimeTypes::getValueProperty : " << token << endl; + return Undefined(); +} + +Value MimeTypesFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::MimeTypes, thisObj ); + KJS::MimeTypes* base = static_cast<KJS::MimeTypes *>(thisObj.imp()); + if (!base->pluginsEnabled()) { + if (id == MimeTypes_Item || + id == MimeTypes_NamedItem) + return Undefined(); + } else { + switch( id ) { + case MimeTypes_Item: + { + bool ok; + unsigned int i = args[0].toString(exec).toArrayIndex(&ok); + if( ok && i<base->mimes->count() ) + return Value( new MimeType( exec, base->mimes->at(i) ) ); + return Undefined(); + } + case MimeTypes_NamedItem: + UString s = args[0].toString(exec); + return base->mimeTypeByName( exec, s.qstring() ); + } + } + kdDebug(6070) << "WARNING: Unhandled token in MimeTypesFunc::tryCall : " << id << endl; + return Undefined(); +} + +/************************************************************************/ +const ClassInfo Plugin::info = { "Plugin", 0, &PluginTable, 0 }; +/* +@begin PluginTable 7 + name Plugin_Name DontDelete|ReadOnly + filename Plugin_FileName DontDelete|ReadOnly + description Plugin_Description DontDelete|ReadOnly + length Plugin_Length DontDelete|ReadOnly + item Plugin_Item DontDelete|Function 1 + namedItem Plugin_NamedItem DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(PluginFunc) + +Value Plugin::get(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Plugin::get " << propertyName.qstring() << endl; +#endif + if ( propertyName == lengthPropertyName ) + return Number( m_info->mimes.count() ); + + // plugin[#] + bool ok; + unsigned int i = propertyName.toULong(&ok); + //kdDebug(6070) << "Plugin::get plugin[" << i << "]" << endl; + if( ok && i<m_info->mimes.count() ) + { + //kdDebug(6070) << "returning mimetype " << m_info->mimes.at(i)->type << endl; + return Value(new MimeType(exec, m_info->mimes.at(i))); + } + + // plugin["name"] + Value val = mimeByName( exec, propertyName.qstring() ); + if (!val.isA(UndefinedType)) + return val; + + return lookupGet<PluginFunc,Plugin,ObjectImp>(exec, propertyName, &PluginTable, this ); +} + +Value Plugin::mimeByName(ExecState* exec, const TQString& name) const +{ + for ( PluginBase::MimeClassInfo *m = m_info->mimes.first(); + m != 0; m = m_info->mimes.next() ) { + if ( m->type == name ) + return Value(new MimeType(exec, m)); + } + return Undefined(); +} + +Value Plugin::getValueProperty(ExecState* /*exec*/, int token) const +{ + switch( token ) { + case Plugin_Name: + return String( m_info->name ); + case Plugin_FileName: + return String( m_info->file ); + case Plugin_Description: + return String( m_info->desc ); + default: + kdDebug(6070) << "WARNING: Unhandled token in Plugin::getValueProperty : " << token << endl; + return Undefined(); + } +} + +Value PluginFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::Plugin, thisObj ); + KJS::Plugin* plugin = static_cast<KJS::Plugin *>(thisObj.imp()); + switch( id ) { + case Plugin_Item: + { + bool ok; + unsigned int i = args[0].toString(exec).toArrayIndex(&ok); + if( ok && i< plugin->pluginInfo()->mimes.count() ) + return Value( new MimeType( exec, plugin->pluginInfo()->mimes.at(i) ) ); + return Undefined(); + } + case Plugin_NamedItem: + { + UString s = args[0].toString(exec); + return plugin->mimeByName( exec, s.qstring() ); + } + default: + kdDebug(6070) << "WARNING: Unhandled token in PluginFunc::tryCall : " << id << endl; + return Undefined(); + } +} + +/*****************************************************************************/ + +const ClassInfo MimeType::info = { "MimeType", 0, &MimeTypeTable, 0 }; +/* +@begin MimeTypeTable 4 + description MimeType_Description DontDelete|ReadOnly + enabledPlugin MimeType_EnabledPlugin DontDelete|ReadOnly + suffixes MimeType_Suffixes DontDelete|ReadOnly + type MimeType_Type DontDelete|ReadOnly +@end +*/ + +Value MimeType::get(ExecState *exec, const Identifier &propertyName) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "MimeType::get " << propertyName.qstring() << endl; +#endif + return lookupGetValue<MimeType,ObjectImp>(exec, propertyName, &MimeTypeTable, this ); +} + +Value MimeType::getValueProperty(ExecState* exec, int token) const +{ + switch( token ) { + case MimeType_Type: + return String( m_info->type ); + case MimeType_Suffixes: + return String( m_info->suffixes ); + case MimeType_Description: + return String( m_info->desc ); + case MimeType_EnabledPlugin: + return Value(new Plugin(exec, m_info->plugin)); + default: + kdDebug(6070) << "WARNING: Unhandled token in MimeType::getValueProperty : " << token << endl; + return Undefined(); + } +} + + +Value NavigatorFunc::tryCall(ExecState *exec, Object &thisObj, const List &) +{ + KJS_CHECK_THIS( KJS::Navigator, thisObj ); + Navigator *nav = static_cast<Navigator *>(thisObj.imp()); + // javaEnabled() + return Boolean(nav->part()->javaEnabled()); +} diff --git a/tdehtml/ecma/kjs_navigator.h b/tdehtml/ecma/kjs_navigator.h new file mode 100644 index 000000000..ccd1ba63b --- /dev/null +++ b/tdehtml/ecma/kjs_navigator.h @@ -0,0 +1,53 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * + * 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 + */ + +#ifndef _KJS_NAVIGATOR_H_ +#define _KJS_NAVIGATOR_H_ + +#include <kjs/object.h> + +class KHTMLPart; + +namespace KJS { + + class Navigator : public ObjectImp { + public: + Navigator(ExecState *exec, KHTMLPart *p); + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { AppCodeName, AppName, AppVersion, Language, UserAgent, UserLanguage, Platform, + _Plugins, _MimeTypes, Product, ProductSub, Vendor, CookieEnabled, JavaEnabled, + BrowserLanguage, CpuClass }; + KHTMLPart *part() const { return m_part; } + private: + KHTMLPart *m_part; + }; + + // Hashtable enums + enum { Plugins_Refresh, Plugins_Length, Plugins_Item, Plugins_NamedItem }; + enum { MimeTypes_Length, MimeTypes_Item, MimeTypes_NamedItem }; + enum { Plugin_Name, Plugin_FileName, Plugin_Description, Plugin_Length, Plugin_Item, Plugin_NamedItem }; + enum { MimeType_Type, MimeType_Description, MimeType_EnabledPlugin, MimeType_Suffixes }; + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_proxy.cpp b/tdehtml/ecma/kjs_proxy.cpp new file mode 100644 index 000000000..cc7afa00a --- /dev/null +++ b/tdehtml/ecma/kjs_proxy.cpp @@ -0,0 +1,411 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 1999-2001 Harri Porten (porten@kde.org) + * Copyright (C) 2001,2003 Peter Kelly (pmk@post.com) + * Copyright (C) 2001-2003 David Faure (faure@kde.org) + * + * 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 <config.h> + +#if defined(HAVE_VALGRIND_MEMCHECK_H) && !defined(NDEBUG) + +#include <valgrind/memcheck.h> +#define VALGRIND_SUPPORT + +#endif + + +#include "kjs_proxy.h" + +#include "kjs_window.h" +#include "kjs_events.h" +#include "kjs_debugwin.h" +#include "xml/dom_nodeimpl.h" +#include "tdehtmlpart_p.h" +#include <tdehtml_part.h> +#include <kprotocolmanager.h> +#include <kdebug.h> +#include <kmessagebox.h> +#include <klocale.h> +#include <unistd.h> +#include <signal.h> +#include <sys/time.h> +#include <assert.h> +#include <kjs/function.h> + +using namespace KJS; + +extern "C" { + KJSProxy *kjs_html_init(tdehtml::ChildFrame *childframe); +} + +namespace KJS { + +class KJSProxyImpl : public KJSProxy { +public: + KJSProxyImpl(tdehtml::ChildFrame *frame); + virtual ~KJSProxyImpl(); + virtual TQVariant evaluate(TQString filename, int baseLine, const TQString &, const DOM::Node &n, + Completion *completion = 0); + virtual void clear(); + virtual DOM::EventListener *createHTMLEventHandler(TQString sourceUrl, TQString name, TQString code, DOM::NodeImpl *node); + virtual void finishedWithEvent(const DOM::Event &event); + virtual KJS::Interpreter *interpreter(); + + virtual void setDebugEnabled(bool enabled); + virtual void showDebugWindow(bool show=true); + virtual bool paused() const; + virtual void dataReceived(); + + void initScript(); + void applyUserAgent(); + +private: + KJS::ScriptInterpreter* m_script; + bool m_debugEnabled; +#ifndef NDEBUG + static int s_count; +#endif +}; + +} // namespace KJS + +#ifndef NDEBUG +int KJSProxyImpl::s_count = 0; +#endif + +KJSProxyImpl::KJSProxyImpl(tdehtml::ChildFrame *frame) +{ + m_script = 0; + m_frame = frame; + m_debugEnabled = false; +#ifndef NDEBUG + s_count++; +#endif +} + +KJSProxyImpl::~KJSProxyImpl() +{ + if ( m_script ) { + //kdDebug() << "KJSProxyImpl::~KJSProxyImpl clearing global object " << m_script->globalObject().imp() << endl; + // This allows to delete the global-object properties, like all the protos + static_cast<ObjectImp*>(m_script->globalObject().imp())->deleteAllProperties( m_script->globalExec() ); + //kdDebug() << "KJSProxyImpl::~KJSProxyImpl garbage collecting" << endl; + while (KJS::Interpreter::collect()) + ; + //kdDebug() << "KJSProxyImpl::~KJSProxyImpl deleting interpreter " << m_script << endl; + delete m_script; + //kdDebug() << "KJSProxyImpl::~KJSProxyImpl garbage collecting again" << endl; + // Garbage collect - as many times as necessary + // (we could delete an object which was holding another object, so + // the deref() will happen too late for deleting the impl of the 2nd object). + while (KJS::Interpreter::collect()) + ; + } + +#ifndef NDEBUG + s_count--; + // If it was the last interpreter, we should have nothing left +#ifdef KJS_DEBUG_MEM + if ( s_count == 0 ) + Interpreter::finalCheck(); +#endif +#endif +} + +TQVariant KJSProxyImpl::evaluate(TQString filename, int baseLine, + const TQString&str, const DOM::Node &n, Completion *completion) { + // evaluate code. Returns the JS return value or an invalid QVariant + // if there was none, an error occurred or the type couldn't be converted. + + initScript(); + // inlineCode is true for <a href="javascript:doSomething()"> + // and false for <script>doSomething()</script>. Check if it has the + // expected value in all cases. + // See smart window.open policy for where this is used. + bool inlineCode = filename.isNull(); + //kdDebug(6070) << "KJSProxyImpl::evaluate inlineCode=" << inlineCode << endl; + +#ifdef KJS_DEBUGGER + if (inlineCode) + filename = "(unknown file)"; + if (KJSDebugWin::debugWindow()) { + KJSDebugWin::debugWindow()->attach(m_script); + KJSDebugWin::debugWindow()->setNextSourceInfo(filename,baseLine); + // KJSDebugWin::debugWindow()->setMode(KJSDebugWin::Step); + } +#else + Q_UNUSED(baseLine); +#endif + + m_script->setInlineCode(inlineCode); + Window* window = Window::retrieveWindow( m_frame->m_part ); + KJS::Value thisNode = n.isNull() ? Window::retrieve( m_frame->m_part ) : getDOMNode(m_script->globalExec(),n); + + UString code( str ); + + KJSCPUGuard guard; + guard.start(); + Completion comp = m_script->evaluate(code, thisNode); + guard.stop(); + + bool success = ( comp.complType() == Normal ) || ( comp.complType() == ReturnValue ); + + if (completion) + *completion = comp; + +#ifdef KJS_DEBUGGER + // KJSDebugWin::debugWindow()->setCode(TQString::null); +#endif + + window->afterScriptExecution(); + + // let's try to convert the return value + if (success && comp.value().isValid()) + return ValueToVariant( m_script->globalExec(), comp.value()); + else + { + if ( comp.complType() == Throw ) + { + UString msg = comp.value().toString(m_script->globalExec()); + kdDebug(6070) << "WARNING: Script threw exception: " << msg.qstring() << endl; + } + return TQVariant(); + } +} + +// Implementation of the debug() function +class TestFunctionImp : public ObjectImp { +public: + TestFunctionImp() : ObjectImp() {} + virtual bool implementsCall() const { return true; } + virtual Value call(ExecState *exec, Object &thisObj, const List &args); +}; + +Value TestFunctionImp::call(ExecState *exec, Object &/*thisObj*/, const List &args) +{ + fprintf(stderr,"--> %s\n",args[0].toString(exec).ascii()); + return Undefined(); +} + +void KJSProxyImpl::clear() { + // clear resources allocated by the interpreter, and make it ready to be used by another page + // We have to keep it, so that the Window object for the part remains the same. + // (we used to delete and re-create it, previously) + if (m_script) { +#ifdef KJS_DEBUGGER + // ### + KJSDebugWin *debugWin = KJSDebugWin::debugWindow(); + if (debugWin) { + if (debugWin->getExecState() && + debugWin->getExecState()->interpreter() == m_script) + debugWin->slotStop(); + debugWin->clearInterpreter(m_script); + } +#endif + m_script->clear(); + + Window *win = static_cast<Window *>(m_script->globalObject().imp()); + if (win) { + win->clear( m_script->globalExec() ); + // re-add "debug", clear() removed it + m_script->globalObject().put(m_script->globalExec(), + "debug", Value(new TestFunctionImp()), Internal); + if ( win->part() ) + applyUserAgent(); + } + + // Really delete everything that can be, so that the DOM nodes get deref'ed + //kdDebug() << k_funcinfo << "all done -> collecting" << endl; + while (KJS::Interpreter::collect()) + ; + } +} + +DOM::EventListener *KJSProxyImpl::createHTMLEventHandler(TQString sourceUrl, TQString name, TQString code, DOM::NodeImpl *node) +{ + initScript(); + +#ifdef KJS_DEBUGGER + if (KJSDebugWin::debugWindow()) { + KJSDebugWin::debugWindow()->attach(m_script); + KJSDebugWin::debugWindow()->setNextSourceInfo(sourceUrl,m_handlerLineno); + } +#else + Q_UNUSED(sourceUrl); +#endif + + return KJS::Window::retrieveWindow(m_frame->m_part)->getJSLazyEventListener(code,name,node); +} + +void KJSProxyImpl::finishedWithEvent(const DOM::Event &event) +{ + // This is called when the DOM implementation has finished with a particular event. This + // is the case in sitations where an event has been created just for temporary usage, + // e.g. an image load or mouse move. Once the event has been dispatched, it is forgotten + // by the DOM implementation and so does not need to be cached still by the interpreter + ScriptInterpreter::forgetDOMObject(event.handle()); +} + +KJS::Interpreter *KJSProxyImpl::interpreter() +{ + if (!m_script) + initScript(); + return m_script; +} + +void KJSProxyImpl::setDebugEnabled(bool enabled) +{ +#ifdef KJS_DEBUGGER + m_debugEnabled = enabled; + //if (m_script) + // m_script->setDebuggingEnabled(enabled); + // NOTE: this is consistent across all KJSProxyImpl instances, as we only + // ever have 1 debug window + if (!enabled && KJSDebugWin::debugWindow()) { + KJSDebugWin::destroyInstance(); + } + else if (enabled && !KJSDebugWin::debugWindow()) { + KJSDebugWin::createInstance(); + initScript(); + KJSDebugWin::debugWindow()->attach(m_script); + } +#else + Q_UNUSED(enabled); +#endif +} + +void KJSProxyImpl::showDebugWindow(bool /*show*/) +{ +#ifdef KJS_DEBUGGER + if (KJSDebugWin::debugWindow()) + KJSDebugWin::debugWindow()->show(); +#else + //Q_UNUSED(show); +#endif +} + +bool KJSProxyImpl::paused() const +{ +#ifdef KJS_DEBUGGER + if (KJSDebugWin::debugWindow()) + return KJSDebugWin::debugWindow()->inSession(); +#endif + return false; +} + +void KJSProxyImpl::dataReceived() +{ +#ifdef KJS_DEBUGGER + if (KJSDebugWin::debugWindow() && m_frame->m_part) + KJSDebugWin::debugWindow()->sourceChanged(m_script,m_frame->m_part->url().url()); +#endif +} + +void KJSProxyImpl::initScript() +{ + if (m_script) + return; + + // Build the global object - which is a Window instance + Object globalObject( new Window(m_frame) ); + + // Create a KJS interpreter for this part + m_script = new KJS::ScriptInterpreter(globalObject, m_frame); + static_cast<ObjectImp*>(globalObject.imp())->setPrototype(m_script->builtinObjectPrototype()); + +#ifdef KJS_DEBUGGER + //m_script->setDebuggingEnabled(m_debugEnabled); +#endif + //m_script->enableDebug(); + globalObject.put(m_script->globalExec(), + "debug", Value(new TestFunctionImp()), Internal); + applyUserAgent(); +} + +void KJSProxyImpl::applyUserAgent() +{ + assert( m_script ); + TQString host = m_frame->m_part->url().isLocalFile() ? "localhost" : m_frame->m_part->url().host(); + TQString userAgent = KProtocolManager::userAgentForHost(host); + if (userAgent.find(TQString::fromLatin1("Microsoft")) >= 0 || + userAgent.find(TQString::fromLatin1("MSIE")) >= 0) + { + m_script->setCompatMode(Interpreter::IECompat); +#ifdef KJS_VERBOSE + kdDebug() << "Setting IE compat mode" << endl; +#endif + } + else + // If we find "Mozilla" but not "(compatible, ...)" we are a real Netscape + if (userAgent.find(TQString::fromLatin1("Mozilla")) >= 0 && + userAgent.find(TQString::fromLatin1("compatible")) == -1 && + userAgent.find(TQString::fromLatin1("KHTML")) == -1) + { + m_script->setCompatMode(Interpreter::NetscapeCompat); +#ifdef KJS_VERBOSE + kdDebug() << "Setting NS compat mode" << endl; +#endif + } +} + +// Helper method, so that all classes which need jScript() don't need to be added +// as friend to KHTMLPart +KJSProxy * KJSProxy::proxy( KHTMLPart *part ) +{ + return part->jScript(); +} + +// initialize HTML module +KJSProxy *kjs_html_init(tdehtml::ChildFrame *childframe) +{ + return new KJSProxyImpl(childframe); +} + +void KJSCPUGuard::start(unsigned int ms, unsigned int i_ms) +{ +#ifdef VALGRIND_SUPPORT + if (RUNNING_ON_VALGRIND) { + ms *= 50; + i_ms *= 50; + } +#endif + + oldAlarmHandler = signal(SIGVTALRM, alarmHandler); + itimerval tv = { + { i_ms / 1000, (i_ms % 1000) * 1000 }, + { ms / 1000, (ms % 1000) * 1000 } + }; + setitimer(ITIMER_VIRTUAL, &tv, &oldtv); +} + +void KJSCPUGuard::stop() +{ + setitimer(ITIMER_VIRTUAL, &oldtv, 0L); + signal(SIGVTALRM, oldAlarmHandler); +} + +bool KJSCPUGuard::confirmTerminate() { + kdDebug(6070) << "alarmhandler" << endl; + return KMessageBox::warningYesNo(0L, i18n("A script on this page is causing KHTML to freeze. If it continues to run, other applications may become less responsive.\nDo you want to abort the script?"), i18n("JavaScript"), i18n("&Abort"), KStdGuiItem::cont(), "kjscupguard_alarmhandler") == KMessageBox::Yes; +} + +void KJSCPUGuard::alarmHandler(int) { + ExecState::requestTerminate(); + ExecState::confirmTerminate = KJSCPUGuard::confirmTerminate; +} diff --git a/tdehtml/ecma/kjs_proxy.h b/tdehtml/ecma/kjs_proxy.h new file mode 100644 index 000000000..5ea2d5bf6 --- /dev/null +++ b/tdehtml/ecma/kjs_proxy.h @@ -0,0 +1,91 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 1999 Harri Porten (porten@kde.org) + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * + * 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 + */ + +#ifndef _KJS_PROXY_H_ +#define _KJS_PROXY_H_ + +#include <tqvariant.h> +#include <tqstring.h> +#include <sys/time.h> + +class KHTMLPart; + +namespace DOM { + class Node; + class NodeImpl; + class EventListener; + class Event; +} + +namespace KJS { + class List; + class Interpreter; + class Completion; + class KJSDebugWin; +} + +namespace tdehtml { + class ChildFrame; +} + +/** + * @internal + * + * @short Proxy class serving as interface when being dlopen'ed. + */ +class KJSProxy { +public: + KJSProxy() { m_handlerLineno = 0; } + virtual ~KJSProxy() { } + virtual TQVariant evaluate(TQString filename, int baseLine, const TQString &, const DOM::Node &n, + KJS::Completion *completion = 0) = 0; + virtual void clear() = 0; + virtual DOM::EventListener *createHTMLEventHandler(TQString sourceUrl, TQString name, TQString code, DOM::NodeImpl* node) = 0; + virtual void finishedWithEvent(const DOM::Event &event) = 0; + virtual KJS::Interpreter *interpreter() = 0; + + virtual void setDebugEnabled(bool enabled) = 0; + virtual void showDebugWindow(bool show=true) = 0; + virtual bool paused() const = 0; + virtual void dataReceived() = 0; + + void setEventHandlerLineno(int lineno) { m_handlerLineno = lineno; } + + tdehtml::ChildFrame *m_frame; + int m_handlerLineno; + + // Helper method, to access the private KHTMLPart::jScript() + static KJSProxy *proxy( KHTMLPart *part ); +}; + +class KJSCPUGuard { +public: + KJSCPUGuard() {} + void start(unsigned int msec=5000, unsigned int i_msec=10000); + void stop(); +private: + void (*oldAlarmHandler)(int); + static void alarmHandler(int); + static bool confirmTerminate(); + itimerval oldtv; +}; + +#endif diff --git a/tdehtml/ecma/kjs_range.cpp b/tdehtml/ecma/kjs_range.cpp new file mode 100644 index 000000000..bf148ffe8 --- /dev/null +++ b/tdehtml/ecma/kjs_range.cpp @@ -0,0 +1,233 @@ + +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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_range.h" +#include "kjs_range.lut.h" +#include <kdebug.h> + +namespace KJS { + +// ------------------------------------------------------------------------- + +const ClassInfo DOMRange::info = { "Range", 0, &DOMRangeTable, 0 }; +/* +@begin DOMRangeTable 7 + startContainer DOMRange::StartContainer DontDelete|ReadOnly + startOffset DOMRange::StartOffset DontDelete|ReadOnly + endContainer DOMRange::EndContainer DontDelete|ReadOnly + endOffset DOMRange::EndOffset DontDelete|ReadOnly + collapsed DOMRange::Collapsed DontDelete|ReadOnly + commonAncestorContainer DOMRange::CommonAncestorContainer DontDelete|ReadOnly +@end +@begin DOMRangeProtoTable 17 +setStart DOMRange::SetStart DontDelete|Function 2 + setEnd DOMRange::SetEnd DontDelete|Function 2 + setStartBefore DOMRange::SetStartBefore DontDelete|Function 1 + setStartAfter DOMRange::SetStartAfter DontDelete|Function 1 + setEndBefore DOMRange::SetEndBefore DontDelete|Function 1 + setEndAfter DOMRange::SetEndAfter DontDelete|Function 1 + collapse DOMRange::Collapse DontDelete|Function 1 + selectNode DOMRange::SelectNode DontDelete|Function 1 + selectNodeContents DOMRange::SelectNodeContents DontDelete|Function 1 + compareBoundaryPoints DOMRange::CompareBoundaryPoints DontDelete|Function 2 + deleteContents DOMRange::DeleteContents DontDelete|Function 0 + extractContents DOMRange::ExtractContents DontDelete|Function 0 + cloneContents DOMRange::CloneContents DontDelete|Function 0 + insertNode DOMRange::InsertNode DontDelete|Function 1 + surroundContents DOMRange::SurroundContents DontDelete|Function 1 + cloneRange DOMRange::CloneRange DontDelete|Function 0 + toString DOMRange::ToString DontDelete|Function 0 + detach DOMRange::Detach DontDelete|Function 0 + createContextualFragment DOMRange::CreateContextualFragment DontDelete|Function 1 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMRangeProto) +IMPLEMENT_PROTOFUNC_DOM(DOMRangeProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMRange",DOMRangeProto,DOMRangeProtoFunc) + +DOMRange::DOMRange(ExecState *exec, DOM::Range r) + : DOMObject(DOMRangeProto::self(exec)), range(r) {} + +DOMRange::~DOMRange() +{ + ScriptInterpreter::forgetDOMObject(range.handle()); +} + +Value DOMRange::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMRange,DOMObject>(exec,p,&DOMRangeTable,this); +} + +Value DOMRange::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case StartContainer: + return getDOMNode(exec,range.startContainer()); + case StartOffset: + return Number(range.startOffset()); + case EndContainer: + return getDOMNode(exec,range.endContainer()); + case EndOffset: + return Number(range.endOffset()); + case Collapsed: + return Boolean(range.collapsed()); + case CommonAncestorContainer: { + DOM::Range range2 = range; // avoid const error + return getDOMNode(exec,range2.commonAncestorContainer()); + } + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMRange::getValueProperty : " << token << endl; + return Value(); + } +} + +Value DOMRangeProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMRange, thisObj ); + DOM::Range range = static_cast<DOMRange *>(thisObj.imp())->toRange(); + Value result; + + switch (id) { + case DOMRange::SetStart: + range.setStart(toNode(args[0]),args[1].toInteger(exec)); + result = Undefined(); + break; + case DOMRange::SetEnd: + range.setEnd(toNode(args[0]),args[1].toInteger(exec)); + result = Undefined(); + break; + case DOMRange::SetStartBefore: + range.setStartBefore(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::SetStartAfter: + range.setStartAfter(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::SetEndBefore: + range.setEndBefore(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::SetEndAfter: + range.setEndAfter(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::Collapse: + range.collapse(args[0].toBoolean(exec)); + result = Undefined(); + break; + case DOMRange::SelectNode: + range.selectNode(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::SelectNodeContents: + range.selectNodeContents(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::CompareBoundaryPoints: + result = Number(range.compareBoundaryPoints(static_cast<DOM::Range::CompareHow>(args[0].toInteger(exec)),toRange(args[1]))); + break; + case DOMRange::DeleteContents: + range.deleteContents(); + result = Undefined(); + break; + case DOMRange::ExtractContents: + result = getDOMNode(exec,range.extractContents()); + break; + case DOMRange::CloneContents: + result = getDOMNode(exec,range.cloneContents()); + break; + case DOMRange::InsertNode: + range.insertNode(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::SurroundContents: + range.surroundContents(toNode(args[0])); + result = Undefined(); + break; + case DOMRange::CloneRange: + result = getDOMRange(exec,range.cloneRange()); + break; + case DOMRange::ToString: + result = String(range.toString()); + break; + case DOMRange::Detach: + range.detach(); + result = Undefined(); + break; + case DOMRange::CreateContextualFragment: + Value value = args[0]; + DOM::DOMString str = value.isA(NullType) ? DOM::DOMString() : value.toString(exec).string(); + result = getDOMNode(exec, range.createContextualFragment(str)); + break; + }; + + return result; +} + +Value getDOMRange(ExecState *exec, DOM::Range r) +{ + return cacheDOMObject<DOM::Range, KJS::DOMRange>(exec, r); +} + +// ------------------------------------------------------------------------- + +const ClassInfo RangeConstructor::info = { "RangeConstructor", 0, &RangeConstructorTable, 0 }; +/* +@begin RangeConstructorTable 5 + START_TO_START DOM::Range::START_TO_START DontDelete|ReadOnly + START_TO_END DOM::Range::START_TO_END DontDelete|ReadOnly + END_TO_END DOM::Range::END_TO_END DontDelete|ReadOnly + END_TO_START DOM::Range::END_TO_START DontDelete|ReadOnly +@end +*/ + +RangeConstructor::RangeConstructor(ExecState *exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) { } + +Value RangeConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<RangeConstructor,DOMObject>(exec,p,&RangeConstructorTable,this); +} + +Value RangeConstructor::getValueProperty(ExecState *, int token) const +{ + return Number(token); +} + +Value getRangeConstructor(ExecState *exec) +{ + return cacheGlobalObject<RangeConstructor>(exec, "[[range.constructor]]"); +} + + +DOM::Range toRange(const Value& val) +{ + Object obj = Object::dynamicCast(val); + if (!obj.isValid() || !obj.inherits(&DOMRange::info)) + return DOM::Range(); + + const DOMRange *dobj = static_cast<const DOMRange*>(obj.imp()); + return dobj->toRange(); +} + +} //namespace KJS diff --git a/tdehtml/ecma/kjs_range.h b/tdehtml/ecma/kjs_range.h new file mode 100644 index 000000000..fbf47020f --- /dev/null +++ b/tdehtml/ecma/kjs_range.h @@ -0,0 +1,71 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * + * 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 + */ + +#ifndef _KJS_RANGE_H_ +#define _KJS_RANGE_H_ + +#include "ecma/kjs_dom.h" +#include "dom/dom2_range.h" + +namespace KJS { + + class DOMRange : public DOMObject { + public: + DOMRange(ExecState *exec, DOM::Range r); + ~DOMRange(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { StartContainer, StartOffset, EndContainer, EndOffset, Collapsed, + CommonAncestorContainer, + SetStart, SetEnd, SetStartBefore, SetStartAfter, SetEndBefore, + SetEndAfter, Collapse, SelectNode, SelectNodeContents, + CompareBoundaryPoints, DeleteContents, ExtractContents, + CloneContents, InsertNode, SurroundContents, CloneRange, ToString, + Detach, CreateContextualFragment }; + DOM::Range toRange() const { return range; } + protected: + DOM::Range range; + }; + + // Constructor object Range + class RangeConstructor : public DOMObject { + public: + RangeConstructor(ExecState *); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + Value getDOMRange(ExecState *exec, DOM::Range r); + Value getRangeConstructor(ExecState *exec); + + /** + * Convert an object to a Range. Returns a null Node if not possible. + */ + DOM::Range toRange(const Value&); + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_traversal.cpp b/tdehtml/ecma/kjs_traversal.cpp new file mode 100644 index 000000000..b8b9e824a --- /dev/null +++ b/tdehtml/ecma/kjs_traversal.cpp @@ -0,0 +1,327 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * + * 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_traversal.h" +#include "kjs_traversal.lut.h" +#include "kjs_proxy.h" +#include <dom/dom_node.h> +#include <xml/dom_nodeimpl.h> +#include <xml/dom_docimpl.h> +#include <tdehtmlview.h> +#include <tdehtml_part.h> +#include <kdebug.h> + +namespace KJS { + +// ------------------------------------------------------------------------- + +const ClassInfo DOMNodeIterator::info = { "NodeIterator", 0, &DOMNodeIteratorTable, 0 }; +/* +@begin DOMNodeIteratorTable 5 + root DOMNodeIterator::Root DontDelete|ReadOnly + whatToShow DOMNodeIterator::WhatToShow DontDelete|ReadOnly + filter DOMNodeIterator::Filter DontDelete|ReadOnly + expandEntityReferences DOMNodeIterator::ExpandEntityReferences DontDelete|ReadOnly +@end +@begin DOMNodeIteratorProtoTable 3 + nextNode DOMNodeIterator::NextNode DontDelete|Function 0 + previousNode DOMNodeIterator::PreviousNode DontDelete|Function 0 + detach DOMNodeIterator::Detach DontDelete|Function 0 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMNodeIteratorProto) +IMPLEMENT_PROTOFUNC_DOM(DOMNodeIteratorProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMNodeIterator", DOMNodeIteratorProto,DOMNodeIteratorProtoFunc) + +DOMNodeIterator::DOMNodeIterator(ExecState *exec, DOM::NodeIterator ni) + : DOMObject(DOMNodeIteratorProto::self(exec)), nodeIterator(ni) {} + +DOMNodeIterator::~DOMNodeIterator() +{ + ScriptInterpreter::forgetDOMObject(nodeIterator.handle()); +} + +Value DOMNodeIterator::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMNodeIterator,DOMObject>(exec,p,&DOMNodeIteratorTable,this); +} + +Value DOMNodeIterator::getValueProperty(ExecState *exec, int token) const +{ + DOM::NodeIterator ni(nodeIterator); + switch (token) { + case Root: + return getDOMNode(exec,ni.root()); + case WhatToShow: + return Number(ni.whatToShow()); + case Filter: + return getDOMNodeFilter(exec,ni.filter()); + case ExpandEntityReferences: + return Boolean(ni.expandEntityReferences()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMNodeIterator::getValueProperty : " << token << endl; + return Value(); + } +} + +Value DOMNodeIteratorProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &) +{ + KJS_CHECK_THIS( KJS::DOMNodeIterator, thisObj ); + DOM::NodeIterator nodeIterator = static_cast<DOMNodeIterator *>(thisObj.imp())->toNodeIterator(); + switch (id) { + case DOMNodeIterator::PreviousNode: + return getDOMNode(exec,nodeIterator.previousNode()); + case DOMNodeIterator::NextNode: + return getDOMNode(exec,nodeIterator.nextNode()); + case DOMNodeIterator::Detach: + nodeIterator.detach(); + return Undefined(); + } + return Undefined(); +} + +Value getDOMNodeIterator(ExecState *exec, DOM::NodeIterator ni) +{ + return cacheDOMObject<DOM::NodeIterator, DOMNodeIterator>(exec, ni); +} + + +// ------------------------------------------------------------------------- + +const ClassInfo NodeFilterConstructor::info = { "NodeFilterConstructor", 0, &NodeFilterConstructorTable, 0 }; +/* +@begin NodeFilterConstructorTable 17 + FILTER_ACCEPT DOM::NodeFilter::FILTER_ACCEPT DontDelete|ReadOnly + FILTER_REJECT DOM::NodeFilter::FILTER_REJECT DontDelete|ReadOnly + FILTER_SKIP DOM::NodeFilter::FILTER_SKIP DontDelete|ReadOnly + SHOW_ALL DOM::NodeFilter::SHOW_ALL DontDelete|ReadOnly + SHOW_ELEMENT DOM::NodeFilter::SHOW_ELEMENT DontDelete|ReadOnly + SHOW_ATTRIBUTE DOM::NodeFilter::SHOW_ATTRIBUTE DontDelete|ReadOnly + SHOW_TEXT DOM::NodeFilter::SHOW_TEXT DontDelete|ReadOnly + SHOW_CDATA_SECTION DOM::NodeFilter::SHOW_CDATA_SECTION DontDelete|ReadOnly + SHOW_ENTITY_REFERENCE DOM::NodeFilter::SHOW_ENTITY_REFERENCE DontDelete|ReadOnly + SHOW_ENTITY DOM::NodeFilter::SHOW_ENTITY DontDelete|ReadOnly + SHOW_PROCESSING_INSTRUCTION DOM::NodeFilter::SHOW_PROCESSING_INSTRUCTION DontDelete|ReadOnly + SHOW_COMMENT DOM::NodeFilter::SHOW_COMMENT DontDelete|ReadOnly + SHOW_DOCUMENT DOM::NodeFilter::SHOW_DOCUMENT DontDelete|ReadOnly + SHOW_DOCUMENT_TYPE DOM::NodeFilter::SHOW_DOCUMENT_TYPE DontDelete|ReadOnly + SHOW_DOCUMENT_FRAGMENT DOM::NodeFilter::SHOW_DOCUMENT_FRAGMENT DontDelete|ReadOnly + SHOW_NOTATION DOM::NodeFilter::SHOW_NOTATION DontDelete|ReadOnly +@end +*/ + +NodeFilterConstructor::NodeFilterConstructor(ExecState* exec) + : DOMObject(exec->interpreter()->builtinObjectPrototype()) +{ +} + +Value NodeFilterConstructor::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<NodeFilterConstructor,DOMObject>(exec,p,&NodeFilterConstructorTable,this); +} + +Value NodeFilterConstructor::getValueProperty(ExecState *, int token) const +{ + // We use the token as the value to return directly + return Number(token); +} + +Value getNodeFilterConstructor(ExecState *exec) +{ + return cacheGlobalObject<NodeFilterConstructor>(exec, "[[nodeFilter.constructor]]"); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMNodeFilter::info = { "NodeFilter", 0, 0, 0 }; +/* +@begin DOMNodeFilterProtoTable 1 + acceptNode DOMNodeFilter::AcceptNode DontDelete|Function 0 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMNodeFilterProto) +IMPLEMENT_PROTOFUNC_DOM(DOMNodeFilterProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMNodeFilter",DOMNodeFilterProto,DOMNodeFilterProtoFunc) + +DOMNodeFilter::DOMNodeFilter(ExecState *exec, DOM::NodeFilter nf) + : DOMObject(DOMNodeFilterProto::self(exec)), nodeFilter(nf) {} + +DOMNodeFilter::~DOMNodeFilter() +{ + ScriptInterpreter::forgetDOMObject(nodeFilter.handle()); +} + +Value DOMNodeFilterProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMNodeFilter, thisObj ); + DOM::NodeFilter nodeFilter = static_cast<DOMNodeFilter *>(thisObj.imp())->toNodeFilter(); + switch (id) { + case DOMNodeFilter::AcceptNode: + return Number(nodeFilter.acceptNode(toNode(args[0]))); + } + return Undefined(); +} + +Value getDOMNodeFilter(ExecState *exec, DOM::NodeFilter nf) +{ + return cacheDOMObject<DOM::NodeFilter, DOMNodeFilter>(exec, nf); +} + +// ------------------------------------------------------------------------- + +const ClassInfo DOMTreeWalker::info = { "TreeWalker", 0, &DOMTreeWalkerTable, 0 }; +/* +@begin DOMTreeWalkerTable 5 + root DOMTreeWalker::Root DontDelete|ReadOnly + whatToShow DOMTreeWalker::WhatToShow DontDelete|ReadOnly + filter DOMTreeWalker::Filter DontDelete|ReadOnly + expandEntityReferences DOMTreeWalker::ExpandEntityReferences DontDelete|ReadOnly + currentNode DOMTreeWalker::CurrentNode DontDelete +@end +@begin DOMTreeWalkerProtoTable 7 + parentNode DOMTreeWalker::ParentNode DontDelete|Function 0 + firstChild DOMTreeWalker::FirstChild DontDelete|Function 0 + lastChild DOMTreeWalker::LastChild DontDelete|Function 0 + previousSibling DOMTreeWalker::PreviousSibling DontDelete|Function 0 + nextSibling DOMTreeWalker::NextSibling DontDelete|Function 0 + previousNode DOMTreeWalker::PreviousNode DontDelete|Function 0 + nextNode DOMTreeWalker::NextNode DontDelete|Function 0 +@end +*/ +KJS_DEFINE_PROTOTYPE(DOMTreeWalkerProto) +IMPLEMENT_PROTOFUNC_DOM(DOMTreeWalkerProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("DOMTreeWalker", DOMTreeWalkerProto,DOMTreeWalkerProtoFunc) + +DOMTreeWalker::DOMTreeWalker(ExecState *exec, DOM::TreeWalker tw) + : DOMObject(DOMTreeWalkerProto::self(exec)), treeWalker(tw) {} + +DOMTreeWalker::~DOMTreeWalker() +{ + ScriptInterpreter::forgetDOMObject(treeWalker.handle()); +} + +Value DOMTreeWalker::tryGet(ExecState *exec, const Identifier &p) const +{ + return DOMObjectLookupGetValue<DOMTreeWalker,DOMObject>(exec,p,&DOMTreeWalkerTable,this); +} + +Value DOMTreeWalker::getValueProperty(ExecState *exec, int token) const +{ + DOM::TreeWalker tw(treeWalker); + switch (token) { + case Root: + return getDOMNode(exec,tw.root()); + case WhatToShow: + return Number(tw.whatToShow()); + case Filter: + return getDOMNodeFilter(exec,tw.filter()); + case ExpandEntityReferences: + return Boolean(tw.expandEntityReferences()); + case CurrentNode: + return getDOMNode(exec,tw.currentNode()); + default: + kdDebug(6070) << "WARNING: Unhandled token in DOMTreeWalker::getValueProperty : " << token << endl; + return Value(); + } +} + +void DOMTreeWalker::tryPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr) +{ + if (propertyName == "currentNode") { + treeWalker.setCurrentNode(toNode(value)); + } + else + ObjectImp::put(exec, propertyName, value, attr); +} + +Value DOMTreeWalkerProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &) +{ + KJS_CHECK_THIS( KJS::DOMTreeWalker, thisObj ); + DOM::TreeWalker treeWalker = static_cast<DOMTreeWalker *>(thisObj.imp())->toTreeWalker(); + switch (id) { + case DOMTreeWalker::ParentNode: + return getDOMNode(exec,treeWalker.parentNode()); + case DOMTreeWalker::FirstChild: + return getDOMNode(exec,treeWalker.firstChild()); + case DOMTreeWalker::LastChild: + return getDOMNode(exec,treeWalker.lastChild()); + case DOMTreeWalker::PreviousSibling: + return getDOMNode(exec,treeWalker.previousSibling()); + case DOMTreeWalker::NextSibling: + return getDOMNode(exec,treeWalker.nextSibling()); + case DOMTreeWalker::PreviousNode: + return getDOMNode(exec,treeWalker.previousSibling()); + case DOMTreeWalker::NextNode: + return getDOMNode(exec,treeWalker.nextNode()); + } + return Undefined(); +} + +Value getDOMTreeWalker(ExecState *exec, DOM::TreeWalker tw) +{ + return cacheDOMObject<DOM::TreeWalker, DOMTreeWalker>(exec, tw); +} + +DOM::NodeFilter toNodeFilter(const Value& val) +{ + Object obj = Object::dynamicCast(val); + if (!obj.isValid() || !obj.inherits(&DOMNodeFilter::info)) + return DOM::NodeFilter(); + + const DOMNodeFilter *dobj = static_cast<const DOMNodeFilter*>(obj.imp()); + return dobj->toNodeFilter(); +} + +// ------------------------------------------------------------------------- + +JSNodeFilter::JSNodeFilter(Object & _filter) : DOM::CustomNodeFilter(), filter( _filter ) +{ +} + +JSNodeFilter::~JSNodeFilter() +{ +} + +short JSNodeFilter::acceptNode(const DOM::Node &n) +{ + KHTMLView *view = static_cast<DOM::DocumentImpl *>( n.handle()->docPtr() )->view(); + if (!view) + return DOM::NodeFilter::FILTER_REJECT; + + KHTMLPart *part = view->part(); + KJSProxy *proxy = part->jScript(); + if (proxy) { + ExecState *exec = proxy->interpreter()->globalExec(); + Object acceptNodeFunc = Object::dynamicCast( filter.get(exec, "acceptNode") ); + if (!acceptNodeFunc.isNull() && acceptNodeFunc.implementsCall()) { + List args; + args.append(getDOMNode(exec,n)); + Value result = acceptNodeFunc.call(exec,filter,args); + if (exec->hadException()) + exec->clearException(); + return result.toInteger(exec); + } + } + + return DOM::NodeFilter::FILTER_REJECT; +} + +} //namespace KJS diff --git a/tdehtml/ecma/kjs_traversal.h b/tdehtml/ecma/kjs_traversal.h new file mode 100644 index 000000000..fd7e064b1 --- /dev/null +++ b/tdehtml/ecma/kjs_traversal.h @@ -0,0 +1,108 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * + * 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 + */ + +#ifndef _KJS_TRAVERSAL_H_ +#define _KJS_TRAVERSAL_H_ + +#include "ecma/kjs_dom.h" +#include "dom/dom2_traversal.h" + +namespace KJS { + + class DOMNodeIterator : public DOMObject { + public: + DOMNodeIterator(ExecState *exec, DOM::NodeIterator ni); + ~DOMNodeIterator(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Filter, Root, WhatToShow, ExpandEntityReferences, + NextNode, PreviousNode, Detach }; + DOM::NodeIterator toNodeIterator() const { return nodeIterator; } + protected: + DOM::NodeIterator nodeIterator; + }; + + // Constructor object NodeFilter + class NodeFilterConstructor : public DOMObject { + public: + NodeFilterConstructor(ExecState *); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *exec, int token) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + class DOMNodeFilter : public DOMObject { + public: + DOMNodeFilter(ExecState *exec, DOM::NodeFilter nf); + ~DOMNodeFilter(); + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + virtual DOM::NodeFilter toNodeFilter() const { return nodeFilter; } + enum { AcceptNode }; + protected: + DOM::NodeFilter nodeFilter; + }; + + class DOMTreeWalker : public DOMObject { + public: + DOMTreeWalker(ExecState *exec, DOM::TreeWalker tw); + ~DOMTreeWalker(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, + const Value& value, int attr = None); + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Root, WhatToShow, Filter, ExpandEntityReferences, CurrentNode, + ParentNode, FirstChild, LastChild, PreviousSibling, NextSibling, + PreviousNode, NextNode }; + DOM::TreeWalker toTreeWalker() const { return treeWalker; } + protected: + DOM::TreeWalker treeWalker; + }; + + Value getDOMNodeIterator(ExecState *exec, DOM::NodeIterator ni); + Value getNodeFilterConstructor(ExecState *exec); + Value getDOMNodeFilter(ExecState *exec, DOM::NodeFilter nf); + Value getDOMTreeWalker(ExecState *exec, DOM::TreeWalker tw); + + /** + * Convert an object to a NodeFilter. Returns a null Node if not possible. + */ + DOM::NodeFilter toNodeFilter(const Value&); + + class JSNodeFilter : public DOM::CustomNodeFilter { + public: + JSNodeFilter(Object & _filter); + virtual ~JSNodeFilter(); + virtual short acceptNode (const DOM::Node &n); + protected: + Object filter; + }; + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_views.cpp b/tdehtml/ecma/kjs_views.cpp new file mode 100644 index 000000000..dbf354ce8 --- /dev/null +++ b/tdehtml/ecma/kjs_views.cpp @@ -0,0 +1,91 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * + * 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 "ecma/kjs_views.h" +#include "ecma/kjs_css.h" +#include "ecma/kjs_window.h" +#include "kjs_views.lut.h" + +using namespace KJS; + +// ------------------------------------------------------------------------- + +const ClassInfo DOMAbstractView::info = { "AbstractView", 0, &DOMAbstractViewTable, 0 }; +/* +@begin DOMAbstractViewTable 2 + document DOMAbstractView::Document DontDelete|ReadOnly + getComputedStyle DOMAbstractView::GetComputedStyle DontDelete|Function 2 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(DOMAbstractViewFunc) + +DOMAbstractView::DOMAbstractView(ExecState *exec, DOM::AbstractView av) + : DOMObject(exec->interpreter()->builtinObjectPrototype()), abstractView(av) {} + +DOMAbstractView::~DOMAbstractView() +{ + ScriptInterpreter::forgetDOMObject(abstractView.handle()); +} + +Value DOMAbstractView::tryGet(ExecState *exec, const Identifier &p) const +{ + if ( p == "document" ) + return getDOMNode(exec,abstractView.document()); + else if ( p == "getComputedStyle" ) + return lookupOrCreateFunction<DOMAbstractViewFunc>(exec,p,this,DOMAbstractView::GetComputedStyle,2,DontDelete|Function); + else + return DOMObject::tryGet(exec,p); +} + +Value DOMAbstractViewFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( KJS::DOMAbstractView, thisObj ); + DOM::AbstractView abstractView = static_cast<DOMAbstractView *>(thisObj.imp())->toAbstractView(); + switch (id) { + case DOMAbstractView::GetComputedStyle: { + DOM::Node arg0 = toNode(args[0]); + if (arg0.nodeType() != DOM::Node::ELEMENT_NODE) + return Undefined(); // throw exception? + else + return getDOMCSSStyleDeclaration(exec,abstractView.getComputedStyle(static_cast<DOM::Element>(arg0), + args[1].toString(exec).string())); + } + } + return Undefined(); +} + +Value KJS::getDOMAbstractView(ExecState *exec, DOM::AbstractView av) +{ + return cacheDOMObject<DOM::AbstractView, DOMAbstractView>(exec, av); +} + +DOM::AbstractView KJS::toAbstractView (const Value& val) +{ + Object obj = Object::dynamicCast(val); + if (!obj.isValid() || !obj.inherits(&DOMAbstractView::info)) + return DOM::AbstractView (); + + // the Window object is considered for all practical purposes as a descendant of AbstractView + if (obj.inherits(&Window::info)) + return static_cast<const Window *>(obj.imp())->toAbstractView(); + + const DOMAbstractView *dobj = static_cast<const DOMAbstractView *>(obj.imp()); + return dobj->toAbstractView (); +} diff --git a/tdehtml/ecma/kjs_views.h b/tdehtml/ecma/kjs_views.h new file mode 100644 index 000000000..11e103fde --- /dev/null +++ b/tdehtml/ecma/kjs_views.h @@ -0,0 +1,53 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2001 Peter Kelly (pmk@post.com) + * + * 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 + */ + +#ifndef _KJS_VIEWS_H_ +#define _KJS_VIEWS_H_ + +#include "ecma/kjs_dom.h" +#include "dom/dom2_views.h" + +namespace KJS { + + + class DOMAbstractView : public DOMObject { + public: + DOMAbstractView(ExecState *, DOM::AbstractView av); + ~DOMAbstractView(); + virtual Value tryGet(ExecState *exec,const Identifier &p) const; + // no put - all read-only + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + virtual DOM::AbstractView toAbstractView() const { return abstractView; } + enum { Document, GetComputedStyle }; + protected: + DOM::AbstractView abstractView; + }; + + Value getDOMAbstractView(ExecState *exec, DOM::AbstractView av); + + /** + * Convert an object to an AbstractView. Returns a null Node if not possible. + */ + DOM::AbstractView toAbstractView(const Value&); + +} // namespace + +#endif diff --git a/tdehtml/ecma/kjs_window.cpp b/tdehtml/ecma/kjs_window.cpp new file mode 100644 index 000000000..767c7607f --- /dev/null +++ b/tdehtml/ecma/kjs_window.cpp @@ -0,0 +1,2935 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000-2003 Harri Porten (porten@kde.org) + * Copyright (C) 2001-2003 David Faure (faure@kde.org) + * 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 "config.h" + +#include "tdehtmlview.h" +#include "tdehtml_part.h" +#include "tdehtmlpart_p.h" +#include "tdehtml_settings.h" +#include "xml/dom2_eventsimpl.h" +#include "xml/dom_docimpl.h" +#include "misc/htmltags.h" +#include "html/html_documentimpl.h" +#include "rendering/render_frames.h" + +#include <tqstylesheet.h> +#include <tqtimer.h> +#include <tqpaintdevicemetrics.h> +#include <tqapplication.h> +#include <kdebug.h> +#include <kmessagebox.h> +#include <kinputdialog.h> +#include <klocale.h> +#include <kmdcodec.h> +#include <tdeparts/browserinterface.h> +#include <twin.h> + +#if defined Q_WS_X11 && ! defined K_WS_QTONLY +#include <twinmodule.h> // schroder +#endif + +#ifndef KONQ_EMBEDDED +#include <kbookmarkmanager.h> +#endif +#include <kglobalsettings.h> +#include <assert.h> +#include <tqstyle.h> +#include <tqobjectlist.h> +#include <kstringhandler.h> + +#include "kjs_proxy.h" +#include "kjs_window.h" +#include "kjs_navigator.h" +#include "kjs_mozilla.h" +#include "kjs_html.h" +#include "kjs_range.h" +#include "kjs_traversal.h" +#include "kjs_css.h" +#include "kjs_events.h" +#include "kjs_views.h" +#include "xmlhttprequest.h" +#include "xmlserializer.h" +#include "domparser.h" + +using namespace KJS; + +namespace KJS { + + class History : public ObjectImp { + friend class HistoryFunc; + public: + History(ExecState *exec, KHTMLPart *p) + : ObjectImp(exec->interpreter()->builtinObjectPrototype()), part(p) { } + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Back, Forward, Go, Length }; + private: + TQGuardedPtr<KHTMLPart> part; + }; + + class External : public ObjectImp { + friend class ExternalFunc; + public: + External(ExecState *exec, KHTMLPart *p) + : ObjectImp(exec->interpreter()->builtinObjectPrototype()), part(p) { } + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { AddFavorite }; + private: + TQGuardedPtr<KHTMLPart> part; + }; + + class FrameArray : public ObjectImp { + public: + FrameArray(ExecState *exec, KHTMLPart *p) + : ObjectImp(exec->interpreter()->builtinObjectPrototype()), part(p) { } + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual Value call(ExecState *exec, Object &thisObj, const List &args); + virtual bool implementsCall() const { return true; } + private: + TQGuardedPtr<KHTMLPart> part; + }; + +#ifdef Q_WS_QWS + class KonquerorFunc : public DOMFunction { + public: + KonquerorFunc(ExecState *exec, const Konqueror* k, const char* name) + : DOMFunction(exec), konqueror(k), m_name(name) { } + virtual Value tryCall(ExecState *exec, Object &thisObj, const List &args); + + private: + const Konqueror* konqueror; + TQCString m_name; + }; +#endif +} // namespace KJS + +#include "kjs_window.lut.h" +#include "rendering/render_replaced.h" + +////////////////////// Screen Object //////////////////////// +namespace KJS { +// table for screen object +/* +@begin ScreenTable 7 + height Screen::Height DontEnum|ReadOnly + width Screen::Width DontEnum|ReadOnly + colorDepth Screen::ColorDepth DontEnum|ReadOnly + pixelDepth Screen::PixelDepth DontEnum|ReadOnly + availLeft Screen::AvailLeft DontEnum|ReadOnly + availTop Screen::AvailTop DontEnum|ReadOnly + availHeight Screen::AvailHeight DontEnum|ReadOnly + availWidth Screen::AvailWidth DontEnum|ReadOnly +@end +*/ + +const ClassInfo Screen::info = { "Screen", 0, &ScreenTable, 0 }; + +// We set the object prototype so that toString is implemented +Screen::Screen(ExecState *exec) + : ObjectImp(exec->interpreter()->builtinObjectPrototype()) {} + +Value Screen::get(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Screen::get " << p.qstring() << endl; +#endif + return lookupGetValue<Screen,ObjectImp>(exec,p,&ScreenTable,this); +} + +Value Screen::getValueProperty(ExecState *exec, int token) const +{ +#if defined Q_WS_X11 && ! defined K_WS_QTONLY + KWinModule info(0, KWinModule::INFO_DESKTOP); +#endif + TQWidget *thisWidget = Window::retrieveActive(exec)->part()->widget(); + TQRect sg = TDEGlobalSettings::desktopGeometry(thisWidget); + + switch( token ) { + case Height: + return Number(sg.height()); + case Width: + return Number(sg.width()); + case ColorDepth: + case PixelDepth: { + TQPaintDeviceMetrics m(TQApplication::desktop()); + return Number(m.depth()); + } + case AvailLeft: { +#if defined Q_WS_X11 && ! defined K_WS_QTONLY + TQRect clipped = info.workArea().intersect(sg); + return Number(clipped.x()-sg.x()); +#else + return Number(10); +#endif + } + case AvailTop: { +#if defined Q_WS_X11 && ! defined K_WS_QTONLY + TQRect clipped = info.workArea().intersect(sg); + return Number(clipped.y()-sg.y()); +#else + return Number(10); +#endif + } + case AvailHeight: { +#if defined Q_WS_X11 && ! defined K_WS_QTONLY + TQRect clipped = info.workArea().intersect(sg); + return Number(clipped.height()); +#else + return Number(100); +#endif + } + case AvailWidth: { +#if defined Q_WS_X11 && ! defined K_WS_QTONLY + TQRect clipped = info.workArea().intersect(sg); + return Number(clipped.width()); +#else + return Number(100); +#endif + } + default: + kdDebug(6070) << "WARNING: Screen::getValueProperty unhandled token " << token << endl; + return Undefined(); + } +} + +////////////////////// Window Object //////////////////////// + +const ClassInfo Window::info = { "Window", &DOMAbstractView::info, &WindowTable, 0 }; + +/* +@begin WindowTable 162 + atob Window::AToB DontDelete|Function 1 + btoa Window::BToA DontDelete|Function 1 + closed Window::Closed DontDelete|ReadOnly + crypto Window::Crypto DontDelete|ReadOnly + defaultStatus Window::DefaultStatus DontDelete + defaultstatus Window::DefaultStatus DontDelete + status Window::Status DontDelete + document Window::Document DontDelete|ReadOnly + frameElement Window::FrameElement DontDelete|ReadOnly + frames Window::Frames DontDelete|ReadOnly + history Window::_History DontDelete|ReadOnly + external Window::_External DontDelete|ReadOnly + event Window::Event DontDelete|ReadOnly + innerHeight Window::InnerHeight DontDelete|ReadOnly + innerWidth Window::InnerWidth DontDelete|ReadOnly + length Window::Length DontDelete|ReadOnly + location Window::_Location DontDelete + name Window::Name DontDelete + navigator Window::_Navigator DontDelete|ReadOnly + clientInformation Window::ClientInformation DontDelete|ReadOnly + konqueror Window::_Konqueror DontDelete|ReadOnly + offscreenBuffering Window::OffscreenBuffering DontDelete|ReadOnly + opener Window::Opener DontDelete|ReadOnly + outerHeight Window::OuterHeight DontDelete|ReadOnly + outerWidth Window::OuterWidth DontDelete|ReadOnly + pageXOffset Window::PageXOffset DontDelete|ReadOnly + pageYOffset Window::PageYOffset DontDelete|ReadOnly + parent Window::Parent DontDelete|ReadOnly + personalbar Window::Personalbar DontDelete|ReadOnly + screenX Window::ScreenX DontDelete|ReadOnly + screenY Window::ScreenY DontDelete|ReadOnly + scrollbars Window::Scrollbars DontDelete|ReadOnly + scroll Window::Scroll DontDelete|Function 2 + scrollBy Window::ScrollBy DontDelete|Function 2 + scrollTo Window::ScrollTo DontDelete|Function 2 + scrollX Window::ScrollX DontDelete|ReadOnly + scrollY Window::ScrollY DontDelete|ReadOnly + moveBy Window::MoveBy DontDelete|Function 2 + moveTo Window::MoveTo DontDelete|Function 2 + resizeBy Window::ResizeBy DontDelete|Function 2 + resizeTo Window::ResizeTo DontDelete|Function 2 + self Window::Self DontDelete|ReadOnly + window Window::_Window DontDelete|ReadOnly + top Window::Top DontDelete|ReadOnly + screen Window::_Screen DontDelete|ReadOnly + alert Window::Alert DontDelete|Function 1 + confirm Window::Confirm DontDelete|Function 1 + prompt Window::Prompt DontDelete|Function 2 + open Window::Open DontDelete|Function 3 + setTimeout Window::SetTimeout DontDelete|Function 2 + clearTimeout Window::ClearTimeout DontDelete|Function 1 + focus Window::Focus DontDelete|Function 0 + blur Window::Blur DontDelete|Function 0 + close Window::Close DontDelete|Function 0 + setInterval Window::SetInterval DontDelete|Function 2 + clearInterval Window::ClearInterval DontDelete|Function 1 + captureEvents Window::CaptureEvents DontDelete|Function 0 + releaseEvents Window::ReleaseEvents DontDelete|Function 0 + print Window::Print DontDelete|Function 0 + addEventListener Window::AddEventListener DontDelete|Function 3 + removeEventListener Window::RemoveEventListener DontDelete|Function 3 +# Normally found in prototype. Add to window object itself to make them +# accessible in closed and cross-site windows + valueOf Window::ValueOf DontDelete|Function 0 + toString Window::ToString DontDelete|Function 0 +# IE extension + navigate Window::Navigate DontDelete|Function 1 +# Mozilla extension + sidebar Window::SideBar DontDelete|ReadOnly + getComputedStyle Window::GetComputedStyle DontDelete|Function 2 + +# Warning, when adding a function to this object you need to add a case in Window::get + +# Event handlers +# IE also has: onactivate, onbefore/afterprint, onbeforedeactivate/unload, oncontrolselect, +# ondeactivate, onhelp, onmovestart/end, onresizestart/end, onscroll. +# It doesn't have onabort, onchange, ondragdrop (but NS has that last one). + onabort Window::Onabort DontDelete + onblur Window::Onblur DontDelete + onchange Window::Onchange DontDelete + onclick Window::Onclick DontDelete + ondblclick Window::Ondblclick DontDelete + ondragdrop Window::Ondragdrop DontDelete + onerror Window::Onerror DontDelete + onfocus Window::Onfocus DontDelete + onkeydown Window::Onkeydown DontDelete + onkeypress Window::Onkeypress DontDelete + onkeyup Window::Onkeyup DontDelete + onload Window::Onload DontDelete + onmousedown Window::Onmousedown DontDelete + onmousemove Window::Onmousemove DontDelete + onmouseout Window::Onmouseout DontDelete + onmouseover Window::Onmouseover DontDelete + onmouseup Window::Onmouseup DontDelete + onmove Window::Onmove DontDelete + onreset Window::Onreset DontDelete + onresize Window::Onresize DontDelete + onselect Window::Onselect DontDelete + onsubmit Window::Onsubmit DontDelete + onunload Window::Onunload DontDelete + +# Constructors/constant tables + Node Window::Node DontDelete + Event Window::EventCtor DontDelete + Range Window::Range DontDelete + NodeFilter Window::NodeFilter DontDelete + DOMException Window::DOMException DontDelete + CSSRule Window::CSSRule DontDelete + MutationEvent Window::MutationEventCtor DontDelete + KeyboardEvent Window::KeyboardEventCtor DontDelete + EventException Window::EventExceptionCtor DontDelete + Image Window::Image DontDelete|ReadOnly + Option Window::Option DontDelete|ReadOnly + XMLHttpRequest Window::XMLHttpRequest DontDelete|ReadOnly + XMLSerializer Window::XMLSerializer DontDelete|ReadOnly + DOMParser Window::DOMParser DontDelete|ReadOnly + +# Mozilla dom emulation ones. + Element Window::ElementCtor DontDelete + Document Window::DocumentCtor DontDelete + #this one is an alias since we don't have a separate XMLDocument + XMLDocument Window::DocumentCtor DontDelete + HTMLElement Window::HTMLElementCtor DontDelete + HTMLDocument Window::HTMLDocumentCtor DontDelete + HTMLHtmlElement Window::HTMLHtmlElementCtor DontDelete + HTMLHeadElement Window::HTMLHeadElementCtor DontDelete + HTMLLinkElement Window::HTMLLinkElementCtor DontDelete + HTMLTitleElement Window::HTMLTitleElementCtor DontDelete + HTMLMetaElement Window::HTMLMetaElementCtor DontDelete + HTMLBaseElement Window::HTMLBaseElementCtor DontDelete + HTMLIsIndexElement Window::HTMLIsIndexElementCtor DontDelete + HTMLStyleElement Window::HTMLStyleElementCtor DontDelete + HTMLBodyElement Window::HTMLBodyElementCtor DontDelete + HTMLFormElement Window::HTMLFormElementCtor DontDelete + HTMLSelectElement Window::HTMLSelectElementCtor DontDelete + HTMLOptGroupElement Window::HTMLOptGroupElementCtor DontDelete + HTMLOptionElement Window::HTMLOptionElementCtor DontDelete + HTMLInputElement Window::HTMLInputElementCtor DontDelete + HTMLTextAreaElement Window::HTMLTextAreaElementCtor DontDelete + HTMLButtonElement Window::HTMLButtonElementCtor DontDelete + HTMLLabelElement Window::HTMLLabelElementCtor DontDelete + HTMLFieldSetElement Window::HTMLFieldSetElementCtor DontDelete + HTMLLegendElement Window::HTMLLegendElementCtor DontDelete + HTMLUListElement Window::HTMLUListElementCtor DontDelete + HTMLOListElement Window::HTMLOListElementCtor DontDelete + HTMLDListElement Window::HTMLDListElementCtor DontDelete + HTMLDirectoryElement Window::HTMLDirectoryElementCtor DontDelete + HTMLMenuElement Window::HTMLMenuElementCtor DontDelete + HTMLLIElement Window::HTMLLIElementCtor DontDelete + HTMLDivElement Window::HTMLDivElementCtor DontDelete + HTMLParagraphElement Window::HTMLParagraphElementCtor DontDelete + HTMLHeadingElement Window::HTMLHeadingElementCtor DontDelete + HTMLBlockQuoteElement Window::HTMLBlockQuoteElementCtor DontDelete + HTMLQuoteElement Window::HTMLQuoteElementCtor DontDelete + HTMLPreElement Window::HTMLPreElementCtor DontDelete + HTMLBRElement Window::HTMLBRElementCtor DontDelete + HTMLBaseFontElement Window::HTMLBaseFontElementCtor DontDelete + HTMLFontElement Window::HTMLFontElementCtor DontDelete + HTMLHRElement Window::HTMLHRElementCtor DontDelete + HTMLModElement Window::HTMLModElementCtor DontDelete + HTMLAnchorElement Window::HTMLAnchorElementCtor DontDelete + HTMLImageElement Window::HTMLImageElementCtor DontDelete + HTMLObjectElement Window::HTMLObjectElementCtor DontDelete + HTMLParamElement Window::HTMLParamElementCtor DontDelete + HTMLAppletElement Window::HTMLAppletElementCtor DontDelete + HTMLMapElement Window::HTMLMapElementCtor DontDelete + HTMLAreaElement Window::HTMLAreaElementCtor DontDelete + HTMLScriptElement Window::HTMLScriptElementCtor DontDelete + HTMLTableElement Window::HTMLTableElementCtor DontDelete + HTMLTableCaptionElement Window::HTMLTableCaptionElementCtor DontDelete + HTMLTableColElement Window::HTMLTableColElementCtor DontDelete + HTMLTableSectionElement Window::HTMLTableSectionElementCtor DontDelete + HTMLTableRowElement Window::HTMLTableRowElementCtor DontDelete + HTMLTableCellElement Window::HTMLTableCellElementCtor DontDelete + HTMLFrameSetElement Window::HTMLFrameSetElementCtor DontDelete + HTMLLayerElement Window::HTMLLayerElementCtor DontDelete + HTMLFrameElement Window::HTMLFrameElementCtor DontDelete + HTMLIFrameElement Window::HTMLIFrameElementCtor DontDelete + CSSStyleDeclaration Window::CSSStyleDeclarationCtor DontDelete +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(WindowFunc) + +Window::Window(tdehtml::ChildFrame *p) + : ObjectImp(/*no proto*/), m_frame(p), screen(0), history(0), external(0), m_frames(0), loc(0), m_evt(0) +{ + winq = new WindowQObject(this); + //kdDebug(6070) << "Window::Window this=" << this << " part=" << m_part << " " << m_part->name() << endl; +} + +Window::~Window() +{ + delete winq; +} + +Window *Window::retrieveWindow(KParts::ReadOnlyPart *p) +{ + Object obj = Object::dynamicCast( retrieve( p ) ); +#ifndef NDEBUG + // obj should never be null, except when javascript has been disabled in that part. + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(p); + if ( part && part->jScriptEnabled() ) + { + assert( obj.isValid() ); +#ifndef QWS + assert( dynamic_cast<KJS::Window*>(obj.imp()) ); // type checking +#endif + } +#endif + if ( !obj.isValid() ) // JS disabled + return 0; + return static_cast<KJS::Window*>(obj.imp()); +} + +Window *Window::retrieveActive(ExecState *exec) +{ + ValueImp *imp = exec->interpreter()->globalObject().imp(); + assert( imp ); +#ifndef QWS + assert( dynamic_cast<KJS::Window*>(imp) ); +#endif + return static_cast<KJS::Window*>(imp); +} + +Value Window::retrieve(KParts::ReadOnlyPart *p) +{ + assert(p); + KHTMLPart * part = ::tqqt_cast<KHTMLPart *>(p); + KJSProxy *proxy = 0L; + if (!part) { + part = ::tqqt_cast<KHTMLPart *>(p->parent()); + if (part) + proxy = part->framejScript(p); + } else + proxy = part->jScript(); + if (proxy) { +#ifdef KJS_VERBOSE + kdDebug(6070) << "Window::retrieve part=" << part << " '" << part->name() << "' interpreter=" << proxy->interpreter() << " window=" << proxy->interpreter()->globalObject().imp() << endl; +#endif + return proxy->interpreter()->globalObject(); // the Global object is the "window" + } else { +#ifdef KJS_VERBOSE + kdDebug(6070) << "Window::retrieve part=" << p << " '" << p->name() << "' no jsproxy." << endl; +#endif + return Undefined(); // This can happen with JS disabled on the domain of that window + } +} + +Location *Window::location() const +{ + if (!loc) + const_cast<Window*>(this)->loc = new Location(m_frame); + return loc; +} + +ObjectImp* Window::frames( ExecState* exec ) const +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (part) + return m_frames ? m_frames : + (const_cast<Window*>(this)->m_frames = new FrameArray(exec, part)); + return 0L; +} + +// reference our special objects during garbage collection +void Window::mark() +{ + ObjectImp::mark(); + if (screen && !screen->marked()) + screen->mark(); + if (history && !history->marked()) + history->mark(); + if (external && !external->marked()) + external->mark(); + if (m_frames && !m_frames->marked()) + m_frames->mark(); + //kdDebug(6070) << "Window::mark " << this << " marking loc=" << loc << endl; + if (loc && !loc->marked()) + loc->mark(); + if (winq) + winq->mark(); +} + +bool Window::hasProperty(ExecState *exec, const Identifier &p) const +{ + // we don't want any operations on a closed window + if (m_frame.isNull() || m_frame->m_part.isNull()) + return ( p == "closed" ); + + if (ObjectImp::hasProperty(exec, p)) + return true; + + if (Lookup::findEntry(&WindowTable, p)) + return true; + + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part) + return false; + + TQString q = p.qstring(); + if (part->findFramePart(p.qstring())) + return true; + // allow window[1] or parent[1] etc. (#56983) + bool ok; + unsigned int i = p.toArrayIndex(&ok); + if (ok) { + TQPtrList<KParts::ReadOnlyPart> frames = part->frames(); + unsigned int len = frames.count(); + if (i < len) + return true; + } + + // allow shortcuts like 'Image1' instead of document.images.Image1 + if (part->document().isHTMLDocument()) { // might be XML + DOM::HTMLDocument doc = part->htmlDocument(); + // Keep in sync with tryGet + + if (static_cast<DOM::DocumentImpl*>(doc.handle())->underDocNamedCache().get(p.qstring())) + return true; + + return !doc.getElementById(p.string()).isNull(); + } + + return false; +} + +UString Window::toString(ExecState *) const +{ + return "[object Window]"; +} + +Value Window::get(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Window("<<this<<")::get " << p.qstring() << endl; +#endif + // we want only limited operations on a closed window + if (m_frame.isNull() || m_frame->m_part.isNull()) { + const HashEntry* entry = Lookup::findEntry(&WindowTable, p); + if (entry) { + switch (entry->value) { + case Closed: + return Boolean(true); + case _Location: + return Null(); + case ValueOf: + case ToString: + return lookupOrCreateFunction<WindowFunc>(exec,p, this, entry->value, + entry->params, entry->attr); + default: + break; + } + } + return Undefined(); + } + + // Look for overrides first + ValueImp *val = getDirect(p); + if (val) { + //kdDebug(6070) << "Window::get found dynamic property '" << p.ascii() << "'" << endl; + return isSafeScript(exec) ? Value(val) : Undefined(); + } + + const HashEntry* entry = Lookup::findEntry(&WindowTable, p); + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + + // properties that work on all windows + if (entry) { + // ReadOnlyPart first + switch(entry->value) { + case Closed: + return Boolean( false ); + case _Location: + // No isSafeScript test here, we must be able to _set_ location.href (#49819) + return Value(location()); + case _Window: + case Self: + return retrieve(m_frame->m_part); + default: + break; + } + if (!part) + return Undefined(); + // KHTMLPart next + switch(entry->value) { + case Frames: + return Value(frames(exec)); + case Opener: + if (!part->opener()) + return Null(); // ### a null Window might be better, but == null + else // doesn't work yet + return retrieve(part->opener()); + case Parent: + return retrieve(part->parentPart() ? part->parentPart() : (KHTMLPart*)part); + case Top: { + KHTMLPart *p = part; + while (p->parentPart()) + p = p->parentPart(); + return retrieve(p); + } + case Alert: + case Confirm: + case Prompt: + case Open: + case Close: + case Focus: + case Blur: + case AToB: + case BToA: + case GetComputedStyle: + case ValueOf: + case ToString: + return lookupOrCreateFunction<WindowFunc>(exec,p,this,entry->value,entry->params,entry->attr); + default: + break; + } + } else if (!part) { + // not a KHTMLPart + TQString rvalue; + KParts::LiveConnectExtension::Type rtype; + unsigned long robjid; + if (m_frame->m_liveconnect && + isSafeScript(exec) && + m_frame->m_liveconnect->get(0, p.qstring(), rtype, robjid, rvalue)) + return getLiveConnectValue(m_frame->m_liveconnect, p.qstring(), rtype, rvalue, robjid); + return Undefined(); + } + // properties that only work on safe windows + if (isSafeScript(exec) && entry) + { + //kdDebug(6070) << "token: " << entry->value << endl; + switch( entry->value ) { + case Crypto: + return Undefined(); // ### + case DefaultStatus: + return String(UString(part->jsDefaultStatusBarText())); + case Status: + return String(UString(part->jsStatusBarText())); + case Document: + if (part->document().isNull()) { + kdDebug(6070) << "Document.write: adding <HTML><BODY> to create document" << endl; + part->begin(); + part->write("<HTML><BODY>"); + part->end(); + } + return getDOMNode(exec,part->document()); + case FrameElement: + if (m_frame->m_frame) + return getDOMNode(exec,m_frame->m_frame->element()); + else + return Undefined(); + case Node: + return NodeConstructor::self(exec); + case Range: + return getRangeConstructor(exec); + case NodeFilter: + return getNodeFilterConstructor(exec); + case DOMException: + return getDOMExceptionConstructor(exec); + case CSSRule: + return getCSSRuleConstructor(exec); + case ElementCtor: + return ElementPseudoCtor::self(exec); + case HTMLElementCtor: + return HTMLElementPseudoCtor::self(exec); + case HTMLHtmlElementCtor: + return HTMLHtmlElementPseudoCtor::self(exec); + case HTMLHeadElementCtor: + return HTMLHeadElementPseudoCtor::self(exec); + case HTMLLinkElementCtor: + return HTMLLinkElementPseudoCtor::self(exec); + case HTMLTitleElementCtor: + return HTMLTitleElementPseudoCtor::self(exec); + case HTMLMetaElementCtor: + return HTMLMetaElementPseudoCtor::self(exec); + case HTMLBaseElementCtor: + return HTMLBaseElementPseudoCtor::self(exec); + case HTMLIsIndexElementCtor: + return HTMLIsIndexElementPseudoCtor::self(exec); + case HTMLStyleElementCtor: + return HTMLStyleElementPseudoCtor::self(exec); + case HTMLBodyElementCtor: + return HTMLBodyElementPseudoCtor::self(exec); + case HTMLFormElementCtor: + return HTMLFormElementPseudoCtor::self(exec); + case HTMLSelectElementCtor: + return HTMLSelectElementPseudoCtor::self(exec); + case HTMLOptGroupElementCtor: + return HTMLOptGroupElementPseudoCtor::self(exec); + case HTMLOptionElementCtor: + return HTMLOptionElementPseudoCtor::self(exec); + case HTMLInputElementCtor: + return HTMLInputElementPseudoCtor::self(exec); + case HTMLTextAreaElementCtor: + return HTMLTextAreaElementPseudoCtor::self(exec); + case HTMLButtonElementCtor: + return HTMLButtonElementPseudoCtor::self(exec); + case HTMLLabelElementCtor: + return HTMLLabelElementPseudoCtor::self(exec); + case HTMLFieldSetElementCtor: + return HTMLFieldSetElementPseudoCtor::self(exec); + case HTMLLegendElementCtor: + return HTMLLegendElementPseudoCtor::self(exec); + case HTMLUListElementCtor: + return HTMLUListElementPseudoCtor::self(exec); + case HTMLOListElementCtor: + return HTMLOListElementPseudoCtor::self(exec); + case HTMLDListElementCtor: + return HTMLDListElementPseudoCtor::self(exec); + case HTMLDirectoryElementCtor: + return HTMLDirectoryElementPseudoCtor::self(exec); + case HTMLMenuElementCtor: + return HTMLMenuElementPseudoCtor::self(exec); + case HTMLLIElementCtor: + return HTMLLIElementPseudoCtor::self(exec); + case HTMLDivElementCtor: + return HTMLDivElementPseudoCtor::self(exec); + case HTMLParagraphElementCtor: + return HTMLParagraphElementPseudoCtor::self(exec); + case HTMLHeadingElementCtor: + return HTMLHeadingElementPseudoCtor::self(exec); + case HTMLBlockQuoteElementCtor: + return HTMLBlockQuoteElementPseudoCtor::self(exec); + case HTMLQuoteElementCtor: + return HTMLQuoteElementPseudoCtor::self(exec); + case HTMLPreElementCtor: + return HTMLPreElementPseudoCtor::self(exec); + case HTMLBRElementCtor: + return HTMLBRElementPseudoCtor::self(exec); + case HTMLBaseFontElementCtor: + return HTMLBaseFontElementPseudoCtor::self(exec); + case HTMLFontElementCtor: + return HTMLFontElementPseudoCtor::self(exec); + case HTMLHRElementCtor: + return HTMLHRElementPseudoCtor::self(exec); + case HTMLModElementCtor: + return HTMLModElementPseudoCtor::self(exec); + case HTMLAnchorElementCtor: + return HTMLAnchorElementPseudoCtor::self(exec); + case HTMLImageElementCtor: + return HTMLImageElementPseudoCtor::self(exec); + case HTMLObjectElementCtor: + return HTMLObjectElementPseudoCtor::self(exec); + case HTMLParamElementCtor: + return HTMLParamElementPseudoCtor::self(exec); + case HTMLAppletElementCtor: + return HTMLAppletElementPseudoCtor::self(exec); + case HTMLMapElementCtor: + return HTMLMapElementPseudoCtor::self(exec); + case HTMLAreaElementCtor: + return HTMLAreaElementPseudoCtor::self(exec); + case HTMLScriptElementCtor: + return HTMLScriptElementPseudoCtor::self(exec); + case HTMLTableElementCtor: + return HTMLTableElementPseudoCtor::self(exec); + case HTMLTableCaptionElementCtor: + return HTMLTableCaptionElementPseudoCtor::self(exec); + case HTMLTableColElementCtor: + return HTMLTableColElementPseudoCtor::self(exec); + case HTMLTableSectionElementCtor: + return HTMLTableSectionElementPseudoCtor::self(exec); + case HTMLTableRowElementCtor: + return HTMLTableRowElementPseudoCtor::self(exec); + case HTMLTableCellElementCtor: + return HTMLTableCellElementPseudoCtor::self(exec); + case HTMLFrameSetElementCtor: + return HTMLFrameSetElementPseudoCtor::self(exec); + case HTMLLayerElementCtor: + return HTMLLayerElementPseudoCtor::self(exec); + case HTMLFrameElementCtor: + return HTMLFrameElementPseudoCtor::self(exec); + case HTMLIFrameElementCtor: + return HTMLIFrameElementPseudoCtor::self(exec); + case DocumentCtor: + return DocumentPseudoCtor::self(exec); + case HTMLDocumentCtor: + return HTMLDocumentPseudoCtor::self(exec); + case CSSStyleDeclarationCtor: + return CSSStyleDeclarationPseudoCtor::self(exec); + case EventCtor: + return EventConstructor::self(exec); + case MutationEventCtor: + return getMutationEventConstructor(exec); + case KeyboardEventCtor: + return getKeyboardEventConstructor(exec); + case EventExceptionCtor: + return getEventExceptionConstructor(exec); + case _History: + return Value(history ? history : + (const_cast<Window*>(this)->history = new History(exec,part))); + + case _External: + return Value(external ? external : + (const_cast<Window*>(this)->external = new External(exec,part))); + + case Event: + if (m_evt) + return getDOMEvent(exec,*m_evt); + else { +#ifdef KJS_VERBOSE + kdDebug(6070) << "WARNING: window(" << this << "," << part->name() << ").event, no event!" << endl; +#endif + return Undefined(); + } + case InnerHeight: + if (!part->view()) + return Undefined(); + tdehtml::RenderWidget::flushWidgetResizes(); // make sure frames have their final size + return Number(part->view()->visibleHeight()); + case InnerWidth: + if (!part->view()) + return Undefined(); + tdehtml::RenderWidget::flushWidgetResizes(); // make sure frames have their final size + return Number(part->view()->visibleWidth()); + case Length: + return Number(part->frames().count()); + case Name: + return String(part->name()); + case SideBar: + return Value(new MozillaSidebarExtension(exec, part)); + case _Navigator: + case ClientInformation: { + // Store the navigator in the object so we get the same one each time. + Value nav( new Navigator(exec, part) ); + const_cast<Window *>(this)->put(exec, "navigator", nav, DontDelete|ReadOnly|Internal); + const_cast<Window *>(this)->put(exec, "clientInformation", nav, DontDelete|ReadOnly|Internal); + return nav; + } +#ifdef Q_WS_QWS + case _Konqueror: { + Value k( new Konqueror(part) ); + const_cast<Window *>(this)->put(exec, "konqueror", k, DontDelete|ReadOnly|Internal); + return k; + } +#endif + case OffscreenBuffering: + return Boolean(true); + case OuterHeight: + case OuterWidth: + { +#if defined Q_WS_X11 && ! defined K_WS_QTONLY + if (!part->widget()) + return Number(0); + KWin::WindowInfo inf = KWin::windowInfo(part->widget()->topLevelWidget()->winId()); + return Number(entry->value == OuterHeight ? + inf.geometry().height() : inf.geometry().width()); +#else + return Number(entry->value == OuterHeight ? + part->view()->height() : part->view()->width()); +#endif + } + case PageXOffset: + return Number(part->view()->contentsX()); + case PageYOffset: + return Number(part->view()->contentsY()); + case Personalbar: + return Undefined(); // ### + case ScreenLeft: + case ScreenX: { + if (!part->view()) + return Undefined(); + TQRect sg = TDEGlobalSettings::desktopGeometry(part->view()); + return Number(part->view()->mapToGlobal(TQPoint(0,0)).x() + sg.x()); + } + case ScreenTop: + case ScreenY: { + if (!part->view()) + return Undefined(); + TQRect sg = TDEGlobalSettings::desktopGeometry(part->view()); + return Number(part->view()->mapToGlobal(TQPoint(0,0)).y() + sg.y()); + } + case ScrollX: { + if (!part->view()) + return Undefined(); + return Number(part->view()->contentsX()); + } + case ScrollY: { + if (!part->view()) + return Undefined(); + return Number(part->view()->contentsY()); + } + case Scrollbars: + return Undefined(); // ### + case _Screen: + return Value(screen ? screen : + (const_cast<Window*>(this)->screen = new Screen(exec))); + case Image: + return Value(new ImageConstructorImp(exec, part->document())); + case Option: + return Value(new OptionConstructorImp(exec, part->document())); + case XMLHttpRequest: + return Value(new XMLHttpRequestConstructorImp(exec, part->document())); + case XMLSerializer: + return Value(new XMLSerializerConstructorImp(exec)); + case DOMParser: + return Value(new DOMParserConstructorImp(exec, part->xmlDocImpl())); + case Scroll: // compatibility + case ScrollBy: + case ScrollTo: + case MoveBy: + case MoveTo: + case ResizeBy: + case ResizeTo: + case CaptureEvents: + case ReleaseEvents: + case AddEventListener: + case RemoveEventListener: + case SetTimeout: + case ClearTimeout: + case SetInterval: + case ClearInterval: + case Print: + return lookupOrCreateFunction<WindowFunc>(exec,p,this,entry->value,entry->params,entry->attr); + // IE extension + case Navigate: + // Disabled in NS-compat mode. Supported by default - can't hurt, unless someone uses + // if (navigate) to test for IE (unlikely). + if ( exec->interpreter()->compatMode() == Interpreter::NetscapeCompat ) + return Undefined(); + return lookupOrCreateFunction<WindowFunc>(exec,p,this,entry->value,entry->params,entry->attr); + case Onabort: + return getListener(exec,DOM::EventImpl::ABORT_EVENT); + case Onblur: + return getListener(exec,DOM::EventImpl::BLUR_EVENT); + case Onchange: + return getListener(exec,DOM::EventImpl::CHANGE_EVENT); + case Onclick: + return getListener(exec,DOM::EventImpl::KHTML_ECMA_CLICK_EVENT); + case Ondblclick: + return getListener(exec,DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT); + case Ondragdrop: + return getListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT); + case Onerror: + return getListener(exec,DOM::EventImpl::ERROR_EVENT); + case Onfocus: + return getListener(exec,DOM::EventImpl::FOCUS_EVENT); + case Onkeydown: + return getListener(exec,DOM::EventImpl::KEYDOWN_EVENT); + case Onkeypress: + return getListener(exec,DOM::EventImpl::KEYPRESS_EVENT); + case Onkeyup: + return getListener(exec,DOM::EventImpl::KEYUP_EVENT); + case Onload: + return getListener(exec,DOM::EventImpl::LOAD_EVENT); + case Onmousedown: + return getListener(exec,DOM::EventImpl::MOUSEDOWN_EVENT); + case Onmousemove: + return getListener(exec,DOM::EventImpl::MOUSEMOVE_EVENT); + case Onmouseout: + return getListener(exec,DOM::EventImpl::MOUSEOUT_EVENT); + case Onmouseover: + return getListener(exec,DOM::EventImpl::MOUSEOVER_EVENT); + case Onmouseup: + return getListener(exec,DOM::EventImpl::MOUSEUP_EVENT); + case Onmove: + return getListener(exec,DOM::EventImpl::KHTML_MOVE_EVENT); + case Onreset: + return getListener(exec,DOM::EventImpl::RESET_EVENT); + case Onresize: + return getListener(exec,DOM::EventImpl::RESIZE_EVENT); + case Onselect: + return getListener(exec,DOM::EventImpl::SELECT_EVENT); + case Onsubmit: + return getListener(exec,DOM::EventImpl::SUBMIT_EVENT); + case Onunload: + return getListener(exec,DOM::EventImpl::UNLOAD_EVENT); + } + } + + // doing the remainder of ObjectImp::get() that is not covered by + // the getDirect() call above. + // #### guessed position. move further up or down? + Object proto = Object::dynamicCast(prototype()); + assert(proto.isValid()); + if (p == specialPrototypePropertyName) + return isSafeScript(exec) ? Value(proto) : Undefined(); + Value val2 = proto.get(exec, p); + if (!val2.isA(UndefinedType)) { + return isSafeScript(exec) ? val2 : Undefined(); + } + + KParts::ReadOnlyPart *rop = part->findFramePart( p.qstring() ); + if (rop) + return retrieve(rop); + + // allow window[1] or parent[1] etc. (#56983) + bool ok; + unsigned int i = p.toArrayIndex(&ok); + if (ok) { + TQPtrList<KParts::ReadOnlyPart> frames = part->frames(); + unsigned int len = frames.count(); + if (i < len) { + KParts::ReadOnlyPart* frame = frames.at(i); + if (frame) + return Window::retrieve(frame); + } + } + + //Check for images, forms, objects, etc. + if (isSafeScript(exec) && part->document().isHTMLDocument()) { // might be XML + DOM::DocumentImpl* docImpl = part->xmlDocImpl(); + DOM::ElementMappingCache::ItemInfo* info = docImpl->underDocNamedCache().get(p.qstring()); + if (info) { + //May be a false positive, but we can try to avoid doing it the hard way in + //simpler cases. The trickiness here is that the cache is kept under both + //name and id, but we sometimes ignore id for IE compat + DOM::DOMString propertyDOMString = p.string(); + if (info->nd && DOM::HTMLMappedNameCollectionImpl::matchesName(info->nd, + DOM::HTMLCollectionImpl::WINDOW_NAMED_ITEMS, propertyDOMString)) { + return getDOMNode(exec, info->nd); + } else { + //Can't tell it just like that, so better go through collection and count stuff. This is the slow path... + DOM::HTMLMappedNameCollection coll(docImpl, DOM::HTMLCollectionImpl::WINDOW_NAMED_ITEMS, propertyDOMString); + + if (coll.length() == 1) + return getDOMNode(exec, coll.firstItem()); + else if (coll.length() > 1) + return getHTMLCollection(exec, coll); + } + } + DOM::Element element = part->document().getElementById(p.string()); + if ( !element.isNull() ) + return getDOMNode(exec, element ); + } + + // This isn't necessarily a bug. Some code uses if(!window.blah) window.blah=1 + // But it can also mean something isn't loaded or implemented, hence the WARNING to help grepping. +#ifdef KJS_VERBOSE + kdDebug(6070) << "WARNING: Window::get property not found: " << p.qstring() << endl; +#endif + return Undefined(); +} + +void Window::put(ExecState* exec, const Identifier &propertyName, const Value &value, int attr) +{ + // we don't want any operations on a closed window + if (m_frame.isNull() || m_frame->m_part.isNull()) { + // ### throw exception? allow setting of some props like location? + return; + } + + // Called by an internal KJS call (e.g. InterpreterImp's constructor) ? + // If yes, save time and jump directly to ObjectImp. + if ( (attr != None && attr != DontDelete) || + // Same thing if we have a local override (e.g. "var location") + ( isSafeScript( exec ) && ObjectImp::getDirect(propertyName) ) ) + { + ObjectImp::put( exec, propertyName, value, attr ); + return; + } + + const HashEntry* entry = Lookup::findEntry(&WindowTable, propertyName); + if (entry && !m_frame.isNull() && !m_frame->m_part.isNull()) + { +#ifdef KJS_VERBOSE + kdDebug(6070) << "Window("<<this<<")::put " << propertyName.qstring() << endl; +#endif + switch( entry->value) { + case _Location: + goURL(exec, value.toString(exec).qstring(), false /*don't lock history*/); + return; + default: + break; + } + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (part) { + switch( entry->value ) { + case Status: { + if (isSafeScript(exec) && part->settings()->windowStatusPolicy(part->url().host()) + == KHTMLSettings::KJSWindowStatusAllow) { + String s = value.toString(exec); + part->setJSStatusBarText(s.value().qstring()); + } + return; + } + case DefaultStatus: { + if (isSafeScript(exec) && part->settings()->windowStatusPolicy(part->url().host()) + == KHTMLSettings::KJSWindowStatusAllow) { + String s = value.toString(exec); + part->setJSDefaultStatusBarText(s.value().qstring()); + } + return; + } + case Onabort: + if (isSafeScript(exec)) + setListener(exec, DOM::EventImpl::ABORT_EVENT,value); + return; + case Onblur: + if (isSafeScript(exec)) + setListener(exec, DOM::EventImpl::BLUR_EVENT,value); + return; + case Onchange: + if (isSafeScript(exec)) + setListener(exec, DOM::EventImpl::CHANGE_EVENT,value); + return; + case Onclick: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KHTML_ECMA_CLICK_EVENT,value); + return; + case Ondblclick: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT,value); + return; + case Ondragdrop: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT,value); + return; + case Onerror: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::ERROR_EVENT,value); + return; + case Onfocus: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::FOCUS_EVENT,value); + return; + case Onkeydown: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KEYDOWN_EVENT,value); + return; + case Onkeypress: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KEYPRESS_EVENT,value); + return; + case Onkeyup: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KEYUP_EVENT,value); + return; + case Onload: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::LOAD_EVENT,value); + return; + case Onmousedown: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::MOUSEDOWN_EVENT,value); + return; + case Onmousemove: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::MOUSEMOVE_EVENT,value); + return; + case Onmouseout: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::MOUSEOUT_EVENT,value); + return; + case Onmouseover: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::MOUSEOVER_EVENT,value); + return; + case Onmouseup: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::MOUSEUP_EVENT,value); + return; + case Onmove: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::KHTML_MOVE_EVENT,value); + return; + case Onreset: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::RESET_EVENT,value); + return; + case Onresize: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::RESIZE_EVENT,value); + return; + case Onselect: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::SELECT_EVENT,value); + return; + case Onsubmit: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::SUBMIT_EVENT,value); + return; + case Onunload: + if (isSafeScript(exec)) + setListener(exec,DOM::EventImpl::UNLOAD_EVENT,value); + return; + case Name: + if (isSafeScript(exec)) + part->setName( value.toString(exec).qstring().local8Bit().data() ); + return; + default: + break; + } + } + } + if (m_frame->m_liveconnect && + isSafeScript(exec) && + m_frame->m_liveconnect->put(0, propertyName.qstring(), value.toString(exec).qstring())) + return; + if (isSafeScript(exec)) { + //kdDebug(6070) << "Window("<<this<<")::put storing " << propertyName.qstring() << endl; + ObjectImp::put(exec, propertyName, value, attr); + } +} + +bool Window::toBoolean(ExecState *) const +{ + return !m_frame.isNull() && !m_frame->m_part.isNull(); +} + +DOM::AbstractView Window::toAbstractView() const +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part) + return DOM::AbstractView(); + return part->document().defaultView(); +} + +void Window::scheduleClose() +{ + kdDebug(6070) << "Window::scheduleClose window.close() " << m_frame << endl; + Q_ASSERT(winq); + TQTimer::singleShot( 0, winq, TQT_SLOT( timeoutClose() ) ); +} + +void Window::closeNow() +{ + if (m_frame.isNull() || m_frame->m_part.isNull()) { + kdDebug(6070) << k_funcinfo << "part is deleted already" << endl; + } else { + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part) { + kdDebug(6070) << "closeNow on non KHTML part" << endl; + } else { + //kdDebug(6070) << k_funcinfo << " -> closing window" << endl; + // We want to make sure that window.open won't find this part by name. + part->setName( 0 ); + part->deleteLater(); + part = 0; + } + } +} + +void Window::afterScriptExecution() +{ + DOM::DocumentImpl::updateDocumentsRendering(); + TQValueList<DelayedAction> delayedActions = m_delayed; + m_delayed.clear(); + TQValueList<DelayedAction>::Iterator it = delayedActions.begin(); + for ( ; it != delayedActions.end() ; ++it ) + { + switch ((*it).actionId) { + case DelayedClose: + scheduleClose(); + return; // stop here, in case of multiple actions + case DelayedGoHistory: + goHistory( (*it).param.toInt() ); + break; + case NullAction: + // FIXME: anything needs to be done here? This is warning anyways. + break; + }; + } +} + +bool Window::checkIsSafeScript(KParts::ReadOnlyPart *activePart) const +{ + if (m_frame.isNull() || m_frame->m_part.isNull()) { // part deleted ? can't grant access + kdDebug(6070) << "Window::isSafeScript: accessing deleted part !" << endl; + return false; + } + if (!activePart) { + kdDebug(6070) << "Window::isSafeScript: current interpreter's part is 0L!" << endl; + return false; + } + if ( activePart == m_frame->m_part ) // Not calling from another frame, no problem. + return true; + + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part) + return true; // not a KHTMLPart + + if ( part->document().isNull() ) + return true; // allow to access a window that was just created (e.g. with window.open("about:blank")) + + DOM::HTMLDocument thisDocument = part->htmlDocument(); + if ( thisDocument.isNull() ) { + kdDebug(6070) << "Window::isSafeScript: trying to access an XML document !?" << endl; + return false; + } + + KHTMLPart *activeKHTMLPart = ::tqqt_cast<KHTMLPart *>(activePart); + if (!activeKHTMLPart) + return true; // not a KHTMLPart + + DOM::HTMLDocument actDocument = activeKHTMLPart->htmlDocument(); + if ( actDocument.isNull() ) { + kdDebug(6070) << "Window::isSafeScript: active part has no document!" << endl; + return false; + } + DOM::DOMString actDomain = actDocument.domain(); + DOM::DOMString thisDomain = thisDocument.domain(); + + if ( actDomain == thisDomain ) { +#ifdef KJS_VERBOSE + //kdDebug(6070) << "JavaScript: access granted, domain is '" << actDomain.string() << "'" << endl; +#endif + return true; + } + + kdDebug(6070) << "WARNING: JavaScript: access denied for current frame '" << actDomain.string() << "' to frame '" << thisDomain.string() << "'" << endl; + // TODO after 3.1: throw security exception (exec->setException()) + return false; +} + +void Window::setListener(ExecState *exec, int eventId, Value func) +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part || !isSafeScript(exec)) + return; + DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl*>(part->htmlDocument().handle()); + if (!doc) + return; + + doc->setHTMLWindowEventListener(eventId,getJSEventListener(func,true)); +} + +Value Window::getListener(ExecState *exec, int eventId) const +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part || !isSafeScript(exec)) + return Undefined(); + DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl*>(part->htmlDocument().handle()); + if (!doc) + return Undefined(); + + DOM::EventListener *listener = doc->getHTMLWindowEventListener(eventId); + if (listener && static_cast<JSEventListener*>(listener)->listenerObjImp()) + return static_cast<JSEventListener*>(listener)->listenerObj(); + else + return Null(); +} + + +JSEventListener *Window::getJSEventListener(const Value& val, bool html) +{ + // This function is so hot that it's worth coding it directly with imps. + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part || val.type() != ObjectType) + return 0; + + // It's ObjectType, so it must be valid. + Object listenerObject = Object::dynamicCast(val); + ObjectImp *listenerObjectImp = listenerObject.imp(); + + // 'listener' is not a simple ecma function. (Always use sanity checks: Better safe than sorry!) + if (!listenerObject.implementsCall() && part && part->jScript() && part->jScript()->interpreter()) + { + Interpreter *interpreter = part->jScript()->interpreter(); + + // 'listener' probably is an EventListener object containing a 'handleEvent' function. + Value handleEventValue = listenerObject.get(interpreter->globalExec(), Identifier("handleEvent")); + Object handleEventObject = Object::dynamicCast(handleEventValue); + + if(handleEventObject.isValid() && handleEventObject.implementsCall()) + { + listenerObject = handleEventObject; + listenerObjectImp = handleEventObject.imp(); + } + } + + JSEventListener *existingListener = jsEventListeners[listenerObjectImp]; + if (existingListener) { + if ( existingListener->isHTMLEventListener() != html ) + // The existingListener will have the wrong type, so onclick= will behave like addEventListener or vice versa. + kdWarning() << "getJSEventListener: event listener already found but with html=" << !html << " - please report this, we thought it would never happen" << endl; + return existingListener; + } + + // Note that the JSEventListener constructor adds it to our jsEventListeners list + return new JSEventListener(listenerObject, listenerObjectImp, Object(this), html); +} + +JSLazyEventListener *Window::getJSLazyEventListener(const TQString& code, const TQString& name, DOM::NodeImpl *node) +{ + return new JSLazyEventListener(code, name, Object(this), node); +} + +void Window::clear( ExecState *exec ) +{ + delete winq; + winq = 0L; + // Get rid of everything, those user vars could hold references to DOM nodes + deleteAllProperties( exec ); + + // Break the dependency between the listeners and their object + TQPtrDictIterator<JSEventListener> it(jsEventListeners); + for (; it.current(); ++it) + it.current()->clear(); + // Forget about the listeners (the DOM::NodeImpls will delete them) + jsEventListeners.clear(); + + if (m_frame) { + KJSProxy* proxy = m_frame->m_jscript; + if (proxy) // i.e. JS not disabled + { + winq = new WindowQObject(this); + // Now recreate a working global object for the next URL that will use us + KJS::Interpreter *interpreter = proxy->interpreter(); + interpreter->initGlobalObject(); + } + } +} + +void Window::setCurrentEvent( DOM::Event *evt ) +{ + m_evt = evt; + //kdDebug(6070) << "Window " << this << " (part=" << m_part << ")::setCurrentEvent m_evt=" << evt << endl; +} + +void Window::goURL(ExecState* exec, const TQString& url, bool lockHistory) +{ + Window* active = Window::retrieveActive(exec); + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + KHTMLPart *active_part = ::tqqt_cast<KHTMLPart *>(active->part()); + // Complete the URL using the "active part" (running interpreter) + if (active_part && part) { + if (url[0] == TQChar('#')) { + part->gotoAnchor(url.mid(1)); + } else { + TQString dstUrl = active_part->htmlDocument().completeURL(url).string(); + kdDebug(6070) << "Window::goURL dstUrl=" << dstUrl << endl; + + // check if we're allowed to inject javascript + // SYNC check with tdehtml_part.cpp::slotRedirect! + if ( isSafeScript(exec) || + dstUrl.find(TQString::fromLatin1("javascript:"), 0, false) != 0 ) + part->scheduleRedirection(-1, + dstUrl, + lockHistory); + } + } else if (!part && !m_frame->m_part.isNull()) { + KParts::BrowserExtension *b = KParts::BrowserExtension::childObject(m_frame->m_part); + if (b) + b->emit openURLRequest(m_frame->m_frame->element()->getDocument()->completeURL(url)); + kdDebug() << "goURL for ROPart" << endl; + } +} + +KParts::ReadOnlyPart *Window::part() const { + return m_frame.isNull() ? 0L : static_cast<KParts::ReadOnlyPart *>(m_frame->m_part); +} + +void Window::delayedGoHistory( int steps ) +{ + m_delayed.append( DelayedAction( DelayedGoHistory, steps ) ); +} + +void Window::goHistory( int steps ) +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if(!part) + // TODO history readonlypart + return; + KParts::BrowserExtension *ext = part->browserExtension(); + if(!ext) + return; + KParts::BrowserInterface *iface = ext->browserInterface(); + + if ( !iface ) + return; + + iface->callMethod( "goHistory(int)", steps ); + //emit ext->goHistory(steps); +} + +void KJS::Window::resizeTo(TQWidget* tl, int width, int height) +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if(!part) + // TODO resizeTo readonlypart + return; + KParts::BrowserExtension *ext = part->browserExtension(); + if (!ext) { + kdDebug(6070) << "Window::resizeTo found no browserExtension" << endl; + return; + } + + // Security check: within desktop limits and bigger than 100x100 (per spec) + if ( width < 100 || height < 100 ) { + kdDebug(6070) << "Window::resizeTo refused, window would be too small ("<<width<<","<<height<<")" << endl; + return; + } + + TQRect sg = TDEGlobalSettings::desktopGeometry(tl); + + if ( width > sg.width() || height > sg.height() ) { + kdDebug(6070) << "Window::resizeTo refused, window would be too big ("<<width<<","<<height<<")" << endl; + return; + } + + kdDebug(6070) << "resizing to " << width << "x" << height << endl; + + emit ext->resizeTopLevelWidget( width, height ); + + // If the window is out of the desktop, move it up/left + // (maybe we should use workarea instead of sg, otherwise the window ends up below kicker) + int right = tl->x() + tl->frameGeometry().width(); + int bottom = tl->y() + tl->frameGeometry().height(); + int moveByX = 0; + int moveByY = 0; + if ( right > sg.right() ) + moveByX = - right + sg.right(); // always <0 + if ( bottom > sg.bottom() ) + moveByY = - bottom + sg.bottom(); // always <0 + if ( moveByX || moveByY ) + emit ext->moveTopLevelWidget( tl->x() + moveByX , tl->y() + moveByY ); +} + +Value Window::openWindow(ExecState *exec, const List& args) +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + if (!part) + return Undefined(); + KHTMLView *widget = part->view(); + Value v = args[0]; + TQString str; + if (v.isValid() && !v.isA(UndefinedType)) + str = v.toString(exec).qstring(); + + // prepare arguments + KURL url; + if (!str.isEmpty()) + { + KHTMLPart* p = ::tqqt_cast<KHTMLPart *>(Window::retrieveActive(exec)->m_frame->m_part); + if ( p ) + url = p->htmlDocument().completeURL(str).string(); + if ( !p || + !static_cast<DOM::DocumentImpl*>(p->htmlDocument().handle())->isURLAllowed(url.url()) ) + return Undefined(); + } + + KHTMLSettings::KJSWindowOpenPolicy policy = + part->settings()->windowOpenPolicy(part->url().host()); + if ( policy == KHTMLSettings::KJSWindowOpenAsk ) { + emit part->browserExtension()->requestFocus(part); + TQString caption; + if (!part->url().host().isEmpty()) + caption = part->url().host() + " - "; + caption += i18n( "Confirmation: JavaScript Popup" ); + if ( KMessageBox::questionYesNo(widget, + str.isEmpty() ? + i18n( "This site is requesting to open up a new browser " + "window via JavaScript.\n" + "Do you want to allow this?" ) : + i18n( "<qt>This site is requesting to open<p>%1</p>in a new browser window via JavaScript.<br />" + "Do you want to allow this?</qt>").arg(KStringHandler::csqueeze(url.htmlURL(), 100)), + caption, i18n("Allow"), i18n("Do Not Allow") ) == KMessageBox::Yes ) + policy = KHTMLSettings::KJSWindowOpenAllow; + } else if ( policy == KHTMLSettings::KJSWindowOpenSmart ) + { + // window.open disabled unless from a key/mouse event + if (static_cast<ScriptInterpreter *>(exec->interpreter())->isWindowOpenAllowed()) + policy = KHTMLSettings::KJSWindowOpenAllow; + } + + TQString frameName = args.size() > 1 ? args[1].toString(exec).qstring() : TQString("_blank"); + + v = args[2]; + TQString features; + if (!v.isNull() && v.type() != UndefinedType && v.toString(exec).size() > 0) { + features = v.toString(exec).qstring(); + // Buggy scripts have ' at beginning and end, cut those + if (features.startsWith("\'") && features.endsWith("\'")) + features = features.mid(1, features.length()-2); + } + + if ( policy != KHTMLSettings::KJSWindowOpenAllow ) { + if ( url.isEmpty() ) + part->setSuppressedPopupIndicator(true, 0); + else { + part->setSuppressedPopupIndicator(true, part); + m_suppressedWindowInfo.append( SuppressedWindowInfo( url, frameName, features ) ); + } + return Undefined(); + } else { + return executeOpenWindow(exec, url, frameName, features); + } +} + +Value Window::executeOpenWindow(ExecState *exec, const KURL& url, const TQString& frameName, const TQString& features) +{ + KHTMLPart *p = ::tqqt_cast<KHTMLPart *>(m_frame->m_part); + KHTMLView *widget = p->view(); + KParts::WindowArgs winargs; + + // scan feature argument + if (!features.isEmpty()) { + // specifying window params means false defaults + winargs.menuBarVisible = false; + winargs.toolBarsVisible = false; + winargs.statusBarVisible = false; + winargs.scrollBarsVisible = false; + TQStringList flist = TQStringList::split(',', features); + TQStringList::ConstIterator it = flist.begin(); + while (it != flist.end()) { + TQString s = *it++; + TQString key, val; + int pos = s.find('='); + if (pos >= 0) { + key = s.left(pos).stripWhiteSpace().lower(); + val = s.mid(pos + 1).stripWhiteSpace().lower(); + TQRect screen = TDEGlobalSettings::desktopGeometry(widget->topLevelWidget()); + + if (key == "left" || key == "screenx") { + winargs.x = (int)val.toFloat() + screen.x(); + if (winargs.x < screen.x() || winargs.x > screen.right()) + winargs.x = screen.x(); // only safe choice until size is determined + } else if (key == "top" || key == "screeny") { + winargs.y = (int)val.toFloat() + screen.y(); + if (winargs.y < screen.y() || winargs.y > screen.bottom()) + winargs.y = screen.y(); // only safe choice until size is determined + } else if (key == "height") { + winargs.height = (int)val.toFloat() + 2*tqApp->style().pixelMetric( TQStyle::PM_DefaultFrameWidth ) + 2; + if (winargs.height > screen.height()) // should actually check workspace + winargs.height = screen.height(); + if (winargs.height < 100) + winargs.height = 100; + } else if (key == "width") { + winargs.width = (int)val.toFloat() + 2*tqApp->style().pixelMetric( TQStyle::PM_DefaultFrameWidth ) + 2; + if (winargs.width > screen.width()) // should actually check workspace + winargs.width = screen.width(); + if (winargs.width < 100) + winargs.width = 100; + } else { + goto boolargs; + } + continue; + } else { + // leaving away the value gives true + key = s.stripWhiteSpace().lower(); + val = "1"; + } + boolargs: + if (key == "menubar") + winargs.menuBarVisible = (val == "1" || val == "yes"); + else if (key == "toolbar") + winargs.toolBarsVisible = (val == "1" || val == "yes"); + else if (key == "location") // ### missing in WindowArgs + winargs.toolBarsVisible = (val == "1" || val == "yes"); + else if (key == "status" || key == "statusbar") + winargs.statusBarVisible = (val == "1" || val == "yes"); + else if (key == "scrollbars") + winargs.scrollBarsVisible = (val == "1" || val == "yes"); + else if (key == "resizable") + winargs.resizable = (val == "1" || val == "yes"); + else if (key == "fullscreen") + winargs.fullscreen = (val == "1" || val == "yes"); + } + } + + KParts::URLArgs uargs; + uargs.frameName = frameName; + + if ( uargs.frameName.lower() == "_top" ) + { + while ( p->parentPart() ) + p = p->parentPart(); + Window::retrieveWindow(p)->goURL(exec, url.url(), false /*don't lock history*/); + return Window::retrieve(p); + } + if ( uargs.frameName.lower() == "_parent" ) + { + if ( p->parentPart() ) + p = p->parentPart(); + Window::retrieveWindow(p)->goURL(exec, url.url(), false /*don't lock history*/); + return Window::retrieve(p); + } + if ( uargs.frameName.lower() == "_self") + { + Window::retrieveWindow(p)->goURL(exec, url.url(), false /*don't lock history*/); + return Window::retrieve(p); + } + if ( uargs.frameName.lower() == "replace" ) + { + Window::retrieveWindow(p)->goURL(exec, url.url(), true /*lock history*/); + return Window::retrieve(p); + } + uargs.serviceType = "text/html"; + + // request window (new or existing if framename is set) + KParts::ReadOnlyPart *newPart = 0L; + emit p->browserExtension()->createNewWindow(KURL(), uargs,winargs,newPart); + if (newPart && ::tqqt_cast<KHTMLPart*>(newPart)) { + KHTMLPart *tdehtmlpart = static_cast<KHTMLPart*>(newPart); + //tqDebug("opener set to %p (this Window's part) in new Window %p (this Window=%p)",part,win,window); + tdehtmlpart->setOpener(p); + tdehtmlpart->setOpenedByJS(true); + if (tdehtmlpart->document().isNull()) { + tdehtmlpart->begin(); + tdehtmlpart->write("<HTML><BODY>"); + tdehtmlpart->end(); + if ( p->docImpl() ) { + //kdDebug(6070) << "Setting domain to " << p->docImpl()->domain().string() << endl; + tdehtmlpart->docImpl()->setDomain( p->docImpl()->domain()); + tdehtmlpart->docImpl()->setBaseURL( p->docImpl()->baseURL() ); + } + } + uargs.serviceType = TQString::null; + if (uargs.frameName.lower() == "_blank") + uargs.frameName = TQString::null; + if (!url.isEmpty()) + emit tdehtmlpart->browserExtension()->openURLRequest(url,uargs); + return Window::retrieve(tdehtmlpart); // global object + } else + return Undefined(); +} + +void Window::forgetSuppressedWindows() +{ + m_suppressedWindowInfo.clear(); +} + +void Window::showSuppressedWindows() +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>( m_frame->m_part ); + KJS::Interpreter *interpreter = part->jScript()->interpreter(); + ExecState *exec = interpreter->globalExec(); + + TQValueList<SuppressedWindowInfo> suppressedWindowInfo = m_suppressedWindowInfo; + m_suppressedWindowInfo.clear(); + TQValueList<SuppressedWindowInfo>::Iterator it = suppressedWindowInfo.begin(); + for ( ; it != suppressedWindowInfo.end() ; ++it ) { + executeOpenWindow(exec, (*it).url, (*it).frameName, (*it).features); + } +} + +Value WindowFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( Window, thisObj ); + + // these should work no matter whether the window is already + // closed or not + if (id == Window::ValueOf || id == Window::ToString) { + return String("[object Window]"); + } + + Window *window = static_cast<Window *>(thisObj.imp()); + TQString str, str2; + + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(window->m_frame->m_part); + if (!part) + return Undefined(); + + KHTMLView *widget = part->view(); + Value v = args[0]; + UString s; + if (v.isValid() && !v.isA(UndefinedType)) { + s = v.toString(exec); + str = s.qstring(); + } + + TQString caption; + if (part && !part->url().host().isEmpty()) + caption = part->url().host() + " - "; + caption += "JavaScript"; // TODO: i18n + // functions that work everywhere + switch(id) { + case Window::Alert: + if (!widget->dialogsAllowed()) + return Undefined(); + if ( part && part->xmlDocImpl() ) + part->xmlDocImpl()->updateRendering(); + if ( part ) + emit part->browserExtension()->requestFocus(part); + KMessageBox::error(widget, TQStyleSheet::convertFromPlainText(str, TQStyleSheetItem::WhiteSpaceNormal), caption); + return Undefined(); + case Window::Confirm: + if (!widget->dialogsAllowed()) + return Undefined(); + if ( part && part->xmlDocImpl() ) + part->xmlDocImpl()->updateRendering(); + if ( part ) + emit part->browserExtension()->requestFocus(part); + return Boolean((KMessageBox::warningYesNo(widget, TQStyleSheet::convertFromPlainText(str), caption, + KStdGuiItem::ok(), KStdGuiItem::cancel()) == KMessageBox::Yes)); + case Window::Prompt: +#ifndef KONQ_EMBEDDED + if (!widget->dialogsAllowed()) + return Undefined(); + if ( part && part->xmlDocImpl() ) + part->xmlDocImpl()->updateRendering(); + if ( part ) + emit part->browserExtension()->requestFocus(part); + bool ok; + if (args.size() >= 2) + str2 = KInputDialog::getText(caption, + TQStyleSheet::convertFromPlainText(str), + args[1].toString(exec).qstring(), &ok, widget); + else + str2 = KInputDialog::getText(caption, + TQStyleSheet::convertFromPlainText(str), + TQString::null, &ok, widget); + if ( ok ) + return String(str2); + else + return Null(); +#else + return Undefined(); +#endif + case Window::GetComputedStyle: { + if ( !part || !part->xmlDocImpl() ) + return Undefined(); + DOM::Node arg0 = toNode(args[0]); + if (arg0.nodeType() != DOM::Node::ELEMENT_NODE) + return Undefined(); // throw exception? + else + return getDOMCSSStyleDeclaration(exec, part->document().defaultView().getComputedStyle(static_cast<DOM::Element>(arg0), + args[1].toString(exec).string())); + } + case Window::Open: + return window->openWindow(exec, args); + case Window::Close: { + /* From http://developer.netscape.com/docs/manuals/js/client/jsref/window.htm : + The close method closes only windows opened by JavaScript using the open method. + If you attempt to close any other window, a confirm is generated, which + lets the user choose whether the window closes. + This is a security feature to prevent "mail bombs" containing self.close(). + However, if the window has only one document (the current one) in its + session history, the close is allowed without any confirm. This is a + special case for one-off windows that need to open other windows and + then dispose of themselves. + */ + bool doClose = false; + if (!part->openedByJS()) + { + // To conform to the SPEC, we only ask if the window + // has more than one entry in the history (NS does that too). + History history(exec,part); + + if ( history.get( exec, "length" ).toInt32(exec) <= 1 ) + { + doClose = true; + } + else + { + // Can we get this dialog with tabs??? Does it close the window or the tab in that case? + emit part->browserExtension()->requestFocus(part); + if ( KMessageBox::questionYesNo( window->part()->widget(), + i18n("Close window?"), i18n("Confirmation Required"), + KStdGuiItem::close(), KStdGuiItem::cancel() ) + == KMessageBox::Yes ) + doClose = true; + } + } + else + doClose = true; + + if (doClose) + { + // If this is the current window (the one the interpreter runs in), + // then schedule a delayed close (so that the script terminates first). + // But otherwise, close immediately. This fixes w=window.open("","name");w.close();window.open("name"); + if ( Window::retrieveActive(exec) == window ) { + if (widget) { + // quit all dialogs of this view + // this fixes 'setTimeout('self.close()',1000); alert("Hi");' crash + widget->closeChildDialogs(); + } + //kdDebug() << "scheduling delayed close" << endl; + // We'll close the window at the end of the script execution + Window* w = const_cast<Window*>(window); + w->m_delayed.append( Window::DelayedAction( Window::DelayedClose ) ); + } else { + //kdDebug() << "closing NOW" << endl; + (const_cast<Window*>(window))->closeNow(); + } + } + return Undefined(); + } + case Window::Navigate: + window->goURL(exec, args[0].toString(exec).qstring(), false /*don't lock history*/); + return Undefined(); + case Window::Focus: { + KHTMLSettings::KJSWindowFocusPolicy policy = + part->settings()->windowFocusPolicy(part->url().host()); + if(policy == KHTMLSettings::KJSWindowFocusAllow && widget) { + widget->topLevelWidget()->raise(); + KWin::deIconifyWindow( widget->topLevelWidget()->winId() ); + widget->setActiveWindow(); + emit part->browserExtension()->requestFocus(part); + } + return Undefined(); + } + case Window::Blur: + // TODO + return Undefined(); + case Window::BToA: + case Window::AToB: { + if (!s.is8Bit()) + return Undefined(); + TQByteArray in, out; + char *binData = s.ascii(); + in.setRawData( binData, s.size() ); + if (id == Window::AToB) + KCodecs::base64Decode( in, out ); + else + KCodecs::base64Encode( in, out ); + in.resetRawData( binData, s.size() ); + UChar *d = new UChar[out.size()]; + for (uint i = 0; i < out.size(); i++) + d[i].uc = (uchar) out[i]; + UString ret(d, out.size(), false /*no copy*/); + return String(ret); + } + + }; + + + // now unsafe functions.. + if (!window->isSafeScript(exec)) + return Undefined(); + + switch (id) { + case Window::ScrollBy: + if(args.size() == 2 && widget) + widget->scrollBy(args[0].toInt32(exec), args[1].toInt32(exec)); + return Undefined(); + case Window::Scroll: + case Window::ScrollTo: + if(args.size() == 2 && widget) + widget->setContentsPos(args[0].toInt32(exec), args[1].toInt32(exec)); + return Undefined(); + case Window::MoveBy: { + KHTMLSettings::KJSWindowMovePolicy policy = + part->settings()->windowMovePolicy(part->url().host()); + if(policy == KHTMLSettings::KJSWindowMoveAllow && args.size() == 2 && widget) + { + KParts::BrowserExtension *ext = part->browserExtension(); + if (ext) { + TQWidget * tl = widget->topLevelWidget(); + TQRect sg = TDEGlobalSettings::desktopGeometry(tl); + + TQPoint dest = tl->pos() + TQPoint( args[0].toInt32(exec), args[1].toInt32(exec) ); + // Security check (the spec talks about UniversalBrowserWrite to disable this check...) + if ( dest.x() >= sg.x() && dest.y() >= sg.x() && + dest.x()+tl->width() <= sg.width()+sg.x() && + dest.y()+tl->height() <= sg.height()+sg.y() ) + emit ext->moveTopLevelWidget( dest.x(), dest.y() ); + } + } + return Undefined(); + } + case Window::MoveTo: { + KHTMLSettings::KJSWindowMovePolicy policy = + part->settings()->windowMovePolicy(part->url().host()); + if(policy == KHTMLSettings::KJSWindowMoveAllow && args.size() == 2 && widget) + { + KParts::BrowserExtension *ext = part->browserExtension(); + if (ext) { + TQWidget * tl = widget->topLevelWidget(); + TQRect sg = TDEGlobalSettings::desktopGeometry(tl); + + TQPoint dest( args[0].toInt32(exec)+sg.x(), args[1].toInt32(exec)+sg.y() ); + // Security check (the spec talks about UniversalBrowserWrite to disable this check...) + if ( dest.x() >= sg.x() && dest.y() >= sg.y() && + dest.x()+tl->width() <= sg.width()+sg.x() && + dest.y()+tl->height() <= sg.height()+sg.y() ) + emit ext->moveTopLevelWidget( dest.x(), dest.y() ); + } + } + return Undefined(); + } + case Window::ResizeBy: { + KHTMLSettings::KJSWindowResizePolicy policy = + part->settings()->windowResizePolicy(part->url().host()); + if(policy == KHTMLSettings::KJSWindowResizeAllow + && args.size() == 2 && widget) + { + TQWidget * tl = widget->topLevelWidget(); + TQRect geom = tl->frameGeometry(); + window->resizeTo( tl, + geom.width() + args[0].toInt32(exec), + geom.height() + args[1].toInt32(exec) ); + } + return Undefined(); + } + case Window::ResizeTo: { + KHTMLSettings::KJSWindowResizePolicy policy = + part->settings()->windowResizePolicy(part->url().host()); + if(policy == KHTMLSettings::KJSWindowResizeAllow + && args.size() == 2 && widget) + { + TQWidget * tl = widget->topLevelWidget(); + window->resizeTo( tl, args[0].toInt32(exec), args[1].toInt32(exec) ); + } + return Undefined(); + } + case Window::SetTimeout: + case Window::SetInterval: { + bool singleShot; + int i; // timeout interval + if (args.size() == 0) + return Undefined(); + if (args.size() > 1) { + singleShot = (id == Window::SetTimeout); + i = args[1].toInt32(exec); + } else { + // second parameter is missing. Emulate Mozilla behavior. + singleShot = true; + i = 4; + } + if (v.isA(StringType)) { + int r = (const_cast<Window*>(window))->winq->installTimeout(Identifier(s), i, singleShot ); + return Number(r); + } + else if (v.isA(ObjectType) && Object::dynamicCast(v).implementsCall()) { + Object func = Object::dynamicCast(v); + List funcArgs; + ListIterator it = args.begin(); + int argno = 0; + while (it != args.end()) { + Value arg = it++; + if (argno++ >= 2) + funcArgs.append(arg); + } + if (args.size() < 2) + funcArgs.append(Number(i)); + int r = (const_cast<Window*>(window))->winq->installTimeout(func, funcArgs, i, singleShot ); + return Number(r); + } + else + return Undefined(); + } + case Window::ClearTimeout: + case Window::ClearInterval: + (const_cast<Window*>(window))->winq->clearTimeout(v.toInt32(exec)); + return Undefined(); + case Window::Print: + if ( widget ) { + // ### TODO emit onbeforeprint event + widget->print(); + // ### TODO emit onafterprint event + } + case Window::CaptureEvents: + case Window::ReleaseEvents: + // Do nothing for now. These are NS-specific legacy calls. + break; + case Window::AddEventListener: { + JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]); + if (listener) { + DOM::DocumentImpl* docimpl = static_cast<DOM::DocumentImpl *>(part->document().handle()); + docimpl->addWindowEventListener(DOM::EventImpl::typeToId(args[0].toString(exec).string()),listener,args[2].toBoolean(exec)); + } + return Undefined(); + } + case Window::RemoveEventListener: { + JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]); + if (listener) { + DOM::DocumentImpl* docimpl = static_cast<DOM::DocumentImpl *>(part->document().handle()); + docimpl->removeWindowEventListener(DOM::EventImpl::typeToId(args[0].toString(exec).string()),listener,args[2].toBoolean(exec)); + } + return Undefined(); + } + + } + return Undefined(); +} + +////////////////////// ScheduledAction //////////////////////// + +// KDE 4: Make those parameters const ... & +ScheduledAction::ScheduledAction(Object _func, List _args, DateTimeMS _nextTime, int _interval, bool _singleShot, + int _timerId) +{ + //kdDebug(6070) << "ScheduledAction::ScheduledAction(isFunction) " << this << endl; + func = static_cast<ObjectImp*>(_func.imp()); + args = _args; + isFunction = true; + singleShot = _singleShot; + nextTime = _nextTime; + interval = _interval; + executing = false; + timerId = _timerId; +} + +// KDE 4: Make it const TQString & +ScheduledAction::ScheduledAction(TQString _code, DateTimeMS _nextTime, int _interval, bool _singleShot, int _timerId) +{ + //kdDebug(6070) << "ScheduledAction::ScheduledAction(!isFunction) " << this << endl; + //func = 0; + //args = 0; + func = 0; + code = _code; + isFunction = false; + singleShot = _singleShot; + nextTime = _nextTime; + interval = _interval; + executing = false; + timerId = _timerId; +} + +bool ScheduledAction::execute(Window *window) +{ + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(window->m_frame->m_part); + if (!part || !part->jScriptEnabled()) + return false; + ScriptInterpreter *interpreter = static_cast<ScriptInterpreter *>(part->jScript()->interpreter()); + + interpreter->setProcessingTimerCallback(true); + + //kdDebug(6070) << "ScheduledAction::execute " << this << endl; + if (isFunction) { + if (func->implementsCall()) { + // #### check this + Q_ASSERT( part ); + if ( part ) + { + KJS::Interpreter *interpreter = part->jScript()->interpreter(); + ExecState *exec = interpreter->globalExec(); + Q_ASSERT( window == interpreter->globalObject().imp() ); + Object obj( window ); + func->call(exec,obj,args); // note that call() creates its own execution state for the func call + if (exec->hadException()) + exec->clearException(); + + // Update our document's rendering following the execution of the timeout callback. + part->document().updateRendering(); + } + } + } + else { + part->executeScript(DOM::Node(), code); + } + + interpreter->setProcessingTimerCallback(false); + return true; +} + +void ScheduledAction::mark() +{ + if (func && !func->marked()) + func->mark(); + args.mark(); +} + +ScheduledAction::~ScheduledAction() +{ + //kdDebug(6070) << "ScheduledAction::~ScheduledAction " << this << endl; +} + +////////////////////// WindowQObject //////////////////////// + +WindowQObject::WindowQObject(Window *w) + : parent(w) +{ + //kdDebug(6070) << "WindowQObject::WindowQObject " << this << endl; + if ( !parent->m_frame ) + kdDebug(6070) << "WARNING: null part in " << k_funcinfo << endl; + else + connect( parent->m_frame, TQT_SIGNAL( destroyed() ), + this, TQT_SLOT( parentDestroyed() ) ); + pausedTime = 0; + lastTimerId = 0; + currentlyDispatching = false; +} + +WindowQObject::~WindowQObject() +{ + //kdDebug(6070) << "WindowQObject::~WindowQObject " << this << endl; + parentDestroyed(); // reuse same code +} + +void WindowQObject::parentDestroyed() +{ + killTimers(); + + TQPtrListIterator<ScheduledAction> it(scheduledActions); + for (; it.current(); ++it) + delete it.current(); + scheduledActions.clear(); +} + +int WindowQObject::installTimeout(const Identifier &handler, int t, bool singleShot) +{ + int id = ++lastTimerId; + if (t < 10) t = 10; + DateTimeMS nextTime = DateTimeMS::now().addMSecs(-pausedTime + t); + + ScheduledAction *action = new ScheduledAction(handler.qstring(),nextTime,t,singleShot,id); + scheduledActions.append(action); + setNextTimer(); + return id; +} + +int WindowQObject::installTimeout(const Value &func, List args, int t, bool singleShot) +{ + Object objFunc = Object::dynamicCast( func ); + if (!objFunc.isValid()) + return 0; + int id = ++lastTimerId; + if (t < 10) t = 10; + + DateTimeMS nextTime = DateTimeMS::now().addMSecs(-pausedTime + t); + ScheduledAction *action = new ScheduledAction(objFunc,args,nextTime,t,singleShot,id); + scheduledActions.append(action); + setNextTimer(); + return id; +} + +void WindowQObject::clearTimeout(int timerId) +{ + TQPtrListIterator<ScheduledAction> it(scheduledActions); + for (; it.current(); ++it) { + ScheduledAction *action = it.current(); + if (action->timerId == timerId) { + scheduledActions.removeRef(action); + if (!action->executing) + delete action; + return; + } + } +} + +bool WindowQObject::hasTimers() const +{ + return scheduledActions.count(); +} + +void WindowQObject::mark() +{ + TQPtrListIterator<ScheduledAction> it(scheduledActions); + for (; it.current(); ++it) + it.current()->mark(); +} + +void WindowQObject::timerEvent(TQTimerEvent *) +{ + killTimers(); + + if (scheduledActions.isEmpty()) + return; + + currentlyDispatching = true; + + + DateTimeMS currentActual = DateTimeMS::now(); + DateTimeMS currentAdjusted = currentActual.addMSecs(-pausedTime); + + // Work out which actions are to be executed. We take a separate copy of + // this list since the main one may be modified during action execution + TQPtrList<ScheduledAction> toExecute; + TQPtrListIterator<ScheduledAction> it(scheduledActions); + for (; it.current(); ++it) + if (currentAdjusted >= it.current()->nextTime) + toExecute.append(it.current()); + + // ### verify that the window can't be closed (and action deleted) during execution + it = TQPtrListIterator<ScheduledAction>(toExecute); + for (; it.current(); ++it) { + ScheduledAction *action = it.current(); + if (!scheduledActions.containsRef(action)) // removed by clearTimeout() + continue; + + action->executing = true; // prevent deletion in clearTimeout() + + if (parent->part()) { + bool ok = action->execute(parent); + if ( !ok ) // e.g. JS disabled + scheduledActions.removeRef( action ); + } + + if (action->singleShot) { + scheduledActions.removeRef(action); + } + + action->executing = false; + + if (!scheduledActions.containsRef(action)) + delete action; + else + action->nextTime = action->nextTime.addMSecs(action->interval); + } + + pausedTime += currentActual.msecsTo(DateTimeMS::now()); + + currentlyDispatching = false; + + // Work out when next event is to occur + setNextTimer(); +} + +DateTimeMS DateTimeMS::addMSecs(int s) const +{ + DateTimeMS c = *this; + c.mTime = TQT_TQTIME_OBJECT(mTime.addMSecs(s)); + if (s > 0) + { + if (c.mTime < mTime) + c.mDate = TQT_TQDATE_OBJECT(mDate.addDays(1)); + } + else + { + if (c.mTime > mTime) + c.mDate = TQT_TQDATE_OBJECT(mDate.addDays(-1)); + } + return c; +} + +bool DateTimeMS::operator >(const DateTimeMS &other) const +{ + if (mDate > other.mDate) + return true; + + if (mDate < other.mDate) + return false; + + return mTime > other.mTime; +} + +bool DateTimeMS::operator >=(const DateTimeMS &other) const +{ + if (mDate > other.mDate) + return true; + + if (mDate < other.mDate) + return false; + + return mTime >= other.mTime; +} + +int DateTimeMS::msecsTo(const DateTimeMS &other) const +{ + int d = mDate.daysTo(other.mDate); + int ms = mTime.msecsTo(other.mTime); + return d*24*60*60*1000 + ms; +} + + +DateTimeMS DateTimeMS::now() +{ + DateTimeMS t; + TQTime before = TQTime::currentTime(); + t.mDate = TQDate::currentDate(); + t.mTime = TQTime::currentTime(); + if (t.mTime < before) + t.mDate = TQDate::currentDate(); // prevent race condition in hacky way :) + return t; +} + +void WindowQObject::setNextTimer() +{ + if (currentlyDispatching) + return; // Will schedule at the end + + if (scheduledActions.isEmpty()) + return; + + TQPtrListIterator<ScheduledAction> it(scheduledActions); + DateTimeMS nextTime = it.current()->nextTime; + for (++it; it.current(); ++it) + if (nextTime > it.current()->nextTime) + nextTime = it.current()->nextTime; + + DateTimeMS nextTimeActual = nextTime.addMSecs(pausedTime); + int nextInterval = DateTimeMS::now().msecsTo(nextTimeActual); + if (nextInterval < 0) + nextInterval = 0; + startTimer(nextInterval); +} + +void WindowQObject::timeoutClose() +{ + parent->closeNow(); +} + +Value FrameArray::get(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "FrameArray::get " << p.qstring() << " part=" << (void*)part << endl; +#endif + if (part.isNull()) + return Undefined(); + + TQPtrList<KParts::ReadOnlyPart> frames = part->frames(); + unsigned int len = frames.count(); + if (p == lengthPropertyName) + return Number(len); + else if (p== "location") // non-standard property, but works in NS and IE + { + Object obj = Object::dynamicCast( Window::retrieve( part ) ); + if ( obj.isValid() ) + return obj.get( exec, "location" ); + return Undefined(); + } + + // check for the name or number + KParts::ReadOnlyPart *frame = part->findFramePart(p.qstring()); + if (!frame) { + bool ok; + unsigned int i = p.toArrayIndex(&ok); + if (ok && i < len) + frame = frames.at(i); + } + + // we are potentially fetching a reference to a another Window object here. + // i.e. we may be accessing objects from another interpreter instance. + // Therefore we have to be a bit careful with memory management. + if (frame) { + return Window::retrieve(frame); + } + + // Fun IE quirk: name lookup in there is actually done by document.all + // hence, it can find non-frame things (and even let them hide frame ones!) + // We don't quite do that, but do this as a fallback. + DOM::DocumentImpl* doc = static_cast<DOM::DocumentImpl*>(part->document().handle()); + if (doc) { + DOM::HTMLCollectionImpl docuAll(doc, DOM::HTMLCollectionImpl::DOC_ALL); + DOM::NodeImpl* node = docuAll.namedItem(p.string()); + if (node) { + if (node->id() == ID_FRAME || node->id() == ID_IFRAME) { + //Return the Window object. + KHTMLPart* part = static_cast<DOM::HTMLFrameElementImpl*>(node)->contentPart(); + if (part) + return Value(Window::retrieveWindow(part)); + else + return Undefined(); + } else { + //Just a regular node.. + return getDOMNode(exec, node); + } + } + } else { + kdWarning(6070) << "Missing own document in FrameArray::get()" << endl; + } + + return ObjectImp::get(exec, p); +} + +Value FrameArray::call(ExecState *exec, Object &/*thisObj*/, const List &args) +{ + //IE supports a subset of the get functionality as call... + //... basically, when the return is a window, it supports that, otherwise it + //errors out. We do a cheap-and-easy emulation of that, and just do the same + //thing as get does. + if (args.size() == 1) + return get(exec, Identifier(args[0].toString(exec))); + + return Undefined(); +} + + +////////////////////// Location Object //////////////////////// + +const ClassInfo Location::info = { "Location", 0, &LocationTable, 0 }; +/* +@begin LocationTable 11 + hash Location::Hash DontDelete + host Location::Host DontDelete + hostname Location::Hostname DontDelete + href Location::Href DontDelete + pathname Location::Pathname DontDelete + port Location::Port DontDelete + protocol Location::Protocol DontDelete + search Location::Search DontDelete + [[==]] Location::EqualEqual DontDelete|ReadOnly + assign Location::Assign DontDelete|Function 1 + toString Location::ToString DontDelete|Function 0 + replace Location::Replace DontDelete|Function 1 + reload Location::Reload DontDelete|Function 0 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(LocationFunc) +Location::Location(tdehtml::ChildFrame *f) : m_frame(f) +{ + //kdDebug(6070) << "Location::Location " << this << " m_part=" << (void*)m_part << endl; +} + +Location::~Location() +{ + //kdDebug(6070) << "Location::~Location " << this << " m_part=" << (void*)m_part << endl; +} + +KParts::ReadOnlyPart *Location::part() const { + return m_frame ? static_cast<KParts::ReadOnlyPart *>(m_frame->m_part) : 0L; +} + +Value Location::get(ExecState *exec, const Identifier &p) const +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Location::get " << p.qstring() << " m_part=" << (void*)m_frame->m_part << endl; +#endif + + if (m_frame.isNull() || m_frame->m_part.isNull()) + return Undefined(); + + const HashEntry *entry = Lookup::findEntry(&LocationTable, p); + + // properties that work on all Location objects + if ( entry && entry->value == Replace ) + return lookupOrCreateFunction<LocationFunc>(exec,p,this,entry->value,entry->params,entry->attr); + + // XSS check + const Window* window = Window::retrieveWindow( m_frame->m_part ); + if ( !window || !window->isSafeScript(exec) ) + return Undefined(); + + KURL url = m_frame->m_part->url(); + if (entry) + switch (entry->value) { + case Hash: + return String( url.ref().isNull() ? TQString("") : "#" + url.ref() ); + case Host: { + UString str = url.host(); + if (url.port()) + str += ":" + TQString::number((int)url.port()); + return String(str); + // Note: this is the IE spec. The NS spec swaps the two, it says + // "The hostname property is the concatenation of the host and port properties, separated by a colon." + // Bleh. + } + case Hostname: + return String( url.host() ); + case Href: + if (url.isEmpty()) + return String("about:blank"); + else if (!url.hasPath()) + return String( url.prettyURL()+"/" ); + else + return String( url.prettyURL() ); + case Pathname: + if (url.isEmpty()) + return String(""); + return String( url.path().isEmpty() ? TQString("/") : url.path() ); + case Port: + return String( url.port() ? TQString::number((int)url.port()) : TQString::fromLatin1("") ); + case Protocol: + return String( url.protocol()+":" ); + case Search: + return String( url.query() ); + case EqualEqual: // [[==]] + return String(toString(exec)); + case ToString: + return lookupOrCreateFunction<LocationFunc>(exec,p,this,entry->value,entry->params,entry->attr); + } + // Look for overrides + ValueImp * val = ObjectImp::getDirect(p); + if (val) + return Value(val); + if (entry && (entry->attr & Function)) + return lookupOrCreateFunction<LocationFunc>(exec,p,this,entry->value,entry->params,entry->attr); + + return Undefined(); +} + +void Location::put(ExecState *exec, const Identifier &p, const Value &v, int attr) +{ +#ifdef KJS_VERBOSE + kdDebug(6070) << "Location::put " << p.qstring() << " m_part=" << (void*)m_frame->m_part << endl; +#endif + if (m_frame.isNull() || m_frame->m_part.isNull()) + return; + + const Window* window = Window::retrieveWindow( m_frame->m_part ); + if ( !window ) + return; + + KURL url = m_frame->m_part->url(); + + const HashEntry *entry = Lookup::findEntry(&LocationTable, p); + + if (entry) { + + // XSS check. Only new hrefs can be set from other sites + if (entry->value != Href && !window->isSafeScript(exec)) + return; + + TQString str = v.toString(exec).qstring(); + switch (entry->value) { + case Href: { + KHTMLPart* p =::tqqt_cast<KHTMLPart*>(Window::retrieveActive(exec)->part()); + if ( p ) + url = p->htmlDocument().completeURL( str ).string(); + else + url = str; + break; + } + case Hash: + // when the hash is already the same ignore it + if (str == url.ref()) return; + url.setRef(str); + break; + case Host: { + TQString host = str.left(str.find(":")); + TQString port = str.mid(str.find(":")+1); + url.setHost(host); + url.setPort(port.toUInt()); + break; + } + case Hostname: + url.setHost(str); + break; + case Pathname: + url.setPath(str); + break; + case Port: + url.setPort(str.toUInt()); + break; + case Protocol: + url.setProtocol(str); + break; + case Search: + url.setQuery(str); + break; + } + } else { + ObjectImp::put(exec, p, v, attr); + return; + } + + Window::retrieveWindow(m_frame->m_part)->goURL(exec, url.url(), false /* don't lock history*/ ); +} + +Value Location::toPrimitive(ExecState *exec, Type) const +{ + if (m_frame) { + Window* window = Window::retrieveWindow( m_frame->m_part ); + if ( window && window->isSafeScript(exec) ) + return String(toString(exec)); + } + return Undefined(); +} + +UString Location::toString(ExecState *exec) const +{ + if (m_frame) { + Window* window = Window::retrieveWindow( m_frame->m_part ); + if ( window && window->isSafeScript(exec) ) + { + KURL url = m_frame->m_part->url(); + if (url.isEmpty()) + return "about:blank"; + else if (!url.hasPath()) + return url.prettyURL()+"/"; + else + return url.prettyURL(); + } + } + return ""; +} + +Value LocationFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( Location, thisObj ); + Location *location = static_cast<Location *>(thisObj.imp()); + KParts::ReadOnlyPart *part = location->part(); + + if (!part) return Undefined(); + + Window* window = Window::retrieveWindow(part); + + if ( !window->isSafeScript(exec) && id != Location::Replace) + return Undefined(); + + switch (id) { + case Location::Assign: + case Location::Replace: + Window::retrieveWindow(part)->goURL(exec, args[0].toString(exec).qstring(), + id == Location::Replace); + break; + case Location::Reload: { + KHTMLPart *tdehtmlpart = ::tqqt_cast<KHTMLPart *>(part); + if (tdehtmlpart) + tdehtmlpart->scheduleRedirection(-1, part->url().url(), true/*lock history*/); + else + part->openURL(part->url()); + break; + } + case Location::ToString: + return String(location->toString(exec)); + } + return Undefined(); +} + +////////////////////// External Object //////////////////////// + +const ClassInfo External::info = { "External", 0, 0, 0 }; +/* +@begin ExternalTable 4 + addFavorite External::AddFavorite DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(ExternalFunc) + +Value External::get(ExecState *exec, const Identifier &p) const +{ + return lookupGetFunction<ExternalFunc,ObjectImp>(exec,p,&ExternalTable,this); +} + +Value ExternalFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( External, thisObj ); + External *external = static_cast<External *>(thisObj.imp()); + + KHTMLPart *part = external->part; + if (!part) + return Undefined(); + + KHTMLView *widget = part->view(); + + switch (id) { + case External::AddFavorite: + { +#ifndef KONQ_EMBEDDED + if (!widget->dialogsAllowed()) + return Undefined(); + part->xmlDocImpl()->updateRendering(); + if (args.size() != 1 && args.size() != 2) + return Undefined(); + + TQString url = args[0].toString(exec).qstring(); + TQString title; + if (args.size() == 2) + title = args[1].toString(exec).qstring(); + + // AK - don't do anything yet, for the moment i + // just wanted the base js handling code in cvs + return Undefined(); + + TQString question; + if ( title.isEmpty() ) + question = i18n("Do you want a bookmark pointing to the location \"%1\" to be added to your collection?") + .arg(url); + else + question = i18n("Do you want a bookmark pointing to the location \"%1\" titled \"%2\" to be added to your collection?") + .arg(url).arg(title); + + emit part->browserExtension()->requestFocus(part); + + TQString caption; + if (!part->url().host().isEmpty()) + caption = part->url().host() + " - "; + caption += i18n("JavaScript Attempted Bookmark Insert"); + + if (KMessageBox::warningYesNo( + widget, question, caption, + i18n("Insert"), i18n("Disallow")) == KMessageBox::Yes) + { + KBookmarkManager *mgr = KBookmarkManager::userBookmarksManager(); + mgr->addBookmarkDialog(url,title); + } +#else + return Undefined(); +#endif + break; + } + default: + return Undefined(); + } + + return Undefined(); +} + +////////////////////// History Object //////////////////////// + +const ClassInfo History::info = { "History", 0, 0, 0 }; +/* +@begin HistoryTable 4 + length History::Length DontDelete|ReadOnly + back History::Back DontDelete|Function 0 + forward History::Forward DontDelete|Function 0 + go History::Go DontDelete|Function 1 +@end +*/ +IMPLEMENT_PROTOFUNC_DOM(HistoryFunc) + +Value History::get(ExecState *exec, const Identifier &p) const +{ + return lookupGet<HistoryFunc,History,ObjectImp>(exec,p,&HistoryTable,this); +} + +Value History::getValueProperty(ExecState *, int token) const +{ + // if previous or next is implemented, make sure its not a major + // privacy leak (see i.e. http://security.greymagic.com/adv/gm005-op/) + switch (token) { + case Length: + { + if ( !part ) + return Number( 0 ); + + KParts::BrowserExtension *ext = part->browserExtension(); + if ( !ext ) + return Number( 0 ); + + KParts::BrowserInterface *iface = ext->browserInterface(); + if ( !iface ) + return Number( 0 ); + + TQVariant length = iface->property( "historyLength" ); + + if ( length.type() != TQVariant::UInt ) + return Number( 0 ); + + return Number( length.toUInt() ); + } + default: + kdDebug(6070) << "WARNING: Unhandled token in History::getValueProperty : " << token << endl; + return Undefined(); + } +} + +Value HistoryFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + KJS_CHECK_THIS( History, thisObj ); + History *history = static_cast<History *>(thisObj.imp()); + + Value v = args[0]; + Number n; + if(v.isValid()) + n = v.toInteger(exec); + + int steps; + switch (id) { + case History::Back: + steps = -1; + break; + case History::Forward: + steps = 1; + break; + case History::Go: + steps = n.intValue(); + break; + default: + return Undefined(); + } + + // Special case for go(0) from a frame -> reload only the frame + // go(i!=0) from a frame navigates into the history of the frame only, + // in both IE and NS (but not in Mozilla).... we can't easily do that + // in Konqueror... + if (!steps) // add && history->part->parentPart() to get only frames, but doesn't matter + { + history->part->openURL( history->part->url() ); /// ## need args.reload=true? + } else + { + // Delay it. + // Testcase: history.back(); alert("hello"); + Window* window = Window::retrieveWindow( history->part ); + window->delayedGoHistory( steps ); + } + return Undefined(); +} + +///////////////////////////////////////////////////////////////////////////// + +#ifdef Q_WS_QWS + +const ClassInfo Konqueror::info = { "Konqueror", 0, 0, 0 }; + +bool Konqueror::hasProperty(ExecState *exec, const Identifier &p) const +{ + if ( p.qstring().startsWith( "goHistory" ) ) return false; + + return true; +} + +Value Konqueror::get(ExecState *exec, const Identifier &p) const +{ + if ( p == "goHistory" || part->url().protocol() != "http" || part->url().host() != "localhost" ) + return Undefined(); + + KParts::BrowserExtension *ext = part->browserExtension(); + if ( ext ) { + KParts::BrowserInterface *iface = ext->browserInterface(); + if ( iface ) { + TQVariant prop = iface->property( p.qstring().latin1() ); + + if ( prop.isValid() ) { + switch( prop.type() ) { + case TQVariant::Int: + return Number( prop.toInt() ); + case TQVariant::String: + return String( prop.toString() ); + default: + break; + } + } + } + } + + return Value( new KonquerorFunc(exec, this, p.qstring().latin1() ) ); +} + +Value KonquerorFunc::tryCall(ExecState *exec, Object &, const List &args) +{ + KParts::BrowserExtension *ext = konqueror->part->browserExtension(); + + if (!ext) + return Undefined(); + + KParts::BrowserInterface *iface = ext->browserInterface(); + + if ( !iface ) + return Undefined(); + + TQCString n = m_name.data(); + n += "()"; + iface->callMethod( n.data(), TQVariant() ); + + return Undefined(); +} + +UString Konqueror::toString(ExecState *) const +{ + return UString("[object Konqueror]"); +} + +#endif +///////////////////////////////////////////////////////////////////////////// +} //namespace KJS + +#include "kjs_window.moc" diff --git a/tdehtml/ecma/kjs_window.h b/tdehtml/ecma/kjs_window.h new file mode 100644 index 000000000..b9142f983 --- /dev/null +++ b/tdehtml/ecma/kjs_window.h @@ -0,0 +1,309 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * 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 + */ + +#ifndef _KJS_WINDOW_H_ +#define _KJS_WINDOW_H_ + +#include <tqobject.h> +#include <tqguardedptr.h> +#include <tqmap.h> +#include <tqptrlist.h> +#include <tqdatetime.h> + +#include "kjs_binding.h" +#include "kjs_views.h" + +class TQTimer; +class KHTMLView; +class KHTMLPart; + +namespace KParts { + class ReadOnlyPart; +} + +namespace tdehtml { + class ChildFrame; +} + +namespace KJS { + + class WindowFunc; + class WindowQObject; + class Location; + class History; + class External; + class FrameArray; + class JSEventListener; + class JSLazyEventListener; + + class Screen : public ObjectImp { + public: + Screen(ExecState *exec); + enum { + Height, Width, ColorDepth, PixelDepth, AvailLeft, AvailTop, AvailHeight, + AvailWidth + }; + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + private: + KHTMLView *view; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + }; + + class KDE_EXPORT Window : public ObjectImp { + friend TQGuardedPtr<KHTMLPart> getInstance(); + friend class Location; + friend class WindowFunc; + friend class WindowQObject; + friend class ScheduledAction; + public: + Window(tdehtml::ChildFrame *p); + public: + ~Window(); + /** + * Returns and registers a window object. In case there's already a Window + * for the specified part p this will be returned in order to have unique + * bindings. + */ + static Value retrieve(KParts::ReadOnlyPart *p); + /** + * Returns the Window object for a given part + */ + static Window *retrieveWindow(KParts::ReadOnlyPart *p); + /** + * returns a pointer to the Window object this javascript interpreting instance + * was called from. + */ + static Window *retrieveActive(ExecState *exec); + KParts::ReadOnlyPart *part() const; + virtual void mark(); + virtual bool hasProperty(ExecState *exec, const Identifier &p) const; + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual void put(ExecState *exec, const Identifier &propertyName, const Value &value, int attr = None); + virtual bool toBoolean(ExecState *exec) const; + virtual DOM::AbstractView toAbstractView() const; + void scheduleClose(); + void closeNow(); + void delayedGoHistory(int steps); + void goHistory(int steps); + void goURL(ExecState* exec, const TQString& url, bool lockHistory); + Value openWindow(ExecState *exec, const List &args); + Value executeOpenWindow(ExecState *exec, const KURL& url, const TQString& frameName, const TQString& features); + void resizeTo(TQWidget* tl, int width, int height); + void afterScriptExecution(); + bool isSafeScript(ExecState *exec) const { + KParts::ReadOnlyPart *activePart = static_cast<KJS::ScriptInterpreter *>( exec->interpreter() )->part(); + if ( activePart == part() ) return true; + return checkIsSafeScript( activePart ); + } + Location *location() const; + ObjectImp* frames( ExecState* exec ) const; + JSEventListener *getJSEventListener(const Value &val, bool html = false); + JSLazyEventListener *getJSLazyEventListener(const TQString &code, const TQString &name, DOM::NodeImpl* node); + void clear( ExecState *exec ); + virtual UString toString(ExecState *exec) const; + + // Set the current "event" object + void setCurrentEvent( DOM::Event *evt ); + + TQPtrDict<JSEventListener> jsEventListeners; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Closed, Crypto, DefaultStatus, Status, Document, Node, EventCtor, Range, + NodeFilter, DOMException, CSSRule, Frames, _History, _External, Event, InnerHeight, + InnerWidth, Length, _Location, Navigate, Name, _Navigator, _Konqueror, ClientInformation, + OffscreenBuffering, Opener, OuterHeight, OuterWidth, PageXOffset, PageYOffset, + Parent, Personalbar, ScreenX, ScreenY, Scrollbars, Scroll, ScrollBy, + ScreenTop, ScreenLeft, AToB, BToA, FrameElement, GetComputedStyle, + ScrollTo, ScrollX, ScrollY, MoveBy, MoveTo, ResizeBy, ResizeTo, Self, _Window, Top, _Screen, + Image, Option, Alert, Confirm, Prompt, Open, SetTimeout, ClearTimeout, + XMLHttpRequest, XMLSerializer, DOMParser, + Focus, Blur, Close, SetInterval, ClearInterval, CaptureEvents, ReleaseEvents, + Print, AddEventListener, RemoveEventListener, SideBar, + ValueOf, ToString, + Onabort, Onblur, + Onchange, Onclick, Ondblclick, Ondragdrop, Onerror, Onfocus, + Onkeydown, Onkeypress, Onkeyup, Onload, Onmousedown, Onmousemove, + Onmouseout, Onmouseover, Onmouseup, Onmove, Onreset, Onresize, + Onselect, Onsubmit, Onunload, + MutationEventCtor, KeyboardEventCtor, EventExceptionCtor, + ElementCtor, DocumentCtor, HTMLDocumentCtor, + HTMLElementCtor, HTMLHtmlElementCtor, HTMLHeadElementCtor, HTMLLinkElementCtor, + HTMLTitleElementCtor, HTMLMetaElementCtor, HTMLBaseElementCtor, HTMLIsIndexElementCtor, + HTMLStyleElementCtor, HTMLBodyElementCtor, HTMLFormElementCtor, HTMLSelectElementCtor, + HTMLOptGroupElementCtor, HTMLOptionElementCtor, HTMLInputElementCtor, HTMLTextAreaElementCtor, + HTMLButtonElementCtor, HTMLLabelElementCtor, HTMLFieldSetElementCtor, HTMLLegendElementCtor, + HTMLUListElementCtor, HTMLOListElementCtor, HTMLDListElementCtor, HTMLDirectoryElementCtor, + HTMLMenuElementCtor, HTMLLIElementCtor, HTMLDivElementCtor, HTMLParagraphElementCtor, + HTMLHeadingElementCtor, HTMLBlockQuoteElementCtor, HTMLQuoteElementCtor, HTMLPreElementCtor, + HTMLBRElementCtor, HTMLBaseFontElementCtor, HTMLFontElementCtor, HTMLHRElementCtor, HTMLModElementCtor, + HTMLAnchorElementCtor, HTMLImageElementCtor, HTMLObjectElementCtor, HTMLParamElementCtor, + HTMLAppletElementCtor, HTMLMapElementCtor, HTMLAreaElementCtor, HTMLScriptElementCtor, + HTMLTableElementCtor, HTMLTableCaptionElementCtor, HTMLTableColElementCtor, + HTMLTableSectionElementCtor, HTMLTableRowElementCtor, HTMLTableCellElementCtor, + HTMLFrameSetElementCtor, HTMLLayerElementCtor, HTMLFrameElementCtor, HTMLIFrameElementCtor, + CSSStyleDeclarationCtor}; + WindowQObject *winq; + + void forgetSuppressedWindows(); + void showSuppressedWindows(); + + protected: + enum DelayedActionId { NullAction, DelayedClose, DelayedGoHistory }; + + Value getListener(ExecState *exec, int eventId) const; + void setListener(ExecState *exec, int eventId, Value func); + private: + struct DelayedAction; + friend struct DelayedAction; + + bool checkIsSafeScript( KParts::ReadOnlyPart* activePart ) const; + + TQGuardedPtr<tdehtml::ChildFrame> m_frame; + Screen *screen; + History *history; + External *external; + FrameArray *m_frames; + Location *loc; + DOM::Event *m_evt; + + struct DelayedAction { + DelayedAction() : actionId(NullAction) {} // for QValueList + DelayedAction( DelayedActionId id, TQVariant p = TQVariant() ) : actionId(id), param(p) {} + DelayedActionId actionId; + TQVariant param; // just in case + }; + TQValueList<DelayedAction> m_delayed; + + struct SuppressedWindowInfo { + SuppressedWindowInfo() {} // for QValueList + SuppressedWindowInfo( KURL u, TQString fr, TQString fe ) : url(u), frameName(fr), features(fe) {} + KURL url; + TQString frameName; + TQString features; + }; + TQValueList<SuppressedWindowInfo> m_suppressedWindowInfo; + }; + + /** + * like TQDateTime, but properly handles milliseconds + */ + class DateTimeMS + { + TQDate mDate; + TQTime mTime; + public: + DateTimeMS addMSecs(int s) const; + bool operator >(const DateTimeMS &other) const; + bool operator >=(const DateTimeMS &other) const; + + int msecsTo(const DateTimeMS &other) const; + + static DateTimeMS now(); + }; + + /** + * An action (either function or string) to be executed after a specified + * time interval, either once or repeatedly. Used for window.setTimeout() + * and window.setInterval() + */ + class ScheduledAction { + public: + ScheduledAction(Object _func, List _args, DateTimeMS _nextTime, int _interval, bool _singleShot, int _timerId); + ScheduledAction(TQString _code, DateTimeMS _nextTime, int _interval, bool _singleShot, int _timerId); + ~ScheduledAction(); + bool execute(Window *window); + void mark(); + + ObjectImp *func; + List args; + TQString code; + bool isFunction; + bool singleShot; + + DateTimeMS nextTime; + int interval; + bool executing; + int timerId; + }; + + class KDE_EXPORT WindowQObject : public TQObject { + Q_OBJECT + public: + WindowQObject(Window *w); + ~WindowQObject(); + int installTimeout(const Identifier &handler, int t, bool singleShot); + int installTimeout(const Value &func, List args, int t, bool singleShot); + void clearTimeout(int timerId); + void mark(); + bool hasTimers() const; + public slots: + void timeoutClose(); + protected slots: + void parentDestroyed(); + protected: + void timerEvent(TQTimerEvent *e); + void setNextTimer(); + private: + Window *parent; + TQPtrList<ScheduledAction> scheduledActions; + int pausedTime; + int lastTimerId; + bool currentlyDispatching; + }; + + class Location : public ObjectImp { + public: + ~Location(); + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual void put(ExecState *exec, const Identifier &propertyName, const Value &value, int attr = None); + virtual Value toPrimitive(ExecState *exec, Type preferred) const; + virtual UString toString(ExecState *exec) const; + enum { Hash, Href, Hostname, Host, Pathname, Port, Protocol, Search, EqualEqual, + Assign, Replace, Reload, ToString }; + KParts::ReadOnlyPart *part() const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + private: + friend class Window; + Location(tdehtml::ChildFrame *f); + TQGuardedPtr<tdehtml::ChildFrame> m_frame; + }; + +#ifdef Q_WS_QWS + class Konqueror : public ObjectImp { + friend class KonquerorFunc; + public: + Konqueror(KHTMLPart *p) : part(p) { } + virtual Value get(ExecState *exec, const Identifier &propertyName) const; + virtual bool hasProperty(ExecState *exec, const Identifier &p) const; + virtual UString toString(ExecState *exec) const; + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + private: + KHTMLPart *part; + }; +#endif + +} // namespace + +#endif diff --git a/tdehtml/ecma/testecma.cpp b/tdehtml/ecma/testecma.cpp new file mode 100644 index 000000000..44cd7ecb0 --- /dev/null +++ b/tdehtml/ecma/testecma.cpp @@ -0,0 +1,67 @@ +/* + * This file is part of the KDE libraries + * Copyright (C) 2000 Harri Porten (porten@kde.org) + * + * 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 + */ + +/** + * An interactive interpreter to test the ECMA Script language bindings + * for the DOM of KHTML. + * The 'document' property is preset to an instance of Document and serves + * as an entrypoint. + * + * Example session: + * + * KJS> text = document.createTextNode('foo'); + * KJS> document.appendChild(text); + * KJS> debug(document.firstChild.nodeValue); + * ---> foo + */ + +#include <stdio.h> +#include <kjs/object.h> +#include <kjs/interpreter.h> +#include "dom/dom_doc.h" +#include "dom/dom_string.h" +#include "ecma/kjs_dom.h" + + +using namespace KJS; + +int main(int, char **) +{ + KJScript kjs; + kjs.enableDebug(); + DOM::Document doc; + + DOMDocument *dd = new DOMDocument(&doc); + Global::current().put("document", KJSO(dd)); + + printf("Entering interactive mode.\n" + "You may access the DOM via the 'document' property.\n" + "Use debug() to print to the console. Press C-d or C-c to exit.\n\n"); + + char buffer[1000]; + FILE *in = fdopen(0, "r"); + + while (1) { + printf("KJS> "); + if (!fgets(buffer, 999, in)) + break; + kjs.evaluate(buffer); + } + printf("\n"); +} diff --git a/tdehtml/ecma/xmlhttprequest.cpp b/tdehtml/ecma/xmlhttprequest.cpp new file mode 100644 index 000000000..f3aec5492 --- /dev/null +++ b/tdehtml/ecma/xmlhttprequest.cpp @@ -0,0 +1,810 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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 Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 "xmlhttprequest.h" +#include "xmlhttprequest.lut.h" +#include "kjs_window.h" +#include "kjs_events.h" + +#include "dom/dom_doc.h" +#include "dom/dom_exception.h" +#include "dom/dom_string.h" +#include "misc/loader.h" +#include "html/html_documentimpl.h" +#include "xml/dom2_eventsimpl.h" + +#include "tdehtml_part.h" +#include "tdehtmlview.h" + +#include <kio/scheduler.h> +#include <kio/job.h> +#include <tqobject.h> +#include <kdebug.h> + +#ifdef APPLE_CHANGES +#include "KWQLoader.h" +#else +#include <kio/netaccess.h> +using TDEIO::NetAccess; +#endif + +#define BANNED_HTTP_HEADERS "authorization,proxy-authorization,"\ + "content-length,host,connect,copy,move,"\ + "delete,head,trace,put,propfind,proppatch,"\ + "mkcol,lock,unlock,options,via,"\ + "accept-charset,accept-encoding,expect,date,"\ + "keep-alive,te,trailer,"\ + "transfer-encoding,upgrade" + +using tdehtml::Decoder; + +namespace KJS { + +////////////////////// XMLHttpRequest Object //////////////////////// + +/* Source for XMLHttpRequestProtoTable. +@begin XMLHttpRequestProtoTable 7 + abort XMLHttpRequest::Abort DontDelete|Function 0 + getAllResponseHeaders XMLHttpRequest::GetAllResponseHeaders DontDelete|Function 0 + getResponseHeader XMLHttpRequest::GetResponseHeader DontDelete|Function 1 + open XMLHttpRequest::Open DontDelete|Function 5 + overrideMimeType XMLHttpRequest::OverrideMIMEType DontDelete|Function 1 + send XMLHttpRequest::Send DontDelete|Function 1 + setRequestHeader XMLHttpRequest::SetRequestHeader DontDelete|Function 2 +@end +*/ +KJS_DEFINE_PROTOTYPE(XMLHttpRequestProto) +IMPLEMENT_PROTOFUNC_DOM(XMLHttpRequestProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("XMLHttpRequest", XMLHttpRequestProto,XMLHttpRequestProtoFunc) + + +XMLHttpRequestQObject::XMLHttpRequestQObject(XMLHttpRequest *_jsObject) +{ + jsObject = _jsObject; +} + +#ifdef APPLE_CHANGES +void XMLHttpRequestQObject::slotData( TDEIO::Job* job, const char *data, int size ) +{ + jsObject->slotData(job, data, size); +} +#else +void XMLHttpRequestQObject::slotData( TDEIO::Job* job, const TQByteArray &data ) +{ + jsObject->slotData(job, data); +} +#endif + +void XMLHttpRequestQObject::slotFinished( TDEIO::Job* job ) +{ + jsObject->slotFinished(job); +} + +void XMLHttpRequestQObject::slotRedirection( TDEIO::Job* job, const KURL& url) +{ + jsObject->slotRedirection( job, url ); +} + +XMLHttpRequestConstructorImp::XMLHttpRequestConstructorImp(ExecState *, const DOM::Document &d) + : ObjectImp(), doc(d) +{ +} + +bool XMLHttpRequestConstructorImp::implementsConstruct() const +{ + return true; +} + +Object XMLHttpRequestConstructorImp::construct(ExecState *exec, const List &) +{ + return Object(new XMLHttpRequest(exec, doc)); +} + +const ClassInfo XMLHttpRequest::info = { "XMLHttpRequest", 0, &XMLHttpRequestTable, 0 }; + + +/* Source for XMLHttpRequestTable. +@begin XMLHttpRequestTable 7 + readyState XMLHttpRequest::ReadyState DontDelete|ReadOnly + responseText XMLHttpRequest::ResponseText DontDelete|ReadOnly + responseXML XMLHttpRequest::ResponseXML DontDelete|ReadOnly + status XMLHttpRequest::Status DontDelete|ReadOnly + statusText XMLHttpRequest::StatusText DontDelete|ReadOnly + onreadystatechange XMLHttpRequest::Onreadystatechange DontDelete + onload XMLHttpRequest::Onload DontDelete +@end +*/ + +Value XMLHttpRequest::tryGet(ExecState *exec, const Identifier &propertyName) const +{ + return DOMObjectLookupGetValue<XMLHttpRequest,DOMObject>(exec, propertyName, &XMLHttpRequestTable, this); +} + +Value XMLHttpRequest::getValueProperty(ExecState *exec, int token) const +{ + switch (token) { + case ReadyState: + return Number(state); + case ResponseText: + return getString(DOM::DOMString(response)); + case ResponseXML: + if (state != Completed) { + return Null(); + } + if (!createdDocument) { + TQString mimeType = "text/xml"; + + if (!m_mimeTypeOverride.isEmpty()) { + mimeType = m_mimeTypeOverride; + } else { + Value header = getResponseHeader("Content-Type"); + if (header.type() != UndefinedType) { + mimeType = TQStringList::split(";", header.toString(exec).qstring())[0].stripWhiteSpace(); + } + } + + if (mimeType == "text/xml" || mimeType == "application/xml" || mimeType == "application/xhtml+xml") { + responseXML = DOM::Document(doc->implementation()->createDocument()); + + DOM::DocumentImpl *docImpl = static_cast<DOM::DocumentImpl *>(responseXML.handle()); + + docImpl->open(); + docImpl->write(response); + docImpl->finishParsing(); + docImpl->close(); + + typeIsXML = true; + } else { + typeIsXML = false; + } + createdDocument = true; + } + + if (!typeIsXML) { + return Undefined(); + } + + return getDOMNode(exec,responseXML); + case Status: + return getStatus(); + case StatusText: + return getStatusText(); + case Onreadystatechange: + if (onReadyStateChangeListener && onReadyStateChangeListener->listenerObjImp()) { + return onReadyStateChangeListener->listenerObj(); + } else { + return Null(); + } + case Onload: + if (onLoadListener && onLoadListener->listenerObjImp()) { + return onLoadListener->listenerObj(); + } else { + return Null(); + } + default: + kdWarning() << "XMLHttpRequest::getValueProperty unhandled token " << token << endl; + return Value(); + } +} + +void XMLHttpRequest::tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr) +{ + DOMObjectLookupPut<XMLHttpRequest,DOMObject>(exec, propertyName, value, attr, &XMLHttpRequestTable, this ); +} + +void XMLHttpRequest::putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/) +{ + JSEventListener* newListener; + switch(token) { + case Onreadystatechange: + newListener = Window::retrieveActive(exec)->getJSEventListener(value, true); + if (newListener != onReadyStateChangeListener) { + if (onReadyStateChangeListener) onReadyStateChangeListener->deref(); + onReadyStateChangeListener = newListener; + if (onReadyStateChangeListener) onReadyStateChangeListener->ref(); + } + break; + case Onload: + newListener = Window::retrieveActive(exec)->getJSEventListener(value, true); + if (newListener != onLoadListener) { + if (onLoadListener) onLoadListener->deref(); + onLoadListener = newListener; + if (onLoadListener) onLoadListener->ref(); + } + break; + default: + kdWarning() << "XMLHttpRequest::putValue unhandled token " << token << endl; + } +} + +XMLHttpRequest::XMLHttpRequest(ExecState *exec, const DOM::Document &d) + : DOMObject(XMLHttpRequestProto::self(exec)), + qObject(new XMLHttpRequestQObject(this)), + doc(static_cast<DOM::DocumentImpl*>(d.handle())), + async(true), + contentType(TQString::null), + job(0), + state(Uninitialized), + onReadyStateChangeListener(0), + onLoadListener(0), + decoder(0), + createdDocument(false), + aborted(false) +{ +} + +XMLHttpRequest::~XMLHttpRequest() +{ + if (onReadyStateChangeListener) + onReadyStateChangeListener->deref(); + if (onLoadListener) + onLoadListener->deref(); + delete qObject; + qObject = 0; + delete decoder; + decoder = 0; +} + +void XMLHttpRequest::changeState(XMLHttpRequestState newState) +{ + if (state != newState) { + state = newState; + + ref(); + + if (onReadyStateChangeListener != 0 && doc->view() && doc->view()->part()) { + DOM::Event ev = doc->view()->part()->document().createEvent("HTMLEvents"); + ev.initEvent("readystatechange", true, true); + onReadyStateChangeListener->handleEvent(ev); + } + + if (state == Completed && onLoadListener != 0 && doc->view() && doc->view()->part()) { + DOM::Event ev = doc->view()->part()->document().createEvent("HTMLEvents"); + ev.initEvent("load", true, true); + onLoadListener->handleEvent(ev); + } + + deref(); + } +} + +bool XMLHttpRequest::urlMatchesDocumentDomain(const KURL& _url) const +{ + // No need to do work if _url is not valid... + if (!_url.isValid()) + return false; + + KURL documentURL(doc->URL()); + + // a local file can load anything + if (documentURL.protocol().lower() == "file") { + return true; + } + + // but a remote document can only load from the same port on the server + if (documentURL.protocol().lower() == _url.protocol().lower() && + documentURL.host().lower() == _url.host().lower() && + documentURL.port() == _url.port()) { + return true; + } + + return false; +} + +void XMLHttpRequest::open(const TQString& _method, const KURL& _url, bool _async) +{ + abort(); + aborted = false; + + // clear stuff from possible previous load + requestHeaders.clear(); + responseHeaders = TQString(); + response = TQString(); + createdDocument = false; + responseXML = DOM::Document(); + + changeState(Uninitialized); + + if (aborted) { + return; + } + + if (!urlMatchesDocumentDomain(_url)) { + return; + } + + + method = _method.lower(); + url = _url; + async = _async; + + changeState(Loading); +} + +void XMLHttpRequest::send(const TQString& _body) +{ + aborted = false; + + const TQString protocol = url.protocol().lower(); + // Abandon the request when the protocol is other than "http", + // instead of blindly doing a TDEIO::get on other protocols like file:/. + if (!protocol.startsWith("http") && !protocol.startsWith("webdav")) + { + abort(); + return; + } + + if (method == "post") { + + // FIXME: determine post encoding correctly by looking in headers + // for charset. + TQByteArray buf; + TQCString str = _body.utf8(); + buf.duplicate(str.data(), str.size() - 1); + + job = TDEIO::http_post( url, buf, false ); + if(contentType.isNull()) + job->addMetaData( "content-type", "Content-type: text/plain" ); + else + job->addMetaData( "content-type", contentType ); + } + else { + job = TDEIO::get( url, false, false ); + } + + if (!requestHeaders.isEmpty()) { + TQString rh; + TQMap<TQString, TQString>::ConstIterator begin = requestHeaders.begin(); + TQMap<TQString, TQString>::ConstIterator end = requestHeaders.end(); + for (TQMap<TQString, TQString>::ConstIterator i = begin; i != end; ++i) { + TQString key = i.key(); + TQString value = i.data(); + if (key == "accept") { + // The HTTP KIO slave supports an override this way + job->addMetaData("accept", value); + } else { + if (i != begin) + rh += "\r\n"; + rh += key + ": " + value; + } + } + + job->addMetaData("customHTTPHeader", rh); + } + + job->addMetaData("PropagateHttpHeader", "true"); + + // Set the default referrer if one is not already supplied + // through setRequestHeader. NOTE: the user can still disable + // this feature at the protocol level (kio_http). + // ### does find() ever succeed? the headers are stored in lower case! + if (requestHeaders.find("Referer") == requestHeaders.end()) { + KURL documentURL(doc->URL()); + documentURL.setPass(TQString::null); + documentURL.setUser(TQString::null); + job->addMetaData("referrer", documentURL.url()); + // kdDebug() << "Adding referrer: " << documentURL << endl; + } + + if (!async) { + TQByteArray data; + KURL finalURL; + TQString headers; + +#ifdef APPLE_CHANGES + data = KWQServeSynchronousRequest(tdehtml::Cache::loader(), doc->docLoader(), job, finalURL, headers); +#else + TQMap<TQString, TQString> metaData; + if ( NetAccess::synchronousRun( job, 0, &data, &finalURL, &metaData ) ) { + headers = metaData[ "HTTP-Headers" ]; + } +#endif + job = 0; + processSyncLoadResults(data, finalURL, headers); + return; + } + + qObject->connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), + TQT_SLOT( slotFinished( TDEIO::Job* ) ) ); +#ifdef APPLE_CHANGES + qObject->connect( job, TQT_SIGNAL( data( TDEIO::Job*, const char*, int ) ), + TQT_SLOT( slotData( TDEIO::Job*, const char*, int ) ) ); +#else + qObject->connect( job, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ), + TQT_SLOT( slotData( TDEIO::Job*, const TQByteArray& ) ) ); +#endif + qObject->connect( job, TQT_SIGNAL(redirection(TDEIO::Job*, const KURL& ) ), + TQT_SLOT( slotRedirection(TDEIO::Job*, const KURL&) ) ); + +#ifdef APPLE_CHANGES + KWQServeRequest(tdehtml::Cache::loader(), doc->docLoader(), job); +#else + TDEIO::Scheduler::scheduleJob( job ); +#endif +} + +void XMLHttpRequest::abort() +{ + if (job) { + job->kill(); + job = 0; + } + delete decoder; + decoder = 0; + aborted = true; +} + +void XMLHttpRequest::overrideMIMEType(const TQString& override) +{ + m_mimeTypeOverride = override; +} + +void XMLHttpRequest::setRequestHeader(const TQString& _name, const TQString &value) +{ + TQString name = _name.lower().stripWhiteSpace(); + + // Content-type needs to be set seperately from the other headers + if(name == "content-type") { + contentType = "Content-type: " + value; + return; + } + + // Sanitize the referrer header to protect against spoofing... + if(name == "referer") { + KURL referrerURL(value); + if (urlMatchesDocumentDomain(referrerURL)) + requestHeaders[name] = referrerURL.url(); + return; + } + + // Sanitize the request headers below and handle them as if they are + // calls to open. Otherwise, we will end up ignoring them all together! + // TODO: Do something about "put" which kio_http sort of supports and + // the webDAV headers such as PROPFIND etc... + if (name == "get" || name == "post") { + KURL reqURL (doc->URL(), value.stripWhiteSpace()); + open(name, reqURL, async); + return; + } + + // Reject all banned headers. See BANNED_HTTP_HEADERS above. + // kdDebug() << "Banned HTTP Headers: " << BANNED_HTTP_HEADERS << endl; + TQStringList bannedHeaders = TQStringList::split(',', + TQString::fromLatin1(BANNED_HTTP_HEADERS)); + + if (bannedHeaders.contains(name)) + return; // Denied + + requestHeaders[name] = value.stripWhiteSpace(); +} + +Value XMLHttpRequest::getAllResponseHeaders() const +{ + if (responseHeaders.isEmpty()) { + return Undefined(); + } + + int endOfLine = responseHeaders.find("\n"); + + if (endOfLine == -1) { + return Undefined(); + } + + return String(responseHeaders.mid(endOfLine + 1) + "\n"); +} + +Value XMLHttpRequest::getResponseHeader(const TQString& name) const +{ + if (responseHeaders.isEmpty()) { + return Undefined(); + } + + TQRegExp headerLinePattern(name + ":", false); + + int matchLength; + int headerLinePos = headerLinePattern.search(responseHeaders, 0); + matchLength = headerLinePattern.matchedLength(); + while (headerLinePos != -1) { + if (headerLinePos == 0 || responseHeaders[headerLinePos-1] == '\n') { + break; + } + + headerLinePos = headerLinePattern.search(responseHeaders, headerLinePos + 1); + matchLength = headerLinePattern.matchedLength(); + } + + + if (headerLinePos == -1) { + return Undefined(); + } + + int endOfLine = responseHeaders.find("\n", headerLinePos + matchLength); + + return String(responseHeaders.mid(headerLinePos + matchLength, endOfLine - (headerLinePos + matchLength)).stripWhiteSpace()); +} + +static Value httpStatus(const TQString& response, bool textStatus = false) +{ + if (response.isEmpty()) { + return Undefined(); + } + + int endOfLine = response.find("\n"); + TQString firstLine = (endOfLine == -1) ? response : response.left(endOfLine); + int codeStart = firstLine.find(" "); + int codeEnd = firstLine.find(" ", codeStart + 1); + + if (codeStart == -1 || codeEnd == -1) { + return Undefined(); + } + + if (textStatus) { + TQString statusText = firstLine.mid(codeEnd + 1, endOfLine - (codeEnd + 1)).stripWhiteSpace(); + return String(statusText); + } + + TQString number = firstLine.mid(codeStart + 1, codeEnd - (codeStart + 1)); + + bool ok = false; + int code = number.toInt(&ok); + if (!ok) { + return Undefined(); + } + + return Number(code); +} + +Value XMLHttpRequest::getStatus() const +{ + return httpStatus(responseHeaders); +} + +Value XMLHttpRequest::getStatusText() const +{ + return httpStatus(responseHeaders, true); +} + +void XMLHttpRequest::processSyncLoadResults(const TQByteArray &data, const KURL &finalURL, const TQString &headers) +{ + if (!urlMatchesDocumentDomain(finalURL)) { + abort(); + return; + } + + responseHeaders = headers; + changeState(Loaded); + if (aborted) { + return; + } + +#ifdef APPLE_CHANGES + const char *bytes = (const char *)data.data(); + int len = (int)data.size(); + + slotData(0, bytes, len); +#else + slotData(0, data); +#endif + + if (aborted) { + return; + } + + slotFinished(0); +} + +void XMLHttpRequest::slotFinished(TDEIO::Job *) +{ + if (decoder) { + response += decoder->flush(); + } + + // make sure to forget about the job before emitting completed, + // since changeState triggers JS code, which might e.g. call abort. + job = 0; + changeState(Completed); + + delete decoder; + decoder = 0; +} + +void XMLHttpRequest::slotRedirection(TDEIO::Job*, const KURL& url) +{ + if (!urlMatchesDocumentDomain(url)) { + abort(); + } +} + +#ifdef APPLE_CHANGES +void XMLHttpRequest::slotData( TDEIO::Job*, const char *data, int len ) +#else +void XMLHttpRequest::slotData(TDEIO::Job*, const TQByteArray &_data) +#endif +{ + if (state < Loaded ) { + responseHeaders = job->queryMetaData("HTTP-Headers"); + + // NOTE: Replace a 304 response with a 200! Both IE and Mozilla do this. + // Problem first reported through bug# 110272. + int codeStart = responseHeaders.find("304"); + if ( codeStart != -1) { + int codeEnd = responseHeaders.find("\n", codeStart+3); + if (codeEnd != -1) + responseHeaders.replace(codeStart, (codeEnd-codeStart), "200 OK"); + } + + changeState(Loaded); + } + +#ifndef APPLE_CHANGES + const char *data = (const char *)_data.data(); + int len = (int)_data.size(); +#endif + + if ( decoder == NULL ) { + int pos = responseHeaders.find("content-type:", 0, false); + + if ( pos > -1 ) { + pos += 13; + int index = responseHeaders.find('\n', pos); + TQString type = responseHeaders.mid(pos, (index-pos)); + index = type.find (';'); + if (index > -1) + encoding = TQString(type.mid( index+1 ).remove(TQRegExp("charset[ ]*=[ ]*", false))).stripWhiteSpace(); + } + + decoder = new Decoder; + if (!encoding.isNull()) + decoder->setEncoding(encoding.latin1(), Decoder::EncodingFromHTTPHeader); + else { + // Per section 2 of W3C working draft spec, fall back to "UTF-8". + decoder->setEncoding("UTF-8", Decoder::DefaultEncoding); + } + } + if (len == 0) + return; + + if (len == -1) + len = strlen(data); + + TQString decoded = decoder->decode(data, len); + + response += decoded; + + if (!aborted) { + changeState(Interactive); + } +} + +Value XMLHttpRequestProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + if (!thisObj.inherits(&XMLHttpRequest::info)) { + Object err = Error::create(exec,TypeError); + exec->setException(err); + return err; + } + + XMLHttpRequest *request = static_cast<XMLHttpRequest *>(thisObj.imp()); + switch (id) { + case XMLHttpRequest::Abort: + request->abort(); + return Undefined(); + case XMLHttpRequest::GetAllResponseHeaders: + if (args.size() != 0) { + return Undefined(); + } + + return request->getAllResponseHeaders(); + case XMLHttpRequest::GetResponseHeader: + if (args.size() != 1) { + return Undefined(); + } + + return request->getResponseHeader(args[0].toString(exec).qstring()); + case XMLHttpRequest::Open: + { + if (args.size() < 2 || args.size() > 5) { + return Undefined(); + } + + TQString method = args[0].toString(exec).qstring(); + KHTMLPart *part = ::tqqt_cast<KHTMLPart *>(Window::retrieveActive(exec)->part()); + if (!part) + return Undefined(); + KURL url = KURL(part->document().completeURL(args[1].toString(exec).qstring()).string()); + + bool async = true; + if (args.size() >= 3) { + async = args[2].toBoolean(exec); + } + + if (args.size() >= 4) { + url.setUser(args[3].toString(exec).qstring()); + } + + if (args.size() >= 5) { + url.setPass(args[4].toString(exec).qstring()); + } + + request->open(method, url, async); + + return Undefined(); + } + case XMLHttpRequest::Send: + { + if (args.size() > 1) { + return Undefined(); + } + + if (request->state != Loading) { + return Undefined(); + } + + TQString body; + if (args.size() >= 1) { + Object obj = Object::dynamicCast(args[0]); + if (obj.isValid() && obj.inherits(&DOMDocument::info)) { + DOM::Node docNode = static_cast<KJS::DOMDocument *>(obj.imp())->toNode(); + DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl *>(docNode.handle()); + + try { + body = doc->toString().string(); + // FIXME: also need to set content type, including encoding! + + } catch(DOM::DOMException& e) { + Object err = Error::create(exec, GeneralError, "Exception serializing document"); + exec->setException(err); + } + } else { + body = args[0].toString(exec).qstring(); + } + } + + request->send(body); + + return Undefined(); + } + case XMLHttpRequest::SetRequestHeader: + if (args.size() != 2) { + return Undefined(); + } + + request->setRequestHeader(args[0].toString(exec).qstring(), args[1].toString(exec).qstring()); + + return Undefined(); + + case XMLHttpRequest::OverrideMIMEType: + if (args.size() < 1) { + Object err = Error::create(exec, SyntaxError, "Not enough arguments"); + exec->setException(err); + return err; + } + + request->overrideMIMEType(args[0].toString(exec).qstring()); + return Undefined(); + } + + return Undefined(); +} + +} // end namespace + + +#include "xmlhttprequest.moc" diff --git a/tdehtml/ecma/xmlhttprequest.h b/tdehtml/ecma/xmlhttprequest.h new file mode 100644 index 000000000..2dc89e227 --- /dev/null +++ b/tdehtml/ecma/xmlhttprequest.h @@ -0,0 +1,142 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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 Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 + */ + +#ifndef _XMLHTTPREQUEST_H_ +#define _XMLHTTPREQUEST_H_ + +#include "ecma/kjs_binding.h" +#include "ecma/kjs_dom.h" +#include "misc/decoder.h" +#include "kio/jobclasses.h" + +namespace KJS { + + class JSEventListener; + class XMLHttpRequestQObject; + + // these exact numeric values are important because JS expects them + enum XMLHttpRequestState { + Uninitialized = 0, + Loading = 1, + Loaded = 2, + Interactive = 3, + Completed = 4 + }; + + class XMLHttpRequestConstructorImp : public ObjectImp { + public: + XMLHttpRequestConstructorImp(ExecState *exec, const DOM::Document &d); + virtual bool implementsConstruct() const; + virtual Object construct(ExecState *exec, const List &args); + private: + DOM::Document doc; + }; + + class XMLHttpRequest : public DOMObject { + public: + XMLHttpRequest(ExecState *, const DOM::Document &d); + ~XMLHttpRequest(); + virtual Value tryGet(ExecState *exec, const Identifier &propertyName) const; + Value getValueProperty(ExecState *exec, int token) const; + virtual void tryPut(ExecState *exec, const Identifier &propertyName, const Value& value, int attr = None); + void putValueProperty(ExecState *exec, int token, const Value& value, int /*attr*/); + virtual bool toBoolean(ExecState *) const { return true; } + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { Onload, Onreadystatechange, ReadyState, ResponseText, ResponseXML, Status, StatusText, Abort, + GetAllResponseHeaders, GetResponseHeader, Open, Send, SetRequestHeader, + OverrideMIMEType }; + + private: + friend class XMLHttpRequestProtoFunc; + friend class XMLHttpRequestQObject; + + Value getStatusText() const; + Value getStatus() const; + bool urlMatchesDocumentDomain(const KURL&) const; + + XMLHttpRequestQObject *qObject; + +#ifdef APPLE_CHANGES + void slotData( TDEIO::Job* job, const char *data, int size ); +#else + void slotData( TDEIO::Job* job, const TQByteArray &data ); +#endif + void slotFinished( TDEIO::Job* ); + void slotRedirection( TDEIO::Job*, const KURL& ); + + void processSyncLoadResults(const TQByteArray &data, const KURL &finalURL, const TQString &headers); + + void open(const TQString& _method, const KURL& _url, bool _async); + void send(const TQString& _body); + void abort(); + void setRequestHeader(const TQString& name, const TQString &value); + void overrideMIMEType(const TQString& override); + Value getAllResponseHeaders() const; + Value getResponseHeader(const TQString& name) const; + + void changeState(XMLHttpRequestState newState); + + TQGuardedPtr<DOM::DocumentImpl> doc; + + KURL url; + TQString method; + bool async; + TQMap<TQString,TQString> requestHeaders; + TQString m_mimeTypeOverride; + TQString contentType; + + TDEIO::TransferJob * job; + + XMLHttpRequestState state; + JSEventListener *onReadyStateChangeListener; + JSEventListener *onLoadListener; + + tdehtml::Decoder *decoder; + TQString encoding; + TQString responseHeaders; + + TQString response; + mutable bool createdDocument; + mutable bool typeIsXML; + mutable DOM::Document responseXML; + + bool aborted; + }; + + + class XMLHttpRequestQObject : public TQObject { + Q_OBJECT + + public: + XMLHttpRequestQObject(XMLHttpRequest *_jsObject); + + public slots: + void slotData( TDEIO::Job* job, const TQByteArray &data ); + void slotFinished( TDEIO::Job* job ); + void slotRedirection( TDEIO::Job* job, const KURL& url); + + private: + XMLHttpRequest *jsObject; + }; + +} // namespace + +#endif diff --git a/tdehtml/ecma/xmlserializer.cpp b/tdehtml/ecma/xmlserializer.cpp new file mode 100644 index 000000000..856f35e1f --- /dev/null +++ b/tdehtml/ecma/xmlserializer.cpp @@ -0,0 +1,109 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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 Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 "xmlserializer.h" +#include "xmlserializer.lut.h" + +#include "dom/dom_exception.h" +#include "dom/dom_doc.h" +#include "xml/dom_docimpl.h" + +#include <kdebug.h> + + +////////////////////// XMLSerializer Object //////////////////////// + +/* Source for XMLSerializerProtoTable. +@begin XMLSerializerProtoTable 1 + serializeToString XMLSerializer::SerializeToString DontDelete|Function 1 +@end +*/ + +namespace KJS { + +KJS_DEFINE_PROTOTYPE(XMLSerializerProto) +IMPLEMENT_PROTOFUNC_DOM(XMLSerializerProtoFunc) +KJS_IMPLEMENT_PROTOTYPE("XMLSerializer", XMLSerializerProto, XMLSerializerProtoFunc) + +XMLSerializerConstructorImp::XMLSerializerConstructorImp(ExecState *) + : ObjectImp() +{ +} + +bool XMLSerializerConstructorImp::implementsConstruct() const +{ + return true; +} + +Object XMLSerializerConstructorImp::construct(ExecState *exec, const List &) +{ + return Object(new XMLSerializer(exec)); +} + +const ClassInfo XMLSerializer::info = { "XMLSerializer", 0, 0, 0 }; + +XMLSerializer::XMLSerializer(ExecState *exec) + : DOMObject(XMLSerializerProto::self(exec)) +{ +} + +Value XMLSerializerProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args) +{ + if (!thisObj.inherits(&XMLSerializer::info)) { + Object err = Error::create(exec,TypeError); + exec->setException(err); + return err; + } + + switch (id) { + case XMLSerializer::SerializeToString: + { + if (args.size() != 1) { + return Undefined(); + } + + if (!args[0].toObject(exec).inherits(&DOMNode::info)) { + return Undefined(); + } + + DOM::NodeImpl *node = static_cast<DOM::NodeImpl *>(static_cast<KJS::DOMNode *>(args[0].toObject(exec).imp())->toNode().handle()); + + if (!node) { + return Undefined(); + } + + TQString body; + + try { + body = node->toString().string(); + } catch(DOM::DOMException& e) { + Object err = Error::create(exec, GeneralError, "Exception serializing document"); + exec->setException(err); + return err; + } + + return getString(body); + } + } + + return Undefined(); +} + +} // end namespace diff --git a/tdehtml/ecma/xmlserializer.h b/tdehtml/ecma/xmlserializer.h new file mode 100644 index 000000000..629d09afe --- /dev/null +++ b/tdehtml/ecma/xmlserializer.h @@ -0,0 +1,54 @@ +// -*- c-basic-offset: 2 -*- +/* + * This file is part of the KDE libraries + * 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 Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 + */ + +#ifndef _XMLSERIALIZER_H_ +#define _XMLSERIALIZER_H_ + +#include "ecma/kjs_binding.h" +#include "ecma/kjs_dom.h" +#include "misc/decoder.h" +#include "kio/jobclasses.h" + +namespace KJS { + + class JSEventListener; + + class XMLSerializerConstructorImp : public ObjectImp { + public: + XMLSerializerConstructorImp(ExecState *); + virtual bool implementsConstruct() const; + virtual Object construct(ExecState *exec, const List &args); + }; + + class XMLSerializer : public DOMObject { + public: + XMLSerializer(ExecState *); + virtual bool toBoolean(ExecState *) const { return true; } + virtual const ClassInfo* classInfo() const { return &info; } + static const ClassInfo info; + enum { SerializeToString }; + + private: + friend class XMLSerializerProtoFunc; + }; + +} // namespace + +#endif |