FCL/sf/mw/qt: comparison src/gui/kernel/qapplication

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
-** This file is part of the QtGui of the Qt Toolkit.
+** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 #include "qpaintengine.h"
 #include "private/qmenubar_p.h"
 #include "private/qsoftkeymanager_p.h"
 #include "apgwgnam.h" // For CApaWindowGroupName
-#include <MdaAudioTonePlayer.h>     // For CMdaAudioToneUtility
+#include <mdaaudiotoneplayer.h>     // For CMdaAudioToneUtility
 #if defined(Q_WS_S60)
 # if !defined(QT_NO_IM)
 #  include "qinputcontext.h"
 #  include <private/qcoefepinputcontext_p.h>
 TBeepState iState;
 TInt iFrequency;
 TTimeIntervalMicroSeconds iDuration;
 };
+static QS60Beep* qt_S60Beep = 0;
 QS60Beep::~QS60Beep()
 {
+if (iToneUtil) {
+switch (iState) {
+case EBeepPlaying:
+iToneUtil->CancelPlay();
+break;
+case EBeepNotPrepared:
+iToneUtil->CancelPrepare();
+break;
+}
+}
 delete iToneUtil;
 }
 QS60Beep* QS60Beep::NewL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)
 {
-QS60Beep* self=new (ELeave) QS60Beep();
+QS60Beep* self = new (ELeave) QS60Beep();
 CleanupStack::PushL(self);
 self->ConstructL(aFrequency, aDuration);
 CleanupStack::Pop();
 return self;
-};
+}
 void QS60Beep::ConstructL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)
 {
-iToneUtil=CMdaAudioToneUtility::NewL(*this);
+iToneUtil = CMdaAudioToneUtility::NewL(*this);
-iState=EBeepNotPrepared;
+iState = EBeepNotPrepared;
-iFrequency=aFrequency;
+iFrequency = aFrequency;
-iDuration=aDuration;
+iDuration = aDuration;
-iToneUtil->PrepareToPlayTone(iFrequency,iDuration);
+iToneUtil->PrepareToPlayTone(iFrequency, iDuration);
 }
 void QS60Beep::Play()
 {
-if (iState != EBeepNotPrepared) {
+if (iState == EBeepPlaying) {
-if (iState == EBeepPlaying) {
+iToneUtil->CancelPlay();
-iToneUtil->CancelPlay();
+iState = EBeepPrepared;
-iState = EBeepPrepared;
-}
 }
 iToneUtil->Play();
 iState = EBeepPlaying;
 }
 void QS60Beep::MatoPrepareComplete(TInt aError)
 {
 if (aError == KErrNone) {
 iState = EBeepPrepared;
+Play();
 }
 }
 void QS60Beep::MatoPlayComplete(TInt aError)
 {
 Q_UNUSED(aError);
-iState=EBeepPrepared;
+iState = EBeepPrepared;
 }
 QHash<TInt, TUint> QApplicationPrivate::scanCodeCache;
 if (m_observer)
 m_observer->HandleLongTapEventL(m_event.iPosition, m_event.iParentPosition);
 }
 QSymbianControl::QSymbianControl(QWidget *w)
-: CCoeControl(), qwidget(w), m_ignoreFocusChanged(false)
+: CCoeControl()
+, qwidget(w)
+, m_longTapDetector(0)
+, m_ignoreFocusChanged(0)
+, m_symbianPopupIsOpen(0)
 {
 }
 void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)
 {
 // the control's window
 qwidget->d_func()->createExtra();
 SetFocusing(true);
 m_longTapDetector = QLongTapTimer::NewL(this);
+DrawableWindow()->SetPointerGrab(ETrue);
 }
 }
 QSymbianControl::~QSymbianControl()
 {
 QPoint widgetPos = QPoint(aPenEventLocation.iX, aPenEventLocation.iY);
 QPoint globalPos = QPoint(aPenEventScreenLocation.iX,aPenEventScreenLocation.iY);
 alienWidget = qwidget->childAt(widgetPos);
 if (!alienWidget)
 alienWidget = qwidget;
-QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons &(~Qt::LeftButton);
-QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons | Qt::RightButton;
-QMouseEvent mEvent(QEvent::MouseButtonPress, alienWidget->mapFrom(qwidget, widgetPos), globalPos,
-Qt::RightButton, QApplicationPrivate::mouse_buttons, Qt::NoModifier);
-bool res = sendMouseEvent(alienWidget, &mEvent);
 #if !defined(QT_NO_CONTEXTMENU)
-QContextMenuEvent contextMenuEvent(QContextMenuEvent::Mouse, widgetPos, globalPos, mEvent.modifiers());
+QContextMenuEvent contextMenuEvent(QContextMenuEvent::Mouse, widgetPos, globalPos, Qt::NoModifier);
 qt_sendSpontaneousEvent(alienWidget, &contextMenuEvent);
 #endif
-m_previousEventLongTap = true;
 }
 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
 void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent *event)
 {
 m_longTapDetector->PointerEventL(pEvent);
 QT_TRYCATCH_LEAVING(HandlePointerEvent(pEvent));
 }
