QWSCursor Class Reference

#include <qwscursor_qws.h>

Public Functions
QPoint	hotSpot () const
QImage &	image ()
	QWSCursor ()
	QWSCursor (const uchar *data, const uchar *mask, int width, int height, int hotX, int hotY)
void	set (const uchar *data, const uchar *mask, int width, int height, int hotX, int hotY)

Static Public Functions
static QWSCursor *	systemCursor (int id)

Private Functions
void	createDropShadow (int dropx, int dropy)

Static Private Functions
static void	createSystemCursor (int id)

Properties
QImage	cursor
QPoint	hot

Detailed Description

Definition at line 54 of file qwscursor_qws.h.

Constructors and Destructors

QWSCursor() [1/2]

QWSCursor::QWSCursor ( )

inline

Definition at line 57 of file qwscursor_qws.h.

{}

QWSCursor() [2/2]

QWSCursor::QWSCursor ( const uchar *  data, const uchar *  mask, int  width, int  height, int  hotX, int  hotY  )

inline

Definition at line 58 of file qwscursor_qws.h.

        { set(data, mask, width, height, hotX, hotY); }

Functions

createDropShadow()

void QWSCursor::createDropShadow ( int  dropx, int  dropy  )

private

Definition at line 587 of file qwscursor_qws.cpp.

{
    //####
#if 1 || defined(QT_NO_QWS_CURSOR) || defined(QT_NO_QWS_ALHPA_CURSOR)
    Q_UNUSED(dropx);
    Q_UNUSED(dropy);
#else
    if (cursor.width() + dropx > 64 || cursor.height() + dropy > 64)
        return;

    if (!cursor.hasAlphaBuffer()) {
        cursor.setAlphaBuffer(true);

        const int nblur=4;
        const int darkness=140;

        QImage drop(cursor.width()+dropx+nblur, cursor.height()+dropy+nblur, 8, 18);
        drop.setColor(0, 0xff000000); // bg (black)
        drop.setColor(1, 0xffffffff); // fg (white)
        for (int i=0; i<16; i++) {
            drop.setColor(2+i, (darkness*i/16)<<24);
        }
        drop.fill(2); // all trans
        QImage drop2 = drop.copy();

        int cp;

        // made solid shadow
        for (int row = 0; row < cursor.height(); row++) {
            for (int col = 0; col < cursor.width(); col++) {
                cp = cursor.pixelIndex(col, row);
                if (cp != 2)
                    drop.setPixel(col+dropx, row+dropy, 17);
            }
        }

        // blur shadow
        for (int blur=0; blur<nblur; blur++) {
            QImage& to((blur&1)?drop:drop2);
            QImage& from((blur&1)?drop2:drop);
            for (int row = 1; row < drop.height()-1; row++) {
                for (int col = 1; col < drop.width()-1; col++) {
                    int t=0;
                    for (int dx=-1; dx<=1; dx++) {
                        for (int dy=-1; dy<=1; dy++) {
                            t += from.pixelIndex(col+dx,row+dy)-2;
                        }
                    }
                    to.setPixel(col,row,2+t/9);
                }
            }
        }

        // copy cursor
        for (int row = 0; row < cursor.height(); row++) {
            for (int col = 0; col < cursor.width(); col++) {
                cp = cursor.pixelIndex(col, row);
                if (cp != 2)
                    drop.setPixel(col, row, cp);
            }
        }

        cursor = drop;
    }
#endif
}

createSystemCursor()

void QWSCursor::createSystemCursor ( int  id )

staticprivate

Definition at line 384 of file qwscursor_qws.cpp.

