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

     2 **

     3 ** Copyright (C) 2010 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 module 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 "qapplication_p.h"

    43 #include "qsessionmanager.h"

    44 #include "qevent.h"

    45 #include "qsymbianevent.h"

    46 #include "qeventdispatcher_s60_p.h"

    47 #include "qwidget.h"

    48 #include "qdesktopwidget.h"

    49 #include "private/qbackingstore_p.h"

    50 #include "qt_s60_p.h"

    51 #include "private/qevent_p.h"

    52 #include "qstring.h"

    53 #include "qdebug.h"

    54 #include "qimage.h"

    55 #include "qcombobox.h"

    56 #include "private/qkeymapper_p.h"

    57 #include "private/qfont_p.h"

    58 #ifndef QT_NO_STYLE_S60

    59 #include "private/qs60style_p.h"

    60 #endif

    61 #include "private/qwindowsurface_s60_p.h"

    62 #include "qpaintengine.h"

    63 #include "private/qmenubar_p.h"

    64 #include "private/qsoftkeymanager_p.h"

    65 

    66 #include "apgwgnam.h" // For CApaWindowGroupName

    67 #include <mdaaudiotoneplayer.h>     // For CMdaAudioToneUtility

    68 

    69 #if defined(Q_WS_S60)

    70 # if !defined(QT_NO_IM)

    71 #  include "qinputcontext.h"

    72 #  include <private/qcoefepinputcontext_p.h>

    73 # endif

    74 # include <private/qs60mainapplication_p.h>

    75 # include <centralrepository.h>

    76 # include "qs60mainappui.h"

    77 #endif

    78 

    79 #include "private/qstylesheetstyle_p.h"

    80 

    81 #include <hal.h>

    82 #include <hal_data.h>

    83 

    84 QT_BEGIN_NAMESPACE

    85 

    86 #if defined(QT_DEBUG)

    87 static bool        appNoGrab        = false;        // Grabbing enabled

    88 #endif

    89 static bool        app_do_modal        = false;        // modal mode

    90 Q_GLOBAL_STATIC(QS60Data, qt_s60Data);

    91 

    92 extern bool qt_sendSpontaneousEvent(QObject*,QEvent*);

    93 extern QWidgetList *qt_modal_stack;              // stack of modal widgets

    94 extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp

    95 

    96 QWidget *qt_button_down = 0;                     // widget got last button-down

    97 

    98 QSymbianControl *QSymbianControl::lastFocusedControl = 0;

    99 

   100 QS60Data* qGlobalS60Data()

   101 {

   102     return qt_s60Data();

   103 }

   104 

   105 bool qt_nograb()                                // application no-grab option

   106 {

   107 #if defined(QT_DEBUG)

   108     return appNoGrab;

   109 #else

   110     return false;

   111 #endif

   112 }

   113 

   114 // Modified from http://www3.symbian.com/faq.nsf/0/0F1464EE96E737E780256D5E00503DD1?OpenDocument

   115 class QS60Beep : public CBase, public MMdaAudioToneObserver

   116 {

   117 public:

   118     static QS60Beep* NewL(TInt aFrequency,  TTimeIntervalMicroSeconds iDuration);

   119     void Play();

   120     ~QS60Beep();

   121 private:

   122     void ConstructL(TInt aFrequency,  TTimeIntervalMicroSeconds iDuration);

   123     void MatoPrepareComplete(TInt aError);

   124     void MatoPlayComplete(TInt aError);

   125 private:

   126     typedef enum

   127         {

   128         EBeepNotPrepared,

   129         EBeepPrepared,

   130         EBeepPlaying

   131         } TBeepState;

   132 private:

   133     CMdaAudioToneUtility* iToneUtil;

   134     TBeepState iState;

   135     TInt iFrequency;

   136     TTimeIntervalMicroSeconds iDuration;

   137 };

   138 

   139 static QS60Beep* qt_S60Beep = 0;

   140 

   141 QS60Beep::~QS60Beep()

   142 {

   143     if (iToneUtil) {

   144         switch (iState) {

   145         case EBeepPlaying:

   146             iToneUtil->CancelPlay();

   147             break;

   148         case EBeepNotPrepared:

   149             iToneUtil->CancelPrepare();

   150             break;

   151         }

   152     }

   153     delete iToneUtil;

   154 }

   155 

   156 QS60Beep* QS60Beep::NewL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)

   157 {

   158     QS60Beep* self = new (ELeave) QS60Beep();

   159     CleanupStack::PushL(self);

   160     self->ConstructL(aFrequency, aDuration);

   161     CleanupStack::Pop();

   162     return self;

   163 }

   164 

   165 void QS60Beep::ConstructL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)

   166 {

   167     iToneUtil = CMdaAudioToneUtility::NewL(*this);

   168     iState = EBeepNotPrepared;

   169     iFrequency = aFrequency;

   170     iDuration = aDuration;

   171     iToneUtil->PrepareToPlayTone(iFrequency, iDuration);

   172 }

   173 

   174 void QS60Beep::Play()

   175 {

   176     if (iState == EBeepPlaying) {

   177         iToneUtil->CancelPlay();

   178         iState = EBeepPrepared;

   179     }

   180 

   181     iToneUtil->Play();

   182     iState = EBeepPlaying;

   183 }

   184 

   185 void QS60Beep::MatoPrepareComplete(TInt aError)

   186 {

   187     if (aError == KErrNone) {

   188         iState = EBeepPrepared;

   189         Play();

   190     }

   191 }

   192 

   193 void QS60Beep::MatoPlayComplete(TInt aError)

   194 {

   195     Q_UNUSED(aError);

   196     iState = EBeepPrepared;

   197 }

   198 

   199 

   200 QHash<TInt, TUint> QApplicationPrivate::scanCodeCache;

   201 

   202 static Qt::KeyboardModifiers mapToQtModifiers(TUint s60Modifiers)

   203 {

   204     Qt::KeyboardModifiers result = Qt::NoModifier;

   205 

   206     if (s60Modifiers & EModifierKeypad)

   207         result |= Qt::KeypadModifier;

   208     if (s60Modifiers & EModifierShift || s60Modifiers & EModifierLeftShift

   209             || s60Modifiers & EModifierRightShift)

   210         result |= Qt::ShiftModifier;

   211     if (s60Modifiers & EModifierCtrl || s60Modifiers & EModifierLeftCtrl

   212             || s60Modifiers & EModifierRightCtrl)

   213         result |= Qt::ControlModifier;

   214     if (s60Modifiers & EModifierAlt || s60Modifiers & EModifierLeftAlt

   215             || s60Modifiers & EModifierRightAlt)

   216         result |= Qt::AltModifier;

   217 

   218     return result;

   219 }

   220 

   221 static void mapS60MouseEventTypeToQt(QEvent::Type *type, Qt::MouseButton *button, const TPointerEvent *pEvent)

   222 {

   223     switch (pEvent->iType) {

   224     case TPointerEvent::EButton1Down:

   225         *type = QEvent::MouseButtonPress;

   226         *button = Qt::LeftButton;

   227         break;

   228     case TPointerEvent::EButton1Up:

   229         *type = QEvent::MouseButtonRelease;

   230         *button = Qt::LeftButton;

   231         break;

   232     case TPointerEvent::EButton2Down:

   233         *type = QEvent::MouseButtonPress;

   234         *button = Qt::MidButton;

   235         break;

   236     case TPointerEvent::EButton2Up:

   237         *type = QEvent::MouseButtonRelease;

   238         *button = Qt::MidButton;

   239         break;

   240     case TPointerEvent::EButton3Down:

   241         *type = QEvent::MouseButtonPress;

   242         *button = Qt::RightButton;

   243         break;

   244     case TPointerEvent::EButton3Up:

   245         *type = QEvent::MouseButtonRelease;

   246         *button = Qt::RightButton;

   247         break;

   248     case TPointerEvent::EDrag:

   249         *type = QEvent::MouseMove;

   250         *button = Qt::NoButton;

   251         break;

   252     case TPointerEvent::EMove:

   253         // Qt makes no distinction between move and drag

   254         *type = QEvent::MouseMove;

   255         *button = Qt::NoButton;

   256         break;

   257     default:

   258         *type = QEvent::None;

   259         *button = Qt::NoButton;

   260         break;

   261     }

   262     if (pEvent->iModifiers & EModifierDoubleClick){

   263         *type = QEvent::MouseButtonDblClick;

   264     }

   265 

   266     if (*type == QEvent::MouseButtonPress || *type == QEvent::MouseButtonDblClick)

   267         QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons | (*button);

   268     else if (*type == QEvent::MouseButtonRelease)

   269         QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons &(~(*button));

   270 

   271     QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons & Qt::MouseButtonMask;

   272 }

   273 

   274 //### Can be replaced with CAknLongTapDetector if animation is required.

   275 //NOTE: if CAknLongTapDetector is used make sure it gets variated out of 3.1 and 3.2,.

   276 //also MLongTapObserver needs to be changed to MAknLongTapDetectorCallBack if CAknLongTapDetector is used.

   277 class QLongTapTimer : public CTimer

   278 {

   279 public:

   280     static QLongTapTimer* NewL(QAbstractLongTapObserver *observer);

   281     QLongTapTimer(QAbstractLongTapObserver *observer);

   282     void ConstructL();

   283 public:

   284     void PointerEventL(const TPointerEvent &event);

   285     void RunL();

   286 protected:

   287 private:

   288     QAbstractLongTapObserver *m_observer;

   289     TPointerEvent m_event;

   290     QPoint m_pressedCoordinates;

   291     int m_dragDistance;

   292 };

   293 

   294 QLongTapTimer* QLongTapTimer::NewL(QAbstractLongTapObserver *observer)

   295 {

   296     QLongTapTimer* self = new QLongTapTimer(observer);

   297     self->ConstructL();

   298     return self;

   299 }

   300 void QLongTapTimer::ConstructL()

   301 {

   302     CTimer::ConstructL();

   303 }

   304 

   305 QLongTapTimer::QLongTapTimer(QAbstractLongTapObserver *observer):CTimer(CActive::EPriorityHigh)

   306 {

   307     m_observer = observer;

   308     m_dragDistance = qApp->startDragDistance();

   309     CActiveScheduler::Add(this);

   310 }

   311 

   312 void QLongTapTimer::PointerEventL(const TPointerEvent& event)

   313 {

   314     if ( event.iType == TPointerEvent::EDrag || event.iType == TPointerEvent::EButtonRepeat)

   315     {

   316         QPoint diff(QPoint(event.iPosition.iX,event.iPosition.iY) - m_pressedCoordinates);

   317         if (diff.manhattanLength() < m_dragDistance)

   318             return;

   319     }

   320     Cancel();

   321     m_event = event;

   322     if (event.iType == TPointerEvent::EButton1Down)

   323     {

   324         m_pressedCoordinates = QPoint(event.iPosition.iX,event.iPosition.iY);

   325         // must be same as KLongTapDelay in aknlongtapdetector.h

   326         After(800000);

   327     }

   328 }

   329 void QLongTapTimer::RunL()

   330 {

   331     if (m_observer)

   332         m_observer->HandleLongTapEventL(m_event.iPosition, m_event.iParentPosition);

   333 }

   334 

   335 QSymbianControl::QSymbianControl(QWidget *w)

   336     : CCoeControl()

   337     , qwidget(w)

   338     , m_longTapDetector(0)

   339     , m_ignoreFocusChanged(0)

   340     , m_symbianPopupIsOpen(0)

   341 {

   342 }

   343 

   344 void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)

   345 {

   346     if (!desktop)

   347     {

   348         if (isWindowOwning or !qwidget->parentWidget())

   349             CreateWindowL(S60->windowGroup());

   350         else

   351             /**

   352              * TODO: in order to avoid creating windows for all ancestors of

   353              * this widget up to the root window, the parameter passed to

   354              * CreateWindowL should be

   355              * qwidget->parentWidget()->effectiveWinId().  However, if we do

   356              * this, then we need to take care of re-parenting when a window

   357              * is created for a widget between this one and the root window.

   358              */

   359             CreateWindowL(qwidget->parentWidget()->winId());

   360 

   361         // Necessary in order to be able to track the activation status of

   362         // the control's window

   363         qwidget->d_func()->createExtra();

   364 

   365         SetFocusing(true);

   366         m_longTapDetector = QLongTapTimer::NewL(this);

   367 

   368         DrawableWindow()->SetPointerGrab(ETrue);

   369     }

   370 }

   371 

   372 QSymbianControl::~QSymbianControl()

   373 {

   374     if (S60->curWin == this)

   375         S60->curWin = 0;

   376     if (!QApplicationPrivate::is_app_closing) {

   377         QT_TRY {

   378             setFocusSafely(false);

   379         } QT_CATCH(const std::exception&) {

   380             // ignore exceptions, nothing can be done

   381         }

   382     }

   383     S60->appUi()->RemoveFromStack(this);

   384     delete m_longTapDetector;

   385 }

   386 

   387 void QSymbianControl::setWidget(QWidget *w)

   388 {

   389     qwidget = w;

   390 }

   391 void QSymbianControl::HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation )

   392 {

   393     QWidget *alienWidget;

   394     QPoint widgetPos = QPoint(aPenEventLocation.iX, aPenEventLocation.iY);

   395     QPoint globalPos = QPoint(aPenEventScreenLocation.iX,aPenEventScreenLocation.iY);

   396     alienWidget = qwidget->childAt(widgetPos);

   397     if (!alienWidget)

   398         alienWidget = qwidget;

   399 

   400 #if !defined(QT_NO_CONTEXTMENU)

   401     QContextMenuEvent contextMenuEvent(QContextMenuEvent::Mouse, widgetPos, globalPos, Qt::NoModifier);

   402     qt_sendSpontaneousEvent(alienWidget, &contextMenuEvent);

   403 #endif

   404 }

   405 

   406 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

   407 void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent *event)

   408 {

   409     QApplicationPrivate *d = QApplicationPrivate::instance();

   410 

   411     QRect screenGeometry = qApp->desktop()->screenGeometry(qwidget);

   412 

   413     while (d->appAllTouchPoints.count() <= event->PointerNumber())

   414         d->appAllTouchPoints.append(QTouchEvent::TouchPoint(d->appAllTouchPoints.count()));

   415 

   416     Qt::TouchPointStates allStates = 0;

   417     for (int i = 0; i < d->appAllTouchPoints.count(); ++i) {

   418         QTouchEvent::TouchPoint &touchPoint = d->appAllTouchPoints[i];

   419 

   420         if (touchPoint.id() == event->PointerNumber()) {

   421             Qt::TouchPointStates state;

   422             switch (event->iType) {

   423             case TPointerEvent::EButton1Down:

   424             case TPointerEvent::EEnterHighPressure:

   425                 state = Qt::TouchPointPressed;

   426                 break;

   427             case TPointerEvent::EButton1Up:

   428             case TPointerEvent::EExitCloseProximity:

   429                 state = Qt::TouchPointReleased;

   430                 break;

   431             case TPointerEvent::EDrag:

   432                 state = Qt::TouchPointMoved;

   433                 break;

   434             default:

   435                 // how likely is this to happen?

   436                 state = Qt::TouchPointStationary;

   437                 break;

   438             }

   439             if (event->PointerNumber() == 0)

   440                 state |= Qt::TouchPointPrimary;

   441             touchPoint.setState(state);

   442 

   443             QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));

   444             touchPoint.setScreenPos(screenPos);

   445             touchPoint.setNormalizedPos(QPointF(screenPos.x() / screenGeometry.width(),

   446                                                 screenPos.y() / screenGeometry.height()));

   447 

   448             touchPoint.setPressure(event->Pressure() / qreal(d->maxTouchPressure));

   449         } else if (touchPoint.state() != Qt::TouchPointReleased) {

   450             // all other active touch points should be marked as stationary

   451             touchPoint.setState(Qt::TouchPointStationary);

   452         }

   453 

   454         allStates |= touchPoint.state();

   455     }

   456 

   457     if ((allStates & Qt::TouchPointStateMask) == Qt::TouchPointReleased) {

   458         // all touch points released

   459         d->appAllTouchPoints.clear();

   460     }

   461 

   462     QApplicationPrivate::translateRawTouchEvent(qwidget,

   463                                                 QTouchEvent::TouchScreen,

   464                                                 d->appAllTouchPoints);

   465 }

   466 #endif

   467 

   468 void QSymbianControl::HandlePointerEventL(const TPointerEvent& pEvent)

   469 {

   470 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

   471     if (pEvent.IsAdvancedPointerEvent()) {

   472         const TAdvancedPointerEvent *advancedPointerEvent = pEvent.AdvancedPointerEvent();

   473         translateAdvancedPointerEvent(advancedPointerEvent);

   474         if (advancedPointerEvent->PointerNumber() != 0) {

   475             // only send mouse events for the first touch point

   476             return;

   477         }

   478     }

   479 #endif

   480 

   481     m_longTapDetector->PointerEventL(pEvent);

   482     QT_TRYCATCH_LEAVING(HandlePointerEvent(pEvent));

   483 }

   484 

   485 void QSymbianControl::HandlePointerEvent(const TPointerEvent& pEvent)

   486 {

   487     QMouseEvent::Type type;

   488     Qt::MouseButton button;

   489     mapS60MouseEventTypeToQt(&type, &button, &pEvent);

   490     Qt::KeyboardModifiers modifiers = mapToQtModifiers(pEvent.iModifiers);

   491 

   492     QPoint widgetPos = QPoint(pEvent.iPosition.iX, pEvent.iPosition.iY);

   493     TPoint controlScreenPos = PositionRelativeToScreen();

   494     QPoint globalPos = QPoint(controlScreenPos.iX, controlScreenPos.iY) + widgetPos;

   495     S60->lastCursorPos = globalPos;

   496     S60->lastPointerEventPos = widgetPos;

   497 

   498     QWidget *mouseGrabber = QWidget::mouseGrabber();

   499 

   500     QWidget *popupWidget = qApp->activePopupWidget();

   501     QWidget *popupReceiver = 0;

   502     if (popupWidget) {

   503         QWidget *popupChild = popupWidget->childAt(popupWidget->mapFromGlobal(globalPos));

   504         popupReceiver = popupChild ? popupChild : popupWidget;

   505     }

   506 

   507     if (mouseGrabber) {

   508         if (popupReceiver) {

   509             sendMouseEvent(popupReceiver, type, globalPos, button, modifiers);

   510         } else {

   511             sendMouseEvent(mouseGrabber, type, globalPos, button, modifiers);

   512         }

   513         // No Enter/Leave events in grabbing mode.

   514         return;

   515     }

   516 

   517     QWidget *widgetUnderPointer = qwidget->childAt(widgetPos);

   518     if (!widgetUnderPointer)

   519         widgetUnderPointer = qwidget;

   520 

   521     QApplicationPrivate::dispatchEnterLeave(widgetUnderPointer, S60->lastPointerEventTarget);

   522     S60->lastPointerEventTarget = widgetUnderPointer;

   523 

   524     QWidget *receiver;

   525     if (!popupReceiver && S60->mousePressTarget && type != QEvent::MouseButtonPress) {

   526         receiver = S60->mousePressTarget;

   527         if (type == QEvent::MouseButtonRelease)

   528             S60->mousePressTarget = 0;

   529     } else {

   530         receiver = popupReceiver ? popupReceiver : widgetUnderPointer;

   531         if (type == QEvent::MouseButtonPress)

   532             S60->mousePressTarget = receiver;

   533     }

   534 

   535 #if !defined(QT_NO_CURSOR) && !defined(Q_SYMBIAN_FIXED_POINTER_CURSORS)

   536     if (S60->brokenPointerCursors)

   537         qt_symbian_move_cursor_sprite();

   538 #endif

   539 

   540     sendMouseEvent(receiver, type, globalPos, button, modifiers);

   541 }

   542 

   543 #ifdef Q_WS_S60

   544 void QSymbianControl::HandleStatusPaneSizeChange()

   545 {

   546     QS60MainAppUi *s60AppUi = static_cast<QS60MainAppUi *>(S60->appUi());

   547     s60AppUi->HandleStatusPaneSizeChange();

   548 }

   549 #endif

   550 

   551 void QSymbianControl::sendMouseEvent(

   552         QWidget *receiver,

   553         QEvent::Type type,

   554         const QPoint &globalPos,

   555         Qt::MouseButton button,

   556         Qt::KeyboardModifiers modifiers)

   557 {

   558     Q_ASSERT(receiver);

   559     QMouseEvent mEvent(type, receiver->mapFromGlobal(globalPos), globalPos,

   560         button, QApplicationPrivate::mouse_buttons, modifiers);

   561     QEventDispatcherS60 *dispatcher;

   562     // It is theoretically possible for someone to install a different event dispatcher.

   563     if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(receiver->d_func()->threadData->eventDispatcher)) != 0) {

   564         if (dispatcher->excludeUserInputEvents()) {

   565             dispatcher->saveInputEvent(this, receiver, new QMouseEvent(mEvent));

   566             return;

   567         }

   568     }

   569 

   570     sendMouseEvent(receiver, &mEvent);

   571 }

   572 

   573 bool QSymbianControl::sendMouseEvent(QWidget *widget, QMouseEvent *mEvent)

   574 {

   575     return qt_sendSpontaneousEvent(widget, mEvent);

   576 }

   577 

   578 TKeyResponse QSymbianControl::OfferKeyEventL(const TKeyEvent& keyEvent, TEventCode type)

   579 {

   580     TKeyResponse r = EKeyWasNotConsumed;

   581     QT_TRYCATCH_LEAVING(r = OfferKeyEvent(keyEvent, type));

   582     return r;

   583 }

   584 

   585 TKeyResponse QSymbianControl::OfferKeyEvent(const TKeyEvent& keyEvent, TEventCode type)

   586 {

   587     switch (type) {

   588     //case EEventKeyDown: // <-- Intentionally left out. See below.

   589     case EEventKeyUp:

   590     case EEventKey:

   591     {

   592         // S60 has a confusing way of delivering key events. There are three types of

   593         // events: EKeyEvent, EKeyEventDown and EKeyEventUp. When a key is pressed, the

   594         // two first events are generated. When releasing the key, the last one is

   595         // generated.

   596         // Because S60 does not generate keysyms for EKeyEventDown and EKeyEventUp events,

   597         // we need to do some special tricks to map it to the Qt way. First, we completely

   598         // discard EKeyEventDown events, since they are redundant. Second, since

   599         // EKeyEventUp does not give us a keysym, we need to cache the keysyms from

   600         // the EKeyEvent events. This is what resolveS60ScanCode does.

   601 

   602 

   603         // ### hackish way to send Qt application to background when pressing right softkey

   604         /*

   605         if( keyEvent.iScanCode == EStdKeyDevice1 ) {

   606             S60->window_group->SetOrdinalPosition(-1);

   607             qApp->setActiveWindow(0);

   608             return EKeyWasNotConsumed;

   609         }

   610         */

   611 

   612         TUint s60Keysym = QApplicationPrivate::resolveS60ScanCode(keyEvent.iScanCode,

   613                 keyEvent.iCode);

   614         int keyCode;

   615         if (s60Keysym == EKeyNull){ //some key events have 0 in iCode, for them iScanCode should be used

   616             keyCode = qt_keymapper_private()->mapS60ScanCodesToQt(keyEvent.iScanCode);

   617         } else if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {

   618             // Normal characters keys.

   619             keyCode = s60Keysym;

   620         } else {

   621             // Special S60 keys.

   622             keyCode = qt_keymapper_private()->mapS60KeyToQt(s60Keysym);

   623         }

   624 

   625 #ifndef QT_NO_CURSOR

   626         if (S60->mouseInteractionEnabled && S60->virtualMouseRequired) {

   627             //translate keys to pointer

   628             if (keyCode >= Qt::Key_Left && keyCode <= Qt::Key_Down || keyCode == Qt::Key_Select) {

   629                 /*Explanation about virtualMouseAccel:

   630                  Tapping an arrow key allows precise pixel positioning

   631                  Holding an arrow key down, acceleration is applied to allow cursor

   632                  to be quickly moved to another part of the screen by key repeats.

   633                  */

   634                 if (S60->virtualMouseLastKey == keyCode) {

   635                     S60->virtualMouseAccel *= 2;

   636                     if (S60->virtualMouseAccel > S60->virtualMouseMaxAccel)

   637                         S60->virtualMouseAccel = S60->virtualMouseMaxAccel;

   638                 }

   639                 else

   640                     S60->virtualMouseAccel = 1;

   641                 S60->virtualMouseLastKey = keyCode;

   642 

   643                 QPoint pos = QCursor::pos();

   644                 TPointerEvent fakeEvent;

   645                 TInt x = pos.x();

   646                 TInt y = pos.y();

   647                 if (type == EEventKeyUp) {

   648                     if (keyCode == Qt::Key_Select)

   649                         fakeEvent.iType = TPointerEvent::EButton1Up;

   650                     S60->virtualMouseAccel = 1;

   651                     S60->virtualMouseLastKey = 0;

   652                     switch (keyCode) {

   653                     case Qt::Key_Left:

   654                         S60->virtualMousePressedKeys &= ~QS60Data::Left;

   655                         break;

   656                     case Qt::Key_Right:

   657                         S60->virtualMousePressedKeys &= ~QS60Data::Right;

   658                         break;

   659                     case Qt::Key_Up:

   660                         S60->virtualMousePressedKeys &= ~QS60Data::Up;

   661                         break;

   662                     case Qt::Key_Down:

   663                         S60->virtualMousePressedKeys &= ~QS60Data::Down;

   664                         break;

   665                     case Qt::Key_Select:

   666                         S60->virtualMousePressedKeys &= ~QS60Data::Select;

   667                         break;

   668                     }

   669                 }

   670                 else if (type == EEventKey) {

   671                     switch (keyCode) {

   672                     case Qt::Key_Left:

   673                         S60->virtualMousePressedKeys |= QS60Data::Left;

   674                         x -= S60->virtualMouseAccel;

   675                         fakeEvent.iType = TPointerEvent::EMove;

   676                         break;

   677                     case Qt::Key_Right:

   678                         S60->virtualMousePressedKeys |= QS60Data::Right;

   679                         x += S60->virtualMouseAccel;

   680                         fakeEvent.iType = TPointerEvent::EMove;

   681                         break;

   682                     case Qt::Key_Up:

   683                         S60->virtualMousePressedKeys |= QS60Data::Up;

   684                         y -= S60->virtualMouseAccel;

   685                         fakeEvent.iType = TPointerEvent::EMove;

   686                         break;

   687                     case Qt::Key_Down:

   688                         S60->virtualMousePressedKeys |= QS60Data::Down;

   689                         y += S60->virtualMouseAccel;

   690                         fakeEvent.iType = TPointerEvent::EMove;

   691                         break;

   692                     case Qt::Key_Select:

   693                         // Platform bug. If you start pressing several keys simultaneously (for

   694                         // example for drag'n'drop), Symbian starts producing spurious up and

   695                         // down messages for some keys. Therefore, make sure we have a clean slate

   696                         // of pressed keys before starting a new button press.

   697                         if (S60->virtualMousePressedKeys != 0) {

   698                             S60->virtualMousePressedKeys |= QS60Data::Select;

   699                             return EKeyWasConsumed;

   700                         } else {

   701                             S60->virtualMousePressedKeys |= QS60Data::Select;

   702                             fakeEvent.iType = TPointerEvent::EButton1Down;

   703                         }

   704                         break;

   705                     }

   706                 }

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

   708                 if (x < 0)

   709                     x = 0;

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

   711                     x = S60->screenWidthInPixels - 1;

   712                 if (y < 0)

   713                     y = 0;

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

   715                     y = S60->screenHeightInPixels - 1;

   716                 TPoint epos(x, y);

   717                 TPoint cpos = epos - PositionRelativeToScreen();

   718                 fakeEvent.iModifiers = keyEvent.iModifiers;

   719                 fakeEvent.iPosition = cpos;

   720                 fakeEvent.iParentPosition = epos;

   721                 HandlePointerEvent(fakeEvent);

   722                 return EKeyWasConsumed;

   723             }

   724             else {

   725                 S60->virtualMouseLastKey = keyCode;

   726                 S60->virtualMouseAccel = 1;

   727             }

   728         }

   729 #endif

   730 

   731         Qt::KeyboardModifiers mods = mapToQtModifiers(keyEvent.iModifiers);

   732         QKeyEventEx qKeyEvent(type == EEventKeyUp ? QEvent::KeyRelease : QEvent::KeyPress, keyCode,

   733                 mods, qt_keymapper_private()->translateKeyEvent(keyCode, mods),

   734                 (keyEvent.iRepeats != 0), 1, keyEvent.iScanCode, s60Keysym, keyEvent.iModifiers);

   735 //        WId wid = reinterpret_cast<RWindowGroup *>(keyEvent.Handle())->Child();

   736 //        if (!wid)

   737 //             Could happen if window isn't shown yet.

   738 //            return EKeyWasNotConsumed;

   739         QWidget *widget;

   740         widget = QWidget::keyboardGrabber();

   741         if (!widget) {

   742             if (QApplicationPrivate::popupWidgets != 0) {

   743                 widget = QApplication::activePopupWidget()->focusWidget();

   744                 if (!widget) {

   745                     widget = QApplication::activePopupWidget();

   746                 }

   747             } else {

   748                 widget = QApplicationPrivate::focus_widget;

   749                 if (!widget) {

   750                     widget = qwidget;

   751                 }

   752             }

   753         }

   754 

   755         QEventDispatcherS60 *dispatcher;

   756         // It is theoretically possible for someone to install a different event dispatcher.

   757         if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(widget->d_func()->threadData->eventDispatcher)) != 0) {

   758             if (dispatcher->excludeUserInputEvents()) {

   759                 dispatcher->saveInputEvent(this, widget, new QKeyEventEx(qKeyEvent));

   760                 return EKeyWasConsumed;

   761             }

   762         }

   763         return sendKeyEvent(widget, &qKeyEvent);

   764     }

   765     }

   766     return EKeyWasNotConsumed;

   767 }

   768 

   769 void QSymbianControl::sendInputEvent(QWidget *widget, QInputEvent *inputEvent)

   770 {

   771     switch (inputEvent->type()) {

   772     case QEvent::KeyPress:

   773     case QEvent::KeyRelease:

   774         sendKeyEvent(widget, static_cast<QKeyEvent *>(inputEvent));

   775         break;

   776     case QEvent::MouseButtonDblClick:

   777     case QEvent::MouseButtonPress:

   778     case QEvent::MouseButtonRelease:

   779     case QEvent::MouseMove:

   780         sendMouseEvent(widget, static_cast<QMouseEvent *>(inputEvent));

   781         break;

   782     default:

   783         // Shouldn't get here.

   784         Q_ASSERT_X(0 == 1, "QSymbianControl::sendInputEvent()", "inputEvent->type() is unknown");

   785         break;

   786     }

   787 }

   788 

   789 TKeyResponse QSymbianControl::sendKeyEvent(QWidget *widget, QKeyEvent *keyEvent)

   790 {

   791 #if !defined(QT_NO_IM) && defined(Q_WS_S60)

   792     if (widget && widget->isEnabled() && widget->testAttribute(Qt::WA_InputMethodEnabled)) {

   793         QInputContext *qic = widget->inputContext();

   794         if (qic && qic->filterEvent(keyEvent))

   795             return EKeyWasConsumed;

   796     }

   797 #endif // !defined(QT_NO_IM) && defined(Q_WS_S60)

   798 

   799     if (widget && qt_sendSpontaneousEvent(widget, keyEvent))

   800         if (keyEvent->isAccepted())

   801             return EKeyWasConsumed;

   802 

   803     return EKeyWasNotConsumed;

   804 }

   805 

   806 #if !defined(QT_NO_IM) && defined(Q_WS_S60)

   807 TCoeInputCapabilities QSymbianControl::InputCapabilities() const

   808 {

   809     QWidget *w = 0;

   810 

   811     if (qwidget->hasFocus())

   812         w = qwidget;

   813     else

   814         w = qwidget->focusWidget();

   815 

   816     QCoeFepInputContext *ic;

   817     if (w && w->isEnabled() && w->testAttribute(Qt::WA_InputMethodEnabled)

   818             && (ic = qobject_cast<QCoeFepInputContext *>(w->inputContext()))) {

   819         return ic->inputCapabilities();

   820     } else {

   821         return TCoeInputCapabilities(TCoeInputCapabilities::ENone, 0, 0);

   822     }

   823 }

   824 #endif

   825 

   826 void QSymbianControl::Draw(const TRect& controlRect) const

   827 {

   828     // Set flag to avoid calling DrawNow in window surface

   829     QWidget *window = qwidget->window();

   830     Q_ASSERT(window);

   831     QTLWExtra *topExtra = window->d_func()->maybeTopData();

   832     Q_ASSERT(topExtra);

   833     if (!topExtra->inExpose) {

   834         topExtra->inExpose = true;

   835         QRect exposeRect = qt_TRect2QRect(controlRect);

   836         qwidget->d_func()->syncBackingStore(exposeRect);

   837         topExtra->inExpose = false;

   838     }

   839 

   840     QWindowSurface *surface = qwidget->windowSurface();

   841     QPaintEngine *engine = surface ? surface->paintDevice()->paintEngine() : NULL;

   842 

   843     if (!engine)

   844         return;

   845 

   846     const bool sendNativePaintEvents = qwidget->d_func()->extraData()->receiveNativePaintEvents;

   847     if (sendNativePaintEvents) {

   848         const QRect r = qt_TRect2QRect(controlRect);

   849         QMetaObject::invokeMethod(qwidget, "beginNativePaintEvent", Qt::DirectConnection, Q_ARG(QRect, r));

   850     }

   851 

   852     // Map source rectangle into coordinates of the backing store.

   853     const QPoint controlBase(controlRect.iTl.iX, controlRect.iTl.iY);

   854     const QPoint backingStoreBase = qwidget->mapTo(qwidget->window(), controlBase);

   855     const TRect backingStoreRect(TPoint(backingStoreBase.x(), backingStoreBase.y()), controlRect.Size());

   856 

   857     if (engine->type() == QPaintEngine::Raster) {

   858         QS60WindowSurface *s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());

   859         CFbsBitmap *bitmap = s60Surface->symbianBitmap();

   860         CWindowGc &gc = SystemGc();

   861 

   862         switch(qwidget->d_func()->extraData()->nativePaintMode) {

   863         case QWExtra::Disable:

   864             // Do nothing

   865             break;

   866 

   867         case QWExtra::Blit:

   868             if (qwidget->d_func()->isOpaque)

   869                 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

   870             gc.BitBlt(controlRect.iTl, bitmap, backingStoreRect);

   871             break;

   872 

   873         case QWExtra::ZeroFill:

   874             if (Window().DisplayMode() == EColor16MA) {

   875                 gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   876                 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

   877                 gc.SetBrushColor(TRgb::Color16MA(0));

   878                 gc.Clear(controlRect);

   879             } else {

   880                 gc.SetBrushColor(TRgb(0x000000));

   881                 gc.Clear(controlRect);

   882             };

   883             break;

   884 

   885         default:

   886             Q_ASSERT(false);

   887         }

   888     }

   889 

   890     if (sendNativePaintEvents) {

   891         const QRect r = qt_TRect2QRect(controlRect);

   892         // The draw ops aren't actually sent to WSERV until the graphics

   893         // context is deactivated, which happens in the function calling

   894         // this one.  We therefore delay the delivery of endNativePaintEvent,

   895         // to ensure that drawing has completed by the time the widget

   896         // receives the event.  Note that, if the widget needs to ensure

   897         // that the draw ops have actually been executed into the output

   898         // framebuffer, a call to RWsSession::Flush is required in the

   899         // endNativePaintEvent implementation.

   900         QMetaObject::invokeMethod(qwidget, "endNativePaintEvent", Qt::QueuedConnection, Q_ARG(QRect, r));

   901     }

   902 }

   903 

   904 void QSymbianControl::SizeChanged()

   905 {

   906     CCoeControl::SizeChanged();

   907 

   908     QSize oldSize = qwidget->size();

   909     QSize newSize(Size().iWidth, Size().iHeight);

   910 

   911     if (oldSize != newSize) {

   912         QRect cr = qwidget->geometry();

   913         cr.setSize(newSize);

   914         qwidget->data->crect = cr;

   915         if (qwidget->isVisible()) {

   916             QTLWExtra *tlwExtra = qwidget->d_func()->maybeTopData();

   917             bool slowResize = qgetenv("QT_SLOW_TOPLEVEL_RESIZE").toInt();

   918             if (!slowResize && tlwExtra)

   919                 tlwExtra->inTopLevelResize = true;

   920             QResizeEvent e(newSize, oldSize);

   921             qt_sendSpontaneousEvent(qwidget, &e);

   922             if (!qwidget->testAttribute(Qt::WA_StaticContents))

   923                 qwidget->d_func()->syncBackingStore();

   924             if (!slowResize && tlwExtra)

   925                 tlwExtra->inTopLevelResize = false;

   926         }

   927     }

   928 

   929     // CCoeControl::SetExtent calls SizeChanged, but does not call

   930     // PositionChanged, so we call it here to ensure that the widget's

   931     // position is updated.

   932     PositionChanged();

   933 }

   934 

   935 void QSymbianControl::PositionChanged()

   936 {

   937     CCoeControl::PositionChanged();

   938 

   939     QPoint oldPos = qwidget->geometry().topLeft();

   940     QPoint newPos(Position().iX, Position().iY);

   941 

   942     if (oldPos != newPos) {

   943         QRect cr = qwidget->geometry();

   944         cr.moveTopLeft(newPos);

   945         qwidget->data->crect = cr;

   946         QTLWExtra *top = qwidget->d_func()->maybeTopData();

   947         if (top && (qwidget->windowState() & (~Qt::WindowActive)) == Qt::WindowNoState)

   948             top->normalGeometry.moveTopLeft(newPos);

   949         if (qwidget->isVisible()) {

   950             QMoveEvent e(newPos, oldPos);

   951             qt_sendSpontaneousEvent(qwidget, &e);

   952         } else {

   953             QMoveEvent * e = new QMoveEvent(newPos, oldPos);

   954             QApplication::postEvent(qwidget, e);

   955         }

   956     }

   957 }

   958 

   959 void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)

   960 {

   961     if (m_ignoreFocusChanged || (qwidget->windowType() & Qt::WindowType_Mask) == Qt::Desktop)

   962         return;

   963 

   964     // Popups never get focused, but still receive the FocusChanged when they are hidden.

   965     if (QApplicationPrivate::popupWidgets != 0

   966             || (qwidget->windowType() & Qt::Popup) == Qt::Popup)

   967         return;

   968 

   969     if (IsFocused() && IsVisible()) {

   970         if (m_symbianPopupIsOpen) {

   971             QWidget *fw = QApplication::focusWidget();

   972             if (fw) {

   973                 QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason);

   974                 QCoreApplication::sendEvent(fw, &event);

   975             }

   976             m_symbianPopupIsOpen = false;

   977         }

   978 

   979         QApplication::setActiveWindow(qwidget->window());

   980         qwidget->d_func()->setWindowIcon_sys(true);

   981         qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());

   982 #ifdef Q_WS_S60

   983         // If widget is fullscreen/minimized, hide status pane and button container otherwise show them.

   984         CEikStatusPane *statusPane = S60->statusPane();

   985         CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();

   986         TBool visible = !(qwidget->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));

   987         if (statusPane)

   988             statusPane->MakeVisible(visible);

   989         if (buttonGroup) {

   990             // Visibility

   991             const TBool isFullscreen = qwidget->windowState() & Qt::WindowFullScreen;

   992             const TBool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;

   993             buttonGroup->MakeVisible(visible || (isFullscreen && cbaVisibilityHint));

   994 

   995             // Responsiviness

   996             CEikCba *cba = static_cast<CEikCba *>( buttonGroup->ButtonGroup() ); // downcast from MEikButtonGroup

   997             TUint cbaFlags = cba->ButtonGroupFlags();

   998             if(qwidget->windowFlags() & Qt::WindowSoftkeysRespondHint)

   999                 cbaFlags |= EAknCBAFlagRespondWhenInvisible;

  1000             else

  1001                 cbaFlags &= ~EAknCBAFlagRespondWhenInvisible;

  1002             cba->SetButtonGroupFlags(cbaFlags);

  1003         }

  1004 #endif

  1005     } else if (QApplication::activeWindow() == qwidget->window()) {

  1006         if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog() || S60->menuBeingConstructed) {

  1007             QWidget *fw = QApplication::focusWidget();

  1008             if (fw) {

  1009                 QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);

  1010                 QCoreApplication::sendEvent(fw, &event);

  1011             }

  1012             m_symbianPopupIsOpen = true;

  1013             return;

  1014         }

  1015 

  1016         QApplication::setActiveWindow(0);

  1017     }

  1018     // else { We don't touch the active window unless we were explicitly activated or deactivated }

  1019 }

  1020 

  1021 void QSymbianControl::handleClientAreaChange()

  1022 {

  1023     const bool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;

  1024     if (qwidget->isFullScreen() && !cbaVisibilityHint) {

  1025         SetExtentToWholeScreen();

  1026     } else if (qwidget->isMaximized() || (qwidget->isFullScreen() && cbaVisibilityHint)) {

  1027         TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();

  1028         SetExtent(r.iTl, r.Size());

  1029     } else if (!qwidget->isMinimized()) { // Normal geometry

  1030         if (!qwidget->testAttribute(Qt::WA_Resized)) {

  1031             qwidget->adjustSize();

  1032             qwidget->setAttribute(Qt::WA_Resized, false); //not a user resize

  1033         }

  1034         if (!qwidget->testAttribute(Qt::WA_Moved) && qwidget->windowType() != Qt::Dialog) {

  1035             TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();

  1036             SetPosition(r.iTl);

  1037             qwidget->setAttribute(Qt::WA_Moved, false); // not really an explicit position

  1038         }

  1039     }

  1040 }

  1041 

  1042 void QSymbianControl::HandleResourceChange(int resourceType)

  1043 {

  1044     switch (resourceType) {

  1045     case KInternalStatusPaneChange:

  1046         handleClientAreaChange();

  1047         if (IsFocused() && IsVisible()) {

  1048             qwidget->d_func()->setWindowIcon_sys(true);

  1049             qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());

  1050         }

  1051         break;

  1052     case KUidValueCoeFontChangeEvent:

  1053         // font change event

  1054         break;

  1055 #ifdef Q_WS_S60

  1056     case KEikDynamicLayoutVariantSwitch:

  1057     {

  1058         handleClientAreaChange();

  1059         break;

  1060     }

  1061 #endif

  1062     default:

  1063         break;

  1064     }

  1065 

  1066     CCoeControl::HandleResourceChange(resourceType);

  1067 

  1068 }

  1069 void QSymbianControl::CancelLongTapTimer()

  1070 {

  1071     m_longTapDetector->Cancel();

  1072 }

  1073 

  1074 TTypeUid::Ptr QSymbianControl::MopSupplyObject(TTypeUid id)

  1075 {

  1076     if (id.iUid == ETypeId)

  1077         return id.MakePtr(this);

  1078 

  1079     return CCoeControl::MopSupplyObject(id);

  1080 }

  1081 

  1082 void QSymbianControl::setFocusSafely(bool focus)

  1083 {

  1084     // The stack hack in here is very unfortunate, but it is the only way to ensure proper

  1085     // focus in Symbian. If this is not executed, the control which happens to be on

  1086     // the top of the stack may randomly be assigned focus by Symbian, for example

  1087     // when creating new windows (specifically in CCoeAppUi::HandleStackChanged()).

  1088     if (focus) {

  1089         S60->appUi()->RemoveFromStack(this);

  1090         // Symbian doesn't automatically remove focus from the last focused control, so we need to

  1091         // remember it and clear focus ourselves.

  1092         if (lastFocusedControl && lastFocusedControl != this)

  1093             lastFocusedControl->SetFocus(false);

  1094         QT_TRAP_THROWING(S60->appUi()->AddToStackL(this,

  1095                 ECoeStackPriorityDefault + 1, ECoeStackFlagStandard)); // Note the + 1

  1096         lastFocusedControl = this;

  1097         this->SetFocus(true);

  1098     } else {

  1099         S60->appUi()->RemoveFromStack(this);

  1100         QT_TRAP_THROWING(S60->appUi()->AddToStackL(this,

  1101                 ECoeStackPriorityDefault, ECoeStackFlagStandard));

  1102         if(this == lastFocusedControl)

  1103             lastFocusedControl = 0;

  1104         this->SetFocus(false);

  1105     }

  1106 }

  1107 

  1108 /*!

  1109     \typedef QApplication::QS60MainApplicationFactory

  1110     \since 4.6

  1111 

  1112     This is a typedef for a pointer to a function with the following

  1113     signature:

  1114 

  1115     \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 47

  1116 

  1117     \sa QApplication::QApplication()

  1118 */

  1119 

  1120 /*!

  1121     \since 4.6

  1122 

  1123     Creates an application using the application factory given in

  1124     \a factory, and using \a argc command line arguments in \a argv.

  1125     \a factory can be leaving, but the error will be converted to a

  1126     standard exception.

  1127 

  1128     This function is only available on S60.

  1129 */

  1130 QApplication::QApplication(QApplication::QS60MainApplicationFactory factory, int &argc, char **argv)

  1131     : QCoreApplication(*new QApplicationPrivate(argc, argv, GuiClient))

  1132 {

  1133     Q_D(QApplication);

  1134     S60->s60ApplicationFactory = factory;

  1135     d->construct();