| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtGui module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include <private/qcursor_p.h> |
| #include <private/qwidget_p.h> |
| #include <private/qapplication_p.h> |
| #include <coecntrl.h> |
| #include <qcursor.h> |
| #include <private/qt_s60_p.h> |
| #include <qbitmap.h> |
| #include <w32std.h> |
| #include <qapplication.h> |
| #include <qwidget.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| #ifndef QT_NO_CURSOR |
| static QCursor cursorSprite; |
| static int cursorSpriteVisible; |
| #endif |
| |
| //pos and setpos are required whether cursors are configured or not. |
| QPoint QCursor::pos() |
| { |
| return S60->lastCursorPos; |
| } |
| |
| void QCursor::setPos(int x, int y) |
| { |
| //clip to screen size (window server allows a sprite hotspot to be outside the screen) |
| if (x < 0) |
| x=0; |
| else if (x >= S60->screenWidthInPixels) |
| x = S60->screenWidthInPixels - 1; |
| if (y < 0) |
| y = 0; |
| else if (y >= S60->screenHeightInPixels) |
| y = S60->screenHeightInPixels - 1; |
| |
| #ifndef QT_NO_CURSOR |
| #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS |
| if (S60->brokenPointerCursors && cursorSpriteVisible) |
| cursorSprite.d->scurs.SetPosition(TPoint(x,y)); |
| else |
| #endif |
| S60->wsSession().SetPointerCursorPosition(TPoint(x, y)); |
| #endif |
| S60->lastCursorPos = QPoint(x, y); |
| //send a fake mouse move event, so that enter/leave events go to the widget hierarchy |
| QWidget *w = QApplication::topLevelAt(S60->lastCursorPos); |
| if (w) { |
| CCoeControl* ctrl = w->effectiveWinId(); |
| TPoint epos(x, y); |
| TPoint cpos = epos - ctrl->PositionRelativeToScreen(); |
| TPointerEvent fakeEvent; |
| fakeEvent.iType = TPointerEvent::EMove; |
| fakeEvent.iModifiers = 0U; |
| fakeEvent.iPosition = cpos; |
| fakeEvent.iParentPosition = epos; |
| ctrl->HandlePointerEventL(fakeEvent); |
| } |
| } |
| |
| #ifndef QT_NO_CURSOR |
| /* |
| * Request cursor to be turned on or off. |
| * Reference counted, so 2 on + 1 off = on, for example |
| */ |
| void qt_symbian_set_cursor_visible(bool visible) { |
| if (visible) |
| cursorSpriteVisible++; |
| else |
| cursorSpriteVisible--; |
| Q_ASSERT(cursorSpriteVisible >=0); |
| |
| if (cursorSpriteVisible && !S60->mouseInteractionEnabled) { |
| #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS |
| if (S60->brokenPointerCursors) |
| qt_symbian_show_pointer_sprite(); |
| else |
| #endif |
| S60->wsSession().SetPointerCursorMode(EPointerCursorNormal); |
| } else if (!cursorSpriteVisible && S60->mouseInteractionEnabled) { |
| #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS |
| if (S60->brokenPointerCursors) |
| qt_symbian_hide_pointer_sprite(); |
| else |
| #endif |
| S60->wsSession().SetPointerCursorMode(EPointerCursorNone); |
| } |
| S60->mouseInteractionEnabled = ((cursorSpriteVisible > 0) ? true : false); |
| } |
| |
| /* |
| * Check if the cursor is on or off |
| */ |
| bool qt_symbian_is_cursor_visible() { |
| return S60->mouseInteractionEnabled; |
| } |
| |
| QCursorData::QCursorData(Qt::CursorShape s) : |
| cshape(s), bm(0), bmm(0), hx(0), hy(0), pcurs() |
| { |
| ref = 1; |
| } |
| |
| QCursorData::~QCursorData() |
| { |
| for(int i=0;i<nativeSpriteMembers.Count();i++) { |
| delete nativeSpriteMembers[i]->iBitmap; |
| delete nativeSpriteMembers[i]->iMaskBitmap; |
| } |
| nativeSpriteMembers.ResetAndDestroy(); |
| pcurs.Close(); |
| delete bm; |
| delete bmm; |
| } |
| |
| /* Create a bitmap cursor, this is called by public constructors in the |
| * generic QCursor code. |
| */ |
| QCursorData *QCursorData::setBitmap(const QBitmap &bitmap, const QBitmap &mask, int hotX, int hotY) |
| { |
| if (!QCursorData::initialized) |
| QCursorData::initialize(); |
| if (bitmap.depth() != 1 || mask.depth() != 1 || bitmap.size() != mask.size()) { |
| qWarning("QCursor: Cannot create bitmap cursor; invalid bitmap(s)"); |
| QCursorData *c = qt_cursorTable[0]; |
| c->ref.ref(); |
| return c; |
| } |
| QCursorData *d = new QCursorData; |
| d->bm = new QBitmap(bitmap); |
| d->bmm = new QBitmap(mask); |
| d->cshape = Qt::BitmapCursor; |
| d->hx = hotX >= 0 ? hotX : bitmap.width() / 2; |
| d->hy = hotY >= 0 ? hotY : bitmap.height() / 2; |
| return d; |
| } |
| |
| /* |
| * returns an opaque native handle to a cursor. |
| * It happens to be the address of the native handle, as window server handles |
| * are not POD types. Note there is no QCursor(HANDLE) constructor on Symbian, |
| * Mac or QWS. |
| */ |
| Qt::HANDLE QCursor::handle() const |
| { |
| if (d->pcurs.WsHandle()) |
| return reinterpret_cast<Qt::HANDLE> (&(d->pcurs)); |
| |
| #ifdef Q_SYMBIAN_HAS_SYSTEM_CURSORS |
| // don't construct shape cursors, QApplication_s60 will use the system cursor instead |
| if (!(d->bm)) |
| return 0; |
| #endif |
| |
| d->pcurs = RWsPointerCursor(S60->wsSession()); |
| d->pcurs.Construct(0); |
| d->constructCursorSprite(d->pcurs); |
| d->pcurs.Activate(); |
| |
| return reinterpret_cast<Qt::HANDLE> (&(d->pcurs)); |
| } |
| |
| #ifndef Q_SYMBIAN_HAS_SYSTEM_CURSORS |
| /* |
| * Loads a single cursor shape from resources and appends it to a native sprite. |
| * Animated cursors (e.g. the busy cursor) have multiple members. |
| */ |
| void QCursorData::loadShapeFromResource(RWsSpriteBase& target, QString resource, int hx, int hy, int interval) |
| { |
| QPixmap pix; |
| CFbsBitmap* native; |
| QScopedPointer<TSpriteMember> member(new TSpriteMember); |
| member->iInterval = interval; |
| member->iInvertMask = false; |
| member->iMaskBitmap = 0; // all shapes are RGBA |
| member->iDrawMode = CGraphicsContext::EDrawModePEN; |
| member->iOffset = TPoint(-hx, -hy); |
| QString res(QLatin1String(":/trolltech/symbian/cursors/images/%1.png")); |
| pix.load(res.arg(resource)); |
| native = pix.toSymbianCFbsBitmap(); |
| member->iBitmap = native; |
| qt_symbian_throwIfError(nativeSpriteMembers.Append(member.data())); |
| target.AppendMember(*(member.take())); |
| } |
| |
| //TODO: after 4.6, connect with style & skins? |
| /* |
| * Constructs the native cursor from resources compiled into QtGui |
| * This is needed only when the platform doesn't have system cursors. |
| * |
| * System cursors are higher performance, since they are constructed once |
| * and shared by all applications by specifying the shape number. |
| * Due to symbian platform security considerations, and the fact most |
| * existing phones have a broken RWsPointerCursor, system cursors are not |
| * being used. |
| */ |
| void QCursorData::constructShapeSprite(RWsSpriteBase& target) |
| { |
| int i; |
| switch (cshape) { |
| default: |
| qWarning("QCursorData::constructShapeSprite unknown shape %d", cshape); |
| //fall through and give arrow cursor |
| case Qt::ArrowCursor: |
| loadShapeFromResource(target, QLatin1String("pointer"), 1, 1); |
| break; |
| case Qt::UpArrowCursor: |
| loadShapeFromResource(target, QLatin1String("uparrow"), 4, 0); |
| break; |
| case Qt::CrossCursor: |
| loadShapeFromResource(target, QLatin1String("cross"), 7, 7); |
| break; |
| case Qt::WaitCursor: |
| for (i = 1; i <= 12; i++) { |
| loadShapeFromResource(target, QString(QLatin1String("wait%1")).arg(i), 7, 7, 1000000); |
| } |
| break; |
| case Qt::IBeamCursor: |
| loadShapeFromResource(target, QLatin1String("ibeam"), 3, 10); |
| break; |
| case Qt::SizeVerCursor: |
| loadShapeFromResource(target, QLatin1String("sizever"), 4, 8); |
| break; |
| case Qt::SizeHorCursor: |
| loadShapeFromResource(target, QLatin1String("sizehor"), 8, 4); |
| break; |
| case Qt::SizeBDiagCursor: |
| loadShapeFromResource(target, QLatin1String("sizebdiag"), 8, 8); |
| break; |
| case Qt::SizeFDiagCursor: |
| loadShapeFromResource(target, QLatin1String("sizefdiag"), 8, 8); |
| break; |
| case Qt::SizeAllCursor: |
| loadShapeFromResource(target, QLatin1String("sizeall"), 7, 7); |
| break; |
| case Qt::BlankCursor: |
| loadShapeFromResource(target, QLatin1String("blank"), 0, 0); |
| break; |
| case Qt::SplitVCursor: |
| loadShapeFromResource(target, QLatin1String("splitv"), 7, 7); |
| break; |
| case Qt::SplitHCursor: |
| loadShapeFromResource(target, QLatin1String("splith"), 7, 7); |
| break; |
| case Qt::PointingHandCursor: |
| loadShapeFromResource(target, QLatin1String("handpoint"), 5, 0); |
| break; |
| case Qt::ForbiddenCursor: |
| loadShapeFromResource(target, QLatin1String("forbidden"), 7, 7); |
| break; |
| case Qt::WhatsThisCursor: |
| loadShapeFromResource(target, QLatin1String("whatsthis"), 1, 1); |
| break; |
| case Qt::BusyCursor: |
| loadShapeFromResource(target, QLatin1String("busy3"), 1, 1, 1000000); |
| loadShapeFromResource(target, QLatin1String("busy6"), 1, 1, 1000000); |
| loadShapeFromResource(target, QLatin1String("busy9"), 1, 1, 1000000); |
| loadShapeFromResource(target, QLatin1String("busy12"), 1, 1, 1000000); |
| break; |
| case Qt::OpenHandCursor: |
| loadShapeFromResource(target, QLatin1String("openhand"), 7, 7); |
| break; |
| case Qt::ClosedHandCursor: |
| loadShapeFromResource(target, QLatin1String("closehand"), 7, 7); |
| break; |
| } |
| } |
| #endif |
| |
| /* |
| * Common code between the sprite workaround and standard modes of operation. |
| * RWsSpriteBase is the base class for both RWsSprite and RWsPointerCursor. |
| * It is called from both handle() and qt_s60_show_pointer_sprite() |
| */ |
| void QCursorData::constructCursorSprite(RWsSpriteBase& target) |
| { |
| int count = nativeSpriteMembers.Count(); |
| if (count) { |
| // already constructed |
| for (int i = 0; i < count; i++) |
| target.AppendMember(*(nativeSpriteMembers[i])); |
| |
| return; |
| } |
| if (pixmap.isNull() && !bm) { |
| #ifndef Q_SYMBIAN_HAS_SYSTEM_CURSORS |
| //shape cursor |
| constructShapeSprite(target); |
| #endif |
| return; |
| } |
| QScopedPointer<TSpriteMember> member(new TSpriteMember); |
| if (pixmap.isNull()) { |
| //construct mono cursor |
| member->iBitmap = bm->toSymbianCFbsBitmap(); |
| member->iMaskBitmap = bmm->toSymbianCFbsBitmap(); |
| } |
| else { |
| //construct normal cursor |
| member->iBitmap = pixmap.toSymbianCFbsBitmap(); |
| if (pixmap.hasAlphaChannel()) { |
| member->iMaskBitmap = 0; //use alpha blending |
| } |
| else if (pixmap.hasAlpha()) { |
| member->iMaskBitmap = pixmap.mask().toSymbianCFbsBitmap(); |
| } |
| else { |
| member->iMaskBitmap = 0; //opaque rectangle cursor (due to EDrawModePEN) |
| } |
| } |
| |
| member->iDrawMode = CGraphicsContext::EDrawModePEN; |
| member->iInvertMask = EFalse; |
| member->iInterval = 0; |
| member->iOffset = TPoint(-(hx), -(hy)); //Symbian hotspot coordinates are negative |
| qt_symbian_throwIfError(nativeSpriteMembers.Append(member.data())); |
| target.AppendMember(*(member.take())); |
| } |
| |
| /* |
| * shows the pointer sprite by constructing a native handle, and registering |
| * it with the window server. |
| * Only used when the sprite workaround is in use. |
| */ |
| void qt_symbian_show_pointer_sprite() |
| { |
| if (cursorSprite.d) { |
| if (cursorSprite.d->scurs.WsHandle()) |
| cursorSprite.d->scurs.Close(); |
| } else { |
| cursorSprite = QCursor(Qt::ArrowCursor); |
| } |
| |
| cursorSprite.d->scurs = RWsSprite(S60->wsSession()); |
| QPoint pos = QCursor::pos(); |
| cursorSprite.d->scurs.Construct(S60->windowGroup(), TPoint(pos.x(), pos.y()), ESpriteNoChildClip | ESpriteNoShadows); |
| |
| cursorSprite.d->constructCursorSprite(cursorSprite.d->scurs); |
| cursorSprite.d->scurs.Activate(); |
| } |
| |
| /* |
| * hides the pointer sprite by closing the native handle. |
| * Only used when the sprite workaround is in use. |
| */ |
| void qt_symbian_hide_pointer_sprite() |
| { |
| if (cursorSprite.d) { |
| cursorSprite.d->scurs.Close(); |
| } |
| } |
| |
| /* |
| * Changes the cursor sprite to the cursor specified. |
| * Only used when the sprite workaround is in use. |
| */ |
| void qt_symbian_set_pointer_sprite(const QCursor& cursor) |
| { |
| if (S60->mouseInteractionEnabled) |
| qt_symbian_hide_pointer_sprite(); |
| cursorSprite = cursor; |
| if (S60->mouseInteractionEnabled) |
| qt_symbian_show_pointer_sprite(); |
| } |
| |
| /* |
| * When using sprites as a workaround on phones that have a broken |
| * RWsPointerCursor, this function is called in response to pointer events |
| * and when QCursor::setPos() is called. |
| * Performance is worse than a real pointer cursor, due to extra context |
| * switches vs. the window server moving the cursor by itself. |
| */ |
| void qt_symbian_move_cursor_sprite() |
| { |
| if (S60->mouseInteractionEnabled) { |
| cursorSprite.d->scurs.SetPosition(TPoint(S60->lastCursorPos.x(), S60->lastCursorPos.y())); |
| } |
| } |
| |
| /* |
| * Translate from Qt::CursorShape to OS system pointer cursor list index. |
| * Currently we control the implementation of the system pointer cursor list, |
| * so this function is trivial. That may not always be the case. |
| */ |
| TInt qt_symbian_translate_cursor_shape(Qt::CursorShape shape) |
| { |
| return (TInt) shape; |
| } |
| |
| /* |
| Internal function called from QWidget::setCursor() |
| force is true if this function is called from dispatchEnterLeave, it means that the |
| mouse is actually directly under this widget. |
| */ |
| void qt_symbian_set_cursor(QWidget *w, bool force) |
| { |
| static QPointer<QWidget> lastUnderMouse = 0; |
| if (force) { |
| lastUnderMouse = w; |
| } |
| else if (w->testAttribute(Qt::WA_WState_Created) && lastUnderMouse |
| && lastUnderMouse->effectiveWinId() == w->effectiveWinId()) { |
| w = lastUnderMouse; |
| } |
| |
| if (!S60->curWin && w && w->internalWinId()) |
| return; |
| QWidget* cW = w && !w->internalWinId() ? w : QWidget::find(S60->curWin); |
| if (!cW || cW->window() != w->window() || !cW->isVisible() || !cW->underMouse() |
| || QApplication::overrideCursor()) |
| return; |
| |
| #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS |
| if (S60->brokenPointerCursors) |
| qt_symbian_set_pointer_sprite(cW->cursor()); |
| else |
| #endif |
| qt_symbian_setWindowCursor(cW->cursor(), w->effectiveWinId()); |
| } |
| |
| /* |
| * Makes the specified cursor appear above a specific native window group |
| * Called from QSymbianControl and QApplication::restoreOverrideCursor |
| * |
| * Window server is needed for this, so there is no equivalent when using |
| * the sprite workaround. |
| */ |
| void qt_symbian_setWindowGroupCursor(const QCursor &cursor, RWindowTreeNode &node) |
| { |
| Qt::HANDLE handle = cursor.handle(); |
| if (handle) { |
| RWsPointerCursor *pcurs = reinterpret_cast<RWsPointerCursor *> (handle); |
| node.SetCustomPointerCursor(*pcurs); |
| } else |
| #ifdef Q_SYMBIAN_HAS_SYSTEM_CURSORS |
| { |
| TInt shape = qt_symbian_translate_cursor_shape(cursor.shape()); |
| node.SetPointerCursor(shape); |
| } |
| #else |
| qWarning("qt_s60_setWindowGroupCursor - null handle"); |
| #endif |
| } |
| |
| /* |
| * Makes the specified cursor appear above a specific native window |
| * Called from QSymbianControl and QApplication::restoreOverrideCursor |
| * |
| * Window server is needed for this, so there is no equivalent when using |
| * the sprite workaround. |
| */ |
| void qt_symbian_setWindowCursor(const QCursor &cursor, const CCoeControl* wid) |
| { |
| //find the window for this control |
| while (!wid->OwnsWindow()) { |
| wid = wid->Parent(); |
| if (!wid) |
| return; |
| } |
| RWindowTreeNode *node = wid->DrawableWindow(); |
| qt_symbian_setWindowGroupCursor(cursor, *node); |
| } |
| |
| /* |
| * Makes the specified cursor appear everywhere. |
| * Called from QApplication::setOverrideCursor |
| */ |
| void qt_symbian_setGlobalCursor(const QCursor &cursor) |
| { |
| #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS |
| if (S60->brokenPointerCursors) { |
| qt_symbian_set_pointer_sprite(cursor); |
| } else |
| #endif |
| { |
| //because of the internals of window server, we need to force the cursor |
| //to be set in all child windows too, otherwise when the cursor is over |
| //the child window it may show a widget cursor or arrow cursor instead, |
| //depending on construction order. |
| QListIterator<WId> iter(QWidgetPrivate::mapper->uniqueKeys()); |
| while(iter.hasNext()) |
| { |
| CCoeControl *ctrl = iter.next(); |
| if(ctrl->OwnsWindow()) { |
| RWindowTreeNode *node = ctrl->DrawableWindow(); |
| qt_symbian_setWindowGroupCursor(cursor, *node); |
| } |
| } |
| } |
| } |
| QT_END_NAMESPACE |
| #endif // QT_NO_CURSOR |