Qt 4.8
Public Functions | Static Public Functions | Public Variables | Static Public Variables | List of all members
QCursorData Class Reference

#include <qcursor_p.h>

Public Functions

 QCursorData (Qt::CursorShape s=Qt::ArrowCursor)
 
void update ()
 Creates the cursor. More...
 
 ~QCursorData ()
 

Static Public Functions

static void cleanup ()
 
static void initialize ()
 
static QCursorData * setBitmap (const QBitmap &bitmap, const QBitmap &mask, int hotX, int hotY)
 

Public Variables

QBitmap * bm
 
QBitmap * bmm
 
Qt::CursorShape cshape
 
HCURSOR hcurs
 
short hx
 
short hy
 
int mId
 
QPixmap pixmap
 
QAtomicInt ref
 

Static Public Variables

static bool initialized = false
 

Detailed Description

Definition at line 79 of file qcursor_p.h.

Constructors and Destructors

◆ QCursorData()

QCursorData::QCursorData ( Qt::CursorShape  s = Qt::ArrowCursor)

Definition at line 253 of file qcursor_mac.mm.

Referenced by QCursor::QCursor(), and setBitmap().

254  : cshape(s), bm(0), bmm(0), hx(-1), hy(-1), mId(s), type(TYPE_None)
255 {
256  ref = 1;
257  memset(&curs, '\0', sizeof(curs));
258 }
type
int type
Definition: qmetatype.cpp:239
QCursorData::hy
short hy
Definition: qcursor_p.h:91
QCursorData::cshape
Qt::CursorShape cshape
Definition: qcursor_p.h:88
QCursorData::hx
short hx
Definition: qcursor_p.h:91
QCursorData::bmm
QBitmap * bmm
Definition: qcursor_p.h:89
QCursorData::ref
QAtomicInt ref
Definition: qcursor_p.h:87
QCursorData::bm
QBitmap * bm
Definition: qcursor_p.h:89

◆ ~QCursorData()

QCursorData::~QCursorData ( )

Definition at line 260 of file qcursor_mac.mm.

261 {
262  if (type == TYPE_ImageCursor) {
263  if (curs.cp.my_cursor) {
264  QMacCocoaAutoReleasePool pool;
265  [static_cast<NSCursor *>(curs.cp.nscursor) release];
266  }
267  } else if(type == TYPE_ThemeCursor) {
268  delete curs.tc.anim;
269  }
270  type = TYPE_None;
271 
272  delete bm;
273  delete bmm;
274  if(currentCursor == this)
275  currentCursor = 0;
276 }
type
int type
Definition: qmetatype.cpp:239
currentCursor
static QCursorData * currentCursor
Definition: qcursor_mac.mm:106
QCursorData::bmm
QBitmap * bmm
Definition: qcursor_p.h:89
QCursorData::bm
QBitmap * bm
Definition: qcursor_p.h:89

Functions

◆ cleanup()

void QCursorData::cleanup ( )
static
Warning
This function is not part of the public interface.

Definition at line 402 of file qcursor.cpp.

Referenced by qt_cleanup().

403 {
404  if(!QCursorData::initialized)
405  return;
406 
407  for (int shape = 0; shape <= Qt::LastCursor; ++shape) {
408  // In case someone has a static QCursor defined with this shape
409  if (!qt_cursorTable[shape]->ref.deref())
410  delete qt_cursorTable[shape];
411  qt_cursorTable[shape] = 0;
412  }
413  QCursorData::initialized = false;
414 }
QCursorData::initialized
static bool initialized
Definition: qcursor_p.h:125
QAtomicInt::deref
bool deref()
Atomically decrements the value of this QAtomicInt.
qt_cursorTable
QCursorData * qt_cursorTable[Qt::LastCursor+1]
Definition: qcursor.cpp:398
QCursorData::ref
QAtomicInt ref
Definition: qcursor_p.h:87

◆ initialize()

void QCursorData::initialize ( )
static
Warning
This function is not part of the public interface.

Definition at line 417 of file qcursor.cpp.

