1 | /****************************************************************************
|
---|
2 | **
|
---|
3 | ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
---|
4 | ** All rights reserved.
|
---|
5 | ** Contact: Nokia Corporation ([email protected])
|
---|
6 | **
|
---|
7 | ** This file is part of the QtGui module of the Qt Toolkit.
|
---|
8 | **
|
---|
9 | ** $QT_BEGIN_LICENSE:LGPL$
|
---|
10 | ** Commercial Usage
|
---|
11 | ** Licensees holding valid Qt Commercial licenses may use this file in
|
---|
12 | ** accordance with the Qt Commercial License Agreement provided with the
|
---|
13 | ** Software or, alternatively, in accordance with the terms contained in
|
---|
14 | ** a written agreement between you and Nokia.
|
---|
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 | ** GNU General Public License Usage
|
---|
29 | ** Alternatively, this file may be used under the terms of the GNU
|
---|
30 | ** General Public License version 3.0 as published by the Free Software
|
---|
31 | ** Foundation and appearing in the file LICENSE.GPL included in the
|
---|
32 | ** packaging of this file. Please review the following information to
|
---|
33 | ** ensure the GNU General Public License version 3.0 requirements will be
|
---|
34 | ** met: http://www.gnu.org/copyleft/gpl.html.
|
---|
35 | **
|
---|
36 | ** If you have questions regarding the use of this file, please contact
|
---|
37 | ** Nokia at [email protected].
|
---|
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 | #ifdef QT_GRAPHICSSYSTEM_RUNTIME
|
---|
66 | #include "private/qgraphicssystem_runtime_p.h"
|
---|
67 | #endif
|
---|
68 |
|
---|
69 | #include "apgwgnam.h" // For CApaWindowGroupName
|
---|
70 | #include <mdaaudiotoneplayer.h> // For CMdaAudioToneUtility
|
---|
71 |
|
---|
72 | #if defined(Q_OS_SYMBIAN)
|
---|
73 | # include <private/qs60mainapplication_p.h>
|
---|
74 | # include <centralrepository.h>
|
---|
75 | # include "qs60mainappui.h"
|
---|
76 | # include "qinputcontext.h"
|
---|
77 | #endif
|
---|
78 |
|
---|
79 | #if defined(Q_WS_S60)
|
---|
80 | # if !defined(QT_NO_IM)
|
---|
81 | # include <private/qcoefepinputcontext_p.h>
|
---|
82 | # endif
|
---|
83 | #endif
|
---|
84 |
|
---|
85 | #include "private/qstylesheetstyle_p.h"
|
---|
86 |
|
---|
87 | #include <hal.h>
|
---|
88 | #include <hal_data.h>
|
---|
89 |
|
---|
90 | #ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
|
---|
91 | #include <graphics/wstfxconst.h>
|
---|
92 | #endif
|
---|
93 |
|
---|
94 | QT_BEGIN_NAMESPACE
|
---|
95 |
|
---|
96 | // Goom Events through Window Server
|
---|
97 | static const int KGoomMemoryLowEvent = 0x10282DBF;
|
---|
98 | static const int KGoomMemoryGoodEvent = 0x20026790;
|
---|
99 |
|
---|
100 | #if defined(QT_DEBUG)
|
---|
101 | static bool appNoGrab = false; // Grabbing enabled
|
---|
102 | #endif
|
---|
103 | static bool app_do_modal = false; // modal mode
|
---|
104 | Q_GLOBAL_STATIC(QS60Data, qt_s60Data);
|
---|
105 |
|
---|
106 | extern bool qt_sendSpontaneousEvent(QObject*,QEvent*);
|
---|
107 | extern QWidgetList *qt_modal_stack; // stack of modal widgets
|
---|
108 | extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp
|
---|
109 |
|
---|
110 | QWidget *qt_button_down = 0; // widget got last button-down
|
---|
111 |
|
---|
112 | QSymbianControl *QSymbianControl::lastFocusedControl = 0;
|
---|
113 |
|
---|
114 | QS60Data* qGlobalS60Data()
|
---|
115 | {
|
---|
116 | return qt_s60Data();
|
---|
117 | }
|
---|
118 |
|
---|
119 | #ifdef Q_WS_S60
|
---|
120 | void QS60Data::setStatusPaneAndButtonGroupVisibility(bool statusPaneVisible, bool buttonGroupVisible)
|
---|
121 | {
|
---|
122 | bool buttonGroupVisibilityChanged = false;
|
---|
123 | if (CEikButtonGroupContainer *const b = buttonGroupContainer()) {
|
---|
124 | buttonGroupVisibilityChanged = (b->IsVisible() != buttonGroupVisible);
|
---|
125 | b->MakeVisible(buttonGroupVisible);
|
---|
126 | }
|
---|
127 | bool statusPaneVisibilityChanged = false;
|
---|
128 | if (CEikStatusPane *const s = statusPane()) {
|
---|
129 | statusPaneVisibilityChanged = (s->IsVisible() != statusPaneVisible);
|
---|
130 | s->MakeVisible(statusPaneVisible);
|
---|
131 | }
|
---|
132 | if (buttonGroupVisibilityChanged || statusPaneVisibilityChanged) {
|
---|
133 | const QSize size = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect()).size();
|
---|
134 | const QSize oldSize; // note that QDesktopWidget::resizeEvent ignores the QResizeEvent contents
|
---|
135 | QResizeEvent event(size, oldSize);
|
---|
136 | QApplication::instance()->sendEvent(QApplication::desktop(), &event);
|
---|
137 | }
|
---|
138 | if (buttonGroupVisibilityChanged && !statusPaneVisibilityChanged && QApplication::activeWindow())
|
---|
139 | // Ensure that control rectangle is updated
|
---|
140 | static_cast<QSymbianControl *>(QApplication::activeWindow()->winId())->handleClientAreaChange();
|
---|
141 | }
|
---|
142 | #endif
|
---|
143 |
|
---|
144 | void QS60Data::controlVisibilityChanged(CCoeControl *control, bool visible)
|
---|
145 | {
|
---|
146 | if (QWidgetPrivate::mapper && QWidgetPrivate::mapper->contains(control)) {
|
---|
147 | QWidget *const widget = QWidgetPrivate::mapper->value(control);
|
---|
148 | QWidget *const window = widget->window();
|
---|
149 | if (QTLWExtra *topData = qt_widget_private(window)->maybeTopData()) {
|
---|
150 | QWidgetBackingStoreTracker &backingStore = topData->backingStore;
|
---|
151 | if (visible) {
|
---|
152 | if (backingStore.data()) {
|
---|
153 | backingStore.registerWidget(widget);
|
---|
154 | } else {
|
---|
155 | backingStore.create(window);
|
---|
156 | backingStore.registerWidget(widget);
|
---|
157 | qt_widget_private(widget)->invalidateBuffer(widget->rect());
|
---|
158 | widget->repaint();
|
---|
159 | }
|
---|
160 | } else {
|
---|
161 | backingStore.unregisterWidget(widget);
|
---|
162 | // In order to ensure that any resources used by the window surface
|
---|
163 | // are immediately freed, we flush the WSERV command buffer.
|
---|
164 | S60->wsSession().Flush();
|
---|
165 | }
|
---|
166 | }
|
---|
167 | }
|
---|
168 | }
|
---|
169 |
|
---|
170 | bool qt_nograb() // application no-grab option
|
---|
171 | {
|
---|
172 | #if defined(QT_DEBUG)
|
---|
173 | return appNoGrab;
|
---|
174 | #else
|
---|
175 | return false;
|
---|
176 | #endif
|
---|
177 | }
|
---|
178 |
|
---|
179 | // Modified from http://www3.symbian.com/faq.nsf/0/0F1464EE96E737E780256D5E00503DD1?OpenDocument
|
---|
180 | class QS60Beep : public CBase, public MMdaAudioToneObserver
|
---|
181 | {
|
---|
182 | public:
|
---|
183 | static QS60Beep* NewL(TInt aFrequency, TTimeIntervalMicroSeconds iDuration);
|
---|
184 | void Play();
|
---|
185 | ~QS60Beep();
|
---|
186 | private:
|
---|
187 | void ConstructL(TInt aFrequency, TTimeIntervalMicroSeconds iDuration);
|
---|
188 | void MatoPrepareComplete(TInt aError);
|
---|
189 | void MatoPlayComplete(TInt aError);
|
---|
190 | private:
|
---|
191 | typedef enum
|
---|
192 | {
|
---|
193 | EBeepNotPrepared,
|
---|
194 | EBeepPrepared,
|
---|
195 | EBeepPlaying
|
---|
196 | } TBeepState;
|
---|
197 | private:
|
---|
198 | CMdaAudioToneUtility* iToneUtil;
|
---|
199 | TBeepState iState;
|
---|
200 | TInt iFrequency;
|
---|
201 | TTimeIntervalMicroSeconds iDuration;
|
---|
202 | };
|
---|
203 |
|
---|
204 | static QS60Beep* qt_S60Beep = 0;
|
---|
205 |
|
---|
206 | QS60Beep::~QS60Beep()
|
---|
207 | {
|
---|
208 | if (iToneUtil) {
|
---|
209 | switch (iState) {
|
---|
210 | case EBeepPlaying:
|
---|
211 | iToneUtil->CancelPlay();
|
---|
212 | break;
|
---|
213 | case EBeepNotPrepared:
|
---|
214 | iToneUtil->CancelPrepare();
|
---|
215 | break;
|
---|
216 | }
|
---|
217 | }
|
---|
218 | delete iToneUtil;
|
---|
219 | }
|
---|
220 |
|
---|
221 | QS60Beep* QS60Beep::NewL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)
|
---|
222 | {
|
---|
223 | QS60Beep* self = new (ELeave) QS60Beep();
|
---|
224 | CleanupStack::PushL(self);
|
---|
225 | self->ConstructL(aFrequency, aDuration);
|
---|
226 | CleanupStack::Pop();
|
---|
227 | return self;
|
---|
228 | }
|
---|
229 |
|
---|
230 | void QS60Beep::ConstructL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)
|
---|
231 | {
|
---|
232 | iToneUtil = CMdaAudioToneUtility::NewL(*this);
|
---|
233 | iState = EBeepNotPrepared;
|
---|
234 | iFrequency = aFrequency;
|
---|
235 | iDuration = aDuration;
|
---|
236 | iToneUtil->PrepareToPlayTone(iFrequency, iDuration);
|
---|
237 | }
|
---|
238 |
|
---|
239 | void QS60Beep::Play()
|
---|
240 | {
|
---|
241 | if (iState == EBeepPlaying) {
|
---|
242 | iToneUtil->CancelPlay();
|
---|
243 | iState = EBeepPrepared;
|
---|
244 | }
|
---|
245 |
|
---|
246 | iToneUtil->Play();
|
---|
247 | iState = EBeepPlaying;
|
---|
248 | }
|
---|
249 |
|
---|
250 | void QS60Beep::MatoPrepareComplete(TInt aError)
|
---|
251 | {
|
---|
252 | if (aError == KErrNone) {
|
---|
253 | iState = EBeepPrepared;
|
---|
254 | Play();
|
---|
255 | }
|
---|
256 | }
|
---|
257 |
|
---|
258 | void QS60Beep::MatoPlayComplete(TInt aError)
|
---|
259 | {
|
---|
260 | Q_UNUSED(aError);
|
---|
261 | iState = EBeepPrepared;
|
---|
262 | }
|
---|
263 |
|
---|
264 |
|
---|
265 | static Qt::KeyboardModifiers mapToQtModifiers(TUint s60Modifiers)
|
---|
266 | {
|
---|
267 | Qt::KeyboardModifiers result = Qt::NoModifier;
|
---|
268 |
|
---|
269 | if (s60Modifiers & EModifierKeypad)
|
---|
270 | result |= Qt::KeypadModifier;
|
---|
271 | if (s60Modifiers & EModifierShift || s60Modifiers & EModifierLeftShift
|
---|
272 | || s60Modifiers & EModifierRightShift)
|
---|
273 | result |= Qt::ShiftModifier;
|
---|
274 | if (s60Modifiers & EModifierCtrl || s60Modifiers & EModifierLeftCtrl
|
---|
275 | || s60Modifiers & EModifierRightCtrl)
|
---|
276 | result |= Qt::ControlModifier;
|
---|
277 | if (s60Modifiers & EModifierAlt || s60Modifiers & EModifierLeftAlt
|
---|
278 | || s60Modifiers & EModifierRightAlt)
|
---|
279 | result |= Qt::AltModifier;
|
---|
280 |
|
---|
281 | return result;
|
---|
282 | }
|
---|
283 |
|
---|
284 | static void mapS60MouseEventTypeToQt(QEvent::Type *type, Qt::MouseButton *button, const TPointerEvent *pEvent)
|
---|
285 | {
|
---|
286 | switch (pEvent->iType) {
|
---|
287 | case TPointerEvent::EButton1Down:
|
---|
288 | *type = QEvent::MouseButtonPress;
|
---|
289 | *button = Qt::LeftButton;
|
---|
290 | break;
|
---|
291 | case TPointerEvent::EButton1Up:
|
---|
292 | *type = QEvent::MouseButtonRelease;
|
---|
293 | *button = Qt::LeftButton;
|
---|
294 | break;
|
---|
295 | case TPointerEvent::EButton2Down:
|
---|
296 | *type = QEvent::MouseButtonPress;
|
---|
297 | *button = Qt::MidButton;
|
---|
298 | break;
|
---|
299 | case TPointerEvent::EButton2Up:
|
---|
300 | *type = QEvent::MouseButtonRelease;
|
---|
301 | *button = Qt::MidButton;
|
---|
302 | break;
|
---|
303 | case TPointerEvent::EButton3Down:
|
---|
304 | *type = QEvent::MouseButtonPress;
|
---|
305 | *button = Qt::RightButton;
|
---|
306 | break;
|
---|
307 | case TPointerEvent::EButton3Up:
|
---|
308 | *type = QEvent::MouseButtonRelease;
|
---|
309 | *button = Qt::RightButton;
|
---|
310 | break;
|
---|
311 | case TPointerEvent::EDrag:
|
---|
312 | *type = QEvent::MouseMove;
|
---|
313 | *button = Qt::NoButton;
|
---|
314 | break;
|
---|
315 | case TPointerEvent::EMove:
|
---|
316 | // Qt makes no distinction between move and drag
|
---|
317 | *type = QEvent::MouseMove;
|
---|
318 | *button = Qt::NoButton;
|
---|
319 | break;
|
---|
320 | default:
|
---|
321 | *type = QEvent::None;
|
---|
322 | *button = Qt::NoButton;
|
---|
323 | break;
|
---|
324 | }
|
---|
325 | if (pEvent->iModifiers & EModifierDoubleClick){
|
---|
326 | *type = QEvent::MouseButtonDblClick;
|
---|
327 | }
|
---|
328 |
|
---|
329 | if (*type == QEvent::MouseButtonPress || *type == QEvent::MouseButtonDblClick)
|
---|
330 | QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons | (*button);
|
---|
331 | else if (*type == QEvent::MouseButtonRelease)
|
---|
332 | QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons &(~(*button));
|
---|
333 |
|
---|
334 | QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons & Qt::MouseButtonMask;
|
---|
335 | }
|
---|
336 |
|
---|
337 | //### Can be replaced with CAknLongTapDetector if animation is required.
|
---|
338 | //NOTE: if CAknLongTapDetector is used make sure it gets variated out of 3.1 and 3.2,.
|
---|
339 | //also MLongTapObserver needs to be changed to MAknLongTapDetectorCallBack if CAknLongTapDetector is used.
|
---|
340 | class QLongTapTimer : public CTimer
|
---|
341 | {
|
---|
342 | public:
|
---|
343 | static QLongTapTimer* NewL(QAbstractLongTapObserver *observer);
|
---|
344 | QLongTapTimer(QAbstractLongTapObserver *observer);
|
---|
345 | void ConstructL();
|
---|
346 | public:
|
---|
347 | void PointerEventL(const TPointerEvent &event);
|
---|
348 | void RunL();
|
---|
349 | protected:
|
---|
350 | private:
|
---|
351 | QAbstractLongTapObserver *m_observer;
|
---|
352 | TPointerEvent m_event;
|
---|
353 | QPoint m_pressedCoordinates;
|
---|
354 | int m_dragDistance;
|
---|
355 | };
|
---|
356 |
|
---|
357 | QLongTapTimer* QLongTapTimer::NewL(QAbstractLongTapObserver *observer)
|
---|
358 | {
|
---|
359 | QLongTapTimer* self = new QLongTapTimer(observer);
|
---|
360 | self->ConstructL();
|
---|
361 | return self;
|
---|
362 | }
|
---|
363 | void QLongTapTimer::ConstructL()
|
---|
364 | {
|
---|
365 | CTimer::ConstructL();
|
---|
366 | }
|
---|
367 |
|
---|
368 | QLongTapTimer::QLongTapTimer(QAbstractLongTapObserver *observer):CTimer(CActive::EPriorityHigh)
|
---|
369 | {
|
---|
370 | m_observer = observer;
|
---|
371 | m_dragDistance = qApp->startDragDistance();
|
---|
372 | CActiveScheduler::Add(this);
|
---|
373 | }
|
---|
374 |
|
---|
375 | void QLongTapTimer::PointerEventL(const TPointerEvent& event)
|
---|
376 | {
|
---|
377 | if ( event.iType == TPointerEvent::EDrag || event.iType == TPointerEvent::EButtonRepeat)
|
---|
378 | {
|
---|
379 | QPoint diff(QPoint(event.iPosition.iX,event.iPosition.iY) - m_pressedCoordinates);
|
---|
380 | if (diff.manhattanLength() < m_dragDistance)
|
---|
381 | return;
|
---|
382 | }
|
---|
383 | Cancel();
|
---|
384 | m_event = event;
|
---|
385 | if (event.iType == TPointerEvent::EButton1Down)
|
---|
386 | {
|
---|
387 | m_pressedCoordinates = QPoint(event.iPosition.iX,event.iPosition.iY);
|
---|
388 | // must be same as KLongTapDelay in aknlongtapdetector.h
|
---|
389 | After(800000);
|
---|
390 | }
|
---|
391 | }
|
---|
392 | void QLongTapTimer::RunL()
|
---|
393 | {
|
---|
394 | if (m_observer)
|
---|
395 | m_observer->HandleLongTapEventL(m_event.iPosition, m_event.iParentPosition);
|
---|
396 | }
|
---|
397 |
|
---|
398 | QSymbianControl::QSymbianControl(QWidget *w)
|
---|
399 | : CCoeControl()
|
---|
400 | , qwidget(w)
|
---|
401 | , m_longTapDetector(0)
|
---|
402 | , m_ignoreFocusChanged(0)
|
---|
403 | , m_symbianPopupIsOpen(0)
|
---|
404 | {
|
---|
405 | }
|
---|
406 |
|
---|
407 | void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)
|
---|
408 | {
|
---|
409 | if (!desktop)
|
---|
410 | {
|
---|
411 | if (isWindowOwning || !qwidget->parentWidget())
|
---|
412 | CreateWindowL(S60->windowGroup());
|
---|
413 | else
|
---|
414 | /**
|
---|
415 | * TODO: in order to avoid creating windows for all ancestors of
|
---|
416 | * this widget up to the root window, the parameter passed to
|
---|
417 | * CreateWindowL should be
|
---|
418 | * qwidget->parentWidget()->effectiveWinId(). However, if we do
|
---|
419 | * this, then we need to take care of re-parenting when a window
|
---|
420 | * is created for a widget between this one and the root window.
|
---|
421 | */
|
---|
422 | CreateWindowL(qwidget->parentWidget()->winId());
|
---|
423 |
|
---|
424 | // Necessary in order to be able to track the activation status of
|
---|
425 | // the control's window
|
---|
426 | qwidget->d_func()->createExtra();
|
---|
427 |
|
---|
428 | SetFocusing(true);
|
---|
429 | m_longTapDetector = QLongTapTimer::NewL(this);
|
---|
430 | m_doubleClickTimer.invalidate();
|
---|
431 |
|
---|
432 | DrawableWindow()->SetPointerGrab(ETrue);
|
---|
433 | }
|
---|
434 |
|
---|
435 | #ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
|
---|
436 | if (OwnsWindow()) {
|
---|
437 | TTfxWindowPurpose windowPurpose(ETfxPurposeNone);
|
---|
438 | switch (qwidget->windowType()) {
|
---|
439 | case Qt::Dialog:
|
---|
440 | windowPurpose = ETfxPurposeDialogWindow;
|
---|
441 | break;
|
---|
442 | case Qt::Popup:
|
---|
443 | windowPurpose = ETfxPurposePopupWindow;
|
---|
444 | break;
|
---|
445 | case Qt::Tool:
|
---|
446 | windowPurpose = ETfxPurposeToolWindow;
|
---|
447 | break;
|
---|
448 | case Qt::ToolTip:
|
---|
449 | windowPurpose = ETfxPurposeToolTipWindow;
|
---|
450 | break;
|
---|
451 | case Qt::SplashScreen:
|
---|
452 | windowPurpose = ETfxPurposeSplashScreenWindow;
|
---|
453 | break;
|
---|
454 | default:
|
---|
455 | windowPurpose = (isWindowOwning || !qwidget->parentWidget())
|
---|
456 | ? ETfxPurposeWindow : ETfxPurposeChildWindow;
|
---|
457 | break;
|
---|
458 | }
|
---|
459 | Window().SetPurpose(windowPurpose);
|
---|
460 | }
|
---|
461 | #endif
|
---|
462 | }
|
---|
463 |
|
---|
464 | QSymbianControl::~QSymbianControl()
|
---|
465 | {
|
---|
466 | // Ensure backing store is deleted before the top-level
|
---|
467 | // window is destroyed
|
---|
468 | qt_widget_private(qwidget)->topData()->backingStore.destroy();
|
---|
469 |
|
---|
470 | if (S60->curWin == this)
|
---|
471 | S60->curWin = 0;
|
---|
472 | if (!QApplicationPrivate::is_app_closing) {
|
---|
473 | QT_TRY {
|
---|
474 | setFocusSafely(false);
|
---|
475 | } QT_CATCH(const std::exception&) {
|
---|
476 | // ignore exceptions, nothing can be done
|
---|
477 | }
|
---|
478 | }
|
---|
479 | S60->appUi()->RemoveFromStack(this);
|
---|
480 | delete m_longTapDetector;
|
---|
481 | }
|
---|
482 |
|
---|
483 | void QSymbianControl::setWidget(QWidget *w)
|
---|
484 | {
|
---|
485 | qwidget = w;
|
---|
486 | }
|
---|
487 | void QSymbianControl::HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation )
|
---|
488 | {
|
---|
489 | QWidget *alienWidget;
|
---|
490 | QPoint widgetPos = QPoint(aPenEventLocation.iX, aPenEventLocation.iY);
|
---|
491 | QPoint globalPos = QPoint(aPenEventScreenLocation.iX,aPenEventScreenLocation.iY);
|
---|
492 | alienWidget = qwidget->childAt(widgetPos);
|
---|
493 | if (!alienWidget)
|
---|
494 | alienWidget = qwidget;
|
---|
495 |
|
---|
496 | #if !defined(QT_NO_CONTEXTMENU)
|
---|
497 | QContextMenuEvent contextMenuEvent(QContextMenuEvent::Mouse, widgetPos, globalPos, Qt::NoModifier);
|
---|
498 | qt_sendSpontaneousEvent(alienWidget, &contextMenuEvent);
|
---|
499 | #endif
|
---|
500 | }
|
---|
501 |
|
---|
502 | #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
|
---|
503 | void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent *event)
|
---|
504 | {
|
---|
505 | QApplicationPrivate *d = QApplicationPrivate::instance();
|
---|
506 | QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));
|
---|
507 | qreal pressure;
|
---|
508 | if(d->pressureSupported
|
---|
509 | && event->Pressure() > 0) //workaround for misconfigured HAL
|
---|
510 | pressure = event->Pressure() / qreal(d->maxTouchPressure);
|
---|
511 | else
|
---|
512 | pressure = qreal(1.0);
|
---|
513 | processTouchEvent(event->PointerNumber(), event->iType, screenPos, pressure);
|
---|
514 | }
|
---|
515 | #endif
|
---|
516 |
|
---|
517 | void QSymbianControl::processTouchEvent(int pointerNumber, TPointerEvent::TType type, QPointF screenPos, qreal pressure)
|
---|
518 | {
|
---|
519 | QRect screenGeometry = qApp->desktop()->screenGeometry(qwidget);
|
---|
520 |
|
---|
521 | QApplicationPrivate *d = QApplicationPrivate::instance();
|
---|
522 |
|
---|
523 | QList<QTouchEvent::TouchPoint> points = d->appAllTouchPoints;
|
---|
524 | while (points.count() <= pointerNumber)
|
---|
525 | points.append(QTouchEvent::TouchPoint(points.count()));
|
---|
526 |
|
---|
527 | Qt::TouchPointStates allStates = 0;
|
---|
528 | for (int i = 0; i < points.count(); ++i) {
|
---|
529 | QTouchEvent::TouchPoint &touchPoint = points[i];
|
---|
530 |
|
---|
531 | if (touchPoint.id() == pointerNumber) {
|
---|
532 | Qt::TouchPointStates state;
|
---|
533 | switch (type) {
|
---|
534 | case TPointerEvent::EButton1Down:
|
---|
535 | #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
|
---|
536 | case TPointerEvent::EEnterHighPressure:
|
---|
537 | #endif
|
---|
538 | state = Qt::TouchPointPressed;
|
---|
539 | break;
|
---|
540 | case TPointerEvent::EButton1Up:
|
---|
541 | #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
|
---|
542 | case TPointerEvent::EExitCloseProximity:
|
---|
543 | #endif
|
---|
544 | state = Qt::TouchPointReleased;
|
---|
545 | break;
|
---|
546 | case TPointerEvent::EDrag:
|
---|
547 | state = Qt::TouchPointMoved;
|
---|
548 | break;
|
---|
549 | default:
|
---|
550 | // how likely is this to happen?
|
---|
551 | state = Qt::TouchPointStationary;
|
---|
552 | break;
|
---|
553 | }
|
---|
554 | if (pointerNumber == 0)
|
---|
555 | state |= Qt::TouchPointPrimary;
|
---|
556 | touchPoint.setState(state);
|
---|
557 |
|
---|
558 | touchPoint.setScreenPos(screenPos);
|
---|
559 | touchPoint.setNormalizedPos(QPointF(screenPos.x() / screenGeometry.width(),
|
---|
560 | screenPos.y() / screenGeometry.height()));
|
---|
561 |
|
---|
562 | touchPoint.setPressure(pressure);
|
---|
563 | } else if (touchPoint.state() != Qt::TouchPointReleased) {
|
---|
564 | // all other active touch points should be marked as stationary
|
---|
565 | touchPoint.setState(Qt::TouchPointStationary);
|
---|
566 | }
|
---|
567 |
|
---|
568 | allStates |= touchPoint.state();
|
---|
569 | }
|
---|
570 |
|
---|
571 | if ((allStates & Qt::TouchPointStateMask) == Qt::TouchPointReleased) {
|
---|
572 | // all touch points released
|
---|
573 | d->appAllTouchPoints.clear();
|
---|
574 | } else {
|
---|
575 | d->appAllTouchPoints = points;
|
---|
576 | }
|
---|
577 |
|
---|
578 | QApplicationPrivate::translateRawTouchEvent(qwidget,
|
---|
579 | QTouchEvent::TouchScreen,
|
---|
580 | points);
|
---|
581 | }
|
---|
582 |
|
---|
583 | void QSymbianControl::HandlePointerEventL(const TPointerEvent& pEvent)
|
---|
584 | {
|
---|
585 | #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
|
---|
586 | if (pEvent.IsAdvancedPointerEvent()) {
|
---|
587 | const TAdvancedPointerEvent *advancedPointerEvent = pEvent.AdvancedPointerEvent();
|
---|
588 | translateAdvancedPointerEvent(advancedPointerEvent);
|
---|
589 | if (advancedPointerEvent->PointerNumber() != 0) {
|
---|
590 | // only send mouse events for the first touch point
|
---|
591 | return;
|
---|
592 | }
|
---|
593 | }
|
---|
594 | #endif
|
---|
595 |
|
---|
596 | m_longTapDetector->PointerEventL(pEvent);
|
---|
597 | QT_TRYCATCH_LEAVING(HandlePointerEvent(pEvent));
|
---|
598 | }
|
---|
599 |
|
---|
600 | void QSymbianControl::HandlePointerEvent(const TPointerEvent& pEvent)
|
---|
601 | {
|
---|
602 | QMouseEvent::Type type;
|
---|
603 | Qt::MouseButton button;
|
---|
604 | mapS60MouseEventTypeToQt(&type, &button, &pEvent);
|
---|
605 | Qt::KeyboardModifiers modifiers = mapToQtModifiers(pEvent.iModifiers);
|
---|
606 |
|
---|
607 | QPoint widgetPos = QPoint(pEvent.iPosition.iX, pEvent.iPosition.iY);
|
---|
608 | TPoint controlScreenPos = PositionRelativeToScreen();
|
---|
609 | QPoint globalPos = QPoint(controlScreenPos.iX, controlScreenPos.iY) + widgetPos;
|
---|
610 | S60->lastCursorPos = globalPos;
|
---|
611 | S60->lastPointerEventPos = widgetPos;
|
---|
612 |
|
---|
613 | QWidget *mouseGrabber = QWidget::mouseGrabber();
|
---|
614 |
|
---|
615 | QWidget *popupWidget = qApp->activePopupWidget();
|
---|
616 | QWidget *popupReceiver = 0;
|
---|
617 | if (popupWidget) {
|
---|
618 | QWidget *popupChild = popupWidget->childAt(popupWidget->mapFromGlobal(globalPos));
|
---|
619 | popupReceiver = popupChild ? popupChild : popupWidget;
|
---|
620 | }
|
---|
621 |
|
---|
622 | if (mouseGrabber) {
|
---|
623 | if (popupReceiver) {
|
---|
624 | sendMouseEvent(popupReceiver, type, globalPos, button, modifiers);
|
---|
625 | } else {
|
---|
626 | sendMouseEvent(mouseGrabber, type, globalPos, button, modifiers);
|
---|
627 | }
|
---|
628 | // No Enter/Leave events in grabbing mode.
|
---|
629 | return;
|
---|
630 | }
|
---|
631 |
|
---|
632 | QWidget *widgetUnderPointer = qwidget->childAt(widgetPos);
|
---|
633 | if (!widgetUnderPointer)
|
---|
634 | widgetUnderPointer = qwidget;
|
---|
635 |
|
---|
636 | QApplicationPrivate::dispatchEnterLeave(widgetUnderPointer, S60->lastPointerEventTarget);
|
---|
637 | S60->lastPointerEventTarget = widgetUnderPointer;
|
---|
638 |
|
---|
639 | QWidget *receiver;
|
---|
640 | if (!popupReceiver && S60->mousePressTarget && type != QEvent::MouseButtonPress) {
|
---|
641 | receiver = S60->mousePressTarget;
|
---|
642 | if (type == QEvent::MouseButtonRelease)
|
---|
643 | S60->mousePressTarget = 0;
|
---|
644 | } else {
|
---|
645 | receiver = popupReceiver ? popupReceiver : widgetUnderPointer;
|
---|
646 | if (type == QEvent::MouseButtonPress)
|
---|
647 | S60->mousePressTarget = receiver;
|
---|
648 | }
|
---|
649 |
|
---|
650 | #if !defined(QT_NO_CURSOR) && !defined(Q_SYMBIAN_FIXED_POINTER_CURSORS)
|
---|
651 | if (S60->brokenPointerCursors)
|
---|
652 | qt_symbian_move_cursor_sprite();
|
---|
653 | #endif
|
---|
654 |
|
---|
655 | //Generate single touch event for S60 5.0 (has touchscreen, does not have advanced pointers)
|
---|
656 | #ifndef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
|
---|
657 | if (S60->hasTouchscreen) {
|
---|
658 | processTouchEvent(0, pEvent.iType, QPointF(globalPos), 1.0);
|
---|
659 | }
|
---|
660 | #endif
|
---|
661 |
|
---|
662 | sendMouseEvent(receiver, type, globalPos, button, modifiers);
|
---|
663 | }
|
---|
664 |
|
---|
665 | #ifdef Q_WS_S60
|
---|
666 | void QSymbianControl::HandleStatusPaneSizeChange()
|
---|
667 | {
|
---|
668 | QS60MainAppUi *s60AppUi = static_cast<QS60MainAppUi *>(S60->appUi());
|
---|
669 | s60AppUi->HandleStatusPaneSizeChange();
|
---|
670 | }
|
---|
671 | #endif
|
---|
672 |
|
---|
673 | void QSymbianControl::sendMouseEvent(
|
---|
674 | QWidget *receiver,
|
---|
675 | QEvent::Type type,
|
---|
676 | const QPoint &globalPos,
|
---|
677 | Qt::MouseButton button,
|
---|
678 | Qt::KeyboardModifiers modifiers)
|
---|
679 | {
|
---|
680 | Q_ASSERT(receiver);
|
---|
681 | QMouseEvent mEvent(type, receiver->mapFromGlobal(globalPos), globalPos,
|
---|
682 | button, QApplicationPrivate::mouse_buttons, modifiers);
|
---|
683 | QEventDispatcherS60 *dispatcher;
|
---|
684 | // It is theoretically possible for someone to install a different event dispatcher.
|
---|
685 | if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(receiver->d_func()->threadData->eventDispatcher)) != 0) {
|
---|
686 | if (dispatcher->excludeUserInputEvents()) {
|
---|
687 | dispatcher->saveInputEvent(this, receiver, new QMouseEvent(mEvent));
|
---|
688 | return;
|
---|
689 | }
|
---|
690 | }
|
---|
691 |
|
---|
692 | sendMouseEvent(receiver, &mEvent);
|
---|
693 | }
|
---|
694 |
|
---|
695 | bool QSymbianControl::sendMouseEvent(QWidget *widget, QMouseEvent *mEvent)
|
---|
696 | {
|
---|
697 | return qt_sendSpontaneousEvent(widget, mEvent);
|
---|
698 | }
|
---|
699 |
|
---|
700 | TKeyResponse QSymbianControl::OfferKeyEventL(const TKeyEvent& keyEvent, TEventCode type)
|
---|
701 | {
|
---|
702 | TKeyResponse r = EKeyWasNotConsumed;
|
---|
703 | QT_TRYCATCH_LEAVING(r = OfferKeyEvent(keyEvent, type));
|
---|
704 | return r;
|
---|
705 | }
|
---|
706 |
|
---|
707 | TKeyResponse QSymbianControl::OfferKeyEvent(const TKeyEvent& keyEvent, TEventCode type)
|
---|
708 | {
|
---|
709 | /*
|
---|
710 | S60 has a confusing way of delivering key events. There are three types of
|
---|
711 | events: EEventKey, EEventKeyDown and EEventKeyUp. When a key is pressed,
|
---|
712 | EEventKeyDown is first generated, followed by EEventKey. Then, when the key is
|
---|
713 | released, EEventKeyUp is generated.
|
---|
714 | However, it is possible that only the EEventKey is generated alone, typically
|
---|
715 | in relation to virtual keyboards. In that case we need to take care to
|
---|
716 | generate both press and release events in Qt, since applications expect that.
|
---|
717 | We do this by having three states for each used scan code, depending on the
|
---|
718 | events received. See the switch below for what happens in each state
|
---|
719 | transition.
|
---|
720 | */
|
---|
721 |
|
---|
722 | if (type != EEventKeyDown)
|
---|
723 | if (handleVirtualMouse(keyEvent, type) == EKeyWasConsumed)
|
---|
724 | return EKeyWasConsumed;
|
---|
725 |
|
---|
726 | TKeyResponse ret = EKeyWasNotConsumed;
|
---|
727 | #define GET_RETURN(x) (ret = ((x) == EKeyWasConsumed) ? EKeyWasConsumed : ret)
|
---|
728 |
|
---|
729 | // This top level switch corresponds to the states, and the inner switches
|
---|
730 | // correspond to the transitions.
|
---|
731 | QS60Data::ScanCodeState &scanCodeState = S60->scanCodeStates[keyEvent.iScanCode];
|
---|
732 | switch (scanCodeState) {
|
---|
733 | case QS60Data::Unpressed:
|
---|
734 | switch (type) {
|
---|
735 | case EEventKeyDown:
|
---|
736 | scanCodeState = QS60Data::KeyDown;
|
---|
737 | break;
|
---|
738 | case EEventKey:
|
---|
739 | GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyPress));
|
---|
740 | GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyRelease));
|
---|
741 | break;
|
---|
742 | case EEventKeyUp:
|
---|
743 | // No action.
|
---|
744 | break;
|
---|
745 | }
|
---|
746 | break;
|
---|
747 | case QS60Data::KeyDown:
|
---|
748 | switch (type) {
|
---|
749 | case EEventKeyDown:
|
---|
750 | // This should never happen, just stay in this state to be safe.
|
---|
751 | break;
|
---|
752 | case EEventKey:
|
---|
753 | GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyPress));
|
---|
754 | scanCodeState = QS60Data::KeyDownAndKey;
|
---|
755 | break;
|
---|
756 | case EEventKeyUp:
|
---|
757 | scanCodeState = QS60Data::Unpressed;
|
---|
758 | break;
|
---|
759 | }
|
---|
760 | break;
|
---|
761 | case QS60Data::KeyDownAndKey:
|
---|
762 | switch (type) {
|
---|
763 | case EEventKeyDown:
|
---|
764 | // This should never happen, just stay in this state to be safe.
|
---|
765 | break;
|
---|
766 | case EEventKey:
|
---|
767 | GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyRelease));
|
---|
768 | GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyPress));
|
---|
769 | break;
|
---|
770 | case EEventKeyUp:
|
---|
771 | GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyRelease));
|
---|
772 | scanCodeState = QS60Data::Unpressed;
|
---|
773 | break;
|
---|
774 | }
|
---|
775 | break;
|
---|
776 | }
|
---|
777 | return ret;
|
---|
778 |
|
---|
779 | #undef GET_RETURN
|
---|
780 | }
|
---|
781 |
|
---|
782 | TKeyResponse QSymbianControl::sendSymbianKeyEvent(const TKeyEvent &keyEvent, QEvent::Type type)
|
---|
783 | {
|
---|
784 | // Because S60 does not generate keysyms for EKeyEventDown and EKeyEventUp
|
---|
785 | // events, we need to cache the keysyms from the EKeyEvent events. This is what
|
---|
786 | // resolveS60ScanCode does.
|
---|
787 | TUint s60Keysym = QApplicationPrivate::resolveS60ScanCode(keyEvent.iScanCode,
|
---|
788 | keyEvent.iCode);
|
---|
789 | int keyCode;
|
---|
790 | if (s60Keysym == EKeyNull){ //some key events have 0 in iCode, for them iScanCode should be used
|
---|
791 | keyCode = qt_keymapper_private()->mapS60ScanCodesToQt(keyEvent.iScanCode);
|
---|
792 | } else if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {
|
---|
793 | // Normal characters keys.
|
---|
794 | keyCode = s60Keysym;
|
---|
795 | } else {
|
---|
796 | // Special S60 keys.
|
---|
797 | keyCode = qt_keymapper_private()->mapS60KeyToQt(s60Keysym);
|
---|
798 | }
|
---|
799 |
|
---|
800 | Qt::KeyboardModifiers mods = mapToQtModifiers(keyEvent.iModifiers);
|
---|
801 | QKeyEventEx qKeyEvent(type, keyCode, mods, qt_keymapper_private()->translateKeyEvent(keyCode, mods),
|
---|
802 | (keyEvent.iRepeats != 0), 1, keyEvent.iScanCode, s60Keysym, keyEvent.iModifiers);
|
---|
803 | QWidget *widget;
|
---|
804 | widget = QWidget::keyboardGrabber();
|
---|
805 | if (!widget) {
|
---|
806 | if (QApplicationPrivate::popupWidgets != 0) {
|
---|
807 | widget = QApplication::activePopupWidget()->focusWidget();
|
---|
808 | if (!widget) {
|
---|
809 | widget = QApplication::activePopupWidget();
|
---|
810 | }
|
---|
811 | } else {
|
---|
812 | widget = QApplicationPrivate::focus_widget;
|
---|
813 | if (!widget) {
|
---|
814 | widget = qwidget;
|
---|
815 | }
|
---|
816 | }
|
---|
817 | }
|
---|
818 |
|
---|
819 | QEventDispatcherS60 *dispatcher;
|
---|
820 | // It is theoretically possible for someone to install a different event dispatcher.
|
---|
821 | if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(widget->d_func()->threadData->eventDispatcher)) != 0) {
|
---|
822 | if (dispatcher->excludeUserInputEvents()) {
|
---|
823 | dispatcher->saveInputEvent(this, widget, new QKeyEventEx(qKeyEvent));
|
---|
824 | return EKeyWasConsumed;
|
---|
825 | }
|
---|
826 | }
|
---|
827 | return sendKeyEvent(widget, &qKeyEvent);
|
---|
828 | }
|
---|
829 |
|
---|
830 | TKeyResponse QSymbianControl::handleVirtualMouse(const TKeyEvent& keyEvent,TEventCode type)
|
---|
831 | {
|
---|
832 | #ifndef QT_NO_CURSOR
|
---|
833 | if (S60->mouseInteractionEnabled && S60->virtualMouseRequired) {
|
---|
834 | //translate keys to pointer
|
---|
835 | if ((keyEvent.iScanCode >= EStdKeyLeftArrow && keyEvent.iScanCode <= EStdKeyDownArrow) ||
|
---|
836 | (keyEvent.iScanCode >= EStdKeyDevice10 && keyEvent.iScanCode <= EStdKeyDevice13) ||
|
---|
837 | keyEvent.iScanCode == EStdKeyDevice3) {
|
---|
838 | QPoint pos = QCursor::pos();
|
---|
839 | TPointerEvent fakeEvent;
|
---|
840 | fakeEvent.iType = (TPointerEvent::TType)(-1);
|
---|
841 | fakeEvent.iModifiers = keyEvent.iModifiers;
|
---|
842 | TInt x = pos.x();
|
---|
843 | TInt y = pos.y();
|
---|
844 | if (type == EEventKeyUp) {
|
---|
845 | S60->virtualMouseAccelTimeout.start();
|
---|
846 | switch (keyEvent.iScanCode) {
|
---|
847 | case EStdKeyLeftArrow:
|
---|
848 | S60->virtualMousePressedKeys &= ~QS60Data::Left;
|
---|
849 | break;
|
---|
850 | case EStdKeyRightArrow:
|
---|
851 | S60->virtualMousePressedKeys &= ~QS60Data::Right;
|
---|
852 | break;
|
---|
853 | case EStdKeyUpArrow:
|
---|
854 | S60->virtualMousePressedKeys &= ~QS60Data::Up;
|
---|
855 | break;
|
---|
856 | case EStdKeyDownArrow:
|
---|
857 | S60->virtualMousePressedKeys &= ~QS60Data::Down;
|
---|
858 | break;
|
---|
859 | // diagonal keys (named aliases don't exist in 3.1 SDK)
|
---|
860 | case EStdKeyDevice10:
|
---|
861 | S60->virtualMousePressedKeys &= ~QS60Data::LeftUp;
|
---|
862 | break;
|
---|
863 | case EStdKeyDevice11:
|
---|
864 | S60->virtualMousePressedKeys &= ~QS60Data::RightUp;
|
---|
865 | break;
|
---|
866 | case EStdKeyDevice12:
|
---|
867 | S60->virtualMousePressedKeys &= ~QS60Data::RightDown;
|
---|
868 | break;
|
---|
869 | case EStdKeyDevice13:
|
---|
870 | S60->virtualMousePressedKeys &= ~QS60Data::LeftDown;
|
---|
871 | break;
|
---|
872 | case EStdKeyDevice3: //select
|
---|
873 | if (S60->virtualMousePressedKeys & QS60Data::Select)
|
---|
874 | fakeEvent.iType = TPointerEvent::EButton1Up;
|
---|
875 | S60->virtualMousePressedKeys &= ~QS60Data::Select;
|
---|
876 | break;
|
---|
877 | }
|
---|
878 | }
|
---|
879 | else if (type == EEventKey) {
|
---|
880 | int dx = 0;
|
---|
881 | int dy = 0;
|
---|
882 | if (keyEvent.iScanCode != EStdKeyDevice3) {
|
---|
883 | m_doubleClickTimer.invalidate();
|
---|
884 | //reset mouse accelleration after a short time with no moves
|
---|
885 | const int maxTimeBetweenKeyEventsMs = 500;
|
---|
886 | if (S60->virtualMouseAccelTimeout.isValid() &&
|
---|
887 | S60->virtualMouseAccelTimeout.hasExpired(maxTimeBetweenKeyEventsMs)) {
|
---|
888 | S60->virtualMouseAccelDX = 0;
|
---|
889 | S60->virtualMouseAccelDY = 0;
|
---|
890 | }
|
---|
891 | S60->virtualMouseAccelTimeout.invalidate();
|
---|
892 | }
|
---|
893 | switch (keyEvent.iScanCode) {
|
---|
894 | case EStdKeyLeftArrow:
|
---|
895 | S60->virtualMousePressedKeys |= QS60Data::Left;
|
---|
896 | dx = -1;
|
---|
897 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
898 | break;
|
---|
899 | case EStdKeyRightArrow:
|
---|
900 | S60->virtualMousePressedKeys |= QS60Data::Right;
|
---|
901 | dx = 1;
|
---|
902 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
903 | break;
|
---|
904 | case EStdKeyUpArrow:
|
---|
905 | S60->virtualMousePressedKeys |= QS60Data::Up;
|
---|
906 | dy = -1;
|
---|
907 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
908 | break;
|
---|
909 | case EStdKeyDownArrow:
|
---|
910 | S60->virtualMousePressedKeys |= QS60Data::Down;
|
---|
911 | dy = 1;
|
---|
912 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
913 | break;
|
---|
914 | case EStdKeyDevice10:
|
---|
915 | S60->virtualMousePressedKeys |= QS60Data::LeftUp;
|
---|
916 | dx = -1;
|
---|
917 | dy = -1;
|
---|
918 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
919 | break;
|
---|
920 | case EStdKeyDevice11:
|
---|
921 | S60->virtualMousePressedKeys |= QS60Data::RightUp;
|
---|
922 | dx = 1;
|
---|
923 | dy = -1;
|
---|
924 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
925 | break;
|
---|
926 | case EStdKeyDevice12:
|
---|
927 | S60->virtualMousePressedKeys |= QS60Data::RightDown;
|
---|
928 | dx = 1;
|
---|
929 | dy = 1;
|
---|
930 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
931 | break;
|
---|
932 | case EStdKeyDevice13:
|
---|
933 | S60->virtualMousePressedKeys |= QS60Data::LeftDown;
|
---|
934 | dx = -1;
|
---|
935 | dy = 1;
|
---|
936 | fakeEvent.iType = TPointerEvent::EMove;
|
---|
937 | break;
|
---|
938 | case EStdKeyDevice3:
|
---|
939 | // Platform bug. If you start pressing several keys simultaneously (for
|
---|
940 | // example for drag'n'drop), Symbian starts producing spurious up and
|
---|
941 | // down messages for some keys. Therefore, make sure we have a clean slate
|
---|
942 | // of pressed keys before starting a new button press.
|
---|
943 | if (S60->virtualMousePressedKeys & QS60Data::Select) {
|
---|
944 | return EKeyWasConsumed;
|
---|
945 | } else {
|
---|
946 | S60->virtualMousePressedKeys |= QS60Data::Select;
|
---|
947 | fakeEvent.iType = TPointerEvent::EButton1Down;
|
---|
948 | if (m_doubleClickTimer.isValid()
|
---|
949 | && !m_doubleClickTimer.hasExpired(QApplication::doubleClickInterval())) {
|
---|
950 | fakeEvent.iModifiers |= EModifierDoubleClick;
|
---|
951 | m_doubleClickTimer.invalidate();
|
---|
952 | } else {
|
---|
953 | m_doubleClickTimer.start();
|
---|
954 | }
|
---|
955 | }
|
---|
956 | break;
|
---|
957 | }
|
---|
958 | if (dx) {
|
---|
959 | int cdx = S60->virtualMouseAccelDX;
|
---|
960 | //reset accel on change of sign, else double accel
|
---|
961 | if (dx * cdx <= 0)
|
---|
962 | cdx = dx;
|
---|
963 | else
|
---|
964 | cdx *= 4;
|
---|
965 | //cap accelleration
|
---|
966 | if (dx * cdx > S60->virtualMouseMaxAccel)
|
---|
967 | cdx = dx * S60->virtualMouseMaxAccel;
|
---|
968 | //move mouse position
|
---|
969 | x += cdx;
|
---|
970 | S60->virtualMouseAccelDX = cdx;
|
---|
971 | }
|
---|
972 |
|
---|
973 | if (dy) {
|
---|
974 | int cdy = S60->virtualMouseAccelDY;
|
---|
975 | if (dy * cdy <= 0)
|
---|
976 | cdy = dy;
|
---|
977 | else
|
---|
978 | cdy *= 4;
|
---|
979 | if (dy * cdy > S60->virtualMouseMaxAccel)
|
---|
980 | cdy = dy * S60->virtualMouseMaxAccel;
|
---|
981 | y += cdy;
|
---|
982 | S60->virtualMouseAccelDY = cdy;
|
---|
983 | }
|
---|
984 | }
|
---|
985 | //clip to screen size (window server allows a sprite hotspot to be outside the screen)
|
---|
986 | if (x < 0)
|
---|
987 | x = 0;
|
---|
988 | else if (x >= S60->screenWidthInPixels)
|
---|
989 | x = S60->screenWidthInPixels - 1;
|
---|
990 | if (y < 0)
|
---|
991 | y = 0;
|
---|
992 | else if (y >= S60->screenHeightInPixels)
|
---|
993 | y = S60->screenHeightInPixels - 1;
|
---|
994 | TPoint epos(x, y);
|
---|
995 | TPoint cpos = epos - PositionRelativeToScreen();
|
---|
996 | fakeEvent.iPosition = cpos;
|
---|
997 | fakeEvent.iParentPosition = epos;
|
---|
998 | if(fakeEvent.iType != -1)
|
---|
999 | HandlePointerEvent(fakeEvent);
|
---|
1000 | return EKeyWasConsumed;
|
---|
1001 | }
|
---|
1002 | }
|
---|
1003 | #endif
|
---|
1004 |
|
---|
1005 | return EKeyWasNotConsumed;
|
---|
1006 | }
|
---|
1007 |
|
---|
1008 | void QSymbianControl::sendInputEvent(QWidget *widget, QInputEvent *inputEvent)
|
---|
1009 | {
|
---|
1010 | switch (inputEvent->type()) {
|
---|
1011 | case QEvent::KeyPress:
|
---|
1012 | case QEvent::KeyRelease:
|
---|
1013 | sendKeyEvent(widget, static_cast<QKeyEvent *>(inputEvent));
|
---|
1014 | break;
|
---|
1015 | case QEvent::MouseButtonDblClick:
|
---|
1016 | case QEvent::MouseButtonPress:
|
---|
1017 | case QEvent::MouseButtonRelease:
|
---|
1018 | case QEvent::MouseMove:
|
---|
1019 | sendMouseEvent(widget, static_cast<QMouseEvent *>(inputEvent));
|
---|
1020 | break;
|
---|
1021 | default:
|
---|
1022 | // Shouldn't get here.
|
---|
1023 | Q_ASSERT_X(0 == 1, "QSymbianControl::sendInputEvent()", "inputEvent->type() is unknown");
|
---|
1024 | break;
|
---|
1025 | }
|
---|
1026 | }
|
---|
1027 |
|
---|
1028 | TKeyResponse QSymbianControl::sendKeyEvent(QWidget *widget, QKeyEvent *keyEvent)
|
---|
1029 | {
|
---|
1030 | #if !defined(QT_NO_IM) && defined(Q_WS_S60)
|
---|
1031 | if (widget && widget->isEnabled() && widget->testAttribute(Qt::WA_InputMethodEnabled)) {
|
---|
1032 | QInputContext *qic = widget->inputContext();
|
---|
1033 | if (qic && qic->filterEvent(keyEvent))
|
---|
1034 | return EKeyWasConsumed;
|
---|
1035 | }
|
---|
1036 | #endif // !defined(QT_NO_IM) && defined(Q_OS_SYMBIAN)
|
---|
1037 |
|
---|
1038 | if (widget && qt_sendSpontaneousEvent(widget, keyEvent))
|
---|
1039 | if (keyEvent->isAccepted())
|
---|
1040 | return EKeyWasConsumed;
|
---|
1041 |
|
---|
1042 | return EKeyWasNotConsumed;
|
---|
1043 | }
|
---|
1044 |
|
---|
1045 | #if !defined(QT_NO_IM) && defined(Q_WS_S60)
|
---|
1046 | TCoeInputCapabilities QSymbianControl::InputCapabilities() const
|
---|
1047 | {
|
---|
1048 | QWidget *w = 0;
|
---|
1049 |
|
---|
1050 | if (qwidget->hasFocus())
|
---|
1051 | w = qwidget;
|
---|
1052 | else
|
---|
1053 | w = qwidget->focusWidget();
|
---|
1054 |
|
---|
1055 | QCoeFepInputContext *ic;
|
---|
1056 | if (w && w->isEnabled() && w->testAttribute(Qt::WA_InputMethodEnabled)
|
---|
1057 | && (ic = qobject_cast<QCoeFepInputContext *>(w->inputContext()))) {
|
---|
1058 | return ic->inputCapabilities();
|
---|
1059 | } else {
|
---|
1060 | return TCoeInputCapabilities(TCoeInputCapabilities::ENone, 0, 0);
|
---|
1061 | }
|
---|
1062 | }
|
---|
1063 | #endif
|
---|
1064 |
|
---|
1065 | void QSymbianControl::Draw(const TRect& controlRect) const
|
---|
1066 | {
|
---|
1067 | // Set flag to avoid calling DrawNow in window surface
|
---|
1068 | QWidget *window = qwidget->window();
|
---|
1069 | Q_ASSERT(window);
|
---|
1070 | QTLWExtra *topExtra = window->d_func()->maybeTopData();
|
---|
1071 | Q_ASSERT(topExtra);
|
---|
1072 | if (!topExtra->inExpose) {
|
---|
1073 | topExtra->inExpose = true;
|
---|
1074 | if (!qwidget->isWindow()) {
|
---|
1075 | // If we get here, then it means we have a native child window
|
---|
1076 | // Since no content should ever be painted to these windows, we
|
---|
1077 | // erase them with a transparent brush when they get an expose.
|
---|
1078 | CWindowGc &gc = SystemGc();
|
---|
1079 | gc.SetBrushColor(TRgb(0, 0, 0, 0));
|
---|
1080 | gc.Clear(controlRect);
|
---|
1081 | }
|
---|
1082 | QRect exposeRect = qt_TRect2QRect(controlRect);
|
---|
1083 | qwidget->d_func()->syncBackingStore(exposeRect);
|
---|
1084 | topExtra->inExpose = false;
|
---|
1085 | }
|
---|
1086 |
|
---|
1087 | QWindowSurface *surface = qwidget->windowSurface();
|
---|
1088 | QPaintEngine *engine = surface ? surface->paintDevice()->paintEngine() : NULL;
|
---|
1089 |
|
---|
1090 | if (!engine)
|
---|
1091 | return;
|
---|
1092 |
|
---|
1093 | const bool sendNativePaintEvents = qwidget->d_func()->extraData()->receiveNativePaintEvents;
|
---|
1094 | if (sendNativePaintEvents) {
|
---|
1095 | const QRect r = qt_TRect2QRect(controlRect);
|
---|
1096 | QMetaObject::invokeMethod(qwidget, "beginNativePaintEvent", Qt::DirectConnection, Q_ARG(QRect, r));
|
---|
1097 | }
|
---|
1098 |
|
---|
1099 | // Map source rectangle into coordinates of the backing store.
|
---|
1100 | const QPoint controlBase(controlRect.iTl.iX, controlRect.iTl.iY);
|
---|
1101 | const QPoint backingStoreBase = qwidget->mapTo(qwidget->window(), controlBase);
|
---|
1102 | const TRect backingStoreRect(TPoint(backingStoreBase.x(), backingStoreBase.y()), controlRect.Size());
|
---|
1103 |
|
---|
1104 | if (engine->type() == QPaintEngine::Raster) {
|
---|
1105 | QS60WindowSurface *s60Surface;
|
---|
1106 | #ifdef QT_GRAPHICSSYSTEM_RUNTIME
|
---|
1107 | if (QApplicationPrivate::runtime_graphics_system) {
|
---|
1108 | QRuntimeWindowSurface *rtSurface =
|
---|
1109 | static_cast<QRuntimeWindowSurface*>(qwidget->windowSurface());
|
---|
1110 | s60Surface = static_cast<QS60WindowSurface *>(rtSurface->m_windowSurface.data());
|
---|
1111 | } else
|
---|
1112 | #endif
|
---|
1113 | s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());
|
---|
1114 |
|
---|
1115 | CFbsBitmap *bitmap = s60Surface->symbianBitmap();
|
---|
1116 | CWindowGc &gc = SystemGc();
|
---|
1117 |
|
---|
1118 | QWExtra::NativePaintMode nativePaintMode = qwidget->d_func()->extraData()->nativePaintMode;
|
---|
1119 | if(qwidget->d_func()->paintOnScreen())
|
---|
1120 | nativePaintMode = QWExtra::Disable;
|
---|
1121 |
|
---|
1122 | switch(nativePaintMode) {
|
---|
1123 | case QWExtra::Disable:
|
---|
1124 | // Do nothing
|
---|
1125 | break;
|
---|
1126 | case QWExtra::Blit:
|
---|
1127 | if (qwidget->d_func()->isOpaque)
|
---|
1128 | gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
|
---|
1129 | gc.BitBlt(controlRect.iTl, bitmap, backingStoreRect);
|
---|
1130 | break;
|
---|
1131 | case QWExtra::ZeroFill:
|
---|
1132 | if (Window().DisplayMode() == EColor16MA
|
---|
1133 | || Window().DisplayMode() == Q_SYMBIAN_ECOLOR16MAP) {
|
---|
1134 | gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
|
---|
1135 | gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
|
---|
1136 | gc.SetBrushColor(TRgb::Color16MA(0));
|
---|
1137 | gc.Clear(controlRect);
|
---|
1138 | } else {
|
---|
1139 | gc.SetBrushColor(TRgb(0x000000));
|
---|
1140 | gc.Clear(controlRect);
|
---|
1141 | };
|
---|
1142 | break;
|
---|
1143 | default:
|
---|
1144 | Q_ASSERT(false);
|
---|
1145 | }
|
---|
1146 | }
|
---|
1147 |
|
---|
1148 | if (sendNativePaintEvents) {
|
---|
1149 | const QRect r = qt_TRect2QRect(controlRect);
|
---|
1150 | // The draw ops aren't actually sent to WSERV until the graphics
|
---|
1151 | // context is deactivated, which happens in the function calling
|
---|
1152 | // this one. We therefore delay the delivery of endNativePaintEvent,
|
---|
1153 | // to ensure that drawing has completed by the time the widget
|
---|
1154 | // receives the event. Note that, if the widget needs to ensure
|
---|
1155 | // that the draw ops have actually been executed into the output
|
---|
1156 | // framebuffer, a call to RWsSession::Flush is required in the
|
---|
1157 | // endNativePaintEvent implementation.
|
---|
1158 | QMetaObject::invokeMethod(qwidget, "endNativePaintEvent", Qt::QueuedConnection, Q_ARG(QRect, r));
|
---|
1159 | }
|
---|
1160 | }
|
---|
1161 |
|
---|
1162 | void QSymbianControl::SizeChanged()
|
---|
1163 | {
|
---|
1164 | CCoeControl::SizeChanged();
|
---|
1165 |
|
---|
1166 | QSize oldSize = qwidget->size();
|
---|
1167 | QSize newSize(Size().iWidth, Size().iHeight);
|
---|
1168 |
|
---|
1169 | if (oldSize != newSize) {
|
---|
1170 | QRect cr = qwidget->geometry();
|
---|
1171 | cr.setSize(newSize);
|
---|
1172 | qwidget->data->crect = cr;
|
---|
1173 | if (qwidget->isVisible()) {
|
---|
1174 | QTLWExtra *tlwExtra = qwidget->d_func()->maybeTopData();
|
---|
1175 | bool slowResize = qgetenv("QT_SLOW_TOPLEVEL_RESIZE").toInt();
|
---|
1176 | if (!slowResize && tlwExtra)
|
---|
1177 | tlwExtra->inTopLevelResize = true;
|
---|
1178 | QResizeEvent e(newSize, oldSize);
|
---|
1179 | qt_sendSpontaneousEvent(qwidget, &e);
|
---|
1180 | if (!qwidget->testAttribute(Qt::WA_StaticContents))
|
---|
1181 | qwidget->d_func()->syncBackingStore();
|
---|
1182 | if (!slowResize && tlwExtra)
|
---|
1183 | tlwExtra->inTopLevelResize = false;
|
---|
1184 | } else {
|
---|
1185 | if (!qwidget->testAttribute(Qt::WA_PendingResizeEvent)) {
|
---|
1186 | QResizeEvent *e = new QResizeEvent(newSize, oldSize);
|
---|
1187 | QApplication::postEvent(qwidget, e);
|
---|
1188 | }
|
---|
1189 | }
|
---|
1190 | }
|
---|
1191 |
|
---|
1192 | // CCoeControl::SetExtent calls SizeChanged, but does not call
|
---|
1193 | // PositionChanged, so we call it here to ensure that the widget's
|
---|
1194 | // position is updated.
|
---|
1195 | PositionChanged();
|
---|
1196 | }
|
---|
1197 |
|
---|
1198 | void QSymbianControl::PositionChanged()
|
---|
1199 | {
|
---|
1200 | CCoeControl::PositionChanged();
|
---|
1201 |
|
---|
1202 | QPoint oldPos = qwidget->geometry().topLeft();
|
---|
1203 | QPoint newPos(Position().iX, Position().iY);
|
---|
1204 |
|
---|
1205 | if (oldPos != newPos) {
|
---|
1206 | QRect cr = qwidget->geometry();
|
---|
1207 | cr.moveTopLeft(newPos);
|
---|
1208 | qwidget->data->crect = cr;
|
---|
1209 | QTLWExtra *top = qwidget->d_func()->maybeTopData();
|
---|
1210 | if (top && (qwidget->windowState() & (~Qt::WindowActive)) == Qt::WindowNoState)
|
---|
1211 | top->normalGeometry.moveTopLeft(newPos);
|
---|
1212 | if (qwidget->isVisible()) {
|
---|
1213 | QMoveEvent e(newPos, oldPos);
|
---|
1214 | qt_sendSpontaneousEvent(qwidget, &e);
|
---|
1215 | } else {
|
---|
1216 | QMoveEvent * e = new QMoveEvent(newPos, oldPos);
|
---|
1217 | QApplication::postEvent(qwidget, e);
|
---|
1218 | }
|
---|
1219 | }
|
---|
1220 | }
|
---|
1221 |
|
---|
1222 | void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)
|
---|
1223 | {
|
---|
1224 | if (m_ignoreFocusChanged || (qwidget->windowType() & Qt::WindowType_Mask) == Qt::Desktop)
|
---|
1225 | return;
|
---|
1226 |
|
---|
1227 | // Popups never get focused, but still receive the FocusChanged when they are hidden.
|
---|
1228 | if (QApplicationPrivate::popupWidgets != 0
|
---|
1229 | || (qwidget->windowType() & Qt::Popup) == Qt::Popup)
|
---|
1230 | return;
|
---|
1231 |
|
---|
1232 | if (IsFocused() && IsVisible()) {
|
---|
1233 | if (m_symbianPopupIsOpen) {
|
---|
1234 | QWidget *fw = QApplication::focusWidget();
|
---|
1235 | if (fw) {
|
---|
1236 | QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason);
|
---|
1237 | QCoreApplication::sendEvent(fw, &event);
|
---|
1238 | }
|
---|
1239 | m_symbianPopupIsOpen = false;
|
---|
1240 | }
|
---|
1241 |
|
---|
1242 | QApplication::setActiveWindow(qwidget->window());
|
---|
1243 | qwidget->d_func()->setWindowIcon_sys(true);
|
---|
1244 | qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());
|
---|
1245 | #ifdef Q_WS_S60
|
---|
1246 | if (qwidget->isWindow()) {
|
---|
1247 | QWidget *const window = qwidget->window();
|
---|
1248 | QWidget *parentWindow = window->parentWidget();
|
---|
1249 | if (parentWindow) {
|
---|
1250 | while (parentWindow->parentWidget())
|
---|
1251 | parentWindow = parentWindow->parentWidget();
|
---|
1252 | } else {
|
---|
1253 | parentWindow = window;
|
---|
1254 | }
|
---|
1255 |
|
---|
1256 | const bool parentDecorationsVisible = !(parentWindow->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
|
---|
1257 | const bool parentIsFullscreen = parentWindow->windowState() & Qt::WindowFullScreen;
|
---|
1258 | const bool parentCbaVisibilityHint = parentWindow->windowFlags() & Qt::WindowSoftkeysVisibleHint;
|
---|
1259 | bool buttonGroupVisibility = (parentDecorationsVisible || (parentIsFullscreen && parentCbaVisibilityHint));
|
---|
1260 |
|
---|
1261 | // For non-toplevel normal and maximized windows, show cba if window has softkey
|
---|
1262 | // actions even if topmost parent is not showing cba. Do the same for fullscreen
|
---|
1263 | // windows that request it.
|
---|
1264 | if (!buttonGroupVisibility
|
---|
1265 | && window->parentWidget()
|
---|
1266 | && !(window->windowState() & Qt::WindowMinimized)
|
---|
1267 | && ((window->windowFlags() & Qt::WindowSoftkeysVisibleHint) || !(window->windowState() & Qt::WindowFullScreen))) {
|
---|
1268 | for (int i = 0; i < window->actions().size(); ++i) {
|
---|
1269 | if (window->actions().at(i)->softKeyRole() != QAction::NoSoftKey) {
|
---|
1270 | buttonGroupVisibility = true;
|
---|
1271 | break;
|
---|
1272 | }
|
---|
1273 | }
|
---|
1274 | }
|
---|
1275 | S60->setStatusPaneAndButtonGroupVisibility(parentDecorationsVisible, buttonGroupVisibility);
|
---|
1276 | }
|
---|
1277 | #endif
|
---|
1278 | } else if (QApplication::activeWindow() == qwidget->window()) {
|
---|
1279 | bool focusedControlFound = false;
|
---|
1280 | WId winId = 0;
|
---|
1281 | for (QWidget *w = qwidget->parentWidget(); w && (winId = w->internalWinId()); w = w->parentWidget()) {
|
---|
1282 | if (winId->IsFocused() && winId->IsVisible()) {
|
---|
1283 | focusedControlFound = true;
|
---|
1284 | break;
|
---|
1285 | } else if (w->isWindow())
|
---|
1286 | break;
|
---|
1287 | }
|
---|
1288 | if (!focusedControlFound) {
|
---|
1289 | if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog() || S60->menuBeingConstructed) {
|
---|
1290 | QWidget *fw = QApplication::focusWidget();
|
---|
1291 | if (fw) {
|
---|
1292 | QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);
|
---|
1293 | QCoreApplication::sendEvent(fw, &event);
|
---|
1294 | }
|
---|
1295 | m_symbianPopupIsOpen = true;
|
---|
1296 | return;
|
---|
1297 | }
|
---|
1298 |
|
---|
1299 | QApplication::setActiveWindow(0);
|
---|
1300 | }
|
---|
1301 | }
|
---|
1302 | // else { We don't touch the active window unless we were explicitly activated or deactivated }
|
---|
1303 | }
|
---|
1304 |
|
---|
1305 | void QSymbianControl::handleClientAreaChange()
|
---|
1306 | {
|
---|
1307 | const bool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;
|
---|
1308 | if (qwidget->isFullScreen() && !cbaVisibilityHint) {
|
---|
1309 | SetExtentToWholeScreen();
|
---|
1310 | } else if (qwidget->isMaximized() || (qwidget->isFullScreen() && cbaVisibilityHint)) {
|
---|
1311 | TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
|
---|
1312 | SetExtent(r.iTl, r.Size());
|
---|
1313 | } else if (!qwidget->isMinimized()) { // Normal geometry
|
---|
1314 | if (!qwidget->testAttribute(Qt::WA_Resized)) {
|
---|
1315 | qwidget->adjustSize();
|
---|
1316 | qwidget->setAttribute(Qt::WA_Resized, false); //not a user resize
|
---|
1317 | }
|
---|
1318 | if (!qwidget->testAttribute(Qt::WA_Moved) && qwidget->windowType() != Qt::Dialog) {
|
---|
1319 | TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
|
---|
1320 | SetPosition(r.iTl);
|
---|
1321 | qwidget->setAttribute(Qt::WA_Moved, false); // not really an explicit position
|
---|
1322 | }
|
---|
1323 | }
|
---|
1324 | }
|
---|
1325 |
|
---|
1326 | void QSymbianControl::HandleResourceChange(int resourceType)
|
---|
1327 | {
|
---|
1328 | switch (resourceType) {
|
---|
1329 | case KInternalStatusPaneChange:
|
---|
1330 | handleClientAreaChange();
|
---|
1331 | if (IsFocused() && IsVisible()) {
|
---|
1332 | qwidget->d_func()->setWindowIcon_sys(true);
|
---|
1333 | qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());
|
---|
1334 | }
|
---|
1335 | break;
|
---|
1336 | case KUidValueCoeFontChangeEvent:
|
---|
1337 | // font change event
|
---|
1338 | break;
|
---|
1339 | #ifdef Q_WS_S60
|
---|
1340 | case KEikDynamicLayoutVariantSwitch:
|
---|
1341 | {
|
---|
1342 | handleClientAreaChange();
|
---|
1343 | // Send resize event to trigger desktopwidget workAreaResized signal
|
---|
1344 | QResizeEvent e(qt_desktopWidget->size(), qt_desktopWidget->size());
|
---|
1345 | QApplication::sendEvent(qt_desktopWidget, &e);
|
---|
1346 | break;
|
---|
1347 | }
|
---|
1348 | #endif
|
---|
1349 | default:
|
---|
1350 | break;
|
---|
1351 | }
|
---|
1352 |
|
---|
1353 | CCoeControl::HandleResourceChange(resourceType);
|
---|
1354 |
|
---|
1355 | }
|
---|
1356 | void QSymbianControl::CancelLongTapTimer()
|
---|
1357 | {
|
---|
1358 | m_longTapDetector->Cancel();
|
---|
1359 | }
|
---|
1360 |
|
---|
1361 | TTypeUid::Ptr QSymbianControl::MopSupplyObject(TTypeUid id)
|
---|
1362 | {
|
---|
1363 | if (id.iUid == ETypeId)
|
---|
1364 | return id.MakePtr(this);
|
---|
1365 |
|
---|
1366 | return CCoeControl::MopSupplyObject(id);
|
---|
1367 | }
|
---|
1368 |
|
---|
1369 | void QSymbianControl::setFocusSafely(bool focus)
|
---|
1370 | {
|
---|
1371 | // The stack hack in here is very unfortunate, but it is the only way to ensure proper
|
---|
1372 | // focus in Symbian. If this is not executed, the control which happens to be on
|
---|
1373 | // the top of the stack may randomly be assigned focus by Symbian, for example
|
---|
1374 | // when creating new windows (specifically in CCoeAppUi::HandleStackChanged()).
|
---|
1375 |
|
---|
1376 | // Close any popups.
|
---|
1377 | CEikonEnv::Static()->EikAppUi()->StopDisplayingMenuBar();
|
---|
1378 |
|
---|
1379 | if (focus) {
|
---|
1380 | S60->appUi()->RemoveFromStack(this);
|
---|
1381 | // Symbian doesn't automatically remove focus from the last focused control, so we need to
|
---|
1382 | // remember it and clear focus ourselves.
|
---|
1383 | if (lastFocusedControl && lastFocusedControl != this)
|
---|
1384 | lastFocusedControl->SetFocus(false);
|
---|
1385 | QT_TRAP_THROWING(S60->appUi()->AddToStackL(this,
|
---|
1386 | ECoeStackPriorityDefault + 1, ECoeStackFlagStandard)); // Note the + 1
|
---|
1387 | lastFocusedControl = this;
|
---|
1388 | this->SetFocus(true);
|
---|
1389 | } else {
|
---|
1390 | S60->appUi()->RemoveFromStack(this);
|
---|
1391 | QT_TRAP_THROWING(S60->appUi()->AddToStackL(this,
|
---|
1392 | ECoeStackPriorityDefault, ECoeStackFlagStandard));
|
---|
1393 | if(this == lastFocusedControl)
|
---|
1394 | lastFocusedControl = 0;
|
---|
1395 | this->SetFocus(false);
|
---|
1396 | }
|
---|
1397 | }
|
---|
1398 |
|
---|
1399 | bool QSymbianControl::isControlActive()
|
---|
1400 | {
|
---|
1401 | return IsActivated() ? true : false;
|
---|
1402 | }
|
---|
1403 |
|
---|
1404 | /*!
|
---|
1405 | \typedef QApplication::QS60MainApplicationFactory
|
---|
1406 | \since 4.6
|
---|
1407 |
|
---|
1408 | This is a typedef for a pointer to a function with the following
|
---|
1409 | signature:
|
---|
1410 |
|
---|
1411 | \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 47
|
---|
1412 |
|
---|
1413 | \sa QApplication::QApplication()
|
---|
1414 | */
|
---|
1415 |
|
---|
1416 | /*!
|
---|
1417 | \since 4.6
|
---|
1418 |
|
---|
1419 | Creates an application using the application factory given in
|
---|
1420 | \a factory, and using \a argc command line arguments in \a argv.
|
---|
1421 | \a factory can be leaving, but the error will be converted to a
|
---|
1422 | standard exception.
|
---|
1423 |
|
---|
1424 | This function is only available on S60.
|
---|
1425 | */
|
---|
1426 | QApplication::QApplication(QApplication::QS60MainApplicationFactory factory, int &argc, char **argv)
|
---|
1427 | : QCoreApplication(*new QApplicationPrivate(argc, argv, GuiClient))
|
---|
1428 | {
|
---|
1429 | Q_D(QApplication);
|
---|
1430 | S60->s60ApplicationFactory = factory;
|
---|
1431 | d->construct();
|
---|
1432 | }
|
---|
1433 |
|
---|
1434 | QApplication::QApplication(QApplication::QS60MainApplicationFactory factory, int &argc, char **argv, int _internal)
|
---|
1435 | : QCoreApplication(*new QApplicationPrivate(argc, argv, GuiClient))
|
---|
1436 | {
|
---|
1437 | Q_D(QApplication);
|
---|
1438 | S60->s60ApplicationFactory = factory;
|
---|
1439 | d->construct();
|
---|
1440 | QApplicationPrivate::app_compile_version = _internal;
|
---|
1441 | }
|
---|
1442 |
|
---|
1443 | void qt_init(QApplicationPrivate * /* priv */, int)
|
---|
1444 | {
|
---|
1445 | if (!CCoeEnv::Static()) {
|
---|
1446 | // The S60 framework creates a new trap handler which will render any existing traps
|
---|
1447 | // invalid as long as it is active. This means that all code in main() that occurs after
|
---|
1448 | // the QApplication construction needs to be surrounded by a new trap, despite having
|
---|
1449 | // an outer one already. To avoid this, we save the original trap handler here, and set
|
---|
1450 | // it back after the S60 framework is constructed. Then we restore it right before the S60
|
---|
1451 | // framework destruction.
|
---|
1452 | TTrapHandler *origTrapHandler = User::TrapHandler();
|
---|
1453 |
|
---|
1454 | // The S60 framework has not been initialized. We need to do it.
|
---|
1455 | TApaApplicationFactory factory(S60->s60ApplicationFactory ?
|
---|
1456 | S60->s60ApplicationFactory : newS60Application);
|
---|
1457 | CApaCommandLine* commandLine = 0;
|
---|
1458 | TInt err = CApaCommandLine::GetCommandLineFromProcessEnvironment(commandLine);
|
---|
1459 | // After this construction, CEikonEnv will be available from CEikonEnv::Static().
|
---|
1460 | // (much like our qApp).
|
---|
1461 | QtEikonEnv* coe = new QtEikonEnv;
|
---|
1462 | //not using QT_TRAP_THROWING, because coe owns the cleanupstack so it can't be pushed there.
|
---|
1463 | if(err == KErrNone)
|
---|
1464 | TRAP(err, coe->ConstructAppFromCommandLineL(factory,*commandLine));
|
---|
1465 | delete commandLine;
|
---|
1466 | if(err != KErrNone) {
|
---|
1467 | qWarning() << "qt_init: Eikon application construct failed ("
|
---|
1468 | << err
|
---|
1469 | << "), maybe missing resource file on S60 3.1?";
|
---|
1470 | delete coe;
|
---|
1471 | qt_symbian_throwIfError(err);
|
---|
1472 | }
|
---|
1473 |
|
---|
1474 | S60->s60InstalledTrapHandler = User::SetTrapHandler(origTrapHandler);
|
---|
1475 |
|
---|
1476 | S60->qtOwnsS60Environment = true;
|
---|
1477 | } else {
|
---|
1478 | S60->qtOwnsS60Environment = false;
|
---|
1479 | }
|
---|
1480 |
|
---|
1481 | #ifdef QT_NO_DEBUG
|
---|
1482 | if (!qgetenv("QT_S60_AUTO_FLUSH_WSERV").isEmpty())
|
---|
1483 | #endif
|
---|
1484 | S60->wsSession().SetAutoFlush(ETrue);
|
---|
1485 |
|
---|
1486 | #ifdef Q_SYMBIAN_WINDOW_SIZE_CACHE
|
---|
1487 | TRAP_IGNORE(S60->wsSession().EnableWindowSizeCacheL());
|
---|
1488 | #endif
|
---|
1489 |
|
---|
1490 | S60->updateScreenSize();
|
---|
1491 |
|
---|
1492 |
|
---|
1493 | TDisplayMode mode = S60->screenDevice()->DisplayMode();
|
---|
1494 | S60->screenDepth = TDisplayModeUtils::NumDisplayModeBitsPerPixel(mode);
|
---|
1495 |
|
---|
1496 | //NB: RWsSession::GetColorModeList tells you what window modes are supported,
|
---|
1497 | //not what bitmap formats.
|
---|
1498 | if(QSysInfo::symbianVersion() == QSysInfo::SV_9_2)
|
---|
1499 | S60->supportsPremultipliedAlpha = 0;
|
---|
1500 | else
|
---|
1501 | S60->supportsPremultipliedAlpha = 1;
|
---|
1502 |
|
---|
1503 | RProcess me;
|
---|
1504 | TSecureId securId = me.SecureId();
|
---|
1505 | S60->uid = securId.operator TUid();
|
---|
1506 |
|
---|
1507 | // enable focus events - used to re-enable mouse after focus changed between mouse and non mouse app,
|
---|
1508 | // and for dimming behind modal windows
|
---|
1509 | S60->windowGroup().EnableFocusChangeEvents();
|
---|
1510 |
|
---|
1511 | //Check if mouse interaction is supported (either EMouse=1 in the HAL, or EMachineUID is one of the phones known to support this)
|
---|
1512 | const TInt KMachineUidSamsungI8510 = 0x2000C51E;
|
---|
1513 | // HAL::Get(HALData::EPen, TInt& result) may set 'result' to 1 on some 3.1 systems (e.g. N95).
|
---|
1514 | // But we know that S60 systems below 5.0 did not support touch.
|
---|
1515 | static const bool touchIsUnsupportedOnSystem =
|
---|
1516 | QSysInfo::s60Version() == QSysInfo::SV_S60_3_1
|
---|
1517 | || QSysInfo::s60Version() == QSysInfo::SV_S60_3_2;
|
---|
1518 | TInt machineUID;
|
---|
1519 | TInt mouse;
|
---|
1520 | TInt touch;
|
---|
1521 | TInt err;
|
---|
1522 | err = HAL::Get(HALData::EMouse, mouse);
|
---|
1523 | if (err != KErrNone)
|
---|
1524 | mouse = 0;
|
---|
1525 | err = HAL::Get(HALData::EMachineUid, machineUID);
|
---|
1526 | if (err != KErrNone)
|
---|
1527 | machineUID = 0;
|
---|
1528 | err = HAL::Get(HALData::EPen, touch);
|
---|
1529 | if (err != KErrNone || touchIsUnsupportedOnSystem)
|
---|
1530 | touch = 0;
|
---|
1531 | #ifdef __WINS__
|
---|
1532 | if(QSysInfo::symbianVersion() <= QSysInfo::SV_9_4) {
|
---|
1533 | //for symbian SDK emulator, force values to match typical devices.
|
---|
1534 | mouse = 0;
|
---|
1535 | touch = touchIsUnsupportedOnSystem ? 0 : 1;
|
---|
1536 | }
|
---|
1537 | #endif
|
---|
1538 | if (mouse || machineUID == KMachineUidSamsungI8510) {
|
---|
1539 | S60->hasTouchscreen = false;
|
---|
1540 | S60->virtualMouseRequired = false;
|
---|
1541 | }
|
---|
1542 | else if (!touch) {
|
---|
1543 | S60->hasTouchscreen = false;
|
---|
1544 | S60->virtualMouseRequired = true;
|
---|
1545 | }
|
---|
1546 | else {
|
---|
1547 | S60->hasTouchscreen = true;
|
---|
1548 | S60->virtualMouseRequired = false;
|
---|
1549 | }
|
---|
1550 |
|
---|
1551 | S60->avkonComponentsSupportTransparency = false;
|
---|
1552 | S60->menuBeingConstructed = false;
|
---|
1553 |
|
---|
1554 | #ifdef Q_WS_S60
|
---|
1555 | TUid KCRUidAvkon = { 0x101F876E };
|
---|
1556 | TUint32 KAknAvkonTransparencyEnabled = 0x0000000D;
|
---|
1557 |
|
---|
1558 | CRepository* repository = 0;
|
---|
1559 | TRAP(err, repository = CRepository::NewL(KCRUidAvkon));
|
---|
1560 |
|
---|
1561 | if(err == KErrNone) {
|
---|
1562 | TInt value = 0;
|
---|
1563 | err = repository->Get(KAknAvkonTransparencyEnabled, value);
|
---|
1564 | if(err == KErrNone) {
|
---|
1565 | S60->avkonComponentsSupportTransparency = (value==1) ? true : false;
|
---|
1566 | }
|
---|
1567 | }
|
---|
1568 | delete repository;
|
---|
1569 | repository = 0;
|
---|
1570 | #endif
|
---|
1571 |
|
---|
1572 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
1573 | if (touch) {
|
---|
1574 | QApplicationPrivate::navigationMode = Qt::NavigationModeNone;
|
---|
1575 | } else {
|
---|
1576 | QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadDirectional;
|
---|
1577 | }
|
---|
1578 | #endif
|
---|
1579 |
|
---|
1580 | #ifndef QT_NO_CURSOR
|
---|
1581 | //Check if window server pointer cursors are supported or not
|
---|
1582 | #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
|
---|
1583 | //In generic binary, use the HAL and OS version
|
---|
1584 | //Any other known good phones should be added here.
|
---|
1585 | if (machineUID == KMachineUidSamsungI8510 || (QSysInfo::symbianVersion() != QSysInfo::SV_9_4
|
---|
1586 | && QSysInfo::symbianVersion() != QSysInfo::SV_9_3 && QSysInfo::symbianVersion()
|
---|
1587 | != QSysInfo::SV_9_2)) {
|
---|
1588 | S60->brokenPointerCursors = false;
|
---|
1589 | qt_symbian_setWindowGroupCursor(Qt::ArrowCursor, S60->windowGroup());
|
---|
1590 | }
|
---|
1591 | else
|
---|
1592 | S60->brokenPointerCursors = true;
|
---|
1593 | #endif
|
---|
1594 |
|
---|
1595 | if (S60->mouseInteractionEnabled) {
|
---|
1596 | #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
|
---|
1597 | if (S60->brokenPointerCursors) {
|
---|
1598 | qt_symbian_set_pointer_sprite(Qt::ArrowCursor);
|
---|
1599 | qt_symbian_show_pointer_sprite();
|
---|
1600 | }
|
---|
1601 | else
|
---|
1602 | #endif
|
---|
1603 | S60->wsSession().SetPointerCursorMode(EPointerCursorNormal);
|
---|
1604 | }
|
---|
1605 | #endif
|
---|
1606 |
|
---|
1607 | QFont systemFont;
|
---|
1608 | systemFont.setFamily(systemFont.defaultFamily());
|
---|
1609 | QApplicationPrivate::setSystemFont(systemFont);
|
---|
1610 |
|
---|
1611 | #ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
|
---|
1612 | QObject::connect(qApp, SIGNAL(aboutToQuit()), qApp, SLOT(_q_aboutToQuit()));
|
---|
1613 | #endif
|
---|
1614 |
|
---|
1615 | /*
|
---|
1616 | ### Commented out for now as parameter handling not needed in SOS(yet). Code below will break testlib with -o flag
|
---|
1617 | int argc = priv->argc;
|
---|
1618 | char **argv = priv->argv;
|
---|
1619 |
|
---|
1620 | // Get command line params
|
---|
1621 | int j = argc ? 1 : 0;
|
---|
1622 | for (int i=1; i<argc; i++) {
|
---|
1623 | if (argv[i] && *argv[i] != '-') {
|
---|
1624 | argv[j++] = argv[i];
|
---|
1625 | continue;
|
---|
1626 | }
|
---|
1627 |
|
---|
1628 | #if defined(QT_DEBUG)
|
---|
1629 | if (qstrcmp(argv[i], "-nograb") == 0)
|
---|
1630 | appNoGrab = !appNoGrab;
|
---|
1631 | else
|
---|
1632 | #endif // QT_DEBUG
|
---|
1633 | ;
|
---|
1634 | }
|
---|
1635 | */
|
---|
1636 |
|
---|
1637 | // Register WId with the metatype system. This is to enable
|
---|
1638 | // QWidgetPrivate::create_sys to used delayed slot invocation in order
|
---|
1639 | // to destroy WId objects during reparenting.
|
---|
1640 | qRegisterMetaType<WId>("WId");
|
---|
1641 | }
|
---|
1642 |
|
---|
1643 | extern void qt_cleanup_symbianFontDatabase(); // qfontdatabase_s60.cpp
|
---|
1644 |
|
---|
1645 | /*****************************************************************************
|
---|
1646 | qt_cleanup() - cleans up when the application is finished
|
---|
1647 | *****************************************************************************/
|
---|
1648 | void qt_cleanup()
|
---|
1649 | {
|
---|
1650 | if(qt_S60Beep) {
|
---|
1651 | delete qt_S60Beep;
|
---|
1652 | qt_S60Beep = 0;
|
---|
1653 | }
|
---|
1654 | QFontCache::cleanup(); // Has to happen now, since QFontEngineS60 has FBS handles
|
---|
1655 | QPixmapCache::clear(); // Has to happen now, since QS60PixmapData has FBS handles
|
---|
1656 |
|
---|
1657 | qt_cleanup_symbianFontDatabase();
|
---|
1658 | // S60 structure and window server session are freed in eventdispatcher destructor as they are needed there
|
---|
1659 |
|
---|
1660 | // It's important that this happens here, before the event dispatcher gets
|
---|
1661 | // deleted, because the input context needs the event loop one last time before
|
---|
1662 | // it dies.
|
---|
1663 | delete QApplicationPrivate::inputContext;
|
---|
1664 | QApplicationPrivate::inputContext = 0;
|
---|
1665 |
|
---|
1666 | //Change mouse pointer back
|
---|
1667 | S60->wsSession().SetPointerCursorMode(EPointerCursorNone);
|
---|
1668 |
|
---|
1669 | #ifdef Q_WS_S60
|
---|
1670 | // Clear CBA
|
---|
1671 | CEikonEnv::Static()->AppUiFactory()->SwapButtonGroup(0);
|
---|
1672 | delete S60->buttonGroupContainer();
|
---|
1673 | S60->setButtonGroupContainer(0);
|
---|
1674 | #endif
|
---|
1675 |
|
---|
1676 | if (S60->qtOwnsS60Environment) {
|
---|
1677 | // Restore the S60 framework trap handler. See qt_init().
|
---|
1678 | User::SetTrapHandler(S60->s60InstalledTrapHandler);
|
---|
1679 |
|
---|
1680 | CEikonEnv* coe = CEikonEnv::Static();
|
---|
1681 | coe->PrepareToExit();
|
---|
1682 | // The CEikonEnv itself is destroyed in here.
|
---|
1683 | coe->DestroyEnvironment();
|
---|
1684 | }
|
---|
1685 | }
|
---|
1686 |
|
---|
1687 | void QApplicationPrivate::initializeWidgetPaletteHash()
|
---|
1688 | {
|
---|
1689 | // TODO: Implement QApplicationPrivate::initializeWidgetPaletteHash()
|
---|
1690 | // Possibly a task fot the S60Style guys
|
---|
1691 | }
|
---|
1692 |
|
---|
1693 | void QApplicationPrivate::createEventDispatcher()
|
---|
1694 | {
|
---|
1695 | Q_Q(QApplication);
|
---|
1696 | eventDispatcher = new QEventDispatcherS60(q);
|
---|
1697 | }
|
---|
1698 |
|
---|
1699 | QString QApplicationPrivate::appName() const
|
---|
1700 | {
|
---|
1701 | return QCoreApplicationPrivate::appName();
|
---|
1702 | }
|
---|
1703 |
|
---|
1704 | bool QApplicationPrivate::modalState()
|
---|
1705 | {
|
---|
1706 | return app_do_modal;
|
---|
1707 | }
|
---|
1708 |
|
---|
1709 | void QApplicationPrivate::enterModal_sys(QWidget *widget)
|
---|
1710 | {
|
---|
1711 | #ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
|
---|
1712 | S60->wsSession().SendEffectCommand(ETfxCmdAppModalModeEnter);
|
---|
1713 | #endif
|
---|
1714 | if (widget) {
|
---|
1715 | static_cast<QSymbianControl *>(widget->effectiveWinId())->FadeBehindPopup(ETrue);
|
---|
1716 | // Modal partial screen dialogs (like queries) capture pointer events.
|
---|
1717 | // ### FixMe: Add specialized behaviour for fullscreen modal dialogs
|
---|
1718 | widget->effectiveWinId()->SetGloballyCapturing(ETrue);
|
---|
1719 | widget->effectiveWinId()->SetPointerCapture(ETrue);
|
---|
1720 | }
|
---|
1721 | if (!qt_modal_stack)
|
---|
1722 | qt_modal_stack = new QWidgetList;
|
---|
1723 | qt_modal_stack->insert(0, widget);
|
---|
1724 | app_do_modal = true;
|
---|
1725 | }
|
---|
1726 |
|
---|
1727 | void QApplicationPrivate::leaveModal_sys(QWidget *widget)
|
---|
1728 | {
|
---|
1729 | #ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
|
---|
1730 | S60->wsSession().SendEffectCommand(ETfxCmdAppModalModeExit);
|
---|
1731 | #endif
|
---|
1732 | if (widget) {
|
---|
1733 | static_cast<QSymbianControl *>(widget->effectiveWinId())->FadeBehindPopup(EFalse);
|
---|
1734 | // ### FixMe: Add specialized behaviour for fullscreen modal dialogs
|
---|
1735 | widget->effectiveWinId()->SetGloballyCapturing(EFalse);
|
---|
1736 | widget->effectiveWinId()->SetPointerCapture(EFalse);
|
---|
1737 | }
|
---|
1738 | if (qt_modal_stack && qt_modal_stack->removeAll(widget)) {
|
---|
1739 | if (qt_modal_stack->isEmpty()) {
|
---|
1740 | delete qt_modal_stack;
|
---|
1741 | qt_modal_stack = 0;
|
---|
1742 | }
|
---|
1743 | }
|
---|
1744 | app_do_modal = qt_modal_stack != 0;
|
---|
1745 | }
|
---|
1746 |
|
---|
1747 | void QApplicationPrivate::openPopup(QWidget *popup)
|
---|
1748 | {
|
---|
1749 | if (popup && qobject_cast<QComboBox *>(popup->parentWidget()))
|
---|
1750 | static_cast<QSymbianControl *>(popup->effectiveWinId())->FadeBehindPopup(ETrue);
|
---|
1751 |
|
---|
1752 | if (!QApplicationPrivate::popupWidgets)
|
---|
1753 | QApplicationPrivate::popupWidgets = new QWidgetList;
|
---|
1754 | QApplicationPrivate::popupWidgets->append(popup);
|
---|
1755 |
|
---|
1756 | // Cancel focus widget pointer capture and long tap timer
|
---|
1757 | if (QApplication::focusWidget()) {
|
---|
1758 | static_cast<QSymbianControl*>(QApplication::focusWidget()->effectiveWinId())->CancelLongTapTimer();
|
---|
1759 | QApplication::focusWidget()->effectiveWinId()->SetPointerCapture(false);
|
---|
1760 | }
|
---|
1761 |
|
---|
1762 | if (!qt_nograb()) {
|
---|
1763 | // Cancel pointer capture and long tap timer for earlier popup
|
---|
1764 | int popupCount = QApplicationPrivate::popupWidgets->count();
|
---|
1765 | if (popupCount > 1) {
|
---|
1766 | QWidget* prevPopup = QApplicationPrivate::popupWidgets->at(popupCount-2);
|
---|
1767 | static_cast<QSymbianControl*>(prevPopup->effectiveWinId())->CancelLongTapTimer();
|
---|
1768 | prevPopup->effectiveWinId()->SetPointerCapture(false);
|
---|
1769 | }
|
---|
1770 |
|
---|
1771 | // Enable pointer capture for this (topmost) popup
|
---|
1772 | Q_ASSERT(popup->testAttribute(Qt::WA_WState_Created));
|
---|
1773 | WId id = popup->effectiveWinId();
|
---|
1774 | id->SetPointerCapture(true);
|
---|
1775 | }
|
---|
1776 |
|
---|
1777 | // popups are not focus-handled by the window system (the first
|
---|
1778 | // popup grabbed the keyboard), so we have to do that manually: A
|
---|
1779 | // new popup gets the focus
|
---|
1780 | QWidget *fw = popup->focusWidget();
|
---|
1781 | if (fw) {
|
---|
1782 | fw->setFocus(Qt::PopupFocusReason);
|
---|
1783 | } else if (QApplicationPrivate::popupWidgets->count() == 1) { // this was the first popup
|
---|
1784 | fw = QApplication::focusWidget();
|
---|
1785 | if (fw) {
|
---|
1786 | QFocusEvent e(QEvent::FocusOut, Qt::PopupFocusReason);
|
---|
1787 | q_func()->sendEvent(fw, &e);
|
---|
1788 | }
|
---|
1789 | }
|
---|
1790 | }
|
---|
1791 |
|
---|
1792 | void QApplicationPrivate::closePopup(QWidget *popup)
|
---|
1793 | {
|
---|
1794 | if (popup && qobject_cast<QComboBox *>(popup->parentWidget()))
|
---|
1795 | static_cast<QSymbianControl *>(popup->effectiveWinId())->FadeBehindPopup(EFalse);
|
---|
1796 |
|
---|
1797 | if (!QApplicationPrivate::popupWidgets)
|
---|
1798 | return;
|
---|
1799 | QApplicationPrivate::popupWidgets->removeAll(popup);
|
---|
1800 |
|
---|
1801 | // Cancel pointer capture and long tap for this popup
|
---|
1802 | WId id = popup->effectiveWinId();
|
---|
1803 | id->SetPointerCapture(false);
|
---|
1804 | static_cast<QSymbianControl*>(id)->CancelLongTapTimer();
|
---|
1805 |
|
---|
1806 | if (QApplicationPrivate::popupWidgets->isEmpty()) { // this was the last popup
|
---|
1807 | delete QApplicationPrivate::popupWidgets;
|
---|
1808 | QApplicationPrivate::popupWidgets = 0;
|
---|
1809 | if (!qt_nograb()) { // grabbing not disabled
|
---|
1810 | Q_ASSERT(popup->testAttribute(Qt::WA_WState_Created));
|
---|
1811 | if (QWidgetPrivate::mouseGrabber != 0)
|
---|
1812 | QWidgetPrivate::mouseGrabber->grabMouse();
|
---|
1813 |
|
---|
1814 | if (QWidgetPrivate::keyboardGrabber != 0)
|
---|
1815 | QWidgetPrivate::keyboardGrabber->grabKeyboard();
|
---|
1816 |
|
---|
1817 | QWidget *fw = QApplicationPrivate::active_window ? QApplicationPrivate::active_window->focusWidget()
|
---|
1818 | : q_func()->focusWidget();
|
---|
1819 | if (fw) {
|
---|
1820 | if(fw->window()->isModal()) // restore pointer capture for modal window
|
---|
1821 | fw->effectiveWinId()->SetPointerCapture(true);
|
---|
1822 |
|
---|
1823 | if (fw != q_func()->focusWidget()) {
|
---|
1824 | fw->setFocus(Qt::PopupFocusReason);
|
---|
1825 | } else {
|
---|
1826 | QFocusEvent e(QEvent::FocusIn, Qt::PopupFocusReason);
|
---|
1827 | q_func()->sendEvent(fw, &e);
|
---|
1828 | }
|
---|
1829 | }
|
---|
1830 | }
|
---|
1831 | } else {
|
---|
1832 |
|
---|
1833 | // popups are not focus-handled by the window system (the
|
---|
1834 | // first popup grabbed the keyboard), so we have to do that
|
---|
1835 | // manually: A popup was closed, so the previous popup gets
|
---|
1836 | // the focus.
|
---|
1837 | QWidget* aw = QApplicationPrivate::popupWidgets->last();
|
---|
1838 | if (QWidget *fw = QApplication::focusWidget()) {
|
---|
1839 | QFocusEvent e(QEvent::FocusOut, Qt::PopupFocusReason);
|
---|
1840 | q_func()->sendEvent(fw, &e);
|
---|
1841 | }
|
---|
1842 |
|
---|
1843 | // Enable pointer capture for previous popup
|
---|
1844 | if (aw) {
|
---|
1845 | aw->effectiveWinId()->SetPointerCapture(true);
|
---|
1846 | }
|
---|
1847 | }
|
---|
1848 | }
|
---|
1849 |
|
---|
1850 | QWidget * QApplication::topLevelAt(QPoint const& point)
|
---|
1851 | {
|
---|
1852 | QWidget *found = 0;
|
---|
1853 | int lowestZ = INT_MAX;
|
---|
1854 | QWidgetList list = QApplication::topLevelWidgets();
|
---|
1855 | for (int i = 0; i < list.count(); ++i) {
|
---|
1856 | QWidget *widget = list.at(i);
|
---|
1857 | if (widget->isVisible() && !(widget->windowType() == Qt::Desktop)) {
|
---|
1858 | Q_ASSERT(widget->testAttribute(Qt::WA_WState_Created));
|
---|
1859 | if (widget->geometry().adjusted(0,0,1,1).contains(point)) {
|
---|
1860 | // At this point we know there is a Qt widget under the point.
|
---|
1861 | // Now we need to make sure it is the top most in the z-order.
|
---|
1862 | RDrawableWindow *const window = widget->effectiveWinId()->DrawableWindow();
|
---|
1863 | int z = window->OrdinalPosition();
|
---|
1864 | if (z < lowestZ) {
|
---|
1865 | lowestZ = z;
|
---|
1866 | found = widget;
|
---|
1867 | }
|
---|
1868 | }
|
---|
1869 | }
|
---|
1870 | }
|
---|
1871 | return found;
|
---|
1872 | }
|
---|
1873 |
|
---|
1874 | void QApplication::alert(QWidget * /* widget */, int /* duration */)
|
---|
1875 | {
|
---|
1876 | // TODO: Implement QApplication::alert(QWidget *widget, int duration)
|
---|
1877 | }
|
---|
1878 |
|
---|
1879 | int QApplication::doubleClickInterval()
|
---|
1880 | {
|
---|
1881 | TTimeIntervalMicroSeconds32 us;
|
---|
1882 | TInt distance;
|
---|
1883 | S60->wsSession().GetDoubleClickSettings(us, distance);
|
---|
1884 | return (us.Int() / 1000);
|
---|
1885 | }
|
---|
1886 |
|
---|
1887 | void QApplication::setDoubleClickInterval(int ms)
|
---|
1888 | {
|
---|
1889 | TTimeIntervalMicroSeconds32 newUs( ms * 1000);
|
---|
1890 | TTimeIntervalMicroSeconds32 us;
|
---|
1891 | TInt distance;
|
---|
1892 | S60->wsSession().GetDoubleClickSettings(us, distance);
|
---|
1893 | if (us != newUs)
|
---|
1894 | S60->wsSession().SetDoubleClick(newUs, distance);
|
---|
1895 | }
|
---|
1896 |
|
---|
1897 | int QApplication::keyboardInputInterval()
|
---|
1898 | {
|
---|
1899 | return QApplicationPrivate::keyboard_input_time;
|
---|
1900 | }
|
---|
1901 |
|
---|
1902 | void QApplication::setKeyboardInputInterval(int ms)
|
---|
1903 | {
|
---|
1904 | QApplicationPrivate::keyboard_input_time = ms;
|
---|
1905 | }
|
---|
1906 |
|
---|
1907 | int QApplication::cursorFlashTime()
|
---|
1908 | {
|
---|
1909 | return QApplicationPrivate::cursor_flash_time;
|
---|
1910 | }
|
---|
1911 |
|
---|
1912 | void QApplication::setCursorFlashTime(int msecs)
|
---|
1913 | {
|
---|
1914 | QApplicationPrivate::cursor_flash_time = msecs;
|
---|
1915 | }
|
---|
1916 |
|
---|
1917 | void QApplication::beep()
|
---|
1918 | {
|
---|
1919 | if (!qt_S60Beep) {
|
---|
1920 | TInt frequency = 880;
|
---|
1921 | TTimeIntervalMicroSeconds duration(500000);
|
---|
1922 | TRAP_IGNORE(qt_S60Beep=QS60Beep::NewL(frequency, duration));
|
---|
1923 | }
|
---|
1924 | if (qt_S60Beep)
|
---|
1925 | qt_S60Beep->Play();
|
---|
1926 | }
|
---|
1927 |
|
---|
1928 | static inline bool callSymbianEventFilters(const QSymbianEvent *event)
|
---|
1929 | {
|
---|
1930 | long unused;
|
---|
1931 | return qApp->filterEvent(const_cast<QSymbianEvent *>(event), &unused);
|
---|
1932 | }
|
---|
1933 |
|
---|
1934 | /*!
|
---|
1935 | \warning This function is only available on Symbian.
|
---|
1936 | \since 4.6
|
---|
1937 |
|
---|
1938 | This function processes an individual Symbian event
|
---|
1939 | \a event. It returns 1 if the event was handled, 0 if
|
---|
1940 | the \a event was not handled, and -1 if the event was
|
---|
1941 | not handled because the event is not known to Qt.
|
---|
1942 | */
|
---|
1943 |
|
---|
1944 | int QApplication::symbianProcessEvent(const QSymbianEvent *event)
|
---|
1945 | {
|
---|
1946 | Q_D(QApplication);
|
---|
1947 |
|
---|
1948 | QScopedLoopLevelCounter counter(d->threadData);
|
---|
1949 |
|
---|
1950 | if (d->eventDispatcher->filterEvent(const_cast<QSymbianEvent *>(event)))
|
---|
1951 | return 1;
|
---|
1952 |
|
---|
1953 | QWidget *w = qApp ? qApp->focusWidget() : 0;
|
---|
1954 | if (w) {
|
---|
1955 | QInputContext *ic = w->inputContext();
|
---|
1956 | if (ic && ic->symbianFilterEvent(w, event))
|
---|
1957 | return 1;
|
---|
1958 | }
|
---|
1959 |
|
---|
1960 | if (symbianEventFilter(event))
|
---|
1961 | return 1;
|
---|
1962 |
|
---|
1963 | switch (event->type()) {
|
---|
1964 | case QSymbianEvent::WindowServerEvent:
|
---|
1965 | return d->symbianProcessWsEvent(event);
|
---|
1966 | case QSymbianEvent::CommandEvent:
|
---|
1967 | return d->symbianHandleCommand(event);
|
---|
1968 | case QSymbianEvent::ResourceChangeEvent:
|
---|
1969 | return d->symbianResourceChange(event);
|
---|
1970 | default:
|
---|
1971 | return -1;
|
---|
1972 | }
|
---|
1973 | }
|
---|
1974 |
|
---|
1975 | int QApplicationPrivate::symbianProcessWsEvent(const QSymbianEvent *symbianEvent)
|
---|
1976 | {
|
---|
1977 | // Qt event handling. Handle some events regardless of if the handle is in our
|
---|
1978 | // widget map or not.
|
---|
1979 | const TWsEvent *event = symbianEvent->windowServerEvent();
|
---|
1980 | CCoeControl* control = reinterpret_cast<CCoeControl*>(event->Handle());
|
---|
1981 | const bool controlInMap = QWidgetPrivate::mapper && QWidgetPrivate::mapper->contains(control);
|
---|
1982 | switch (event->Type()) {
|
---|
1983 | case EEventPointerEnter:
|
---|
1984 | if (controlInMap) {
|
---|
1985 | callSymbianEventFilters(symbianEvent);
|
---|
1986 | return 1; // Qt::Enter will be generated in HandlePointerL
|
---|
1987 | }
|
---|
1988 | break;
|
---|
1989 | case EEventPointerExit:
|
---|
1990 | if (controlInMap) {
|
---|
1991 | if (callSymbianEventFilters(symbianEvent))
|
---|
1992 | return 1;
|
---|
1993 | if (S60) {
|
---|
1994 | // mouseEvent outside our window, send leave event to last focused widget
|
---|
1995 | QMouseEvent mEvent(QEvent::Leave, S60->lastPointerEventPos, S60->lastCursorPos,
|
---|
1996 | Qt::NoButton, QApplicationPrivate::mouse_buttons, Qt::NoModifier);
|
---|
1997 | if (S60->lastPointerEventTarget)
|
---|
1998 | qt_sendSpontaneousEvent(S60->lastPointerEventTarget,&mEvent);
|
---|
1999 | S60->lastPointerEventTarget = 0;
|
---|
2000 | }
|
---|
2001 | return 1;
|
---|
2002 | }
|
---|
2003 | break;
|
---|
2004 | case EEventScreenDeviceChanged:
|
---|
2005 | if (callSymbianEventFilters(symbianEvent))
|
---|
2006 | return 1;
|
---|
2007 | if (S60)
|
---|
2008 | S60->updateScreenSize();
|
---|
2009 | if (qt_desktopWidget) {
|
---|
2010 | QSize oldSize = qt_desktopWidget->size();
|
---|
2011 | qt_desktopWidget->data->crect.setWidth(S60->screenWidthInPixels);
|
---|
2012 | qt_desktopWidget->data->crect.setHeight(S60->screenHeightInPixels);
|
---|
2013 | QResizeEvent e(qt_desktopWidget->size(), oldSize);
|
---|
2014 | QApplication::sendEvent(qt_desktopWidget, &e);
|
---|
2015 | }
|
---|
2016 | return 0; // Propagate to CONE
|
---|
2017 | case EEventWindowVisibilityChanged:
|
---|
2018 | if (controlInMap) {
|
---|
2019 | if (callSymbianEventFilters(symbianEvent))
|
---|
2020 | return 1;
|
---|
2021 | const TWsVisibilityChangedEvent *visChangedEvent = event->VisibilityChanged();
|
---|
2022 | if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::ENotVisible)
|
---|
2023 | S60->controlVisibilityChanged(control, false);
|
---|
2024 | else if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::EPartiallyVisible)
|
---|
2025 | S60->controlVisibilityChanged(control, true);
|
---|
2026 | return 1;
|
---|
2027 | }
|
---|
2028 | break;
|
---|
2029 | case EEventFocusGained:
|
---|
2030 | if (callSymbianEventFilters(symbianEvent))
|
---|
2031 | return 1;
|
---|
2032 | #ifndef QT_NO_CURSOR
|
---|
2033 | //re-enable mouse interaction
|
---|
2034 | if (S60->mouseInteractionEnabled) {
|
---|
2035 | #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
|
---|
2036 | if (S60->brokenPointerCursors)
|
---|
2037 | qt_symbian_show_pointer_sprite();
|
---|
2038 | else
|
---|
2039 | #endif
|
---|
2040 | S60->wsSession().SetPointerCursorMode(EPointerCursorNormal);
|
---|
2041 | }
|
---|
2042 | #endif
|
---|
2043 | #ifdef QT_SOFTKEYS_ENABLED
|
---|
2044 | QSoftKeyManager::updateSoftKeys();
|
---|
2045 | #endif
|
---|
2046 | break;
|
---|
2047 | case EEventFocusLost:
|
---|
2048 | if (callSymbianEventFilters(symbianEvent))
|
---|
2049 | return 1;
|
---|
2050 | #ifndef QT_NO_CURSOR
|
---|
2051 | //disable mouse as may be moving to application that does not support it
|
---|
2052 | if (S60->mouseInteractionEnabled) {
|
---|
2053 | #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
|
---|
2054 | if (S60->brokenPointerCursors)
|
---|
2055 | qt_symbian_hide_pointer_sprite();
|
---|
2056 | else
|
---|
2057 | #endif
|
---|
2058 | S60->wsSession().SetPointerCursorMode(EPointerCursorNone);
|
---|
2059 | }
|
---|
2060 | #endif
|
---|
2061 | break;
|
---|
2062 | case KGoomMemoryLowEvent:
|
---|
2063 | #ifdef QT_DEBUG
|
---|
2064 | qDebug() << "QApplicationPrivate::symbianProcessWsEvent - KGoomMemoryLowEvent";
|
---|
2065 | #endif
|
---|
2066 | if (callSymbianEventFilters(symbianEvent))
|
---|
2067 | return 1;
|
---|
2068 | #ifdef QT_GRAPHICSSYSTEM_RUNTIME
|
---|
2069 | if(QApplicationPrivate::runtime_graphics_system) {
|
---|
2070 | bool switchToSwRendering(false);
|
---|
2071 |
|
---|
2072 | foreach (QWidget *w, QApplication::topLevelWidgets()) {
|
---|
2073 | if(w->d_func()->topData()->backingStore) {
|
---|
2074 | switchToSwRendering = true;
|
---|
2075 | break;
|
---|
2076 | }
|
---|
2077 | }
|
---|
2078 |
|
---|
2079 | if (switchToSwRendering) {
|
---|
2080 | QRuntimeGraphicsSystem *gs =
|
---|
2081 | static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
|
---|
2082 | gs->setGraphicsSystem(QLatin1String("raster"));
|
---|
2083 | }
|
---|
2084 | }
|
---|
2085 | #endif
|
---|
2086 | break;
|
---|
2087 | case KGoomMemoryGoodEvent:
|
---|
2088 | #ifdef QT_DEBUG
|
---|
2089 | qDebug() << "QApplicationPrivate::symbianProcessWsEvent - KGoomMemoryGoodEvent";
|
---|
2090 | #endif
|
---|
2091 | if (callSymbianEventFilters(symbianEvent))
|
---|
2092 | return 1;
|
---|
2093 | #ifdef QT_GRAPHICSSYSTEM_RUNTIME
|
---|
2094 | if(QApplicationPrivate::runtime_graphics_system) {
|
---|
2095 | QRuntimeGraphicsSystem *gs =
|
---|
2096 | static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
|
---|
2097 | gs->setGraphicsSystem(QLatin1String("openvg"));
|
---|
2098 | }
|
---|
2099 | #endif
|
---|
2100 | break;
|
---|
2101 | #ifdef Q_SYMBIAN_SUPPORTS_SURFACES
|
---|
2102 | case EEventUser:
|
---|
2103 | {
|
---|
2104 | // GOOM is looking for candidates to kill so indicate that we are
|
---|
2105 | // capable of cleaning up by handling this event
|
---|
2106 | TInt32 *data = reinterpret_cast<TInt32 *>(event->EventData());
|
---|
2107 | if (data[0] == EApaSystemEventShutdown && data[1] == KGoomMemoryLowEvent)
|
---|
2108 | return 1;
|
---|
2109 | }
|
---|
2110 | break;
|
---|
2111 | #endif
|
---|
2112 | default:
|
---|
2113 | break;
|
---|
2114 | }
|
---|
2115 |
|
---|
2116 | if (!controlInMap)
|
---|
2117 | return -1;
|
---|
2118 |
|
---|
2119 | return 0;
|
---|
2120 | }
|
---|
2121 |
|
---|
2122 | /*!
|
---|
2123 | \warning This virtual function is only available on Symbian.
|
---|
2124 | \since 4.6
|
---|
2125 |
|
---|
2126 | If you create an application that inherits QApplication and reimplement
|
---|
2127 | this function, you get direct access to events that the are received
|
---|
2128 | from Symbian. The events are passed in the \a event parameter.
|
---|
2129 |
|
---|
2130 | Return true if you want to stop the event from being processed. Return
|
---|
2131 | false for normal event dispatching. The default implementation returns
|
---|
2132 | false, and does nothing with \a event.
|
---|
2133 | */
|
---|
2134 | bool QApplication::symbianEventFilter(const QSymbianEvent *event)
|
---|
2135 | {
|
---|
2136 | Q_UNUSED(event);
|
---|
2137 | return false;
|
---|
2138 | }
|
---|
2139 |
|
---|
2140 | /*!
|
---|
2141 | \warning This function is only available on Symbian.
|
---|
2142 | \since 4.6
|
---|
2143 |
|
---|
2144 | Handles \a{command}s which are typically handled by
|
---|
2145 | CAknAppUi::HandleCommandL(). Qts Ui integration into Symbian is
|
---|
2146 | partially achieved by deriving from CAknAppUi. Currently, exit,
|
---|
2147 | menu and softkey commands are handled.
|
---|
2148 |
|
---|
2149 | \sa s60EventFilter(), s60ProcessEvent()
|
---|
2150 | */
|
---|
2151 | int QApplicationPrivate::symbianHandleCommand(const QSymbianEvent *symbianEvent)
|
---|
2152 | {
|
---|
2153 | Q_Q(QApplication);
|
---|
2154 | int ret = 0;
|
---|
2155 |
|
---|
2156 | if (callSymbianEventFilters(symbianEvent))
|
---|
2157 | return 1;
|
---|
2158 |
|
---|
2159 | int command = symbianEvent->command();
|
---|
2160 |
|
---|
2161 | switch (command) {
|
---|
2162 | #ifdef Q_WS_S60
|
---|
2163 | case EAknSoftkeyExit: {
|
---|
2164 | QCloseEvent ev;
|
---|
2165 | QApplication::sendSpontaneousEvent(q, &ev);
|
---|
2166 | if (ev.isAccepted()) {
|
---|
2167 | q->quit();
|
---|
2168 | ret = 1;
|
---|
2169 | }
|
---|
2170 | break;
|
---|
2171 | }
|
---|
2172 | #endif
|
---|
2173 | case EEikCmdExit:
|
---|
2174 | q->quit();
|
---|
2175 | ret = 1;
|
---|
2176 | break;
|
---|
2177 | default:
|
---|
2178 | #ifdef Q_WS_S60
|
---|
2179 | bool handled = QSoftKeyManager::handleCommand(command);
|
---|
2180 | if (handled)
|
---|
2181 | ret = 1;
|
---|
2182 | else
|
---|
2183 | ret = QMenuBarPrivate::symbianCommands(command);
|
---|
2184 | #endif
|
---|
2185 | break;
|
---|
2186 | }
|
---|
2187 |
|
---|
2188 | return ret;
|
---|
2189 | }
|
---|
2190 |
|
---|
2191 | /*!
|
---|
2192 | \warning This function is only available on Symbian.
|
---|
2193 | \since 4.6
|
---|
2194 |
|
---|
2195 | Handles the resource change specified by \a type.
|
---|
2196 |
|
---|
2197 | Currently, KEikDynamicLayoutVariantSwitch and
|
---|
2198 | KAknsMessageSkinChange are handled.
|
---|
2199 | */
|
---|
2200 | int QApplicationPrivate::symbianResourceChange(const QSymbianEvent *symbianEvent)
|
---|
2201 | {
|
---|
2202 | int ret = 0;
|
---|
2203 |
|
---|
2204 | int type = symbianEvent->resourceChangeType();
|
---|
2205 |
|
---|
2206 | switch (type) {
|
---|
2207 | #ifdef Q_WS_S60
|
---|
2208 | case KEikDynamicLayoutVariantSwitch:
|
---|
2209 | {
|
---|
2210 | if (callSymbianEventFilters(symbianEvent))
|
---|
2211 | return 1;
|
---|
2212 | if (S60)
|
---|
2213 | S60->updateScreenSize();
|
---|
2214 |
|
---|
2215 | #ifndef QT_NO_STYLE_S60
|
---|
2216 | QS60Style *s60Style = 0;
|
---|
2217 |
|
---|
2218 | #ifndef QT_NO_STYLE_STYLESHEET
|
---|
2219 | QStyleSheetStyle *proxy = qobject_cast<QStyleSheetStyle*>(QApplication::style());
|
---|
2220 | if (proxy)
|
---|
2221 | s60Style = qobject_cast<QS60Style*>(proxy->baseStyle());
|
---|
2222 | else
|
---|
2223 | #endif
|
---|
2224 | s60Style = qobject_cast<QS60Style*>(QApplication::style());
|
---|
2225 |
|
---|
2226 | if (s60Style) {
|
---|
2227 | s60Style->d_func()->handleDynamicLayoutVariantSwitch();
|
---|
2228 | ret = 1;
|
---|
2229 | }
|
---|
2230 | #endif
|
---|
2231 | }
|
---|
2232 | break;
|
---|
2233 |
|
---|
2234 | #ifndef QT_NO_STYLE_S60
|
---|
2235 | case KAknsMessageSkinChange:
|
---|
2236 | if (callSymbianEventFilters(symbianEvent))
|
---|
2237 | return 1;
|
---|
2238 | if (QS60Style *s60Style = qobject_cast<QS60Style*>(QApplication::style())) {
|
---|
2239 | s60Style->d_func()->handleSkinChange();
|
---|
2240 | ret = 1;
|
---|
2241 | }
|
---|
2242 | break;
|
---|
2243 | #endif
|
---|
2244 | #endif // Q_WS_S60
|
---|
2245 | default:
|
---|
2246 | break;
|
---|
2247 | }
|
---|
2248 |
|
---|
2249 | return ret;
|
---|
2250 | }
|
---|
2251 |
|
---|
2252 | #ifndef QT_NO_WHEELEVENT
|
---|
2253 | int QApplication::wheelScrollLines()
|
---|
2254 | {
|
---|
2255 | return QApplicationPrivate::wheel_scroll_lines;
|
---|
2256 | }
|
---|
2257 |
|
---|
2258 | void QApplication::setWheelScrollLines(int n)
|
---|
2259 | {
|
---|
2260 | QApplicationPrivate::wheel_scroll_lines = n;
|
---|
2261 | }
|
---|
2262 | #endif //QT_NO_WHEELEVENT
|
---|
2263 |
|
---|
2264 | bool QApplication::isEffectEnabled(Qt::UIEffect /* effect */)
|
---|
2265 | {
|
---|
2266 | // TODO: Implement QApplication::isEffectEnabled(Qt::UIEffect effect)
|
---|
2267 | return false;
|
---|
2268 | }
|
---|
2269 |
|
---|
2270 | void QApplication::setEffectEnabled(Qt::UIEffect /* effect */, bool /* enable */)
|
---|
2271 | {
|
---|
2272 | // TODO: Implement QApplication::setEffectEnabled(Qt::UIEffect effect, bool enable)
|
---|
2273 | }
|
---|
2274 |
|
---|
2275 | TUint QApplicationPrivate::resolveS60ScanCode(TInt scanCode, TUint keysym)
|
---|
2276 | {
|
---|
2277 | if (!scanCode)
|
---|
2278 | return keysym;
|
---|
2279 |
|
---|
2280 | QApplicationPrivate *d = QApplicationPrivate::instance();
|
---|
2281 |
|
---|
2282 | if (keysym) {
|
---|
2283 | // If keysym is specified, cache it.
|
---|
2284 | d->scanCodeCache.insert(scanCode, keysym);
|
---|
2285 | return keysym;
|
---|
2286 | } else {
|
---|
2287 | // If not, retrieve the cached version.
|
---|
2288 | return d->scanCodeCache[scanCode];
|
---|
2289 | }
|
---|
2290 | }
|
---|
2291 |
|
---|
2292 | void QApplicationPrivate::initializeMultitouch_sys()
|
---|
2293 | {
|
---|
2294 | #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
|
---|
2295 | if (HAL::Get(HALData::EPointer3DPressureSupported, pressureSupported) != KErrNone)
|
---|
2296 | pressureSupported = 0;
|
---|
2297 | if (HAL::Get(HALData::EPointer3DMaxPressure, maxTouchPressure) != KErrNone)
|
---|
2298 | maxTouchPressure = KMaxTInt;
|
---|
2299 | #else
|
---|
2300 | pressureSupported = 0;
|
---|
2301 | maxTouchPressure = KMaxTInt;
|
---|
2302 | #endif
|
---|
2303 | }
|
---|
2304 |
|
---|
2305 | void QApplicationPrivate::cleanupMultitouch_sys()
|
---|
2306 | { }
|
---|
2307 |
|
---|
2308 | #ifndef QT_NO_SESSIONMANAGER
|
---|
2309 | QSessionManager::QSessionManager(QApplication * /* app */, QString & /* id */, QString& /* key */)
|
---|
2310 | {
|
---|
2311 |
|
---|
2312 | }
|
---|
2313 |
|
---|
2314 | QSessionManager::~QSessionManager()
|
---|
2315 | {
|
---|
2316 |
|
---|
2317 | }
|
---|
2318 |
|
---|
2319 | bool QSessionManager::allowsInteraction()
|
---|
2320 | {
|
---|
2321 | return false;
|
---|
2322 | }
|
---|
2323 |
|
---|
2324 | void QSessionManager::cancel()
|
---|
2325 | {
|
---|
2326 |
|
---|
2327 | }
|
---|
2328 | #endif //QT_NO_SESSIONMANAGER
|
---|
2329 |
|
---|
2330 | #ifdef QT_KEYPAD_NAVIGATION
|
---|
2331 | /*
|
---|
2332 | * Show/Hide the mouse cursor depending on phone type and chosen mode
|
---|
2333 | */
|
---|
2334 | void QApplicationPrivate::setNavigationMode(Qt::NavigationMode mode)
|
---|
2335 | {
|
---|
2336 | #ifndef QT_NO_CURSOR
|
---|
2337 | const bool wasCursorOn = (QApplicationPrivate::navigationMode == Qt::NavigationModeCursorAuto
|
---|
2338 | && !S60->hasTouchscreen)
|
---|
2339 | || QApplicationPrivate::navigationMode == Qt::NavigationModeCursorForceVisible;
|
---|
2340 | const bool isCursorOn = (mode == Qt::NavigationModeCursorAuto
|
---|
2341 | && !S60->hasTouchscreen)
|
---|
2342 | || mode == Qt::NavigationModeCursorForceVisible;
|
---|
2343 |
|
---|
2344 | if (!wasCursorOn && isCursorOn) {
|
---|
2345 | //Show the cursor, when changing from another mode to cursor mode
|
---|
2346 | qt_symbian_set_cursor_visible(true);
|
---|
2347 | }
|
---|
2348 | else if (wasCursorOn && !isCursorOn) {
|
---|
2349 | //Hide the cursor, when leaving cursor mode
|
---|
2350 | qt_symbian_set_cursor_visible(false);
|
---|
2351 | }
|
---|
2352 | #endif
|
---|
2353 | QApplicationPrivate::navigationMode = mode;
|
---|
2354 | }
|
---|
2355 | #endif
|
---|
2356 |
|
---|
2357 | #ifndef QT_NO_CURSOR
|
---|
2358 | /*****************************************************************************
|
---|
2359 | QApplication cursor stack
|
---|
2360 | *****************************************************************************/
|
---|
2361 |
|
---|
2362 | void QApplication::setOverrideCursor(const QCursor &cursor)
|
---|
2363 | {
|
---|
2364 | qApp->d_func()->cursor_list.prepend(cursor);
|
---|
2365 | qt_symbian_setGlobalCursor(cursor);
|
---|
2366 | }
|
---|
2367 |
|
---|
2368 | void QApplication::restoreOverrideCursor()
|
---|
2369 | {
|
---|
2370 | if (qApp->d_func()->cursor_list.isEmpty())
|
---|
2371 | return;
|
---|
2372 | qApp->d_func()->cursor_list.removeFirst();
|
---|
2373 |
|
---|
2374 | if (!qApp->d_func()->cursor_list.isEmpty()) {
|
---|
2375 | qt_symbian_setGlobalCursor(qApp->d_func()->cursor_list.first());
|
---|
2376 | }
|
---|
2377 | else {
|
---|
2378 | //determine which widget has focus
|
---|
2379 | QWidget *w = QApplication::widgetAt(QCursor::pos());
|
---|
2380 | #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
|
---|
2381 | if (S60->brokenPointerCursors) {
|
---|
2382 | qt_symbian_set_pointer_sprite(w ? w->cursor() : Qt::ArrowCursor);
|
---|
2383 | }
|
---|
2384 | else
|
---|
2385 | #endif
|
---|
2386 | {
|
---|
2387 | //because of the internals of window server, we need to force the cursor
|
---|
2388 | //to be set in all child windows too, otherwise when the cursor is over
|
---|
2389 | //the child window it may show a widget cursor or arrow cursor instead,
|
---|
2390 | //depending on construction order.
|
---|
2391 | QListIterator<WId> iter(QWidgetPrivate::mapper->uniqueKeys());
|
---|
2392 | while (iter.hasNext()) {
|
---|
2393 | CCoeControl *ctrl = iter.next();
|
---|
2394 | if(ctrl->OwnsWindow()) {
|
---|
2395 | ctrl->DrawableWindow()->ClearPointerCursor();
|
---|
2396 | }
|
---|
2397 | }
|
---|
2398 | if (w)
|
---|
2399 | qt_symbian_setWindowCursor(w->cursor(), w->effectiveWinId());
|
---|
2400 | else
|
---|
2401 | qt_symbian_setWindowGroupCursor(Qt::ArrowCursor, S60->windowGroup());
|
---|
2402 | }
|
---|
2403 | }
|
---|
2404 | }
|
---|
2405 |
|
---|
2406 | #endif // QT_NO_CURSOR
|
---|
2407 |
|
---|
2408 | void QApplicationPrivate::_q_aboutToQuit()
|
---|
2409 | {
|
---|
2410 | #ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
|
---|
2411 | // Send the shutdown tfx command
|
---|
2412 | S60->wsSession().SendEffectCommand(ETfxCmdAppShutDown);
|
---|
2413 | #endif
|
---|
2414 | }
|
---|
2415 |
|
---|
2416 | QS60ThreadLocalData::QS60ThreadLocalData()
|
---|
2417 | {
|
---|
2418 | CCoeEnv *env = CCoeEnv::Static();
|
---|
2419 | if (env) {
|
---|
2420 | //if this is the UI thread, share objects owned by CONE
|
---|
2421 | usingCONEinstances = true;
|
---|
2422 | wsSession = env->WsSession();
|
---|
2423 | screenDevice = env->ScreenDevice();
|
---|
2424 | }
|
---|
2425 | else {
|
---|
2426 | usingCONEinstances = false;
|
---|
2427 | qt_symbian_throwIfError(wsSession.Connect(qt_s60GetRFs()));
|
---|
2428 | screenDevice = new CWsScreenDevice(wsSession);
|
---|
2429 | screenDevice->Construct();
|
---|
2430 | }
|
---|
2431 | }
|
---|
2432 |
|
---|
2433 | QS60ThreadLocalData::~QS60ThreadLocalData()
|
---|
2434 | {
|
---|
2435 | if (!usingCONEinstances) {
|
---|
2436 | delete screenDevice;
|
---|
2437 | wsSession.Close();
|
---|
2438 | }
|
---|
2439 | }
|
---|
2440 |
|
---|
2441 | QT_END_NAMESPACE
|
---|