-typedef QPair<QWidget*,QMouseEvent> Event;
-/*
-* Helper function called by HandlePointerEvent - separated to keep that function readable
-*/
-static void generateEnterLeaveEvents(QList<Event> &events, QWidget *widgetUnderPointer,
-QPoint globalPos, Qt::MouseButton button, Qt::KeyboardModifiers modifiers)
-{
-//moved to another widget, create enter and leave events
-if (S60->lastPointerEventTarget) {
-QMouseEvent mEventLeave(QEvent::Leave, S60->lastPointerEventTarget->mapFromGlobal(
-S60->lastCursorPos), S60->lastCursorPos, button, QApplicationPrivate::mouse_buttons,
-modifiers);
-events.append(Event(S60->lastPointerEventTarget, mEventLeave));
-}
-if (widgetUnderPointer) {
-QMouseEvent mEventEnter(QEvent::Enter, widgetUnderPointer->mapFromGlobal(globalPos),
-globalPos, button, QApplicationPrivate::mouse_buttons, modifiers);
-events.append(Event(widgetUnderPointer, mEventEnter));
-#ifndef QT_NO_CURSOR
-S60->curWin = widgetUnderPointer->effectiveWinId();
-if (!QApplication::overrideCursor()) {
-#ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
-if (S60->brokenPointerCursors)
-qt_symbian_set_pointer_sprite(widgetUnderPointer->cursor());
-else
-#endif
-qt_symbian_setWindowCursor(widgetUnderPointer->cursor(), S60->curWin);
-}
-#endif
-}
-}
 void QSymbianControl::HandlePointerEvent(const TPointerEvent& pEvent)
 {
 QMouseEvent::Type type;
 Qt::MouseButton button;
 mapS60MouseEventTypeToQt(&type, &button, &pEvent);
 Qt::KeyboardModifiers modifiers = mapToQtModifiers(pEvent.iModifiers);
-if (m_previousEventLongTap)
-if (type == QEvent::MouseButtonRelease){
-button = Qt::RightButton;
-QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons & ~Qt::RightButton;
-m_previousEventLongTap = false;
-}
-if (type == QMouseEvent::None)
-return;
-// store events for later sending/saving
-QList<Event > events;
 QPoint widgetPos = QPoint(pEvent.iPosition.iX, pEvent.iPosition.iY);
 TPoint controlScreenPos = PositionRelativeToScreen();
 QPoint globalPos = QPoint(controlScreenPos.iX, controlScreenPos.iY) + widgetPos;
+S60->lastCursorPos = globalPos;
-// widgets interested in the event
+S60->lastPointerEventPos = widgetPos;
+QWidget *mouseGrabber = QWidget::mouseGrabber();
+QWidget *popupWidget = qApp->activePopupWidget();
+QWidget *popupReceiver = 0;
+if (popupWidget) {
+QWidget *popupChild = popupWidget->childAt(popupWidget->mapFromGlobal(globalPos));
+popupReceiver = popupChild ? popupChild : popupWidget;
+}
+if (mouseGrabber) {
+if (popupReceiver) {
+sendMouseEvent(popupReceiver, type, globalPos, button, modifiers);
+} else {
+sendMouseEvent(mouseGrabber, type, globalPos, button, modifiers);
+}
+// No Enter/Leave events in grabbing mode.
+return;
+}
 QWidget *widgetUnderPointer = qwidget->childAt(widgetPos);
 if (!widgetUnderPointer)
-widgetUnderPointer = qwidget; //i.e. this container widget
+widgetUnderPointer = qwidget;
-QWidget *widgetWithMouseGrab = QWidget::mouseGrabber();
+QApplicationPrivate::dispatchEnterLeave(widgetUnderPointer, S60->lastPointerEventTarget);
-// handle auto grab of pointer when pressing / releasing
-if (!widgetWithMouseGrab && type == QEvent::MouseButtonPress) {
-//if previously auto-grabbed, generate a fake mouse release (platform bug: mouse release event was lost)
-if (S60->mousePressTarget) {
-QMouseEvent mEvent(QEvent::MouseButtonRelease, S60->mousePressTarget->mapFromGlobal(globalPos), globalPos,
-button, QApplicationPrivate::mouse_buttons, modifiers);
-events.append(Event(S60->mousePressTarget,mEvent));
-}
-//auto grab the mouse
-widgetWithMouseGrab = S60->mousePressTarget = widgetUnderPointer;
-widgetWithMouseGrab->grabMouse();
-}
-if (widgetWithMouseGrab && widgetWithMouseGrab == S60->mousePressTarget && type == QEvent::MouseButtonRelease) {
-//release the auto grab - note this release event still goes to the autograb widget
-S60->mousePressTarget = 0;
-widgetWithMouseGrab->releaseMouse();
-}
-QWidget *widgetToReceiveMouseEvent;
-if (widgetWithMouseGrab)
-widgetToReceiveMouseEvent = widgetWithMouseGrab;
-else
-widgetToReceiveMouseEvent = widgetUnderPointer;
-//queue QEvent::Enter and QEvent::Leave, if the pointer has moved
-if (widgetUnderPointer != S60->lastPointerEventTarget && (type == QEvent::MouseButtonPress || type == QEvent::MouseButtonDblClick || type == QEvent::MouseMove))
-generateEnterLeaveEvents(events, widgetUnderPointer, globalPos, button, modifiers);
-//save global state
-S60->lastCursorPos = globalPos;
-S60->lastPointerEventPos = widgetPos;
 S60->lastPointerEventTarget = widgetUnderPointer;
+QWidget *receiver;
+if (!popupReceiver && S60->mousePressTarget && type != QEvent::MouseButtonPress) {
+receiver = S60->mousePressTarget;
+if (type == QEvent::MouseButtonRelease)
+S60->mousePressTarget = 0;
+} else {
+receiver = popupReceiver ? popupReceiver : widgetUnderPointer;
+if (type == QEvent::MouseButtonPress)
+S60->mousePressTarget = receiver;
+}
 #if !defined(QT_NO_CURSOR) && !defined(Q_SYMBIAN_FIXED_POINTER_CURSORS)
 if (S60->brokenPointerCursors)
 qt_symbian_move_cursor_sprite();
 #endif
-//queue this event.
+sendMouseEvent(receiver, type, globalPos, button, modifiers);
-Q_ASSERT(widgetToReceiveMouseEvent);
+}
-QMouseEvent mEvent(type, widgetToReceiveMouseEvent->mapFromGlobal(globalPos), globalPos,
+void QSymbianControl::sendMouseEvent(
+QWidget *receiver,
+QEvent::Type type,
+const QPoint &globalPos,
+Qt::MouseButton button,
+Qt::KeyboardModifiers modifiers)
+{
+Q_ASSERT(receiver);
+QMouseEvent mEvent(type, receiver->mapFromGlobal(globalPos), globalPos,
 button, QApplicationPrivate::mouse_buttons, modifiers);
-events.append(Event(widgetToReceiveMouseEvent,mEvent));
 QEventDispatcherS60 *dispatcher;
 // It is theoretically possible for someone to install a different event dispatcher.
-if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(widgetToReceiveMouseEvent->d_func()->threadData->eventDispatcher)) != 0) {
+if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(receiver->d_func()->threadData->eventDispatcher)) != 0) {
 if (dispatcher->excludeUserInputEvents()) {
-for (int i=0;i < events.count();++i)
+dispatcher->saveInputEvent(this, receiver, new QMouseEvent(mEvent));
-{
-Event next = events[i];
-dispatcher->saveInputEvent(this, next.first, new QMouseEvent(next.second));
-}
 return;
 }
 }
