← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to src/gui/kernel/qplatformcursor.cpp

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/kernel/qplatformcursor.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
 
4
** Contact: http://www.qt-project.org/legal
 
5
**
 
6
** This file is part of the QtOpenVG module of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:LGPL$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and Digia.  For licensing terms and
 
14
** conditions see http://qt.digia.com/licensing.  For further information
 
15
** use the contact form at http://qt.digia.com/contact-us.
 
16
**
 
17
** GNU Lesser General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU Lesser
 
19
** General Public License version 2.1 as published by the Free Software
 
20
** Foundation and appearing in the file LICENSE.LGPL included in the
 
21
** packaging of this file.  Please review the following information to
 
22
** ensure the GNU Lesser General Public License version 2.1 requirements
 
23
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
24
**
 
25
** In addition, as a special exception, Digia gives you certain additional
 
26
** rights.  These rights are described in the Digia Qt LGPL Exception
 
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
28
**
 
29
** GNU General Public License Usage
 
30
** Alternatively, this file may be used under the terms of the GNU
 
31
** General Public License version 3.0 as published by the Free Software
 
32
** Foundation and appearing in the file LICENSE.GPL included in the
 
33
** packaging of this file.  Please review the following information to
 
34
** ensure the GNU General Public License version 3.0 requirements will be
 
35
** met: http://www.gnu.org/copyleft/gpl.html.
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
#include "qplatformcursor.h"
 
42
 
 
43
#include <QPainter>
 
44
#include <QBitmap>
 
45
#include <QGuiApplication>
 
46
#include <QScreen>
 
47
#include <qpa/qplatformscreen.h>
 
48
#include <private/qguiapplication_p.h>
 
49
 
 
50
#include <QDebug>
 
51
 
 
52
QT_BEGIN_NAMESPACE
 
53
 
 
54
QList<QPlatformCursor *> QPlatformCursorPrivate::getInstances()
 
55
{
 
56
    QList<QPlatformCursor *> result;
 
57
    foreach (const QScreen *screen, QGuiApplicationPrivate::screen_list)
 
58
        if (QPlatformCursor *cursor = screen->handle()->cursor())
 
59
            result.push_back(cursor);
 
60
    return result;
 
61
}
 
62
 
 
63
/*!
 
64
    \class QPlatformCursor
 
65
    \since 5.0
 
66
    \internal
 
67
    \preliminary
 
68
    \ingroup qpa
 
69
 
 
70
    \brief The QPlatformCursor class provides information about
 
71
    pointer device events (movement, buttons), and requests to change
 
72
    the currently displayed cursor.
 
73
 
 
74
    Note that QPlatformCursor does not include any graphics for
 
75
    display. An application that sets a QCursor may provide its own
 
76
    graphics.
 
77
 
 
78
    \sa QPlatformCursorImage
 
79
*/
 
80
 
 
81
/*!
 
82
    \fn virtual void QPlatformCursor::pointerEvent(const QMouseEvent & event)
 
83
 
 
84
    This method is called by Qt whenever a QMouseEvent is generated by the
 
85
    underlying pointer input. \a event is a reference to the QMouseEvent in
 
86
    question. A default do-nothing implementation is provided.
 
87
*/
 
88
 
 
89
/*!
 
90
    \fn virtual void QPlatformCursor::changeCursor(QCursor * windowCursor, QWindow * window)
 
91
 
 
92
    \brief This method is called by Qt whenever the cursor graphic should be changed.
 
93
 
 
94
    Implementation of this method is mandatory for a subclass of QPlatformCursor.
 
95
 
 
96
    \a windowCursor is a pointer to the QCursor that should be displayed.
 
97
 
 
98
    \a window is a pointer to the window currently displayed at QCursor::pos(). Note
 
99
    that this may be 0 if the current position is not occupied by a displayed widget.
 
100
 
 
101
    \sa QCursor::pos()
 
102
*/
 
103
 
 
104
/*!
 
105
    \fn QPlatformCursor::QPlatformCursor()
 
106
 
 
107
    Constructs a QPlatformCursor.
 
108
*/
 
109
QPlatformCursor::QPlatformCursor()
 
110
{
 
111
}
 
112
 
 
113
QPoint QPlatformCursor::pos() const
 
114
{
 
115
    // As a fallback return the last mouse position seen by QGuiApplication.
 
116
    return QGuiApplicationPrivate::lastCursorPosition.toPoint();
 
117
}
 
118
 
 
119
void QPlatformCursor::setPos(const QPoint &pos)
 
120
{
 
121
    Q_UNUSED(pos);
 
122
    qWarning("This plugin does not support QCursor::setPos()");
 
123
}
 
