← Back to branch summary

~mir-team/qtmir/trunk

« back to all changes in this revision

Viewing changes to src/common/debughelpers.cpp

  • Committer: Bileto Bot
  • Author(s): Albert Astals Cid, Gerry Boland
  • Date: 2017-03-20 21:15:13 UTC
  • mfrom: (606.4.12 make_sure_surface_not_null)
  • Revision ID: ci-train-bot@canonical.com-20170320211513-z7v3z0ldes3gtcc0
Check for find() result not being null before using it

We do it in onWindowReady, onWindowMoved, onWindowFocusChanged, etc so no reason to not do it in onWindowRemoved

Approved by: Lukáš Tinkl, Unity8 CI Bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/debughelpers.cpp
21
21
 
22
22
// Unity API
23
23
#include <unity/shell/application/ApplicationInfoInterface.h>
 
24
#include <unity/shell/application/Mir.h>
24
25
 
25
26
const char *touchPointStateToString(Qt::TouchPointState state)
26
27
{
54
55
        break;
55
56
    case QEvent::TouchCancel:
56
57
        message.append("TouchCancel ");
 
58
        break;
57
59
    default:
58
60
        message.append("TouchUNKNOWN ");
59
61
    }
62
64
 
63
65
        const QTouchEvent::TouchPoint& touchPoint = ev->touchPoints().at(i);
64
66
        message.append(
65
 
            QString("(id:%1, state:%2, scenePos:(%3,%4), pos:(%5,%6)) ")
 
67
            QStringLiteral("(id:%1, state:%2, scenePos:(%3,%4), pos:(%5,%6)) ")
66
68
                .arg(touchPoint.id())
67
69
                .arg(touchPointStateToString(touchPoint.state()))
68
70
                .arg(touchPoint.scenePos().x())
75
77
    return message;
76
78
}
77
79
 
78
 
QString mirSurfaceAttribAndValueToString(MirSurfaceAttrib attrib, int value)
 