-//send events in the queue
+sendMouseEvent(receiver, &mEvent);
-for (int i=0;i < events.count();++i)
-{
-Event next = events[i];
-sendMouseEvent(next.first, &(next.second));
-}
 }
 bool QSymbianControl::sendMouseEvent(QWidget *widget, QMouseEvent *mEvent)
 {
 return qt_sendSpontaneousEvent(widget, mEvent);
 if (type == EEventKeyUp) {
 if (keyCode == Qt::Key_Select)
 fakeEvent.iType = TPointerEvent::EButton1Up;
 S60->virtualMouseAccel = 1;
 S60->virtualMouseLastKey = 0;
+switch (keyCode) {
+case Qt::Key_Left:
+S60->virtualMousePressedKeys &= ~QS60Data::Left;
+break;
+case Qt::Key_Right:
+S60->virtualMousePressedKeys &= ~QS60Data::Right;
+break;
+case Qt::Key_Up:
+S60->virtualMousePressedKeys &= ~QS60Data::Up;
+break;
+case Qt::Key_Down:
+S60->virtualMousePressedKeys &= ~QS60Data::Down;
+break;
+case Qt::Key_Select:
+S60->virtualMousePressedKeys &= ~QS60Data::Select;
+break;
+}
 }
 else if (type == EEventKey) {
 switch (keyCode) {
 case Qt::Key_Left:
+S60->virtualMousePressedKeys |= QS60Data::Left;
 x -= S60->virtualMouseAccel;
 fakeEvent.iType = TPointerEvent::EMove;
 break;
 case Qt::Key_Right:
+S60->virtualMousePressedKeys |= QS60Data::Right;
 x += S60->virtualMouseAccel;
 fakeEvent.iType = TPointerEvent::EMove;
 break;
 case Qt::Key_Up:
+S60->virtualMousePressedKeys |= QS60Data::Up;
 y -= S60->virtualMouseAccel;
 fakeEvent.iType = TPointerEvent::EMove;
 break;
 case Qt::Key_Down:
+S60->virtualMousePressedKeys |= QS60Data::Down;
 y += S60->virtualMouseAccel;
 fakeEvent.iType = TPointerEvent::EMove;
 break;
 case Qt::Key_Select:
-fakeEvent.iType = TPointerEvent::EButton1Down;
+// Platform bug. If you start pressing several keys simultaneously (for
+// example for drag'n'drop), Symbian starts producing spurious up and
+// down messages for some keys. Therefore, make sure we have a clean slate
+// of pressed keys before starting a new button press.
+if (S60->virtualMousePressedKeys != 0) {
+S60->virtualMousePressedKeys |= QS60Data::Select;
+return EKeyWasConsumed;
+} else {
+S60->virtualMousePressedKeys |= QS60Data::Select;
+fakeEvent.iType = TPointerEvent::EButton1Down;
+}
 break;
 }
 }
 //clip to screen size (window server allows a sprite hotspot to be outside the screen)
 if (x < 0)
 #endif
 Qt::KeyboardModifiers mods = mapToQtModifiers(keyEvent.iModifiers);
 QKeyEventEx qKeyEvent(type == EEventKeyUp ? QEvent::KeyRelease : QEvent::KeyPress, keyCode,
 mods, qt_keymapper_private()->translateKeyEvent(keyCode, mods),
-false, 1, keyEvent.iScanCode, s60Keysym, keyEvent.iModifiers);
+(keyEvent.iRepeats != 0), 1, keyEvent.iScanCode, s60Keysym, keyEvent.iModifiers);
 //        WId wid = reinterpret_cast<RWindowGroup *>(keyEvent.Handle())->Child();
 //        if (!wid)
 //             Could happen if window isn't shown yet.
 //            return EKeyWasNotConsumed;
 QWidget *widget;
 QPaintEngine *engine = surface ? surface->paintDevice()->paintEngine() : NULL;
 if (!engine)
 return;
