ui/events/test/mock_motion_event.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/events/test/mock_motion_event.h"
   6
   7 #include "base/logging.h"
   8
   9 using base::TimeTicks;
  10
  11 namespace ui {
  12 namespace test {
  13
  14 MockMotionEvent::MockMotionEvent()
  15     : action(ACTION_CANCEL), pointer_count(1), touch_major(TOUCH_MAJOR), id(0),
  16       button_state(0) {
  17 }
  18
  19 MockMotionEvent::MockMotionEvent(Action action)
  20     : action(action), pointer_count(1), touch_major(TOUCH_MAJOR), id(0),
  21       button_state(0) {
  22 }
  23
  24 MockMotionEvent::MockMotionEvent(Action action,
  25                                  TimeTicks time,
  26                                  float x,
  27                                  float y)
  28     : action(action),
  29       pointer_count(1),
  30       time(time),
  31       touch_major(TOUCH_MAJOR),
  32       id(0),
  33       button_state(0) {
  34   points[0].SetPoint(x, y);
  35   tool_types[0] = TOOL_TYPE_UNKNOWN;
  36 }
  37
  38 MockMotionEvent::MockMotionEvent(Action action,
  39                                  TimeTicks time,
  40                                  float x0,
  41                                  float y0,
  42                                  float x1,
  43                                  float y1)
  44     : action(action),
  45       pointer_count(2),
  46       time(time),
  47       touch_major(TOUCH_MAJOR),
  48       id(0),
  49       button_state(0) {
  50   points[0].SetPoint(x0, y0);
  51   tool_types[0] = TOOL_TYPE_UNKNOWN;
  52   points[1].SetPoint(x1, y1);
  53   tool_types[1] = TOOL_TYPE_UNKNOWN;
  54 }
  55
  56 MockMotionEvent::MockMotionEvent(Action action,
  57                                  TimeTicks time,
  58                                  float x0,
  59                                  float y0,
  60                                  float x1,
  61                                  float y1,
  62                                  float x2,
  63                                  float y2)
  64     : action(action),
  65       pointer_count(3),
  66       time(time),
  67       touch_major(TOUCH_MAJOR),
  68       id(0),
  69       button_state(0) {
  70   points[0].SetPoint(x0, y0);
  71   tool_types[0] = TOOL_TYPE_UNKNOWN;
  72   points[1].SetPoint(x1, y1);
  73   tool_types[1] = TOOL_TYPE_UNKNOWN;
  74   points[2].SetPoint(x2, y2);
  75   tool_types[2] = TOOL_TYPE_UNKNOWN;
  76 }
  77
  78 MockMotionEvent::MockMotionEvent(const MockMotionEvent& other)
  79     : action(other.action),
  80       pointer_count(other.pointer_count),
  81       time(other.time),
  82       touch_major(other.touch_major),
  83       id(other.GetId()),
  84       button_state(other.GetButtonState()) {
  85   for (size_t i = 0; i < pointer_count; ++i) {
  86     points[i] = other.points[i];
  87     tool_types[i] = other.tool_types[i];
  88   }
  89 }
  90
  91 MockMotionEvent::~MockMotionEvent() {}
  92
  93 MotionEvent::Action MockMotionEvent::GetAction() const { return action; }
  94
  95 int MockMotionEvent::GetActionIndex() const {
  96   return static_cast<int>(pointer_count) - 1;
  97 }
  98
  99 size_t MockMotionEvent::GetPointerCount() const { return pointer_count; }
 100
 101 int MockMotionEvent::GetId() const {
 102   return id;
 103 }
 104
 105 int MockMotionEvent::GetPointerId(size_t pointer_index) const {
 106   DCHECK(pointer_index < pointer_count);
 107   return static_cast<int>(pointer_index);
 108 }
 109
 110 float MockMotionEvent::GetX(size_t pointer_index) const {
 111   return points[pointer_index].x();
 112 }
 113
 114 float MockMotionEvent::GetY(size_t pointer_index) const {
 115   return points[pointer_index].y();
 116 }
 117
 118 float MockMotionEvent::GetRawX(size_t pointer_index) const {
 119   return GetX(pointer_index) + raw_offset.x();
 120 }
 121
 122 float MockMotionEvent::GetRawY(size_t pointer_index) const {
 123   return GetY(pointer_index) + raw_offset.y();
 124 }
 125
 126 float MockMotionEvent::GetTouchMajor(size_t pointer_index) const {
 127   return touch_major;
 128 }
 129
 130 float MockMotionEvent::GetPressure(size_t pointer_index) const {
 131   return 0;
 132 }
 133
 134 TimeTicks MockMotionEvent::GetEventTime() const { return time; }
 135
 136 size_t MockMotionEvent::GetHistorySize() const { return 0; }
 137
 138 TimeTicks MockMotionEvent::GetHistoricalEventTime(
 139     size_t historical_index) const {
 140   return TimeTicks();
 141 }
 142
 143 float MockMotionEvent::GetHistoricalTouchMajor(size_t pointer_index,
 144                                                size_t historical_index) const {
 145   return 0;
 146 }
 147
 148 float MockMotionEvent::GetHistoricalX(size_t pointer_index,
 149                                       size_t historical_index) const {
 150   return 0;
 151 }
 152
 153 float MockMotionEvent::GetHistoricalY(size_t pointer_index,
 154                                       size_t historical_index) const {
 155   return 0;
 156 }
 157
 158 MotionEvent::ToolType MockMotionEvent::GetToolType(size_t pointer_index) const {
 159   DCHECK_LT(pointer_index, pointer_count);
 160   return tool_types[pointer_index];
 161 }
 162
 163 int MockMotionEvent::GetButtonState() const {
 164   return button_state;
 165 }
 166
 167 scoped_ptr<MotionEvent> MockMotionEvent::Clone() const {
 168   return scoped_ptr<MotionEvent>(new MockMotionEvent(*this));
 169 }
 170
 171 scoped_ptr<MotionEvent> MockMotionEvent::Cancel() const {
 172   scoped_ptr<MockMotionEvent> cancel_event(new MockMotionEvent(*this));
 173   cancel_event->action = MotionEvent::ACTION_CANCEL;
 174   return cancel_event.PassAs<MotionEvent>();
 175 }
 176
 177 void MockMotionEvent::SetId(int new_id) {
 178   id = new_id;
 179 }
 180
 181 void MockMotionEvent::SetTime(base::TimeTicks new_time) {
 182   time = new_time;
 183 }
 184
 185 void MockMotionEvent::PressPoint(float x, float y) {
 186   // Reset the pointer count if the previously released and/or cancelled pointer
 187   // was the last pointer in the event.
 188   if (pointer_count == 1 && (action == ACTION_UP || action == ACTION_CANCEL))
 189     pointer_count = 0;
 190
 191   DCHECK_LT(pointer_count, static_cast<size_t>(MAX_POINTERS));
 192   points[pointer_count++] = gfx::PointF(x, y);
 193   tool_types[pointer_count] = TOOL_TYPE_UNKNOWN;
 194   action = pointer_count > 1 ? ACTION_POINTER_DOWN : ACTION_DOWN;
 195 }
 196
 197 void MockMotionEvent::MovePoint(size_t index, float x, float y) {
 198   DCHECK_LT(index, pointer_count);
 199   points[index] = gfx::PointF(x, y);
 200   tool_types[index] = TOOL_TYPE_UNKNOWN;
 201   action = ACTION_MOVE;
 202 }
 203
 204 void MockMotionEvent::ReleasePoint() {
 205   DCHECK_GT(pointer_count, 0U);
 206   if (pointer_count > 1) {
 207     --pointer_count;
 208     action = ACTION_POINTER_UP;
 209   } else {
 210     action = ACTION_UP;
 211   }
 212 }
 213
 214 void MockMotionEvent::CancelPoint() {
 215   DCHECK_GT(pointer_count, 0U);
 216   if (pointer_count > 1)
 217     --pointer_count;
 218   action = ACTION_CANCEL;
 219 }
 220
 221 void MockMotionEvent::SetTouchMajor(float new_touch_major) {
 222   touch_major = new_touch_major;
 223 }
 224
 225 void MockMotionEvent::SetRawOffset(float raw_offset_x, float raw_offset_y) {
 226   raw_offset.set_x(raw_offset_x);
 227   raw_offset.set_y(raw_offset_y);
 228 }
 229
 230 void MockMotionEvent::SetToolType(size_t pointer_index, ToolType tool_type) {
 231   DCHECK_LT(pointer_index, pointer_count);
 232   tool_types[pointer_index] = tool_type;
 233 }
 234
 235 void MockMotionEvent::SetButtonState(int new_button_state) {
 236   button_state = new_button_state;
 237 }
 238
 239 }  // namespace test
 240 }  // namespace ui