← Back to branch summary

~ubuntu-branches/ubuntu/wily/unity/wily

« back to all changes in this revision

Viewing changes to tests/test-gestures/test_window_gesture_target.cpp

  • Committer: Daniel d'Andrada
  • Date: 2012-07-27 20:20:29 UTC
  • mto: (55.2094.1 alt_tab_v2)
  • mto: This revision was merged to the branch mainline in revision 747.
  • Revision ID: daniel.dandrada@canonical.com-20120727202029-9tbkwzemtzil6crt
Use gestures support from Nux and adapt code for regular gesture rules

Remove GeisAdapter as we are getting gesture events from Nux instead.

Then modify code to handle geisv2-style gestures. They require
acceptance/rejection and enable multiple simultaneous gestures

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-gestures/test_window_gesture_target.cpp
 
1
/*
 
2
 * Copyright 2012 Canonical Ltd.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify it
 
5
 * under the terms of the GNU General Public License version 3, as published
 
6
 * by the  Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful, but
 
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
10
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
 
11
 * PURPOSE.  See the GNU General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU General Public License
 
14
 * version 3 along with this program.  If not, see
 
15
 * <http://www.gnu.org/licenses/>
 
16
 *
 
17
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
 
18
 *
 
19
 */
 
20
 
 
21
#include <gtest/gtest.h>
 
22
#include <compiz_mock/core/core.h>
 
23
#include "FakeGestureEvent.h"
 
24
#include "unityshell_mock.h"
 
25
#include <WindowGestureTarget.h>
 
26
 
 
27
class WindowGestureTargetTest : public ::testing::Test
 
28
{
 
29
 protected:
 
30
  virtual void SetUp()
 
31
  {
 
32
    screen_mock->width_ = 1280;
 
33
    screen_mock->height_ = 1024;
 
34
  }
 
35
 
 
36
  void PerformPinch(WindowGestureTarget &gesture_target, float peak_radius)
 
37
  {
 
38
    nux::FakeGestureEvent fake_event;
 
39
 
 
40
    fake_event.type = nux::EVENT_GESTURE_BEGIN;
 
41
    fake_event.gesture_id = 0;
 
42
    fake_event.gesture_classes = nux::PINCH_GESTURE;
 
43
    fake_event.is_direct_touch = false;
 
44
    // in touch device's coordinate system (because it's not a direct device).
 
45
    // Thus not used by WindowCompositor
 
46
    fake_event.touches.push_back(nux::TouchPoint(0, 10.0f, 10.0f));
 
47
    fake_event.touches.push_back(nux::TouchPoint(1, 20.0f, 20.0f));
 
48
    fake_event.touches.push_back(nux::TouchPoint(2, 22.0f, 22.0f));
 
49
    fake_event.focus.x = gesture_target.window()->geometry_.centerX();
 
50
    fake_event.focus.y = gesture_target.window()->geometry_.centerY();;
 
51
    fake_event.radius = 1.0;
 
52
    fake_event.is_construction_finished = false;
 
53
    gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
54
 
 
55
    fake_event.type = nux::EVENT_GESTURE_UPDATE;
 
56
    fake_event.radius = peak_radius;
 
57
    gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
58
 
 
59
    fake_event.type = nux::EVENT_GESTURE_END;
 
60
    gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
61
  }
 
62
};
 
63
 
 
64
TEST_F(WindowGestureTargetTest, ThreeFingersDragMovesWindow)
 