+const bool sendNativePaintEvents = qwidget->d_func()->extraData()->receiveNativePaintEvents;
+if (sendNativePaintEvents) {
+const QRect r = qt_TRect2QRect(controlRect);
+QMetaObject::invokeMethod(qwidget, "beginNativePaintEvent", Qt::DirectConnection, Q_ARG(QRect, r));
+}
 // Map source rectangle into coordinates of the backing store.
 const QPoint controlBase(controlRect.iTl.iX, controlRect.iTl.iY);
 const QPoint backingStoreBase = qwidget->mapTo(qwidget->window(), controlBase);
 const TRect backingStoreRect(TPoint(backingStoreBase.x(), backingStoreBase.y()), controlRect.Size());
 if (engine->type() == QPaintEngine::Raster) {
 QS60WindowSurface *s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());
 CFbsBitmap *bitmap = s60Surface->symbianBitmap();
 CWindowGc &gc = SystemGc();
-if(!qwidget->d_func()->extraData()->disableBlit) {
+switch(qwidget->d_func()->extraData()->nativePaintMode) {
+case QWExtra::Disable:
+// Do nothing
+break;
+case QWExtra::Blit:
 if (qwidget->d_func()->isOpaque)
 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
 gc.BitBlt(controlRect.iTl, bitmap, backingStoreRect);
-	    }
+break;
+case QWExtra::ZeroFill:
+if (Window().DisplayMode() == EColor16MA) {
+gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+gc.SetBrushColor(TRgb::Color16MA(0));
+gc.Clear(controlRect);
+} else {
+gc.SetBrushColor(TRgb(0x000000));
+gc.Clear(controlRect);
+};
+break;
+default:
+Q_ASSERT(false);
+}
 } else {
 surface->flush(qwidget, QRegion(qt_TRect2QRect(backingStoreRect)), QPoint());
+}
+if (sendNativePaintEvents) {
+const QRect r = qt_TRect2QRect(controlRect);
+// The draw ops aren't actually sent to WSERV until the graphics
+// context is deactivated, which happens in the function calling
+// this one.  We therefore delay the delivery of endNativePaintEvent,
+// to ensure that drawing has completed by the time the widget
+// receives the event.  Note that, if the widget needs to ensure
+// that the draw ops have actually been executed into the output
+// framebuffer, a call to RWsSession::Flush is required in the
+// endNativePaintEvent implementation.
+QMetaObject::invokeMethod(qwidget, "endNativePaintEvent", Qt::QueuedConnection, Q_ARG(QRect, r));
 }
 }
 void QSymbianControl::SizeChanged()
 {
 qwidget->d_func()->syncBackingStore();
 if (!slowResize && tlwExtra)
 tlwExtra->inTopLevelResize = false;
 }
 }