124
 
 
125
// End of display and pointer event handling code
 
126
// Beginning of built-in cursor graphics
 
127
// from src/gui/embedded/QGraphicsSystemCursorImage_qws.cpp
 
128
 
 
129
/*!
 
130
    \class QPlatformCursorImage
 
131
    \since 5.0
 
132
    \internal
 
133
    \preliminary
 
134
    \ingroup qpa
 
135
 
 
136
    \brief The QPlatformCursorImage class provides a set of graphics
 
137
    intended to be used as cursors.
 
138
 
 
139
    \sa QPlatformCursor
 
140
*/
 
141
 
 
142
static QPlatformCursorImage *systemCursorTable[Qt::LastCursor+1];
 
143
static bool systemCursorTableInit = false;
 
144
 
 
145
// 16 x 16
 
146
static const uchar cur_arrow_bits[] = {
 
147
   0x07, 0x00, 0x39, 0x00, 0xc1, 0x01, 0x02, 0x0e, 0x02, 0x10, 0x02, 0x08,
 
148
   0x04, 0x04, 0x04, 0x02, 0x04, 0x04, 0x88, 0x08, 0x48, 0x11, 0x28, 0x22,
 
149
   0x10, 0x44, 0x00, 0x28, 0x00, 0x10, 0x00, 0x00 };
 
150
static const uchar mcur_arrow_bits[] = {
 
151
   0x07, 0x00, 0x3f, 0x00, 0xff, 0x01, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x0f,
 
152
   0xfc, 0x07, 0xfc, 0x03, 0xfc, 0x07, 0xf8, 0x0f, 0x78, 0x1f, 0x38, 0x3e,
 
153
   0x10, 0x7c, 0x00, 0x38, 0x00, 0x10, 0x00, 0x00 };
 
154
 
 
155
static const unsigned char cur_up_arrow_bits[] = {
 
156
   0x80, 0x00, 0x40, 0x01, 0x40, 0x01, 0x20, 0x02, 0x20, 0x02, 0x10, 0x04,
 
157
   0x10, 0x04, 0x08, 0x08, 0x78, 0x0f, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
 
158
   0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0xc0, 0x01};
 
159
static const unsigned char mcur_up_arrow_bits[] = {
 
160
   0x80, 0x00, 0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xe0, 0x03, 0xf0, 0x07,
 
161
   0xf0, 0x07, 0xf8, 0x0f, 0xf8, 0x0f, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
 
162
   0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01};
 
163
 
 
164
static const unsigned char cur_cross_bits[] = {
 
165
   0xc0, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
 
166
   0x7f, 0x7f, 0x01, 0x40, 0x7f, 0x7f, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
 
167
   0x40, 0x01, 0x40, 0x01, 0xc0, 0x01, 0x00, 0x00};
 
168
static const unsigned char mcur_cross_bits[] = {
 
169
   0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
 
170
   0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
 
171
   0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0x00, 0x00};
 
172
 
 
173
static const uchar cur_ibeam_bits[] = {
 
174
   0x00, 0x00, 0xe0, 0x03, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
 
175
   0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
 
176
   0x80, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00 };
 
177
static const uchar mcur_ibeam_bits[] = {
 
178
   0xf0, 0x07, 0xf0, 0x07, 0xf0, 0x07, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
 
179
   0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
 
180
   0xf0, 0x07, 0xf0, 0x07, 0xf0, 0x07, 0x00, 0x00 };
 
181
 
 
182
static const uchar cur_ver_bits[] = {
 
183
    0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f,
 
184
    0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xf0, 0x0f,
 
185
    0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00 };
 
186
static const uchar mcur_ver_bits[] = {
 
187
    0x00, 0x00, 0x80, 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0, 0x1f, 0xf8, 0x3f,
 
188
    0xfc, 0x7f, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xfc, 0x7f, 0xf8, 0x3f,
 
189
    0xf0, 0x1f, 0xe0, 0x0f, 0xc0, 0x07, 0x80, 0x03 };
 