65
{
 
66
  unity::UnityWindowMock window;
 
67
  window.geometry_.set(10, 10, 400, 400, 0);
 
68
  window.server_geometry_ = window.geometry_;
 
69
  window.actions_ = CompWindowActionMoveMask;
 
70
  window.state_ = 0;
 
71
  window.id_ = 1;
 
72
 
 
73
  WindowGestureTarget gesture_target(&window);
 
74
 
 
75
  nux::FakeGestureEvent fake_event;
 
76
 
 
77
  /* prepare and send the fake event  */
 
78
  fake_event.type = nux::EVENT_GESTURE_BEGIN;
 
79
  fake_event.gesture_id = 0;
 
80
  fake_event.gesture_classes = nux::TOUCH_GESTURE;
 
81
  fake_event.is_direct_touch = false;
 
82
  fake_event.focus.x = 100.0f; // hits the middle window
 
83
  fake_event.focus.y = 100.0f;
 
84
  // in touch device's coordinate system (because it's not a direct device).
 
85
  // Thus not used by WindowCompositor
 
86
  fake_event.touches.push_back(nux::TouchPoint(0, 10.0f, 10.0f));
 
87
  fake_event.touches.push_back(nux::TouchPoint(1, 20.0f, 20.0f));
 
88
  fake_event.touches.push_back(nux::TouchPoint(2, 22.0f, 22.0f));
 
89
  fake_event.is_construction_finished = false;
 
90
  fake_event.radius = 1.0f;
 
91
  gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
92
 
 
93
  ASSERT_FALSE(window.moved_);
 
94
 
 
95
  fake_event.type = nux::EVENT_GESTURE_UPDATE;
 
96
  fake_event.gesture_classes = nux::TOUCH_GESTURE | nux::DRAG_GESTURE;
 
97
  fake_event.delta.x = 10.0f;
 
98
  fake_event.delta.y = 20.0f;
 
99
  fake_event.focus.x += fake_event.delta.x;
 
100
  fake_event.focus.y += fake_event.delta.y;
 
101
  fake_event.is_construction_finished = true;
 
102
  gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
103
 
 
104
  ASSERT_TRUE(window.moved_);
 
105
  ASSERT_EQ(fake_event.delta.x, window.movement_x_);
 
106
  ASSERT_EQ(fake_event.delta.y, window.movement_y_);
 
107
}
 
108
 
 
109
TEST_F(WindowGestureTargetTest, ThreeFingersDragDoesntMoveStaticWindow)
 
110
{
 
111
 
 
112
  unity::UnityWindowMock window;
 
113
  window.geometry_.set(10, 10, 400, 400, 0);
 
114
  window.server_geometry_ = window.geometry_;
 
115
  window.actions_ = 0; /* can't be moved */
 
116
  window.state_ = 0;
 
117
  window.id_ = 1; 
 
118
 
 
119
  WindowGestureTarget gesture_target(&window);
 
120
 
 
121
  nux::FakeGestureEvent fake_event;
 
122
 
 
123
  /* prepare and send the fake event  */
 
124
  fake_event.type = nux::EVENT_GESTURE_BEGIN;
 
125
  fake_event.gesture_id = 0;
 
126
  fake_event.is_direct_touch = false;
 
127
  fake_event.focus.x = 100.0f; // hits the middle window
 
128
  fake_event.focus.y = 100.0f;
 
129
  // in touch device's coordinate system (because it's not a direct device).
 
130
  // Thus not used by WindowCompositor
 
131
  fake_event.touches.push_back(nux::TouchPoint(0, 10.0f, 10.0f));
 
132
  fake_event.touches.push_back(nux::TouchPoint(1, 20.0f, 20.0f));
 
133
  fake_event.touches.push_back(nux::TouchPoint(2, 22.0f, 22.0f));
 
134
  fake_event.is_construction_finished = false;
 
135
  fake_event.radius = 1.0f;
 
136
  gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
137
 
 
138
  ASSERT_FALSE(window.moved_);
 
139
 
 
140
  fake_event.type = nux::EVENT_GESTURE_UPDATE;
 
141
  fake_event.delta.x += 10.0f;
 
142
  fake_event.delta.y += 20.0f;
 
143
  fake_event.focus.x += fake_event.delta.x;
 
144
  fake_event.focus.y += fake_event.delta.y;
 
145
  fake_event.is_construction_finished = true;
 
146
  gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
147
 
 
148
  ASSERT_FALSE(window.moved_);
 
149
}
 
150
 
 
151
TEST_F(WindowGestureTargetTest, ThreeFingersPinchMaximizesWindow)
 
