OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "mojo/converters/input_events/input_events_type_converters.h" | 5 #include "mojo/converters/input_events/input_events_type_converters.h" |
6 | 6 |
7 #if defined(USE_X11) | 7 #if defined(USE_X11) |
8 #include <X11/extensions/XInput2.h> | 8 #include <X11/extensions/XInput2.h> |
9 #include <X11/Xlib.h> | 9 #include <X11/Xlib.h> |
10 #endif | 10 #endif |
(...skipping 12 matching lines...) Expand all Loading... |
23 DCHECK_EQ(POINTER_KIND_MOUSE, event->pointer_data->kind); | 23 DCHECK_EQ(POINTER_KIND_MOUSE, event->pointer_data->kind); |
24 switch (event->action) { | 24 switch (event->action) { |
25 case EVENT_TYPE_POINTER_DOWN: | 25 case EVENT_TYPE_POINTER_DOWN: |
26 return ui::ET_MOUSE_PRESSED; | 26 return ui::ET_MOUSE_PRESSED; |
27 | 27 |
28 case EVENT_TYPE_POINTER_UP: | 28 case EVENT_TYPE_POINTER_UP: |
29 return ui::ET_MOUSE_RELEASED; | 29 return ui::ET_MOUSE_RELEASED; |
30 | 30 |
31 case EVENT_TYPE_POINTER_MOVE: | 31 case EVENT_TYPE_POINTER_MOVE: |
32 DCHECK(event->pointer_data); | 32 DCHECK(event->pointer_data); |
| 33 if (event->pointer_data->horizontal_wheel != 0 || |
| 34 event->pointer_data->vertical_wheel != 0) { |
| 35 return ui::ET_MOUSEWHEEL; |
| 36 } |
33 if (event->flags & | 37 if (event->flags & |
34 (EVENT_FLAGS_LEFT_MOUSE_BUTTON | EVENT_FLAGS_MIDDLE_MOUSE_BUTTON | | 38 (EVENT_FLAGS_LEFT_MOUSE_BUTTON | EVENT_FLAGS_MIDDLE_MOUSE_BUTTON | |
35 EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) { | 39 EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) { |
36 return ui::ET_MOUSE_DRAGGED; | 40 return ui::ET_MOUSE_DRAGGED; |
37 } | 41 } |
38 return ui::ET_MOUSE_MOVED; | 42 return ui::ET_MOUSE_MOVED; |
39 | 43 |
40 default: | 44 default: |
41 NOTREACHED(); | 45 NOTREACHED(); |
42 } | 46 } |
(...skipping 17 matching lines...) Expand all Loading... |
60 case EVENT_TYPE_POINTER_CANCEL: | 64 case EVENT_TYPE_POINTER_CANCEL: |
61 return ui::ET_TOUCH_CANCELLED; | 65 return ui::ET_TOUCH_CANCELLED; |
62 | 66 |
63 default: | 67 default: |
64 NOTREACHED(); | 68 NOTREACHED(); |
65 } | 69 } |
66 | 70 |
67 return ui::ET_TOUCH_CANCELLED; | 71 return ui::ET_TOUCH_CANCELLED; |
68 } | 72 } |
69 | 73 |
70 ui::EventType MojoWheelEventTypeToUIEvent(const EventPtr& event) { | |
71 DCHECK(!event->wheel_data.is_null()); | |
72 return ui::ET_MOUSEWHEEL; | |
73 } | |
74 | |
75 void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event, | 74 void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event, |
76 mojo::LocationData* location_data) { | 75 PointerData* pointer_data) { |
77 location_data->x = located_event.location_f().x(); | 76 pointer_data->x = located_event.location_f().x(); |
78 location_data->y = located_event.location_f().y(); | 77 pointer_data->y = located_event.location_f().y(); |
79 location_data->screen_x = located_event.root_location_f().x(); | 78 pointer_data->screen_x = located_event.root_location_f().x(); |
80 location_data->screen_y = located_event.root_location_f().y(); | 79 pointer_data->screen_y = located_event.root_location_f().y(); |
81 } | 80 } |
82 | 81 |
83 } // namespace | 82 } // namespace |
84 | 83 |
85 COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_NONE) == | 84 COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_NONE) == |
86 static_cast<int32>(ui::EF_NONE), | 85 static_cast<int32>(ui::EF_NONE), |
87 event_flags_should_match); | 86 event_flags_should_match); |
88 COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_CAPS_LOCK_DOWN) == | 87 COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_CAPS_LOCK_DOWN) == |
89 static_cast<int32>(ui::EF_CAPS_LOCK_DOWN), | 88 static_cast<int32>(ui::EF_CAPS_LOCK_DOWN), |
90 event_flags_should_match); | 89 event_flags_should_match); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 switch (type) { | 127 switch (type) { |
129 case ui::ET_MOUSE_PRESSED: | 128 case ui::ET_MOUSE_PRESSED: |
130 case ui::ET_TOUCH_PRESSED: | 129 case ui::ET_TOUCH_PRESSED: |
131 return EVENT_TYPE_POINTER_DOWN; | 130 return EVENT_TYPE_POINTER_DOWN; |
132 | 131 |
133 case ui::ET_MOUSE_DRAGGED: | 132 case ui::ET_MOUSE_DRAGGED: |
134 case ui::ET_MOUSE_MOVED: | 133 case ui::ET_MOUSE_MOVED: |
135 case ui::ET_MOUSE_ENTERED: | 134 case ui::ET_MOUSE_ENTERED: |
136 case ui::ET_MOUSE_EXITED: | 135 case ui::ET_MOUSE_EXITED: |
137 case ui::ET_TOUCH_MOVED: | 136 case ui::ET_TOUCH_MOVED: |
| 137 case ui::ET_MOUSEWHEEL: |
138 return EVENT_TYPE_POINTER_MOVE; | 138 return EVENT_TYPE_POINTER_MOVE; |
139 | 139 |
140 case ui::ET_MOUSEWHEEL: | |
141 return EVENT_TYPE_WHEEL; | |
142 | |
143 case ui::ET_MOUSE_RELEASED: | 140 case ui::ET_MOUSE_RELEASED: |
144 case ui::ET_TOUCH_RELEASED: | 141 case ui::ET_TOUCH_RELEASED: |
145 return EVENT_TYPE_POINTER_UP; | 142 return EVENT_TYPE_POINTER_UP; |
146 | 143 |
147 case ui::ET_TOUCH_CANCELLED: | 144 case ui::ET_TOUCH_CANCELLED: |
148 return EVENT_TYPE_POINTER_CANCEL; | 145 return EVENT_TYPE_POINTER_CANCEL; |
149 | 146 |
150 case ui::ET_KEY_PRESSED: | 147 case ui::ET_KEY_PRESSED: |
151 return EVENT_TYPE_KEY_PRESSED; | 148 return EVENT_TYPE_KEY_PRESSED; |
152 | 149 |
153 case ui::ET_KEY_RELEASED: | 150 case ui::ET_KEY_RELEASED: |
154 return EVENT_TYPE_KEY_RELEASED; | 151 return EVENT_TYPE_KEY_RELEASED; |
155 | 152 |
156 default: | 153 default: |
157 break; | 154 break; |
158 } | 155 } |
159 return EVENT_TYPE_UNKNOWN; | 156 return EVENT_TYPE_UNKNOWN; |
160 } | 157 } |
161 | 158 |
162 EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) { | 159 EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) { |
163 const EventType type = ConvertTo<EventType>(input.type()); | 160 const EventType type = ConvertTo<EventType>(input.type()); |
164 if (type == EVENT_TYPE_UNKNOWN) | 161 if (type == EVENT_TYPE_UNKNOWN) |
165 return nullptr; | 162 return nullptr; |
166 | 163 |
167 EventPtr event = Event::New(); | 164 EventPtr event = Event::New(); |
168 event->action = type; | 165 event->action = type; |
169 event->flags = EventFlags(input.flags()); | 166 event->flags = EventFlags(input.flags()); |
170 event->time_stamp = input.time_stamp().ToInternalValue(); | 167 event->time_stamp = input.time_stamp().ToInternalValue(); |
171 | 168 |
172 if (input.IsMouseWheelEvent()) { | 169 PointerData pointer_data; |
173 const ui::MouseWheelEvent* wheel_event = | 170 if (input.IsMouseEvent()) { |
174 static_cast<const ui::MouseWheelEvent*>(&input); | |
175 | |
176 WheelDataPtr wheel_data(WheelData::New()); | |
177 LocationDataPtr location_data(LocationData::New()); | |
178 const ui::LocatedEvent* located_event = | |
179 static_cast<const ui::LocatedEvent*>(&input); | |
180 SetPointerDataLocationFromEvent(*located_event, location_data.get()); | |
181 wheel_data->location = location_data.Pass(); | |
182 | |
183 // TODO(rjkroege): Support page scrolling on windows by directly | |
184 // cracking into a mojo event when the native event is available. | |
185 wheel_data->mode = WHEEL_MODE_LINE; | |
186 // TODO(rjkroege): Support precise scrolling deltas. | |
187 | |
188 if ((input.flags() & ui::EF_SHIFT_DOWN) != 0 && | |
189 wheel_event->x_offset() == 0) { | |
190 wheel_data->delta_x = wheel_event->y_offset(); | |
191 wheel_data->delta_y = 0; | |
192 wheel_data->delta_z = 0; | |
193 } else { | |
194 // TODO(rjkroege): support z in ui::Events. | |
195 wheel_data->delta_x = wheel_event->x_offset(); | |
196 wheel_data->delta_y = wheel_event->y_offset(); | |
197 wheel_data->delta_z = 0; | |
198 } | |
199 event->wheel_data = wheel_data.Pass(); | |
200 } else if (input.IsMouseEvent()) { | |
201 const ui::LocatedEvent* located_event = | 171 const ui::LocatedEvent* located_event = |
202 static_cast<const ui::LocatedEvent*>(&input); | 172 static_cast<const ui::LocatedEvent*>(&input); |
203 PointerDataPtr pointer_data(PointerData::New()); | 173 PointerDataPtr pointer_data(PointerData::New()); |
204 // TODO(sky): come up with a better way to handle this. | 174 // TODO(sky): come up with a better way to handle this. |
205 pointer_data->pointer_id = std::numeric_limits<int32>::max(); | 175 pointer_data->pointer_id = std::numeric_limits<int32>::max(); |
206 pointer_data->kind = POINTER_KIND_MOUSE; | 176 pointer_data->kind = POINTER_KIND_MOUSE; |
207 LocationDataPtr location_data(LocationData::New()); | 177 SetPointerDataLocationFromEvent(*located_event, pointer_data.get()); |
208 SetPointerDataLocationFromEvent(*located_event, location_data.get()); | 178 if (input.IsMouseWheelEvent()) { |
209 pointer_data->location = location_data.Pass(); | 179 const ui::MouseWheelEvent* wheel_event = |
210 | 180 static_cast<const ui::MouseWheelEvent*>(&input); |
| 181 // This conversion assumes we're using the mojo meaning of these values: |
| 182 // [-1 1]. |
| 183 pointer_data->horizontal_wheel = |
| 184 static_cast<float>(wheel_event->x_offset()) / 100.0f; |
| 185 pointer_data->vertical_wheel = |
| 186 static_cast<float>(wheel_event->y_offset()) / 100.0f; |
| 187 } |
211 event->pointer_data = pointer_data.Pass(); | 188 event->pointer_data = pointer_data.Pass(); |
212 } else if (input.IsTouchEvent()) { | 189 } else if (input.IsTouchEvent()) { |
213 const ui::TouchEvent* touch_event = | 190 const ui::TouchEvent* touch_event = |
214 static_cast<const ui::TouchEvent*>(&input); | 191 static_cast<const ui::TouchEvent*>(&input); |
215 | |
216 PointerDataPtr pointer_data(PointerData::New()); | 192 PointerDataPtr pointer_data(PointerData::New()); |
217 pointer_data->pointer_id = touch_event->touch_id(); | 193 pointer_data->pointer_id = touch_event->touch_id(); |
218 pointer_data->kind = POINTER_KIND_TOUCH; | 194 pointer_data->kind = POINTER_KIND_TOUCH; |
219 LocationDataPtr location_data(LocationData::New()); | 195 SetPointerDataLocationFromEvent(*touch_event, pointer_data.get()); |
220 SetPointerDataLocationFromEvent(*touch_event, location_data.get()); | 196 pointer_data->radius_major = touch_event->pointer_details().radius_x(); |
221 pointer_data->location = location_data.Pass(); | 197 pointer_data->radius_minor = touch_event->pointer_details().radius_y(); |
222 | 198 pointer_data->pressure = touch_event->pointer_details().force(); |
223 BrushDataPtr brush_data(BrushData::New()); | 199 pointer_data->orientation = touch_event->rotation_angle(); |
224 | |
225 // TODO(rjk): this is in the wrong coordinate system | |
226 brush_data->width = touch_event->pointer_details().radius_x(); | |
227 brush_data->height = touch_event->pointer_details().radius_y(); | |
228 // TODO(rjk): update for touch_event->rotation_angle(); | |
229 brush_data->pressure = touch_event->pointer_details().force(); | |
230 brush_data->tiltY = 0; | |
231 brush_data->tiltZ = 0; | |
232 pointer_data->brush_data = brush_data.Pass(); | |
233 event->pointer_data = pointer_data.Pass(); | 200 event->pointer_data = pointer_data.Pass(); |
234 | |
235 // TODO(rjkroege): Plumb raw pointer events on windows. | |
236 // TODO(rjkroege): Handle force-touch on MacOS | |
237 // TODO(rjkroege): Adjust brush data appropriately for Android. | |
238 } else if (input.IsKeyEvent()) { | 201 } else if (input.IsKeyEvent()) { |
239 const ui::KeyEvent* key_event = static_cast<const ui::KeyEvent*>(&input); | 202 const ui::KeyEvent* key_event = static_cast<const ui::KeyEvent*>(&input); |
240 KeyDataPtr key_data(KeyData::New()); | 203 KeyDataPtr key_data(KeyData::New()); |
241 key_data->key_code = key_event->GetConflatedWindowsKeyCode(); | 204 key_data->key_code = key_event->GetConflatedWindowsKeyCode(); |
242 key_data->native_key_code = key_event->platform_keycode(); | 205 key_data->native_key_code = key_event->platform_keycode(); |
243 key_data->is_char = key_event->is_char(); | 206 key_data->is_char = key_event->is_char(); |
244 key_data->character = key_event->GetCharacter(); | 207 key_data->character = key_event->GetCharacter(); |
245 | 208 |
246 if (key_event->extended_key_event_data()) { | 209 if (key_event->extended_key_event_data()) { |
247 const MojoExtendedKeyEventData* data = | 210 const MojoExtendedKeyEventData* data = |
(...skipping 19 matching lines...) Expand all Loading... |
267 const ui::KeyEvent& input) { | 230 const ui::KeyEvent& input) { |
268 return Event::From(static_cast<const ui::Event&>(input)); | 231 return Event::From(static_cast<const ui::Event&>(input)); |
269 } | 232 } |
270 | 233 |
271 // static | 234 // static |
272 scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert( | 235 scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert( |
273 const EventPtr& input) { | 236 const EventPtr& input) { |
274 gfx::PointF location; | 237 gfx::PointF location; |
275 gfx::PointF screen_location; | 238 gfx::PointF screen_location; |
276 if (!input->pointer_data.is_null()) { | 239 if (!input->pointer_data.is_null()) { |
277 location.SetPoint(input->pointer_data->location->x, | 240 location.SetPoint(input->pointer_data->x, input->pointer_data->y); |
278 input->pointer_data->location->y); | 241 screen_location.SetPoint(input->pointer_data->screen_x, |
279 screen_location.SetPoint(input->pointer_data->location->screen_x, | 242 input->pointer_data->screen_y); |
280 input->pointer_data->location->screen_y); | |
281 } | 243 } |
282 | 244 |
283 switch (input->action) { | 245 switch (input->action) { |
284 case EVENT_TYPE_KEY_PRESSED: | 246 case EVENT_TYPE_KEY_PRESSED: |
285 case EVENT_TYPE_KEY_RELEASED: { | 247 case EVENT_TYPE_KEY_RELEASED: { |
286 scoped_ptr<ui::KeyEvent> key_event; | 248 scoped_ptr<ui::KeyEvent> key_event; |
287 if (input->key_data->is_char) { | 249 if (input->key_data->is_char) { |
288 key_event.reset(new ui::KeyEvent( | 250 key_event.reset(new ui::KeyEvent( |
289 static_cast<base::char16>(input->key_data->character), | 251 static_cast<base::char16>(input->key_data->character), |
290 static_cast<ui::KeyboardCode>( | 252 static_cast<ui::KeyboardCode>( |
(...skipping 12 matching lines...) Expand all Loading... |
303 static_cast<int32_t>(input->key_data->windows_key_code), | 265 static_cast<int32_t>(input->key_data->windows_key_code), |
304 input->key_data->text, | 266 input->key_data->text, |
305 input->key_data->unmodified_text))); | 267 input->key_data->unmodified_text))); |
306 key_event->set_platform_keycode(input->key_data->native_key_code); | 268 key_event->set_platform_keycode(input->key_data->native_key_code); |
307 return key_event.Pass(); | 269 return key_event.Pass(); |
308 } | 270 } |
309 case EVENT_TYPE_POINTER_DOWN: | 271 case EVENT_TYPE_POINTER_DOWN: |
310 case EVENT_TYPE_POINTER_UP: | 272 case EVENT_TYPE_POINTER_UP: |
311 case EVENT_TYPE_POINTER_MOVE: | 273 case EVENT_TYPE_POINTER_MOVE: |
312 case EVENT_TYPE_POINTER_CANCEL: { | 274 case EVENT_TYPE_POINTER_CANCEL: { |
313 switch (input->pointer_data->kind) { | 275 if (input->pointer_data->kind == POINTER_KIND_MOUSE) { |
314 case POINTER_KIND_MOUSE: { | 276 // TODO: last flags isn't right. Need to send changed_flags. |
315 // TODO: last flags isn't right. Need to send changed_flags. | 277 scoped_ptr<ui::MouseEvent> event(new ui::MouseEvent( |
316 scoped_ptr<ui::MouseEvent> event(new ui::MouseEvent( | 278 MojoMouseEventTypeToUIEvent(input), location, screen_location, |
317 MojoMouseEventTypeToUIEvent(input), location, screen_location, | 279 ui::EventTimeForNow(), ui::EventFlags(input->flags), |
318 ui::EventTimeForNow(), ui::EventFlags(input->flags), | 280 ui::EventFlags(input->flags))); |
319 ui::EventFlags(input->flags))); | 281 if (event->IsMouseWheelEvent()) { |
320 return event.Pass(); | 282 // This conversion assumes we're using the mojo meaning of these |
321 } break; | 283 // values: [-1 1]. |
322 case POINTER_KIND_TOUCH: { | 284 scoped_ptr<ui::MouseEvent> wheel_event(new ui::MouseWheelEvent( |
323 scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent( | 285 *event, |
324 MojoTouchEventTypeToUIEvent(input), location, | 286 static_cast<int>(input->pointer_data->horizontal_wheel * 100), |
325 ui::EventFlags(input->flags), input->pointer_data->pointer_id, | 287 static_cast<int>(input->pointer_data->vertical_wheel * 100))); |
326 base::TimeDelta::FromInternalValue(input->time_stamp), | 288 event = wheel_event.Pass(); |
327 input->pointer_data->brush_data->width, | 289 } |
328 input->pointer_data->brush_data->height, 0, | 290 return event.Pass(); |
329 input->pointer_data->brush_data->pressure)); | |
330 touch_event->set_root_location(screen_location); | |
331 return touch_event.Pass(); | |
332 } break; | |
333 case POINTER_KIND_PEN: | |
334 NOTIMPLEMENTED(); | |
335 break; | |
336 } | 291 } |
337 } break; | 292 scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent( |
338 case EVENT_TYPE_WHEEL: { | 293 MojoTouchEventTypeToUIEvent(input), location, |
339 scoped_ptr<ui::MouseEvent> pre_wheel_event(new ui::MouseEvent( | 294 ui::EventFlags(input->flags), input->pointer_data->pointer_id, |
340 MojoWheelEventTypeToUIEvent(input), location, screen_location, | 295 base::TimeDelta::FromInternalValue(input->time_stamp), |
341 ui::EventTimeForNow(), ui::EventFlags(input->flags), | 296 input->pointer_data->radius_major, input->pointer_data->radius_minor, |
342 ui::EventFlags(input->flags))); | 297 input->pointer_data->orientation, input->pointer_data->pressure)); |
343 scoped_ptr<ui::MouseEvent> wheel_event(new ui::MouseWheelEvent( | 298 touch_event->set_root_location(screen_location); |
344 *pre_wheel_event, static_cast<int>(input->wheel_data->delta_x), | 299 return touch_event.Pass(); |
345 static_cast<int>(input->wheel_data->delta_y))); | 300 } |
346 return wheel_event.Pass(); | |
347 } break; | |
348 | |
349 default: | 301 default: |
350 NOTIMPLEMENTED(); | 302 NOTIMPLEMENTED(); |
351 } | 303 } |
352 // TODO: need to support time_stamp. | 304 // TODO: need to support time_stamp. |
353 return nullptr; | 305 return nullptr; |
354 } | 306 } |
355 | 307 |
356 } // namespace mojo | 308 } // namespace mojo |
OLD | NEW |