source: trunk/src/gui/kernel/qcursor_mac.mm@ 765

Last change on this file since 765 was 651, checked in by Dmitry A. Kuminov, 16 years ago

trunk: Merged in qt 4.6.2 sources.
File size: 19.5 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtGui module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include <private/qcursor_p.h>
43#include <private/qpixmap_mac_p.h>
44#include <qapplication.h>
45#include <qbitmap.h>
46#include <qcursor.h>
47#include <qevent.h>
48#include <string.h>
49#include <unistd.h>
50#include <AppKit/NSCursor.h>
51#include <qpainter.h>
52#include <private/qt_cocoa_helpers_mac_p.h>
53
54QT_BEGIN_NAMESPACE
55
56/*****************************************************************************
57 Externals
58 *****************************************************************************/
59extern QCursorData *qt_cursorTable[Qt::LastCursor + 1];
60extern OSWindowRef qt_mac_window_for(const QWidget *); //qwidget_mac.cpp
61extern GrafPtr qt_mac_qd_context(const QPaintDevice *); //qpaintdevice_mac.cpp
62extern bool qt_sendSpontaneousEvent(QObject *, QEvent *); //qapplication_mac.cpp
63
64/*****************************************************************************
65 Internal QCursorData class
66 *****************************************************************************/
67
68class QMacAnimateCursor : public QObject
69{
70 int timerId, step;
71 ThemeCursor curs;
72public:
73 QMacAnimateCursor() : QObject(), timerId(-1) { }
74 void start(ThemeCursor c) {
75 step = 1;
76 if(timerId != -1)
77 killTimer(timerId);
78 timerId = startTimer(300);
79 curs = c;
80 }
81 void stop() {
82 if(timerId != -1) {
83 killTimer(timerId);
84 timerId = -1;
85 }
86 }
87protected:
88 void timerEvent(QTimerEvent *e) {
89 if(e->timerId() == timerId) {
90 /*
91 if(SetAnimatedThemeCursor(curs, step++) == themeBadCursorIndexErr)
92 stop();
93 */
94 }
95 }
96};
97
98void *qt_mac_nsCursorForQCursor(const QCursor &c)
99{
100 c.d->update();
101 return [[static_cast<NSCursor *>(c.d->curs.cp.nscursor) retain] autorelease];
102}
103
104static QCursorData *currentCursor = 0; //current cursor
105void qt_mac_set_cursor(const QCursor *c, const QPoint &)
106{
107#ifdef QT_MAC_USE_COCOA
108 Q_UNUSED(c);
109 return;
110#else
111 if (!c) {
112 currentCursor = 0;
113 return;
114 }
115 c->handle(); //force the cursor to get loaded, if it's not
116
117 if(1 || currentCursor != c->d) {
118 if(currentCursor && currentCursor->type == QCursorData::TYPE_ThemeCursor
119 && currentCursor->curs.tc.anim)
120 currentCursor->curs.tc.anim->stop();
121 QMacCocoaAutoReleasePool pool;
122 if(c->d->type == QCursorData::TYPE_ImageCursor) {
123 [static_cast<NSCursor *>(c->d->curs.cp.nscursor) set];
124 } else if(c->d->type == QCursorData::TYPE_ThemeCursor) {
125#ifdef QT_MAC_USE_COCOA
126 if (c->d->curs.cp.nscursor == 0)
127 [[NSCursor arrowCursor] set];
128 [static_cast<NSCursor *>(c->d->curs.cp.nscursor) set];
129#else
130 if(SetAnimatedThemeCursor(c->d->curs.tc.curs, 0) == themeBadCursorIndexErr) {
131 SetThemeCursor(c->d->curs.tc.curs);
132 } else {
133 if(!c->d->curs.tc.anim)
134 c->d->curs.tc.anim = new QMacAnimateCursor;
135 c->d->curs.tc.anim->start(c->d->curs.tc.curs);
136 }
137#endif
138 }
139 }
140 currentCursor = c->d;
141#endif
142}
143
144void qt_mac_update_cursor_at_global_pos(const QPoint &globalPos)
145{
146#ifdef QT_MAC_USE_COCOA
147 Q_UNUSED(globalPos);
148 return;
149#else
150 QCursor cursor(Qt::ArrowCursor);
151 if (QApplication::overrideCursor()) {
152 cursor = *QApplication::overrideCursor();
153 } else {
154 for(QWidget *w = QApplication::widgetAt(globalPos); w; w = w->parentWidget()) {
155 if(w->testAttribute(Qt::WA_SetCursor)) {
156 cursor = w->cursor();
157 break;
158 }
159 }
160 }
161 qt_mac_set_cursor(&cursor, globalPos);
162#endif
163}
164
165void qt_mac_update_cursor()
166{
167 qt_mac_update_cursor_at_global_pos(QCursor::pos());
168}
169
170static int nextCursorId = Qt::BitmapCursor;
171
172QCursorData::QCursorData(Qt::CursorShape s)
173 : cshape(s), bm(0), bmm(0), hx(-1), hy(-1), mId(s), type(TYPE_None)
174{
175 ref = 1;
176 memset(&curs, '\0', sizeof(curs));
177}
178
179QCursorData::~QCursorData()
180{
181 if (type == TYPE_ImageCursor) {
182 if (curs.cp.my_cursor) {
183 QMacCocoaAutoReleasePool pool;
184 [static_cast<NSCursor *>(curs.cp.nscursor) release];
185 }
186 } else if(type == TYPE_ThemeCursor) {
187 delete curs.tc.anim;
188 }
189 type = TYPE_None;
190
191 delete bm;
192 delete bmm;
193 if(currentCursor == this)
194 currentCursor = 0;
195}
196
197QCursorData *QCursorData::setBitmap(const QBitmap &bitmap, const QBitmap &mask, int hotX, int hotY)
198{
199 if (!QCursorData::initialized)
200 QCursorData::initialize();
201 if (bitmap.depth() != 1 || mask.depth() != 1 || bitmap.size() != mask.size()) {
202 qWarning("Qt: QCursor: Cannot create bitmap cursor; invalid bitmap(s)");
203 QCursorData *c = qt_cursorTable[0];
204 c->ref.ref();
205 return c;
206 }
207 // This is silly, but this is apparently called outside the constructor, so we have
208 // to be ready for that case.
209 QCursorData *x = new QCursorData;
210 x->ref = 1;
211 x->mId = ++nextCursorId;
212 x->bm = new QBitmap(bitmap);
213 x->bmm = new QBitmap(mask);
214 x->cshape = Qt::BitmapCursor;
215 x->hx = hotX >= 0 ? hotX : bitmap.width() / 2;
216 x->hy = hotY >= 0 ? hotY : bitmap.height() / 2;
217 return x;
218}
219
220Qt::HANDLE QCursor::handle() const
221{
222 if(!QCursorData::initialized)
223 QCursorData::initialize();
224 if(d->type == QCursorData::TYPE_None)
225 d->update();
226 return (Qt::HANDLE)d->mId;
227}
228
229QPoint QCursor::pos()
230{
231 return flipPoint([NSEvent mouseLocation]).toPoint();
232}
233
234void QCursor::setPos(int x, int y)
235{
236 CGWarpMouseCursorPosition(CGPointMake(x, y));
237
238 /* I'm not too keen on doing this, but this makes it a lot easier, so I just
239 send the event back through the event system and let it get propagated correctly
240 ideally this would not really need to be faked --Sam
241 */
242 QWidget *widget = 0;
243 if(QWidget *grb = QWidget::mouseGrabber())
244 widget = grb;
245 else
246 widget = QApplication::widgetAt(QPoint(x, y));
247 if(widget) {
248 QMouseEvent me(QMouseEvent::MouseMove, widget->mapFromGlobal(QPoint(x, y)), Qt::NoButton,
249 QApplication::mouseButtons(), QApplication::keyboardModifiers());
250 qt_sendSpontaneousEvent(widget, &me);
251 }
252}
253
254void QCursorData::initCursorFromBitmap()
255{
256 NSImage *nsimage;
257 QImage finalCursor(bm->size(), QImage::Format_ARGB32);
258 QImage bmi = bm->toImage().convertToFormat(QImage::Format_RGB32);
259 QImage bmmi = bmm->toImage().convertToFormat(QImage::Format_RGB32);
260 for (int row = 0; row < finalCursor.height(); ++row) {
261 QRgb *bmData = reinterpret_cast<QRgb *>(bmi.scanLine(row));
262 QRgb *bmmData = reinterpret_cast<QRgb *>(bmmi.scanLine(row));
263 QRgb *finalData = reinterpret_cast<QRgb *>(finalCursor.scanLine(row));
264 for (int col = 0; col < finalCursor.width(); ++col) {
265 if (bmmData[col] == 0xff000000 && bmData[col] == 0xffffffff) {
266 finalData[col] = 0xffffffff;
267 } else if (bmmData[col] == 0xff000000 && bmData[col] == 0xffffffff) {
268 finalData[col] = 0x7f000000;
269 } else if (bmmData[col] == 0xffffffff && bmData[col] == 0xffffffff) {
270 finalData[col] = 0x00000000;
271 } else {
272 finalData[col] = 0xff000000;
273 }
274 }
275 }
276 type = QCursorData::TYPE_ImageCursor;
277 curs.cp.my_cursor = true;
278 QPixmap bmCopy = QPixmap::fromImage(finalCursor);
279 NSPoint hotSpot = { hx, hy };
280 nsimage = static_cast<NSImage*>(qt_mac_create_nsimage(bmCopy));
281 curs.cp.nscursor = [[NSCursor alloc] initWithImage:nsimage hotSpot: hotSpot];
282 [nsimage release];
283}
284
285void QCursorData::initCursorFromPixmap()
286{
287 type = QCursorData::TYPE_ImageCursor;
288 curs.cp.my_cursor = true;
289 NSPoint hotSpot = { hx, hy };
290 NSImage *nsimage;
291 nsimage = static_cast<NSImage *>(qt_mac_create_nsimage(pixmap));
292 curs.cp.nscursor = [[NSCursor alloc] initWithImage:nsimage hotSpot: hotSpot];
293 [nsimage release];
294}
295
296void QCursorData::update()
297{
298 if(!QCursorData::initialized)
299 QCursorData::initialize();
300 if(type != QCursorData::TYPE_None)
301 return;
302
303 /* Note to self... ***
304 * mask x data
305 * 0xFF x 0x00 == fully opaque white
306 * 0x00 x 0xFF == xor'd black
307 * 0xFF x 0xFF == fully opaque black
308 * 0x00 x 0x00 == fully transparent
309 */
310
311 if (hx < 0)
312 hx = 0;
313 if (hy < 0)
314 hy = 0;
315
316#define QT_USE_APPROXIMATE_CURSORS
317#ifdef QT_USE_APPROXIMATE_CURSORS
318 static const uchar cur_ver_bits[] = {
319 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0,
320 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x0f, 0xf0,
321 0x07, 0xe0, 0x03, 0xc0, 0x01, 0x80, 0x00, 0x00 };
322 static const uchar mcur_ver_bits[] = {
323 0x00, 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x3f, 0xf8,
324 0x7f, 0xfc, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x7f, 0xfc, 0x3f, 0xf8,
325 0x1f, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80 };
326
327 static const uchar cur_hor_bits[] = {
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0x18, 0x30,
329 0x38, 0x38, 0x7f, 0xfc, 0x7f, 0xfc, 0x38, 0x38, 0x18, 0x30, 0x08, 0x20,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
331 static const uchar mcur_hor_bits[] = {
332 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x0c, 0x60, 0x1c, 0x70, 0x3c, 0x78,
333 0x7f, 0xfc, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0x7f, 0xfc, 0x3c, 0x78,
334 0x1c, 0x70, 0x0c, 0x60, 0x04, 0x40, 0x00, 0x00 };
335
336 static const uchar cur_fdiag_bits[] = {
337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8, 0x00, 0xf8, 0x00, 0x78,
338 0x00, 0xf8, 0x01, 0xd8, 0x23, 0x88, 0x37, 0x00, 0x3e, 0x00, 0x3c, 0x00,
339 0x3e, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00 };
340 static const uchar mcur_fdiag_bits[] = {
341 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x03, 0xfc, 0x01, 0xfc, 0x00, 0xfc,
342 0x41, 0xfc, 0x63, 0xfc, 0x77, 0xdc, 0x7f, 0x8c, 0x7f, 0x04, 0x7e, 0x00,
343 0x7f, 0x00, 0x7f, 0x80, 0x7f, 0xc0, 0x00, 0x00 };
344
345 static const uchar cur_bdiag_bits[] = {
346 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x3c, 0x00, 0x3e, 0x00,
347 0x37, 0x00, 0x23, 0x88, 0x01, 0xd8, 0x00, 0xf8, 0x00, 0x78, 0x00, 0xf8,
348 0x01, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
349 static const uchar mcur_bdiag_bits[] = {
350 0x00, 0x00, 0x7f, 0xc0, 0x7f, 0x80, 0x7f, 0x00, 0x7e, 0x00, 0x7f, 0x04,
351 0x7f, 0x8c, 0x77, 0xdc, 0x63, 0xfc, 0x41, 0xfc, 0x00, 0xfc, 0x01, 0xfc,
352 0x03, 0xfc, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00 };
353
354 static const unsigned char cur_up_arrow_bits[] = {
355 0x00, 0x80, 0x01, 0x40, 0x01, 0x40, 0x02, 0x20, 0x02, 0x20, 0x04, 0x10,
356 0x04, 0x10, 0x08, 0x08, 0x0f, 0x78, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40,
357 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0xc0 };
358 static const unsigned char mcur_up_arrow_bits[] = {
359 0x00, 0x80, 0x01, 0xc0, 0x01, 0xc0, 0x03, 0xe0, 0x03, 0xe0, 0x07, 0xf0,
360 0x07, 0xf0, 0x0f, 0xf8, 0x0f, 0xf8, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
361 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0 };
362#endif
363 const uchar *cursorData = 0;
364 const uchar *cursorMaskData = 0;
365#ifdef QT_MAC_USE_COCOA
366 switch (cshape) { // map Q cursor to MAC cursor
367 case Qt::BitmapCursor: {
368 if (pixmap.isNull())
369 initCursorFromBitmap();
370 else
371 initCursorFromPixmap();
372 break; }
373 case Qt::BlankCursor: {
374 pixmap = QPixmap(16, 16);
375 pixmap.fill(Qt::transparent);
376 initCursorFromPixmap();
377 break; }
378 case Qt::ArrowCursor: {
379 type = QCursorData::TYPE_ThemeCursor;
380 curs.cp.nscursor = [NSCursor arrowCursor];
381 break; }
382 case Qt::CrossCursor: {
383 type = QCursorData::TYPE_ThemeCursor;
384 curs.cp.nscursor = [NSCursor crosshairCursor];
385 break; }
386 case Qt::WaitCursor: {
387 pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/spincursor.png"));
388 initCursorFromPixmap();
389 break; }
390 case Qt::IBeamCursor: {
391 type = QCursorData::TYPE_ThemeCursor;
392 curs.cp.nscursor = [NSCursor IBeamCursor];
393 break; }
394 case Qt::SizeAllCursor: {
395 pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/pluscursor.png"));
396 initCursorFromPixmap();
397 break; }
398 case Qt::WhatsThisCursor: { //for now just use the pointing hand
399 case Qt::PointingHandCursor:
400 type = QCursorData::TYPE_ThemeCursor;
401 curs.cp.nscursor = [NSCursor pointingHandCursor];
402 break; }
403 case Qt::BusyCursor: {
404 pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/waitcursor.png"));
405 initCursorFromPixmap();
406 break; }
407 case Qt::SplitVCursor: {
408 type = QCursorData::TYPE_ThemeCursor;
409 curs.cp.nscursor = [NSCursor resizeUpDownCursor];
410 break; }
411 case Qt::SplitHCursor: {
412 type = QCursorData::TYPE_ThemeCursor;
413 curs.cp.nscursor = [NSCursor resizeLeftRightCursor];
414 break; }
415 case Qt::ForbiddenCursor: {
416 pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/forbiddencursor.png"));
417 initCursorFromPixmap();
418 break; }
419 case Qt::OpenHandCursor:
420 type = QCursorData::TYPE_ThemeCursor;
421 curs.cp.nscursor = [NSCursor openHandCursor];
422 break;
423 case Qt::ClosedHandCursor:
424 type = QCursorData::TYPE_ThemeCursor;
425 curs.cp.nscursor = [NSCursor closedHandCursor];
426 break;
427#define QT_USE_APPROXIMATE_CURSORS
428#ifdef QT_USE_APPROXIMATE_CURSORS
429 case Qt::SizeVerCursor:
430 cursorData = cur_ver_bits;
431 cursorMaskData = mcur_ver_bits;
432 hx = hy = 8;
433 break;
434 case Qt::SizeHorCursor:
435 cursorData = cur_hor_bits;
436 cursorMaskData = mcur_hor_bits;
437 hx = hy = 8;
438 break;
439 case Qt::SizeBDiagCursor:
440 cursorData = cur_fdiag_bits;
441 cursorMaskData = mcur_fdiag_bits;
442 hx = hy = 8;
443 break;
444 case Qt::SizeFDiagCursor:
445 cursorData = cur_bdiag_bits;
446 cursorMaskData = mcur_bdiag_bits;
447 hx = hy = 8;
448 break;
449 case Qt::UpArrowCursor:
450 cursorData = cur_up_arrow_bits;
451 cursorMaskData = mcur_up_arrow_bits;
452 hx = 8;
453 break;
454#endif
455 default:
456 qWarning("Qt: QCursor::update: Invalid cursor shape %d", cshape);
457 return;
458 }
459#else
460 // Carbon
461 switch (cshape) { // map Q cursor to MAC cursor
462 case Qt::BitmapCursor: {
463 if (pixmap.isNull())
464 initCursorFromBitmap();
465 else
466 initCursorFromPixmap();
467 break; }
468 case Qt::BlankCursor: {
469 pixmap = QPixmap(16, 16);
470 pixmap.fill(Qt::transparent);
471 initCursorFromPixmap();
472 break; }
473 case Qt::ArrowCursor: {
474 type = QCursorData::TYPE_ThemeCursor;
475 curs.tc.curs = kThemeArrowCursor;
476 break; }
477 case Qt::CrossCursor: {
478 type = QCursorData::TYPE_ThemeCursor;
479 curs.tc.curs = kThemeCrossCursor;
480 break; }
481 case Qt::WaitCursor: {
482 type = QCursorData::TYPE_ThemeCursor;
483 curs.tc.curs = kThemeWatchCursor;
484 break; }
485 case Qt::IBeamCursor: {
486 type = QCursorData::TYPE_ThemeCursor;
487 curs.tc.curs = kThemeIBeamCursor;
488 break; }
489 case Qt::SizeAllCursor: {
490 type = QCursorData::TYPE_ThemeCursor;
491 curs.tc.curs = kThemePlusCursor;
492 break; }
493 case Qt::WhatsThisCursor: { //for now just use the pointing hand
494 case Qt::PointingHandCursor:
495 type = QCursorData::TYPE_ThemeCursor;
496 curs.tc.curs = kThemePointingHandCursor;
497 break; }
498 case Qt::BusyCursor: {
499 type = QCursorData::TYPE_ThemeCursor;
500 curs.tc.curs = kThemeSpinningCursor;
501 break; }
502 case Qt::SplitVCursor: {
503 type = QCursorData::TYPE_ThemeCursor;
504 curs.tc.curs = kThemeResizeUpDownCursor;
505 break; }
506 case Qt::SplitHCursor: {
507 type = QCursorData::TYPE_ThemeCursor;
508 curs.tc.curs = kThemeResizeLeftRightCursor;
509 break; }
510 case Qt::ForbiddenCursor: {
511 type = QCursorData::TYPE_ThemeCursor;
512 curs.tc.curs = kThemeNotAllowedCursor;
513 break; }
514 case Qt::OpenHandCursor:
515 type = QCursorData::TYPE_ThemeCursor;
516 curs.tc.curs = kThemeOpenHandCursor;
517 break;
518 case Qt::ClosedHandCursor:
519 type = QCursorData::TYPE_ThemeCursor;
520 curs.tc.curs = kThemeClosedHandCursor;
521 break;
522#define QT_USE_APPROXIMATE_CURSORS
523#ifdef QT_USE_APPROXIMATE_CURSORS
524 case Qt::SizeVerCursor:
525 cursorData = cur_ver_bits;
526 cursorMaskData = mcur_ver_bits;
527 hx = hy = 8;
528 break;
529 case Qt::SizeHorCursor:
530 cursorData = cur_hor_bits;
531 cursorMaskData = mcur_hor_bits;
532 hx = hy = 8;
533 break;
534 case Qt::SizeBDiagCursor:
535 cursorData = cur_fdiag_bits;
536 cursorMaskData = mcur_fdiag_bits;
537 hx = hy = 8;
538 break;
539 case Qt::SizeFDiagCursor:
540 cursorData = cur_bdiag_bits;
541 cursorMaskData = mcur_bdiag_bits;
542 hx = hy = 8;
543 break;
544 case Qt::UpArrowCursor:
545 cursorData = cur_up_arrow_bits;
546 cursorMaskData = mcur_up_arrow_bits;
547 hx = 8;
548 break;
549#endif
550 default:
551 qWarning("Qt: QCursor::update: Invalid cursor shape %d", cshape);
552 return;
553 }
554#endif
555
556 if (cursorData) {
557 bm = new QBitmap(QBitmap::fromData(QSize(16, 16), cursorData,
558 QImage::Format_Mono));
559 bmm = new QBitmap(QBitmap::fromData(QSize(16, 16), cursorMaskData,
560 QImage::Format_Mono));
561 initCursorFromBitmap();
562 }
563
564#if 0
565 if(type == QCursorData::TYPE_CursPtr && curs.cp.hcurs && curs.cp.my_cursor) {
566 curs.cp.hcurs->hotSpot.h = hx >= 0 ? hx : 8;
567 curs.cp.hcurs->hotSpot.v = hy >= 0 ? hy : 8;
568 }
569#endif
570}
571
572QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.