152
{
 
153
  unity::UnityWindowMock window;
 
154
  window.geometry_.set(10, 10, 400, 400, 0);
 
155
  window.server_geometry_ = window.geometry_;
 
156
  window.actions_ = CompWindowActionMoveMask;
 
157
  window.state_ = 0;
 
158
  window.id_ = 1;
 
159
 
 
160
  WindowGestureTarget gesture_target(&window);
 
161
 
 
162
  PerformPinch(gesture_target, 2.0);
 
163
 
 
164
  ASSERT_EQ(1, window.maximize_count_);
 
165
  ASSERT_EQ(MAXIMIZE_STATE, window.maximize_state_);
 
166
}
 
167
 
 
168
TEST_F(WindowGestureTargetTest, ThreeFingersPinchRestoresWindow)
 
169
{
 
170
  unity::UnityWindowMock window;
 
171
  window.geometry_.set(10, 10, 400, 400, 0);
 
172
  window.server_geometry_ = window.geometry_;
 
173
  window.actions_ = CompWindowActionMoveMask;
 
174
  window.state_ = MAXIMIZE_STATE;
 
175
  window.id_ = 1;
 
176
 
 
177
  WindowGestureTarget gesture_target(&window);
 
178
 
 
179
  PerformPinch(gesture_target, 0.3);
 
180
 
 
181
  ASSERT_EQ(1, window.maximize_count_);
 
182
  ASSERT_EQ(0, window.maximize_state_);
 
183
}
 
184
 
 
185
TEST_F(WindowGestureTargetTest, MinimalThreeFingersPinchDoesNothing)
 
186
{
 
187
  unity::UnityWindowMock window;
 
188
  window.geometry_.set(10, 10, 400, 400, 0);
 
189
  window.server_geometry_ = window.geometry_;
 
190
  window.actions_ = CompWindowActionMoveMask;
 
191
  window.state_ = 0;
 
192
  window.id_ = 1;
 
193
 
 
194
  WindowGestureTarget gesture_target(&window);
 
195
 
 
196
  PerformPinch(gesture_target, 1.1);
 
197
 
 
198
  ASSERT_EQ(0, window.maximize_count_);
 
199
}
 
200
 
 
201
/* Regression test for lp:979418, where the grab is not removed if the gesture
 
202
 * id is 0. */
 
203
TEST_F(WindowGestureTargetTest, DragGrabCheck)
 
204
{
 
205
  screen_mock->grab_count_ = 0;
 
206
 
 
207
  unity::UnityWindowMock window;
 
208
  window.geometry_.set(10, 10, 400, 400, 0);
 
209
  window.server_geometry_ = window.geometry_;
 
210
  window.actions_ = CompWindowActionMoveMask;
 
211
  window.state_ = 0;
 
212
  window.id_ = 1;
 
213
 
 
214
  WindowGestureTarget gesture_target(&window);
 
215
 
 
216
  /* prepare and send the fake event  */
 
217
  nux::FakeGestureEvent fake_event;
 
218
  fake_event.type = nux::EVENT_GESTURE_BEGIN;
 
219
  fake_event.gesture_id = 0;
 
220
  fake_event.is_direct_touch = false;
 
221
  fake_event.focus.x = 100.0f; // hits the middle window
 
222
  fake_event.focus.y = 100.0f;
 
223
  // in touch device's coordinate system (because it's not a direct device).
 
224
  // Thus not used by WindowCompositor
 
225
  fake_event.touches.push_back(nux::TouchPoint(0, 10.0f, 10.0f));
 
226
  fake_event.touches.push_back(nux::TouchPoint(1, 20.0f, 20.0f));
 
227
  fake_event.touches.push_back(nux::TouchPoint(2, 22.0f, 22.0f));
 
228
  fake_event.is_construction_finished = false;
 
229
  gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
230
 
 
231
  fake_event.type = nux::EVENT_GESTURE_END;
 
232
  gesture_target.GestureEvent(fake_event.ToGestureEvent());
 
233
 
 
234
  ASSERT_EQ(0, screen_mock->grab_count_);
 
235
}