src/ppapi/thunk/ppb_input_event_thunk.cc

   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/c/pp_errors.h"
   6 #include "ppapi/thunk/enter.h"
   7 #include "ppapi/thunk/ppb_input_event_api.h"
   8 #include "ppapi/thunk/ppb_instance_api.h"
   9 #include "ppapi/thunk/resource_creation_api.h"
  10 #include "ppapi/thunk/thunk.h"
  11
  12 namespace ppapi {
  13 namespace thunk {
  14
  15 namespace {
  16
  17 typedef EnterResource<PPB_InputEvent_API> EnterInputEvent;
  18
  19 // InputEvent ------------------------------------------------------------------
  20
  21 int32_t RequestInputEvents(PP_Instance instance, uint32_t event_classes) {
  22   VLOG(4) << "PPB_InputEvent::RequestInputEvents()";
  23   EnterInstance enter(instance);
  24   if (enter.failed())
  25     return enter.retval();
  26   return enter.functions()->RequestInputEvents(instance, event_classes);
  27 }
  28
  29 int32_t RequestFilteringInputEvents(PP_Instance instance,
  30                                     uint32_t event_classes) {
  31   VLOG(4) << "PPB_InputEvent::RequestFilteringInputEvents()";
  32   EnterInstance enter(instance);
  33   if (enter.failed())
  34     return enter.retval();
  35   return enter.functions()->RequestFilteringInputEvents(instance,
  36                                                         event_classes);
  37 }
  38
  39 void ClearInputEventRequest(PP_Instance instance,
  40                             uint32_t event_classes) {
  41   VLOG(4) << "PPB_InputEvent::ClearInputEventRequest()";
  42   EnterInstance enter(instance);
  43   if (enter.succeeded())
  44     enter.functions()->ClearInputEventRequest(instance, event_classes);
  45 }
  46
  47 PP_Bool IsInputEvent(PP_Resource resource) {
  48   VLOG(4) << "PPB_InputEvent::IsInputEvent()";
  49   EnterInputEvent enter(resource, false);
  50   return enter.succeeded() ? PP_TRUE : PP_FALSE;
  51 }
  52
  53 PP_InputEvent_Type GetType(PP_Resource event) {
  54   VLOG(4) << "PPB_InputEvent::GetType()";
  55   EnterInputEvent enter(event, true);
  56   if (enter.failed())
  57     return PP_INPUTEVENT_TYPE_UNDEFINED;
  58   return enter.object()->GetType();
  59 }
  60
  61 PP_TimeTicks GetTimeStamp(PP_Resource event) {
  62   VLOG(4) << "PPB_InputEvent::GetTimeStamp()";
  63   EnterInputEvent enter(event, true);
  64   if (enter.failed())
  65     return 0.0;
  66   return enter.object()->GetTimeStamp();
  67 }
  68
  69 uint32_t GetModifiers(PP_Resource event) {
  70   VLOG(4) << "PPB_InputEvent::GetModifiers()";
  71   EnterInputEvent enter(event, true);
  72   if (enter.failed())
  73     return 0;
  74   return enter.object()->GetModifiers();
  75 }
  76
  77 const PPB_InputEvent g_ppb_input_event_thunk = {
  78   &RequestInputEvents,
  79   &RequestFilteringInputEvents,
  80   &ClearInputEventRequest,
  81   &IsInputEvent,
  82   &GetType,
  83   &GetTimeStamp,
  84   &GetModifiers
  85 };
  86
  87 // Mouse -----------------------------------------------------------------------
  88
  89 PP_Resource CreateMouseInputEvent1_0(PP_Instance instance,
  90                                      PP_InputEvent_Type type,
  91                                      PP_TimeTicks time_stamp,
  92                                      uint32_t modifiers,
  93                                      PP_InputEvent_MouseButton mouse_button,
  94                                      const PP_Point* mouse_position,
  95                                      int32_t click_count) {
  96   VLOG(4) << "PPB_MouseInputEvent::Create()";
  97   EnterResourceCreation enter(instance);
  98   if (enter.failed())
  99     return 0;
 100
 101   PP_Point mouse_movement = PP_MakePoint(0, 0);
 102   return enter.functions()->CreateMouseInputEvent(instance, type, time_stamp,
 103                                                   modifiers, mouse_button,
 104                                                   mouse_position, click_count,
 105                                                   &mouse_movement);
 106 }
 107
 108 PP_Resource CreateMouseInputEvent1_1(PP_Instance instance,
 109                                      PP_InputEvent_Type type,
 110                                      PP_TimeTicks time_stamp,
 111                                      uint32_t modifiers,
 112                                      PP_InputEvent_MouseButton mouse_button,
 113                                      const PP_Point* mouse_position,
 114                                      int32_t click_count,
 115                                      const PP_Point* mouse_movement) {
 116   VLOG(4) << "PPB_MouseInputEvent::Create()";
 117   EnterResourceCreation enter(instance);
 118   if (enter.failed())
 119     return 0;
 120   return enter.functions()->CreateMouseInputEvent(instance, type, time_stamp,
 121                                                   modifiers, mouse_button,
 122                                                   mouse_position, click_count,
 123                                                   mouse_movement);
 124 }
 125
 126 PP_Bool IsMouseInputEvent(PP_Resource resource) {
 127   VLOG(4) << "PPB_MouseInputEvent::IsMouseInputEvent()";
 128   if (!IsInputEvent(resource))
 129     return PP_FALSE;  // Prevent warning log in GetType.
 130   PP_InputEvent_Type type = GetType(resource);
 131   return PP_FromBool(type == PP_INPUTEVENT_TYPE_MOUSEDOWN ||
 132                      type == PP_INPUTEVENT_TYPE_MOUSEUP ||
 133                      type == PP_INPUTEVENT_TYPE_MOUSEMOVE ||
 134                      type == PP_INPUTEVENT_TYPE_MOUSEENTER ||
 135                      type == PP_INPUTEVENT_TYPE_MOUSELEAVE ||
 136                      type == PP_INPUTEVENT_TYPE_CONTEXTMENU);
 137 }
 138
 139 PP_InputEvent_MouseButton GetMouseButton(PP_Resource mouse_event) {
 140   VLOG(4) << "PPB_MouseInputEvent::GetButton()";
 141   EnterInputEvent enter(mouse_event, true);
 142   if (enter.failed())
 143     return PP_INPUTEVENT_MOUSEBUTTON_NONE;
 144   return enter.object()->GetMouseButton();
 145 }
 146
 147 PP_Point GetMousePosition(PP_Resource mouse_event) {
 148   VLOG(4) << "PPB_MouseInputEvent::GetPosition()";
 149   EnterInputEvent enter(mouse_event, true);
 150   if (enter.failed())
 151     return PP_MakePoint(0, 0);
 152   return enter.object()->GetMousePosition();
 153 }
 154
 155 int32_t GetMouseClickCount(PP_Resource mouse_event) {
 156   VLOG(4) << "PPB_MouseInputEvent::GetClickCount()";
 157   EnterInputEvent enter(mouse_event, true);
 158   if (enter.failed())
 159     return 0;
 160   return enter.object()->GetMouseClickCount();
 161 }
 162
 163 PP_Point GetMouseMovement(PP_Resource mouse_event) {
 164   VLOG(4) << "PPB_MouseInputEvent::GetMovement()";
 165   EnterInputEvent enter(mouse_event, true);
 166   if (enter.failed())
 167     return PP_MakePoint(0, 0);
 168   return enter.object()->GetMouseMovement();
 169 }
 170
 171 const PPB_MouseInputEvent_1_0 g_ppb_mouse_input_event_1_0_thunk = {
 172   &CreateMouseInputEvent1_0,
 173   &IsMouseInputEvent,
 174   &GetMouseButton,
 175   &GetMousePosition,
 176   &GetMouseClickCount
 177 };
 178
 179 const PPB_MouseInputEvent g_ppb_mouse_input_event_1_1_thunk = {
 180   &CreateMouseInputEvent1_1,
 181   &IsMouseInputEvent,
 182   &GetMouseButton,
 183   &GetMousePosition,
 184   &GetMouseClickCount,
 185   &GetMouseMovement
 186 };
 187
 188 // Wheel -----------------------------------------------------------------------
 189
 190 PP_Resource CreateWheelInputEvent(PP_Instance instance,
 191                                   PP_TimeTicks time_stamp,
 192                                   uint32_t modifiers,
 193                                   const PP_FloatPoint* wheel_delta,
 194                                   const PP_FloatPoint* wheel_ticks,
 195                                   PP_Bool scroll_by_page) {
 196   VLOG(4) << "PPB_WheelInputEvent::Create()";
 197   EnterResourceCreation enter(instance);
 198   if (enter.failed())
 199     return 0;
 200   return enter.functions()->CreateWheelInputEvent(instance, time_stamp,
 201                                                   modifiers, wheel_delta,
 202                                                   wheel_ticks, scroll_by_page);
 203 }
 204
 205 PP_Bool IsWheelInputEvent(PP_Resource resource) {
 206   VLOG(4) << "PPB_WheelInputEvent::IsWheelInputEvent()";
 207   if (!IsInputEvent(resource))
 208     return PP_FALSE;  // Prevent warning log in GetType.
 209   PP_InputEvent_Type type = GetType(resource);
 210   return PP_FromBool(type == PP_INPUTEVENT_TYPE_WHEEL);
 211 }
 212
 213 PP_FloatPoint GetWheelDelta(PP_Resource wheel_event) {
 214   VLOG(4) << "PPB_WheelInputEvent::GetDelta()";
 215   EnterInputEvent enter(wheel_event, true);
 216   if (enter.failed())
 217     return PP_MakeFloatPoint(0.0f, 0.0f);
 218   return enter.object()->GetWheelDelta();
 219 }
 220
 221 PP_FloatPoint GetWheelTicks(PP_Resource wheel_event) {
 222   VLOG(4) << "PPB_WheelInputEvent::GetTicks()";
 223   EnterInputEvent enter(wheel_event, true);
 224   if (enter.failed())
 225     return PP_MakeFloatPoint(0.0f, 0.0f);
 226   return enter.object()->GetWheelTicks();
 227 }
 228
 229 PP_Bool GetWheelScrollByPage(PP_Resource wheel_event) {
 230   VLOG(4) << "PPB_WheelInputEvent::GetScrollByPage()";
 231   EnterInputEvent enter(wheel_event, true);
 232   if (enter.failed())
 233     return PP_FALSE;
 234   return enter.object()->GetWheelScrollByPage();
 235 }
 236
 237 const PPB_WheelInputEvent g_ppb_wheel_input_event_thunk = {
 238   &CreateWheelInputEvent,
 239   &IsWheelInputEvent,
 240   &GetWheelDelta,
 241   &GetWheelTicks,
 242   &GetWheelScrollByPage
 243 };
 244
 245 // Keyboard --------------------------------------------------------------------
 246
 247 PP_Resource CreateKeyboardInputEvent(PP_Instance instance,
 248                                      PP_InputEvent_Type type,
 249                                      PP_TimeTicks time_stamp,
 250                                      uint32_t modifiers,
 251                                      uint32_t key_code,
 252                                      struct PP_Var character_text) {
 253   VLOG(4) << "PPB_KeyboardInputEvent::Create()";
 254   EnterResourceCreation enter(instance);
 255   if (enter.failed())
 256     return 0;
 257   return enter.functions()->CreateKeyboardInputEvent(instance, type, time_stamp,
 258                                                      modifiers, key_code,
 259                                                      character_text);
 260 }
 261
 262 PP_Bool IsKeyboardInputEvent(PP_Resource resource) {
 263   VLOG(4) << "PPB_KeyboardInputEvent::IsKeyboardInputEvent()";
 264   if (!IsInputEvent(resource))
 265     return PP_FALSE;  // Prevent warning log in GetType.
 266   PP_InputEvent_Type type = GetType(resource);
 267   return PP_FromBool(type == PP_INPUTEVENT_TYPE_KEYDOWN ||
 268                      type == PP_INPUTEVENT_TYPE_KEYUP ||
 269                      type == PP_INPUTEVENT_TYPE_RAWKEYDOWN ||
 270                      type == PP_INPUTEVENT_TYPE_CHAR);
 271 }
 272
 273 uint32_t GetKeyCode(PP_Resource key_event) {
 274   VLOG(4) << "PPB_KeyboardInputEvent::GetKeyCode()";
 275   EnterInputEvent enter(key_event, true);
 276   if (enter.failed())
 277     return 0;
 278   return enter.object()->GetKeyCode();
 279 }
 280
 281 PP_Var GetCharacterText(PP_Resource character_event) {
 282   VLOG(4) << "PPB_KeyboardInputEvent::GetCharacterText()";
 283   EnterInputEvent enter(character_event, true);
 284   if (enter.failed())
 285     return PP_MakeUndefined();
 286   return enter.object()->GetCharacterText();
 287 }
 288
 289 const PPB_KeyboardInputEvent g_ppb_keyboard_input_event_thunk = {
 290   &CreateKeyboardInputEvent,
 291   &IsKeyboardInputEvent,
 292   &GetKeyCode,
 293   &GetCharacterText
 294 };
 295
 296 // _Dev interface.
 297
 298 PP_Bool SetUsbKeyCode(PP_Resource key_event, uint32_t usb_key_code) {
 299   VLOG(4) << "PPB_KeyboardInputEvent_Dev::SetUsbKeyCode()";
 300   EnterInputEvent enter(key_event, true);
 301   if (enter.failed())
 302     return PP_FALSE;
 303   return enter.object()->SetUsbKeyCode(usb_key_code);
 304 }
 305
 306 uint32_t GetUsbKeyCode(PP_Resource key_event) {
 307   VLOG(4) << "PPB_KeyboardInputEvent_Dev::GetUsbKeyCode()";
 308   EnterInputEvent enter(key_event, true);
 309   if (enter.failed())
 310     return 0;
 311   return enter.object()->GetUsbKeyCode();
 312 }
 313
 314 PP_Var GetCode(PP_Resource key_event) {
 315   VLOG(4) << "PPB_KeyboardInputEvent_Dev::GetCode()";
 316   EnterInputEvent enter(key_event, true);
 317   if (enter.failed())
 318     return PP_MakeUndefined();
 319   return enter.object()->GetCode();
 320 }
 321
 322 const PPB_KeyboardInputEvent_Dev_0_2
 323     g_ppb_keyboard_input_event_dev_0_2_thunk = {
 324   &SetUsbKeyCode,
 325   &GetUsbKeyCode,
 326   &GetCode,
 327 };
 328
 329 // Composition -----------------------------------------------------------------
 330
 331 PP_Resource CreateIMEInputEvent(PP_Instance instance,
 332                                 PP_InputEvent_Type type,
 333                                 PP_TimeTicks time_stamp,
 334                                 PP_Var text,
 335                                 uint32_t segment_number,
 336                                 const uint32_t segment_offsets[],
 337                                 int32_t target_segment,
 338                                 uint32_t selection_start,
 339                                 uint32_t selection_end) {
 340   VLOG(4) << "PPB_IMEInputEvent_Dev::Create()";
 341   EnterResourceCreation enter(instance);
 342   if (enter.failed())
 343     return 0;
 344   return enter.functions()->CreateIMEInputEvent(instance, type, time_stamp,
 345                                                 text, segment_number,
 346                                                 segment_offsets,
 347                                                 target_segment,
 348                                                 selection_start,
 349                                                 selection_end);
 350 }
 351
 352 PP_Bool IsIMEInputEvent(PP_Resource resource) {
 353   VLOG(4) << "PPB_IMEInputEvent_Dev::IsIMEInputEvent()";
 354   if (!IsInputEvent(resource))
 355     return PP_FALSE;  // Prevent warning log in GetType.
 356   PP_InputEvent_Type type = GetType(resource);
 357   return PP_FromBool(type == PP_INPUTEVENT_TYPE_IME_COMPOSITION_START ||
 358                      type == PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE ||
 359                      type == PP_INPUTEVENT_TYPE_IME_COMPOSITION_END ||
 360                      type == PP_INPUTEVENT_TYPE_IME_TEXT);
 361 }
 362
 363 PP_Var GetIMEText(PP_Resource ime_event) {
 364   VLOG(4) << "PPB_IMEInputEvent_Dev::GetText()";
 365   return GetCharacterText(ime_event);
 366 }
 367
 368 uint32_t GetIMESegmentNumber(PP_Resource ime_event) {
 369   VLOG(4) << "PPB_IMEInputEvent_Dev::GetSegmentNumber()";
 370   EnterInputEvent enter(ime_event, true);
 371   if (enter.failed())
 372     return 0;
 373   return enter.object()->GetIMESegmentNumber();
 374 }
 375
 376 uint32_t GetIMESegmentOffset(PP_Resource ime_event, uint32_t index) {
 377   VLOG(4) << "PPB_IMEInputEvent_Dev::GetSegmentOffset()";
 378   EnterInputEvent enter(ime_event, true);
 379   if (enter.failed())
 380     return 0;
 381   return enter.object()->GetIMESegmentOffset(index);
 382 }
 383
 384 int32_t GetIMETargetSegment(PP_Resource ime_event) {
 385   VLOG(4) << "PPB_IMEInputEvent_Dev::GetTargetSegment()";
 386   EnterInputEvent enter(ime_event, true);
 387   if (enter.failed())
 388     return -1;
 389   return enter.object()->GetIMETargetSegment();
 390 }
 391
 392 void GetIMESelection(PP_Resource ime_event, uint32_t* start, uint32_t* end) {
 393   VLOG(4) << "PPB_IMEInputEvent_Dev::GetSelection()";
 394   EnterInputEvent enter(ime_event, true);
 395   if (enter.failed()) {
 396     if (start)
 397       *start = 0;
 398     if (end)
 399       *end = 0;
 400     return;
 401   }
 402   enter.object()->GetIMESelection(start, end);
 403 }
 404
 405 const PPB_IMEInputEvent_Dev_0_1 g_ppb_ime_input_event_0_1_thunk = {
 406   &IsIMEInputEvent,
 407   &GetIMEText,
 408   &GetIMESegmentNumber,
 409   &GetIMESegmentOffset,
 410   &GetIMETargetSegment,
 411   &GetIMESelection
 412 };
 413
 414 const PPB_IMEInputEvent_Dev_0_2 g_ppb_ime_input_event_0_2_thunk = {
 415   &CreateIMEInputEvent,
 416   &IsIMEInputEvent,
 417   &GetIMEText,
 418   &GetIMESegmentNumber,
 419   &GetIMESegmentOffset,
 420   &GetIMETargetSegment,
 421   &GetIMESelection
 422 };
 423
 424 const PPB_IMEInputEvent_1_0 g_ppb_ime_input_event_1_0_thunk = {
 425   &CreateIMEInputEvent,
 426   &IsIMEInputEvent,
 427   &GetIMEText,
 428   &GetIMESegmentNumber,
 429   &GetIMESegmentOffset,
 430   &GetIMETargetSegment,
 431   &GetIMESelection
 432 };
 433
 434 // Touch -----------------------------------------------------------------------
 435
 436 PP_Resource CreateTouchInputEvent(PP_Instance instance,
 437                                   PP_InputEvent_Type type,
 438                                   PP_TimeTicks time_stamp,
 439                                   uint32_t modifiers) {
 440   VLOG(4) << "PPB_TouchInputEvent::Create()";
 441   EnterResourceCreation enter(instance);
 442   if (enter.failed())
 443     return 0;
 444   return enter.functions()->CreateTouchInputEvent(instance, type, time_stamp,
 445                                                   modifiers);
 446 }
 447
 448 void AddTouchPoint(PP_Resource touch_event,
 449                    PP_TouchListType list,
 450                    const PP_TouchPoint* point) {
 451   VLOG(4) << "PPB_TouchInputEvent::AddTouchPoint()";
 452   EnterInputEvent enter(touch_event, true);
 453   if (enter.failed())
 454     return;
 455   return enter.object()->AddTouchPoint(list, *point);
 456 }
 457
 458 PP_Bool IsTouchInputEvent(PP_Resource resource) {
 459   VLOG(4) << "PPB_TouchInputEvent::IsTouchInputEvent()";
 460   if (!IsInputEvent(resource))
 461     return PP_FALSE;  // Prevent warning log in GetType.
 462   PP_InputEvent_Type type = GetType(resource);
 463   return PP_FromBool(type == PP_INPUTEVENT_TYPE_TOUCHSTART ||
 464                      type == PP_INPUTEVENT_TYPE_TOUCHMOVE ||
 465                      type == PP_INPUTEVENT_TYPE_TOUCHEND ||
 466                      type == PP_INPUTEVENT_TYPE_TOUCHCANCEL);
 467 }
 468
 469 uint32_t GetTouchCount(PP_Resource touch_event, PP_TouchListType list) {
 470   VLOG(4) << "PPB_TouchInputEvent::GetTouchCount()";
 471   EnterInputEvent enter(touch_event, true);
 472   if (enter.failed())
 473     return 0;
 474   return enter.object()->GetTouchCount(list);
 475 }
 476
 477 struct PP_TouchPoint GetTouchByIndex(PP_Resource touch_event,
 478                                      PP_TouchListType list,
 479                                      uint32_t index) {
 480   VLOG(4) << "PPB_TouchInputEvent::GetTouchByIndex()";
 481   EnterInputEvent enter(touch_event, true);
 482   if (enter.failed())
 483     return PP_MakeTouchPoint();
 484   return enter.object()->GetTouchByIndex(list, index);
 485 }
 486
 487 struct PP_TouchPoint GetTouchById(PP_Resource touch_event,
 488                                   PP_TouchListType list,
 489                                   uint32_t id) {
 490   VLOG(4) << "PPB_TouchInputEvent::GetTouchById()";
 491   EnterInputEvent enter(touch_event, true);
 492   if (enter.failed())
 493     return PP_MakeTouchPoint();
 494   return enter.object()->GetTouchById(list, id);
 495 }
 496
 497 const PPB_TouchInputEvent_1_0 g_ppb_touch_input_event_thunk = {
 498   &CreateTouchInputEvent,
 499   &AddTouchPoint,
 500   &IsTouchInputEvent,
 501   &GetTouchCount,
 502   &GetTouchByIndex,
 503   &GetTouchById
 504 };
 505
 506 }  // namespace
 507
 508 const PPB_InputEvent_1_0* GetPPB_InputEvent_1_0_Thunk() {
 509   return &g_ppb_input_event_thunk;
 510 }
 511
 512 const PPB_MouseInputEvent_1_0* GetPPB_MouseInputEvent_1_0_Thunk() {
 513   return &g_ppb_mouse_input_event_1_0_thunk;
 514 }
 515
 516 const PPB_MouseInputEvent_1_1* GetPPB_MouseInputEvent_1_1_Thunk() {
 517   return &g_ppb_mouse_input_event_1_1_thunk;
 518 }
 519
 520 const PPB_KeyboardInputEvent_1_0* GetPPB_KeyboardInputEvent_1_0_Thunk() {
 521   return &g_ppb_keyboard_input_event_thunk;
 522 }
 523
 524 const PPB_KeyboardInputEvent_Dev_0_2*
 525     GetPPB_KeyboardInputEvent_Dev_0_2_Thunk() {
 526   return &g_ppb_keyboard_input_event_dev_0_2_thunk;
 527 }
 528
 529 const PPB_WheelInputEvent_1_0* GetPPB_WheelInputEvent_1_0_Thunk() {
 530   return &g_ppb_wheel_input_event_thunk;
 531 }
 532
 533 const PPB_IMEInputEvent_Dev_0_1* GetPPB_IMEInputEvent_Dev_0_1_Thunk() {
 534   return &g_ppb_ime_input_event_0_1_thunk;
 535 }
 536
 537 const PPB_IMEInputEvent_Dev_0_2* GetPPB_IMEInputEvent_Dev_0_2_Thunk() {
 538   return &g_ppb_ime_input_event_0_2_thunk;
 539 }
 540
 541 const PPB_IMEInputEvent_1_0* GetPPB_IMEInputEvent_1_0_Thunk() {
 542   return &g_ppb_ime_input_event_1_0_thunk;
 543 }
 544
 545 const PPB_TouchInputEvent_1_0* GetPPB_TouchInputEvent_1_0_Thunk() {
 546   return &g_ppb_touch_input_event_thunk;
 547 }
 548
 549 }  // namespace thunk
 550 }  // namespace ppapi