Index: ChangeLog
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/ChangeLog,v
retrieving revision 1.1991.2.2.8.2
diff -u -p -r1.1991.2.2.8.2 ChangeLog
--- ChangeLog	2003/11/14 00:15:45	1.1991.2.2.8.2
+++ ChangeLog	2003/11/16 05:27:41
@@ -1,3 +1,150 @@
+2003-11-15  Maciej Stachowiak  <mjs@apple.com>
+
+	- merged the following fixes from HEAD
+	
+    2003-11-13  Darin Adler  <darin@apple.com>
+
+        Reviewed by Ken.
+
+        - fixed 3452554 -- keyCode attribute for DOM events reports incorrect value
+
+        * khtml/dom/dom2_events.cpp:
+        (UIEvent::keyCode): Return the Windows key code for keydown and keyup events.
+        But for other events, return the character code. This matches IE.
+        (UIEvent::which): Same behavior for now; may need further refinement.
+
+        * kwq/KWQEvent.h: Change QEvent to allow copying. The Qt version probably doesn't
+        allow it, but for us it's no big deal. Our event objects are just data holders.
+        (QKeyEvent::QKeyEvent): Change parameters; take an NSEvent and figure the rest out
+        here. Except for now get the type, button state, and auto repeat flag from the caller
+        because that's a smaller change from how things are done now. I'll take this the next
+        step later.
+        * kwq/KWQEvent.mm:
+        (characterCode): Added. Extracts the character code from the string if it's exactly
+        1 character long.
+        (WindowsKeyCode): Added. Given an event, figures out the Windows key code. 
+        (QKeyEvent::QKeyEvent): Changed to get things from the NSEvent rather than having them
+        passed individually. One change is that _ascii is now the Unicode value of the first
+        character in the string. This causes us to return the Unicode value from keyCode for
+        keypress events. Another change is that we now compute the Windows key code.
+
+        * kwq/KWQKHTMLPart.mm: (KWQKHTMLPart::keyEvent): Change to use the new QKeyEvent
+        constructor, passing in the NSEvent.
+
+        * khtml/xml/dom2_eventsimpl.cpp: (KeyboardEventImpl::KeyboardEventImpl):
+        In APPLE_CHANGES, copy the QKeyEvent using the copy constructor rather than
+        listing the fields. This is easier to maintain when the list of fields changes.
+
+        * khtml/rendering/render_form.cpp: (ComboBoxWidget::eventFilter): Put #if
+        !APPLE_CHANGES around code that constructs a QKeyEvent. We don't ever run this
+        code, but now we can't compile it either so we need the #if.
+
+    2003-11-12  Ken Kocienda  <kocienda@apple.com>
+
+        Reviewed by Richard
+
+	Fix for this bug:
+
+	<rdar://problem/3481600>: key event objects do not preserve unmodified keys
+
+        * khtml/xml/dom2_eventsimpl.cpp: Modified constructor call to include
+	unmodifiedText.
+        (KeyboardEventImpl::KeyboardEventImpl):
+        * kwq/KWQEvent.h: Added unmodifiedText accessor and variable to QKeyEvent.
+        * kwq/KWQEvent.mm:
+        (QKeyEvent::QKeyEvent): Modified constructor to include unmodifiedText.
+        (QKeyEvent::unmodifiedText): Added accessor.
+        * kwq/KWQKHTMLPart.mm:
+        (KWQKHTMLPart::keyEvent): Modified constructor call to include
+        unmodifiedText.
+
+    2003-11-05  Darin Adler  <darin@apple.com>
+
+        Reviewed by Maciej.
+
+        - fixed 3475109 -- support keyboard event object properties of altkey, ctrlKey, shiftKey
+
+        We had the DOM Level 3 KeyboardEvent class already; I just had to add JavaScript bindings.
+
+        * khtml/ecma/kjs_events.h: Added DOMKeyboardEvent class.
+        * khtml/ecma/kjs_events.cpp:
+        (KJS::getDOMEvent): Added code to make a DOMKeyboardEvent if the event is a DOM::KeyboardEvent.
+        (DOMKeyboardEvent::~DOMKeyboardEvent): Added.
+        (DOMKeyboardEvent::classInfo): Added.
+        (DOMKeyboardEvent::tryGet): Added.
+        (DOMKeyboardEvent::getValueProperty): Added.
+        (DOMKeyboardEventProtoFunc::tryCall): Added.
+
+        * khtml/dom/dom2_events.cpp:
+        (KeyboardEvent::keyIdentifier): Added.
+        (KeyboardEvent::keyLocation): Added.
+
+        * khtml/ecma/kjs_events.lut.h: Regenerated.
+
+    2003-10-20  Ken Kocienda  <kocienda@apple.com>
+
+        Reviewed by David
+
+        * khtml/dom/dom2_events.cpp:
+        (UIEvent::keyCode): Change over to use ascii value for key code.
+        (UIEvent::which): Ditto.
+        (KeyboardEvent::KeyboardEvent): New key event class which
+	tracks the DOM Level 3 spec more closely.
+        (KeyboardEvent::operator = ): New function.
+        (KeyboardEvent::~KeyboardEvent): New function.
+        (KeyboardEvent::ctrlKey): New function.
+        (KeyboardEvent::shiftKey): New function.
+        (KeyboardEvent::altKey): New function.
+        (KeyboardEvent::metaKey): New function.
+        (KeyboardEvent::altGraphKey): New function.
+        (KeyboardEvent::initKeyboardEvent): New function.
+        * khtml/dom/dom2_events.h: Ditto.
+        * khtml/html/html_formimpl.cpp:
+        (HTMLGenericFormElementImpl::defaultEventHandler): Use key 
+	identifiers to test which key was pressed, instead of removed keyVal().
+        (HTMLInputElementImpl::defaultEventHandler): Ditto.
+        (HTMLSelectElementImpl::defaultEventHandler): Ditto.
+        * khtml/html/html_inlineimpl.cpp:
+        (HTMLAnchorElementImpl::defaultEventHandler): Change casts to match new
+	class name. Use key identifiers to test which key was pressed, 
+	instead of removed keyVal(). Use new modifier accessors.
+        * khtml/xml/dom2_eventsimpl.cpp:
+        (EventImpl::typeToId): Some reorganization of the constants in the
+	switch statements. Name change for these to remove the KHTML_ prefix
+	from the key up and key down events will happen soon.
+        (EventImpl::idToType): Ditto.
+        (KeyboardEventImpl::KeyboardEventImpl): New key event class which
+        tracks the DOM Level 3 spec more closely.
+        (KeyboardEventImpl::~KeyboardEventImpl): Ditto.
+        (KeyboardEventImpl::initKeyboardEvent): Ditto.
+        * khtml/xml/dom2_eventsimpl.h:
+        (DOM::EventImpl::): Some reorganization of the constants in the
+        switch statements. Name change for these to remove the KHTML_ prefix
+        from the key up and key down events will happen soon.
+        (DOM::KeyboardEventImpl::keyIdentifier): New function.
+        (DOM::KeyboardEventImpl::keyLocation): New function.
+        (DOM::KeyboardEventImpl::ctrlKey): New function.
+        (DOM::KeyboardEventImpl::shiftKey): New function.
+        (DOM::KeyboardEventImpl::altKey): New function.
+        (DOM::KeyboardEventImpl::metaKey): New function.
+        (DOM::KeyboardEventImpl::altGraphKey): New function.
+        (DOM::KeyboardEventImpl::qKeyEvent): New function.
+        * khtml/xml/dom_docimpl.cpp:
+        (DocumentImpl::createEvent): Now can create keyboard events.
+        * khtml/xml/dom_nodeimpl.cpp:
+        (NodeImpl::dispatchKeyEvent): Class name changes.
+        * kwq/KWQEvent.h: Added QString identifier member.
+        * kwq/KWQEvent.mm:
+        (hexDigit): Added helper.
+        (identifierForKeyText): Added new function to map keys to DOM
+	key identifiers as listed in the DOM spec.
+        (QKeyEvent::identifier): Added accessor.
+        * kwq/KWQKHTMLPart.mm:
+        (KWQKHTMLPart::stateForCurrentEvent): Added check to see if
+	a key press is on one of the numeric keypad keys.
+        * kwq/KWQLogging.h: Added log constant for DOM events.
+        * kwq/KWQLogging.m: Ditto
+
 2003-11-13  Vicki Murley  <vicki@apple.com>
 
         Reviewed by NOBODY (OOPS!).
Index: khtml/dom/dom2_events.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/dom/dom2_events.cpp,v
retrieving revision 1.11
diff -u -p -r1.11 khtml/dom/dom2_events.cpp
--- khtml/dom/dom2_events.cpp	2003/04/02 00:46:02	1.11
+++ khtml/dom/dom2_events.cpp	2003/11/16 05:27:41
@@ -261,11 +261,17 @@ int UIEvent::keyCode() const
     if (!impl)
 	throw DOMException(DOMException::INVALID_STATE_ERR);
     
-    KeyEventImpl *keyEvent = dynamic_cast<KeyEventImpl*>(impl);
-    if (keyEvent)
-        return keyEvent->keyVal();
-    else
-        return 0;
+    KeyboardEventImpl *keyEvent = dynamic_cast<KeyboardEventImpl*>(impl);
+    if (keyEvent) {
+#if APPLE_CHANGES
+        if (impl->id() == EventImpl::KHTML_KEYDOWN_EVENT || impl->id() == EventImpl::KHTML_KEYUP_EVENT) {
+            return keyEvent->qKeyEvent()->WindowsKeyCode();
+        }
+#endif
+        return keyEvent->qKeyEvent()->ascii();
+    }
+
+    return 0;
 }
 
 int UIEvent::pageX() const
@@ -323,10 +329,16 @@ int UIEvent::which() const
 
     // Note: This property supports both key events and mouse events
 
-    // Value is just like keyCode()
-    KeyEventImpl *keyEvent = dynamic_cast<KeyEventImpl*>(impl);
-    if (keyEvent)
-        return keyEvent->keyVal();
+    // Netscape's "which" returns a virtual key code for keydown and keyup, and a character code for keypress.
+    KeyboardEventImpl *keyEvent = dynamic_cast<KeyboardEventImpl*>(impl);
+    if (keyEvent) {
+#if APPLE_CHANGES
+        if (impl->id() == EventImpl::KHTML_KEYDOWN_EVENT || impl->id() == EventImpl::KHTML_KEYUP_EVENT) {
+            return keyEvent->qKeyEvent()->WindowsKeyCode();
+        }
+#endif
+        return keyEvent->qKeyEvent()->ascii();
+    }
 
     // For khtml, the return values for left, middle and right mouse buttons are 0, 1, 2, respectively.
     // For the Netscape "which" property, the return values for left, middle and right mouse buttons are 1, 2, 3, respectively. 
@@ -599,3 +611,120 @@ void MutationEvent::initMutationEvent(co
 }
 
 