190
 
 
191
static const uchar cur_hor_bits[] = {
 
192
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x08, 0x30, 0x18,
 
193
    0x38, 0x38, 0xfc, 0x7f, 0xfc, 0x7f, 0x38, 0x38, 0x30, 0x18, 0x20, 0x08,
 
194
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
195
static const uchar mcur_hor_bits[] = {
 
196
    0x00, 0x00, 0x00, 0x00, 0x40, 0x04, 0x60, 0x0c, 0x70, 0x1c, 0x78, 0x3c,
 
197
    0xfc, 0x7f, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfc, 0x7f, 0x78, 0x3c,
 
198
    0x70, 0x1c, 0x60, 0x0c, 0x40, 0x04, 0x00, 0x00 };
 
199
static const uchar cur_bdiag_bits[] = {
 
200
    0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x3c, 0x00, 0x3e,
 
201
    0x00, 0x37, 0x88, 0x23, 0xd8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0xf8, 0x00,
 
202
    0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
203
static const uchar mcur_bdiag_bits[] = {
 
204
    0x00, 0x00, 0xc0, 0x7f, 0x80, 0x7f, 0x00, 0x7f, 0x00, 0x7e, 0x04, 0x7f,
 
205
    0x8c, 0x7f, 0xdc, 0x77, 0xfc, 0x63, 0xfc, 0x41, 0xfc, 0x00, 0xfc, 0x01,
 
206
    0xfc, 0x03, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00 };
 
207
static const uchar cur_fdiag_bits[] = {
 
208
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00,
 
209
    0xf8, 0x00, 0xd8, 0x01, 0x88, 0x23, 0x00, 0x37, 0x00, 0x3e, 0x00, 0x3c,
 
210
    0x00, 0x3e, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00 };
 
211
static const uchar mcur_fdiag_bits[] = {
 
212
    0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xfc, 0x03, 0xfc, 0x01, 0xfc, 0x00,
 
213
    0xfc, 0x41, 0xfc, 0x63, 0xdc, 0x77, 0x8c, 0x7f, 0x04, 0x7f, 0x00, 0x7e,
 
214
    0x00, 0x7f, 0x80, 0x7f, 0xc0, 0x7f, 0x00, 0x00 };
 
215
 
 
216
// 20 x 20
 
217
static const uchar forbidden_bits[] = {
 
218
    0x00,0x00,0x00,0x80,0x1f,0x00,0xe0,0x7f,0x00,0xf0,0xf0,0x00,0x38,0xc0,0x01,
 
219
    0x7c,0x80,0x03,0xec,0x00,0x03,0xce,0x01,0x07,0x86,0x03,0x06,0x06,0x07,0x06,
 
220
    0x06,0x0e,0x06,0x06,0x1c,0x06,0x0e,0x38,0x07,0x0c,0x70,0x03,0x1c,0xe0,0x03,
 
221
    0x38,0xc0,0x01,0xf0,0xe0,0x00,0xe0,0x7f,0x00,0x80,0x1f,0x00,0x00,0x00,0x00 };
 
222
 
 
223
static const uchar forbiddenm_bits[] = {
 
224
    0x80,0x1f,0x00,0xe0,0x7f,0x00,0xf0,0xff,0x00,0xf8,0xff,0x01,0xfc,0xf0,0x03,
 
225
    0xfe,0xc0,0x07,0xfe,0x81,0x07,0xff,0x83,0x0f,0xcf,0x07,0x0f,0x8f,0x0f,0x0f,
 
226
    0x0f,0x1f,0x0f,0x0f,0x3e,0x0f,0x1f,0xfc,0x0f,0x1e,0xf8,0x07,0x3e,0xf0,0x07,
 
227
    0xfc,0xe0,0x03,0xf8,0xff,0x01,0xf0,0xff,0x00,0xe0,0x7f,0x00,0x80,0x1f,0x00};
 
228
 
 
229
// 32 x 32
 
230
static const uchar wait_data_bits[] = {
 
231
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
232
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00,
 
233
   0x00, 0x04, 0x40, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x08, 0x20, 0x00,
 
234
   0x00, 0x08, 0x20, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x08, 0x20, 0x00,
 
235
   0x00, 0x50, 0x15, 0x00, 0x00, 0xa0, 0x0a, 0x00, 0x00, 0x40, 0x05, 0x00,
 
236
   0x00, 0x80, 0x02, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x20, 0x08, 0x00,
 
237
   0x00, 0x10, 0x10, 0x00, 0x00, 0x08, 0x21, 0x00, 0x00, 0x88, 0x22, 0x00,
 
238
   0x00, 0x48, 0x25, 0x00, 0x00, 0xa8, 0x2a, 0x00, 0x00, 0xfc, 0x7f, 0x00,
 
239
   0x00, 0x04, 0x40, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00,
 
240
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
241
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
242
static const uchar wait_mask_bits[] = {
 
243
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
244
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00,
 
245
   0x00, 0xfc, 0x7f, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0xf8, 0x3f, 0x00,
 
246
   0x00, 0xf8, 0x3f, 0x00, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0xf8, 0x3f, 0x00,
 
247
   0x00, 0xf0, 0x1f, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0xc0, 0x07, 0x00,
 
248
   0x00, 0x80, 0x03, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x00, 0xe0, 0x0f, 0x00,
 
249
   0x00, 0xf0, 0x1f, 0x00, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0xf8, 0x3f, 0x00,
 
250
   0x00, 0xf8, 0x3f, 0x00, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0xfc, 0x7f, 0x00,
 
251
   0x00, 0xfc, 0x7f, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00,
 
252
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
253
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
254
 
 
255
static const uchar hsplit_bits[] = {
 
256
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
257
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
258
    0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,
 
259
    0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,
 
260
    0x00, 0x41, 0x82, 0x00, 0x80, 0x41, 0x82, 0x01, 0xc0, 0x7f, 0xfe, 0x03,
 
261
    0x80, 0x41, 0x82, 0x01, 0x00, 0x41, 0x82, 0x00, 0x00, 0x40, 0x02, 0x00,
 
262
    0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,
 
263
    0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 
264
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
265
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
266
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
267
static const uchar hsplitm_bits[] = {
 
268
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
269
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
270
    0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00,
 
271
    0x00, 0xe0, 0x07, 0x00, 0x00, 0xe2, 0x47, 0x00, 0x00, 0xe3, 0xc7, 0x00,
 
272
    0x80, 0xe3, 0xc7, 0x01, 0xc0, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0x07,
 
273
    0xc0, 0xff, 0xff, 0x03, 0x80, 0xe3, 0xc7, 0x01, 0x00, 0xe3, 0xc7, 0x00,
 
274
    0x00, 0xe2, 0x47, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00,
 
275
    0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
 
276
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
277
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
278
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
279
static const uchar vsplit_bits[] = {
 
280
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
281
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
282
    0x00, 0x80, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00,
 
283
    0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 
284
    0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xff, 0x7f, 0x00,
 
285
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x7f, 0x00,
 
286
    0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 
287
    0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00,
 
288
    0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
289
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
290
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
291
static const uchar vsplitm_bits[] = {
 
292
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
293
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 
294
    0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x07, 0x00,
 
295
    0x00, 0xf8, 0x0f, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00,
 
296
    0x00, 0xc0, 0x01, 0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00,
 
297
    0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00,
 
298
    0x80, 0xff, 0xff, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00,
 
299
    0x00, 0xc0, 0x01, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf0, 0x07, 0x00,
 
300
    0x00, 0xe0, 0x03, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00,
 
301
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
302
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
303
static const uchar phand_bits[] = {
 
304
    0x00, 0x00, 0x00, 0x00,        0xfe, 0x01, 0x00, 0x00,        0x01, 0x02, 0x00, 0x00,
 
305
    0x7e, 0x04, 0x00, 0x00,        0x08, 0x08, 0x00, 0x00,        0x70, 0x08, 0x00, 0x00,
 
306
    0x08, 0x08, 0x00, 0x00,        0x70, 0x14, 0x00, 0x00,        0x08, 0x22, 0x00, 0x00,
 
307
    0x30, 0x41, 0x00, 0x00,        0xc0, 0x20, 0x00, 0x00,        0x40, 0x12, 0x00, 0x00,
 
308
    0x80, 0x08, 0x00, 0x00,        0x00, 0x05, 0x00, 0x00,        0x00, 0x02, 0x00, 0x00,
 
309
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
310
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
311
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
312
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
313
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
314
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00 };
 
315
static const uchar phandm_bits[] = {
 
316
    0xfe, 0x01, 0x00, 0x00,        0xff, 0x03, 0x00, 0x00,        0xff, 0x07, 0x00, 0x00,
 
317
    0xff, 0x0f, 0x00, 0x00,        0xfe, 0x1f, 0x00, 0x00,        0xf8, 0x1f, 0x00, 0x00,
 
318
    0xfc, 0x1f, 0x00, 0x00,        0xf8, 0x3f, 0x00, 0x00,        0xfc, 0x7f, 0x00, 0x00,
 
319
    0xf8, 0xff, 0x00, 0x00,        0xf0, 0x7f, 0x00, 0x00,        0xe0, 0x3f, 0x00, 0x00,
 
320
    0xc0, 0x1f, 0x00, 0x00,        0x80, 0x0f, 0x00, 0x00,        0x00, 0x07, 0x00, 0x00,
 
321
    0x00, 0x02, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
322
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
323
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
324
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
325
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00,
 
326
    0x00, 0x00, 0x00, 0x00,        0x00, 0x00, 0x00, 0x00 };
 
327
 
 
328
static const uchar size_all_data_bits[] = {
 
329
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
330
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
331
   0x00, 0x80, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00,
 
332
   0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 
333
   0x00, 0x80, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x80, 0x81, 0xc0, 0x00,
 
334
   0xc0, 0xff, 0xff, 0x01, 0x80, 0x81, 0xc0, 0x00, 0x00, 0x81, 0x40, 0x00,
 
335
   0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 
336
   0x00, 0x80, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xc0, 0x01, 0x00,
 
337
   0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
338
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
339
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
340
static const uchar size_all_mask_bits[] = {
 
341
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
342
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 
343
   0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x07, 0x00,
 
344
   0x00, 0xf8, 0x0f, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc2, 0x21, 0x00,
 
345
   0x00, 0xc3, 0x61, 0x00, 0x80, 0xc3, 0xe1, 0x00, 0xc0, 0xff, 0xff, 0x01,
 
346
   0xe0, 0xff, 0xff, 0x03, 0xc0, 0xff, 0xff, 0x01, 0x80, 0xc3, 0xe1, 0x00,
 
347
   0x00, 0xc3, 0x61, 0x00, 0x00, 0xc2, 0x21, 0x00, 0x00, 0xc0, 0x01, 0x00,
 
348
   0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0xe0, 0x03, 0x00,
 
349
   0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
350
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
351
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
352
 
 
353
static const uchar whatsthis_bits[] = {
 
354
   0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0xf0, 0x07, 0x00,
 
355
   0x09, 0x18, 0x0e, 0x00, 0x11, 0x1c, 0x0e, 0x00, 0x21, 0x1c, 0x0e, 0x00,
 
356
   0x41, 0x1c, 0x0e, 0x00, 0x81, 0x1c, 0x0e, 0x00, 0x01, 0x01, 0x07, 0x00,
 
357
   0x01, 0x82, 0x03, 0x00, 0xc1, 0xc7, 0x01, 0x00, 0x49, 0xc0, 0x01, 0x00,
 
358
   0x95, 0xc0, 0x01, 0x00, 0x93, 0xc0, 0x01, 0x00, 0x21, 0x01, 0x00, 0x00,
 
359
   0x20, 0xc1, 0x01, 0x00, 0x40, 0xc2, 0x01, 0x00, 0x40, 0x02, 0x00, 0x00,
 
360
   0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
361
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
362
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
363
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
364
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
 
365
static const uchar whatsthism_bits[] = {
 
366
   0x01, 0x00, 0x00, 0x00, 0x03, 0xf0, 0x07, 0x00, 0x07, 0xf8, 0x0f, 0x00,
 
367
   0x0f, 0xfc, 0x1f, 0x00, 0x1f, 0x3e, 0x1f, 0x00, 0x3f, 0x3e, 0x1f, 0x00,
 
368
   0x7f, 0x3e, 0x1f, 0x00, 0xff, 0x3e, 0x1f, 0x00, 0xff, 0x9d, 0x0f, 0x00,
 
369
   0xff, 0xc3, 0x07, 0x00, 0xff, 0xe7, 0x03, 0x00, 0x7f, 0xe0, 0x03, 0x00,
 
370
   0xf7, 0xe0, 0x03, 0x00, 0xf3, 0xe0, 0x03, 0x00, 0xe1, 0xe1, 0x03, 0x00,
 
371
   0xe0, 0xe1, 0x03, 0x00, 0xc0, 0xe3, 0x03, 0x00, 0xc0, 0xe3, 0x03, 0x00,
 
372
   0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
373
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
374
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
375
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
376
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
 
377
 
 
378
static const uchar busy_bits[] = {
 
379
    0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 
380
    0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
 
381
    0x41, 0xe0, 0xff, 0x00, 0x81, 0x20, 0x80, 0x00, 0x01, 0xe1, 0xff, 0x00,
 
382
    0x01, 0x42, 0x40, 0x00, 0xc1, 0x47, 0x40, 0x00, 0x49, 0x40, 0x55, 0x00,
 
383
    0x95, 0x80, 0x2a, 0x00, 0x93, 0x00, 0x15, 0x00, 0x21, 0x01, 0x0a, 0x00,
 
384
    0x20, 0x01, 0x11, 0x00, 0x40, 0x82, 0x20, 0x00, 0x40, 0x42, 0x44, 0x00,
 
385
    0x80, 0x41, 0x4a, 0x00, 0x00, 0x40, 0x55, 0x00, 0x00, 0xe0, 0xff, 0x00,
 
386
    0x00, 0x20, 0x80, 0x00, 0x00, 0xe0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
 
387
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
388
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
389
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
390
static const uchar busym_bits[] = {
 
391
    0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
 
392
    0x0f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00,
 
393
    0x7f, 0xe0, 0xff, 0x00, 0xff, 0xe0, 0xff, 0x00, 0xff, 0xe1, 0xff, 0x00,
 
394
    0xff, 0xc3, 0x7f, 0x00, 0xff, 0xc7, 0x7f, 0x00, 0x7f, 0xc0, 0x7f, 0x00,
 
395
    0xf7, 0x80, 0x3f, 0x00, 0xf3, 0x00, 0x1f, 0x00, 0xe1, 0x01, 0x0e, 0x00,
 
396
    0xe0, 0x01, 0x1f, 0x00, 0xc0, 0x83, 0x3f, 0x00, 0xc0, 0xc3, 0x7f, 0x00,
 
397
    0x80, 0xc1, 0x7f, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0xe0, 0xff, 0x00,
 
398
    0x00, 0xe0, 0xff, 0x00, 0x00, 0xe0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
 
399
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
400
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
401
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
402
 
 
403
// 16 x 16
 
404
static const uchar openhand_bits[] = {
 
405
    0x80,0x01,0x58,0x0e,0x64,0x12,0x64,0x52,0x48,0xb2,0x48,0x92,
 
406
    0x16,0x90,0x19,0x80,0x11,0x40,0x02,0x40,0x04,0x40,0x04,0x20,
 
407
    0x08,0x20,0x10,0x10,0x20,0x10,0x00,0x00};
 
408
static const uchar openhandm_bits[] = {
 
409
    0x80,0x01,0xd8,0x0f,0xfc,0x1f,0xfc,0x5f,0xf8,0xff,0xf8,0xff,
 
410
    0xfe,0xff,0xff,0xff,0xff,0x7f,0xfe,0x7f,0xfc,0x7f,0xfc,0x3f,
 
411
    0xf8,0x3f,0xf0,0x1f,0xe0,0x1f,0x00,0x00};
 
412
static const uchar closedhand_bits[] = {
 
413
    0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0x48,0x32,0x08,0x50,
 
414
    0x10,0x40,0x18,0x40,0x04,0x40,0x04,0x20,0x08,0x20,0x10,0x10,
 
415
    0x20,0x10,0x20,0x10,0x00,0x00,0x00,0x00};
 
416
static const uchar closedhandm_bits[] = {
 
417
    0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0xf8,0x3f,0xf8,0x7f,
 
418
    0xf0,0x7f,0xf8,0x7f,0xfc,0x7f,0xfc,0x3f,0xf8,0x3f,0xf0,0x1f,
 
419
    0xe0,0x1f,0xe0,0x1f,0x00,0x00,0x00,0x00};
 
420
 
 
421
void QPlatformCursorImage::createSystemCursor(int id)
 
422
{
 
423
    if (!systemCursorTableInit) {
 
424
        for (int i = 0; i <= Qt::LastCursor; i++)
 
425
            systemCursorTable[i] = 0;
 
426
        systemCursorTableInit = true;
 
427
    }
 
428
    switch (id) {
 
429
        // 16x16 cursors
 
430
        case Qt::ArrowCursor:
 
431
            systemCursorTable[Qt::ArrowCursor] =
 
432
                new QPlatformCursorImage(cur_arrow_bits, mcur_arrow_bits, 16, 16, 0, 0);
 
433
            break;
 
434
 
 
435
        case Qt::UpArrowCursor:
 
436
            systemCursorTable[Qt::UpArrowCursor] =
 
437
                new QPlatformCursorImage(cur_up_arrow_bits, mcur_up_arrow_bits, 16, 16, 7, 0);
 
438
            break;
 
439
 
 
440
        case Qt::CrossCursor:
 
441
            systemCursorTable[Qt::CrossCursor] =
 
442
                new QPlatformCursorImage(cur_cross_bits, mcur_cross_bits, 16, 16, 7, 7);
 
443
            break;
 
444
 
 
445
        case Qt::IBeamCursor:
 
446
            systemCursorTable[Qt::IBeamCursor] =
 
447
                new QPlatformCursorImage(cur_ibeam_bits, mcur_ibeam_bits, 16, 16, 7, 7);
 
448
            break;
 
449
 
 
450
        case Qt::SizeVerCursor:
 
451
            systemCursorTable[Qt::SizeVerCursor] =
 
452
                new QPlatformCursorImage(cur_ver_bits, mcur_ver_bits, 16, 16, 7, 7);
 
453
            break;
 
454
 
 
455
        case Qt::SizeHorCursor:
 
456
            systemCursorTable[Qt::SizeHorCursor] =
 
457
                new QPlatformCursorImage(cur_hor_bits, mcur_hor_bits, 16, 16, 7, 7);
 
458
            break;
 
459
 
 
460
        case Qt::SizeBDiagCursor:
 
461
            systemCursorTable[Qt::SizeBDiagCursor] =
 
462
                new QPlatformCursorImage(cur_bdiag_bits, mcur_bdiag_bits, 16, 16, 7, 7);
 
463
            break;
 
464
 
 
465
        case Qt::SizeFDiagCursor:
 
466
            systemCursorTable[Qt::SizeFDiagCursor] =
 
467
                new QPlatformCursorImage(cur_fdiag_bits, mcur_fdiag_bits, 16, 16, 7, 7);
 
468
            break;
 
469
 
 
470
        case Qt::BlankCursor:
 
471
            systemCursorTable[Qt::BlankCursor] =
 
472
                new QPlatformCursorImage(0, 0, 0, 0, 0, 0);
 
473
            break;
 
474
 
 
475
        // 20x20 cursors
 
476
        case Qt::ForbiddenCursor:
 
477
            systemCursorTable[Qt::ForbiddenCursor] =
 
478
                new QPlatformCursorImage(forbidden_bits, forbiddenm_bits, 20, 20, 10, 10);
 
479
            break;
 
480
 
 
481
        // 32x32 cursors
 
482
        case Qt::WaitCursor:
 
483
            systemCursorTable[Qt::WaitCursor] =
 
484
                new QPlatformCursorImage(wait_data_bits, wait_mask_bits, 32, 32, 15, 15);
 
485
            break;
 
486
 
 
487
        case Qt::SplitVCursor:
 
488
            systemCursorTable[Qt::SplitVCursor] =
 
489
                new QPlatformCursorImage(vsplit_bits, vsplitm_bits, 32, 32, 15, 15);
 
490
            break;
 
491
 
 
492
        case Qt::SplitHCursor:
 
493
            systemCursorTable[Qt::SplitHCursor] =
 
494
                new QPlatformCursorImage(hsplit_bits, hsplitm_bits, 32, 32, 15, 15);
 
495
            break;
 
496
 
 
497
        case Qt::SizeAllCursor:
 
498
            systemCursorTable[Qt::SizeAllCursor] =
 
499
                new QPlatformCursorImage(size_all_data_bits, size_all_mask_bits, 32, 32, 15, 15);
 
500
            break;
 
501
 
 
502
        case Qt::PointingHandCursor:
 
503
            systemCursorTable[Qt::PointingHandCursor] =
 
504
                new QPlatformCursorImage(phand_bits, phandm_bits, 32, 32, 0, 0);
 
505
            break;
 
506
 
 
507
        case Qt::WhatsThisCursor:
 
508
            systemCursorTable[Qt::WhatsThisCursor] =
 
509
                new QPlatformCursorImage(whatsthis_bits, whatsthism_bits, 32, 32, 0, 0);
 
510
            break;
 
511
        case Qt::BusyCursor:
 
512
            systemCursorTable[Qt::BusyCursor] =
 
513
                new QPlatformCursorImage(busy_bits, busym_bits, 32, 32, 0, 0);
 
514
            break;
 
515
 
 
516
        case Qt::OpenHandCursor:
 
517
            systemCursorTable[Qt::OpenHandCursor] =
 
518
                new QPlatformCursorImage(openhand_bits, openhandm_bits, 16, 16, 8, 8);
 
519
            break;
 
520
        case Qt::ClosedHandCursor:
 
521
            systemCursorTable[Qt::ClosedHandCursor] =
 
522
                new QPlatformCursorImage(closedhand_bits, closedhandm_bits, 16, 16, 8, 8);
 
523
            break;
 
524
        default:
 
525
            qWarning("Unknown system cursor %d", id);
 
526
    }
 
527
}
 
528
 
 
529
/*!
 
530
    \fn void QPlatformCursorImage::set(Qt::CursorShape id)
 
531
 
 
532
    \brief Calling this method sets the cursor image to the specified shape
 
533
 
 
534
    \a id is one of the defined Qt::CursorShape values.
 
535
 
 
536
    If id is invalid, Qt::BitmapCursor, or unknown by the implementation,
 
537
    Qt::ArrowCursor is used instead.
 
538
*/
 
539
 
 
540
void QPlatformCursorImage::set(Qt::CursorShape id)
 
541
{
 
542
    QPlatformCursorImage *cursor = 0;
 
543
    if (id >= 0 && id <= Qt::LastCursor) {
 
544
        if (!systemCursorTable[id])
 
545
            createSystemCursor(id);
 
546
        cursor = systemCursorTable[id];
 
547
    }
 
548
 
 
549
    if (cursor == 0) {
 
550
        if (!systemCursorTable[Qt::ArrowCursor])
 
551
            createSystemCursor(Qt::ArrowCursor);
 
552
        cursor = systemCursorTable[Qt::ArrowCursor];
 
553
    }
 
554
    cursorImage = cursor->cursorImage;
 
555
    hot = cursor->hot;
 
556
}
 
557
 
 
558
/*!
 
559
    Sets the cursor image to the given \a image, with the hotspot at the
 
560
    point specified by (\a hx, \a hy).
 
561
*/
 
562
 
 
563
void QPlatformCursorImage::set(const QImage &image, int hx, int hy)
 
564
{
 
565
    hot.setX(hx);
 
566
    hot.setY(hy);
 
567
    cursorImage = image;
 
568
}
 
569
 
 
570
/*!
 
571
    \fn void QPlatformCursorImage::set(const uchar *data, const uchar *mask, int width, int height, int hx, int hy)
 
572
 
 
573
    Sets the cursor image to the graphic represented by the combination of
 
574
    \a data and \a mask, with dimensions given by \a width and \a height and a
 
575
    hotspot at the point specified by (\a hx, \a hy).
 
576
 
 
577
    The image data specified by \a data must be supplied in the format
 
578
    described by QImage::Format_Indexed8.
 
579
 
 
580
    The corresponding mask data specified by \a mask must be supplied in a
 
581
    character array containing packed 1 bit per pixel format data, with any
 
582
    padding bits at the end of the array. Bits of value 0 represent transparent
 
583
    pixels in the image data.
 
584
*/
 
585
void QPlatformCursorImage::set(const uchar *data, const uchar *mask,
 
586
                    int width, int height, int hx, int hy)
 
587
{
 
588
    hot.setX(hx);
 
589
    hot.setY(hy);
 
590
 
 
591
    cursorImage = QImage(width,height, QImage::Format_Indexed8);
 
592
 
 
593
    if (!width || !height || !data || !mask || cursorImage.isNull())
 
594
        return;
 
595
 
 
596
    cursorImage.setColorCount(3);
 
597
    cursorImage.setColor(0, 0xff000000);
 
598
    cursorImage.setColor(1, 0xffffffff);
 
599
    cursorImage.setColor(2, 0x00000000);
 
600
 
 
601
    int bytesPerLine = (width + 7) / 8;
 
602
    int p = 0;
 
603
    int d, m;
 
604
 
 
605
    int x = -1, w = 0;
 
606
 
 
607
    uchar *cursor_data = cursorImage.bits();
 
608
    int bpl = cursorImage.bytesPerLine();
 
609
    for (int i = 0; i < height; i++)
 
610
    {
 
611
        for (int j = 0; j < bytesPerLine; j++, data++, mask++)
 
612
        {
 
613
            for (int b = 0; b < 8 && j*8+b < width; b++)
 
614
            {
 
615
                d = *data & (1 << b);
 
616
                m = *mask & (1 << b);
 
617
                if (d && m) p = 0;
 
618
                else if (!d && m) p = 1;
 
619
                else p = 2;
 
620
                cursor_data[j*8+b] = p;
 
621
 
 
622
                // calc region
 
623
                if (x < 0 && m)
 
624
                    x = j*8+b;
 
625
                else if (x >= 0 && !m) {
 
626
                    x = -1;
 
627
                    w = 0;
 
628
                }
 
629
                if (m)
 
630
                    w++;
 
631
            }
 
632
        }
 
633
        if (x >= 0) {
 
634
            x = -1;
 
635
            w = 0;
 
636
        }
 
637
        cursor_data += bpl;
 
638
    }
 
639
 
 
640
}
 
641
 
 
642
/*!
 
643
    \fn QPlatformCursorImage::QPlatformCursorImage(const uchar *data, const uchar *mask, int width, int height, int hotX, int hotY)
 
644
 
 
645
    Sets the cursor image to the graphic represented by the combination of
 
646
    \a data and \a mask, with dimensions given by \a width and \a height and a
 
647
    hotspot at the point specified by (\a hotX, \a hotY).
 
648
 
 
649
    \sa set()
 
650
*/
 
651
 
 
652
/*!
 
653
  \fn QImage *QPlatformCursorImage::image()
 
654
 
 
655
  \brief Return the cursor graphic as a pointer to a QImage
 
656
*/
 
657
 
 
658
/*!
 
659
    \fn QPoint QPlatformCursorImage::hotspot() const
 
660
 
 
661
    \brief Return the cursor's hotspot
 
662
*/
 
663
 
 
664
QT_END_NAMESPACE