~alan-griffiths/miral/fix-1645284

« back to all changes in this revision

Viewing changes to miral-qt/src/common/debughelpers.cpp

  • Committer: Alan Griffiths
  • Date: 2016-11-07 17:59:19 UTC
  • mfrom: (436.1.1 miral2)
  • Revision ID: alan@octopull.co.uk-20161107175919-stbb64i7j1htgog2
[miral-qt] delete all as qtmir work on MirAL has shifted to lp:~unity-team/qtmir/miral-qt-integration and this is a needless distration

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*
2
 
 * Copyright (C) 2013-2015 Canonical, Ltd.
3
 
 *
4
 
 * This program is free software: you can redistribute it and/or modify it under
5
 
 * the terms of the GNU Lesser General Public License version 3, as published by
6
 
 * the Free Software Foundation.
7
 
 *
8
 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9
 
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
10
 
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11
 
 * Lesser General Public License for more details.
12
 
 *
13
 
 * You should have received a copy of the GNU Lesser General Public License
14
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
 
 */
16
 
 
17
 
#include "debughelpers.h"
18
 
#include <QTouchEvent>
19
 
 
20
 
#include <mir_toolkit/event.h>
21
 
 
22
 
// Unity API
23
 
#include <unity/shell/application/ApplicationInfoInterface.h>
24
 
#include <unity/shell/application/Mir.h>
25
 
 
26
 
const char *touchPointStateToString(Qt::TouchPointState state)
27
 
{
28
 
    switch (state) {
29
 
    case Qt::TouchPointPressed:
30
 
        return "pressed";
31
 
    case Qt::TouchPointMoved:
32
 
        return "moved";
33
 
    case Qt::TouchPointStationary:
34
 
        return "stationary";
35
 
    case Qt::TouchPointReleased:
36
 
        return "released";
37
 
    default:
38
 
        return "UNKNOWN!";
39
 
    }
40
 
}
41
 
 
42
 
QString touchEventToString(const QTouchEvent *ev)
43
 
{
44
 
    QString message;
45
 
 
46
 
    switch (ev->type()) {
47
 
    case QEvent::TouchBegin:
48
 
        message.append("TouchBegin ");
49
 
        break;
50
 
    case QEvent::TouchUpdate:
51
 
        message.append("TouchUpdate ");
52
 
        break;
53
 
    case QEvent::TouchEnd:
54
 
        message.append("TouchEnd ");
55
 
        break;
56
 
    case QEvent::TouchCancel:
57
 
        message.append("TouchCancel ");
58
 
        break;
59
 
    default:
60
 
        message.append("TouchUNKNOWN ");
61
 
    }
62
 
 
63
 
    for (int i=0; i < ev->touchPoints().size(); ++i) {
64
 
 
65
 
        const QTouchEvent::TouchPoint& touchPoint = ev->touchPoints().at(i);
66
 
        message.append(
67
 
            QStringLiteral("(id:%1, state:%2, scenePos:(%3,%4), pos:(%5,%6)) ")
68
 
                .arg(touchPoint.id())
69
 
                .arg(touchPointStateToString(touchPoint.state()))
70
 
                .arg(touchPoint.scenePos().x())
71
 
                .arg(touchPoint.scenePos().y())
72
 
                .arg(touchPoint.pos().x())
73
 
                .arg(touchPoint.pos().y())
74
 
            );
75
 
    }
76
 
 
77
 
    return message;
78
 
}
79
 
 
80
 
QString mirSurfaceAttribAndValueToString(MirSurfaceAttrib attrib, int value)
81
 
{
82
 
    QString str;
83
 
 
84
 
    switch (attrib) {
85
 
    case mir_surface_attrib_type:
86
 
        str = QStringLiteral("type=%1").arg(mirSurfaceTypeToStr(value));
87
 
        break;
88
 
 
89
 
    case mir_surface_attrib_state:
90
 
        str = QStringLiteral("state=%1").arg(mirSurfaceStateToStr(value));
91
 
        break;
92
 
 
93
 
    case mir_surface_attrib_swapinterval:
94
 
        str = QStringLiteral("swapinterval=%1").arg(value);
95
 
        break;
96
 
 
97
 
    case mir_surface_attrib_focus:
98
 
        str = QStringLiteral("focus=%1").arg(mirSurfaceFocusStateToStr(value));
99
 
        break;
100
 
 
101
 
    case mir_surface_attrib_dpi:
102
 
        str = QStringLiteral("dpi=%1").arg(value);
103
 
        break;
104
 
 
105
 
    case mir_surface_attrib_visibility:
106
 
        str = QStringLiteral("visibility=%1").arg(mirSurfaceVisibilityToStr(value));
107
 
        break;
108
 
    default:
109
 
        str = QStringLiteral("type'%1'=%2").arg((int)attrib).arg(value);
110
 
    }
111
 
 
112
 
    return str;
113
 
}
114
 
 
115
 
const char *mirSurfaceTypeToStr(int value)
116
 