+// -----------------------------------------------------------------------------
+
+KeyboardEvent::KeyboardEvent()
+{
+}
+
+KeyboardEvent::KeyboardEvent(const KeyboardEvent &other) : UIEvent(other)
+{
+}
+
+KeyboardEvent::KeyboardEvent(const Event &other)
+{
+    *this = other;
+}
+
+KeyboardEvent::KeyboardEvent(KeyboardEventImpl *impl) : UIEvent(impl)
+{
+}
+
+KeyboardEvent &KeyboardEvent::operator = (const KeyboardEvent &other)
+{
+    UIEvent::operator = (other);
+    return *this;
+}
+
+KeyboardEvent &KeyboardEvent::operator = (const Event &other)
+{
+    Event e;
+    e = other;
+    if (!e.isNull() && !e.handle()->isKeyboardEvent()) {
+	if ( impl ) impl->deref();
+	impl = 0;
+    } else
+	UIEvent::operator = (other);
+    return *this;
+}
+
+KeyboardEvent::~KeyboardEvent()
+{
+}
+
+DOMString KeyboardEvent::keyIdentifier() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->keyIdentifier();
+}
+
+unsigned long KeyboardEvent::keyLocation() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->keyLocation();
+}
+
+bool KeyboardEvent::ctrlKey() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->ctrlKey();
+}
+
+bool KeyboardEvent::shiftKey() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->shiftKey();
+}
+
+bool KeyboardEvent::altKey() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->altKey();
+}
+
+bool KeyboardEvent::metaKey() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->metaKey();
+}
+
+bool KeyboardEvent::altGraphKey() const
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    return static_cast<KeyboardEventImpl*>(impl)->altGraphKey();
+}
+
+void KeyboardEvent::initKeyboardEvent(const DOMString &typeArg, 
+                                        bool canBubbleArg,
+                                        bool cancelableArg,
+                                        const AbstractView &viewArg, 
+                                        const DOMString &keyIdentifierArg, 
+                                        unsigned long keyLocationArg, 
+                                        bool ctrlKeyArg, 
+                                        bool shiftKeyArg, 
+                                        bool altKeyArg, 
+                                        bool metaKeyArg, 
+                                        bool altGraphKeyArg)
+{
+    if (!impl)
+	throw DOMException(DOMException::INVALID_STATE_ERR);
+
+    static_cast<KeyboardEventImpl*>(impl)->initKeyboardEvent(typeArg,canBubbleArg,
+	cancelableArg,viewArg,keyIdentifierArg,keyLocationArg,ctrlKeyArg,altKeyArg,
+        shiftKeyArg,metaKeyArg,altGraphKeyArg);
+}
+                                    
Index: khtml/dom/dom2_events.h
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/dom/dom2_events.h,v
retrieving revision 1.10
diff -u -p -r1.10 khtml/dom/dom2_events.h
--- khtml/dom/dom2_events.h	2003/04/02 00:46:02	1.10
+++ khtml/dom/dom2_events.h	2003/11/16 05:27:41
@@ -34,6 +34,7 @@ class EventException;
 class UIEvent;
 class MouseEvent;
 class MutationEvent;
+class KeyboardEvent;
 class AbstractView;
 
 class EventListenerImpl;
@@ -41,6 +42,7 @@ class EventImpl;
 class UIEventImpl;
 class MouseEventImpl;
 class MutationEventImpl;
+class KeyboardEventImpl;
 
 
 
@@ -660,6 +662,93 @@ protected:
 };
 
 
+/**
+ * Introduced in DOM Level 3
+ *
+ * The KeyboardEvent interface provides specific contextual information
+ * associated with Keyboard events.
+ *
+ */
+class KeyboardEvent : public UIEvent {
+public:
+    KeyboardEvent();
+    KeyboardEvent(const KeyboardEvent &other);
+    KeyboardEvent(const Event &other);
+    KeyboardEvent & operator = (const KeyboardEvent &other);
+    KeyboardEvent & operator = (const Event &other);
+    virtual ~KeyboardEvent();
+
+    // KeyLocationCode
+    static const unsigned long DOM_KEY_LOCATION_STANDARD      = 0x00;
+    static const unsigned long DOM_KEY_LOCATION_LEFT          = 0x01;
+    static const unsigned long DOM_KEY_LOCATION_RIGHT         = 0x02;
+    static const unsigned long DOM_KEY_LOCATION_NUMPAD        = 0x03;
+    static const unsigned long DOM_KEY_LOCATION_UNKNOWN       = 0x04;
+    
+    /**
+     * Holds the identifier of the key.
+     *
+     */
+    DOMString keyIdentifier() const;
+
+    /**
+     * Contains an indication of the location of they key on the device.
+     *
+     */
+    unsigned long keyLocation() const;
+
+    /**
+     * Used to indicate whether the 'ctrl' key was depressed during the firing
+     * of the event.
+     */
+    bool ctrlKey() const;
+
+    /**
+     * Used to indicate whether the 'shift' key was depressed during the firing
+     * of the event.
+     *
+     */
+    bool shiftKey() const;
+
+    /**
+     * Used to indicate whether the 'alt' key was depressed during the firing
+     * of the event. On some platforms this key may map to an alternative key
+     * name.
+     *
+     */
+    bool altKey() const;
+
+    /**
+     * Used to indicate whether the 'meta' key was depressed during the firing
+     * of the event. On some platforms this key may map to an alternative key
+     * name.
+     *
+     */
+    bool metaKey() const;
+
+    /**
+     * Used to indicate whether the 'alt graph' (?) key was depressed during the firing
+     * of the event. On some platforms this key may map to an alternative key
+     * name.
+     *
+     */
+    bool altGraphKey() const;
+
+    void initKeyboardEvent(const DOMString &typeArg, 
+                                bool canBubbleArg,
+                                bool cancelableArg,
+                                const AbstractView &viewArg, 
+                                const DOMString &keyIdentifierArg, 
+                                unsigned long keyLocationArg, 
+                                bool ctrlKeyArg, 
+                                bool shiftKeyArg, 
+                                bool altKeyArg, 
+                                bool metaKeyArg, 
+                                bool altGraphKeyArg);
+                                       
+protected:
+    KeyboardEvent(KeyboardEventImpl *impl);
+};
 
 }; //namespace
 #endif
Index: khtml/ecma/kjs_events.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/ecma/kjs_events.cpp,v
retrieving revision 1.17
diff -u -p -r1.17 khtml/ecma/kjs_events.cpp
--- khtml/ecma/kjs_events.cpp	2003/05/13 21:19:56	1.17
+++ khtml/ecma/kjs_events.cpp	2003/11/16 05:27:41
@@ -33,6 +33,8 @@
 
 using namespace KJS;
 
+using DOM::KeyboardEvent;
+
 // -------------------------------------------------------------------------
 
 JSEventListener::JSEventListener(Object _listener, const Object &_win, bool _html)
@@ -303,7 +305,9 @@ Value KJS::getDOMEvent(ExecState *exec, 
     return Value(ret);
 
   DOM::DOMString module = e.eventModuleName();
-  if (module == "UIEvents")
+  if (e.handle()->isKeyboardEvent())
+    ret = new DOMKeyboardEvent(exec, static_cast<DOM::KeyboardEvent>(e));
+  else if (module == "UIEvents")
     ret = new DOMUIEvent(exec, static_cast<DOM::UIEvent>(e));
   else if (module == "MouseEvents")
     ret = new DOMMouseEvent(exec, static_cast<DOM::MouseEvent>(e));
@@ -563,6 +567,94 @@ Value DOMMouseEventProtoFunc::tryCall(Ex
                                 args[12].toBoolean(exec), // metaKeyArg
                                 args[13].toInteger(exec), // buttonArg
                                 toNode(args[14])); // relatedTargetArg
+      return Undefined();
+  }
+  return Undefined();
+}
+
+// -------------------------------------------------------------------------
+
+const ClassInfo DOMKeyboardEvent::info = { "KeyboardEvent", &DOMUIEvent::info, &DOMKeyboardEventTable, 0 };
+
+/*
+@begin DOMKeyboardEventTable 5
+  keyIdentifier	DOMKeyboardEvent::KeyIdentifier	DontDelete|ReadOnly
+  keyLocation	DOMKeyboardEvent::KeyLocation	DontDelete|ReadOnly
+  ctrlKey	DOMKeyboardEvent::CtrlKey	DontDelete|ReadOnly
+  shiftKey	DOMKeyboardEvent::ShiftKey	DontDelete|ReadOnly
+  altKey	DOMKeyboardEvent::AltKey	DontDelete|ReadOnly
+  metaKey	DOMKeyboardEvent::MetaKey	DontDelete|ReadOnly
+  altGraphKey	DOMKeyboardEvent::AltGraphKey	DontDelete|ReadOnly
+@end
+@begin DOMKeyboardEventProtoTable 1
+  initKeyboardEvent	DOMKeyboardEvent::InitKeyboardEvent	DontDelete|Function 11
+@end
+*/
+DEFINE_PROTOTYPE("DOMKeyboardEvent", DOMKeyboardEventProto)
+IMPLEMENT_PROTOFUNC(DOMKeyboardEventProtoFunc)
+IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMKeyboardEventProto, DOMKeyboardEventProtoFunc, DOMUIEventProto)
+
+DOMKeyboardEvent::~DOMKeyboardEvent()
+{
+}
+
+const ClassInfo* DOMKeyboardEvent::classInfo() const
+{
+    return &info;
+}
+
+Value DOMKeyboardEvent::tryGet(ExecState *exec, const Identifier &p) const
+{
+#ifdef KJS_VERBOSE
+  kdDebug(6070) << "DOMKeyboardEvent::tryGet " << p.qstring() << endl;
+#endif
+  return DOMObjectLookupGetValue<DOMKeyboardEvent, DOMUIEvent>(exec, p, &DOMKeyboardEventTable, this);
+}
+
+Value DOMKeyboardEvent::getValueProperty(ExecState *exec, int token) const
+{
+  switch (token) {
+  case KeyIdentifier:
+    return String(static_cast<KeyboardEvent>(event).keyIdentifier());
+  case KeyLocation:
+    return Number(static_cast<KeyboardEvent>(event).keyLocation());
+  case CtrlKey:
+    return Boolean(static_cast<KeyboardEvent>(event).ctrlKey());
+  case ShiftKey:
+    return Boolean(static_cast<KeyboardEvent>(event).shiftKey());
+  case AltKey:
+    return Boolean(static_cast<KeyboardEvent>(event).altKey());
+  case MetaKey:
+    return Boolean(static_cast<KeyboardEvent>(event).metaKey());
+  case AltGraphKey:
+    return Boolean(static_cast<KeyboardEvent>(event).altGraphKey());
+  default:
+    kdWarning() << "Unhandled token in DOMKeyboardEvent::getValueProperty : " << token << endl;
+    return Value();
+  }
+}
+
+Value DOMKeyboardEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
+{
+  if (!thisObj.inherits(&DOMKeyboardEvent::info)) {
+    Object err = Error::create(exec,TypeError);
+    exec->setException(err);
+    return err;
+  }
+  KeyboardEvent event = static_cast<DOMKeyboardEvent *>(thisObj.imp())->toKeyboardEvent();
+  switch (id) {
+    case DOMKeyboardEvent::InitKeyboardEvent:
+      event.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(), // keyIdentifier
+                              args[5].toInteger(exec), // keyLocationArg
+                              args[6].toBoolean(exec), // ctrlKeyArg
+                              args[7].toBoolean(exec), // altKeyArg
+                              args[8].toBoolean(exec), // shiftKeyArg
+                              args[9].toBoolean(exec), // metaKeyArg
+                              args[10].toBoolean(exec)); // altGraphKeyArg
       return Undefined();
   }
   return Undefined();
Index: khtml/ecma/kjs_events.h
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/ecma/kjs_events.h,v
retrieving revision 1.12
diff -u -p -r1.12 khtml/ecma/kjs_events.h
--- khtml/ecma/kjs_events.h	2003/04/02 00:46:02	1.12
+++ khtml/ecma/kjs_events.h	2003/11/16 05:27:41
@@ -128,6 +128,19 @@ namespace KJS {
     DOM::MouseEvent toMouseEvent() const { return static_cast<DOM::MouseEvent>(event); }
   };
 