{
#ifdef QT_NO_QWS_CURSOR
    Q_UNUSED(id);
#else
    if (!systemCursorTableInit) {
        for (int i = 0; i <= Qt::LastCursor; i++)
            systemCursorTable[i] = 0;
        qAddPostRoutine(cleanupSystemCursorTable);
        systemCursorTableInit = true;
    }
    switch (id) {
        // 16x16 cursors
        case Qt::ArrowCursor:
            systemCursorTable[Qt::ArrowCursor] =
                new QWSCursor(cur_arrow_bits, mcur_arrow_bits, 16, 16, 0, 0);
            break;

        case Qt::UpArrowCursor:
            systemCursorTable[Qt::UpArrowCursor] =
                new QWSCursor(cur_up_arrow_bits, mcur_up_arrow_bits, 16, 16, 7, 0);
            break;

        case Qt::CrossCursor:
            systemCursorTable[Qt::CrossCursor] =
                new QWSCursor(cur_cross_bits, mcur_cross_bits, 16, 16, 7, 7);
            break;

        case Qt::IBeamCursor:
            systemCursorTable[Qt::IBeamCursor] =
                new QWSCursor(cur_ibeam_bits, mcur_ibeam_bits, 16, 16, 7, 7);
            break;

        case Qt::SizeVerCursor:
            systemCursorTable[Qt::SizeVerCursor] =
                new QWSCursor(cur_ver_bits, mcur_ver_bits, 16, 16, 7, 7);
            break;

        case Qt::SizeHorCursor:
            systemCursorTable[Qt::SizeHorCursor] =
                new QWSCursor(cur_hor_bits, mcur_hor_bits, 16, 16, 7, 7);
            break;

        case Qt::SizeBDiagCursor:
            systemCursorTable[Qt::SizeBDiagCursor] =
                new QWSCursor(cur_bdiag_bits, mcur_bdiag_bits, 16, 16, 7, 7);
            break;

        case Qt::SizeFDiagCursor:
            systemCursorTable[Qt::SizeFDiagCursor] =
                new QWSCursor(cur_fdiag_bits, mcur_fdiag_bits, 16, 16, 7, 7);
            break;

        case Qt::BlankCursor:
            systemCursorTable[Qt::BlankCursor] =
                new QWSCursor(0, 0, 0, 0, 0, 0);
            break;

        // 20x20 cursors
        case Qt::ForbiddenCursor:
            systemCursorTable[Qt::ForbiddenCursor] =
                new QWSCursor(forbidden_bits, forbiddenm_bits, 20, 20, 10, 10);
            break;

        // 32x32 cursors
        case Qt::WaitCursor:
            systemCursorTable[Qt::WaitCursor] =
                new QWSCursor(wait_data_bits, wait_mask_bits, 32, 32, 15, 15);
            break;

        case Qt::SplitVCursor:
            systemCursorTable[Qt::SplitVCursor] =
                new QWSCursor(vsplit_bits, vsplitm_bits, 32, 32, 15, 15);
            break;

        case Qt::SplitHCursor:
            systemCursorTable[Qt::SplitHCursor] =
                new QWSCursor(hsplit_bits, hsplitm_bits, 32, 32, 15, 15);
            break;

        case Qt::SizeAllCursor:
            systemCursorTable[Qt::SizeAllCursor] =
                new QWSCursor(size_all_data_bits, size_all_mask_bits, 32, 32, 15, 15);
            break;

        case Qt::PointingHandCursor:
            systemCursorTable[Qt::PointingHandCursor] =
                new QWSCursor(phand_bits, phandm_bits, 32, 32, 0, 0);
            break;

        case Qt::WhatsThisCursor:
            systemCursorTable[Qt::WhatsThisCursor] =
                new QWSCursor(whatsthis_bits, whatsthism_bits, 32, 32, 0, 0);
            break;
        case Qt::BusyCursor:
            systemCursorTable[Qt::BusyCursor] =
                new QWSCursor(busy_bits, busym_bits, 32, 32, 0, 0);
            break;

        case Qt::OpenHandCursor:
            systemCursorTable[Qt::OpenHandCursor] =
                new QWSCursor(openhand_bits, openhandm_bits, 16, 16, 8, 8);
            break;
        case Qt::ClosedHandCursor:
            systemCursorTable[Qt::ClosedHandCursor] =
                new QWSCursor(closedhand_bits, closedhandm_bits, 16, 16, 8, 8);
            break;
        default:
            qWarning("Unknown system cursor %d", id);
    }
#endif
}