80
QString mirSurfaceAttribAndValueToString(MirWindowAttrib attrib, int value)
79
81
{
80
82
    QString str;
81
83
 
82
84
    switch (attrib) {
83
 
    case mir_surface_attrib_type:
84
 
        str = QString("type=%1").arg(mirSurfaceTypeToStr(value));
85
 
        break;
86
 
 
87
 
    case mir_surface_attrib_state:
88
 
        str = QString("state=%1").arg(mirSurfaceStateToStr(value));
89
 
        break;
90
 
 
91
 
    case mir_surface_attrib_swapinterval:
92
 
        str = QString("swapinterval=%1").arg(value);
93
 
        break;
94
 
 
95
 
    case mir_surface_attrib_focus:
96
 
        str = QString("focus=%1").arg(mirSurfaceFocusStateToStr(value));
97
 
        break;
98
 
 
99
 
    case mir_surface_attrib_dpi:
100
 
        str = QString("dpi=%1").arg(value);
101
 
        break;
102
 
 
103
 
    case mir_surface_attrib_visibility:
104
 
        str = QString("visibility=%1").arg(mirSurfaceVisibilityToStr(value));
 
85
    case mir_window_attrib_type:
 
86
        str = QStringLiteral("type=%1").arg(mirSurfaceTypeToStr(value));
 
87
        break;
 
88
 
 
89
    case mir_window_attrib_state:
 
90
        str = QStringLiteral("state=%1").arg(mirSurfaceStateToStr(value));
 
91
        break;
 
92
 
 
93
    case mir_window_attrib_swapinterval:
 
94
        str = QStringLiteral("swapinterval=%1").arg(value);
 
95
        break;
 
96
 
 
97
    case mir_window_attrib_focus:
 
98
        str = QStringLiteral("focus=%1").arg(mirSurfaceFocusStateToStr(value));
 
99
        break;
 
100
 
 
101
    case mir_window_attrib_dpi:
 
102
        str = QStringLiteral("dpi=%1").arg(value);
 
103
        break;
 
104
 
 
105
    case mir_window_attrib_visibility:
 
106
        str = QStringLiteral("visibility=%1").arg(mirSurfaceVisibilityToStr(value));
105
107
        break;
106
108
    default:
107
 
        str = QString("type'%1'=%2").arg((int)attrib).arg(value);
 
109
        str = QStringLiteral("type'%1'=%2").arg((int)attrib).arg(value);
108
110
    }
109
111
 
110
112
    return str;
113
115
const char *mirSurfaceTypeToStr(int value)
114
116
{
115
117
    switch (value) {
116
 
    case mir_surface_type_normal:
117
 
        return "normal";
118
 
    case mir_surface_type_utility:
119
 
        return "utility";
120
 
    case mir_surface_type_dialog:
121
 
        return "dialog";
122
 
    case mir_surface_type_overlay:
123
 
        return "overlay";
124
 
    case mir_surface_type_freestyle:
125
 
        return "freestyle";
126
 
    case mir_surface_type_popover:
127
 
        return "popover";
128
 
    case mir_surface_type_inputmethod:
129
 
        return "inputmethod";
130
 
    default:
131
 
        return "???";
 
118
    case mir_window_type_normal:       return "normal";        /**< AKA "regular"                   */
 
119
    case mir_window_type_utility:      return "utility";       /**< AKA "floating regular"          */
 
120
    case mir_window_type_dialog:       return "dialog";
 
121
    case mir_window_type_gloss:        return "gloss";
 
122
    case mir_window_type_freestyle:    return "freestyle";
 
123
    case mir_window_type_menu:         return "menu";
 
124
    case mir_window_type_inputmethod:  return "input Method";  /**< AKA "OSK" or handwriting etc.   */
 
125
    case mir_window_type_satellite:    return "satellite";     /**< AKA "toolbox"/"toolbar"         */
 
126
    case mir_window_type_tip:          return "tip";           /**< AKA "tooltip"                   */
 
127
    case mir_window_types:             Q_UNREACHABLE();
132
128
    }
 
129
    Q_UNREACHABLE();
133
130
}
134
131
 
135
132
const char *mirSurfaceStateToStr(int value)
136
133
{
137
134
    switch (value) {
138
 
    case mir_surface_state_unknown:
 
135
    case mir_window_state_unknown:
139
136
        return "unknown";
140
 
    case mir_surface_state_restored:
 
137
    case mir_window_state_restored:
141
138
        return "restored";
142
 
    case mir_surface_state_minimized:
 
139
    case mir_window_state_minimized:
143
140
        return "minimized";
144
 
    case mir_surface_state_maximized:
 
141
    case mir_window_state_maximized:
145
142
        return "maximized";
146
 
    case mir_surface_state_vertmaximized:
 
143
    case mir_window_state_vertmaximized:
147
144
        return "vertmaximized";
148
 
    case mir_surface_state_fullscreen:
 
145
    case mir_window_state_horizmaximized:
 
146
        return "horizmaximized";
 
147
    case mir_window_state_fullscreen:
149
148
        return "fullscreen";
 
149
    case mir_window_state_hidden:
 
150
        return "hidden";
150
151
    default:
151
152
        return "???";
152
153
    }
155
156
const char *mirSurfaceFocusStateToStr(int value)
156
157
{
157
158
    switch (value) {
158
 
    case mir_surface_unfocused:
 
159
    case mir_window_focus_state_unfocused:
159
160
        return "unfocused";
160
 
    case mir_surface_focused:
 
161
    case mir_window_focus_state_focused:
161
162
        return "focused";
162
163
    default:
163
164
        return "???";
167
168
const char *mirSurfaceVisibilityToStr(int value)
168
169
{
169
170
    switch (value) {
170
 
    case mir_surface_visibility_occluded:
 
171
    case mir_window_visibility_occluded:
171
172
        return "occluded";
172
 
    case mir_surface_visibility_exposed:
 
173
    case mir_window_visibility_exposed:
173
174
        return "exposed";
174
175
    default:
175
176
        return "???";
176
177
    }
177
178
}
178
179
 
179
 
const char *mirTouchActionToStr(MirTouchAction action)
180
 
{
181
 
    switch (action) {
182
 
    case mir_touch_action_up:
183
 
        return "up";
184
 
    case mir_touch_action_down:
185
 
        return "down";
186
 
    case mir_touch_action_change:
187
 
        return "change";
188
 
    default:
189
 
        return "???";
190
 
    }
191
 
}
192
 
 
193
180
using namespace unity::shell::application;
194
181
 
195
182
const char *applicationStateToStr(int state)
210
197
 
211
198
QString mirPointerEventToString(MirPointerEvent const* event)
212
199
{
213
 
    QString string = QString("MirPointerEvent(x=%1,y=%2,relative_x=%3,relative_y=%4)")
 
200
    QString string = QStringLiteral("MirPointerEvent(x=%1,y=%2,relative_x=%3,relative_y=%4)")
214
201
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_x))
215
202
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_y))
216
203
        .arg(mir_pointer_event_axis_value(event, mir_pointer_axis_relative_x))
223
210
{
224
211
    const int pointerCount = mir_touch_event_point_count(event);
225
212
 
226
 
    QString string("MirTouchEvent(");
 
213
    QString string(QStringLiteral("MirTouchEvent("));
227
214
 
228
215
    for (int i = 0; i < pointerCount; ++i) {
229
216
 
233
220
 
234
221
        MirTouchAction touchAction = mir_touch_event_action(event, i);
235
222
 
236
 
        QString touchStr = QString("(id=%1,action=%2,x=%3,y=%4)")
 
223
        QString touchStr = QStringLiteral("(id=%1,action=%2,x=%3,y=%4)")
237
224
            .arg(mir_touch_event_id(event, i))
238
225
            .arg(mirTouchActionToString(touchAction))
239
226
            .arg(mir_touch_event_axis_value(event, i, mir_touch_axis_x))
290
277
 
291
278
    xkb_keysym_t keyCode = mir_keyboard_event_key_code(event);
292
279
 
293
 
    return QString("MirKeyboardEvent(action=%1,key_code=0x%2)")
 
280
    return QStringLiteral("MirKeyboardEvent(action=%1,key_code=0x%2)")
294
281
        .arg(mirKeyboardActionToString(keyboardAction))
295
282
        .arg(keyCode, 4, 16, QLatin1Char('0'));
296
283
}
348
335
        return "???";
349
336
    }
350
337
}
 
