| // Copyright 2014 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. |
| |
| #include "ui/events/gestures/motion_event_aura.h" |
| |
| #include "base/logging.h" |
| #include "ui/events/gestures/gesture_configuration.h" |
| |
| namespace ui { |
| |
| MotionEventAura::MotionEventAura() |
| : pointer_count_(0), cached_action_index_(-1) { |
| } |
| |
| MotionEventAura::MotionEventAura( |
| size_t pointer_count, |
| const base::TimeTicks& last_touch_time, |
| Action cached_action, |
| int cached_action_index, |
| const PointData (&active_touches)[GestureSequence::kMaxGesturePoints]) |
| : pointer_count_(pointer_count), |
| last_touch_time_(last_touch_time), |
| cached_action_(cached_action), |
| cached_action_index_(cached_action_index) { |
| DCHECK(pointer_count_); |
| for (size_t i = 0; i < pointer_count; ++i) |
| active_touches_[i] = active_touches[i]; |
| } |
| |
| MotionEventAura::~MotionEventAura() {} |
| |
| MotionEventAura::PointData MotionEventAura::GetPointDataFromTouchEvent( |
| const TouchEvent& touch) { |
| PointData point_data; |
| point_data.x = touch.x(); |
| point_data.y = touch.y(); |
| point_data.raw_x = touch.root_location_f().x(); |
| point_data.raw_y = touch.root_location_f().y(); |
| point_data.touch_id = touch.touch_id(); |
| point_data.pressure = touch.force(); |
| point_data.source_device_id = touch.source_device_id(); |
| |
| // TODO(tdresser): at some point we should start using both radii if they are |
| // available, but for now we use the max. |
| point_data.major_radius = std::max(touch.radius_x(), touch.radius_y()); |
| if (!point_data.major_radius) |
| point_data.major_radius = GestureConfiguration::default_radius(); |
| return point_data; |
| } |
| |
| void MotionEventAura::OnTouch(const TouchEvent& touch) { |
| switch (touch.type()) { |
| case ET_TOUCH_PRESSED: |
| AddTouch(touch); |
| break; |
| case ET_TOUCH_RELEASED: |
| case ET_TOUCH_CANCELLED: |
| // Removing these touch points needs to be postponed until after the |
| // MotionEvent has been dispatched. This cleanup occurs in |
| // CleanupRemovedTouchPoints. |
| UpdateTouch(touch); |
| break; |
| case ET_TOUCH_MOVED: |
| UpdateTouch(touch); |
| break; |
| default: |
| NOTREACHED(); |
| break; |
| } |
| |
| UpdateCachedAction(touch); |
| last_touch_time_ = touch.time_stamp() + base::TimeTicks(); |
| } |
| |
| int MotionEventAura::GetId() const { |
| return GetPointerId(0); |
| } |
| |
| MotionEvent::Action MotionEventAura::GetAction() const { |
| return cached_action_; |
| } |
| |
| int MotionEventAura::GetActionIndex() const { |
| DCHECK(cached_action_ == ACTION_POINTER_DOWN || |
| cached_action_ == ACTION_POINTER_UP); |
| DCHECK_GE(cached_action_index_, 0); |
| DCHECK_LE(cached_action_index_, static_cast<int>(pointer_count_)); |
| return cached_action_index_; |
| } |
| |
| size_t MotionEventAura::GetPointerCount() const { return pointer_count_; } |
| |
| int MotionEventAura::GetPointerId(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].touch_id; |
| } |
| |
| float MotionEventAura::GetX(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].x; |
| } |
| |
| float MotionEventAura::GetY(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].y; |
| } |
| |
| float MotionEventAura::GetRawX(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].raw_x; |
| } |
| |
| float MotionEventAura::GetRawY(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].raw_y; |
| } |
| |
| float MotionEventAura::GetTouchMajor(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].major_radius * 2; |
| } |
| |
| float MotionEventAura::GetPressure(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].pressure; |
| } |
| |
| base::TimeTicks MotionEventAura::GetEventTime() const { |
| return last_touch_time_; |
| } |
| |
| size_t MotionEventAura::GetHistorySize() const { return 0; } |
| |
| base::TimeTicks MotionEventAura::GetHistoricalEventTime( |
| size_t historical_index) const { |
| NOTIMPLEMENTED(); |
| return base::TimeTicks(); |
| } |
| |
| float MotionEventAura::GetHistoricalTouchMajor(size_t pointer_index, |
| size_t historical_index) const { |
| NOTIMPLEMENTED(); |
| return 0; |
| } |
| |
| float MotionEventAura::GetHistoricalX(size_t pointer_index, |
| size_t historical_index) const { |
| NOTIMPLEMENTED(); |
| return 0; |
| } |
| |
| float MotionEventAura::GetHistoricalY(size_t pointer_index, |
| size_t historical_index) const { |
| NOTIMPLEMENTED(); |
| return 0; |
| } |
| |
| MotionEvent::ToolType MotionEventAura::GetToolType(size_t pointer_index) const { |
| NOTIMPLEMENTED(); |
| return MotionEvent::TOOL_TYPE_UNKNOWN; |
| } |
| |
| int MotionEventAura::GetButtonState() const { |
| NOTIMPLEMENTED(); |
| return 0; |
| } |
| |
| scoped_ptr<MotionEvent> MotionEventAura::Clone() const { |
| return scoped_ptr<MotionEvent>(new MotionEventAura(pointer_count_, |
| last_touch_time_, |
| cached_action_, |
| cached_action_index_, |
| active_touches_)); |
| } |
| scoped_ptr<MotionEvent> MotionEventAura::Cancel() const { |
| return scoped_ptr<MotionEvent>(new MotionEventAura( |
| pointer_count_, last_touch_time_, ACTION_CANCEL, -1, active_touches_)); |
| } |
| |
| void MotionEventAura::CleanupRemovedTouchPoints(const TouchEvent& event) { |
| if (event.type() != ET_TOUCH_RELEASED && |
| event.type() != ET_TOUCH_CANCELLED) { |
| return; |
| } |
| |
| int index_to_delete = static_cast<int>(GetIndexFromId(event.touch_id())); |
| pointer_count_--; |
| active_touches_[index_to_delete] = active_touches_[pointer_count_]; |
| } |
| |
| MotionEventAura::PointData::PointData() |
| : x(0), |
| y(0), |
| raw_x(0), |
| raw_y(0), |
| touch_id(0), |
| pressure(0), |
| source_device_id(0), |
| major_radius(0) { |
| } |
| |
| int MotionEventAura::GetSourceDeviceId(size_t pointer_index) const { |
| DCHECK_LE(pointer_index, pointer_count_); |
| return active_touches_[pointer_index].source_device_id; |
| } |
| |
| void MotionEventAura::AddTouch(const TouchEvent& touch) { |
| if (pointer_count_ == static_cast<size_t>(GestureSequence::kMaxGesturePoints)) |
| return; |
| |
| active_touches_[pointer_count_] = GetPointDataFromTouchEvent(touch); |
| pointer_count_++; |
| } |
| |
| |
| void MotionEventAura::UpdateTouch(const TouchEvent& touch) { |
| active_touches_[GetIndexFromId(touch.touch_id())] = |
| GetPointDataFromTouchEvent(touch); |
| } |
| |
| void MotionEventAura::UpdateCachedAction(const TouchEvent& touch) { |
| DCHECK(pointer_count_); |
| switch (touch.type()) { |
| case ET_TOUCH_PRESSED: |
| if (pointer_count_ == 1) { |
| cached_action_ = ACTION_DOWN; |
| } else { |
| cached_action_ = ACTION_POINTER_DOWN; |
| cached_action_index_ = |
| static_cast<int>(GetIndexFromId(touch.touch_id())); |
| } |
| break; |
| case ET_TOUCH_RELEASED: |
| if (pointer_count_ == 1) { |
| cached_action_ = ACTION_UP; |
| } else { |
| cached_action_ = ACTION_POINTER_UP; |
| cached_action_index_ = |
| static_cast<int>(GetIndexFromId(touch.touch_id())); |
| DCHECK_LE(cached_action_index_, static_cast<int>(pointer_count_)); |
| } |
| break; |
| case ET_TOUCH_CANCELLED: |
| cached_action_ = ACTION_CANCEL; |
| break; |
| case ET_TOUCH_MOVED: |
| cached_action_ = ACTION_MOVE; |
| break; |
| default: |
| NOTREACHED(); |
| break; |
| } |
| } |
| |
| size_t MotionEventAura::GetIndexFromId(int id) const { |
| for (size_t i = 0; i < pointer_count_; ++i) { |
| if (active_touches_[i].touch_id == id) |
| return i; |
| } |
| NOTREACHED(); |
| return 0; |
| } |
| |
| } // namespace ui |