Declarations for Pepper IME API.

ppapi/cpp/input_event.h

 // 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 PPAPI_CPP_INPUT_EVENT_H_
 #define PPAPI_CPP_INPUT_EVENT_H_
 
 #include <string>
+#include <utility>
 
 #include "ppapi/c/ppb_input_event.h"
 #include "ppapi/cpp/resource.h"
 
 /// @file
 /// This file defines the API used to handle mouse and keyboard input events.
 
 namespace pp {
 
 class FloatPoint;
@@ skipping 76 matching lines @@
   /// This constructor constructs a mouse input event object from the provided
   /// generic input event. If the given event is itself is_null() or is not
   /// a mouse input event, the mouse object will be is_null().
   ///
   /// @param event An <code>InputEvent</code>.
   explicit MouseInputEvent(const InputEvent& event);
 
   /// This constructor manually constructs a mouse event from the provided
   /// parameters.
   ///
-  /// @param[in] instance The instance for which this event occured.
+  /// @param[in] instance The instance for which this event occurred.
   ///
   /// @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
   /// input event.
   ///
   /// @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
-  /// when the event occured.
+  /// when the event occurred.
   ///
   /// @param[in] modifiers A bit field combination of the
   /// <code>PP_InputEvent_Modifier</code> flags.
   ///
   /// @param[in] mouse_button The button that changed for mouse down or up
   /// events. This value will be <code>PP_EVENT_MOUSEBUTTON_NONE</code> for
   /// mouse move, enter, and leave events.
   ///
   /// @param[in] mouse_position A <code>Point</code> containing the x and y
-  /// position of the mouse when the eent occurred.
+  /// position of the mouse when the event occurred.
   ///
   /// @param[in] click_count
   /// TODO(brettw) figure out exactly what this means.
   ///
   /// @param[in] mouse_movement The change in position of the mouse.
   MouseInputEvent(Instance* instance,
                   PP_InputEvent_Type type,
                   PP_TimeTicks time_stamp,
                   uint32_t modifiers,
                   PP_InputEvent_MouseButton mouse_button,
@@ skipping 45 matching lines @@
   /// is_null().
   ///
   /// @param[in] A generic input event.
   explicit WheelInputEvent(const InputEvent& event);
 
   /// Constructs a wheel input even from the given parameters.
   ///
   /// @param[in] instance The instance for which this event occured.
   ///
   /// @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
-  /// when the event occured.
+  /// when the event occurred.
   ///
   /// @param[in] modifiers A bit field combination of the
   /// <code>PP_InputEvent_Modifier</code> flags.
   ///
   /// @param[in] wheel_delta The scroll wheel's horizontal and vertical scroll
   /// amounts.
   ///
   /// @param[in] wheel_ticks The number of "clicks" of the scroll wheel that
   /// have produced the event.
   ///
@@ skipping 14 matching lines @@
   ///
   /// This amount is system dependent and will take into account the user's
   /// preferred scroll sensitivity and potentially also nonlinear acceleration
   /// based on the speed of the scrolling.
   ///
   /// Devices will be of varying resolution. Some mice with large detents will
   /// only generate integer scroll amounts. But fractional values are also
   /// possible, for example, on some trackpads and newer mice that don't have
   /// "clicks".
   ///
-  /// @return The vertial and horizontal scroll values. The units are either in
+  /// @return The vertical and horizontal scroll values. The units are either in
   /// pixels (when scroll_by_page is false) or pages (when scroll_by_page is
   /// true). For example, y = -3 means scroll up 3 pixels when scroll_by_page
   /// is false, and scroll up 3 pages when scroll_by_page is true.
   FloatPoint GetDelta() const;
 
   /// GetTicks() returns the number of "clicks" of the scroll wheel
   /// that have produced the event. The value may have system-specific
   /// acceleration applied to it, depending on the device. The positive and
   /// negative meanings are the same as for GetDelta().
   ///
@@ skipping 19 matching lines @@
   bool GetScrollByPage() const;
 };
 
 class KeyboardInputEvent : public InputEvent {
  public:
   /// Constructs an is_null() keyboard input event object.
   KeyboardInputEvent();
 
   /// Constructs a keyboard input event object from the provided generic input
   /// event. If the given event is itself is_null() or is not a keyboard input
-  /// event, the keybaord object will be is_null().
+  /// event, the keyboard object will be is_null().
   ///
   /// @param[in] event A generic input event.
   explicit KeyboardInputEvent(const InputEvent& event);
 
   /// Constructs a keyboard input even from the given parameters.
   ///
-  /// @param[in] instance The instance for which this event occured.
+  /// @param[in] instance The instance for which this event occurred.
   ///
   /// @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
   /// input event.
   ///
   /// @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
-  /// when the event occured.
+  /// when the event occurred.
   ///
   /// @param[in]  modifiers A bit field combination of the
   /// <code>PP_InputEvent_Modifier</code> flags.
   ///
   /// @param[in] key_code This value reflects the DOM KeyboardEvent
   /// <code>keyCode</code> field. Chrome populates this with the Windows-style
   /// Virtual Key code of the key.
   ///
   /// @param[in] character_text This value represents the typed character as a
   /// UTF-8 string.
   KeyboardInputEvent(Instance* instance,
                      PP_InputEvent_Type type,
                      PP_TimeTicks time_stamp,
                      uint32_t modifiers,
                      uint32_t key_code,
                      const Var& character_text);
 
   /// Returns the DOM keyCode field for the keyboard event.
   /// Chrome populates this with the Windows-style Virtual Key code of the key.
   uint32_t GetKeyCode() const;
 
   /// Returns the typed character for the given character event.
   ///
   /// @return A string var representing a single typed character for character
   /// input events. For non-character input events the return value will be an
   /// undefined var.
   Var GetCharacterText() const;
 };
 
+class CompositionInputEvent : public InputEvent {
+ public:
+  /// Constructs an is_null() composition input event object.
+  CompositionInputEvent();
+
+  /// Constructs a composition input event object from the provided generic
+  /// input event. If the given event is itself is_null() or is not a
+  /// composition input event, the composition object will be is_null().
+  ///
+  /// @param[in] event A generic input event.
+  explicit CompositionInputEvent(const InputEvent& event);
+
+  /// Returns the composition text as a UTF-8 string for the given composition
+  /// event.
+  ///
+  /// @return A string var representing the composition text. For non-
+  /// composition input events the return value will be an undefined var.
+  Var GetText() const;
+
+  /// Returns the number of segments in the composition text.
+  ///
+  /// @return The number of segments. For events other than COMPOSITION_UPDATE,
+  /// returns 0.
+  uint32_t GetSegmentNumber() const;
+
+  /// Returns the start and the end position of the index-th segment in the
+  /// composition text. The positions are given by byte-indices of the string
+  /// GetText(). They always satisfy 0 <= .first < .second <= (Length of
+  /// GetText()) and GetSegmentAt(index).first < GetSegmentAt(index+1).first.
+  /// When the event is not COMPOSITION_UPDATE or index >= GetSegmentNumber(),
+  /// returns (0, 0).
+  ///
+  /// @param[in] index An integer indicating a segment.
+  ///
+  /// @return A pair of integers representing the index-th segment.
+  std::pair<uint32_t, uint32_t> GetSegmentAt(uint32_t index) const;
+
+  /// Returns the index of the current target segment of composition.
+  ///
+  /// @return An integer indicating the index of the target segment. When there
+  /// is no active target segment, or the event is not COMPOSITION_UPDATE,
+  /// returns -1.
+  int32_t GetTargetSegment() const;
+
+  /// Returns the range selected by caret in the composition text.
+  ///
+  /// @return A pair of integers indicating the selection range.
+  std::pair<uint32_t, uint32_t> GetSelection() const;
+};
+
 }  // namespace pp
 
 #endif  // PPAPI_CPP_INPUT_EVENT_H_