input_event.cc revision a36e5920737c6adbddd3e43b760e5de8431db6e0 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ppapi/cpp/input_event.h"
6
7#include "ppapi/cpp/instance_handle.h"
8#include "ppapi/cpp/module.h"
9#include "ppapi/cpp/module_impl.h"
10#include "ppapi/cpp/point.h"
11#include "ppapi/cpp/touch_point.h"
12#include "ppapi/cpp/var.h"
13
14namespace pp {
15
16namespace {
17
18template <> const char* interface_name<PPB_InputEvent_1_0>() {
19  return PPB_INPUT_EVENT_INTERFACE_1_0;
20}
21
22template <> const char* interface_name<PPB_KeyboardInputEvent_1_0>() {
23  return PPB_KEYBOARD_INPUT_EVENT_INTERFACE_1_0;
24}
25
26template <> const char* interface_name<PPB_MouseInputEvent_1_1>() {
27  return PPB_MOUSE_INPUT_EVENT_INTERFACE_1_1;
28}
29
30template <> const char* interface_name<PPB_WheelInputEvent_1_0>() {
31  return PPB_WHEEL_INPUT_EVENT_INTERFACE_1_0;
32}
33
34template <> const char* interface_name<PPB_TouchInputEvent_1_0>() {
35  return PPB_TOUCH_INPUT_EVENT_INTERFACE_1_0;
36}
37
38template <> const char* interface_name<PPB_IMEInputEvent_1_0>() {
39  return PPB_IME_INPUT_EVENT_INTERFACE_1_0;
40}
41
42}  // namespace
43
44// InputEvent ------------------------------------------------------------------
45
46InputEvent::InputEvent() : Resource() {
47}
48
49InputEvent::InputEvent(PP_Resource input_event_resource) : Resource() {
50  // Type check the input event before setting it.
51  if (!has_interface<PPB_InputEvent_1_0>())
52    return;
53  if (get_interface<PPB_InputEvent_1_0>()->IsInputEvent(input_event_resource)) {
54    Module::Get()->core()->AddRefResource(input_event_resource);
55    PassRefFromConstructor(input_event_resource);
56  }
57}
58
59InputEvent::~InputEvent() {
60}
61
62PP_InputEvent_Type InputEvent::GetType() const {
63  if (!has_interface<PPB_InputEvent_1_0>())
64    return PP_INPUTEVENT_TYPE_UNDEFINED;
65  return get_interface<PPB_InputEvent_1_0>()->GetType(pp_resource());
66}
67
68PP_TimeTicks InputEvent::GetTimeStamp() const {
69  if (!has_interface<PPB_InputEvent_1_0>())
70    return 0.0f;
71  return get_interface<PPB_InputEvent_1_0>()->GetTimeStamp(pp_resource());
72}
73
74uint32_t InputEvent::GetModifiers() const {
75  if (!has_interface<PPB_InputEvent_1_0>())
76    return 0;
77  return get_interface<PPB_InputEvent_1_0>()->GetModifiers(pp_resource());
78}
79
80// MouseInputEvent -------------------------------------------------------------
81
82MouseInputEvent::MouseInputEvent() : InputEvent() {
83}
84
85MouseInputEvent::MouseInputEvent(const InputEvent& event) : InputEvent() {
86  // Type check the input event before setting it.
87  if (!has_interface<PPB_MouseInputEvent_1_1>())
88    return;
89  if (get_interface<PPB_MouseInputEvent_1_1>()->IsMouseInputEvent(
90          event.pp_resource())) {
91    Module::Get()->core()->AddRefResource(event.pp_resource());
92    PassRefFromConstructor(event.pp_resource());
93  }
94}
95
96MouseInputEvent::MouseInputEvent(const InstanceHandle& instance,
97                                 PP_InputEvent_Type type,
98                                 PP_TimeTicks time_stamp,
99                                 uint32_t modifiers,
100                                 PP_InputEvent_MouseButton mouse_button,
101                                 const Point& mouse_position,
102                                 int32_t click_count,
103                                 const Point& mouse_movement) {
104  // Type check the input event before setting it.
105  if (!has_interface<PPB_MouseInputEvent_1_1>())
106    return;
107  PassRefFromConstructor(get_interface<PPB_MouseInputEvent_1_1>()->Create(
108      instance.pp_instance(), type, time_stamp, modifiers, mouse_button,
109      &mouse_position.pp_point(), click_count, &mouse_movement.pp_point()));
110}
111
112PP_InputEvent_MouseButton MouseInputEvent::GetButton() const {
113  if (!has_interface<PPB_MouseInputEvent_1_1>())
114    return PP_INPUTEVENT_MOUSEBUTTON_NONE;
115  return get_interface<PPB_MouseInputEvent_1_1>()->GetButton(pp_resource());
116}
117
118Point MouseInputEvent::GetPosition() const {
119  if (!has_interface<PPB_MouseInputEvent_1_1>())
120    return Point();
121  return get_interface<PPB_MouseInputEvent_1_1>()->GetPosition(pp_resource());
122}
123
124int32_t MouseInputEvent::GetClickCount() const {
125  if (!has_interface<PPB_MouseInputEvent_1_1>())
126    return 0;
127  return get_interface<PPB_MouseInputEvent_1_1>()->GetClickCount(pp_resource());
128}
129
130Point MouseInputEvent::GetMovement() const {
131  if (!has_interface<PPB_MouseInputEvent_1_1>())
132    return Point();
133  return get_interface<PPB_MouseInputEvent_1_1>()->GetMovement(pp_resource());
134}
135
136// WheelInputEvent -------------------------------------------------------------
137
138WheelInputEvent::WheelInputEvent() : InputEvent() {
139}
140
141WheelInputEvent::WheelInputEvent(const InputEvent& event) : InputEvent() {
142  // Type check the input event before setting it.
143  if (!has_interface<PPB_WheelInputEvent_1_0>())
144    return;
145  if (get_interface<PPB_WheelInputEvent_1_0>()->IsWheelInputEvent(
146          event.pp_resource())) {
147    Module::Get()->core()->AddRefResource(event.pp_resource());
148    PassRefFromConstructor(event.pp_resource());
149  }
150}
151
152WheelInputEvent::WheelInputEvent(const InstanceHandle& instance,
153                                 PP_TimeTicks time_stamp,
154                                 uint32_t modifiers,
155                                 const FloatPoint& wheel_delta,
156                                 const FloatPoint& wheel_ticks,
157                                 bool scroll_by_page) {
158  // Type check the input event before setting it.
159  if (!has_interface<PPB_WheelInputEvent_1_0>())
160    return;
161  PassRefFromConstructor(get_interface<PPB_WheelInputEvent_1_0>()->Create(
162      instance.pp_instance(), time_stamp, modifiers,
163      &wheel_delta.pp_float_point(), &wheel_ticks.pp_float_point(),
164      PP_FromBool(scroll_by_page)));
165}
166
167FloatPoint WheelInputEvent::GetDelta() const {
168  if (!has_interface<PPB_WheelInputEvent_1_0>())
169    return FloatPoint();
170  return get_interface<PPB_WheelInputEvent_1_0>()->GetDelta(pp_resource());
171}
172
173FloatPoint WheelInputEvent::GetTicks() const {
174  if (!has_interface<PPB_WheelInputEvent_1_0>())
175    return FloatPoint();
176  return get_interface<PPB_WheelInputEvent_1_0>()->GetTicks(pp_resource());
177}
178
179bool WheelInputEvent::GetScrollByPage() const {
180  if (!has_interface<PPB_WheelInputEvent_1_0>())
181    return false;
182  return PP_ToBool(
183      get_interface<PPB_WheelInputEvent_1_0>()->GetScrollByPage(pp_resource()));
184}
185
186// KeyboardInputEvent ----------------------------------------------------------
187
188KeyboardInputEvent::KeyboardInputEvent() : InputEvent() {
189}
190
191KeyboardInputEvent::KeyboardInputEvent(const InputEvent& event) : InputEvent() {
192  // Type check the input event before setting it.
193  if (!has_interface<PPB_KeyboardInputEvent_1_0>())
194    return;
195  if (get_interface<PPB_KeyboardInputEvent_1_0>()->IsKeyboardInputEvent(
196          event.pp_resource())) {
197    Module::Get()->core()->AddRefResource(event.pp_resource());
198    PassRefFromConstructor(event.pp_resource());
199  }
200}
201
202KeyboardInputEvent::KeyboardInputEvent(const InstanceHandle& instance,
203                                       PP_InputEvent_Type type,
204                                       PP_TimeTicks time_stamp,
205                                       uint32_t modifiers,
206                                       uint32_t key_code,
207                                       const Var& character_text) {
208  // Type check the input event before setting it.
209  if (!has_interface<PPB_KeyboardInputEvent_1_0>())
210    return;
211  PassRefFromConstructor(get_interface<PPB_KeyboardInputEvent_1_0>()->Create(
212      instance.pp_instance(), type, time_stamp, modifiers, key_code,
213      character_text.pp_var()));
214}
215
216uint32_t KeyboardInputEvent::GetKeyCode() const {
217  if (!has_interface<PPB_KeyboardInputEvent_1_0>())
218    return 0;
219  return get_interface<PPB_KeyboardInputEvent_1_0>()->GetKeyCode(pp_resource());
220}
221
222Var KeyboardInputEvent::GetCharacterText() const {
223  if (!has_interface<PPB_KeyboardInputEvent_1_0>())
224    return Var();
225  return Var(PASS_REF,
226             get_interface<PPB_KeyboardInputEvent_1_0>()->GetCharacterText(
227                 pp_resource()));
228}
229
230// TouchInputEvent ------------------------------------------------------------
231TouchInputEvent::TouchInputEvent() : InputEvent() {
232}
233
234TouchInputEvent::TouchInputEvent(const InputEvent& event) : InputEvent() {
235  if (!has_interface<PPB_TouchInputEvent_1_0>())
236    return;
237  // Type check the input event before setting it.
238  if (get_interface<PPB_TouchInputEvent_1_0>()->IsTouchInputEvent(
239      event.pp_resource())) {
240    Module::Get()->core()->AddRefResource(event.pp_resource());
241    PassRefFromConstructor(event.pp_resource());
242  }
243}
244
245TouchInputEvent::TouchInputEvent(const InstanceHandle& instance,
246                                 PP_InputEvent_Type type,
247                                 PP_TimeTicks time_stamp,
248                                 uint32_t modifiers) {
249  // Type check the input event before setting it.
250  if (!has_interface<PPB_TouchInputEvent_1_0>())
251    return;
252  PassRefFromConstructor(get_interface<PPB_TouchInputEvent_1_0>()->Create(
253      instance.pp_instance(), type, time_stamp, modifiers));
254}
255
256void TouchInputEvent::AddTouchPoint(PP_TouchListType list,
257                                    PP_TouchPoint point) {
258  if (!has_interface<PPB_TouchInputEvent_1_0>())
259    return;
260  get_interface<PPB_TouchInputEvent_1_0>()->AddTouchPoint(pp_resource(), list,
261                                                          &point);
262}
263
264uint32_t TouchInputEvent::GetTouchCount(PP_TouchListType list) const {
265  if (!has_interface<PPB_TouchInputEvent_1_0>())
266    return 0;
267  return get_interface<PPB_TouchInputEvent_1_0>()->GetTouchCount(pp_resource(),
268                                                                 list);
269}
270
271TouchPoint TouchInputEvent::GetTouchById(PP_TouchListType list,
272                                             uint32_t id) const {
273  if (!has_interface<PPB_TouchInputEvent_1_0>())
274    return TouchPoint();
275  return TouchPoint(get_interface<PPB_TouchInputEvent_1_0>()->
276                        GetTouchById(pp_resource(), list, id));
277}
278
279TouchPoint TouchInputEvent::GetTouchByIndex(PP_TouchListType list,
280                                                uint32_t index) const {
281  if (!has_interface<PPB_TouchInputEvent_1_0>())
282    return TouchPoint();
283  return TouchPoint(get_interface<PPB_TouchInputEvent_1_0>()->
284                        GetTouchByIndex(pp_resource(), list, index));
285}
286
287// IMEInputEvent -------------------------------------------------------
288
289IMEInputEvent::IMEInputEvent() : InputEvent() {
290}
291
292IMEInputEvent::IMEInputEvent(const InputEvent& event) : InputEvent() {
293  if (has_interface<PPB_IMEInputEvent_1_0>()) {
294    if (get_interface<PPB_IMEInputEvent_1_0>()->IsIMEInputEvent(
295            event.pp_resource())) {
296      Module::Get()->core()->AddRefResource(event.pp_resource());
297      PassRefFromConstructor(event.pp_resource());
298    }
299  }
300}
301
302IMEInputEvent::IMEInputEvent(
303    const InstanceHandle& instance,
304    PP_InputEvent_Type type,
305    PP_TimeTicks time_stamp,
306    const Var& text,
307    const std::vector<uint32_t>& segment_offsets,
308    int32_t target_segment,
309    const std::pair<uint32_t, uint32_t>& selection) : InputEvent() {
310  if (!has_interface<PPB_IMEInputEvent_1_0>())
311    return;
312  uint32_t dummy = 0;
313  PassRefFromConstructor(get_interface<PPB_IMEInputEvent_1_0>()->Create(
314      instance.pp_instance(), type, time_stamp, text.pp_var(),
315      segment_offsets.empty() ? 0 : segment_offsets.size() - 1,
316      segment_offsets.empty() ? &dummy : &segment_offsets[0],
317      target_segment, selection.first, selection.second));
318}
319
320
321Var IMEInputEvent::GetText() const {
322  if (has_interface<PPB_IMEInputEvent_1_0>()) {
323    return Var(PASS_REF,
324               get_interface<PPB_IMEInputEvent_1_0>()->GetText(
325                   pp_resource()));
326  }
327  return Var();
328}
329
330uint32_t IMEInputEvent::GetSegmentNumber() const {
331  if (has_interface<PPB_IMEInputEvent_1_0>()) {
332    return get_interface<PPB_IMEInputEvent_1_0>()->GetSegmentNumber(
333        pp_resource());
334  }
335  return 0;
336}
337
338uint32_t IMEInputEvent::GetSegmentOffset(uint32_t index) const {
339  if (has_interface<PPB_IMEInputEvent_1_0>()) {
340    return get_interface<PPB_IMEInputEvent_1_0>()->GetSegmentOffset(
341        pp_resource(), index);
342  }
343  return 0;
344}
345
346int32_t IMEInputEvent::GetTargetSegment() const {
347  if (has_interface<PPB_IMEInputEvent_1_0>()) {
348    return get_interface<PPB_IMEInputEvent_1_0>()->GetTargetSegment(
349        pp_resource());
350  }
351  return 0;
352}
353
354void IMEInputEvent::GetSelection(uint32_t* start, uint32_t* end) const {
355  if (has_interface<PPB_IMEInputEvent_1_0>()) {
356    get_interface<PPB_IMEInputEvent_1_0>()->GetSelection(pp_resource(),
357                                                         start,
358                                                         end);
359  }
360}
361
362}  // namespace pp
363