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 #endif

    77 

    78 #include "private/qstylesheetstyle_p.h"

    79 

    80 #include <hal.h>

    81 #include <hal_data.h>

    82 

    83 QT_BEGIN_NAMESPACE

    84 

    85 #if defined(QT_DEBUG)

    86 static bool        appNoGrab        = false;        // Grabbing enabled

    87 #endif

    88 static bool        app_do_modal        = false;        // modal mode

    89 Q_GLOBAL_STATIC(QS60Data, qt_s60Data);

    90 

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

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

    93 extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp

    94 

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

    96 

    97 QSymbianControl *QSymbianControl::lastFocusedControl = 0;

    98 

    99 QS60Data* qGlobalS60Data()

   100 {

   101     return qt_s60Data();

   102 }

   103 

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

   105 {

   106 #if defined(QT_DEBUG)

   107     return appNoGrab;

   108 #else

   109     return false;

   110 #endif

   111 }

   112 

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

   114 class QS60Beep : public CBase, public MMdaAudioToneObserver

   115 {

   116 public:

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

   118     void Play();

   119     ~QS60Beep();

   120 private:

   121     void ConstructL(TInt aFrequency,  TTimeIntervalMicroSeconds iDuration);

   122     void MatoPrepareComplete(TInt aError);

   123     void MatoPlayComplete(TInt aError);

   124 private:

   125     typedef enum

   126         {

   127         EBeepNotPrepared,

   128         EBeepPrepared,

   129         EBeepPlaying

   130         } TBeepState;

   131 private:

   132     CMdaAudioToneUtility* iToneUtil;

   133     TBeepState iState;

   134     TInt iFrequency;

   135     TTimeIntervalMicroSeconds iDuration;

   136 };

   137 

   138 static QS60Beep* qt_S60Beep = 0;

   139 

   140 QS60Beep::~QS60Beep()

   141 {

   142     if (iToneUtil) {

   143         switch (iState) {

   144         case EBeepPlaying:

   145             iToneUtil->CancelPlay();

   146             break;

   147         case EBeepNotPrepared:

   148             iToneUtil->CancelPrepare();

   149             break;

   150         }

   151     }

   152     delete iToneUtil;

   153 }

   154 

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

   156 {

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

   158     CleanupStack::PushL(self);

   159     self->ConstructL(aFrequency, aDuration);

   160     CleanupStack::Pop();

   161     return self;

   162 }

   163 

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

   165 {

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

   167     iState = EBeepNotPrepared;

   168     iFrequency = aFrequency;

   169     iDuration = aDuration;

   170     iToneUtil->PrepareToPlayTone(iFrequency, iDuration);

   171 }

   172 

   173 void QS60Beep::Play()

   174 {

   175     if (iState == EBeepPlaying) {

   176         iToneUtil->CancelPlay();

   177         iState = EBeepPrepared;

   178     }

   179 

   180     iToneUtil->Play();

   181     iState = EBeepPlaying;

   182 }

   183 

   184 void QS60Beep::MatoPrepareComplete(TInt aError)

   185 {

   186     if (aError == KErrNone) {

   187         iState = EBeepPrepared;

   188         Play();

   189     }

   190 }

   191 

   192 void QS60Beep::MatoPlayComplete(TInt aError)

   193 {

   194     Q_UNUSED(aError);

   195     iState = EBeepPrepared;

   196 }

   197 

   198 

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

   200 

   201 static Qt::KeyboardModifiers mapToQtModifiers(TUint s60Modifiers)

   202 {

   203     Qt::KeyboardModifiers result = Qt::NoModifier;

   204 

   205     if (s60Modifiers & EModifierKeypad)

   206         result |= Qt::KeypadModifier;

   207     if (s60Modifiers & EModifierShift || s60Modifiers & EModifierLeftShift

   208             || s60Modifiers & EModifierRightShift)

   209         result |= Qt::ShiftModifier;

   210     if (s60Modifiers & EModifierCtrl || s60Modifiers & EModifierLeftCtrl

   211             || s60Modifiers & EModifierRightCtrl)

   212         result |= Qt::ControlModifier;

   213     if (s60Modifiers & EModifierAlt || s60Modifiers & EModifierLeftAlt

   214             || s60Modifiers & EModifierRightAlt)

   215         result |= Qt::AltModifier;

   216 

   217     return result;

   218 }

   219 

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

   221 {

   222     switch (pEvent->iType) {

   223     case TPointerEvent::EButton1Down:

   224         *type = QEvent::MouseButtonPress;

   225         *button = Qt::LeftButton;

   226         break;

   227     case TPointerEvent::EButton1Up:

   228         *type = QEvent::MouseButtonRelease;

   229         *button = Qt::LeftButton;

   230         break;

   231     case TPointerEvent::EButton2Down:

   232         *type = QEvent::MouseButtonPress;

   233         *button = Qt::MidButton;

   234         break;

   235     case TPointerEvent::EButton2Up:

   236         *type = QEvent::MouseButtonRelease;

   237         *button = Qt::MidButton;

   238         break;

   239     case TPointerEvent::EButton3Down:

   240         *type = QEvent::MouseButtonPress;

   241         *button = Qt::RightButton;

   242         break;

   243     case TPointerEvent::EButton3Up:

   244         *type = QEvent::MouseButtonRelease;

   245         *button = Qt::RightButton;

   246         break;

   247     case TPointerEvent::EDrag:

   248         *type = QEvent::MouseMove;

   249         *button = Qt::NoButton;

   250         break;

   251     case TPointerEvent::EMove:

   252         // Qt makes no distinction between move and drag

   253         *type = QEvent::MouseMove;

   254         *button = Qt::NoButton;

   255         break;

   256     default:

   257         *type = QEvent::None;

   258         *button = Qt::NoButton;

   259         break;

   260     }

   261     if (pEvent->iModifiers & EModifierDoubleClick){

   262         *type = QEvent::MouseButtonDblClick;

   263     }

   264 

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

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

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

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

   269 

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

   271 }

   272 

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

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

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

   276 class QLongTapTimer : public CTimer

   277 {

   278 public:

   279     static QLongTapTimer* NewL(QAbstractLongTapObserver *observer);

   280     QLongTapTimer(QAbstractLongTapObserver *observer);

   281     void ConstructL();

   282 public:

   283     void PointerEventL(const TPointerEvent &event);

   284     void RunL();

   285 protected:

   286 private:

   287     QAbstractLongTapObserver *m_observer;

   288     TPointerEvent m_event;

   289     QPoint m_pressedCoordinates;

   290     int m_dragDistance;

   291 };

   292 

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

   294 {

   295     QLongTapTimer* self = new QLongTapTimer(observer);

   296     self->ConstructL();

   297     return self;

   298 }

   299 void QLongTapTimer::ConstructL()

   300 {

   301     CTimer::ConstructL();

   302 }

   303 

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

   305 {

   306     m_observer = observer;

   307     m_dragDistance = qApp->startDragDistance();

   308     CActiveScheduler::Add(this);

   309 }

   310 

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

   312 {

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

   314     {

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

   316         if (diff.manhattanLength() < m_dragDistance)

   317             return;

   318     }

   319     Cancel();

   320     m_event = event;

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

   322     {

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

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

   325         After(800000);

   326     }

   327 }

   328 void QLongTapTimer::RunL()

   329 {

   330     if (m_observer)

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

   332 }

   333 

   334 QSymbianControl::QSymbianControl(QWidget *w)

   335     : CCoeControl()

   336     , qwidget(w)

   337     , m_longTapDetector(0)

   338     , m_ignoreFocusChanged(0)

   339     , m_symbianPopupIsOpen(0)

   340 {

   341 }

   342 

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

   344 {

   345     if (!desktop)

   346     {

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

   348             CreateWindowL(S60->windowGroup());

   349         else

   350             /**

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

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

   353              * CreateWindowL should be

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

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

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

   357              */

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

   359 

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

   361         // the control's window

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

   363 

   364         SetFocusing(true);

   365         m_longTapDetector = QLongTapTimer::NewL(this);

   366 

   367         DrawableWindow()->SetPointerGrab(ETrue);

   368     }

   369 }

   370 

   371 QSymbianControl::~QSymbianControl()

   372 {

   373     if (S60->curWin == this)

   374         S60->curWin = 0;

   375     if (!QApplicationPrivate::is_app_closing)

   376         setFocusSafely(false);

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

   378     delete m_longTapDetector;

   379 }

   380 

   381 void QSymbianControl::setWidget(QWidget *w)

   382 {

   383     qwidget = w;

   384 }

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

   386 {

   387     QWidget *alienWidget;

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

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

   390     alienWidget = qwidget->childAt(widgetPos);

   391     if (!alienWidget)

   392         alienWidget = qwidget;

   393 

   394 #if !defined(QT_NO_CONTEXTMENU)

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

   396     qt_sendSpontaneousEvent(alienWidget, &contextMenuEvent);

   397 #endif

   398 }

   399 

   400 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

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

   402 {

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

   404 

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

   406 

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

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

   409 

   410     Qt::TouchPointStates allStates = 0;

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

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

   413 

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

   415             Qt::TouchPointStates state;

   416             switch (event->iType) {

   417             case TPointerEvent::EButton1Down:

   418             case TPointerEvent::EEnterHighPressure:

   419                 state = Qt::TouchPointPressed;

   420                 break;

   421             case TPointerEvent::EButton1Up:

   422             case TPointerEvent::EExitCloseProximity:

   423                 state = Qt::TouchPointReleased;

   424                 break;

   425             case TPointerEvent::EDrag:

   426                 state = Qt::TouchPointMoved;

   427                 break;

   428             default:

   429                 // how likely is this to happen?

   430                 state = Qt::TouchPointStationary;

   431                 break;

   432             }

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

   434                 state |= Qt::TouchPointPrimary;

   435             touchPoint.setState(state);

   436 

   437             QPointF screenPos = QPointF(event->iPosition.iX, event->iPosition.iY);

   438             touchPoint.setScreenPos(screenPos);

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

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

   441 

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

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

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

   445             touchPoint.setState(Qt::TouchPointStationary);

   446         }

   447 

   448         allStates |= touchPoint.state();

   449     }

   450 

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

   452         // all touch points released

   453         d->appAllTouchPoints.clear();

   454     }

   455 

   456     QApplicationPrivate::translateRawTouchEvent(qwidget,

   457                                                 QTouchEvent::TouchScreen,

   458                                                 d->appAllTouchPoints);

   459 }

   460 #endif

   461 

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

   463 {

   464 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

   465     if (pEvent.IsAdvancedPointerEvent()) {

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

   467         translateAdvancedPointerEvent(advancedPointerEvent);

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

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

   470             return;

   471         }

   472     }

   473 #endif

   474 

   475     m_longTapDetector->PointerEventL(pEvent);

   476     QT_TRYCATCH_LEAVING(HandlePointerEvent(pEvent));

   477 }

   478 

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

   480 {

   481     QMouseEvent::Type type;

   482     Qt::MouseButton button;

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

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

   485 

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

   487     TPoint controlScreenPos = PositionRelativeToScreen();

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

   489     S60->lastCursorPos = globalPos;

   490     S60->lastPointerEventPos = widgetPos;

   491 

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

   493 

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

   495     QWidget *popupReceiver = 0;

   496     if (popupWidget) {

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

   498         popupReceiver = popupChild ? popupChild : popupWidget;

   499     }

   500 

   501     if (mouseGrabber) {

   502         if (popupReceiver) {

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

   504         } else {

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

   506         }

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

   508         return;

   509     }

   510 

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

   512     if (!widgetUnderPointer)

   513         widgetUnderPointer = qwidget;

   514 

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

   516     S60->lastPointerEventTarget = widgetUnderPointer;

   517 

   518     QWidget *receiver;

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

   520         receiver = S60->mousePressTarget;

   521         if (type == QEvent::MouseButtonRelease)

   522             S60->mousePressTarget = 0;

   523     } else {

   524         receiver = popupReceiver ? popupReceiver : widgetUnderPointer;

   525         if (type == QEvent::MouseButtonPress)

   526             S60->mousePressTarget = receiver;

   527     }

   528 

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

   530     if (S60->brokenPointerCursors)

   531         qt_symbian_move_cursor_sprite();

   532 #endif

   533 

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

   535 }

   536 

   537 void QSymbianControl::sendMouseEvent(

   538         QWidget *receiver,

   539         QEvent::Type type,

   540         const QPoint &globalPos,

   541         Qt::MouseButton button,

   542         Qt::KeyboardModifiers modifiers)

   543 {

   544     Q_ASSERT(receiver);

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

   546         button, QApplicationPrivate::mouse_buttons, modifiers);

   547     QEventDispatcherS60 *dispatcher;

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

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

   550         if (dispatcher->excludeUserInputEvents()) {

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

   552             return;

   553         }

   554     }

   555 

   556     sendMouseEvent(receiver, &mEvent);

   557 }

   558 

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

   560 {

   561     return qt_sendSpontaneousEvent(widget, mEvent);

   562 }

   563 

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

   565 {

   566     TKeyResponse r = EKeyWasNotConsumed;

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

   568     return r;

   569 }

   570 

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

   572 {

   573     switch (type) {

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

   575     case EEventKeyUp:

   576     case EEventKey:

   577     {

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

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

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

   581         // generated.

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

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

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

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

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

   587 

   588 

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

   590         /*

   591         if( keyEvent.iScanCode == EStdKeyDevice1 ) {

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

   593             qApp->setActiveWindow(0);

   594             return EKeyWasNotConsumed;

   595         }

   596         */

   597 

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

   599                 keyEvent.iCode);

   600         int keyCode;

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

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

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

   604             // Normal characters keys.

   605             keyCode = s60Keysym;

   606         } else {

   607             // Special S60 keys.

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

   609         }

   610 

   611 #ifndef QT_NO_CURSOR

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

   613             //translate keys to pointer

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

   615                 /*Explanation about virtualMouseAccel:

   616                  Tapping an arrow key allows precise pixel positioning

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

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

   619                  */

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

   621                     S60->virtualMouseAccel *= 2;

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

   623                         S60->virtualMouseAccel = S60->virtualMouseMaxAccel;

   624                 }

   625                 else

   626                     S60->virtualMouseAccel = 1;

   627                 S60->virtualMouseLastKey = keyCode;

   628 

   629                 QPoint pos = QCursor::pos();

   630                 TPointerEvent fakeEvent;

   631                 TInt x = pos.x();

   632                 TInt y = pos.y();

   633                 if (type == EEventKeyUp) {

   634                     if (keyCode == Qt::Key_Select)

   635                         fakeEvent.iType = TPointerEvent::EButton1Up;

   636                     S60->virtualMouseAccel = 1;

   637                     S60->virtualMouseLastKey = 0;

   638                     switch (keyCode) {

   639                     case Qt::Key_Left:

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

   641                         break;

   642                     case Qt::Key_Right:

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

   644                         break;

   645                     case Qt::Key_Up:

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

   647                         break;

   648                     case Qt::Key_Down:

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

   650                         break;

   651                     case Qt::Key_Select:

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

   653                         break;

   654                     }

   655                 }

   656                 else if (type == EEventKey) {

   657                     switch (keyCode) {

   658                     case Qt::Key_Left:

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

   660                         x -= S60->virtualMouseAccel;

   661                         fakeEvent.iType = TPointerEvent::EMove;

   662                         break;

   663                     case Qt::Key_Right:

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

   665                         x += S60->virtualMouseAccel;

   666                         fakeEvent.iType = TPointerEvent::EMove;

   667                         break;

   668                     case Qt::Key_Up:

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

   670                         y -= S60->virtualMouseAccel;

   671                         fakeEvent.iType = TPointerEvent::EMove;

   672                         break;

   673                     case Qt::Key_Down:

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

   675                         y += S60->virtualMouseAccel;

   676                         fakeEvent.iType = TPointerEvent::EMove;

   677                         break;

   678                     case Qt::Key_Select:

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

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

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

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

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

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

   685                             return EKeyWasConsumed;

   686                         } else {

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

   688                             fakeEvent.iType = TPointerEvent::EButton1Down;

   689                         }

   690                         break;

   691                     }

   692                 }

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

   694                 if (x < 0)

   695                     x = 0;

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

   697                     x = S60->screenWidthInPixels - 1;

   698                 if (y < 0)

   699                     y = 0;

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

   701                     y = S60->screenHeightInPixels - 1;

   702                 TPoint epos(x, y);

   703                 TPoint cpos = epos - PositionRelativeToScreen();

   704                 fakeEvent.iModifiers = keyEvent.iModifiers;

   705                 fakeEvent.iPosition = cpos;

   706                 fakeEvent.iParentPosition = epos;

   707                 HandlePointerEvent(fakeEvent);

   708                 return EKeyWasConsumed;

   709             }

   710             else {

   711                 S60->virtualMouseLastKey = keyCode;

   712                 S60->virtualMouseAccel = 1;

   713             }

   714         }

   715 #endif

   716 

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

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

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

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

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

   722 //        if (!wid)

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

   724 //            return EKeyWasNotConsumed;

   725         QWidget *widget;

   726         widget = QWidget::keyboardGrabber();

   727         if (!widget) {

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

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

   730                 if (!widget) {

   731                     widget = QApplication::activePopupWidget();

   732                 }

   733             } else {

   734                 widget = QApplicationPrivate::focus_widget;

   735                 if (!widget) {

   736                     widget = qwidget;

   737                 }

   738             }

   739         }

   740 

   741         QEventDispatcherS60 *dispatcher;

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

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

   744             if (dispatcher->excludeUserInputEvents()) {

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

   746                 return EKeyWasConsumed;

   747             }

   748         }

   749         return sendKeyEvent(widget, &qKeyEvent);

   750     }

   751     }

   752     return EKeyWasNotConsumed;

   753 }

   754 

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

   756 {

   757     switch (inputEvent->type()) {

   758     case QEvent::KeyPress:

   759     case QEvent::KeyRelease:

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

   761         break;

   762     case QEvent::MouseButtonDblClick:

   763     case QEvent::MouseButtonPress:

   764     case QEvent::MouseButtonRelease:

   765     case QEvent::MouseMove:

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

   767         break;

   768     default:

   769         // Shouldn't get here.

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

   771         break;

   772     }

   773 }

   774 

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

   776 {

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

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

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

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

   781             return EKeyWasConsumed;

   782     }

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

   784 

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

   786         if (keyEvent->isAccepted())

   787             return EKeyWasConsumed;

   788 

   789     return EKeyWasNotConsumed;

   790 }

   791 

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

   793 TCoeInputCapabilities QSymbianControl::InputCapabilities() const

   794 {

   795     QWidget *w = 0;

   796 

   797     if (qwidget->hasFocus())

   798         w = qwidget;

   799     else

   800         w = qwidget->focusWidget();

   801 

   802     QCoeFepInputContext *ic;

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

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

   805         return ic->inputCapabilities();

   806     } else {

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

   808     }

   809 }

   810 #endif

   811 

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

   813 {

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

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

   816     Q_ASSERT(window);

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

   818     Q_ASSERT(topExtra);

   819     if (!topExtra->inExpose) {

   820         topExtra->inExpose = true;

   821         QRect exposeRect = qt_TRect2QRect(controlRect);

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

   823         topExtra->inExpose = false;

   824     }

   825 

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

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

   828 

   829     if (!engine)

   830         return;

   831 

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

   833     if (sendNativePaintEvents) {

   834         const QRect r = qt_TRect2QRect(controlRect);

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

   836     }

   837 

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

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

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

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

   842 

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

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

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

   846         CWindowGc &gc = SystemGc();

   847 

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

   849         case QWExtra::Disable:

   850             // Do nothing

   851             break;

   852 

   853         case QWExtra::Blit:

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

   855                 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

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

   857             break;

   858 

   859         case QWExtra::ZeroFill:

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

   861                 gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   862                 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

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

   864                 gc.Clear(controlRect);

   865             } else {

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

   867                 gc.Clear(controlRect);

   868             };

   869             break;

   870 

   871         default:

   872             Q_ASSERT(false);

   873         }

   874     }

   875 

   876     if (sendNativePaintEvents) {

   877         const QRect r = qt_TRect2QRect(controlRect);

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

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

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

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

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

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

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

   885         // endNativePaintEvent implementation.

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

   887     }

   888 }

   889 

   890 void QSymbianControl::SizeChanged()

   891 {

   892     CCoeControl::SizeChanged();

   893 

   894     QSize oldSize = qwidget->size();

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

   896 

   897     if (oldSize != newSize) {

   898         QRect cr = qwidget->geometry();

   899         cr.setSize(newSize);

   900         qwidget->data->crect = cr;

   901         if (qwidget->isVisible()) {

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

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

   904             if (!slowResize && tlwExtra)

   905                 tlwExtra->inTopLevelResize = true;

   906             QResizeEvent e(newSize, oldSize);

   907             qt_sendSpontaneousEvent(qwidget, &e);

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

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

   910             if (!slowResize && tlwExtra)

   911                 tlwExtra->inTopLevelResize = false;

   912         }

   913     }

   914 

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

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

   917     // position is updated.

   918     PositionChanged();

   919 }

   920 

   921 void QSymbianControl::PositionChanged()

   922 {

   923     CCoeControl::PositionChanged();

   924 

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

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

   927 

   928     if (oldPos != newPos) {

   929         QRect cr = qwidget->geometry();

   930         cr.moveTopLeft(newPos);

   931         qwidget->data->crect = cr;

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

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

   934             top->normalGeometry.moveTopLeft(newPos);

   935         if (qwidget->isVisible()) {

   936             QMoveEvent e(newPos, oldPos);

   937             qt_sendSpontaneousEvent(qwidget, &e);

   938         } else {

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

   940             QApplication::postEvent(qwidget, e);

   941         }

   942     }

   943 }

   944 

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

   946 {

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

   948         return;

   949 

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

   951     if (QApplicationPrivate::popupWidgets != 0

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

   953         return;

   954 

   955     if (IsFocused() && IsVisible()) {

   956         if (m_symbianPopupIsOpen) {

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

   958             if (fw) {

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

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

   961             }

   962             m_symbianPopupIsOpen = false;

   963         }

   964 

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

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

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

   968 #ifdef Q_WS_S60

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

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

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

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

   973         if (statusPane)

   974             statusPane->MakeVisible(visible);

   975         if (buttonGroup) {

   976             // Visibility

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

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

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

   980 

   981             // Responsiviness

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

   983             TUint cbaFlags = cba->ButtonGroupFlags();

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

   985                 cbaFlags |= EAknCBAFlagRespondWhenInvisible;

   986             else

   987                 cbaFlags &= ~EAknCBAFlagRespondWhenInvisible;

   988             cba->SetButtonGroupFlags(cbaFlags);

   989         }

   990 #endif

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

   992         if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog()) {

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

   994             if (fw) {

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

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

   997             }

   998             m_symbianPopupIsOpen = true;

   999             return;

  1000         }

  1001 

  1002         QApplication::setActiveWindow(0);

  1003     }

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

  1005 }

  1006 

  1007 void QSymbianControl::handleClientAreaChange()

  1008 {

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

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

  1011         SetExtentToWholeScreen();

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

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

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

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

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

  1017             qwidget->adjustSize();

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

  1019         }

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

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

  1022             SetPosition(r.iTl);

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

  1024         }

  1025     }

  1026 }

  1027 

  1028 void QSymbianControl::HandleResourceChange(int resourceType)

  1029 {

  1030     switch (resourceType) {

  1031     case KInternalStatusPaneChange:

  1032         handleClientAreaChange();

  1033         if (IsFocused() && IsVisible()) {

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

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

  1036         }

  1037         break;

  1038     case KUidValueCoeFontChangeEvent:

  1039         // font change event

  1040         break;

  1041 #ifdef Q_WS_S60

  1042     case KEikDynamicLayoutVariantSwitch:

  1043     {

  1044         handleClientAreaChange();

  1045         break;

  1046     }

  1047 #endif

  1048     default:

  1049         break;

  1050     }

  1051 

  1052     CCoeControl::HandleResourceChange(resourceType);

  1053 

  1054 }

  1055 void QSymbianControl::CancelLongTapTimer()

  1056 {

  1057     m_longTapDetector->Cancel();

  1058 }

  1059 

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

  1061 {

  1062     if (id.iUid == ETypeId)

  1063         return id.MakePtr(this);

  1064 

  1065     return CCoeControl::MopSupplyObject(id);

  1066 }

  1067 

  1068 void QSymbianControl::setFocusSafely(bool focus)

  1069 {

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

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

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

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

  1074     if (focus) {

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

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

  1077         // remember it and clear focus ourselves.

  1078         if (lastFocusedControl && lastFocusedControl != this)

  1079             lastFocusedControl->SetFocus(false);

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

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

  1082         lastFocusedControl = this;

  1083         this->SetFocus(true);

  1084     } else {

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

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

  1087                 ECoeStackPriorityDefault, ECoeStackFlagStandard));

  1088         if(this == lastFocusedControl)

  1089             lastFocusedControl = 0;

  1090         this->SetFocus(false);

  1091     }

  1092 }

  1093 

  1094 /*!

  1095     \typedef QApplication::QS60MainApplicationFactory

  1096     \since 4.6

  1097 

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

  1099     signature:

  1100 

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

  1102 

  1103     \sa QApplication::QApplication()

  1104 */

  1105 

  1106 /*!

  1107     \since 4.6

  1108 

  1109     Creates an application using the application factory given in

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

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

  1112     standard exception.

  1113 

  1114     This function is only available on S60.

  1115 */

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

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

  1118 {

  1119     Q_D(QApplication);

  1120     S60->s60ApplicationFactory = factory;

  1121     d->construct();

  1122 }

  1123 

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

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

  1126 {

  1127     Q_D(QApplication);

  1128     S60->s60ApplicationFactory = factory;

  1129     d->construct();

  1130     QApplicationPrivate::app_compile_version = _internal;

  1131 }

  1132 

  1133 void qt_init(QApplicationPrivate * /* priv */, int)

  1134 {

  1135     if (!CCoeEnv::Static()) {