+// CCoeControl::SetExtent calls SizeChanged, but does not call
+// PositionChanged, so we call it here to ensure that the widget's
+// position is updated.
+PositionChanged();
 }
 void QSymbianControl::PositionChanged()
 {
 CCoeControl::PositionChanged();
 if (QApplicationPrivate::popupWidgets != 0
 || (qwidget->windowType() & Qt::Popup) == Qt::Popup)
 return;
 if (IsFocused() && IsVisible()) {
+if (m_symbianPopupIsOpen) {
+QWidget *fw = QApplication::focusWidget();
+if (fw) {
+QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason);
+QCoreApplication::sendEvent(fw, &event);
+}
+m_symbianPopupIsOpen = false;
+}
 QApplication::setActiveWindow(qwidget->window());
+qwidget->d_func()->setWindowIcon_sys(true);
+qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());
 #ifdef Q_WS_S60
 // If widget is fullscreen, hide status pane and button container
 // otherwise show them.
 CEikStatusPane* statusPane = S60->statusPane();
 CEikButtonGroupContainer* buttonGroup = S60->buttonGroupContainer();
 bool isFullscreen = qwidget->windowState() & Qt::WindowFullScreen;
-if (statusPane && (statusPane->IsVisible() == isFullscreen))
+if (statusPane && (bool)statusPane->IsVisible() == isFullscreen)
 statusPane->MakeVisible(!isFullscreen);