Referenced by QCursor::bitmap(), create32BitCursor(), QCursor::handle(), QCursor::hotSpot(), init_display(), QCursor::mask(), QCursor::operator=(), QCursor::pixmap(), QCursor::QCursor(), qt_init(), setBitmap(), QCursor::setShape(), QCursor::shape(), update(), and QX11Data::xdndSetup().

418 {
419  if (QCursorData::initialized)
420  return;
421 #ifdef Q_WS_MAC
422  // DRSWAT - Not Needed Cocoa or Carbon
423  //InitCursor();
424 #endif
425  for (int shape = 0; shape <= Qt::LastCursor; ++shape)
426  qt_cursorTable[shape] = new QCursorData((Qt::CursorShape)shape);
427  QCursorData::initialized = true;
428 }
QCursorData::initialized
static bool initialized
Definition: qcursor_p.h:125
QCursorData::QCursorData
QCursorData(Qt::CursorShape s=Qt::ArrowCursor)
Definition: qcursor_mac.mm:253
qt_cursorTable
QCursorData * qt_cursorTable[Qt::LastCursor+1]
Definition: qcursor.cpp:398
Qt::CursorShape
CursorShape
Definition: qnamespace.h:1262

◆ setBitmap()

QCursorData * QCursorData::setBitmap ( const QBitmap &  bitmap,
const QBitmap &  mask,
int  hotX,
int  hotY 
)
static

Definition at line 278 of file qcursor_mac.mm.

Referenced by QCursor::QCursor().

279 {
280  if (!QCursorData::initialized)
281  QCursorData::initialize();
282  if (bitmap.depth() != 1 || mask.depth() != 1 || bitmap.size() != mask.size()) {
283  qWarning("Qt: QCursor: Cannot create bitmap cursor; invalid bitmap(s)");
284  QCursorData *c = qt_cursorTable[0];
285  c->ref.ref();
286  return c;
287  }
288  // This is silly, but this is apparently called outside the constructor, so we have
289  // to be ready for that case.
290  QCursorData *x = new QCursorData;
291  x->ref = 1;
292  x->mId = ++nextCursorId;
293  x->bm = new QBitmap(bitmap);
294  x->bmm = new QBitmap(mask);
295  x->cshape = Qt::BitmapCursor;
296  x->hx = hotX >= 0 ? hotX : bitmap.width() / 2;
297  x->hy = hotY >= 0 ? hotY : bitmap.height() / 2;
298  return x;
299 }
c
unsigned char c[8]
Definition: qnumeric_p.h:62
QPixmap::width
int width() const
Returns the width of the pixmap.
Definition: qpixmap.cpp:630
QPixmap::size
QSize size() const
Returns the size of the pixmap.
Definition: qpixmap.cpp:661
QCursorData::hy
short hy
Definition: qcursor_p.h:91
QAtomicInt::ref
bool ref()
Atomically increments the value of this QAtomicInt.
QCursorData::initialized
static bool initialized
Definition: qcursor_p.h:125
QPixmap::depth
int depth() const
Returns the depth of the pixmap.
Definition: qpixmap.cpp:695
QBitmap
The QBitmap class provides monochrome (1-bit depth) pixmaps.
Definition: qbitmap.h:55
QCursorData::QCursorData
QCursorData(Qt::CursorShape s=Qt::ArrowCursor)
Definition: qcursor_mac.mm:253
qWarning
Q_CORE_EXPORT void qWarning(const char *,...)
QCursorData::cshape
Qt::CursorShape cshape
Definition: qcursor_p.h:88
nextCursorId
static int nextCursorId
Definition: qcursor_mac.mm:251
QCursorData::hx
short hx
Definition: qcursor_p.h:91
QCursorData::bmm
QBitmap * bmm
Definition: qcursor_p.h:89
QPixmap::height
int height() const
Returns the height of the pixmap.
Definition: qpixmap.cpp:645
QCursorData::initialize
static void initialize()
Definition: qcursor.cpp:417
QCursorData::ref
QAtomicInt ref
Definition: qcursor_p.h:87
QCursorData::bm
QBitmap * bm
Definition: qcursor_p.h:89
qt_cursorTable
QCursorData * qt_cursorTable[Qt::LastCursor+1]
Definition: qcursor.cpp:398