338
 
 
339
const char *unityapiMirStateToStr(int state)
 
340
{
 
341
    switch (state) {
 
342
    case Mir::UnknownState:
 
343
        return "unknown";
 
344
    case Mir::RestoredState:
 
345
        return "restored";
 
346
    case Mir::MinimizedState:
 
347
        return "minimized";
 
348
    case Mir::MaximizedState:
 
349
        return "maximized";
 
350
    case Mir::VertMaximizedState:
 
351
        return "vertMaximized";
 
352
    case Mir::FullscreenState:
 
353
        return "fullscreen";
 
354
    case Mir::HorizMaximizedState:
 
355
        return "horizMaximized";
 
356
    case Mir::MaximizedLeftState:
 
357
        return "maximizedLeft";
 
358
    case Mir::MaximizedRightState:
 
359
        return "maximizedRight";
 
360
    case Mir::MaximizedTopLeftState:
 
361
        return "maximizedTopLeft";
 
362
    case Mir::MaximizedTopRightState:
 
363
        return "maximizedTopRight";
 
364
    case Mir::MaximizedBottomLeftState:
 
365
        return "maximizedBottomLeft";
 
366
    case Mir::MaximizedBottomRightState:
 
367
        return "maximizedBottomRight";
 
368
    case Mir::HiddenState:
 
369
        return "hidden";
 
370
    default:
 
371
        return "???";
 
372
    }
 
373
}