{
117
 
    switch (value) {
118
 
    case mir_surface_type_normal:
119
 
        return "normal";
120
 
    case mir_surface_type_utility:
121
 
        return "utility";
122
 
    case mir_surface_type_dialog:
123
 
        return "dialog";
124
 
    case mir_surface_type_overlay:
125
 
        return "overlay";
126
 
    case mir_surface_type_freestyle:
127
 
        return "freestyle";
128
 
    case mir_surface_type_popover:
129
 
        return "popover";
130
 
    case mir_surface_type_inputmethod:
131
 
        return "inputmethod";
132
 
    default:
133
 
        return "???";
134
 
    }
135
 
}
136
 
 
137
 
const char *mirSurfaceStateToStr(int value)
138
 
{
139
 
    switch (value) {
140
 
    case mir_surface_state_unknown:
141
 
        return "unknown";
142
 
    case mir_surface_state_restored:
143
 
        return "restored";
144
 
    case mir_surface_state_minimized:
145
 
        return "minimized";
146
 
    case mir_surface_state_maximized:
147
 
        return "maximized";
148
 
    case mir_surface_state_vertmaximized:
149
 
        return "vertmaximized";
150
 
    case mir_surface_state_fullscreen:
151
 
        return "fullscreen";
152
 
    case mir_surface_state_hidden:
153
 
        return "hidden";
154
 
    default:
155
 
        return "???";
156
 
    }
157
 
}
158
 
 
159
 
const char *mirSurfaceFocusStateToStr(int value)
160
 
{
161
 
    switch (value) {
162
 
    case mir_surface_unfocused:
163
 
        return "unfocused";
164
 
    case mir_surface_focused:
165
 
        return "focused";
166
 
    default:
167
 
        return "???";
168
 
    }
169
 
}
170
 
 
171
 
const char *mirSurfaceVisibilityToStr(int value)
172
 
{
173
 
    switch (value) {
174
 
    case mir_surface_visibility_occluded:
175
 
        return "occluded";
176
 
    case mir_surface_visibility_exposed:
177
 
        return "exposed";
178
 
    default:
179
 
        return "???";
180
 
    }
181
 
}
182
 
 
183
 
const char *mirTouchActionToStr(MirTouchAction action)
184
 
{
185
 
    switch (action) {
186
 
    case mir_touch_action_up:
187
 
        return "up";
188
 
    case mir_touch_action_down:
189
 
        return "down";
190
 
    case mir_touch_action_change:
191
 
        return "change";
192
 
    default:
193
 
        return "???";
194
 
    }
195
 
}
196
 
 
197
 
using namespace unity::shell::application;
198
 
 
199
 
const char *applicationStateToStr(int state)
200
 
{
201
 
    switch (state) {
202
 
    case ApplicationInfoInterface::Starting:
203
 
        return "starting";
204
 
    case ApplicationInfoInterface::Running:
205
 
        return "running";
206
 
    case ApplicationInfoInterface::Suspended:
207
 
        return "suspended";
208
 
    case ApplicationInfoInterface::Stopped:
209
 
        return "stopped";
210
 
    default:
211
 
        return "???";
212
 
    }
213
 
}
214
 
 
215
 
QString mirPointerEventToString(MirPointerEvent const* event)
216
 
{
217
 
    QString string = QStringLiteral("MirPointerEvent(x=%1,y=%2,relative_x=%3,relative_y=%4)")
218
 
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_x))
219
 
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_y))
220
 
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_relative_x))
221
 
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_relative_y));
222
 
 
223
 
    return string;
224
 
}
225
 
 
226
 
QString mirTouchEventToString(MirTouchEvent const* event)
227
 
{
228
 
    const int pointerCount = mir_touch_event_point_count(event);
229
 
 
230
 
    QString string(QStringLiteral("MirTouchEvent("));
231
 
 
232
 
    for (int i = 0; i < pointerCount; ++i) {
233
 
 
234
 
        if (i > 0) {
235
 
            string.append(",");
236
 
        }
237
 
 
238
 
        MirTouchAction touchAction = mir_touch_event_action(event, i);
239
 
 
240
 
        QString touchStr = QStringLiteral("(id=%1,action=%2,x=%3,y=%4)")
241
 
            .arg(mir_touch_event_id(event, i))
242
 
            .arg(mirTouchActionToString(touchAction))
243
 
            .arg(mir_touch_event_axis_value(event, i, mir_touch_axis_x))
244
 
            .arg(mir_touch_event_axis_value(event, i, mir_touch_axis_y));
245
 
 
246
 
        string.append(touchStr);
247
 
    }
248
 
 
249
 
    string.append(")");
250
 
 
251
 
    return string;
252
 
}
253
 
 
254
 
const char *mirTouchActionToString(MirTouchAction touchAction)
255
 