◆ update()

void QCursorData::update ( )

Creates the cursor.

Warning
This function is not part of the public interface.

Definition at line 387 of file qcursor_mac.mm.

Referenced by create32BitCursor(), QCursor::QCursor(), qt_mac_nsCursorForQCursor(), and qt_mac_updateCursorWithWidgetUnderMouse().

388 {
389  if(!QCursorData::initialized)
390  QCursorData::initialize();
391  if(type != QCursorData::TYPE_None)
392  return;
393 
394  /* Note to self... ***
395  * mask x data
396  * 0xFF x 0x00 == fully opaque white
397  * 0x00 x 0xFF == xor'd black
398  * 0xFF x 0xFF == fully opaque black
399  * 0x00 x 0x00 == fully transparent
400  */
401 
402  if (hx < 0)
403  hx = 0;
404  if (hy < 0)
405  hy = 0;
406 
407 #define QT_USE_APPROXIMATE_CURSORS
408 #ifdef QT_USE_APPROXIMATE_CURSORS
409  static const uchar cur_ver_bits[] = {
410  0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0,
411  0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x0f, 0xf0,
412  0x07, 0xe0, 0x03, 0xc0, 0x01, 0x80, 0x00, 0x00 };
413  static const uchar mcur_ver_bits[] = {
414  0x00, 0x00, 0x03, 0x80, 0x07, 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x3f, 0xf8,
415  0x7f, 0xfc, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x7f, 0xfc, 0x3f, 0xf8,
416  0x1f, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80 };
417 
418  static const uchar cur_hor_bits[] = {
419  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0x18, 0x30,
420  0x38, 0x38, 0x7f, 0xfc, 0x7f, 0xfc, 0x38, 0x38, 0x18, 0x30, 0x08, 0x20,
421  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
422  static const uchar mcur_hor_bits[] = {
423  0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x0c, 0x60, 0x1c, 0x70, 0x3c, 0x78,
424  0x7f, 0xfc, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0x7f, 0xfc, 0x3c, 0x78,
425  0x1c, 0x70, 0x0c, 0x60, 0x04, 0x40, 0x00, 0x00 };
426 
427  static const uchar cur_fdiag_bits[] = {
428  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8, 0x00, 0xf8, 0x00, 0x78,
429  0x00, 0xf8, 0x01, 0xd8, 0x23, 0x88, 0x37, 0x00, 0x3e, 0x00, 0x3c, 0x00,
430  0x3e, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00 };
431  static const uchar mcur_fdiag_bits[] = {
432  0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x03, 0xfc, 0x01, 0xfc, 0x00, 0xfc,
433  0x41, 0xfc, 0x63, 0xfc, 0x77, 0xdc, 0x7f, 0x8c, 0x7f, 0x04, 0x7e, 0x00,
434  0x7f, 0x00, 0x7f, 0x80, 0x7f, 0xc0, 0x00, 0x00 };
435 
436  static const uchar cur_bdiag_bits[] = {
437  0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x3c, 0x00, 0x3e, 0x00,
438  0x37, 0x00, 0x23, 0x88, 0x01, 0xd8, 0x00, 0xf8, 0x00, 0x78, 0x00, 0xf8,
439  0x01, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
440  static const uchar mcur_bdiag_bits[] = {
441  0x00, 0x00, 0x7f, 0xc0, 0x7f, 0x80, 0x7f, 0x00, 0x7e, 0x00, 0x7f, 0x04,
442  0x7f, 0x8c, 0x77, 0xdc, 0x63, 0xfc, 0x41, 0xfc, 0x00, 0xfc, 0x01, 0xfc,
443  0x03, 0xfc, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00 };
444 
445  static const unsigned char cur_up_arrow_bits[] = {
446  0x00, 0x80, 0x01, 0x40, 0x01, 0x40, 0x02, 0x20, 0x02, 0x20, 0x04, 0x10,
447  0x04, 0x10, 0x08, 0x08, 0x0f, 0x78, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40,
448  0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0xc0 };
449  static const unsigned char mcur_up_arrow_bits[] = {
450  0x00, 0x80, 0x01, 0xc0, 0x01, 0xc0, 0x03, 0xe0, 0x03, 0xe0, 0x07, 0xf0,
451  0x07, 0xf0, 0x0f, 0xf8, 0x0f, 0xf8, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
452  0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0 };
453 #endif
454  const uchar *cursorData = 0;
455  const uchar *cursorMaskData = 0;
456 #ifdef QT_MAC_USE_COCOA
457  switch (cshape) { // map Q cursor to MAC cursor
458  case Qt::BitmapCursor: {
459  if (pixmap.isNull())
460  initCursorFromBitmap();
461  else
462  initCursorFromPixmap();
463  break; }
464  case Qt::BlankCursor: {
465  pixmap = QPixmap(16, 16);
466  pixmap.fill(Qt::transparent);
467  initCursorFromPixmap();
468  break; }
469  case Qt::ArrowCursor: {
470  type = QCursorData::TYPE_ThemeCursor;
471  curs.cp.nscursor = [NSCursor arrowCursor];
472  break; }
473  case Qt::CrossCursor: {
474  type = QCursorData::TYPE_ThemeCursor;
475  curs.cp.nscursor = [NSCursor crosshairCursor];
476  break; }
477  case Qt::WaitCursor: {
478  pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/spincursor.png"));
479  initCursorFromPixmap();
480  break; }
481  case Qt::IBeamCursor: {
482  type = QCursorData::TYPE_ThemeCursor;
483  curs.cp.nscursor = [NSCursor IBeamCursor];
484  break; }
485  case Qt::SizeAllCursor: {
486  pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/pluscursor.png"));
487  initCursorFromPixmap();
488  break; }
489  case Qt::WhatsThisCursor: { //for now just use the pointing hand
490  case Qt::PointingHandCursor:
491  type = QCursorData::TYPE_ThemeCursor;
492  curs.cp.nscursor = [NSCursor pointingHandCursor];
493  break; }
494  case Qt::BusyCursor: {
495  pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/waitcursor.png"));
496  initCursorFromPixmap();
497  break; }
498  case Qt::SplitVCursor: {
499  type = QCursorData::TYPE_ThemeCursor;
500  curs.cp.nscursor = [NSCursor resizeUpDownCursor];
501  break; }
502  case Qt::SplitHCursor: {
503  type = QCursorData::TYPE_ThemeCursor;
504  curs.cp.nscursor = [NSCursor resizeLeftRightCursor];
505  break; }
506  case Qt::ForbiddenCursor: {
507  pixmap = QPixmap(QLatin1String(":/trolltech/mac/cursors/images/forbiddencursor.png"));
508  initCursorFromPixmap();
509  break; }
510  case Qt::OpenHandCursor:
511  type = QCursorData::TYPE_ThemeCursor;
512  curs.cp.nscursor = [NSCursor openHandCursor];
513  break;
514  case Qt::ClosedHandCursor:
515  type = QCursorData::TYPE_ThemeCursor;
516  curs.cp.nscursor = [NSCursor closedHandCursor];
517  break;
518  case Qt::DragCopyCursor:
519  type = QCursorData::TYPE_ThemeCursor;
520  if ([NSCursor respondsToSelector:@selector(dragCopyCursor)])
521  curs.cp.nscursor = [NSCursor performSelector:@selector(dragCopyCursor)];
522  break;
523  case Qt::DragMoveCursor:
524  type = QCursorData::TYPE_ThemeCursor;
525  curs.cp.nscursor = [NSCursor arrowCursor];
526  break;
527  case Qt::DragLinkCursor:
528  type = QCursorData::TYPE_ThemeCursor;
529  if ([NSCursor respondsToSelector:@selector(dragLinkCursor)])
530  curs.cp.nscursor = [NSCursor performSelector:@selector(dragLinkCursor)];
531  break;
532 #define QT_USE_APPROXIMATE_CURSORS
533 #ifdef QT_USE_APPROXIMATE_CURSORS
534  case Qt::SizeVerCursor:
535  cursorData = cur_ver_bits;
536  cursorMaskData = mcur_ver_bits;
537  hx = hy = 8;
538  break;
539  case Qt::SizeHorCursor:
540  cursorData = cur_hor_bits;
541  cursorMaskData = mcur_hor_bits;
542  hx = hy = 8;
543  break;
544  case Qt::SizeBDiagCursor:
545  cursorData = cur_fdiag_bits;
546  cursorMaskData = mcur_fdiag_bits;
547  hx = hy = 8;
548  break;
549  case Qt::SizeFDiagCursor:
550  cursorData = cur_bdiag_bits;
551  cursorMaskData = mcur_bdiag_bits;
552  hx = hy = 8;
553  break;
554  case Qt::UpArrowCursor:
555  cursorData = cur_up_arrow_bits;
556  cursorMaskData = mcur_up_arrow_bits;
557  hx = 8;
558  break;
559 #endif
560  default:
561  qWarning("Qt: QCursor::update: Invalid cursor shape %d", cshape);
562  return;
563  }
564 #else
565  // Carbon
566  switch (cshape) { // map Q cursor to MAC cursor
567  case Qt::BitmapCursor: {
568  if (pixmap.isNull())
569  initCursorFromBitmap();
570  else
571  initCursorFromPixmap();
572  break; }
573  case Qt::BlankCursor: {
574  pixmap = QPixmap(16, 16);
575  pixmap.fill(Qt::transparent);
576  initCursorFromPixmap();
577  break; }
578  case Qt::ArrowCursor: {
579  type = QCursorData::TYPE_ThemeCursor;
580  curs.tc.curs = kThemeArrowCursor;
581  break; }
582  case Qt::CrossCursor: {
583  type = QCursorData::TYPE_ThemeCursor;
584  curs.tc.curs = kThemeCrossCursor;
585  break; }
586  case Qt::WaitCursor: {
587  type = QCursorData::TYPE_ThemeCursor;
588  curs.tc.curs = kThemeWatchCursor;
589  break; }
590  case Qt::IBeamCursor: {
591  type = QCursorData::TYPE_ThemeCursor;
592  curs.tc.curs = kThemeIBeamCursor;
593  break; }
594  case Qt::SizeAllCursor: {
595  type = QCursorData::TYPE_ThemeCursor;
596  curs.tc.curs = kThemePlusCursor;
597  break; }
598  case Qt::WhatsThisCursor: { //for now just use the pointing hand
599  case Qt::PointingHandCursor:
600  type = QCursorData::TYPE_ThemeCursor;
601  curs.tc.curs = kThemePointingHandCursor;
602  break; }
603  case Qt::BusyCursor: {
604  type = QCursorData::TYPE_ThemeCursor;
605  curs.tc.curs = kThemeSpinningCursor;
606  break; }
607  case Qt::SplitVCursor: {
608  type = QCursorData::TYPE_ThemeCursor;
609  curs.tc.curs = kThemeResizeUpDownCursor;
610  break; }
611  case Qt::SplitHCursor: {
612  type = QCursorData::TYPE_ThemeCursor;
613  curs.tc.curs = kThemeResizeLeftRightCursor;
614  break; }
615  case Qt::ForbiddenCursor: {
616  type = QCursorData::TYPE_ThemeCursor;
617  curs.tc.curs = kThemeNotAllowedCursor;
618  break; }
619  case Qt::OpenHandCursor:
620  type = QCursorData::TYPE_ThemeCursor;
621  curs.tc.curs = kThemeOpenHandCursor;
622  break;
623  case Qt::ClosedHandCursor:
624  type = QCursorData::TYPE_ThemeCursor;
625  curs.tc.curs = kThemeClosedHandCursor;
626  break;
627  case Qt::DragMoveCursor:
628  type = QCursorData::TYPE_ThemeCursor;
629  curs.tc.curs = kThemeArrowCursor;
630  break;
631  case Qt::DragCopyCursor:
632  type = QCursorData::TYPE_ThemeCursor;
633  curs.tc.curs = kThemeCopyArrowCursor;
634  break;
635  case Qt::DragLinkCursor:
636  type = QCursorData::TYPE_ThemeCursor;
637  curs.tc.curs = kThemeAliasArrowCursor;
638  break;
639 #define QT_USE_APPROXIMATE_CURSORS
640 #ifdef QT_USE_APPROXIMATE_CURSORS
641  case Qt::SizeVerCursor:
642  cursorData = cur_ver_bits;
643  cursorMaskData = mcur_ver_bits;
644  hx = hy = 8;
645  break;
646  case Qt::SizeHorCursor:
647  cursorData = cur_hor_bits;
648  cursorMaskData = mcur_hor_bits;
649  hx = hy = 8;
650  break;
651  case Qt::SizeBDiagCursor:
652  cursorData = cur_fdiag_bits;
653  cursorMaskData = mcur_fdiag_bits;
654  hx = hy = 8;
655  break;
656  case Qt::SizeFDiagCursor:
657  cursorData = cur_bdiag_bits;
658  cursorMaskData = mcur_bdiag_bits;
659  hx = hy = 8;
660  break;
661  case Qt::UpArrowCursor:
662  cursorData = cur_up_arrow_bits;
663  cursorMaskData = mcur_up_arrow_bits;
664  hx = 8;
665  break;
666 #endif
667  default:
668  qWarning("Qt: QCursor::update: Invalid cursor shape %d", cshape);
669  return;
670  }
671 #endif
672 
673  if (cursorData) {
674  bm = new QBitmap(QBitmap::fromData(QSize(16, 16), cursorData,
675  QImage::Format_Mono));
676  bmm = new QBitmap(QBitmap::fromData(QSize(16, 16), cursorMaskData,
677  QImage::Format_Mono));
678  initCursorFromBitmap();
679  }
680 
681 #if 0
682  if(type == QCursorData::TYPE_CursPtr && curs.cp.hcurs && curs.cp.my_cursor) {
683  curs.cp.hcurs->hotSpot.h = hx >= 0 ? hx : 8;
684  curs.cp.hcurs->hotSpot.v = hy >= 0 ? hy : 8;
685  }
686 #endif
687 }
type
int type
Definition: qmetatype.cpp:239
QCursorData::hy
short hy
Definition: qcursor_p.h:91
QCursorData::pixmap
QPixmap pixmap
Definition: qcursor_p.h:90
cur_bdiag_bits
static const uchar cur_bdiag_bits[]
Definition: qwscursor_qws.cpp:110
QBitmap::fromData
static QBitmap fromData(const QSize &size, const uchar *bits, QImage::Format monoFormat=QImage::Format_MonoLSB)
Constructs a bitmap with the given size, and sets the contents to the bits supplied.
Definition: qbitmap.cpp:318
cur_hor_bits
static const uchar cur_hor_bits[]
Definition: qwscursor_qws.cpp:102
QLatin1String
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
mcur_ver_bits
static const uchar mcur_ver_bits[]
Definition: qwscursor_qws.cpp:97
QCursorData::initialized
static bool initialized
Definition: qcursor_p.h:125
mcur_hor_bits
static const uchar mcur_hor_bits[]
Definition: qwscursor_qws.cpp:106
uchar
unsigned char uchar
Definition: qglobal.h:994
QBitmap
The QBitmap class provides monochrome (1-bit depth) pixmaps.
Definition: qbitmap.h:55
qWarning
Q_CORE_EXPORT void qWarning(const char *,...)
cur_up_arrow_bits
static const unsigned char cur_up_arrow_bits[]
Definition: qwscursor_qws.cpp:66
QPixmap::fill
void fill(const QColor &fillColor=Qt::white)
Fills the pixmap with the given color.
Definition: qpixmap.cpp:1080
QCursorData::cshape
Qt::CursorShape cshape
Definition: qcursor_p.h:88
QCursorData::hx
short hx
Definition: qcursor_p.h:91
QPixmap
The QPixmap class is an off-screen image representation that can be used as a paint device...
Definition: qpixmap.h:71
QCursorData::bmm
QBitmap * bmm
Definition: qcursor_p.h:89
QCursorData::initialize
static void initialize()
Definition: qcursor.cpp:417
mcur_up_arrow_bits
static const unsigned char mcur_up_arrow_bits[]
Definition: qwscursor_qws.cpp:70
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
mcur_bdiag_bits
static const uchar mcur_bdiag_bits[]
Definition: qwscursor_qws.cpp:114
QPixmap::isNull
bool isNull() const
Returns true if this is a null pixmap; otherwise returns false.
Definition: qpixmap.cpp:615
QCursorData::bm
QBitmap * bm
Definition: qcursor_p.h:89
cur_ver_bits
static const uchar cur_ver_bits[]
Definition: qwscursor_qws.cpp:93
mcur_fdiag_bits
static const uchar mcur_fdiag_bits[]
Definition: qwscursor_qws.cpp:122
cur_fdiag_bits
static const uchar cur_fdiag_bits[]
Definition: qwscursor_qws.cpp:118

Properties

◆ bm

QBitmap* QCursorData::bm

Definition at line 89 of file qcursor_p.h.

Referenced by QCursor::bitmap(), create32BitCursor(), QCursor::QCursor(), setBitmap(), QCursor::setPos(), update(), and ~QCursorData().

◆ bmm

QBitmap * QCursorData::bmm

Definition at line 89 of file qcursor_p.h.

Referenced by create32BitCursor(), QCursor::mask(), QCursor::QCursor(), setBitmap(), QCursor::setPos(), update(), and ~QCursorData().

◆ cshape

Qt::CursorShape QCursorData::cshape

Definition at line 88 of file qcursor_p.h.

Referenced by create32BitCursor(), QCursor::QCursor(), setBitmap(), QCursor::shape(), and update().

◆ hcurs

HCURSOR QCursorData::hcurs

Definition at line 98 of file qcursor_p.h.

Referenced by create32BitCursor(), and QCursor::QCursor().

◆ hx

short QCursorData::hx

Definition at line 91 of file qcursor_p.h.

Referenced by create32BitCursor(), QCursor::hotSpot(), QCursor::QCursor(), setBitmap(), QCursor::setPos(), and update().

◆ hy

short QCursorData::hy

Definition at line 91 of file qcursor_p.h.

Referenced by create32BitCursor(), QCursor::hotSpot(), QCursor::QCursor(), setBitmap(), QCursor::setPos(), and update().

◆ initialized

bool QCursorData::initialized = false
static

Definition at line 125 of file qcursor_p.h.

Referenced by QCursor::bitmap(), cleanup(), create32BitCursor(), QCursor::handle(), QCursor::hotSpot(), initialize(), QCursor::mask(), QCursor::operator=(), QCursor::pixmap(), QCursor::QCursor(), setBitmap(), QCursor::setShape(), QCursor::shape(), and update().

◆ mId

int QCursorData::mId

Definition at line 93 of file qcursor_p.h.

Referenced by setBitmap().

◆ pixmap

QPixmap QCursorData::pixmap

Definition at line 90 of file qcursor_p.h.

Referenced by create32BitCursor(), QCursor::pixmap(), QCursor::QCursor(), QCursor::setPos(), and update().

◆ ref

QAtomicInt QCursorData::ref

Definition at line 87 of file qcursor_p.h.

Referenced by QCursor::operator=(), QCursor::QCursor(), QCursorData(), setBitmap(), QCursor::setShape(), and QCursor::~QCursor().

The documentation for this class was generated from the following files:
Qt 4.8 Source Code Browser