hotSpot()

QPoint QWSCursor::hotSpot ( ) const

inline

Definition at line 65 of file qwscursor_qws.h.

Referenced by QWSServerPrivate::setCursor().

{ return hot; }

image()

QImage& QWSCursor::image ( )

inline

Definition at line 66 of file qwscursor_qws.h.

Referenced by QWSServerPrivate::setCursor().

{ return cursor; }

set()

void QWSCursor::set	(	const uchar *	data,
		const uchar *	mask,
		int	width,
		int	height,
		int	hotX,
		int	hotY
	)

Definition at line 518 of file qwscursor_qws.cpp.

{
#ifdef QT_NO_QWS_CURSOR
    Q_UNUSED(data);
    Q_UNUSED(mask);
    Q_UNUSED(width);
    Q_UNUSED(height);
    Q_UNUSED(hx);
    Q_UNUSED(hy);
#else
    hot.setX(hx);
    hot.setY(hy);

    cursor = QImage(width,height, QImage::Format_Indexed8);

    if (!width || !height || !data || !mask || cursor.isNull())
        return;

    cursor.setColorCount(3);
    cursor.setColor(0, 0xff000000);
    cursor.setColor(1, 0xffffffff);
    cursor.setColor(2, 0x00000000);

    int bytesPerLine = (width + 7) / 8;
    int p = 0;
    int d, m;

    int x = -1, w = 0;

    uchar *cursor_data = cursor.bits();
    int bpl = cursor.bytesPerLine();
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < bytesPerLine; j++, data++, mask++)
        {
            for (int b = 0; b < 8 && j*8+b < width; b++)
            {
                d = *data & (1 << b);
                m = *mask & (1 << b);
                if (d && m) p = 0;
                else if (!d && m) p = 1;
                else p = 2;
                cursor_data[j*8+b] = p;

                // calc region
                if (x < 0 && m)
                    x = j*8+b;
                else if (x >= 0 && !m) {
                    x = -1;
                    w = 0;
                }
                if (m)
                    w++;
            }
        }
        if (x >= 0) {
            x = -1;
            w = 0;
        }
        cursor_data += bpl;
    }

    if (qt_screencursor && qt_screencursor->supportsAlphaCursor())
        createDropShadow(5, 2);
#endif
}

systemCursor()

QWSCursor * QWSCursor::systemCursor ( int  id )

static

Definition at line 497 of file qwscursor_qws.cpp.

Referenced by QWSServerPrivate::initializeCursor(), QWSServerPrivate::invokeSelectCursor(), QWSServerPrivate::sendMouseEventUnfiltered(), QWSServerPrivate::setCursor(), and QWSServer::setCursorVisible().

{
    QWSCursor *cursor = 0;
#ifdef QT_NO_QWS_CURSOR
    Q_UNUSED(id);
#else
    if (id >= 0 && id <= Qt::LastCursor) {
        if (!systemCursorTable[id])
            createSystemCursor(id);
        cursor = systemCursorTable[id];
    }

    if (cursor == 0) {
        if (!systemCursorTable[Qt::ArrowCursor])
            createSystemCursor(Qt::ArrowCursor);
        cursor = systemCursorTable[Qt::ArrowCursor];
    }
#endif
    return cursor;
}

Properties

cursor

QImage QWSCursor::cursor

private

Definition at line 76 of file qwscursor_qws.h.

hot

QPoint QWSCursor::hot

private

Definition at line 75 of file qwscursor_qws.h.

---

The documentation for this class was generated from the following files:

• /src/gui/embedded/qwscursor_qws.h
• /src/gui/embedded/qwscursor_qws.cpp