-if (buttonGroup && (buttonGroup->IsVisible() == isFullscreen))
+if (buttonGroup && (bool)buttonGroup->IsVisible() == isFullscreen)
 buttonGroup->MakeVisible(!isFullscreen);
 #endif
 } else if (QApplication::activeWindow() == qwidget->window()) {
+if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog()) {
+QWidget *fw = QApplication::focusWidget();
+if (fw) {
+QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);
+QCoreApplication::sendEvent(fw, &event);
+}
+m_symbianPopupIsOpen = true;
+return;
+}
 QApplication::setActiveWindow(0);
 }
 // else { We don't touch the active window unless we were explicitly activated or deactivated }
 }
 void QSymbianControl::HandleResourceChange(int resourceType)
 {
 switch (resourceType) {
 case KInternalStatusPaneChange:
-qwidget->d_func()->setWindowIcon_sys(true);
+if (qwidget->isFullScreen()) {
+SetExtentToWholeScreen();
+} else if (qwidget->isMaximized()) {
+TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+SetExtent(r.iTl, r.Size());
+}
+if (IsFocused() && IsVisible()) {
+qwidget->d_func()->setWindowIcon_sys(true);
+qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());
+}
 break;
 case KUidValueCoeFontChangeEvent:
 // font change event
 break;
 #ifdef Q_WS_S60
 CApaCommandLine* commandLine = 0;
 TInt err = CApaCommandLine::GetCommandLineFromProcessEnvironment(commandLine);
 // After this construction, CEikonEnv will be available from CEikonEnv::Static().
 // (much like our qApp).
 CEikonEnv* coe = new CEikonEnv;
-QT_TRAP_THROWING(coe->ConstructAppFromCommandLineL(factory,*commandLine));
+//not using QT_TRAP_THROWING, because coe owns the cleanupstack so it can't be pushed there.
+if(err == KErrNone)
+TRAP(err, coe->ConstructAppFromCommandLineL(factory,*commandLine));
 delete commandLine;
+if(err != KErrNone) {
+qWarning() << "qt_init: Eikon application construct failed ("
+<< err
+<< "), maybe missing resource file on S60 3.1?";
+delete coe;
+qt_symbian_throwIfError(err);
+}
 S60->s60InstalledTrapHandler = User::SetTrapHandler(origTrapHandler);
 S60->qtOwnsS60Environment = true;
 } else {
 TSecureId securId = me.SecureId();
 S60->uid = securId.operator TUid();
 // enable focus events - used to re-enable mouse after focus changed between mouse and non mouse app,
 // and for dimming behind modal windows
-	S60->windowGroup().EnableFocusChangeEvents();
+S60->windowGroup().EnableFocusChangeEvents();
-	//Check if mouse interaction is supported (either EMouse=1 in the HAL, or EMachineUID is one of the phones known to support this)
+//Check if mouse interaction is supported (either EMouse=1 in the HAL, or EMachineUID is one of the phones known to support this)
 const TInt KMachineUidSamsungI8510 = 0x2000C51E;
 // HAL::Get(HALData::EPen, TInt& result) may set 'result' to 1 on some 3.1 systems (e.g. N95).
 // But we know that S60 systems below 5.0 did not support touch.
 static const bool touchIsUnsupportedOnSystem =
 QSysInfo::s60Version() == QSysInfo::SV_S60_3_1
 /*****************************************************************************
 qt_cleanup() - cleans up when the application is finished
 *****************************************************************************/
 void qt_cleanup()
 {
+if(qt_S60Beep) {
+delete qt_S60Beep;
+qt_S60Beep = 0;
+}
 QFontCache::cleanup(); // Has to happen now, since QFontEngineS60 has FBS handles
 // S60 structure and window server session are freed in eventdispatcher destructor as they are needed there
 // It's important that this happens here, before the event dispatcher gets
 // deleted, because the input context needs the event loop one last time before
 }
 void QApplicationPrivate::enterModal_sys(QWidget *widget)
 {
 if (widget) {
-widget->effectiveWinId()->DrawableWindow()->FadeBehind(ETrue);
+static_cast<QSymbianControl *>(widget->effectiveWinId())->FadeBehindPopup(ETrue);
 // Modal partial screen dialogs (like queries) capture pointer events.
 // ### FixMe: Add specialized behaviour for fullscreen modal dialogs
 widget->effectiveWinId()->SetGloballyCapturing(ETrue);
 widget->effectiveWinId()->SetPointerCapture(ETrue);
 }
 }
 void QApplicationPrivate::leaveModal_sys(QWidget *widget)
 {
 if (widget) {
-widget->effectiveWinId()->DrawableWindow()->FadeBehind(EFalse);
+static_cast<QSymbianControl *>(widget->effectiveWinId())->FadeBehindPopup(EFalse);
 // ### FixMe: Add specialized behaviour for fullscreen modal dialogs
 widget->effectiveWinId()->SetGloballyCapturing(EFalse);
 widget->effectiveWinId()->SetPointerCapture(EFalse);
 }
 if (qt_modal_stack && qt_modal_stack->removeAll(widget)) {
 QApplicationPrivate::cursor_flash_time = msecs;
 }
 void QApplication::beep()
 {
-TInt frequency=440;
+if (!qt_S60Beep) {
-TTimeIntervalMicroSeconds duration(500000);
+TInt frequency = 880;
-QS60Beep* beep=NULL;
+TTimeIntervalMicroSeconds duration(500000);
-TRAPD(err, beep=QS60Beep::NewL(frequency, duration));
+TRAP_IGNORE(qt_S60Beep=QS60Beep::NewL(frequency, duration));
-if (!err)
+}
-beep->Play();
+if (qt_S60Beep)
-delete beep;
+qt_S60Beep->Play();
-beep=NULL;
 }
 /*!
 \warning This function is only available on Symbian.
 \since 4.6
 #endif
 S60->wsSession().SetPointerCursorMode(EPointerCursorNone);
 }
 #endif
 break;
-	default:
+default:
 break;
 }
 if (!controlInMap)
 return -1;

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c
child 18	2f34d5167611