00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "config.h"
00023
00024 #include <qstylesheet.h>
00025 #include <qtimer.h>
00026 #include <qpaintdevicemetrics.h>
00027 #include <qapplication.h>
00028 #include <kdebug.h>
00029 #include <kmessagebox.h>
00030 #include <kinputdialog.h>
00031 #include <klocale.h>
00032 #include <kparts/browserinterface.h>
00033 #include <kwin.h>
00034
00035 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00036 #include <kwinmodule.h>
00037 #endif
00038
00039 #include <kbookmarkmanager.h>
00040 #include <kglobalsettings.h>
00041 #include <assert.h>
00042 #include <qstyle.h>
00043 #include <qobjectlist.h>
00044 #include <kstringhandler.h>
00045
00046 #include "kjs_proxy.h"
00047 #include "kjs_window.h"
00048 #include "kjs_navigator.h"
00049 #include "kjs_mozilla.h"
00050 #include "kjs_html.h"
00051 #include "kjs_range.h"
00052 #include "kjs_traversal.h"
00053 #include "kjs_css.h"
00054 #include "kjs_events.h"
00055 #include "xmlhttprequest.h"
00056 #include "xmlserializer.h"
00057
00058 #include "khtmlview.h"
00059 #include "khtml_part.h"
00060 #include "khtml_settings.h"
00061 #include "xml/dom2_eventsimpl.h"
00062 #include "xml/dom_docimpl.h"
00063 #include "misc/htmltags.h"
00064 #include "html/html_documentimpl.h"
00065
00066 using namespace KJS;
00067
00068 namespace KJS {
00069
00070 class History : public ObjectImp {
00071 friend class HistoryFunc;
00072 public:
00073 History(ExecState *exec, KHTMLPart *p)
00074 : ObjectImp(exec->interpreter()->builtinObjectPrototype()), part(p) { }
00075 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00076 Value getValueProperty(ExecState *exec, int token) const;
00077 virtual const ClassInfo* classInfo() const { return &info; }
00078 static const ClassInfo info;
00079 enum { Back, Forward, Go, Length };
00080 private:
00081 QGuardedPtr<KHTMLPart> part;
00082 };
00083
00084 class External : public ObjectImp {
00085 friend class ExternalFunc;
00086 public:
00087 External(ExecState *exec, KHTMLPart *p)
00088 : ObjectImp(exec->interpreter()->builtinObjectPrototype()), part(p) { }
00089 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00090 virtual const ClassInfo* classInfo() const { return &info; }
00091 static const ClassInfo info;
00092 enum { AddFavorite };
00093 private:
00094 QGuardedPtr<KHTMLPart> part;
00095 };
00096
00097 class FrameArray : public ObjectImp {
00098 public:
00099 FrameArray(ExecState *exec, KHTMLPart *p)
00100 : ObjectImp(exec->interpreter()->builtinObjectPrototype()), part(p) { }
00101 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00102 private:
00103 QGuardedPtr<KHTMLPart> part;
00104 };
00105
00106 #ifdef Q_WS_QWS
00107 class KonquerorFunc : public DOMFunction {
00108 public:
00109 KonquerorFunc(const Konqueror* k, const char* name)
00110 : DOMFunction(), konqueror(k), m_name(name) { }
00111 virtual Value tryCall(ExecState *exec, Object &thisObj, const List &args);
00112
00113 private:
00114 const Konqueror* konqueror;
00115 QCString m_name;
00116 };
00117 #endif
00118 }
00119
00120 #include "kjs_window.lut.h"
00121 #include "rendering/render_replaced.h"
00122
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139 const ClassInfo Screen::info = { "Screen", 0, &ScreenTable, 0 };
00140
00141
00142 Screen::Screen(ExecState *exec)
00143 : ObjectImp(exec->interpreter()->builtinObjectPrototype()) {}
00144
00145 Value Screen::get(ExecState *exec, const Identifier &p) const
00146 {
00147 #ifdef KJS_VERBOSE
00148 kdDebug(6070) << "Screen::get " << p.qstring() << endl;
00149 #endif
00150 return lookupGetValue<Screen,ObjectImp>(exec,p,&ScreenTable,this);
00151 }
00152
00153 Value Screen::getValueProperty(ExecState *exec, int token) const
00154 {
00155 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00156 KWinModule info(0, KWinModule::INFO_DESKTOP);
00157 #endif
00158 QWidget *thisWidget = Window::retrieveActive(exec)->part()->view();
00159 QRect sg = KGlobalSettings::desktopGeometry(thisWidget);
00160
00161 switch( token ) {
00162 case Height:
00163 return Number(sg.height());
00164 case Width:
00165 return Number(sg.width());
00166 case ColorDepth:
00167 case PixelDepth: {
00168 QPaintDeviceMetrics m(QApplication::desktop());
00169 return Number(m.depth());
00170 }
00171 case AvailLeft: {
00172 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00173 QRect clipped = info.workArea().intersect(sg);
00174 return Number(clipped.x()-sg.x());
00175 #else
00176 return Number(10);
00177 #endif
00178 }
00179 case AvailTop: {
00180 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00181 QRect clipped = info.workArea().intersect(sg);
00182 return Number(clipped.y()-sg.y());
00183 #else
00184 return Number(10);
00185 #endif
00186 }
00187 case AvailHeight: {
00188 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00189 QRect clipped = info.workArea().intersect(sg);
00190 return Number(clipped.height());
00191 #else
00192 return Number(100);
00193 #endif
00194 }
00195 case AvailWidth: {
00196 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00197 QRect clipped = info.workArea().intersect(sg);
00198 return Number(clipped.width());
00199 #else
00200 return Number(100);
00201 #endif
00202 }
00203 default:
00204 kdDebug(6070) << "WARNING: Screen::getValueProperty unhandled token " << token << endl;
00205 return Undefined();
00206 }
00207 }
00208
00210
00211 const ClassInfo Window::info = { "Window", 0, &WindowTable, 0 };
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317 IMPLEMENT_PROTOFUNC_DOM(WindowFunc)
00318
00319 Window::Window(KHTMLPart *p)
00320 : ObjectImp(), m_part(p), screen(0), history(0), external(0), m_frames(0), loc(0), m_evt(0)
00321 {
00322 winq = new WindowQObject(this);
00323
00324 }
00325
00326 Window::~Window()
00327 {
00328 delete winq;
00329 }
00330
00331 Window *Window::retrieveWindow(KHTMLPart *p)
00332 {
00333 Object obj = Object::dynamicCast( retrieve( p ) );
00334 #ifndef NDEBUG
00335
00336 if ( p && p->jScriptEnabled() )
00337 {
00338 assert( !obj.isNull() );
00339 #ifndef QWS
00340 assert( dynamic_cast<KJS::Window*>(obj.imp()) );
00341 #endif
00342 }
00343 #endif
00344 if ( obj.isNull() )
00345 return 0;
00346 return static_cast<KJS::Window*>(obj.imp());
00347 }
00348
00349 Window *Window::retrieveActive(ExecState *exec)
00350 {
00351 ValueImp *imp = exec->interpreter()->globalObject().imp();
00352 assert( imp );
00353 #ifndef QWS
00354 assert( dynamic_cast<KJS::Window*>(imp) );
00355 #endif
00356 return static_cast<KJS::Window*>(imp);
00357 }
00358
00359 Value Window::retrieve(KHTMLPart *p)
00360 {
00361 assert(p);
00362 KJSProxy *proxy = p->jScript();
00363 if (proxy) {
00364 #ifdef KJS_VERBOSE
00365 kdDebug(6070) << "Window::retrieve part=" << p << " '" << p->name() << "' interpreter=" << proxy->interpreter() << " window=" << proxy->interpreter()->globalObject().imp() << endl;
00366 #endif
00367 return proxy->interpreter()->globalObject();
00368 } else {
00369 #ifdef KJS_VERBOSE
00370 kdDebug(6070) << "Window::retrieve part=" << p << " '" << p->name() << "' no jsproxy." << endl;
00371 #endif
00372 return Undefined();
00373 }
00374 }
00375
00376 Location *Window::location() const
00377 {
00378 if (!loc)
00379 const_cast<Window*>(this)->loc = new Location(m_part);
00380 return loc;
00381 }
00382
00383 ObjectImp* Window::frames( ExecState* exec ) const
00384 {
00385 return m_frames ? m_frames :
00386 (const_cast<Window*>(this)->m_frames = new FrameArray(exec,m_part));
00387 }
00388
00389
00390 void Window::mark()
00391 {
00392 ObjectImp::mark();
00393 if (screen && !screen->marked())
00394 screen->mark();
00395 if (history && !history->marked())
00396 history->mark();
00397 if (external && !external->marked())
00398 external->mark();
00399 if (m_frames && !m_frames->marked())
00400 m_frames->mark();
00401
00402 if (loc && !loc->marked())
00403 loc->mark();
00404 if (winq)
00405 winq->mark();
00406 }
00407
00408 bool Window::hasProperty(ExecState *exec, const Identifier &p) const
00409 {
00410
00411 if (m_part.isNull())
00412 return ( p == "closed" );
00413
00414 if (ObjectImp::hasProperty(exec, p))
00415 return true;
00416
00417 if (Lookup::findEntry(&WindowTable, p))
00418 return true;
00419
00420 QString q = p.qstring();
00421 if (m_part->findFrame(p.qstring()))
00422 return true;
00423
00424 bool ok;
00425 unsigned int i = p.toArrayIndex(&ok);
00426 if (ok) {
00427 QPtrList<KParts::ReadOnlyPart> frames = m_part->frames();
00428 unsigned int len = frames.count();
00429 if (i < len)
00430 return true;
00431 }
00432
00433
00434 if (m_part->document().isHTMLDocument()) {
00435 DOM::HTMLDocument doc = m_part->htmlDocument();
00436
00437 NamedTagLengthDeterminer::TagLength tags[3] = {
00438 {ID_IMG, 0, 0L}, {ID_FORM, 0, 0L}, {ID_APPLET, 0, 0L}
00439 };
00440 NamedTagLengthDeterminer(p.string(), tags, 3)(doc.handle());
00441 for (int i = 0; i < 3; i++)
00442 if (tags[i].length > 0)
00443 return true;
00444
00445 return !doc.getElementById(p.string()).isNull();
00446 }
00447
00448 return false;
00449 }
00450
00451 UString Window::toString(ExecState *) const
00452 {
00453 return "[object Window]";
00454 }
00455
00456 Value Window::get(ExecState *exec, const Identifier &p) const
00457 {
00458 #ifdef KJS_VERBOSE
00459 kdDebug(6070) << "Window("<<this<<")::get " << p.qstring() << endl;
00460 #endif
00461
00462 if (m_part.isNull()) {
00463 if ( p == "closed" )
00464 return Boolean( true );
00465 return Undefined();
00466 }
00467
00468
00469 Value val = ObjectImp::get(exec, p);
00470 if (!val.isA(UndefinedType)) {
00471
00472 return isSafeScript(exec) ? val : Undefined();
00473 }
00474
00475 const HashEntry* entry = Lookup::findEntry(&WindowTable, p);
00476
00477
00478 if (entry) {
00479 switch(entry->value) {
00480 case Closed:
00481 return Boolean( false );
00482 case _Location:
00483
00484 return Value(location());
00485 case Frames:
00486 return Value(frames(exec));
00487 case Opener:
00488 if (!m_part->opener())
00489 return Null();
00490 else
00491 return retrieve(m_part->opener());
00492 case Parent:
00493 return retrieve(m_part->parentPart() ? m_part->parentPart() : (KHTMLPart*)m_part);
00494 case _Window:
00495 case Self:
00496 return retrieve(m_part);
00497 case Top: {
00498 KHTMLPart *p = m_part;
00499 while (p->parentPart())
00500 p = p->parentPart();
00501 return retrieve(p);
00502 }
00503 case Alert:
00504 case Confirm:
00505 case Prompt:
00506 case Open:
00507 case Focus:
00508 case Blur:
00509 return lookupOrCreateFunction<WindowFunc>(exec,p,this,entry->value,entry->params,entry->attr);
00510 default:
00511 break;
00512 }
00513 }
00514
00515
00516 if (isSafeScript(exec) && entry)
00517 {
00518
00519 switch( entry->value ) {
00520 case Crypto:
00521 return Undefined();
00522 case DefaultStatus:
00523 return String(UString(m_part->jsDefaultStatusBarText()));
00524 case Status:
00525 return String(UString(m_part->jsStatusBarText()));
00526 case Document:
00527 if (m_part->document().isNull()) {
00528 kdDebug(6070) << "Document.write: adding <HTML><BODY> to create document" << endl;
00529 m_part->begin();
00530 m_part->write("<HTML><BODY>");
00531 m_part->end();
00532 }
00533 return getDOMNode(exec,m_part->document());
00534 case Node:
00535 return getNodeConstructor(exec);
00536 case Range:
00537 return getRangeConstructor(exec);
00538 case NodeFilter:
00539 return getNodeFilterConstructor(exec);
00540 case DOMException:
00541 return getDOMExceptionConstructor(exec);
00542 case CSSRule:
00543 return getCSSRuleConstructor(exec);
00544 case EventCtor:
00545 return getEventConstructor(exec);
00546 case _History:
00547 return Value(history ? history :
00548 (const_cast<Window*>(this)->history = new History(exec,m_part)));
00549
00550 case _External:
00551 return Value(external ? external :
00552 (const_cast<Window*>(this)->external = new External(exec,m_part)));
00553
00554 case Event:
00555 if (m_evt)
00556 return getDOMEvent(exec,*m_evt);
00557 else {
00558 #ifdef KJS_VERBOSE
00559 kdDebug(6070) << "WARNING: window(" << this << "," << m_part->name() << ").event, no event!" << endl;
00560 #endif
00561 return Undefined();
00562 }
00563 case InnerHeight:
00564 if (!m_part->view())
00565 return Undefined();
00566 khtml::RenderWidget::flushWidgetResizes();
00567 return Number(m_part->view()->visibleHeight());
00568 case InnerWidth:
00569 if (!m_part->view())
00570 return Undefined();
00571 khtml::RenderWidget::flushWidgetResizes();
00572 return Number(m_part->view()->visibleWidth());
00573 case Length:
00574 return Number(m_part->frames().count());
00575 case Name:
00576 return String(m_part->name());
00577 case SideBar:
00578 return Value(new MozillaSidebarExtension(exec, m_part));
00579 case _Navigator:
00580 case ClientInformation: {
00581
00582 Value nav( new Navigator(exec, m_part) );
00583 const_cast<Window *>(this)->put(exec, "navigator", nav, DontDelete|ReadOnly|Internal);
00584 const_cast<Window *>(this)->put(exec, "clientInformation", nav, DontDelete|ReadOnly|Internal);
00585 return nav;
00586 }
00587 #ifdef Q_WS_QWS
00588 case _Konqueror: {
00589 Value k( new Konqueror(exec, m_part) );
00590 const_cast<Window *>(this)->put(exec, "konqueror", k, DontDelete|ReadOnly|Internal);
00591 return k;
00592 }
00593 #endif
00594 case OffscreenBuffering:
00595 return Boolean(true);
00596 case OuterHeight:
00597 case OuterWidth:
00598 {
00599 if (!m_part->widget())
00600 return Number(0);
00601 KWin::WindowInfo inf = KWin::windowInfo(m_part->widget()->topLevelWidget()->winId());
00602 return Number(entry->value == OuterHeight ?
00603 inf.geometry().height() : inf.geometry().width());
00604 }
00605 case PageXOffset:
00606 return Number(m_part->view()->contentsX());
00607 case PageYOffset:
00608 return Number(m_part->view()->contentsY());
00609 case Personalbar:
00610 return Undefined();
00611 case ScreenLeft:
00612 case ScreenX: {
00613 if (!m_part->view())
00614 return Undefined();
00615 QRect sg = KGlobalSettings::desktopGeometry(m_part->view());
00616 return Number(m_part->view()->mapToGlobal(QPoint(0,0)).x() + sg.x());
00617 }
00618 case ScreenTop:
00619 case ScreenY: {
00620 if (!m_part->view())
00621 return Undefined();
00622 QRect sg = KGlobalSettings::desktopGeometry(m_part->view());
00623 return Number(m_part->view()->mapToGlobal(QPoint(0,0)).y() + sg.y());
00624 }
00625 case ScrollX: {
00626 if (!m_part->view())
00627 return Undefined();
00628 return Number(m_part->view()->contentsX());
00629 }
00630 case ScrollY: {
00631 if (!m_part->view())
00632 return Undefined();
00633 return Number(m_part->view()->contentsY());
00634 }
00635 case Scrollbars:
00636 return Undefined();
00637 case _Screen:
00638 return Value(screen ? screen :
00639 (const_cast<Window*>(this)->screen = new Screen(exec)));
00640 case Image:
00641 return Value(new ImageConstructorImp(exec, m_part->document()));
00642 case Option:
00643 return Value(new OptionConstructorImp(exec, m_part->document()));
00644 case XMLHttpRequest:
00645 return Value(new XMLHttpRequestConstructorImp(exec, m_part->document()));
00646 case XMLSerializer:
00647 return Value(new XMLSerializerConstructorImp(exec));
00648 case Close:
00649 case Scroll:
00650 case ScrollBy:
00651 case ScrollTo:
00652 case MoveBy:
00653 case MoveTo:
00654 case ResizeBy:
00655 case ResizeTo:
00656 case CaptureEvents:
00657 case ReleaseEvents:
00658 case AddEventListener:
00659 case RemoveEventListener:
00660 case SetTimeout:
00661 case ClearTimeout:
00662 case SetInterval:
00663 case ClearInterval:
00664 case Print:
00665 return lookupOrCreateFunction<WindowFunc>(exec,p,this,entry->value,entry->params,entry->attr);
00666
00667 case Navigate:
00668
00669
00670 if ( exec->interpreter()->compatMode() == Interpreter::NetscapeCompat )
00671 return Undefined();
00672 return lookupOrCreateFunction<WindowFunc>(exec,p,this,entry->value,entry->params,entry->attr);
00673 case Onabort:
00674 return getListener(exec,DOM::EventImpl::ABORT_EVENT);
00675 case Onblur:
00676 return getListener(exec,DOM::EventImpl::BLUR_EVENT);
00677 case Onchange:
00678 return getListener(exec,DOM::EventImpl::CHANGE_EVENT);
00679 case Onclick:
00680 return getListener(exec,DOM::EventImpl::KHTML_ECMA_CLICK_EVENT);
00681 case Ondblclick:
00682 return getListener(exec,DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT);
00683 case Ondragdrop:
00684 return getListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT);
00685 case Onerror:
00686 return getListener(exec,DOM::EventImpl::KHTML_ERROR_EVENT);
00687 case Onfocus:
00688 return getListener(exec,DOM::EventImpl::FOCUS_EVENT);
00689 case Onkeydown:
00690 return getListener(exec,DOM::EventImpl::KEYDOWN_EVENT);
00691 case Onkeypress:
00692 return getListener(exec,DOM::EventImpl::KHTML_KEYPRESS_EVENT);
00693 case Onkeyup:
00694 return getListener(exec,DOM::EventImpl::KEYUP_EVENT);
00695 case Onload:
00696 return getListener(exec,DOM::EventImpl::LOAD_EVENT);
00697 case Onmousedown:
00698 return getListener(exec,DOM::EventImpl::MOUSEDOWN_EVENT);
00699 case Onmousemove:
00700 return getListener(exec,DOM::EventImpl::MOUSEMOVE_EVENT);
00701 case Onmouseout:
00702 return getListener(exec,DOM::EventImpl::MOUSEOUT_EVENT);
00703 case Onmouseover:
00704 return getListener(exec,DOM::EventImpl::MOUSEOVER_EVENT);
00705 case Onmouseup:
00706 return getListener(exec,DOM::EventImpl::MOUSEUP_EVENT);
00707 case Onmove:
00708 return getListener(exec,DOM::EventImpl::KHTML_MOVE_EVENT);
00709 case Onreset:
00710 return getListener(exec,DOM::EventImpl::RESET_EVENT);
00711 case Onresize:
00712 return getListener(exec,DOM::EventImpl::RESIZE_EVENT);
00713 case Onselect:
00714 return getListener(exec,DOM::EventImpl::SELECT_EVENT);
00715 case Onsubmit:
00716 return getListener(exec,DOM::EventImpl::SUBMIT_EVENT);
00717 case Onunload:
00718 return getListener(exec,DOM::EventImpl::UNLOAD_EVENT);
00719 }
00720 }
00721 KHTMLPart *kp = m_part->findFrame( p.qstring() );
00722 if (kp)
00723 return retrieve(kp);
00724
00725
00726 bool ok;
00727 unsigned int i = p.toArrayIndex(&ok);
00728 if (ok) {
00729 QPtrList<KParts::ReadOnlyPart> frames = m_part->frames();
00730 unsigned int len = frames.count();
00731 if (i < len) {
00732 KParts::ReadOnlyPart* frame = frames.at(i);
00733 if (frame && ::qt_cast<KHTMLPart*>(frame)) {
00734 KHTMLPart *khtml = static_cast<KHTMLPart*>(frame);
00735 return Window::retrieve(khtml);
00736 }
00737 }
00738 }
00739
00740
00741 if (isSafeScript(exec) &&
00742 m_part->document().isHTMLDocument()) {
00743
00744 DOM::HTMLDocument doc = m_part->htmlDocument();
00745 NamedTagLengthDeterminer::TagLength tags[3] = {
00746 {ID_IMG, 0, 0L}, {ID_FORM, 0, 0L}, {ID_APPLET, 0, 0L}
00747 };
00748 NamedTagLengthDeterminer(p.string(), tags, 3)(doc.handle());
00749 for (int i = 0; i < 3; i++)
00750 if (tags[i].length > 0) {
00751 if (tags[i].length == 1)
00752 return getDOMNode(exec, tags[i].last);
00753
00754 return getDOMNodeList(exec, DOM::NodeList(new DOM::NamedTagNodeListImpl(doc.handle(), tags[i].id, p.string())));
00755 }
00756
00757 DOM::Element element = doc.getElementById(p.string() );
00758 if ( !element.isNull() )
00759 return getDOMNode(exec, element );
00760 }
00761
00762
00763
00764 #ifdef KJS_VERBOSE
00765 kdDebug(6070) << "WARNING: Window::get property not found: " << p.qstring() << endl;
00766 #endif
00767 return Undefined();
00768 }
00769
00770 void Window::put(ExecState* exec, const Identifier &propertyName, const Value &value, int attr)
00771 {
00772
00773
00774 if ( (attr != None && attr != DontDelete) ||
00775
00776 ( isSafeScript( exec ) && ObjectImp::getDirect(propertyName) ) )
00777 {
00778 ObjectImp::put( exec, propertyName, value, attr );
00779 return;
00780 }
00781
00782 const HashEntry* entry = Lookup::findEntry(&WindowTable, propertyName);
00783 if (entry && !m_part.isNull())
00784 {
00785 #ifdef KJS_VERBOSE
00786 kdDebug(6070) << "Window("<<this<<")::put " << propertyName.qstring() << endl;
00787 #endif
00788 switch( entry->value ) {
00789 case Status: {
00790 if (isSafeScript(exec) && m_part->settings()->windowStatusPolicy(m_part->url().host())
00791 == KHTMLSettings::KJSWindowStatusAllow) {
00792 String s = value.toString(exec);
00793 m_part->setJSStatusBarText(s.value().qstring());
00794 }
00795 return;
00796 }
00797 case DefaultStatus: {
00798 if (isSafeScript(exec) && m_part->settings()->windowStatusPolicy(m_part->url().host())
00799 == KHTMLSettings::KJSWindowStatusAllow) {
00800 String s = value.toString(exec);
00801 m_part->setJSDefaultStatusBarText(s.value().qstring());
00802 }
00803 return;
00804 }
00805 case _Location:
00806 goURL(exec, value.toString(exec).qstring(), false );
00807 return;
00808 case Onabort:
00809 if (isSafeScript(exec))
00810 setListener(exec, DOM::EventImpl::ABORT_EVENT,value);
00811 return;
00812 case Onblur:
00813 if (isSafeScript(exec))
00814 setListener(exec, DOM::EventImpl::BLUR_EVENT,value);
00815 return;
00816 case Onchange:
00817 if (isSafeScript(exec))
00818 setListener(exec, DOM::EventImpl::CHANGE_EVENT,value);
00819 return;
00820 case Onclick:
00821 if (isSafeScript(exec))
00822 setListener(exec,DOM::EventImpl::KHTML_ECMA_CLICK_EVENT,value);
00823 return;
00824 case Ondblclick:
00825 if (isSafeScript(exec))
00826 setListener(exec,DOM::EventImpl::KHTML_ECMA_DBLCLICK_EVENT,value);
00827 return;
00828 case Ondragdrop:
00829 if (isSafeScript(exec))
00830 setListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT,value);
00831 return;
00832 case Onerror:
00833 if (isSafeScript(exec))
00834 setListener(exec,DOM::EventImpl::KHTML_ERROR_EVENT,value);
00835 return;
00836 case Onfocus:
00837 if (isSafeScript(exec))
00838 setListener(exec,DOM::EventImpl::FOCUS_EVENT,value);
00839 return;
00840 case Onkeydown:
00841 if (isSafeScript(exec))
00842 setListener(exec,DOM::EventImpl::KEYDOWN_EVENT,value);
00843 return;
00844 case Onkeypress:
00845 if (isSafeScript(exec))
00846 setListener(exec,DOM::EventImpl::KHTML_KEYPRESS_EVENT,value);
00847 return;
00848 case Onkeyup:
00849 if (isSafeScript(exec))
00850 setListener(exec,DOM::EventImpl::KEYUP_EVENT,value);
00851 return;
00852 case Onload:
00853 if (isSafeScript(exec))
00854 setListener(exec,DOM::EventImpl::LOAD_EVENT,value);
00855 return;
00856 case Onmousedown:
00857 if (isSafeScript(exec))
00858 setListener(exec,DOM::EventImpl::MOUSEDOWN_EVENT,value);
00859 return;
00860 case Onmousemove:
00861 if (isSafeScript(exec))
00862 setListener(exec,DOM::EventImpl::MOUSEMOVE_EVENT,value);
00863 return;
00864 case Onmouseout:
00865 if (isSafeScript(exec))
00866 setListener(exec,DOM::EventImpl::MOUSEOUT_EVENT,value);
00867 return;
00868 case Onmouseover:
00869 if (isSafeScript(exec))
00870 setListener(exec,DOM::EventImpl::MOUSEOVER_EVENT,value);
00871 return;
00872 case Onmouseup:
00873 if (isSafeScript(exec))
00874 setListener(exec,DOM::EventImpl::MOUSEUP_EVENT,value);
00875 return;
00876 case Onmove:
00877 if (isSafeScript(exec))
00878 setListener(exec,DOM::EventImpl::KHTML_MOVE_EVENT,value);
00879 return;
00880 case Onreset:
00881 if (isSafeScript(exec))
00882 setListener(exec,DOM::EventImpl::RESET_EVENT,value);
00883 return;
00884 case Onresize:
00885 if (isSafeScript(exec))
00886 setListener(exec,DOM::EventImpl::RESIZE_EVENT,value);
00887 return;
00888 case Onselect:
00889 if (isSafeScript(exec))
00890 setListener(exec,DOM::EventImpl::SELECT_EVENT,value);
00891 return;
00892 case Onsubmit:
00893 if (isSafeScript(exec))
00894 setListener(exec,DOM::EventImpl::SUBMIT_EVENT,value);
00895 return;
00896 case Onunload:
00897 if (isSafeScript(exec))
00898 setListener(exec,DOM::EventImpl::UNLOAD_EVENT,value);
00899 return;
00900 case Name:
00901 if (isSafeScript(exec))
00902 m_part->setName( value.toString(exec).qstring().local8Bit().data() );
00903 return;
00904 default:
00905 break;
00906 }
00907 }
00908 if (isSafeScript(exec)) {
00909
00910 ObjectImp::put(exec, propertyName, value, attr);
00911 }
00912 }
00913
00914 bool Window::toBoolean(ExecState *) const
00915 {
00916 return !m_part.isNull();
00917 }
00918
00919 void Window::scheduleClose()
00920 {
00921 kdDebug(6070) << "Window::scheduleClose window.close() " << m_part << endl;
00922 Q_ASSERT(winq);
00923 QTimer::singleShot( 0, winq, SLOT( timeoutClose() ) );
00924 }
00925
00926 void Window::closeNow()
00927 {
00928 if (!m_part.isNull())
00929 {
00930
00931
00932 m_part->setName( 0 );
00933 m_part->deleteLater();
00934 m_part = 0;
00935 } else
00936 kdDebug(6070) << k_funcinfo << "part is deleted already" << endl;
00937 }
00938
00939 void Window::afterScriptExecution()
00940 {
00941 DOM::DocumentImpl::updateDocumentsRendering();
00942 QValueList<DelayedAction> delayedActions = m_delayed;
00943 m_delayed.clear();
00944 QValueList<DelayedAction>::Iterator it = delayedActions.begin();
00945 for ( ; it != delayedActions.end() ; ++it )
00946 {
00947 switch ((*it).actionId) {
00948 case DelayedClose:
00949 scheduleClose();
00950 return;
00951 case DelayedGoHistory:
00952 goHistory( (*it).param.toInt() );
00953 break;
00954 case NullAction:
00955
00956 break;
00957 };
00958 }
00959 }
00960
00961 bool Window::checkIsSafeScript(KHTMLPart *activePart) const
00962 {
00963 if (m_part.isNull()) {
00964 kdDebug(6070) << "Window::isSafeScript: accessing deleted part !" << endl;
00965 return false;
00966 }
00967 if (!activePart) {
00968 kdDebug(6070) << "Window::isSafeScript: current interpreter's part is 0L!" << endl;
00969 return false;
00970 }
00971 if ( activePart == m_part )
00972 return true;
00973
00974 if ( m_part->document().isNull() )
00975 return true;
00976
00977 DOM::HTMLDocument thisDocument = m_part->htmlDocument();
00978 if ( thisDocument.isNull() ) {
00979 kdDebug(6070) << "Window::isSafeScript: trying to access an XML document !?" << endl;
00980 return false;
00981 }
00982
00983 DOM::HTMLDocument actDocument = activePart->htmlDocument();
00984 if ( actDocument.isNull() ) {
00985 kdDebug(6070) << "Window::isSafeScript: active part has no document!" << endl;
00986 return false;
00987 }
00988 DOM::DOMString actDomain = actDocument.domain();
00989 DOM::DOMString thisDomain = thisDocument.domain();
00990
00991 if ( actDomain == thisDomain ) {
00992 #ifdef KJS_VERBOSE
00993 kdDebug(6070) << "JavaScript: access granted, domain is '" << actDomain.string() << "'" << endl;
00994 #endif
00995 return true;
00996 }
00997
00998 kdDebug(6070) << "WARNING: JavaScript: access denied for current frame '" << actDomain.string() << "' to frame '" << thisDomain.string() << "'" << endl;
00999
01000 return false;
01001 }
01002
01003 void Window::setListener(ExecState *exec, int eventId, Value func)
01004 {
01005 if (!isSafeScript(exec))
01006 return;
01007 DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl*>(m_part->htmlDocument().handle());
01008 if (!doc)
01009 return;
01010
01011 doc->setWindowEventListener(eventId,getJSEventListener(func,true));
01012 }
01013
01014 Value Window::getListener(ExecState *exec, int eventId) const
01015 {
01016 if (!isSafeScript(exec))
01017 return Undefined();
01018 DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl*>(m_part->htmlDocument().handle());
01019 if (!doc)
01020 return Undefined();
01021
01022 DOM::EventListener *listener = doc->getWindowEventListener(eventId);
01023 if (listener)
01024 return static_cast<JSEventListener*>(listener)->listenerObj();
01025 else
01026 return Null();
01027 }
01028
01029
01030 JSEventListener *Window::getJSEventListener(const Value& val, bool html)
01031 {
01032
01033 if (val.type() != ObjectType)
01034 return 0;
01035
01036
01037 Object listenerObject = Object::dynamicCast(val);
01038 ObjectImp *listenerObjectImp = listenerObject.imp();
01039
01040
01041 if (!listenerObject.implementsCall() && m_part && m_part->jScript() && m_part->jScript()->interpreter())
01042 {
01043 Interpreter *interpreter = m_part->jScript()->interpreter();
01044
01045
01046 Value handleEventValue = listenerObject.get(interpreter->globalExec(), Identifier("handleEvent"));
01047 Object handleEventObject = Object::dynamicCast(handleEventValue);
01048
01049 if(handleEventObject.isValid() && handleEventObject.implementsCall())
01050 {
01051 listenerObject = handleEventObject;
01052 listenerObjectImp = handleEventObject.imp();
01053 }
01054 }
01055
01056 JSEventListener *existingListener = jsEventListeners[listenerObjectImp];
01057 if (existingListener)
01058 return existingListener;
01059
01060
01061 return new JSEventListener(listenerObject, listenerObjectImp, Object(this), html);
01062 }
01063
01064 JSLazyEventListener *Window::getJSLazyEventListener(const QString& code, const QString& name, bool html)
01065 {
01066 return new JSLazyEventListener(code, name, Object(this), html);
01067 }
01068
01069 void Window::clear( ExecState *exec )
01070 {
01071 delete winq;
01072 winq = 0L;
01073
01074 deleteAllProperties( exec );
01075
01076
01077 QPtrDictIterator<JSEventListener> it(jsEventListeners);
01078 for (; it.current(); ++it)
01079 it.current()->clear();
01080
01081 jsEventListeners.clear();
01082
01083 if (!m_part.isNull()) {
01084 KJSProxy* proxy = m_part->jScript();
01085 if (proxy)
01086 {
01087 winq = new WindowQObject(this);
01088
01089 KJS::Interpreter *interpreter = proxy->interpreter();
01090 interpreter->initGlobalObject();
01091 }
01092 }
01093 }
01094
01095 void Window::setCurrentEvent( DOM::Event *evt )
01096 {
01097 m_evt = evt;
01098
01099 }
01100
01101 void Window::goURL(ExecState* exec, const QString& url, bool lockHistory)
01102 {
01103 Window* active = Window::retrieveActive(exec);
01104
01105 if (active->part()) {
01106 if (url[0] == QChar('#')) {
01107 m_part->gotoAnchor(url.mid(1));
01108 } else {
01109 QString dstUrl = active->part()->htmlDocument().completeURL(url).string();
01110 KURL dst( dstUrl );
01111 KURL partURL( m_part->url() );
01112
01113 dst.setRef( QString::null );
01114 partURL.setRef( QString::null );
01115 kdDebug(6070) << "Window::goURL dstUrl=" << dst.prettyURL() << " partURL=" << partURL.prettyURL()
01116 << " identical: " << partURL.equals( dst, true ) << endl;
01117
01118
01119
01120 if ( isSafeScript(exec) ||
01121 dstUrl.find(QString::fromLatin1("javascript:"), 0, false) != 0 )
01122 m_part->scheduleRedirection(-1,
01123 dstUrl,
01124 lockHistory);
01125 }
01126 }
01127 }
01128
01129 void Window::delayedGoHistory( int steps )
01130 {
01131 m_delayed.append( DelayedAction( DelayedGoHistory, steps ) );
01132 }
01133
01134 void Window::goHistory( int steps )
01135 {
01136 KParts::BrowserExtension *ext = m_part->browserExtension();
01137 if(!ext)
01138 return;
01139 KParts::BrowserInterface *iface = ext->browserInterface();
01140
01141 if ( !iface )
01142 return;
01143
01144 iface->callMethod( "goHistory(int)", steps );
01145
01146 }
01147
01148 void KJS::Window::resizeTo(QWidget* tl, int width, int height)
01149 {
01150 KParts::BrowserExtension *ext = m_part->browserExtension();
01151 if (!ext) {
01152 kdDebug(6070) << "Window::resizeTo found no browserExtension" << endl;
01153 return;
01154 }
01155
01156
01157 if ( width < 100 || height < 100 ) {
01158 kdDebug(6070) << "Window::resizeTo refused, window would be too small ("<<width<<","<<height<<")" << endl;
01159 return;
01160 }
01161
01162 QRect sg = KGlobalSettings::desktopGeometry(tl);
01163
01164 if ( width > sg.width() || height > sg.height() ) {
01165 kdDebug(6070) << "Window::resizeTo refused, window would be too big ("<<width<<","<<height<<")" << endl;
01166 return;
01167 }
01168
01169
01170
01171 int deltaWidth = tl->frameGeometry().width() - tl->width();
01172 int deltaHeight = tl->frameGeometry().height() - tl->height();
01173
01174 kdDebug() << "resizing to " << width - deltaWidth << "x" << height - deltaHeight << endl;
01175
01176 emit ext->resizeTopLevelWidget( width - deltaWidth, height - deltaHeight );
01177
01178
01179
01180 int right = tl->x() + tl->frameGeometry().width();
01181 int bottom = tl->y() + tl->frameGeometry().height();
01182 int moveByX = 0;
01183 int moveByY = 0;
01184 if ( right > sg.right() )
01185 moveByX = - right + sg.right();
01186 if ( bottom > sg.bottom() )
01187 moveByY = - bottom + sg.bottom();
01188 if ( moveByX || moveByY )
01189 emit ext->moveTopLevelWidget( tl->x() + moveByX , tl->y() + moveByY );
01190 }
01191
01192 Value Window::openWindow(ExecState *exec, const List& args)
01193 {
01194 KHTMLView *widget = m_part->view();
01195 Value v = args[0];
01196 QString str = v.toString(exec).qstring();
01197
01198
01199 KURL url;
01200 if (!str.isEmpty())
01201 {
01202 KHTMLPart* p = Window::retrieveActive(exec)->m_part;
01203 if ( p )
01204 url = p->htmlDocument().completeURL(str).string();
01205 if ( !p ||
01206 !static_cast<DOM::DocumentImpl*>(p->htmlDocument().handle())->isURLAllowed(url.url()) )
01207 return Undefined();
01208 }
01209
01210 KHTMLSettings::KJSWindowOpenPolicy policy =
01211 m_part->settings()->windowOpenPolicy(m_part->url().host());
01212 if ( policy == KHTMLSettings::KJSWindowOpenAsk ) {
01213 if ( KMessageBox::questionYesNo(widget,
01214 str.isEmpty() ?
01215 i18n( "This site is requesting to open up a new browser "
01216 "window via JavaScript.\n"
01217 "Do you want to allow this?" ) :
01218 i18n( "<qt>This site is requesting to open<p>%1</p>in a new browser window via JavaScript.<br />"
01219 "Do you want to allow this?</qt>").arg(KStringHandler::csqueeze(url.htmlURL(), 100)),
01220 i18n( "Confirmation: JavaScript Popup" ) ) == KMessageBox::Yes )
01221 policy = KHTMLSettings::KJSWindowOpenAllow;
01222 } else if ( policy == KHTMLSettings::KJSWindowOpenSmart )
01223 {
01224
01225 if (static_cast<ScriptInterpreter *>(exec->interpreter())->isWindowOpenAllowed())
01226 policy = KHTMLSettings::KJSWindowOpenAllow;
01227 }
01228 if ( policy != KHTMLSettings::KJSWindowOpenAllow ) {
01229 return Undefined();
01230 } else {
01231 KParts::WindowArgs winargs;
01232
01233
01234 QString features;
01235 if (args.size()>2) {
01236 features = args[2].toString(exec).qstring();
01237
01238 winargs.menuBarVisible = false;
01239 winargs.toolBarsVisible = false;
01240 winargs.statusBarVisible = false;
01241 QStringList flist = QStringList::split(',', features);
01242 QStringList::ConstIterator it = flist.begin();
01243 while (it != flist.end()) {
01244 QString s = *it++;
01245 QString key, val;
01246 int pos = s.find('=');
01247 if (pos >= 0) {
01248 key = s.left(pos).stripWhiteSpace().lower();
01249 val = s.mid(pos + 1).stripWhiteSpace().lower();
01250 QRect screen = KGlobalSettings::desktopGeometry(widget->topLevelWidget());
01251
01252 if (key == "left" || key == "screenx") {
01253 winargs.x = (int)val.toFloat() + screen.x();
01254 if (winargs.x < screen.x() || winargs.x > screen.right())
01255 winargs.x = screen.x();
01256 } else if (key == "top" || key == "screeny") {
01257 winargs.y = (int)val.toFloat() + screen.y();
01258 if (winargs.y < screen.y() || winargs.y > screen.bottom())
01259 winargs.y = screen.y();
01260 } else if (key == "height") {
01261 winargs.height = (int)val.toFloat() + 2*qApp->style().pixelMetric( QStyle::PM_DefaultFrameWidth ) + 2;
01262 if (winargs.height > screen.height())
01263 winargs.height = screen.height();
01264 if (winargs.height < 100)
01265 winargs.height = 100;
01266 } else if (key == "width") {
01267 winargs.width = (int)val.toFloat() + 2*qApp->style().pixelMetric( QStyle::PM_DefaultFrameWidth ) + 2;
01268 if (winargs.width > screen.width())
01269 winargs.width = screen.width();
01270 if (winargs.width < 100)
01271 winargs.width = 100;
01272 } else {
01273 goto boolargs;
01274 }
01275 continue;
01276 } else {
01277
01278 key = s.stripWhiteSpace().lower();
01279 val = "1";
01280 }
01281 boolargs:
01282 if (key == "menubar")
01283 winargs.menuBarVisible = (val == "1" || val == "yes");
01284 else if (key == "toolbar")
01285 winargs.toolBarsVisible = (val == "1" || val == "yes");
01286 else if (key == "location")
01287 winargs.toolBarsVisible = (val == "1" || val == "yes");
01288 else if (key == "status" || key == "statusbar")
01289 winargs.statusBarVisible = (val == "1" || val == "yes");
01290 else if (key == "resizable")
01291 winargs.resizable = (val == "1" || val == "yes");
01292 else if (key == "fullscreen")
01293 winargs.fullscreen = (val == "1" || val == "yes");
01294 }
01295 }
01296
01297 KParts::URLArgs uargs;
01298 KHTMLPart *p = m_part;
01299 uargs.frameName = args.size() > 1 ?
01300 args[1].toString(exec).qstring()
01301 : QString("_blank");
01302 if ( uargs.frameName.lower() == "_top" )
01303 {
01304 while ( p->parentPart() )
01305 p = p->parentPart();
01306 Window::retrieveWindow(p)->goURL(exec, url.url(), false );
01307 return Window::retrieve(p);
01308 }
01309 if ( uargs.frameName.lower() == "_parent" )
01310 {
01311 if ( p->parentPart() )
01312 p = p->parentPart();
01313 Window::retrieveWindow(p)->goURL(exec, url.url(), false );
01314 return Window::retrieve(p);
01315 }
01316 if ( uargs.frameName.lower() == "_self")
01317 {
01318 Window::retrieveWindow(p)->goURL(exec, url.url(), false );
01319 return Window::retrieve(p);
01320 }
01321 if ( uargs.frameName.lower() == "replace" )
01322 {
01323 Window::retrieveWindow(p)->goURL(exec, url.url(), true );
01324 return Window::retrieve(p);
01325 }
01326 uargs.serviceType = "text/html";
01327
01328
01329 KParts::ReadOnlyPart *newPart = 0L;
01330 emit p->browserExtension()->createNewWindow(KURL(), uargs,winargs,newPart);
01331 if (newPart && ::qt_cast<KHTMLPart*>(newPart)) {
01332 KHTMLPart *khtmlpart = static_cast<KHTMLPart*>(newPart);
01333
01334 khtmlpart->setOpener(p);
01335 khtmlpart->setOpenedByJS(true);
01336 if (khtmlpart->document().isNull()) {
01337 khtmlpart->begin();
01338 khtmlpart->write("<HTML><BODY>");
01339 khtmlpart->end();
01340 if ( p->docImpl() ) {
01341
01342 khtmlpart->docImpl()->setDomain( p->docImpl()->domain());
01343 khtmlpart->docImpl()->setBaseURL( p->docImpl()->baseURL() );
01344 }
01345 }
01346 uargs.serviceType = QString::null;
01347 if (uargs.frameName.lower() == "_blank")
01348 uargs.frameName = QString::null;
01349 if (!url.isEmpty())
01350 emit khtmlpart->browserExtension()->openURLRequest(url,uargs);
01351 return Window::retrieve(khtmlpart);
01352 } else
01353 return Undefined();
01354 }
01355 }
01356
01357 Value WindowFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
01358 {
01359 KJS_CHECK_THIS( Window, thisObj );
01360 Window *window = static_cast<Window *>(thisObj.imp());
01361 QString str, str2;
01362
01363 KHTMLPart *part = window->m_part;
01364 if (!part)
01365 return Undefined();
01366
01367 KHTMLView *widget = part->view();
01368 Value v = args[0];
01369 UString s = v.toString(exec);
01370 str = s.qstring();
01371
01372
01373 switch(id) {
01374 case Window::Alert:
01375 if (!widget->dialogsAllowed())
01376 return Undefined();
01377 if ( part && part->xmlDocImpl() )
01378 part->xmlDocImpl()->updateRendering();
01379 KMessageBox::error(widget, QStyleSheet::convertFromPlainText(str), "JavaScript");
01380 return Undefined();
01381 case Window::Confirm:
01382 if (!widget->dialogsAllowed())
01383 return Undefined();
01384 if ( part && part->xmlDocImpl() )
01385 part->xmlDocImpl()->updateRendering();
01386 return Boolean((KMessageBox::warningYesNo(widget, QStyleSheet::convertFromPlainText(str), "JavaScript",
01387 KStdGuiItem::ok(), KStdGuiItem::cancel()) == KMessageBox::Yes));
01388 case Window::Prompt:
01389 if (!widget->dialogsAllowed())
01390 return Undefined();
01391 if ( part && part->xmlDocImpl() )
01392 part->xmlDocImpl()->updateRendering();
01393 bool ok;
01394 if (args.size() >= 2)
01395 str2 = KInputDialog::getText(i18n("Prompt"),
01396 QStyleSheet::convertFromPlainText(str),
01397 args[1].toString(exec).qstring(), &ok, widget);
01398 else
01399 str2 = KInputDialog::getText(i18n("Prompt"),
01400 QStyleSheet::convertFromPlainText(str),
01401 QString::null, &ok, widget);
01402 if ( ok )
01403 return String(str2);
01404 else
01405 return Null();
01406 case Window::Open:
01407 return window->openWindow(exec, args);
01408 case Window::Navigate:
01409 window->goURL(exec, args[0].toString(exec).qstring(), false );
01410 return Undefined();
01411 case Window::Focus: {
01412 KHTMLSettings::KJSWindowFocusPolicy policy =
01413 part->settings()->windowFocusPolicy(part->url().host());
01414 if(policy == KHTMLSettings::KJSWindowFocusAllow && widget) {
01415 widget->topLevelWidget()->raise();
01416 widget->setActiveWindow();
01417 }
01418 return Undefined();
01419 }
01420 case Window::Blur:
01421
01422 return Undefined();
01423 };
01424
01425
01426
01427 if (!window->isSafeScript(exec))
01428 return Undefined();
01429
01430 switch (id) {
01431 case Window::ScrollBy:
01432 if(args.size() == 2 && widget)
01433 widget->scrollBy(args[0].toInt32(exec), args[1].toInt32(exec));
01434 return Undefined();
01435 case Window::Scroll:
01436 case Window::ScrollTo:
01437 if(args.size() == 2 && widget)
01438 widget->setContentsPos(args[0].toInt32(exec), args[1].toInt32(exec));
01439 return Undefined();
01440 case Window::MoveBy: {
01441 KHTMLSettings::KJSWindowMovePolicy policy =
01442 part->settings()->windowMovePolicy(part->url().host());
01443 if(policy == KHTMLSettings::KJSWindowMoveAllow && args.size() == 2 && widget)
01444 {
01445 KParts::BrowserExtension *ext = part->browserExtension();
01446 if (ext) {
01447 QWidget * tl = widget->topLevelWidget();
01448 QRect sg = KGlobalSettings::desktopGeometry(tl);
01449
01450 QPoint dest = tl->pos() + QPoint( args[0].toInt32(exec), args[1].toInt32(exec) );
01451
01452 if ( dest.x() >= sg.x() && dest.y() >= sg.x() &&
01453 dest.x()+tl->width() <= sg.width()+sg.x() &&
01454 dest.y()+tl->height() <= sg.height()+sg.y() )
01455 emit ext->moveTopLevelWidget( dest.x(), dest.y() );
01456 }
01457 }
01458 return Undefined();
01459 }
01460 case Window::MoveTo: {
01461 KHTMLSettings::KJSWindowMovePolicy policy =
01462 part->settings()->windowMovePolicy(part->url().host());
01463 if(policy == KHTMLSettings::KJSWindowMoveAllow && args.size() == 2 && widget)
01464 {
01465 KParts::BrowserExtension *ext = part->browserExtension();
01466 if (ext) {
01467 QWidget * tl = widget->topLevelWidget();
01468 QRect sg = KGlobalSettings::desktopGeometry(tl);
01469
01470 QPoint dest( args[0].toInt32(exec)+sg.x(), args[1].toInt32(exec)+sg.y() );
01471
01472 if ( dest.x() >= sg.x() && dest.y() >= sg.y() &&
01473 dest.x()+tl->width() <= sg.width()+sg.x() &&
01474 dest.y()+tl->height() <= sg.height()+sg.y() )
01475 emit ext->moveTopLevelWidget( dest.x(), dest.y() );
01476 }
01477 }
01478 return Undefined();
01479 }
01480 case Window::ResizeBy: {
01481 KHTMLSettings::KJSWindowResizePolicy policy =
01482 part->settings()->windowResizePolicy(part->url().host());
01483 if(policy == KHTMLSettings::KJSWindowResizeAllow
01484 && args.size() == 2 && widget)
01485 {
01486 QWidget * tl = widget->topLevelWidget();
01487 QRect geom = tl->frameGeometry();
01488 window->resizeTo( tl,
01489 geom.width() + args[0].toInt32(exec),
01490 geom.height() + args[1].toInt32(exec) );
01491 }
01492 return Undefined();
01493 }
01494 case Window::ResizeTo: {
01495 KHTMLSettings::KJSWindowResizePolicy policy =
01496 part->settings()->windowResizePolicy(part->url().host());
01497 if(policy == KHTMLSettings::KJSWindowResizeAllow
01498 && args.size() == 2 && widget)
01499 {
01500 QWidget * tl = widget->topLevelWidget();
01501 window->resizeTo( tl, args[0].toInt32(exec), args[1].toInt32(exec) );
01502 }
01503 return Undefined();
01504 }
01505 case Window::SetTimeout:
01506 case Window::SetInterval: {
01507 bool singleShot;
01508 int i;
01509 if (args.size() == 0)
01510 return Undefined();
01511 if (args.size() > 1) {
01512 singleShot = (id == Window::SetTimeout);
01513 i = args[1].toInt32(exec);
01514 } else {
01515
01516 singleShot = true;
01517 i = 4;
01518 }
01519 if (v.isA(StringType)) {
01520 int r = (const_cast<Window*>(window))->winq->installTimeout(Identifier(s), i, singleShot );
01521 return Number(r);
01522 }
01523 else if (v.isA(ObjectType) && Object::dynamicCast(v).implementsCall()) {
01524 Object func = Object::dynamicCast(v);
01525 List funcArgs;
01526 ListIterator it = args.begin();
01527 int argno = 0;
01528 while (it != args.end()) {
01529 Value arg = it++;
01530 if (argno++ >= 2)
01531 funcArgs.append(arg);
01532 }
01533 if (args.size() < 2)
01534 funcArgs.append(Number(i));
01535 int r = (const_cast<Window*>(window))->winq->installTimeout(func, funcArgs, i, singleShot );
01536 return Number(r);
01537 }
01538 else
01539 return Undefined();
01540 }
01541 case Window::ClearTimeout:
01542 case Window::ClearInterval:
01543 (const_cast<Window*>(window))->winq->clearTimeout(v.toInt32(exec));
01544 return Undefined();
01545 case Window::Close: {
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556 bool doClose = false;
01557 if (!part->openedByJS())
01558 {
01559
01560
01561 History history(exec,part);
01562 if ( history.get( exec, "length" ).toInt32(exec) <= 1 ||
01563 KMessageBox::questionYesNo( window->part()->widget(), i18n("Close window?"), i18n("Confirmation Required") ) == KMessageBox::Yes )
01564 doClose = true;
01565 }
01566 else
01567 doClose = true;
01568
01569 if (doClose)
01570 {
01571
01572
01573
01574 if ( Window::retrieveActive(exec) == window ) {
01575 if (widget) {
01576
01577
01578 widget->closeChildDialogs();
01579 }
01580
01581
01582 Window* w = const_cast<Window*>(window);
01583 w->m_delayed.append( Window::DelayedAction( Window::DelayedClose ) );
01584 } else {
01585
01586 (const_cast<Window*>(window))->closeNow();
01587 }
01588 }
01589 return Undefined();
01590 }
01591 case Window::Print:
01592 if ( widget ) {
01593
01594 widget->print();
01595
01596 }
01597 case Window::CaptureEvents:
01598 case Window::ReleaseEvents:
01599
01600 break;
01601 case Window::AddEventListener: {
01602 JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
01603 DOM::Document doc = part->document();
01604 if (doc.isHTMLDocument()) {
01605 DOM::HTMLDocument htmlDoc = doc;
01606 htmlDoc.body().addEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec));
01607 }
01608 else
01609 doc.addEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec));
01610 return Undefined();
01611 }
01612 case Window::RemoveEventListener: {
01613 JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
01614 DOM::Document doc = part->document();
01615 if (doc.isHTMLDocument()) {
01616 DOM::HTMLDocument htmlDoc = doc;
01617 htmlDoc.body().removeEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec));
01618 }
01619 else
01620 doc.removeEventListener(args[0].toString(exec).string(),listener,args[2].toBoolean(exec));
01621 return Undefined();
01622 }
01623 break;
01624 }
01625 return Undefined();
01626 }
01627
01629
01630
01631 ScheduledAction::ScheduledAction(Object _func, List _args, QTime _nextTime, int _interval, bool _singleShot,
01632 int _timerId)
01633 {
01634
01635 func = static_cast<ObjectImp*>(_func.imp());
01636 args = _args;
01637 isFunction = true;
01638 singleShot = _singleShot;
01639 nextTime = _nextTime;
01640 interval = _interval;
01641 executing = false;
01642 timerId = _timerId;
01643 }
01644
01645
01646 ScheduledAction::ScheduledAction(QString _code, QTime _nextTime, int _interval, bool _singleShot, int _timerId)
01647 {
01648
01649
01650
01651 func = 0;
01652 code = _code;
01653 isFunction = false;
01654 singleShot = _singleShot;
01655 nextTime = _nextTime;
01656 interval = _interval;
01657 executing = false;
01658 timerId = _timerId;
01659 }
01660
01661 void ScheduledAction::execute(Window *window)
01662 {
01663 ScriptInterpreter *interpreter = static_cast<ScriptInterpreter *>(window->m_part->jScript()->interpreter());
01664
01665 interpreter->setProcessingTimerCallback(true);
01666
01667
01668 if (isFunction) {
01669 if (func->implementsCall()) {
01670
01671 Q_ASSERT( window->m_part );
01672 if ( window->m_part )
01673 {
01674 KJS::Interpreter *interpreter = window->m_part->jScript()->interpreter();
01675 ExecState *exec = interpreter->globalExec();
01676 Q_ASSERT( window == interpreter->globalObject().imp() );
01677 Object obj( window );
01678 func->call(exec,obj,args);
01679 if (exec->hadException())
01680 exec->clearException();
01681
01682
01683 window->m_part->document().updateRendering();
01684 }
01685 }
01686 }
01687 else {
01688 window->m_part->executeScript(DOM::Node(), code);
01689 }
01690
01691 interpreter->setProcessingTimerCallback(false);
01692 }
01693
01694 void ScheduledAction::mark()
01695 {
01696 if (func && !func->marked())
01697 func->mark();
01698 args.mark();
01699 }
01700
01701 ScheduledAction::~ScheduledAction()
01702 {
01703
01704 }
01705
01707
01708 WindowQObject::WindowQObject(Window *w)
01709 : parent(w)
01710 {
01711
01712 part = parent->m_part;
01713 if ( !part )
01714 kdDebug(6070) << "WARNING: null part in " << k_funcinfo << endl;
01715 else
01716 connect( part, SIGNAL( destroyed() ),
01717 this, SLOT( parentDestroyed() ) );
01718 pausedTime = 0;
01719 lastTimerId = 0;
01720 }
01721
01722 WindowQObject::~WindowQObject()
01723 {
01724
01725 parentDestroyed();
01726 }
01727
01728 void WindowQObject::parentDestroyed()
01729 {
01730 killTimers();
01731
01732 QPtrListIterator<ScheduledAction> it(scheduledActions);
01733 for (; it.current(); ++it)
01734 delete it.current();
01735 scheduledActions.clear();
01736 }
01737
01738 int WindowQObject::installTimeout(const Identifier &handler, int t, bool singleShot)
01739 {
01740 int id = ++lastTimerId;
01741 if (t < 10) t = 10;
01742 QTime nextTime = QTime::currentTime().addMSecs(-pausedTime).addMSecs(t);
01743 ScheduledAction *action = new ScheduledAction(handler.qstring(),nextTime,t,singleShot,id);
01744 scheduledActions.append(action);
01745 setNextTimer();
01746 return id;
01747 }
01748
01749 int WindowQObject::installTimeout(const Value &func, List args, int t, bool singleShot)
01750 {
01751 Object objFunc = Object::dynamicCast( func );
01752 if (!objFunc.isValid())
01753 return 0;
01754 int id = ++lastTimerId;
01755 if (t < 10) t = 10;
01756 QTime nextTime = QTime::currentTime().addMSecs(-pausedTime).addMSecs(t);
01757 ScheduledAction *action = new ScheduledAction(objFunc,args,nextTime,t,singleShot,id);
01758 scheduledActions.append(action);
01759 setNextTimer();
01760 return id;
01761 }
01762
01763 void WindowQObject::clearTimeout(int timerId)
01764 {
01765 QPtrListIterator<ScheduledAction> it(scheduledActions);
01766 for (; it.current(); ++it) {
01767 ScheduledAction *action = it.current();
01768 if (action->timerId == timerId) {
01769 scheduledActions.removeRef(action);
01770 if (!action->executing)
01771 delete action;
01772 return;
01773 }
01774 }
01775 }
01776
01777 void WindowQObject::mark()
01778 {
01779 QPtrListIterator<ScheduledAction> it(scheduledActions);
01780 for (; it.current(); ++it)
01781 it.current()->mark();
01782 }
01783
01784 void WindowQObject::timerEvent(QTimerEvent *)
01785 {
01786 killTimers();
01787
01788 if (scheduledActions.isEmpty())
01789 return;
01790
01791 QTime currentActual = QTime::currentTime();
01792 QTime currentAdjusted = currentActual.addMSecs(-pausedTime);
01793
01794
01795
01796 QPtrList<ScheduledAction> toExecute;
01797 QPtrListIterator<ScheduledAction> it(scheduledActions);
01798 for (; it.current(); ++it)
01799 if (currentAdjusted >= it.current()->nextTime)
01800 toExecute.append(it.current());
01801
01802
01803 it = QPtrListIterator<ScheduledAction>(toExecute);
01804 for (; it.current(); ++it) {
01805 ScheduledAction *action = it.current();
01806 if (!scheduledActions.containsRef(action))
01807 continue;
01808
01809 action->executing = true;
01810
01811 if (action->singleShot)
01812 scheduledActions.removeRef(action);
01813 if (!parent->part().isNull())
01814 action->execute(parent);
01815
01816 action->executing = false;
01817
01818 if (!scheduledActions.containsRef(action))
01819 delete action;
01820 else
01821 action->nextTime = action->nextTime.addMSecs(action->interval);
01822 }
01823
01824 pausedTime += currentActual.msecsTo(QTime::currentTime());
01825
01826
01827 setNextTimer();
01828 }
01829
01830 void WindowQObject::setNextTimer()
01831 {
01832 if (scheduledActions.isEmpty())
01833 return;
01834
01835 QPtrListIterator<ScheduledAction> it(scheduledActions);
01836 QTime nextTime = it.current()->nextTime;
01837 for (++it; it.current(); ++it)
01838 if (nextTime > it.current()->nextTime)
01839 nextTime = it.current()->nextTime;
01840
01841 QTime nextTimeActual = nextTime.addMSecs(pausedTime);
01842 int nextInterval = QTime::currentTime().msecsTo(nextTimeActual);
01843 if (nextInterval < 0)
01844 nextInterval = 0;
01845 startTimer(nextInterval);
01846 }
01847
01848 void WindowQObject::timeoutClose()
01849 {
01850 parent->closeNow();
01851 }
01852
01853 Value FrameArray::get(ExecState *exec, const Identifier &p) const
01854 {
01855 #ifdef KJS_VERBOSE
01856 kdDebug(6070) << "FrameArray::get " << p.qstring() << " part=" << (void*)part << endl;
01857 #endif
01858 if (part.isNull())
01859 return Undefined();
01860
01861 QPtrList<KParts::ReadOnlyPart> frames = part->frames();
01862 unsigned int len = frames.count();
01863 if (p == lengthPropertyName)
01864 return Number(len);
01865 else if (p== "location")
01866 {
01867 Object obj = Object::dynamicCast( Window::retrieve( part ) );
01868 if ( !obj.isNull() )
01869 return obj.get( exec, "location" );
01870 return Undefined();
01871 }
01872
01873
01874 KParts::ReadOnlyPart *frame = part->findFrame(p.qstring());
01875 if (!frame) {
01876 bool ok;
01877 unsigned int i = p.toArrayIndex(&ok);
01878 if (ok && i < len)
01879 frame = frames.at(i);
01880 }
01881
01882
01883
01884
01885 if (frame && ::qt_cast<KHTMLPart*>(frame)) {
01886 KHTMLPart *khtml = static_cast<KHTMLPart*>(frame);
01887 return Window::retrieve(khtml);
01888 }
01889
01890 return ObjectImp::get(exec, p);
01891 }
01892
01894
01895 const ClassInfo Location::info = { "Location", 0, &LocationTable, 0 };
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913 IMPLEMENT_PROTOFUNC_DOM(LocationFunc)
01914 Location::Location(KHTMLPart *p) : m_part(p)
01915 {
01916
01917 }
01918
01919 Location::~Location()
01920 {
01921
01922 }
01923
01924 Value Location::get(ExecState *exec, const Identifier &p) const
01925 {
01926 #ifdef KJS_VERBOSE
01927 kdDebug(6070) << "Location::get " << p.qstring() << " m_part=" << (void*)m_part << endl;
01928 #endif
01929
01930 if (m_part.isNull())
01931 return Undefined();
01932
01933 const HashEntry *entry = Lookup::findEntry(&LocationTable, p);
01934
01935
01936 if ( entry && entry->value == Replace )
01937 return lookupOrCreateFunction<LocationFunc>(exec,p,this,entry->value,entry->params,entry->attr);
01938
01939
01940 const Window* window = Window::retrieveWindow( m_part );
01941 if ( !window || !window->isSafeScript(exec) )
01942 return Undefined();
01943
01944 KURL url = m_part->url();
01945 if (entry)
01946 switch (entry->value) {
01947 case Hash:
01948 return String( url.ref().isNull() ? QString("") : "#" + url.ref() );
01949 case Host: {
01950 UString str = url.host();
01951 if (url.port())
01952 str += ":" + QString::number((int)url.port());
01953 return String(str);
01954
01955
01956
01957 }
01958 case Hostname:
01959 return String( url.host() );
01960 case Href:
01961 if (!url.hasPath())
01962 return String( url.prettyURL()+"/" );
01963 else
01964 return String( url.prettyURL() );
01965 case Pathname:
01966 return String( url.path().isEmpty() ? QString("/") : url.path() );
01967 case Port:
01968 return String( url.port() ? QString::number((int)url.port()) : QString::fromLatin1("") );
01969 case Protocol:
01970 return String( url.protocol()+":" );
01971 case Search:
01972 return String( url.query() );
01973 case EqualEqual:
01974 return String(toString(exec));
01975 case ToString:
01976 return lookupOrCreateFunction<LocationFunc>(exec,p,this,entry->value,entry->params,entry->attr);
01977 }
01978
01979 ValueImp * val = ObjectImp::getDirect(p);
01980 if (val)
01981 return Value(val);
01982 if (entry && (entry->attr & Function))
01983 return lookupOrCreateFunction<LocationFunc>(exec,p,this,entry->value,entry->params,entry->attr);
01984
01985 return Undefined();
01986 }
01987
01988 void Location::put(ExecState *exec, const Identifier &p, const Value &v, int attr)
01989 {
01990 #ifdef KJS_VERBOSE
01991 kdDebug(6070) << "Location::put " << p.qstring() << " m_part=" << (void*)m_part << endl;
01992 #endif
01993 if (m_part.isNull())
01994 return;
01995
01996
01997 const Window* window = Window::retrieveWindow( m_part );
01998 if ( !window || !window->isSafeScript(exec) )
01999 return;
02000
02001 QString str = v.toString(exec).qstring();
02002 KURL url = m_part->url();
02003 const HashEntry *entry = Lookup::findEntry(&LocationTable, p);
02004 if (entry)
02005 switch (entry->value) {
02006 case Href: {
02007 KHTMLPart* p = Window::retrieveActive(exec)->part();
02008 if ( p )
02009 url = p->htmlDocument().completeURL( str ).string();
02010 else
02011 url = str;
02012 break;
02013 }
02014 case Hash:
02015
02016 if (str == url.ref()) return;
02017 url.setRef(str);
02018 break;
02019 case Host: {
02020 QString host = str.left(str.find(":"));
02021 QString port = str.mid(str.find(":")+1);
02022 url.setHost(host);
02023 url.setPort(port.toUInt());
02024 break;
02025 }
02026 case Hostname:
02027 url.setHost(str);
02028 break;
02029 case Pathname:
02030 url.setPath(str);
02031 break;
02032 case Port:
02033 url.setPort(str.toUInt());
02034 break;
02035 case Protocol:
02036 url.setProtocol(str);
02037 break;
02038 case Search:
02039 url.setQuery(str);
02040 break;
02041 }
02042 else {
02043 ObjectImp::put(exec, p, v, attr);
02044 return;
02045 }
02046
02047 Window::retrieveWindow(m_part)->goURL(exec, url.url(), false );
02048 }
02049
02050 Value Location::toPrimitive(ExecState *exec, Type) const
02051 {
02052 Window* window = Window::retrieveWindow( m_part );
02053 if ( window && window->isSafeScript(exec) )
02054 return String(toString(exec));
02055 return Undefined();
02056 }
02057
02058 UString Location::toString(ExecState *exec) const
02059 {
02060 Window* window = Window::retrieveWindow( m_part );
02061 if ( window && window->isSafeScript(exec) )
02062 {
02063 if (!m_part->url().hasPath())
02064 return m_part->url().prettyURL()+"/";
02065 else
02066 return m_part->url().prettyURL();
02067 }
02068 return "";
02069 }
02070
02071 Value LocationFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
02072 {
02073 KJS_CHECK_THIS( Location, thisObj );
02074 Location *location = static_cast<Location *>(thisObj.imp());
02075 KHTMLPart *part = location->part();
02076
02077 if (!part) return Undefined();
02078
02079 Window* window = Window::retrieveWindow(part);
02080
02081 if ( !window->isSafeScript(exec) && id != Location::Replace)
02082 return Undefined();
02083
02084 switch (id) {
02085 case Location::Assign:
02086 case Location::Replace:
02087 Window::retrieveWindow(part)->goURL(exec, args[0].toString(exec).qstring(),
02088 id == Location::Replace);
02089 break;
02090 case Location::Reload:
02091 part->scheduleRedirection(-1, part->url().url(), true);
02092 break;
02093 case Location::ToString:
02094 return String(location->toString(exec));
02095 }
02096 return Undefined();
02097 }
02098
02100
02101 const ClassInfo External::info = { "External", 0, 0, 0 };
02102
02103
02104
02105
02106
02107 IMPLEMENT_PROTOFUNC_DOM(ExternalFunc)
02108
02109 Value External::get(ExecState *exec, const Identifier &p) const
02110 {
02111 return lookupGetFunction<ExternalFunc,ObjectImp>(exec,p,&ExternalTable,this);
02112 }
02113
02114 Value ExternalFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
02115 {
02116 KJS_CHECK_THIS( External, thisObj );
02117 External *external = static_cast<External *>(thisObj.imp());
02118
02119 KHTMLPart *part = external->part;
02120 if (!part)
02121 return Undefined();
02122
02123 KHTMLView *widget = part->view();
02124
02125 switch (id) {
02126 case External::AddFavorite:
02127 {
02128 if (!widget->dialogsAllowed())
02129 return Undefined();
02130 part->xmlDocImpl()->updateRendering();
02131 if (args.size() != 1 && args.size() != 2)
02132 return Undefined();
02133
02134 QString url = args[0].toString(exec).qstring();
02135 QString title;
02136 if (args.size() == 2)
02137 title = args[1].toString(exec).qstring();
02138
02139
02140
02141 return Undefined();
02142
02143 QString question;
02144 if ( title.isEmpty() )
02145 question = i18n("Do you want a bookmark pointing to the location \"%1\" to be added to your collection?")
02146 .arg(url);
02147 else
02148 question = i18n("Do you want a bookmark pointing to the location \"%1\" titled \"%2\" to be added to your collection?")
02149 .arg(url).arg(title);
02150
02151 if (KMessageBox::warningYesNo(
02152 widget, question,
02153 i18n("JavaScript Attempted Bookmark Insert"),
02154 i18n("Insert"), i18n("Disallow")) == KMessageBox::Yes)
02155 {
02156 KBookmarkManager *mgr = KBookmarkManager::userBookmarksManager();
02157 mgr->addBookmarkDialog(url,title);
02158 }
02159 break;
02160 }
02161 default:
02162 return Undefined();
02163 }
02164
02165 return Undefined();
02166 }
02167
02169
02170 const ClassInfo History::info = { "History", 0, 0, 0 };
02171
02172
02173
02174
02175
02176
02177
02178
02179 IMPLEMENT_PROTOFUNC_DOM(HistoryFunc)
02180
02181 Value History::get(ExecState *exec, const Identifier &p) const
02182 {
02183 return lookupGet<HistoryFunc,History,ObjectImp>(exec,p,&HistoryTable,this);
02184 }
02185
02186 Value History::getValueProperty(ExecState *, int token) const
02187 {
02188
02189
02190 switch (token) {
02191 case Length:
02192 {
02193 KParts::BrowserExtension *ext = part->browserExtension();
02194 if ( !ext )
02195 return Number( 0 );
02196
02197 KParts::BrowserInterface *iface = ext->browserInterface();
02198 if ( !iface )
02199 return Number( 0 );
02200
02201 QVariant length = iface->property( "historyLength" );
02202
02203 if ( length.type() != QVariant::UInt )
02204 return Number( 0 );
02205
02206 return Number( length.toUInt() );
02207 }
02208 default:
02209 kdDebug(6070) << "WARNING: Unhandled token in History::getValueProperty : " << token << endl;
02210 return Undefined();
02211 }
02212 }
02213
02214 Value HistoryFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
02215 {
02216 KJS_CHECK_THIS( History, thisObj );
02217 History *history = static_cast<History *>(thisObj.imp());
02218
02219 Value v = args[0];
02220 Number n;
02221 if(!v.isNull())
02222 n = v.toInteger(exec);
02223
02224 int steps;
02225 switch (id) {
02226 case History::Back:
02227 steps = -1;
02228 break;
02229 case History::Forward:
02230 steps = 1;
02231 break;
02232 case History::Go:
02233 steps = n.intValue();
02234 break;
02235 default:
02236 return Undefined();
02237 }
02238
02239
02240
02241
02242
02243 if (!steps)
02244 {
02245 history->part->openURL( history->part->url() );
02246 } else
02247 {
02248
02249
02250 Window* window = Window::retrieveWindow( history->part );
02251 window->delayedGoHistory( steps );
02252 }
02253 return Undefined();
02254 }
02255
02257
02258 #ifdef Q_WS_QWS
02259
02260 const ClassInfo Konqueror::info = { "Konqueror", 0, 0, 0 };
02261
02262 bool Konqueror::hasProperty(ExecState *exec, const Identifier &p) const
02263 {
02264 if ( p.qstring().startsWith( "goHistory" ) ) return false;
02265
02266 return true;
02267 }
02268
02269 Value Konqueror::get(ExecState *exec, const Identifier &p) const
02270 {
02271 if ( p == "goHistory" || part->url().protocol() != "http" || part->url().host() != "localhost" )
02272 return Undefined();
02273
02274 KParts::BrowserExtension *ext = part->browserExtension();
02275 if ( ext ) {
02276 KParts::BrowserInterface *iface = ext->browserInterface();
02277 if ( iface ) {
02278 QVariant prop = iface->property( p.qstring().latin1() );
02279
02280 if ( prop.isValid() ) {
02281 switch( prop.type() ) {
02282 case QVariant::Int:
02283 return Number( prop.toInt() );
02284 case QVariant::String:
02285 return String( prop.toString() );
02286 default:
02287 break;
02288 }
02289 }
02290 }
02291 }
02292
02293 return Value( new KonquerorFunc(this, p.qstring().latin1() ) );
02294 }
02295
02296 Value KonquerorFunc::tryCall(ExecState *exec, Object &, const List &args)
02297 {
02298 KParts::BrowserExtension *ext = konqueror->part->browserExtension();
02299
02300 if(!ext)
02301 return Undefined();
02302
02303 KParts::BrowserInterface *iface = ext->browserInterface();
02304
02305 if ( !iface )
02306 return Undefined();
02307
02308 QCString n = m_name.data();
02309 n += "()";
02310 iface->callMethod( n.data(), QVariant() );
02311
02312 return Undefined();
02313 }
02314
02315 UString Konqueror::toString(ExecState *) const
02316 {
02317 return UString("[object Konqueror]");
02318 }
02319
02320 #endif
02321
02322
02323 #include "kjs_window.moc"