1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    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 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <private/qcursor_p.h>

    43 #include <private/qwidget_p.h>

    44 #include <private/qapplication_p.h>

    45 #include <coecntrl.h>

    46 #include <qcursor.h>

    47 #include <qt_s60_p.h>

    48 #include <qbitmap.h>

    49 #include <w32std.h>

    50 #include <qapplication.h>

    51 #include <qwidget.h>

    52 

    53 QT_BEGIN_NAMESPACE

    54 

    55 #ifndef QT_NO_CURSOR

    56 static QCursor cursorSprite;

    57 static int cursorSpriteVisible;

    58 #endif

    59 

    60 //pos and setpos are required whether cursors are configured or not.

    61 QPoint QCursor::pos()

    62 {

    63     return S60->lastCursorPos;

    64 }

    65 

    66 void QCursor::setPos(int x, int y)

    67 {

    68     //clip to screen size (window server allows a sprite hotspot to be outside the screen)

    69     if (x < 0)

    70         x=0;

    71     else if (x >= S60->screenWidthInPixels)

    72         x = S60->screenWidthInPixels - 1;

    73     if (y < 0)

    74         y = 0;

    75     else if (y >= S60->screenHeightInPixels)

    76         y = S60->screenHeightInPixels - 1;

    77 

    78 #ifndef QT_NO_CURSOR

    79 #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS

    80     if (S60->brokenPointerCursors && cursorSpriteVisible)

    81         cursorSprite.d->scurs.SetPosition(TPoint(x,y));

    82     else

    83 #endif

    84         S60->wsSession().SetPointerCursorPosition(TPoint(x, y));

    85 #endif

    86     S60->lastCursorPos = QPoint(x, y);

    87     //send a fake mouse move event, so that enter/leave events go to the widget hierarchy

    88     QWidget *w = QApplication::topLevelAt(S60->lastCursorPos);

    89     if (w) {

    90         CCoeControl* ctrl = w->effectiveWinId();

    91         TPoint epos(x, y);

    92         TPoint cpos = epos - ctrl->PositionRelativeToScreen();

    93         TPointerEvent fakeEvent;

    94         fakeEvent.iType = TPointerEvent::EMove;

    95         fakeEvent.iModifiers = 0U;

    96         fakeEvent.iPosition = cpos;

    97         fakeEvent.iParentPosition = epos;

    98         ctrl->HandlePointerEventL(fakeEvent);

    99     }

   100 }

   101 

   102 #ifndef QT_NO_CURSOR

   103 /*

   104  * Request cursor to be turned on or off.

   105  * Reference counted, so 2 on + 1 off = on, for example

   106  */

   107 void qt_symbian_set_cursor_visible(bool visible) {

   108     if (visible)

   109         cursorSpriteVisible++;

   110     else

   111         cursorSpriteVisible--;

   112     Q_ASSERT(cursorSpriteVisible >=0);

   113 

   114     if (cursorSpriteVisible && !S60->mouseInteractionEnabled) {

   115 #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS

   116         if (S60->brokenPointerCursors)

   117             qt_symbian_show_pointer_sprite();

   118         else

   119 #endif

   120             S60->wsSession().SetPointerCursorMode(EPointerCursorNormal);

   121     } else if (!cursorSpriteVisible && S60->mouseInteractionEnabled) {

   122 #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS

   123         if (S60->brokenPointerCursors)

   124             qt_symbian_hide_pointer_sprite();

   125         else

   126 #endif

   127             S60->wsSession().SetPointerCursorMode(EPointerCursorNone);

   128     }

   129     S60->mouseInteractionEnabled = ((cursorSpriteVisible > 0) ? true : false);

   130 }

   131 

   132 /*

   133  * Check if the cursor is on or off

   134  */

   135 bool qt_symbian_is_cursor_visible() {

   136     return S60->mouseInteractionEnabled;

   137 }

   138 

   139 QCursorData::QCursorData(Qt::CursorShape s) :

   140     cshape(s), bm(0), bmm(0), hx(0), hy(0), pcurs()

   141 {

   142     ref = 1;

   143 }

   144 

   145 QCursorData::~QCursorData()

   146 {

   147     for(int i=0;i<nativeSpriteMembers.Count();i++) {

   148         delete nativeSpriteMembers[i]->iBitmap;

   149         delete nativeSpriteMembers[i]->iMaskBitmap;

   150     }

   151     nativeSpriteMembers.ResetAndDestroy();

   152     pcurs.Close();

   153     delete bm;

   154     delete bmm;

   155 }

   156 

   157 /* Create a bitmap cursor, this is called by public constructors in the

   158  * generic QCursor code.

   159  */

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

   161 {

   162     if (!QCursorData::initialized)

   163         QCursorData::initialize();

   164     if (bitmap.depth() != 1 || mask.depth() != 1 || bitmap.size() != mask.size()) {

   165         qWarning("QCursor: Cannot create bitmap cursor; invalid bitmap(s)");

   166         QCursorData *c = qt_cursorTable[0];

   167         c->ref.ref();

   168         return c;

   169     }

   170     QCursorData *d = new QCursorData;

   171     d->bm = new QBitmap(bitmap);

   172     d->bmm = new QBitmap(mask);

   173     d->cshape = Qt::BitmapCursor;

   174     d->hx = hotX >= 0 ? hotX : bitmap.width() / 2;

   175     d->hy = hotY >= 0 ? hotY : bitmap.height() / 2;

   176     return d;

   177 }

   178 

   179 /*

   180  * returns an opaque native handle to a cursor.

   181  * It happens to be the address of the native handle, as window server handles

   182  * are not POD types. Note there is no QCursor(HANDLE) constructor on Symbian,

   183  * Mac or QWS.

   184  */

   185 Qt::HANDLE QCursor::handle() const

   186 {

   187     if (d->pcurs.WsHandle())

   188         return reinterpret_cast<Qt::HANDLE> (&(d->pcurs));

   189 

   190 #ifdef Q_SYMBIAN_HAS_SYSTEM_CURSORS

   191     // don't construct shape cursors, QApplication_s60 will use the system cursor instead

   192     if (!(d->bm))

   193         return 0;

   194 #endif

   195 

   196     d->pcurs = RWsPointerCursor(S60->wsSession());

   197     d->pcurs.Construct(0);

   198     d->constructCursorSprite(d->pcurs);

   199     d->pcurs.Activate();

   200 

   201     return reinterpret_cast<Qt::HANDLE> (&(d->pcurs));

   202 }

   203 

   204 #ifndef Q_SYMBIAN_HAS_SYSTEM_CURSORS

   205 /*

   206  * Loads a single cursor shape from resources and appends it to a native sprite.

   207  * Animated cursors (e.g. the busy cursor) have multiple members.

   208  */

   209 void QCursorData::loadShapeFromResource(RWsSpriteBase& target, QString resource, int hx, int hy, int interval)

   210 {

   211     QPixmap pix;

   212     CFbsBitmap* native;

   213     QScopedPointer<TSpriteMember> member(new TSpriteMember);

   214     member->iInterval = interval;

   215     member->iInvertMask = false;

   216     member->iMaskBitmap = 0; // all shapes are RGBA

   217     member->iDrawMode = CGraphicsContext::EDrawModePEN;

   218     member->iOffset = TPoint(-hx, -hy);

   219     QString res(QLatin1String(":/trolltech/symbian/cursors/images/%1.png"));

   220     pix.load(res.arg(resource));

   221     native = pix.toSymbianCFbsBitmap();

   222     member->iBitmap = native;

   223     qt_symbian_throwIfError(nativeSpriteMembers.Append(member.data()));

   224     target.AppendMember(*(member.take()));

   225 }

   226 

   227 //TODO: after 4.6, connect with style & skins?

   228 /*

   229  * Constructs the native cursor from resources compiled into QtGui

   230  * This is needed only when the platform doesn't have system cursors.

   231  *

   232  * System cursors are higher performance, since they are constructed once

   233  * and shared by all applications by specifying the shape number.

   234  * Due to symbian platform security considerations, and the fact most

   235  * existing phones have a broken RWsPointerCursor, system cursors are not

   236  * being used.

   237  */

   238 void QCursorData::constructShapeSprite(RWsSpriteBase& target)

   239 {

   240     int i;

   241     switch (cshape) {

   242     default:

   243         qWarning("QCursorData::constructShapeSprite unknown shape %d", cshape);

   244         //fall through and give arrow cursor

   245     case Qt::ArrowCursor:

   246         loadShapeFromResource(target, QLatin1String("pointer"), 1, 1);

   247         break;

   248     case Qt::UpArrowCursor:

   249         loadShapeFromResource(target, QLatin1String("uparrow"), 4, 0);

   250         break;

   251     case Qt::CrossCursor:

   252         loadShapeFromResource(target, QLatin1String("cross"), 7, 7);

   253         break;

   254     case Qt::WaitCursor:

   255         for (i = 1; i <= 12; i++) {

   256             loadShapeFromResource(target, QString(QLatin1String("wait%1")).arg(i), 7, 7, 1000000);

   257         }

   258         break;

   259     case Qt::IBeamCursor:

   260         loadShapeFromResource(target, QLatin1String("ibeam"), 3, 10);

   261         break;

   262     case Qt::SizeVerCursor:

   263         loadShapeFromResource(target, QLatin1String("sizever"), 4, 8);

   264         break;

   265     case Qt::SizeHorCursor:

   266         loadShapeFromResource(target, QLatin1String("sizehor"), 8, 4);

   267         break;

   268     case Qt::SizeBDiagCursor:

   269         loadShapeFromResource(target, QLatin1String("sizebdiag"), 8, 8);

   270         break;

   271     case Qt::SizeFDiagCursor:

   272         loadShapeFromResource(target, QLatin1String("sizefdiag"), 8, 8);

   273         break;

   274     case Qt::SizeAllCursor:

   275         loadShapeFromResource(target, QLatin1String("sizeall"), 7, 7);

   276         break;

   277     case Qt::BlankCursor:

   278         loadShapeFromResource(target, QLatin1String("blank"), 0, 0);

   279         break;

   280     case Qt::SplitVCursor:

   281         loadShapeFromResource(target, QLatin1String("splitv"), 7, 7);

   282         break;

   283     case Qt::SplitHCursor:

   284         loadShapeFromResource(target, QLatin1String("splith"), 7, 7);

   285         break;

   286     case Qt::PointingHandCursor:

   287         loadShapeFromResource(target, QLatin1String("handpoint"), 5, 0);

   288         break;

   289     case Qt::ForbiddenCursor:

   290         loadShapeFromResource(target, QLatin1String("forbidden"), 7, 7);

   291         break;

   292     case Qt::WhatsThisCursor:

   293         loadShapeFromResource(target, QLatin1String("whatsthis"), 1, 1);

   294         break;

   295     case Qt::BusyCursor:

   296         loadShapeFromResource(target, QLatin1String("busy3"), 1, 1, 1000000);

   297         loadShapeFromResource(target, QLatin1String("busy6"), 1, 1, 1000000);

   298         loadShapeFromResource(target, QLatin1String("busy9"), 1, 1, 1000000);

   299         loadShapeFromResource(target, QLatin1String("busy12"), 1, 1, 1000000);

   300         break;

   301     case Qt::OpenHandCursor:

   302         loadShapeFromResource(target, QLatin1String("openhand"), 7, 7);

   303         break;

   304     case Qt::ClosedHandCursor:

   305         loadShapeFromResource(target, QLatin1String("closehand"), 7, 7);

   306         break;

   307     }

   308 }

   309 #endif

   310 

   311 /*

   312  * Common code between the sprite workaround and standard modes of operation.

   313  * RWsSpriteBase is the base class for both RWsSprite and RWsPointerCursor.

   314  * It is called from both handle() and qt_s60_show_pointer_sprite()

   315  */

   316 void QCursorData::constructCursorSprite(RWsSpriteBase& target)

   317 {

   318     int count = nativeSpriteMembers.Count();

   319     if (count) {

   320         // already constructed

   321         for (int i = 0; i < count; i++)

   322             target.AppendMember(*(nativeSpriteMembers[i]));

   323 

   324         return;

   325     }

   326     if (pixmap.isNull() && !bm) {

   327 #ifndef Q_SYMBIAN_HAS_SYSTEM_CURSORS

   328         //shape cursor

   329         constructShapeSprite(target);

   330 #endif

   331         return;

   332     }

   333     QScopedPointer<TSpriteMember> member(new TSpriteMember);

   334     if (pixmap.isNull()) {

   335         //construct mono cursor

   336         member->iBitmap = bm->toSymbianCFbsBitmap();

   337         member->iMaskBitmap = bmm->toSymbianCFbsBitmap();

   338     }

   339     else {

   340         //construct normal cursor

   341         member->iBitmap = pixmap.toSymbianCFbsBitmap();

   342         if (pixmap.hasAlphaChannel()) {

   343             member->iMaskBitmap = 0; //use alpha blending

   344         }

   345         else if (pixmap.hasAlpha()) {

   346             member->iMaskBitmap = pixmap.mask().toSymbianCFbsBitmap();

   347         }

   348         else {

   349             member->iMaskBitmap = 0; //opaque rectangle cursor (due to EDrawModePEN)

   350         }

   351     }

   352 

   353     member->iDrawMode = CGraphicsContext::EDrawModePEN;

   354     member->iInvertMask = EFalse;

   355     member->iInterval = 0;

   356     member->iOffset = TPoint(-(hx), -(hy)); //Symbian hotspot coordinates are negative

   357     qt_symbian_throwIfError(nativeSpriteMembers.Append(member.data()));

   358     target.AppendMember(*(member.take()));

   359 }

   360 

   361 /*

   362  * shows the pointer sprite by constructing a native handle, and registering

   363  * it with the window server.

   364  * Only used when the sprite workaround is in use.

   365  */

   366 void qt_symbian_show_pointer_sprite()

   367 {

   368     if (cursorSprite.d) {

   369         if (cursorSprite.d->scurs.WsHandle())

   370             cursorSprite.d->scurs.Close();

   371     } else {

   372         cursorSprite = QCursor(Qt::ArrowCursor);

   373     }

   374 

   375     cursorSprite.d->scurs = RWsSprite(S60->wsSession());

   376     QPoint pos = QCursor::pos();

   377     cursorSprite.d->scurs.Construct(S60->windowGroup(), TPoint(pos.x(), pos.y()), ESpriteNoChildClip | ESpriteNoShadows);

   378 

   379     cursorSprite.d->constructCursorSprite(cursorSprite.d->scurs);

   380     cursorSprite.d->scurs.Activate();

   381 }

   382 

   383 /*

   384  * hides the pointer sprite by closing the native handle.

   385  * Only used when the sprite workaround is in use.

   386  */

   387 void qt_symbian_hide_pointer_sprite()

   388 {

   389     if (cursorSprite.d) {

   390         cursorSprite.d->scurs.Close();

   391     }

   392 }

   393 

   394 /*

   395  * Changes the cursor sprite to the cursor specified.

   396  * Only used when the sprite workaround is in use.

   397  */

   398 void qt_symbian_set_pointer_sprite(const QCursor& cursor)

   399 {

   400     if (S60->mouseInteractionEnabled)

   401         qt_symbian_hide_pointer_sprite();

   402     cursorSprite = cursor;

   403     if (S60->mouseInteractionEnabled)

   404         qt_symbian_show_pointer_sprite();

   405 }

   406 

   407 /*

   408  * When using sprites as a workaround on phones that have a broken

   409  * RWsPointerCursor, this function is called in response to pointer events

   410  * and when QCursor::setPos() is called.

   411  * Performance is worse than a real pointer cursor, due to extra context

   412  * switches vs. the window server moving the cursor by itself.

   413  */

   414 void qt_symbian_move_cursor_sprite()

   415 {

   416     if (S60->mouseInteractionEnabled) {

   417         cursorSprite.d->scurs.SetPosition(TPoint(S60->lastCursorPos.x(), S60->lastCursorPos.y()));

   418     }

   419 }

   420 

   421 /*

   422  * Translate from Qt::CursorShape to OS system pointer cursor list index.

   423  * Currently we control the implementation of the system pointer cursor list,

   424  * so this function is trivial. That may not always be the case.

   425  */

   426 TInt qt_symbian_translate_cursor_shape(Qt::CursorShape shape)

   427 {

   428     return (TInt) shape;

   429 }

   430 

   431 /*

   432   Internal function called from QWidget::setCursor()

   433    force is true if this function is called from dispatchEnterLeave, it means that the

   434    mouse is actually directly under this widget.

   435 */

   436 void qt_symbian_set_cursor(QWidget *w, bool force)

   437 {

   438     static QPointer<QWidget> lastUnderMouse = 0;

   439     if (force) {

   440         lastUnderMouse = w;

   441     }

   442     else if (w->testAttribute(Qt::WA_WState_Created) && lastUnderMouse

   443         && lastUnderMouse->effectiveWinId() == w->effectiveWinId()) {

   444         w = lastUnderMouse;

   445     }

   446 

   447     if (!S60->curWin && w && w->internalWinId())

   448         return;

   449     QWidget* cW = w && !w->internalWinId() ? w : QWidget::find(S60->curWin);

   450     if (!cW || cW->window() != w->window() || !cW->isVisible() || !cW->underMouse()

   451         || QApplication::overrideCursor())

   452         return;

   453 

   454 #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS

   455     if (S60->brokenPointerCursors)

   456         qt_symbian_set_pointer_sprite(cW->cursor());

   457     else

   458 #endif

   459         qt_symbian_setWindowCursor(cW->cursor(), w->effectiveWinId());

   460 }

   461 

   462 /*

   463  * Makes the specified cursor appear above a specific native window group

   464  * Called from QSymbianControl and QApplication::restoreOverrideCursor

   465  *

   466  * Window server is needed for this, so there is no equivalent when using

   467  * the sprite workaround.

   468  */

   469 void qt_symbian_setWindowGroupCursor(const QCursor &cursor, RWindowTreeNode &node)

   470 {

   471     Qt::HANDLE handle = cursor.handle();

   472     if (handle) {

   473         RWsPointerCursor *pcurs = reinterpret_cast<RWsPointerCursor *> (handle);

   474         node.SetCustomPointerCursor(*pcurs);

   475     }

   476 #ifdef Q_SYMBIAN_HAS_SYSTEM_CURSORS

   477     else {

   478         TInt shape = qt_symbian_translate_cursor_shape(cursor.shape());

   479         node.SetPointerCursor(shape);

   480     }

   481 #else

   482     qWarning("qt_s60_setWindowGroupCursor - null handle");

   483 #endif

   484 }

   485 

   486 /*

   487  * Makes the specified cursor appear above a specific native window

   488  * Called from QSymbianControl and QApplication::restoreOverrideCursor

   489  *

   490  * Window server is needed for this, so there is no equivalent when using

   491  * the sprite workaround.

   492  */

   493 void qt_symbian_setWindowCursor(const QCursor &cursor, const CCoeControl* wid)

   494 {

   495     //find the window for this control

   496     while (!wid->OwnsWindow()) {

   497         wid = wid->Parent();

   498         if (!wid)

   499             return;

   500     }

   501     RWindowTreeNode *node = wid->DrawableWindow();

   502     qt_symbian_setWindowGroupCursor(cursor, *node);

   503 }

   504 

   505 /*

   506  * Makes the specified cursor appear everywhere.

   507  * Called from QApplication::setOverrideCursor

   508  */

   509 void qt_symbian_setGlobalCursor(const QCursor &cursor)

   510 {

   511 #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS

   512     if (S60->brokenPointerCursors) {

   513         qt_symbian_set_pointer_sprite(cursor);

   514     } else

   515 #endif

   516     {

   517         //because of the internals of window server, we need to force the cursor

   518         //to be set in all child windows too, otherwise when the cursor is over

   519         //the child window it may show a widget cursor or arrow cursor instead,

   520         //depending on construction order.

   521         QListIterator<WId> iter(QWidgetPrivate::mapper->uniqueKeys());

   522         while(iter.hasNext())

   523         {

   524             CCoeControl *ctrl = iter.next();

   525             if(ctrl->OwnsWindow()) {

   526                 RWindowTreeNode *node = ctrl->DrawableWindow();

   527                 qt_symbian_setWindowGroupCursor(cursor, *node);

   528             }

   529         }

   530     }

   531 }

   532 QT_END_NAMESPACE

   533 #endif // QT_NO_CURSOR