Add a new constructor to KeyEvent.

views/events/event.h

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VIEWS_EVENT_H_
-#define VIEWS_EVENT_H_
+#ifndef VIEWS_EVENTS_EVENT_H_
+#define VIEWS_EVENTS_EVENT_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/time.h"
 #include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/point.h"
 #include "views/native_types.h"
 
-#if defined(OS_LINUX)
-typedef struct _GdkEventKey GdkEventKey;
-#endif
-
 #if defined(TOUCH_UI)
 typedef union _XEvent XEvent;
 #endif
 
 namespace ui {
 class OSExchangeData;
 }
 using ui::OSExchangeData;
 
 namespace views {
 
 class View;
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Event class
 //
 // An event encapsulates an input event that can be propagated into view
 // hierarchies. An event has a type, some flags and a time stamp.
 //
 // Each major event type has a corresponding Event subclass.
 //
 // Events are immutable but support copy
 //
 ////////////////////////////////////////////////////////////////////////////////
 class Event {
  public:
+  // This type exists to distinguish between the NativeEvent and NativeEvent2
+  // constructors.
+  // TODO(beng): remove once we rid views of Gtk/Gdk.
+  struct FromNativeEvent2 {};
+
   const NativeEvent& native_event() const { return native_event_; }
+  const NativeEvent2& native_event_2() const { return native_event_2_; }
   ui::EventType type() const { return type_; }
   const base::Time& time_stamp() const { return time_stamp_; }
   int flags() const { return flags_; }
   void set_flags(int flags) { flags_ = flags; }
 
   // The following methods return true if the respective keys were pressed at
   // the time the event was created.
   bool IsShiftDown() const { return (flags_ & ui::EF_SHIFT_DOWN) != 0; }
   bool IsControlDown() const { return (flags_ & ui::EF_CONTROL_DOWN) != 0; }
   bool IsCapsLockDown() const { return (flags_ & ui::EF_CAPS_LOCK_DOWN) != 0; }
@@ skipping 25 matching lines @@
 
   // Convert windows flags to views::Event flags
   static int ConvertWindowsFlags(uint32 win_flags);
 #elif defined(OS_LINUX)
   // Convert the state member on a GdkEvent to views::Event flags
   static int GetFlagsFromGdkState(int state);
 #endif
 
  protected:
   Event(ui::EventType type, int flags);
+  Event(NativeEvent native_event, ui::EventType type, int flags);
+  // Because the world is complicated, sometimes we have two different kinds of
+  // NativeEvent in play in the same executable. See native_types.h for the tale
+  // of woe.
+  Event(NativeEvent2 native_event, ui::EventType type, int flags,
+        FromNativeEvent2);
 
   Event(const Event& model)
       : native_event_(model.native_event()),
         type_(model.type()),
         time_stamp_(model.time_stamp()),
         flags_(model.flags()) {
   }
 
  private:
   void operator=(const Event&);
 
+  // Safely initializes the native event members of this class.
+  void Init();
+  void InitWithNativeEvent(NativeEvent native_event);
+  void InitWithNativeEvent2(NativeEvent2 native_event_2, FromNativeEvent2);
+
   NativeEvent native_event_;
+  NativeEvent2 native_event_2_;
   ui::EventType type_;
   base::Time time_stamp_;
   int flags_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // LocatedEvent class
 //
 // A generic event that is used for any events that is located at a specific
@@ skipping 124 matching lines @@
  private:
   // The identity (typically finger) of the touch starting at 0 and incrementing
   // for each separable additional touch that the hardware can detect.
   const int touch_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEvent);
 };
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
-//
 // KeyEvent class
 //
-// A key event is used for any input event related to the keyboard.
-// Note: this event is about key pressed, not typed characters.
+//  KeyEvent encapsulates keyboard input events - key press and release.
 //
-////////////////////////////////////////////////////////////////////////////////
 class KeyEvent : public Event {
  public:
-  // Create a new key event
+  explicit KeyEvent(NativeEvent native_event);
+  explicit KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2);
+
+  // Creates a new KeyEvent synthetically (i.e. not in response to an input
+  // event from the host environment). This is typically only used in testing as
+  // some metadata obtainable from the underlying native event is not present.
+  // TODO(beng): see if we can kill this.
   KeyEvent(ui::EventType type,
            ui::KeyboardCode key_code,
-           int event_flags,
-           int repeat_count,
-           int message_flags);
-
-#if defined(OS_WIN)
-  KeyEvent(ui::EventType type,
-           ui::KeyboardCode key_code,
-           int event_flags,
-           int repeat_count,
-           int message_flags,
-           UINT message);
-#endif
-#if defined(OS_LINUX)
-  explicit KeyEvent(const GdkEventKey* event);
-
-  const GdkEventKey* native_event() const { return native_event_; }
-#endif
-#if defined(TOUCH_UI)
-  // Create a key event from an X key event.
-  explicit KeyEvent(XEvent* xevent);
-#endif
+           int event_flags);
 
   ui::KeyboardCode key_code() const { return key_code_; }
 
-#if defined(OS_WIN)
-  bool IsExtendedKey() const;
+ private:
+  ui::KeyboardCode key_code_;
 
-  UINT message() const { return message_; }
-#endif
-
-  int repeat_count() const { return repeat_count_; }
-
-#if defined(OS_WIN)
-  static int GetKeyStateFlags();
-#endif
-
- private:
-
-  ui::KeyboardCode key_code_;
-  int repeat_count_;
-  int message_flags_;
-#if defined(OS_WIN)
-  UINT message_;
-#elif defined(OS_LINUX)
-  const GdkEventKey* native_event_;
-#endif
   DISALLOW_COPY_AND_ASSIGN(KeyEvent);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // MouseWheelEvent class
 //
 // A MouseWheelEvent is used to propagate mouse wheel user events.
 // Note: e.GetOffset() > 0 means scroll up.
 //
@@ skipping 45 matching lines @@
   const OSExchangeData& data_;
 
   // Bitmask of supported ui::DragDropTypes::DragOperation by the source.
   int source_operations_;
 
   DISALLOW_COPY_AND_ASSIGN(DropTargetEvent);
 };
 
 }  // namespace views
 
-#endif  // VIEWS_EVENT_H_
+#endif  // VIEWS_EVENTS_EVENT_H_