Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 250 insertions, 0 deletions

diff --git a/khtml/ecma/kjs_events.h b/khtml/ecma/kjs_events.h
new file mode 100644
index 000000000..9fedfe594
--- /dev/null
+++ b/khtml/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 QString &_code, const QString &_name, const Object &_win, DOM::NodeImpl* node);
+    ~JSLazyEventListener();
+    virtual void handleEvent(DOM::Event &evt);
+    Object listenerObj() const;
+  private:
+    void parseCode() const;
+
+    mutable QString code;
+    mutable QString 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