+  class DOMKeyboardEvent : public DOMUIEvent {
+  public:
+    DOMKeyboardEvent(ExecState *exec, DOM::KeyboardEvent ke) : DOMUIEvent(exec, 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;
+    static const ClassInfo info;
+    enum { KeyIdentifier, KeyLocation, CtrlKey, ShiftKey, AltKey, MetaKey, AltGraphKey, InitKeyboardEvent};
+    DOM::KeyboardEvent toKeyboardEvent() const { return event; }
+  };
+
   // Constructor object MutationEvent
   class MutationEventConstructor : public DOMObject {
   public:
Index: khtml/ecma/kjs_events.lut.h
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/ecma/kjs_events.lut.h,v
retrieving revision 1.5
diff -u -p -r1.5 khtml/ecma/kjs_events.lut.h
--- khtml/ecma/kjs_events.lut.h	2002/12/15 01:48:23	1.5
+++ khtml/ecma/kjs_events.lut.h	2003/11/16 05:27:41
@@ -26,7 +26,7 @@ const struct HashEntry EventConstructorT
 
 const struct HashTable EventConstructorTable = { 2, 19, EventConstructorTableEntries, 3 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -47,7 +47,7 @@ const struct HashEntry DOMEventTableEntr
 
 const struct HashTable DOMEventTable = { 2, 12, DOMEventTableEntries, 7 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -61,7 +61,7 @@ const struct HashEntry DOMEventProtoTabl
 
 const struct HashTable DOMEventProtoTable = { 2, 5, DOMEventProtoTableEntries, 3 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -71,7 +71,7 @@ const struct HashEntry EventExceptionCon
 
 const struct HashTable EventExceptionConstructorTable = { 2, 1, EventExceptionConstructorTableEntries, 1 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -92,7 +92,7 @@ const struct HashEntry DOMUIEventTableEn
 
 const struct HashTable DOMUIEventTable = { 2, 12, DOMUIEventTableEntries, 8 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -102,7 +102,7 @@ const struct HashEntry DOMUIEventProtoTa
 
 const struct HashTable DOMUIEventProtoTable = { 2, 1, DOMUIEventProtoTableEntries, 1 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -127,7 +127,7 @@ const struct HashEntry DOMMouseEventTabl
 
 const struct HashTable DOMMouseEventTable = { 2, 16, DOMMouseEventTableEntries, 2 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -137,10 +137,37 @@ const struct HashEntry DOMMouseEventProt
 
 const struct HashTable DOMMouseEventProtoTable = { 2, 1, DOMMouseEventProtoTableEntries, 1 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
+const struct HashEntry DOMKeyboardEventTableEntries[] = {
+   { "metaKey", DOMKeyboardEvent::MetaKey, DontDelete|ReadOnly, 0, 0 },
+   { "keyIdentifier", DOMKeyboardEvent::KeyIdentifier, DontDelete|ReadOnly, 0, &DOMKeyboardEventTableEntries[7] },
+   { 0, 0, 0, 0, 0 },
+   { "altKey", DOMKeyboardEvent::AltKey, DontDelete|ReadOnly, 0, 0 },
+   { "keyLocation", DOMKeyboardEvent::KeyLocation, DontDelete|ReadOnly, 0, &DOMKeyboardEventTableEntries[5] },
+   { "ctrlKey", DOMKeyboardEvent::CtrlKey, DontDelete|ReadOnly, 0, &DOMKeyboardEventTableEntries[6] },
+   { "shiftKey", DOMKeyboardEvent::ShiftKey, DontDelete|ReadOnly, 0, 0 },
+   { "altGraphKey", DOMKeyboardEvent::AltGraphKey, DontDelete|ReadOnly, 0, 0 }
+};
+
+const struct HashTable DOMKeyboardEventTable = { 2, 8, DOMKeyboardEventTableEntries, 5 };
+
+} // namespace
+
+namespace KJS {
+
+const struct HashEntry DOMKeyboardEventProtoTableEntries[] = {
+   { "initKeyboardEvent", DOMKeyboardEvent::InitKeyboardEvent, DontDelete|Function, 11, 0 }
+};
+
+const struct HashTable DOMKeyboardEventProtoTable = { 2, 1, DOMKeyboardEventProtoTableEntries, 1 };
+
+} // namespace
+
+namespace KJS {
+
 const struct HashEntry MutationEventConstructorTableEntries[] = {
    { "ADDITION", DOM::MutationEvent::ADDITION, DontDelete|ReadOnly, 0, &MutationEventConstructorTableEntries[3] },
    { "MODIFICATION", DOM::MutationEvent::MODIFICATION, DontDelete|ReadOnly, 0, 0 },
@@ -150,7 +177,7 @@ const struct HashEntry MutationEventCons
 
 const struct HashTable MutationEventConstructorTable = { 2, 4, MutationEventConstructorTableEntries, 3 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -165,7 +192,7 @@ const struct HashEntry DOMMutationEventT
 
 const struct HashTable DOMMutationEventTable = { 2, 6, DOMMutationEventTableEntries, 5 };
 
-}; // namespace
+} // namespace
 
 namespace KJS {
 
@@ -175,4 +202,4 @@ const struct HashEntry DOMMutationEventP
 
 const struct HashTable DOMMutationEventProtoTable = { 2, 1, DOMMutationEventProtoTableEntries, 1 };
 
-}; // namespace
+} // namespace
Index: khtml/html/html_formimpl.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/html/html_formimpl.cpp,v
retrieving revision 1.71
diff -u -p -r1.71 khtml/html/html_formimpl.cpp
--- khtml/html/html_formimpl.cpp	2003/08/26 23:13:37	1.71
+++ khtml/html/html_formimpl.cpp	2003/11/16 05:27:42
@@ -856,7 +856,7 @@ void HTMLGenericFormElementImpl::default
 	if (evt->id()==EventImpl::KHTML_KEYDOWN_EVENT ||
 	    evt->id()==EventImpl::KHTML_KEYUP_EVENT)
 	{
-	    KeyEventImpl * k = static_cast<KeyEventImpl *>(evt);
+	    KeyboardEventImpl * k = static_cast<KeyboardEventImpl *>(evt);
 	    if (k->keyVal() == QChar('\n').unicode() && m_render && m_render->isWidget() && k->qKeyEvent)
 		QApplication::sendEvent(static_cast<RenderWidget *>(m_render)->widget(), k->qKeyEvent);
 	}
Index: khtml/html/html_inlineimpl.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/html/html_inlineimpl.cpp,v
retrieving revision 1.17
diff -u -p -r1.17 khtml/html/html_inlineimpl.cpp
--- khtml/html/html_inlineimpl.cpp	2003/07/24 22:07:45	1.17
+++ khtml/html/html_inlineimpl.cpp	2003/11/16 05:27:42
@@ -61,7 +61,7 @@ NodeImpl::Id HTMLAnchorElementImpl::id()
 void HTMLAnchorElementImpl::defaultEventHandler(EventImpl *evt)
 {
     // React on clicks and on keypresses.
-    // Don't make this KEYUP_EVENT again, it makes khtml follow links it shouldn't,
+    // Don't make this KHTML_KEYUP_EVENT again, it makes khtml follow links it shouldn't,
     // when pressing Enter in the combo.
     if ( ( evt->id() == EventImpl::KHTML_CLICK_EVENT ||
          ( evt->id() == EventImpl::KHTML_KEYDOWN_EVENT && m_focused)) && m_hasAnchor) {
@@ -69,9 +69,9 @@ void HTMLAnchorElementImpl::defaultEvent
         if ( evt->id() == EventImpl::KHTML_CLICK_EVENT )
             e = static_cast<MouseEventImpl*>( evt );
 
-        KeyEventImpl *k = 0;
+        KeyboardEventImpl *k = 0;
         if (evt->id() == EventImpl::KHTML_KEYDOWN_EVENT)
-            k = static_cast<KeyEventImpl *>( evt );
+            k = static_cast<KeyboardEventImpl *>( evt );
 
         QString utarget;
         QString url;
@@ -82,11 +82,11 @@ void HTMLAnchorElementImpl::defaultEvent
         }
 
         if ( k ) {
-            if (k->virtKeyVal() != KeyEventImpl::DOM_VK_ENTER) {
+            if (k->keyIdentifier() != "Enter") {
                 HTMLElementImpl::defaultEventHandler(evt);
                 return;
             }
-            if (k->qKeyEvent) k->qKeyEvent->accept();
+            if (k->qKeyEvent()) k->qKeyEvent()->accept();
         }
 
         url = khtml::parseURL(getAttribute(ATTR_HREF)).string();
@@ -138,11 +138,11 @@ void HTMLAnchorElementImpl::defaultEvent
             }
 	    else if ( k )
 	    {
-	      if ( k->checkModifier(Qt::ShiftButton) )
+	      if ( k->shiftKey() )
                 state |= Qt::ShiftButton;
-	      if ( k->checkModifier(Qt::AltButton) )
+	      if ( k->altKey() )
                 state |= Qt::AltButton;
-	      if ( k->checkModifier(Qt::ControlButton) )
+	      if ( k->ctrlKey() )
                 state |= Qt::ControlButton;
 	    }
 
Index: khtml/rendering/render_form.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/rendering/render_form.cpp,v
retrieving revision 1.59
diff -u -p -r1.59 khtml/rendering/render_form.cpp
--- khtml/rendering/render_form.cpp	2003/08/27 20:53:13	1.59
+++ khtml/rendering/render_form.cpp	2003/11/16 05:27:42
@@ -898,6 +898,7 @@ bool ComboBoxWidget::event(QEvent *e)
 
 bool ComboBoxWidget::eventFilter(QObject *dest, QEvent *e)
 {
+#if !APPLE_CHANGES
     if (dest==listBox() &&  e->type()==QEvent::KeyPress)
     {
 	QKeyEvent *ke = static_cast<QKeyEvent *>(e);
@@ -918,6 +919,7 @@ bool ComboBoxWidget::eventFilter(QObject
 	    return KComboBox::eventFilter(dest, e);
 	}
     }
+#endif
     return KComboBox::eventFilter(dest, e);
 }
 
Index: khtml/xml/dom2_eventsimpl.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/xml/dom2_eventsimpl.cpp,v
retrieving revision 1.11
diff -u -p -r1.11 khtml/xml/dom2_eventsimpl.cpp
--- khtml/xml/dom2_eventsimpl.cpp	2003/08/18 21:12:40	1.11
+++ khtml/xml/dom2_eventsimpl.cpp	2003/11/16 05:27:42
@@ -221,6 +221,12 @@ EventImpl::EventId EventImpl::typeToId(D
 	return SCROLL_EVENT;
     else if (type == "contextmenu")
 	return CONTEXTMENU_EVENT;
+    else if (type == "keydown")
+	return KHTML_KEYDOWN_EVENT;
+    else if (type == "keyup")
+	return KHTML_KEYUP_EVENT;
+    else if (type == "textInput")
+	return TEXTINPUT_EVENT;
     // ignore: KHTML_DBLCLICK_EVENT
     // ignore: KHTML_CLICK_EVENT
     return UNKNOWN_EVENT;
@@ -287,6 +293,12 @@ DOMString EventImpl::idToType(EventImpl:
 	    return "scroll";
         case CONTEXTMENU_EVENT:
             return "contextmenu";
+	case KHTML_KEYDOWN_EVENT:
+            return "keydown";
+	case KHTML_KEYUP_EVENT:
+            return "keyup";
+	case TEXTINPUT_EVENT:
+            return "textInput";
 	// khtml extensions
 	case KHTML_DBLCLICK_EVENT:
             return "dblclick";
@@ -296,12 +308,8 @@ DOMString EventImpl::idToType(EventImpl:
             return "khtml_dragdrop";
 	case KHTML_ERROR_EVENT:
             return "khtml_error";
-	case KHTML_KEYDOWN_EVENT:
-            return "khtml_keydown";
 	case KHTML_KEYPRESS_EVENT:
             return "khtml_keypress";
-	case KHTML_KEYUP_EVENT:
-            return "khtml_keyup";
 	case KHTML_MOVE_EVENT:
             return "khtml_move";
         case KHTML_ORIGCLICK_MOUSEUP_EVENT:
@@ -550,267 +558,111 @@ void MouseEventImpl::initMouseEvent(cons
 }
 
 //---------------------------------------------------------------------------------------------
-
 
-KeyEventImpl::KeyEventImpl()
+KeyboardEventImpl::KeyboardEventImpl()
 {
-  qKeyEvent = 0;
+  m_keyEvent = 0;
 }
 
-KeyEventImpl::KeyEventImpl(QKeyEvent *key, AbstractViewImpl *view)
+KeyboardEventImpl::KeyboardEventImpl(QKeyEvent *key, AbstractViewImpl *view)
   : UIEventImpl(key->type() == QEvent::KeyRelease ? KHTML_KEYUP_EVENT : key->isAutoRepeat() ? KHTML_KEYPRESS_EVENT : KHTML_KEYDOWN_EVENT,
                 true,true,view,0)
 {
-  qKeyEvent = new QKeyEvent(key->type(), key->key(), key->ascii(), key->state(), key->text(), key->isAutoRepeat(), key->count() );
-  // Events are supposed to be accepted by default in Qt!
-  // This line made QLineEdit's keyevents be ignored, so they were sent to the khtmlview
-  // (and e.g. space would make it scroll down)
-  //qKeyEvent->ignore();
-
-  m_detail = key->count();
-
-  m_numPad = false;
-  m_keyVal = 0;
-  m_virtKeyVal = DOM_VK_UNDEFINED;
-  m_inputGenerated = true;
-
-  switch(key->key())
-  {
-  case Qt::Key_Enter:
-      m_numPad = true;
-      /* fall through */
-  case Qt::Key_Return:
-      m_virtKeyVal = DOM_VK_ENTER;
-      break;
-  case Qt::Key_NumLock:
-      m_numPad = true;
-      m_virtKeyVal = DOM_VK_NUM_LOCK;
-      break;
-  case Qt::Key_Alt:
-      m_virtKeyVal = DOM_VK_RIGHT_ALT;
-      // ### DOM_VK_LEFT_ALT;
-      break;
-  case Qt::Key_Control:
-      m_virtKeyVal = DOM_VK_LEFT_CONTROL;
-      // ### DOM_VK_RIGHT_CONTROL
-      break;
-  case Qt::Key_Shift:
-      m_virtKeyVal = DOM_VK_LEFT_SHIFT;
-      // ### DOM_VK_RIGHT_SHIFT
-      break;
-  case Qt::Key_Meta:
-      m_virtKeyVal = DOM_VK_LEFT_META;
-      // ### DOM_VK_RIGHT_META
-      break;
-  case Qt::Key_CapsLock:
-      m_virtKeyVal = DOM_VK_CAPS_LOCK;
-      break;
-  case Qt::Key_Delete:
-      m_virtKeyVal = DOM_VK_DELETE;
-      break;
-  case Qt::Key_End:
-      m_virtKeyVal = DOM_VK_END;
-      break;
-  case Qt::Key_Escape:
-      m_virtKeyVal = DOM_VK_ESCAPE;
-      break;
-  case Qt::Key_Home:
-      m_virtKeyVal = DOM_VK_HOME;
-      break;
-  case Qt::Key_Insert:
-      m_virtKeyVal = DOM_VK_INSERT;
-      break;
-  case Qt::Key_Pause:
-      m_virtKeyVal = DOM_VK_PAUSE;
-      break;
-  case Qt::Key_Print:
-      m_virtKeyVal = DOM_VK_PRINTSCREEN;
-      break;
-  case Qt::Key_ScrollLock:
-      m_virtKeyVal = DOM_VK_SCROLL_LOCK;
-      break;
-  case Qt::Key_Left:
-      m_virtKeyVal = DOM_VK_LEFT;
-      break;
-  case Qt::Key_Right:
-      m_virtKeyVal = DOM_VK_RIGHT;
-      break;
-  case Qt::Key_Up:
-      m_virtKeyVal = DOM_VK_UP;
-      break;
-  case Qt::Key_Down:
-      m_virtKeyVal = DOM_VK_DOWN;
-      break;
-  case Qt::Key_Next:
-      m_virtKeyVal = DOM_VK_PAGE_DOWN;
-      break;
-  case Qt::Key_Prior:
-      m_virtKeyVal = DOM_VK_PAGE_UP;
-      break;
-  case Qt::Key_F1:
-      m_virtKeyVal = DOM_VK_F1;
-      break;
-  case Qt::Key_F2:
-      m_virtKeyVal = DOM_VK_F2;
-      break;
-  case Qt::Key_F3:
-      m_virtKeyVal = DOM_VK_F3;
-      break;
-  case Qt::Key_F4:
-      m_virtKeyVal = DOM_VK_F4;
-      break;
-  case Qt::Key_F5:
-      m_virtKeyVal = DOM_VK_F5;
-      break;
-  case Qt::Key_F6:
-      m_virtKeyVal = DOM_VK_F6;
-      break;
-  case Qt::Key_F7:
-      m_virtKeyVal = DOM_VK_F7;
-      break;
-  case Qt::Key_F8:
-      m_virtKeyVal = DOM_VK_F8;
-      break;
-  case Qt::Key_F9:
-      m_virtKeyVal = DOM_VK_F9;
-      break;
-  case Qt::Key_F10:
-      m_virtKeyVal = DOM_VK_F10;
-      break;
-  case Qt::Key_F11:
-      m_virtKeyVal = DOM_VK_F11;
-      break;
-  case Qt::Key_F12:
-      m_virtKeyVal = DOM_VK_F12;
-      break;
-  case Qt::Key_F13:
-      m_virtKeyVal = DOM_VK_F13;
-      break;
-  case Qt::Key_F14:
-      m_virtKeyVal = DOM_VK_F14;
-      break;
-  case Qt::Key_F15:
-      m_virtKeyVal = DOM_VK_F15;
-      break;
-  case Qt::Key_F16:
-      m_virtKeyVal = DOM_VK_F16;
-      break;
-  case Qt::Key_F17:
-      m_virtKeyVal = DOM_VK_F17;
-      break;
-  case Qt::Key_F18:
-      m_virtKeyVal = DOM_VK_F18;
-      break;
-  case Qt::Key_F19:
-      m_virtKeyVal = DOM_VK_F19;
-      break;
-  case Qt::Key_F20:
-      m_virtKeyVal = DOM_VK_F20;
-      break;
-  case Qt::Key_F21:
-      m_virtKeyVal = DOM_VK_F21;
-      break;
-  case Qt::Key_F22:
-      m_virtKeyVal = DOM_VK_F22;
-      break;
-  case Qt::Key_F23:
-      m_virtKeyVal = DOM_VK_F23;
-      break;
-  case Qt::Key_F24:
-      m_virtKeyVal = DOM_VK_F24;
-      break;
-  default:
-      m_virtKeyVal = DOM_VK_UNDEFINED;
-      break;
-  }
-
-  // m_keyVal should contain the unicode value
-  // of the pressed key if available.
-  if (m_virtKeyVal == DOM_VK_UNDEFINED && !key->text().isNull())
-      m_keyVal = key->text().unicode()[0];
-
-  //  m_numPad = ???
-
-  // key->state returns enum ButtonState, which is ShiftButton, ControlButton and AltButton or'ed together.
-  m_modifier = key->state();
-
-  // key->text() returns the unicode sequence as a QString
-  m_outputString = DOMString(key->text());
-}
-
-KeyEventImpl::KeyEventImpl(EventId _id,
-			   bool canBubbleArg,
-			   bool cancelableArg,
-			   AbstractViewImpl *viewArg,
-			   unsigned short detailArg,
-			   DOMString &outputStringArg,
-			   unsigned long keyValArg,
-			   unsigned long virtKeyValArg,
-			   bool inputGeneratedArg,
-			   bool numPadArg)
-  : UIEventImpl(_id,canBubbleArg,cancelableArg,viewArg,detailArg)
-{
-  qKeyEvent = 0;
-  m_keyVal = keyValArg;
-  m_virtKeyVal = virtKeyValArg;
-  m_inputGenerated = inputGeneratedArg;
-  m_outputString = outputStringArg;
-  m_numPad = numPadArg;
-  m_modifier = 0;
-}
-
-KeyEventImpl::~KeyEventImpl()
-{
-    delete qKeyEvent;
-}
-
-bool KeyEventImpl::checkModifier(unsigned long modifierArg)
-{
-  return ((m_modifier && modifierArg) == modifierArg);
-}
-
-void KeyEventImpl::initKeyEvent(DOMString &typeArg,
-				bool canBubbleArg,
-				bool cancelableArg,
-				const AbstractView &viewArg,
-				long detailArg,
-				DOMString &outputStringArg,
-				unsigned long keyValArg,
-				unsigned long virtKeyValArg,
-				bool inputGeneratedArg,
-				bool numPadArg)
-{
-  UIEventImpl::initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
-
-  m_outputString = outputStringArg;
-  m_keyVal = keyValArg;
-  m_virtKeyVal = virtKeyValArg;
-  m_inputGenerated = inputGeneratedArg;
-  m_numPad = numPadArg;
-}
-
-void KeyEventImpl::initModifier(unsigned long modifierArg,
-				bool valueArg)
-{
-  if (valueArg)
-      m_modifier |= modifierArg;
-  else
-      m_modifier &= (modifierArg ^ 0xFFFFFFFF);
-}
-
-bool             KeyEventImpl::inputGenerated() const
-{
-  return m_inputGenerated;
+#if APPLE_CHANGES
+    m_keyEvent = new QKeyEvent(*key);
+#else
+    m_keyEvent = new QKeyEvent(key->type(), key->key(), key->ascii(), key->state(), key->text(), key->isAutoRepeat(), key->count());
+#endif
+    // Events are supposed to be accepted by default in Qt!
+    // This line made QLineEdit's keyevents be ignored, so they were sent to the khtmlview
+    // (and e.g. space would make it scroll down)
+    //qKeyEvent->ignore();
+
+    // m_keyIdentifier should contain the unicode value of the pressed key if available.
+    // key->text() returns the unicode sequence as a QString
+    if (!key->text().isNull()) {
+        DOMString identifier(m_keyEvent->identifier());
+        m_keyIdentifier = identifier.implementation();
+        m_keyIdentifier->ref();
+    }
+    else {
+        m_keyIdentifier = DOMString("Unidentified").implementation();
+        m_keyIdentifier->ref();
+    }
+
+    // key->state returns enum ButtonState, which is ShiftButton, ControlButton and AltButton or'ed together.
+    int keyState = key->state();
+    if (keyState & Qt::ControlButton)
+        m_ctrlKey = true;
+    if (keyState & Qt::ShiftButton)
+        m_shiftKey = true;
+    if (keyState & Qt::AltButton)
+        m_altKey = true;
+    if (keyState & Qt::MetaButton)
+        m_metaKey = true;
+    // altGraphKey is not supported by Qt.
+    
+    // Note: we only support testing for num pad
+    m_keyLocation = (keyState & Qt::Keypad) ? KeyboardEvent::DOM_KEY_LOCATION_NUMPAD : KeyboardEvent::DOM_KEY_LOCATION_STANDARD;
 }
 
-unsigned long    KeyEventImpl::keyVal() const
-{
-  return m_keyVal;
+KeyboardEventImpl::KeyboardEventImpl(EventId _id,
+                                        bool canBubbleArg,
+                                        bool cancelableArg,
+                                        AbstractViewImpl *viewArg, 
+                                        const DOMString &keyIdentifierArg, 
+                                        unsigned long keyLocationArg, 
+                                        bool ctrlKeyArg, 
+                                        bool shiftKeyArg, 
+                                        bool altKeyArg, 
+                                        bool metaKeyArg, 
+                                        bool altGraphKeyArg)
+  : UIEventImpl(_id,canBubbleArg,cancelableArg,viewArg,0)
+{
+    m_keyEvent = 0;
+    m_keyIdentifier = keyIdentifierArg.implementation();
+    if (m_keyIdentifier)
+        m_keyIdentifier->ref();
+    m_keyLocation = keyLocationArg;
+    m_ctrlKey = ctrlKeyArg;
+    m_shiftKey = shiftKeyArg;
+    m_altKey = altKeyArg;
+    m_metaKey = metaKeyArg;
+    m_altGraphKey = altGraphKeyArg;
 }
 
-DOMString        KeyEventImpl::outputString() const
+KeyboardEventImpl::~KeyboardEventImpl()
 {
-  return m_outputString;
+    delete m_keyEvent;
+    if (m_keyIdentifier)
+        m_keyIdentifier->deref();
+}
+
+void KeyboardEventImpl::initKeyboardEvent(const DOMString &typeArg,
+                        bool canBubbleArg,
+                        bool cancelableArg,
+                        const AbstractView &viewArg, 
+                        const DOMString &keyIdentifierArg, 
+                        unsigned long keyLocationArg, 
+                        bool ctrlKeyArg, 
+                        bool shiftKeyArg, 
+                        bool altKeyArg, 
+                        bool metaKeyArg, 
+                        bool altGraphKeyArg)
+{
+    if (m_keyIdentifier)
+        m_keyIdentifier->deref();
+
+    UIEventImpl::initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 0);
+    m_keyIdentifier = keyIdentifierArg.implementation();
+    if (m_keyIdentifier)
+        m_keyIdentifier->ref();
+    m_keyLocation = keyLocationArg;
+    m_ctrlKey = ctrlKeyArg;
+    m_shiftKey = shiftKeyArg;
+    m_altKey = altKeyArg;
+    m_metaKey = metaKeyArg;
+    m_altGraphKey = altGraphKeyArg;
 }
 
 // -----------------------------------------------------------------------------
Index: khtml/xml/dom2_eventsimpl.h
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/xml/dom2_eventsimpl.h,v
retrieving revision 1.7
diff -u -p -r1.7 khtml/xml/dom2_eventsimpl.h
--- khtml/xml/dom2_eventsimpl.h	2003/08/18 21:12:40	1.7
+++ khtml/xml/dom2_eventsimpl.h	2003/11/16 05:27:42
@@ -78,14 +78,17 @@ public:
 	RESIZE_EVENT,
 	SCROLL_EVENT,
         CONTEXTMENU_EVENT,
+        // Keyboard events
+	KHTML_KEYDOWN_EVENT,
+	KHTML_KEYUP_EVENT,
+        // Text events
+        TEXTINPUT_EVENT,
 	// khtml events (not part of DOM)
 	KHTML_DBLCLICK_EVENT, // for html ondblclick
 	KHTML_CLICK_EVENT, // for html onclick
 	KHTML_DRAGDROP_EVENT,
 	KHTML_ERROR_EVENT,
-	KHTML_KEYDOWN_EVENT,
 	KHTML_KEYPRESS_EVENT,
-	KHTML_KEYUP_EVENT,
 	KHTML_MOVE_EVENT,
 	KHTML_ORIGCLICK_MOUSEUP_EVENT
     };
@@ -113,6 +116,8 @@ public:
     virtual bool isUIEvent() { return false; }
     virtual bool isMouseEvent() { return false; }
     virtual bool isMutationEvent() { return false; }
+    virtual bool isKeyboardEvent() { return false; }
+  
     virtual DOMString eventModuleName() { return ""; }
 
     virtual bool propagationStopped() { return m_propagationStopped; }
@@ -121,7 +126,7 @@ public:
     static EventId typeToId(DOMString type);
     static DOMString idToType(EventId id);
 
-    void setDefaultHandled();
+    virtual void setDefaultHandled();
     bool defaultHandled() const { return m_defaultHandled; }
 
 protected:
@@ -234,270 +239,59 @@ protected:
  private:
     void computeLayerPos();
 };
-
 
-// Introduced in DOM Level 3:
-/**
- * DOM::KeyEvent
- * The detail attribute inherited from UIEvent is used to indicate
- * the number of keypresses which have occurred during key repetition.
- * If this information is not available this value should be 0.
- */
-class KeyEventImpl : public UIEventImpl {
+// Introduced in DOM Level 3
+class KeyboardEventImpl : public UIEventImpl {
 public:
-  KeyEventImpl();
-  KeyEventImpl(EventId _id,
-	       bool canBubbleArg,
-	       bool cancelableArg,
-	       AbstractViewImpl *viewArg,
-	       unsigned short detailArg,
-	       DOMString &outputStringArg,
-	       unsigned long keyValArg,
-	       unsigned long virtKeyValArg,
-	       bool inputGeneratedArg,
-	       bool numPadArg);
-
-  KeyEventImpl(QKeyEvent *key, AbstractViewImpl *view);
-
-  virtual ~KeyEventImpl();
-
-  // VirtualKeyCode
-  enum KeyCodes  {
-         DOM_VK_UNDEFINED               = 0x0,
-         DOM_VK_RIGHT_ALT               = 0x01,
-         DOM_VK_LEFT_ALT                = 0x02,
-         DOM_VK_LEFT_CONTROL            = 0x03,
-         DOM_VK_RIGHT_CONTROL           = 0x04,
-         DOM_VK_LEFT_SHIFT              = 0x05,
-         DOM_VK_RIGHT_SHIFT             = 0x06,
-         DOM_VK_LEFT_META               = 0x07,
-         DOM_VK_RIGHT_META              = 0x08,
-         DOM_VK_CAPS_LOCK               = 0x09,
-         DOM_VK_DELETE                  = 0x0A,
-         DOM_VK_END                     = 0x0B,
-         DOM_VK_ENTER                   = 0x0C,
-         DOM_VK_ESCAPE                  = 0x0D,
-         DOM_VK_HOME                    = 0x0E,
-         DOM_VK_INSERT                  = 0x0F,
-         DOM_VK_NUM_LOCK                = 0x10,
-         DOM_VK_PAUSE                   = 0x11,
-         DOM_VK_PRINTSCREEN             = 0x12,
-         DOM_VK_SCROLL_LOCK             = 0x13,
-         DOM_VK_LEFT                    = 0x14,
-         DOM_VK_RIGHT                   = 0x15,
-         DOM_VK_UP                      = 0x16,
-         DOM_VK_DOWN                    = 0x17,
-         DOM_VK_PAGE_DOWN               = 0x18,
-         DOM_VK_PAGE_UP                 = 0x19,
-         DOM_VK_F1                      = 0x1A,
-         DOM_VK_F2                      = 0x1B,
-         DOM_VK_F3                      = 0x1C,
-         DOM_VK_F4                      = 0x1D,
-         DOM_VK_F5                      = 0x1E,
-         DOM_VK_F6                      = 0x1F,
-         DOM_VK_F7                      = 0x20,
-         DOM_VK_F8                      = 0x21,
-         DOM_VK_F9                      = 0x22,
-         DOM_VK_F10                     = 0x23,
-         DOM_VK_F11                     = 0x24,
-         DOM_VK_F12                     = 0x25,
-         DOM_VK_F13                     = 0x26,
-         DOM_VK_F14                     = 0x27,
-         DOM_VK_F15                     = 0x28,
-         DOM_VK_F16                     = 0x29,
-         DOM_VK_F17                     = 0x2A,
-         DOM_VK_F18                     = 0x2B,
-         DOM_VK_F19                     = 0x2C,
-         DOM_VK_F20                     = 0x2D,
-         DOM_VK_F21                     = 0x2E,
-         DOM_VK_F22                     = 0x2F,
-         DOM_VK_F23                     = 0x30,
-         DOM_VK_F24                     = 0x31
-  };
-
- /**
-  *  checkModifier
-  *
-  * Note: the below description does not match the actual behaviour.
-  *       it's extended in a way that you can query multiple modifiers
-  *       at once by logically OR`ing them.
-  *       also, we use the Qt modifier enum instead of the DOM one.
-  *
-  * The CheckModifier method is used to check the status of a single
-  * modifier key associated with a KeyEvent. The identifier of the
-  * modifier in question is passed into the CheckModifier function. If
-  * the modifier is triggered it will return true. If not, it will
-  * return false.  The list of keys below represents the allowable
-  * modifier paramaters for this method:
-  *     DOM_VK_LEFT_ALT
-  *     DOM_VK_RIGHT_ALT
-  *     DOM_VK_LEFT_CONTROL
-  *     DOM_VK_RIGHT_CONTROL
-  *     DOM_VK_LEFT_SHIFT
-  *     DOM_VK_RIGHT_SHIFT
-  *     DOM_VK_META
-  *
-  * Parameters:
-  *
-  * modifer of type unsigned long
-  *   The modifier which the user wishes to query.
-  *
-  * Return Value: boolean
-  *   The status of the modifier represented as a boolean.
-  *
-  * No Exceptions
-  */
- bool checkModifier(unsigned long modiferArg);
-
- /**
-  * initKeyEvent
-  *
-  * The initKeyEvent method is used to initialize the value of a
-  * MouseEvent created through the DocumentEvent interface. This
-  * method may only be called before the KeyEvent has been dispatched
-  * via the dispatchEvent method, though it may be called multiple
-  * times during that phase if necessary. If called multiple times,
-  * the final invocation takes precedence. This method has no effect
-  * if called after the event has been dispatched.
-  *
-  * Parameters:
-  *
-  * typeArg of type DOMString
-  *   Specifies the event type.
-  * canBubbleArg of type boolean
-  *   Specifies whether or not the event can bubble.
-  * cancelableArg of type boolean
-  *   Specifies whether or not the event's default action can be prevent.
-  * viewArg of type views::AbstractView
-  *   Specifies the KeyEvent's AbstractView.
-  * detailArg of type unsigned short
-  *   Specifies the number of repeated keypresses, if available.
-  * outputStringArg of type DOMString
-  *   Specifies the KeyEvent's outputString attribute
-  * keyValArg of type unsigned long
-  *   Specifies the KeyEvent's keyValattribute
-  * virtKeyValArg of type unsigned long
-  *   Specifies the KeyEvent's virtKeyValattribute
-  * inputGeneratedArg of type boolean
-  *   Specifies the KeyEvent's inputGeneratedattribute
-  * numPadArg of type boolean
-  *   Specifies the KeyEvent's numPadattribute
-  *
-  * No Return Value.
-  * No Exceptions.
-  */
- void initKeyEvent(DOMString &typeArg,
-		   bool canBubbleArg,
-		   bool cancelableArg,
-		   const AbstractView &viewArg,
-		   long detailArg,
-		   DOMString &outputStringArg,
-		   unsigned long keyValArg,
-		   unsigned long virtKeyValArg,
-		   bool inputGeneratedArg,
-		   bool numPadArg);
- /**
-  * initModifier
-  *
-  * The initModifier method is used to initialize the values of any
-  * modifiers associated with a KeyEvent created through the
-  * DocumentEvent interface. This method may only be called before the
-  * KeyEvent has been dispatched via the dispatchEvent method, though
-  * it may be called multiple times during that phase if necessary. If
-  * called multiple times with the same modifier property the final
-  * invocation takes precedence. Unless explicitly give a value of
-  * true, all modifiers have a value of false. This method has no
-  * effect if called after the event has been dispatched.  The list of
-  * keys below represents the allowable modifier paramaters for this
-  * method:
-  *    DOM_VK_LEFT_ALT
-  *    DOM_VK_RIGHT_ALT
-  *    DOM_VK_LEFT_CONTROL
-  *    DOM_VK_RIGHT_CONTROL
-  *    DOM_VK_LEFT_SHIFT
-  *    DOM_VK_RIGHT_SHIFT
-  *    DOM_VK_META
-  *
-  * Parameters:
-  *
-  * modifier of type unsigned long
-  *   The modifier which the user wishes to initialize
-  * value of type boolean
-  *   The new value of the modifier.
-  *
-  * No Return Value
-  * No Exceptions
-  */
- void initModifier(unsigned long modifierArg, bool valueArg);
-
- //Attributes:
-
- /**
-  * inputGenerated of type boolean
-  *
-  *  The inputGenerated attribute indicates whether the key event will
-  *  normally cause visible output. If the key event does not
-  *  generate any visible output, such as the use of a function key
-  *  or the combination of certain modifier keys used in conjunction
-  *  with another key, then the value will be false. If visible
-  *  output is normally generated by the key event then the value
-  *  will be true.  The value of inputGenerated does not guarantee
-  *  the creation of a character. If a key event causing visible
-  *  output is cancelable it may be prevented from causing
-  *  output. This attribute is intended primarily to differentiate
-  *  between keys events which may or may not produce visible output
-  *  depending on the system state.
-  */
- bool             inputGenerated() const;
-
- /** keyVal of type unsigned long
-  *
-  *  The value of keyVal holds the value of the Unicode character
-  *  associated with the depressed key. If the key has no Unicode
-  *  representation or no Unicode character is available the value is
-  *  0.
-  */
- unsigned long    keyVal() const;
-
- /** numPad of type boolean
-  *
-  *  The numPad attribute indicates whether or not the key event was
-  *  generated on the number pad section of the keyboard. If the number
-  *  pad was used to generate the key event the value is true,
-  *  otherwise the value is false.
-  */
-    bool             numPad() const { return m_numPad; }
-
- /**
-  *outputString of type DOMString
-  *
-  *  outputString holds the value of the output generated by the key
-  *  event. This may be a single Unicode character or it may be a
-  *  string. It may also be null in the case where no output was
-  *  generated by the key event.
-  */
- DOMString        outputString() const;
-
- /** virtKeyVal of type unsigned long
-  *
-  *  When the key associated with a key event is not representable via
-  *  a Unicode character virtKeyVale holds the virtual key code
-  *  associated with the depressed key. If the key has a Unicode
-  *  representation or no virtual code is available the value is
-  *  DOM_VK_UNDEFINED.
-  */
-    unsigned long virtKeyVal() const { return m_virtKeyVal; }
-
- QKeyEvent *qKeyEvent;
-
+    KeyboardEventImpl();
+    KeyboardEventImpl(QKeyEvent *key, AbstractViewImpl *view);
+    KeyboardEventImpl(EventId _id,
+                bool canBubbleArg,
+                bool cancelableArg,
+                AbstractViewImpl *viewArg,
+                const DOMString &keyIdentifierArg,
+                unsigned long keyLocationArg,
+                bool ctrlKeyArg,
+                bool shiftKeyArg,
+                bool altKeyArg,
+                bool metaKeyArg,
+                bool altGraphKeyArg);
+    virtual ~KeyboardEventImpl();
+     
+    void initKeyboardEvent(const DOMString &typeArg,
+                bool canBubbleArg,
+                bool cancelableArg,
+                const AbstractView &viewArg,
+                const DOMString &keyIdentifierArg,
+                unsigned long keyLocationArg,
+                bool ctrlKeyArg,
+                bool shiftKeyArg,
+                bool altKeyArg,
+                bool metaKeyArg,
+                bool altGraphKeyArg);
+     
+    DOMString keyIdentifier() const { return m_keyIdentifier; }
+    unsigned long keyLocation() const { return m_keyLocation; }
+     
+    bool ctrlKey() const { return m_ctrlKey; }
+    bool shiftKey() const { return m_shiftKey; }
+    bool altKey() const { return m_altKey; }
+    bool metaKey() const { return m_metaKey; }
+    bool altGraphKey() const { return m_altGraphKey; }
+     
+    QKeyEvent *qKeyEvent() const { return m_keyEvent; }
+     
+    virtual bool isKeyboardEvent() { return true; }
+  
 private:
-  unsigned long m_keyVal;
-  unsigned long m_virtKeyVal;
-  bool m_inputGenerated;
-  DOMString m_outputString;
-  bool m_numPad;
-  // bitfield containing state of modifiers. not part of the dom.
-  unsigned long    m_modifier;
+    QKeyEvent *m_keyEvent;
+    DOMStringImpl *m_keyIdentifier;
+    unsigned long m_keyLocation;
+    bool m_ctrlKey : 1;
+    bool m_shiftKey : 1;
+    bool m_altKey : 1;
+    bool m_metaKey : 1;
+    bool m_altGraphKey : 1;
 };
 
 class MutationEventImpl : public EventImpl {
Index: khtml/xml/dom_docimpl.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/xml/dom_docimpl.cpp,v
retrieving revision 1.75
diff -u -p -r1.75 khtml/xml/dom_docimpl.cpp
--- khtml/xml/dom_docimpl.cpp	2003/07/30 00:39:43	1.75
+++ khtml/xml/dom_docimpl.cpp	2003/11/16 05:27:42
@@ -2113,6 +2113,8 @@ EventImpl *DocumentImpl::createEvent(con
         return new MouseEventImpl();
     else if (eventType == "MutationEvents")
         return new MutationEventImpl();
+    else if (eventType == "KeyboardEvents")
+        return new KeyboardEventImpl();
     else if (eventType == "HTMLEvents")
         return new EventImpl();
     else {
Index: khtml/xml/dom_nodeimpl.cpp
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/khtml/xml/dom_nodeimpl.cpp,v
retrieving revision 1.36
diff -u -p -r1.36 khtml/xml/dom_nodeimpl.cpp
--- khtml/xml/dom_nodeimpl.cpp	2003/08/19 20:58:56	1.36
+++ khtml/xml/dom_nodeimpl.cpp	2003/11/16 05:27:42
@@ -737,14 +737,14 @@ bool NodeImpl::dispatchKeyEvent(QKeyEven
 {
     int exceptioncode = 0;
     //kdDebug(6010) << "DOM::NodeImpl: dispatching keyboard event" << endl;
-    KeyEventImpl *keyEventImpl = new KeyEventImpl(key, getDocument()->defaultView());
-    keyEventImpl->ref();
-    bool r = dispatchEvent(keyEventImpl,exceptioncode,true);
+    KeyboardEventImpl *keyboardEventImpl = new KeyboardEventImpl(key, getDocument()->defaultView());
+    keyboardEventImpl->ref();
+    bool r = dispatchEvent(keyboardEventImpl,exceptioncode,true);
     // the default event handler should accept() the internal QKeyEvent
     // to prevent the view from further evaluating it.
-    if (!keyEventImpl->defaultPrevented() && !keyEventImpl->qKeyEvent->isAccepted())
+    if (!keyboardEventImpl->defaultPrevented() && !keyboardEventImpl->qKeyEvent()->isAccepted())
       r = false;
-    keyEventImpl->deref();
+    keyboardEventImpl->deref();
     return r;
 }
 
Index: kwq/KWQEvent.h
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/kwq/KWQEvent.h,v
retrieving revision 1.30
diff -u -p -r1.30 kwq/KWQEvent.h
--- kwq/KWQEvent.h	2003/05/02 20:09:49	1.30
+++ kwq/KWQEvent.h	2003/11/16 05:27:42
@@ -31,6 +31,12 @@
 #include "KWQPointArray.h"
 #include "KWQString.h"
 
+#ifdef __OBJC__
+@class NSEvent;
+#else
+class NSEvent;
+#endif
+
 class QEvent : public Qt {
 public:
 
@@ -58,9 +64,6 @@ public:
     Type type() const { return _type; }
 
 private:
-    QEvent(const QEvent &);
-    QEvent &operator=(const QEvent &);
-
     Type  _type;
 };
 
@@ -99,9 +102,10 @@ private:
 
 class QKeyEvent : public QEvent {
 public:
-    QKeyEvent(Type type, int key, int ascii, int buttonState, const QString &textVal = QString::null, bool autoRepeat = FALSE, ushort countVal = 1);
+    QKeyEvent(NSEvent *, Type, int buttonState, bool autoRepeat);
 
     int key() const;
+    int WindowsKeyCode() const { return _WindowsKeyCode; }
     ButtonState state() const;
     void accept();
     void ignore();
@@ -109,15 +113,21 @@ public:
     bool isAccepted() const;
     int count()  const;
     QString text() const;
+    QString unmodifiedText() const;
     int ascii() const;
- private:
+    QString identifier() const;
+
+private:
     int _key;
     int _ascii;
     ButtonState _state;
     QString _text;
+    QString _unmodifiedText;
+    QString _identifier;
     bool _autoRepeat;
     int _count;
     bool _isAccepted;
+    int _WindowsKeyCode;
 };
 
 class QFocusEvent : public QEvent {
Index: kwq/KWQEvent.mm
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/kwq/KWQEvent.mm,v
retrieving revision 1.18
diff -u -p -r1.18 kwq/KWQEvent.mm
--- kwq/KWQEvent.mm	2003/01/22 00:12:34	1.18
+++ kwq/KWQEvent.mm	2003/11/16 05:27:42
@@ -58,16 +58,630 @@ QTimerEvent::QTimerEvent(int t)
     _timerId = t;
 }
 
+static char hexDigit(int i) {
+    if (i < 0 || i > 16) {
+        ERROR("illegal hex digit");
+        return '0';
+    }
+    int h = i;
+    if (h >= 10) {
+        h = h - 10 + 'a'; 
+    }
+    else {
+        h += '0';
+    }
+    return h;
+}
+
+static QString identifierForKeyText(const QString &text)
+{
+    int count = text.length();
+    if (count == 0 || count > 1) {
+#ifdef APPLE_CHANGES
+        LOG(Events, "received an unexpected number of characters in key event: %d", count);
+#endif
+        return "Unidentified";
+    }
+    ushort c = text[0].unicode();
+    switch (c) {
+        // Each identifier listed in the DOM spec is listed here.
+        // Many are simply commented out since they do not appear on standard Macintosh keyboards.
+        // "Accept"
+        // "AllCandidates"
+        // "Alt"
+        // "Apps"
+        // "BrowserBack"
+        // "BrowserForward"
+        // "BrowserHome"
+        // "BrowserRefresh"
+        // "BrowserSearch"
+        // "BrowserStop"
+        // "CapsLock"
+        // "Clear"
+        case NSClearLineFunctionKey:
+            return "Clear";
+            break;
+        // "CodeInput"
+        // "Compose"
+        // "Control"
+        // "Crsel"
+        // "Convert"
+        // "Copy"
+        // "Cut"
+        // "Down"
+        case NSDownArrowFunctionKey:
+            return "Down";
+            break;
+        // "End"
+        case NSEndFunctionKey:
+            return "End";
+            break;
+        // "Enter"
+        case 0x3:
+            return "Enter";
+            break;
+        // "EraseEof"
+        // "Execute"
+        case NSExecuteFunctionKey:
+            return "Execute";
+            break;
+        // "Exsel"
+        // "F1"
+        case NSF1FunctionKey:
+            return "F1";
+            break;
+        // "F2"
+        case NSF2FunctionKey:
+            return "F2";
+            break;
+        // "F3"
+        case NSF3FunctionKey:
+            return "F3";
+            break;
+        // "F4"
+        case NSF4FunctionKey:
+            return "F4";
+            break;
+        // "F5"
+        case NSF5FunctionKey:
+            return "F5";
+            break;
+        // "F6"
+        case NSF6FunctionKey:
+            return "F6";
+            break;
+        // "F7"
+        case NSF7FunctionKey:
+            return "F7";
+            break;
+        // "F8"
+        case NSF8FunctionKey:
+            return "F8";
+            break;
+        // "F9"
+        case NSF9FunctionKey:
+            return "F9";
+            break;
+        // "F10"
+        case NSF10FunctionKey:
+            return "F10";
+            break;
+        // "F11"
+        case NSF11FunctionKey:
+            return "F11";
+            break;
+        // "F12"
+        case NSF12FunctionKey:
+            return "F12";
+            break;
+        // "F13"
+        case NSF13FunctionKey:
+            return "F13";
+            break;
+        // "F14"
+        case NSF14FunctionKey:
+            return "F14";
+            break;
+        // "F15"
+        case NSF15FunctionKey:
+            return "F15";
+            break;
+        // "F16"
+        case NSF16FunctionKey:
+            return "F16";
+            break;
+        // "F17"
+        case NSF17FunctionKey:
+            return "F17";
+            break;
+        // "F18"
+        case NSF18FunctionKey:
+            return "F18";
+            break;
+        // "F19"
+        case NSF19FunctionKey:
+            return "F19";
+            break;
+        // "F20"
+        case NSF20FunctionKey:
+            return "F20";
+            break;
+        // "F21"
+        case NSF21FunctionKey:
+            return "F21";
+            break;
+        // "F22"
+        case NSF22FunctionKey:
+            return "F22";
+            break;
+        // "F23"
+        case NSF23FunctionKey:
+            return "F23";
+            break;
+        // "F24"
+        case NSF24FunctionKey:
+            return "F24";
+            break;
+        // "FinalMode"
+        // "Find"
+        case NSFindFunctionKey:
+            return "Find";
+            break;
+        // "ForwardDelete" (Non-standard)
+        case NSDeleteFunctionKey:
+            return "ForwardDelete";
+            break;
+        // "FullWidth"
+        // "HalfWidth"
+        // "HangulMode"
+        // "HanjaMode"
+        // "Help"
+        case NSHelpFunctionKey:
+            return "Help";
+            break;
+        // "Hiragana"
+        // "Home"
+        case NSHomeFunctionKey:
+            return "Home";
+            break;
+        // "Insert"
+        case NSInsertFunctionKey:
+            return "Left";
+            break;
+        // "JapaneseHiragana"
+        // "JapaneseKatakana"
+        // "JapaneseRomaji"
+        // "JunjaMode"
+        // "KanaMode"
+        // "KanjiMode"
+        // "Katakana"
+        // "LaunchApplication1"
+        // "LaunchApplication2"
+        // "LaunchMail"
+        // "Left"
+        case NSLeftArrowFunctionKey:
+            return "Left";
+            break;
+        // "Meta"
+        // "MediaNextTrack"
+        // "MediaPlayPause"
+        // "MediaPreviousTrack"
+        // "MediaStop"
+        // "ModeChange"
+        case NSModeSwitchFunctionKey:
+            return "ModeChange";
+            break;
+        // "Nonconvert"
+        // "NumLock"
+        // "PageDown"
+        case NSPageDownFunctionKey:
+            return "PageDown";
+            break;
+        // "PageUp"
+        case NSPageUpFunctionKey:
+            return "PageUp";
+            break;
+        // "Paste"
+        // "Pause"
+        case NSPauseFunctionKey:
+            return "Pause";
+            break;
+        // "Play"
+        // "PreviousCandidate"
+        // "PrintScreen"
+        case NSPrintScreenFunctionKey:
+            return "PrintScreen";
+            break;
+        // "Process"
+        // "Props"
+        // "Right"
+        case NSRightArrowFunctionKey:
+            return "Right";
+            break;
+        // "RomanCharacters"
+        // "Scroll"
+        // "Select"
+        // "SelectMedia"
+        // "Shift"
+        // "Stop"
+        case NSStopFunctionKey:
+            return "Stop";
+            break;
+        // "Up"
+        case NSUpArrowFunctionKey:
+            return "Up";
+            break;
+        // "Undo"
+        case NSUndoFunctionKey:
+            return "Undo";
+            break;
+        // "VolumeDown"
+        // "VolumeMute"
+        // "VolumeUp"
+        // "Win"
+        // "Zoom"
+        default:
+            char escaped[5];
+            escaped[0] = hexDigit((c >> 12) & 0xf);
+            escaped[1] = hexDigit((c >> 8) & 0xf);
+            escaped[2] = hexDigit((c >> 4) & 0xf);
+            escaped[3] = hexDigit(c & 0xf);
+            escaped[4] = '\0';
+            NSString *nsstring = [[NSString alloc] initWithFormat:@"U+00%s", escaped];
+            QString qstring = QString::fromNSString(nsstring);
+            [nsstring release];
+            return qstring;
+    }
+}
+
+static int characterCode(NSString *characters)
+{
+    return [characters length] != 1 ? 0 : [characters characterAtIndex:0];
+}
+
+static int WindowsKeyCode(NSEvent *event)
+{
+    switch ([event keyCode]) {
+        // VK_NUMPAD0 (60) Numeric keypad 0 key
+        case 82: return 0x60;
+        // VK_NUMPAD1 (61) Numeric keypad 1 key
+        case 83: return 0x61;
+        // VK_NUMPAD2 (62) Numeric keypad 2 key
+        case 84: return 0x62;
+        // VK_NUMPAD3 (63) Numeric keypad 3 key
+        case 85: return 0x63;
+        // VK_NUMPAD4 (64) Numeric keypad 4 key
+        case 86: return 0x64;
+        // VK_NUMPAD5 (65) Numeric keypad 5 key
+        case 87: return 0x65;
+        // VK_NUMPAD6 (66) Numeric keypad 6 key
+        case 88: return 0x66;
+        // VK_NUMPAD7 (67) Numeric keypad 7 key
+        case 89: return 0x67;
+        // VK_NUMPAD8 (68) Numeric keypad 8 key
+        case 91: return 0x68;
+        // VK_NUMPAD9 (69) Numeric keypad 9 key
+        case 92: return 0x69;
+        // VK_MULTIPLY (6A) Multiply key
+        case 67: return 0x6A;
+        // VK_ADD (6B) Add key
+        case 69: return 0x6B;
+
+        // VK_SUBTRACT (6D) Subtract key
+        case 78: return 0x6D;
+        // VK_DECIMAL (6E) Decimal key
+        case 65: return 0x6E;
+        // VK_DIVIDE (6F) Divide key
+        case 75: return 0x6F;
+     }
+
+    switch (characterCode([event charactersIgnoringModifiers])) {
+        // VK_LBUTTON (01) Left mouse button
+        // VK_RBUTTON (02) Right mouse button
+        // VK_CANCEL (03) Control-break processing
+        // VK_MBUTTON (04) Middle mouse button (three-button mouse)
+        // VK_XBUTTON1 (05)
+        // VK_XBUTTON2 (06)
+
+        // VK_BACK (08) BACKSPACE key
+        case 8: case 0x7F: return 0x08;
+        // VK_TAB (09) TAB key
+        case 9: return 0x09;
+
+        // VK_CLEAR (0C) CLEAR key
+        // handled by key code above
+
+        // VK_RETURN (0D)
+        case 0xD: case 3: return 0x0D;
+
+        // VK_SHIFT (10) SHIFT key
+        // VK_CONTROL (11) CTRL key
+        // VK_MENU (12) ALT key
+
+        // VK_PAUSE (13) PAUSE key
+        case NSPauseFunctionKey: return 0x13;
+
+        // VK_CAPITAL (14) CAPS LOCK key
+        // VK_KANA (15) Input Method Editor (IME) Kana mode
+        // VK_HANGUEL (15) IME Hanguel mode (maintained for compatibility; use VK_HANGUL)
+        // VK_HANGUL (15) IME Hangul mode
+        // VK_JUNJA (17) IME Junja mode
+        // VK_FINAL (18) IME final mode
+        // VK_HANJA (19) IME Hanja mode
+        // VK_KANJI (19) IME Kanji mode
+
+        // VK_ESCAPE (1B) ESC key
+        case 0x1B: return 0x1B;
+
+        // VK_CONVERT (1C) IME convert
+        // VK_NONCONVERT (1D) IME nonconvert
+        // VK_ACCEPT (1E) IME accept
+        // VK_MODECHANGE (1F) IME mode change request
 
-QKeyEvent::QKeyEvent(Type t, int key, int ascii, int buttonState, const QString &text, bool autoRepeat, ushort count)
+        // VK_SPACE (20) SPACEBAR
+        case ' ': return 0x20;
+        // VK_PRIOR (21) PAGE UP key
+        case NSPageUpFunctionKey: return 0x21;
+        // VK_NEXT (22) PAGE DOWN key
+        case NSPageDownFunctionKey: return 0x22;
+        // VK_END (23) END key
+        case NSEndFunctionKey: return 0x23;
+        // VK_HOME (24) HOME key
+        case NSHomeFunctionKey: return 0x24;
+        // VK_LEFT (25) LEFT ARROW key
+        case NSLeftArrowFunctionKey: return 0x25;
+        // VK_UP (26) UP ARROW key
+        case NSUpArrowFunctionKey: return 0x26;
+        // VK_RIGHT (27) RIGHT ARROW key
+        case NSRightArrowFunctionKey: return 0x27;
+        // VK_DOWN (28) DOWN ARROW key
+        case NSDownArrowFunctionKey: return 0x28;
+        // VK_SELECT (29) SELECT key
+        case NSSelectFunctionKey: return 0x29;
+        // VK_PRINT (2A) PRINT key
+        case NSPrintFunctionKey: return 0x2A;
+        // VK_EXECUTE (2B) EXECUTE key
+        case NSExecuteFunctionKey: return 0x2B;
+        // VK_SNAPSHOT (2C) PRINT SCREEN key
+        case NSPrintScreenFunctionKey: return 0x2C;
+        // VK_INSERT (2D) INS key
+        case NSInsertFunctionKey: case NSHelpFunctionKey: return 0x2D;
+        // VK_DELETE (2E) DEL key
+        case NSDeleteFunctionKey: return 0x2E;
+
+        // VK_HELP (2F) HELP key
+
+        //  (30) 0 key
+        case '0': case ')': return 0x30;
+        //  (31) 1 key
+        case '1': case '!': return 0x31;
+        //  (32) 2 key
+        case '2': case '@': return 0x32;
+        //  (33) 3 key
+        case '3': case '#': return 0x33;
+        //  (34) 4 key
+        case '4': case '$': return 0x34;
+        //  (35) 5 key
+        case '5': case '%': return 0x35;
+        //  (36) 6 key
+        case '6': case '^': return 0x36;
+        //  (37) 7 key
+        case '7': case '&': return 0x37;
+        //  (38) 8 key
+        case '8': case '*': return 0x38;
+        //  (39) 9 key
+        case '9': case '(': return 0x39;
+        //  (41) A key
+        case 'a': case 'A': return 0x41;
+        //  (42) B key
+        case 'b': case 'B': return 0x42;
+        //  (43) C key
+        case 'c': case 'C': return 0x43;
+        //  (44) D key
+        case 'd': case 'D': return 0x44;
+        //  (45) E key
+        case 'e': case 'E': return 0x45;
+        //  (46) F key
+        case 'f': case 'F': return 0x46;
+        //  (47) G key
+        case 'g': case 'G': return 0x47;
+        //  (48) H key
+        case 'h': case 'H': return 0x48;
+        //  (49) I key
+        case 'i': case 'I': return 0x49;
+        //  (4A) J key
+        case 'j': case 'J': return 0x4A;
+        //  (4B) K key
+        case 'k': case 'K': return 0x4B;
+        //  (4C) L key
+        case 'l': case 'L': return 0x4C;
+        //  (4D) M key
+        case 'm': case 'M': return 0x4D;
+        //  (4E) N key
+        case 'n': case 'N': return 0x4E;
+        //  (4F) O key
+        case 'o': case 'O': return 0x4F;
+        //  (50) P key
+        case 'p': case 'P': return 0x50;
+        //  (51) Q key
+        case 'q': case 'Q': return 0x51;
+        //  (52) R key
+        case 'r': case 'R': return 0x52;
+        //  (53) S key
+        case 's': case 'S': return 0x53;
+        //  (54) T key
+        case 't': case 'T': return 0x54;
+        //  (55) U key
+        case 'u': case 'U': return 0x55;
+        //  (56) V key
+        case 'v': case 'V': return 0x56;
+        //  (57) W key
+        case 'w': case 'W': return 0x57;
+        //  (58) X key
+        case 'x': case 'X': return 0x58;
+        //  (59) Y key
+        case 'y': case 'Y': return 0x59;
+        //  (5A) Z key
+        case 'z': case 'Z': return 0x5A;
+
+        // VK_LWIN (5B) Left Windows key (Microsoft Natural keyboard)
+        // VK_RWIN (5C) Right Windows key (Natural keyboard)
+        // VK_APPS (5D) Applications key (Natural keyboard)
+        // VK_SLEEP (5F) Computer Sleep key
+
+        // VK_NUMPAD0 (60) Numeric keypad 0 key
+        // VK_NUMPAD1 (61) Numeric keypad 1 key
+        // VK_NUMPAD2 (62) Numeric keypad 2 key
+        // VK_NUMPAD3 (63) Numeric keypad 3 key
+        // VK_NUMPAD4 (64) Numeric keypad 4 key
+        // VK_NUMPAD5 (65) Numeric keypad 5 key
+        // VK_NUMPAD6 (66) Numeric keypad 6 key
+        // VK_NUMPAD7 (67) Numeric keypad 7 key
+        // VK_NUMPAD8 (68) Numeric keypad 8 key
+        // VK_NUMPAD9 (69) Numeric keypad 9 key
+        // VK_MULTIPLY (6A) Multiply key
+        // VK_ADD (6B) Add key
+        // handled by key code above
+
+        // VK_SEPARATOR (6C) Separator key
+
+        // VK_SUBTRACT (6D) Subtract key
+        // VK_DECIMAL (6E) Decimal key
+        // VK_DIVIDE (6F) Divide key
+        // handled by key code above
+
+        // VK_F1 (70) F1 key
+        case NSF1FunctionKey: return 0x70;
+        // VK_F2 (71) F2 key
+        case NSF2FunctionKey: return 0x71;
+        // VK_F3 (72) F3 key
+        case NSF3FunctionKey: return 0x72;
+        // VK_F4 (73) F4 key
+        case NSF4FunctionKey: return 0x73;
+        // VK_F5 (74) F5 key
+        case NSF5FunctionKey: return 0x74;
+        // VK_F6 (75) F6 key
+        case NSF6FunctionKey: return 0x75;
+        // VK_F7 (76) F7 key
+        case NSF7FunctionKey: return 0x76;
+        // VK_F8 (77) F8 key
+        case NSF8FunctionKey: return 0x77;
+        // VK_F9 (78) F9 key
+        case NSF9FunctionKey: return 0x78;
+        // VK_F10 (79) F10 key
+        case NSF10FunctionKey: return 0x79;
+        // VK_F11 (7A) F11 key
+        case NSF11FunctionKey: return 0x7A;
+        // VK_F12 (7B) F12 key
+        case NSF12FunctionKey: return 0x7B;
+        // VK_F13 (7C) F13 key
+        case NSF13FunctionKey: return 0x7C;
+        // VK_F14 (7D) F14 key
+        case NSF14FunctionKey: return 0x7D;
+        // VK_F15 (7E) F15 key
+        case NSF15FunctionKey: return 0x7E;
+        // VK_F16 (7F) F16 key
+        case NSF16FunctionKey: return 0x7F;
+        // VK_F17 (80H) F17 key
+        case NSF17FunctionKey: return 0x80;
+        // VK_F18 (81H) F18 key
+        case NSF18FunctionKey: return 0x81;
+        // VK_F19 (82H) F19 key
+        case NSF19FunctionKey: return 0x82;
+        // VK_F20 (83H) F20 key
+        case NSF20FunctionKey: return 0x83;
+        // VK_F21 (84H) F21 key
+        case NSF21FunctionKey: return 0x84;
+        // VK_F22 (85H) F22 key
+        case NSF22FunctionKey: return 0x85;
+        // VK_F23 (86H) F23 key
+        case NSF23FunctionKey: return 0x86;
+        // VK_F24 (87H) F24 key
+        case NSF24FunctionKey: return 0x87;
+
+        // VK_NUMLOCK (90) NUM LOCK key
+
+        // VK_SCROLL (91) SCROLL LOCK key
+        case NSScrollLockFunctionKey: return 0x91;
+
+        // VK_LSHIFT (A0) Left SHIFT key
+        // VK_RSHIFT (A1) Right SHIFT key
+        // VK_LCONTROL (A2) Left CONTROL key
+        // VK_RCONTROL (A3) Right CONTROL key
+        // VK_LMENU (A4) Left MENU key
+        // VK_RMENU (A5) Right MENU key
+        // VK_BROWSER_BACK (A6) Windows 2000/XP: Browser Back key
+        // VK_BROWSER_FORWARD (A7) Windows 2000/XP: Browser Forward key
+        // VK_BROWSER_REFRESH (A8) Windows 2000/XP: Browser Refresh key
+        // VK_BROWSER_STOP (A9) Windows 2000/XP: Browser Stop key
+        // VK_BROWSER_SEARCH (AA) Windows 2000/XP: Browser Search key
+        // VK_BROWSER_FAVORITES (AB) Windows 2000/XP: Browser Favorites key
+        // VK_BROWSER_HOME (AC) Windows 2000/XP: Browser Start and Home key
+        // VK_VOLUME_MUTE (AD) Windows 2000/XP: Volume Mute key
+        // VK_VOLUME_DOWN (AE) Windows 2000/XP: Volume Down key
+        // VK_VOLUME_UP (AF) Windows 2000/XP: Volume Up key
+        // VK_MEDIA_NEXT_TRACK (B0) Windows 2000/XP: Next Track key
+        // VK_MEDIA_PREV_TRACK (B1) Windows 2000/XP: Previous Track key
+        // VK_MEDIA_STOP (B2) Windows 2000/XP: Stop Media key
+        // VK_MEDIA_PLAY_PAUSE (B3) Windows 2000/XP: Play/Pause Media key
+        // VK_LAUNCH_MAIL (B4) Windows 2000/XP: Start Mail key
+        // VK_LAUNCH_MEDIA_SELECT (B5) Windows 2000/XP: Select Media key
+        // VK_LAUNCH_APP1 (B6) Windows 2000/XP: Start Application 1 key
+        // VK_LAUNCH_APP2 (B7) Windows 2000/XP: Start Application 2 key
+
+        // VK_OEM_1 (BA) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ';:' key
+        case ';': case ':': return 0xBA;
+        // VK_OEM_PLUS (BB) Windows 2000/XP: For any country/region, the '+' key
+        case '=': case '+': return 0xBB;
+        // VK_OEM_COMMA (BC) Windows 2000/XP: For any country/region, the ',' key
+        case ',': case '<': return 0xBC;
+        // VK_OEM_MINUS (BD) Windows 2000/XP: For any country/region, the '-' key
+        case '-': case '_': return 0xBD;
+        // VK_OEM_PERIOD (BE) Windows 2000/XP: For any country/region, the '.' key
+        case '.': case '>': return 0xBE;
+        // VK_OEM_2 (BF) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '/?' key
+        case '/': case '?': return 0xBF;
+        // VK_OEM_3 (C0) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '`~' key
+        case '`': case '~': return 0xC0;
+        // VK_OEM_4 (DB) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '[{' key
+        case '[': case '{': return 0xDB;
+        // VK_OEM_5 (DC) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '\|' key
+        case '\\': case '|': return 0xDC;
+        // VK_OEM_6 (DD) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ']}' key
+        case ']': case '}': return 0xDD;
+        // VK_OEM_7 (DE) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the 'single-quote/double-quote' key
+        case '\'': case '"': return 0xDE;
+
+        // VK_OEM_8 (DF) Used for miscellaneous characters; it can vary by keyboard.
+        // VK_OEM_102 (E2) Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard
+        // VK_PROCESSKEY (E5) Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key
+        // VK_PACKET (E7) Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes. The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, see Remark in KEYBDINPUT,SendInput, WM_KEYDOWN, and WM_KEYUP
+        // VK_ATTN (F6) Attn key
+        // VK_CRSEL (F7) CrSel key
+        // VK_EXSEL (F8) ExSel key
+        // VK_EREOF (F9) Erase EOF key
+        // VK_PLAY (FA) Play key
+        // VK_ZOOM (FB) Zoom key
+        // VK_NONAME (FC) Reserved for future use
+        // VK_PA1 (FD) PA1 key
+        // VK_OEM_CLEAR (FE) Clear key
+    }
+
+    return 0;
+ }
+ 
+QKeyEvent::QKeyEvent(NSEvent *event, Type t, int buttonState, bool autoRepeat)
     : QEvent(t),
-      _key(key),
-      _ascii(ascii),
+      _key([event keyCode]),
+      _ascii(characterCode([event characters])),
       _state((ButtonState)buttonState),
-      _text(text),
+      _text(QString::fromNSString([event characters])),
+      _unmodifiedText(QString::fromNSString([event charactersIgnoringModifiers])),
+      _identifier(identifierForKeyText(_unmodifiedText)),
       _autoRepeat(autoRepeat),
-      _count(count),
-      _isAccepted(false)
+      _count(1),
+      _isAccepted(false),
+      _WindowsKeyCode(::WindowsKeyCode(event))
 {
 }
 
@@ -101,6 +715,11 @@ QString QKeyEvent::text(void) const
     return _text;
 }
 
+QString QKeyEvent::unmodifiedText(void) const
+{
+    return _unmodifiedText;
+}
+
 int QKeyEvent::ascii(void) const
 {
     return _ascii;
@@ -114,4 +733,9 @@ int QKeyEvent::count(void) const
 bool QKeyEvent::isAccepted(void) const
 {
     return _isAccepted;
+}
+
+QString QKeyEvent::identifier() const
+{
+    return _identifier;
 }
Index: kwq/KWQKHTMLPart.mm
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/kwq/KWQKHTMLPart.mm,v
retrieving revision 1.395.10.1
diff -u -p -r1.395.10.1 kwq/KWQKHTMLPart.mm
--- kwq/KWQKHTMLPart.mm	2003/11/14 00:15:45	1.395.10.1
+++ kwq/KWQKHTMLPart.mm	2003/11/16 05:27:42
@@ -1326,26 +1326,16 @@ bool KWQKHTMLPart::keyEvent(NSEvent *eve
     NSEvent *oldCurrentEvent = _currentEvent;
     _currentEvent = [event retain];
 
-    const char *characters = [[event characters] lossyCString];
-    int ascii = (characters != nil && strlen(characters) == 1) ? characters[0] : 0;
-
-    QKeyEvent qEvent([event type] == NSKeyDown ? QEvent::KeyPress : QEvent::KeyRelease,
-		     [event keyCode],
-		     ascii,
-		     stateForCurrentEvent(),
-		     QString::fromNSString([event characters]),
-		     [event isARepeat]);
+    QEvent::Type type = [event type] == NSKeyDown ? QEvent::KeyPress : QEvent::KeyRelease;
+    QKeyEvent qEvent(event, type, stateForCurrentEvent(), [event isARepeat]);
     bool result = node->dispatchKeyEvent(&qEvent);
 
     // We want to send both a down and a press for the initial key event.
-    // This is a temporary hack; we need to do this a better way.
+    // To get KHTML to do this, we send a second KeyPress QKeyEvent with "is repeat" set to true,
+    // which causes it to send a press to the DOM.
+    // That's not a great hack; it would be good to do this in a better way.
     if ([event type] == NSKeyDown && ![event isARepeat]) {
-	QKeyEvent qEvent(QEvent::KeyPress,
-			 [event keyCode],
-			 ascii,
-			 stateForCurrentEvent(),
-			 QString::fromNSString([event characters]),
-			 true);
+	QKeyEvent qEvent(event, QEvent::KeyPress, stateForCurrentEvent(), true);
         node->dispatchKeyEvent(&qEvent);
     }
 
@@ -1689,6 +1679,8 @@ int KWQKHTMLPart::stateForCurrentEvent()
         state |= Qt::AltButton;
     if (modifiers & NSCommandKeyMask)
         state |= Qt::MetaButton;
+    if (modifiers & NSNumericPadKeyMask)
+        state |= Qt::Keypad;
     
     return state;
 }
Index: kwq/KWQLogging.h
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/kwq/KWQLogging.h,v
retrieving revision 1.6
diff -u -p -r1.6 kwq/KWQLogging.h
--- kwq/KWQLogging.h	2003/01/22 00:12:35	1.6
+++ kwq/KWQLogging.h	2003/11/16 05:27:42
@@ -34,3 +34,4 @@ extern KWQLogChannel KWQLogNotYetImpleme
 extern KWQLogChannel KWQLogFrames;
 extern KWQLogChannel KWQLogLoading;
 extern KWQLogChannel KWQLogPopupBlocking;
+extern KWQLogChannel KWQLogEvents;
Index: kwq/KWQLogging.m
===================================================================
RCS file: /local/home/cvs/Labyrinth/WebCore/kwq/KWQLogging.m,v
retrieving revision 1.5
diff -u -p -r1.5 kwq/KWQLogging.m
--- kwq/KWQLogging.m	2003/01/22 00:12:35	1.5
+++ kwq/KWQLogging.m	2003/11/16 05:27:42
@@ -31,3 +31,5 @@ KWQLogChannel KWQLogFrames =            
 KWQLogChannel KWQLogLoading =           { 0x00000020, "WebCoreLogLevel", KWQLogChannelUninitialized };
 
 KWQLogChannel KWQLogPopupBlocking =     { 0x00000040, "WebCoreLogLevel", KWQLogChannelUninitialized };
+
+KWQLogChannel KWQLogEvents =            { 0x00000080, "WebCoreLogLevel", KWQLogChannelUninitialized };
