ui/ozone/platform/caca/caca_event_factory.cc

   1 // Copyright 2014 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 "ui/ozone/platform/caca/caca_event_factory.h"
   6
   7 #include <caca.h>
   8
   9 #include "base/bind.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "ui/events/event.h"
  12 #include "ui/events/keycodes/keyboard_codes.h"
  13 #include "ui/ozone/platform/caca/caca_connection.h"
  14
  15 namespace ui {
  16
  17 namespace {
  18
  19 ui::KeyboardCode GetKeyboardCode(const caca_event_t& event) {
  20   // List of special mappings the Caca provides.
  21   static const ui::KeyboardCode kCacaKeyMap[] = {
  22     ui::VKEY_UNKNOWN,
  23     ui::VKEY_A,
  24     ui::VKEY_B,
  25     ui::VKEY_C,
  26     ui::VKEY_D,
  27     ui::VKEY_E,
  28     ui::VKEY_F,
  29     ui::VKEY_G,
  30     ui::VKEY_BACK,
  31     ui::VKEY_TAB,
  32     ui::VKEY_J,
  33     ui::VKEY_K,
  34     ui::VKEY_L,
  35     ui::VKEY_RETURN,
  36     ui::VKEY_N,
  37     ui::VKEY_O,
  38     ui::VKEY_P,
  39     ui::VKEY_Q,
  40     ui::VKEY_R,
  41     ui::VKEY_PAUSE,
  42     ui::VKEY_T,
  43     ui::VKEY_U,
  44     ui::VKEY_V,
  45     ui::VKEY_W,
  46     ui::VKEY_X,
  47     ui::VKEY_Y,
  48     ui::VKEY_Z,
  49     ui::VKEY_ESCAPE,
  50     ui::VKEY_DELETE,
  51     ui::VKEY_UP,
  52     ui::VKEY_DOWN,
  53     ui::VKEY_LEFT,
  54     ui::VKEY_RIGHT,
  55     ui::VKEY_INSERT,
  56     ui::VKEY_HOME,
  57     ui::VKEY_END,
  58     ui::VKEY_PRIOR,
  59     ui::VKEY_NEXT,
  60     ui::VKEY_F1,
  61     ui::VKEY_F2,
  62     ui::VKEY_F3,
  63     ui::VKEY_F4,
  64     ui::VKEY_F5,
  65     ui::VKEY_F6,
  66     ui::VKEY_F7,
  67     ui::VKEY_F8,
  68     ui::VKEY_F9,
  69     ui::VKEY_F10,
  70     ui::VKEY_F11,
  71     ui::VKEY_F12,
  72   };
  73
  74   int key_code = caca_get_event_key_ch(&event);
  75   if (key_code >= 'a' && key_code <= 'z')
  76     return static_cast<ui::KeyboardCode>(key_code - ('a' - 'A'));
  77   if (key_code >= '0' && key_code <= 'Z')
  78     return static_cast<ui::KeyboardCode>(key_code);
  79   if (static_cast<unsigned int>(key_code) < arraysize(kCacaKeyMap))
  80     return kCacaKeyMap[key_code];
  81
  82   return ui::VKEY_UNKNOWN;
  83 }
  84
  85 int ModifierFromKey(const caca_event_t& event) {
  86   int key_code = caca_get_event_key_ch(&event);
  87   if (key_code >= 'A' && key_code <= 'Z')
  88     return ui::EF_SHIFT_DOWN;
  89   if ((key_code >= CACA_KEY_CTRL_A && key_code <= CACA_KEY_CTRL_G) ||
  90       (key_code >= CACA_KEY_CTRL_J && key_code <= CACA_KEY_CTRL_L) ||
  91       (key_code >= CACA_KEY_CTRL_N && key_code <= CACA_KEY_CTRL_R) ||
  92       (key_code >= CACA_KEY_CTRL_T && key_code <= CACA_KEY_CTRL_Z))
  93     return ui::EF_CONTROL_DOWN;
  94
  95   return ui::EF_NONE;
  96 }
  97
  98 int ModifierFromButton(const caca_event_t& event) {
  99   switch (caca_get_event_mouse_button(&event)) {
 100     case 1:
 101       return ui::EF_LEFT_MOUSE_BUTTON;
 102     case 2:
 103       return ui::EF_RIGHT_MOUSE_BUTTON;
 104     case 3:
 105       return ui::EF_MIDDLE_MOUSE_BUTTON;
 106   }
 107   return 0;
 108 }
 109
 110 // Translate coordinates to bitmap coordinates.
 111 gfx::PointF TranslateLocation(const gfx::PointF& location,
 112                               CacaConnection* connection) {
 113   gfx::Size physical_size = connection->physical_size();
 114   gfx::Size bitmap_size = connection->bitmap_size();
 115   return gfx::PointF(
 116       location.x() * bitmap_size.width() / physical_size.width(),
 117       location.y() * bitmap_size.height() / physical_size.height());
 118 }
 119
 120 ui::EventType GetEventTypeFromNative(const caca_event_t& event) {
 121   switch (caca_get_event_type(&event)) {
 122     case CACA_EVENT_KEY_PRESS:
 123       return ui::ET_KEY_PRESSED;
 124     case CACA_EVENT_KEY_RELEASE:
 125       return ui::ET_KEY_RELEASED;
 126     case CACA_EVENT_MOUSE_PRESS:
 127       return ui::ET_MOUSE_PRESSED;
 128     case CACA_EVENT_MOUSE_RELEASE:
 129       return ui::ET_MOUSE_RELEASED;
 130     case CACA_EVENT_MOUSE_MOTION:
 131       return ui::ET_MOUSE_MOVED;
 132     default:
 133       return ui::ET_UNKNOWN;
 134   }
 135 }
 136
 137 }  // namespace
 138
 139 CacaEventFactory::CacaEventFactory(CacaConnection* connection)
 140   : connection_(connection),
 141     weak_ptr_factory_(this),
 142     delay_(base::TimeDelta::FromMilliseconds(10)),
 143     modifier_flags_(0) {
 144 }
 145
 146 CacaEventFactory::~CacaEventFactory() {
 147 }
 148
 149 void CacaEventFactory::WarpCursorTo(gfx::AcceleratedWidget widget,
 150                                     const gfx::PointF& location) {
 151   NOTIMPLEMENTED();
 152 }
 153
 154 void CacaEventFactory::OnDispatcherListChanged() {
 155   ScheduleEventProcessing();
 156 }
 157
 158 void CacaEventFactory::ScheduleEventProcessing() {
 159   // Caca uses a poll based event retrieval. Since we don't want to block we'd
 160   // either need to spin up a new thread or just poll. For simplicity just poll
 161   // for a message every |delay_| time delta.
 162   base::MessageLoop::current()->PostDelayedTask(
 163       FROM_HERE,
 164       base::Bind(&CacaEventFactory::TryProcessingEvent,
 165                  weak_ptr_factory_.GetWeakPtr()),
 166       delay_);
 167 }
 168
 169 void CacaEventFactory::TryProcessingEvent() {
 170   caca_event_t event;
 171   int event_mask = CACA_EVENT_KEY_PRESS | CACA_EVENT_KEY_RELEASE |
 172                    CACA_EVENT_MOUSE_PRESS | CACA_EVENT_MOUSE_RELEASE |
 173                    CACA_EVENT_MOUSE_MOTION;
 174   if (connection_->display() &&
 175       caca_get_event(connection_->display(), event_mask, &event, 0)) {
 176
 177     ui::EventType type = GetEventTypeFromNative(event);
 178     bool pressed = type == ui::ET_KEY_PRESSED || type == ui::ET_MOUSE_PRESSED;
 179
 180     switch (type) {
 181       case ui::ET_KEY_PRESSED:
 182       case ui::ET_KEY_RELEASED: {
 183         if (pressed)
 184           modifier_flags_ |= ModifierFromKey(event);
 185         else
 186           modifier_flags_ &= ~ModifierFromKey(event);
 187
 188         ui::KeyEvent key_event(
 189             type, GetKeyboardCode(event), modifier_flags_, true);
 190         DispatchEvent(&key_event);
 191         break;
 192       }
 193       case ui::ET_MOUSE_MOVED:
 194         last_cursor_location_.SetPoint(caca_get_event_mouse_x(&event),
 195                                        caca_get_event_mouse_y(&event));
 196         // Update cursor location.
 197         caca_gotoxy(caca_get_canvas(connection_->display()),
 198                     last_cursor_location_.x(),
 199                     last_cursor_location_.y());
 200       // fallthrough
 201       case ui::ET_MOUSE_PRESSED:
 202       case ui::ET_MOUSE_RELEASED: {
 203         int flags = 0;
 204         int changed_flags = 0;
 205         if (type != ui::ET_MOUSE_MOVED) {
 206           if (pressed) {
 207             changed_flags = ModifierFromButton(event);
 208             modifier_flags_ |= changed_flags;
 209           } else {
 210             modifier_flags_ &= ~changed_flags;
 211           }
 212           // On release the button pressed is removed from |modifier_flags_|,
 213           // but sending the event needs it set.
 214           flags = modifier_flags_ | changed_flags;
 215         }
 216         gfx::PointF location = TranslateLocation(last_cursor_location_,
 217                                                  connection_);
 218         ui::MouseEvent mouse_event(
 219             type, location, location, flags, changed_flags);
 220         DispatchEvent(&mouse_event);
 221         break;
 222       }
 223       default:
 224         NOTIMPLEMENTED();
 225         break;
 226     }
 227   }
 228
 229   ScheduleEventProcessing();
 230 }
 231
 232 }  // namespace ui