{
256
 
    switch (touchAction)
257
 
    {
258
 
    case mir_touch_action_up:
259
 
        return "up";
260
 
        break;
261
 
    case mir_touch_action_down:
262
 
        return "down";
263
 
        break;
264
 
    case mir_touch_action_change:
265
 
        return "change";
266
 
        break;
267
 
    default:
268
 
        return "???";
269
 
        break;
270
 
    }
271
 
}
272
 
 
273
 
namespace {
274
 
const char *mirKeyboardActionToString(MirKeyboardAction keyboardAction)
275
 
{
276
 
    switch (keyboardAction)
277
 
    {
278
 
    case mir_keyboard_action_up:
279
 
        return "up";
280
 
    case mir_keyboard_action_down:
281
 
        return "down";
282
 
    case mir_keyboard_action_repeat:
283
 
        return "repeat";
284
 
    default:
285
 
        return "???";
286
 
        break;
287
 
    }
288
 
}
289
 
}
290
 
 
291
 
QString mirKeyboardEventToString(MirKeyboardEvent const* event)
292
 
{
293
 
    MirKeyboardAction keyboardAction = mir_keyboard_event_action(event);
294
 
 
295
 
    xkb_keysym_t keyCode = mir_keyboard_event_key_code(event);
296
 
 
297
 
    return QStringLiteral("MirKeyboardEvent(action=%1,key_code=0x%2)")
298
 
        .arg(mirKeyboardActionToString(keyboardAction))
299
 
        .arg(keyCode, 4, 16, QLatin1Char('0'));
300
 
}
301
 
 
302
 
const char *qtCursorShapeToStr(Qt::CursorShape shape)
303
 
{
304
 
    switch(shape) {
305
 
    case Qt::ArrowCursor:
306
 
        return "Arrow";
307
 
    case Qt::UpArrowCursor:
308
 
        return "UpArrow";
309
 
    case Qt::CrossCursor:
310
 
        return "Cross";
311
 
    case Qt::WaitCursor:
312
 
        return "Wait";
313
 
    case Qt::IBeamCursor:
314
 
        return "IBeam";
315
 
    case Qt::SizeVerCursor:
316
 
        return "SizeVer";
317
 
    case Qt::SizeHorCursor:
318
 
        return "SizeHor";
319
 
    case Qt::SizeBDiagCursor:
320
 
        return "SizeBDiag";
321
 
    case Qt::SizeFDiagCursor:
322
 
        return "SizeFDiag";
323
 
    case Qt::SizeAllCursor:
324
 
        return "SizeAll";
325
 
    case Qt::BlankCursor:
326
 
        return "Blank";
327
 
    case Qt::SplitVCursor:
328
 
        return "SplitV";
329
 
    case Qt::SplitHCursor:
330
 
        return "SplitH";
331
 
    case Qt::PointingHandCursor:
332
 
        return "PointingHand";
333
 
    case Qt::ForbiddenCursor:
334
 
        return "Forbidden";
335
 
    case Qt::WhatsThisCursor:
336
 
        return "WhatsThis";
337
 
    case Qt::BusyCursor:
338
 
        return "Busy";
339
 
    case Qt::OpenHandCursor:
340
 
        return "OpenHand";
341
 
    case Qt::ClosedHandCursor:
342
 
        return "ClosedHand";
343
 
    case Qt::DragCopyCursor:
344
 
        return "DragCopy";
345
 
    case Qt::DragMoveCursor:
346
 
        return "DragMove";
347
 
    case Qt::DragLinkCursor:
348
 
        return "DragLink";
349
 
    case Qt::BitmapCursor:
350
 
        return "Bitmap";
351
 
    default:
352
 
        return "???";
353
 
    }
354
 
}
355
 
 
356
 
const char *unityapiMirStateToStr(int state)
357
 
{
358
 
    switch (state) {
359
 
    case Mir::UnknownState:
360
 
        return "unknown";
361
 
    case Mir::RestoredState:
362
 
        return "restored";
363
 
    case Mir::MinimizedState:
364
 
        return "minimized";
365
 
    case Mir::MaximizedState:
366
 
        return "maximized";
367
 
    case Mir::VertMaximizedState:
368
 
        return "vertMaximized";
369
 
    case Mir::FullscreenState:
370
 
        return "fullscreen";
371
 
    case Mir::HorizMaximizedState:
372
 
        return "horizMaximized";
373
 
    case Mir::MaximizedLeftState:
374
 
        return "maximizedLeft";
375
 
    case Mir::MaximizedRightState:
376
 
        return "maximizedRight";
377
 
    case Mir::MaximizedTopLeftState:
378
 
        return "maximizedTopLeft";
379
 
    case Mir::MaximizedTopRightState:
380
 
        return "maximizedTopRight";
381
 
    case Mir::MaximizedBottomLeftState:
382
 
        return "maximizedBottomLeft";
383
 
    case Mir::MaximizedBottomRightState:
384
 
        return "maximizedBottomRight";
385
 
    case Mir::HiddenState:
386
 
        return "hidden";
387
 
    default:
388
 
        return "???";
389
 
    }
390
 
}