{

if (!widget)

return false;

return !widget->isWindow()

# ifdef Q_BACKINGSTORE_SUBSURFACES

&& !(widget->d_func()->maybeTopData() && widget->d_func()->maybeTopData()->windowSurface)

{

QWidgetPrivate::mapper = new QWidgetMapper;

QWidgetPrivate::allWidgets = new QWidgetSet;

if (qt_appType != QApplication::Tty)

(void) QApplication::style(); // trigger creation of application style

// trigger registering of QVariant's GUI types

// Set up which span functions should be used in raster engine...

qInitDrawhelperAsm();

#ifndef QT_NO_WHEELEVENT

QApplicationPrivate::wheel_scroll_lines = 3;

#endif

" languages or to 'RTL' in right-to-left languages (such as Hebrew"

" and Arabic) to get proper widget layout.") == QLatin1String("RTL"));

}

#endif

/*!\reimp

#ifndef QT_NO_TRANSLATION

setLayoutDirection(qt_detectRTLLanguage()?Qt::RightToLeft:Qt::LeftToRight);

#endif

QWidgetList list = topLevelWidgets();

for (int i = 0; i < list.size(); ++i) {

QWidget *w = list.at(i);

return result;

}

/*

This function should only be called when the widget changes visibility, i.e.

when the \a widget is shown, hidden or deleted. This function does nothing

sendMouseEvent(widgetUnderCursor, &e, widgetUnderCursor, tlw, &qt_button_down, qt_last_mouse_receiver);

#endif // QT_NO_CURSOR

}

/*!

Returns the desktop widget (also called the root window).

QApplication *that = const_cast<QApplication *>(this);

const QStringList keys = QInputContextFactory::keys();

// Try hbim and coefep first, then try others.

that->d_func()->inputContext = QInputContextFactory::create(QLatin1String("hbim"), that);

that->d_func()->inputContext = QInputContextFactory::create(QLatin1String("coefep"), that);

} else {

for (int c = 0; c < keys.size() && !d->inputContext; ++c) {

Q_DECLARE_PRIVATE(QApplication)

friend class QGraphicsWidget;

friend class QGraphicsScene;

friend class QGraphicsScenePrivate;

friend class QWidget;

bool qt_scrollbar_jump_to_pos = false;

static bool qt_mac_collapse_on_dblclick = true;

extern int qt_antialiasing_threshold; // from qapplication.cpp

#ifndef QT_MAC_USE_COCOA

static bool qt_button_down_in_content; // whether the button_down was in the content area.

static bool qt_mac_previous_press_in_popup_mode = false;

#endif

if (!app_proc_ae_handlerUPP) {

app_proc_ae_handlerUPP = AEEventHandlerUPP(QApplicationPrivate::globalAppleEventProcessor);

}

if (QApplicationPrivate::app_style) {

// (actually two events; one for horizontal and one for vertical).

// As a results of this, and to make sure we dont't receive duplicate events,

// we try to detect when this happend by checking the 'compatibilityEvent'.

SInt32 mdelt = 0;

GetEventParameter(event, kEventParamMouseWheelSmoothHorizontalDelta, typeSInt32, 0,

sizeof(mdelt), 0, &mdelt);

mdelt = 0;

GetEventParameter(event, kEventParamMouseWheelSmoothVerticalDelta, typeSInt32, 0,

sizeof(mdelt), 0, &mdelt);

GetEventParameter(event, kEventParamEventRef, typeEventRef, 0,

sizeof(compatibilityEvent), 0, &compatibilityEvent);

} else if (ekind == kEventMouseWheelMoved) {

// finished initialization, which appears to be just after [NSApplication run] has

// started to execute. By setting up our apple events handlers this late, we override

// the ones set up by NSApplication.

QT_MANGLE_NAMESPACE(QCocoaApplicationDelegate) *newDelegate = [QT_MANGLE_NAMESPACE(QCocoaApplicationDelegate) sharedDelegate];

NSAppleEventManager *eventManager = [NSAppleEventManager sharedAppleEventManager];

[eventManager setEventHandler:newDelegate andSelector:@selector(appleEventQuit:withReplyEvent:)

int symbianResourceChange(const QSymbianEvent *symbianEvent);

#endif

void sendSyntheticEnterLeave(QWidget *widget);

#endif

const QList<QTouchEvent::TouchPoint> &touchPoints);

#if defined(Q_WS_WIN)

static PtrRegisterTouchWindow RegisterTouchWindow;

static PtrGetTouchInputInfo GetTouchInputInfo;

static PtrCloseTouchInputHandle CloseTouchInputHandle;

#include "qstring.h"

#include "qdebug.h"

#include "qimage.h"

#include "private/qkeymapper_p.h"

#include "private/qfont_p.h"

#ifndef QT_NO_STYLE_S60

{

if (S60->curWin == this)

S60->curWin = 0;

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

delete m_longTapDetector;

}

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

keyEvent.iCode);

int keyCode;

// Normal characters keys.

keyCode = s60Keysym;

} else {

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

#ifdef Q_WS_S60

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

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

if (statusPane)

statusPane->MakeVisible(visible);

#endif

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

QWidget *fw = QApplication::focusWidget();

if (fw) {

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

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

}

void QSymbianControl::HandleResourceChange(int resourceType)

{

switch (resourceType) {

case KInternalStatusPaneChange:

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

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

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

#ifdef Q_WS_S60

case KEikDynamicLayoutVariantSwitch:

{

break;

}

#endif

}

S60->avkonComponentsSupportTransparency = false;

#ifdef Q_WS_S60

TUid KCRUidAvkon = { 0x101F876E };

S60->avkonComponentsSupportTransparency = (value==1) ? true : false;

}

}

if (touch) {

QApplicationPrivate::navigationMode = Qt::NavigationModeNone;

} else {

QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadDirectional;

}

#ifndef QT_NO_CURSOR

//Check if window server pointer cursors are supported or not

void QApplicationPrivate::openPopup(QWidget *popup)

{

if (!QApplicationPrivate::popupWidgets)

QApplicationPrivate::popupWidgets = new QWidgetList;

QApplicationPrivate::popupWidgets->append(popup);

// Cancel focus widget pointer capture and long tap timer

if (QApplication::focusWidget()) {

static_cast<QSymbianControl*>(QApplication::focusWidget()->effectiveWinId())->CancelLongTapTimer();

void QApplicationPrivate::closePopup(QWidget *popup)

{

if (!QApplicationPrivate::popupWidgets)

return;

QApplicationPrivate::popupWidgets->removeAll(popup);

QWidget *fw = QApplicationPrivate::active_window ? QApplicationPrivate::active_window->focusWidget()

: q_func()->focusWidget();

if (fw) {

if (fw != q_func()->focusWidget()) {

fw->setFocus(Qt::PopupFocusReason);

} else {

# include <winable.h>

#endif

#ifndef WM_TOUCH

# define WM_TOUCH 0x0240

#define __export

#endif

class QETWidget : public QWidget // event translator widget

{

;

}

{

bool result = true;

QEvent::Type evt_type = QEvent::None;

case WM_MBUTTONDOWN:

case WM_RBUTTONDOWN:

case WM_XBUTTONDOWN:

if (qt_win_ignoreNextMouseReleaseEvent)

qt_win_ignoreNextMouseReleaseEvent = false;

break;

case WM_GETOBJECT:

{

// Ignoring all requests while starting up

result = false;

break;

}

}

result = false;

break;

case WM_GESTURE: {

GESTUREINFO gi;

memset(&gi, 0, sizeof(GESTUREINFO));

result = true;

break;

}

#ifndef QT_NO_CURSOR

case WM_SETCURSOR: {

QCursor *ovr = QApplication::overrideCursor();

#endif //QT_NO_SESSIONMANAGER

PtrRegisterTouchWindow QApplicationPrivate::RegisterTouchWindow = 0;

PtrGetTouchInputInfo QApplicationPrivate::GetTouchInputInfo = 0;

PtrCloseTouchInputHandle QApplicationPrivate::CloseTouchInputHandle = 0;

void QApplicationPrivate::initializeMultitouch_sys()

{

QLibrary library(QLatin1String("user32"));

// MinGW (g++ 3.4.5) accepts only C casts.

RegisterTouchWindow = (PtrRegisterTouchWindow)(library.resolve("RegisterTouchWindow"));

}

#endif

//#define ALIEN_DEBUG

#if !defined(QT_NO_GLIB)

"_NET_SYSTEM_TRAY_VISUAL\0"

// Property formats

"COMPOUND_TEXT\0"

"TEXT\0"

"_XEMBED\0"

"_XEMBED_INFO\0"

"Wacom Stylus\0"

"Wacom Cursor\0"

"Wacom Eraser\0"

};

Q_GUI_EXPORT QX11Data *qt_x11Data = 0;

return 0;

break;

default:

#if !defined(QT_NO_XINPUT)

if (err->request_code == X11->xinput_major

extensionName = "XInputExtension";

else if (err->request_code == X11->mitshm_major)

extensionName = "MIT-SHM";

char minor_str[256];

if (extensionName) {

X11->xinput_eventbase = 0;

X11->xinput_errorbase = 0;

// MIT-SHM

X11->use_mitshm = false;

X11->use_mitshm_pixmaps = false;

}

#endif // QT_NO_XINPUT

#if !defined(QT_NO_FONTCONFIG)

int dpi = 0;

getXDefault("Xft", FC_DPI, &dpi);

// initialize key mapper

QKeyMapper::changeKeyboard();

// Misc. initialization

#if 0 //disabled for now..

QSegfaultHandler::initialize(priv->argv, priv->argc);

gotStylus = true;

}

#else

deviceType = QTabletEvent::Stylus;

if (wacomDeviceName()->isEmpty())

wacomDeviceName()->append(devs->name);

gotStylus = true;

deviceType = QTabletEvent::XFreeEraser;

gotEraser = true;

}

if ((ulong) event->xclient.data.l[1] > X11->time)

X11->time = event->xclient.data.l[1];

QWidget *amw = activeModalWidget();

if (amw && !QApplicationPrivate::tryModalHelper(widget, 0)) {

QWidget *p = amw->parentWidget();

while (p && p != widget)

QKeyMapper::changeKeyboard();

return 0;

}

if (!widget) { // don't know this windows

QWidget* popup = QApplication::activePopupWidget();

mouseButtonPressed == button &&

(long)event->xbutton.time -(long)mouseButtonPressTime

< QApplication::doubleClickInterval() &&

type = QEvent::MouseButtonDblClick;

mouseButtonPressTime -= 2000; // no double-click next time

} else {

store or retrieve the clipboard contents in response to timer or

non-user-input events.

\endlist

\section1 Notes for Mac OS X Users

#include "qapplication.h"

#include "qdesktopwidget.h"

#include "qbitmap.h"

#include "qiodevice.h"

#include "qbuffer.h"

#include "qtextcodec.h"

#include "qt_x11_p.h"

#include "qx11info_x11.h"

#include "qimagewriter.h"

#include "qvariant.h"

#include "qdnd_p.h"

#include <private/qwidget_p.h>

bool QX11Data::clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout)

{

if (QAbstractEventDispatcher::instance()->inherits("QtMotif")

|| QApplication::clipboard()->property("useEventLoopWhenWaiting").toBool()) {

XSync(X11->display, false);

usleep(50000);

QEventLoop::ProcessEventsFlags flags(QEventLoop::ExcludeUserInputEvents

| QEventLoop::ExcludeSocketNotifiers

if (XCheckIfEvent(X11->display, &e, checkForClipboardEvents, 0))

qApp->x11ProcessEvent(&e);

XFlush(X11->display);

}

// This function will only be called when NSApp is actually running. Before

// QApplicationPrivate::globalAppleEventProcessor in qapplication_mac.mm

- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender

{

qAppInstance()->quit();

startedQuit = false;

}

}

if (qtPrivate->threadData->eventLoops.size() == 0) {

// INVARIANT: No event loop is executing. This probably

// means that Qt is used as a plugin, or as a part of a native

// terminate now:

return NSTerminateNow;

}

}

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification

#include <private/qt_mac_p.h>

#include <private/qmenubar_p.h>

#include <qmenubar.h>

QT_FORWARD_DECLARE_CLASS(QCFString)

QT_FORWARD_DECLARE_CLASS(QString)

- (void)awakeFromNib

{

// Get the names in the nib to match the app name set by Qt.

NSString *appName = reinterpret_cast<const NSString*>(QCFString::toCFStringRef(qAppName()));

[quitItem setTitle:[[quitItem title] stringByReplacingOccurrencesOfString:@"NewApplication"

- (void)dealloc

{

[lastAppSpecificItem release];

[theMenu release];

[appMenu release];

QMenuBarPrivate::macUpdateMenuBarImmediatly();

}

- (IBAction)qtDispatcherToQAction:(id)sender

{

QScopedLoopLevelCounter loopLevelCounter(QApplicationPrivate::instance()->threadData);

IBOutlet NSMenuItem *aboutQtItem;

IBOutlet NSMenuItem *hideItem;

NSMenuItem *lastAppSpecificItem;

}

- (void)ensureAppMenuInMenu:(NSMenu *)menu;

- (void)removeActionsFromAppMenu;

[super toggleToolbarShown:sender];

}

- (void)flagsChanged:(NSEvent *)theEvent

{

qt_dispatchModifiersChanged(theEvent, [self QT_MANGLE_NAMESPACE(qt_qwidget)]);

extern NSString *NSTextInputReplacementRangeAttributeName;

}

@implementation QT_MANGLE_NAMESPACE(QCocoaView)

if (self) {

[self finishInitWithQWidget:widget widgetPrivate:widgetprivate];

}

composingText = new QString();

composing = false;

sendKeyEvents = true;

[self setHidden:YES];

QRegion mask = qt_widget_private(cursorWidget)->extra->mask;

NSCursor *nscursor = static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursorWidget->cursor()));

[self addCursorRect:[qt_mac_nativeview_for(cursorWidget) visibleRect] cursor:nscursor];

} else {

const QVector<QRect> &rects = mask.rects();

{

delete composingText;

[[NSNotificationCenter defaultCenter] removeObserver:self];

[super dealloc];

}

return YES;

}

{

return qwidget->testAttribute(Qt::WA_StaticContents);

}

}

}

- (void)drawRect:(NSRect)aRect

{

if (!qwidget)

return;

if (QApplicationPrivate::graphicsSystem() != 0) {

// Drawing is handled on the window level

// See qcocoasharedwindowmethods_mac_p.h

if (!qwidget->testAttribute(Qt::WA_PaintOnScreen))

CGContextClearRect(cg, NSRectToCGRect(aRect));

}

if (engine && !qwidget->testAttribute(Qt::WA_NoSystemBackground)

&& (qwidget->isWindow() || qwidget->autoFillBackground())

|| qwidget->testAttribute(Qt::WA_TintedBackground)

e.setErased(true);

#endif

qt_sendSpontaneousEvent(qwidget, &e);

if (!redirectionOffset.isNull())

QPainter::restoreRedirected(qwidget);

if (engine)

// The mouse device containts pixel scroll wheel support (Mighty Mouse, Trackpad).

// Since deviceDelta is delivered as pixels rather than degrees, we need to

// convert from pixels to degrees in a sensible manner.

} else {

// carbonEventKind == kEventMouseWheelMoved

// Remove acceleration, and use either -120 or 120 as delta:

{

if (!qwidget)

return NO;

return YES; // Always do it, so that windows can accept key press events.

return qwidget->focusPolicy() != Qt::NoFocus;

}

// Seems like the following test only triggers if this

// view is inside a QMacNativeWidget:

if (qwidget == QApplication::focusWidget())

return YES;

}

}

if (sendKeyEvents && !composing) {

bool keyOK = qt_dispatchKeyEvent(theEvent, widgetToGetKey);

}

}

{

if (sendKeyEvents) {

bool keyOK = qt_dispatchKeyEvent(theEvent, qwidget);

}

}

\o B=1 and M=1 gives black.

\o B=0 and M=1 gives white.

\o B=0 and M=0 gives transparent.

\endlist

Use the global Qt color Qt::color0 to draw 0-pixels and Qt::color1 to

}

c->handle(); //force the cursor to get loaded, if it's not

}

}

currentCursor = c->d;

#include <private/qapplication_p.h>

#include <coecntrl.h>

#include <qcursor.h>

#include <qbitmap.h>

#include <w32std.h>

#include <qapplication.h>

return;

#endif // QT_NO_XCURSOR

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

// Non-standard X11 cursors are created from bitmaps

#ifndef QT_USE_APPROXIMATE_CURSORS

0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f,

0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xf0, 0x0f,

0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00 };

0x00, 0x00, 0x80, 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0, 0x1f, 0xf8, 0x3f,

0xfc, 0x7f, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xfc, 0x7f, 0xf8, 0x3f,

0xf0, 0x1f, 0xe0, 0x0f, 0xc0, 0x07, 0x80, 0x03 };

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x08, 0x30, 0x18,

0x38, 0x38, 0xfc, 0x7f, 0xfc, 0x7f, 0x38, 0x38, 0x30, 0x18, 0x20, 0x08,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0x40, 0x04, 0x60, 0x0c, 0x70, 0x1c, 0x78, 0x3c,

0xfc, 0x7f, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfc, 0x7f, 0x78, 0x3c,

0x70, 0x1c, 0x60, 0x0c, 0x40, 0x04, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x3c, 0x00, 0x3e,

0x00, 0x37, 0x88, 0x23, 0xd8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0xf8, 0x00,

0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0xc0, 0x7f, 0x80, 0x7f, 0x00, 0x7f, 0x00, 0x7e, 0x04, 0x7f,

0x8c, 0x7f, 0xdc, 0x77, 0xfc, 0x63, 0xfc, 0x41, 0xfc, 0x00, 0xfc, 0x01,

0xfc, 0x03, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00,

0xf8, 0x00, 0xd8, 0x01, 0x88, 0x23, 0x00, 0x37, 0x00, 0x3e, 0x00, 0x3c,

0x00, 0x3e, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xfc, 0x03, 0xfc, 0x01, 0xfc, 0x00,

0xfc, 0x41, 0xfc, 0x63, 0xdc, 0x77, 0x8c, 0x7f, 0x04, 0x7f, 0x00, 0x7e,

0x00, 0x7f, 0x80, 0x7f, 0xc0, 0x7f, 0x00, 0x00 };

cur_ver_bits, mcur_ver_bits, cur_hor_bits, mcur_hor_bits,

cur_bdiag_bits, mcur_bdiag_bits, cur_fdiag_bits, mcur_fdiag_bits,

0, 0, cur_blank_bits, cur_blank_bits };

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x80, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00,

0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,

0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x07, 0x00,

0x00, 0xe0, 0x03, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0xf0, 0x07, 0x00,

0x09, 0x18, 0x0e, 0x00, 0x11, 0x1c, 0x0e, 0x00, 0x21, 0x1c, 0x0e, 0x00,

0x41, 0x1c, 0x0e, 0x00, 0x81, 0x1c, 0x0e, 0x00, 0x01, 0x01, 0x07, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

0x01, 0x00, 0x00, 0x00, 0x03, 0xf0, 0x07, 0x00, 0x07, 0xf8, 0x0f, 0x00,

0x0f, 0xfc, 0x1f, 0x00, 0x1f, 0x3e, 0x1f, 0x00, 0x3f, 0x3e, 0x1f, 0x00,

0x7f, 0x3e, 0x1f, 0x00, 0xff, 0x3e, 0x1f, 0x00, 0xff, 0x9d, 0x0f, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,

0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,

0x41, 0xe0, 0xff, 0x00, 0x81, 0x20, 0x80, 0x00, 0x01, 0xe1, 0xff, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,

0x0f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00,

0x7f, 0xe0, 0xff, 0x00, 0xff, 0xe0, 0xff, 0x00, 0xff, 0xe1, 0xff, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

vsplit_bits, vsplitm_bits, hsplit_bits, hsplitm_bits,

0, 0, 0, 0, whatsthis_bits, whatsthism_bits, busy_bits, busym_bits

};

0x00,0x00,0x00,0x80,0x1f,0x00,0xe0,0x7f,0x00,0xf0,0xf0,0x00,0x38,0xc0,0x01,

0x7c,0x80,0x03,0xec,0x00,0x03,0xce,0x01,0x07,0x86,0x03,0x06,0x06,0x07,0x06,

0x06,0x0e,0x06,0x06,0x1c,0x06,0x0e,0x38,0x07,0x0c,0x70,0x03,0x1c,0xe0,0x03,

0x38,0xc0,0x01,0xf0,0xe0,0x00,0xe0,0x7f,0x00,0x80,0x1f,0x00,0x00,0x00,0x00 };

0x80,0x1f,0x00,0xe0,0x7f,0x00,0xf0,0xff,0x00,0xf8,0xff,0x01,0xfc,0xf0,0x03,

0xfe,0xc0,0x07,0xfe,0x81,0x07,0xff,0x83,0x0f,0xcf,0x07,0x0f,0x8f,0x0f,0x0f,

0x0f,0x1f,0x0f,0x0f,0x3e,0x0f,0x1f,0xfc,0x0f,0x1e,0xf8,0x07,0x3e,0xf0,0x07,

0xfc,0xe0,0x03,0xf8,0xff,0x01,0xf0,0xff,0x00,0xe0,0x7f,0x00,0x80,0x1f,0x00};

0x80,0x01,0x58,0x0e,0x64,0x12,0x64,0x52,0x48,0xb2,0x48,0x92,

0x16,0x90,0x19,0x80,0x11,0x40,0x02,0x40,0x04,0x40,0x04,0x20,

0x08,0x20,0x10,0x10,0x20,0x10,0x00,0x00};

0x80,0x01,0xd8,0x0f,0xfc,0x1f,0xfc,0x5f,0xf8,0xff,0xf8,0xff,

0xf6,0xff,0xff,0xff,0xff,0x7f,0xfe,0x7f,0xfc,0x7f,0xfc,0x3f,

0xf8,0x3f,0xf0,0x1f,0xe0,0x1f,0x00,0x00};

0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0x48,0x32,0x08,0x50,

0x10,0x40,0x18,0x40,0x04,0x40,0x04,0x20,0x08,0x20,0x10,0x10,

0x20,0x10,0x20,0x10,0x00,0x00,0x00,0x00};

0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0xf8,0x3f,0xf8,0x7f,

0xf0,0x7f,0xf8,0x7f,0xfc,0x7f,0xfc,0x3f,0xf8,0x3f,0xf0,0x1f,

0xe0,0x1f,0xe0,0x1f,0x00,0x00,0x00,0x00};

forbidden_bits, forbiddenm_bits

};

fg.green = 0;

fg.blue = 0;

int i = (cshape - Qt::SizeVerCursor) * 2;

hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 8, 8);

} else if ((cshape >= Qt::SplitVCursor && cshape <= Qt::SplitHCursor)

|| cshape == Qt::WhatsThisCursor || cshape == Qt::BusyCursor) {

fg.green = 0;

fg.blue = 0;

int i = (cshape - Qt::SplitVCursor) * 2;

int hs = (cshape == Qt::PointingHandCursor || cshape == Qt::WhatsThisCursor

|| cshape == Qt::BusyCursor) ? 0 : 16;

hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, hs, hs);

fg.green = 0;

fg.blue = 0;

int i = (cshape - Qt::ForbiddenCursor) * 2;

hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 10, 10);

} else if (cshape == Qt::OpenHandCursor || cshape == Qt::ClosedHandCursor) {

XColor bg, fg;

fg.green = 0;

fg.blue = 0;

bool open = cshape == Qt::OpenHandCursor;

hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 8, 8);

} else if (cshape == Qt::DragCopyCursor || cshape == Qt::DragMoveCursor

|| cshape == Qt::DragLinkCursor) {

void QDesktopWidgetPrivate::init(QDesktopWidget *that)

{

// int screenCount=0;

// ### TODO: Implement proper multi-display support

};

typedef BOOL (WINAPI *InfoFunc)(HMONITOR, MONITORINFO*);

typedef BOOL (WINAPI *EnumFunc)(HDC, LPCRECT, EnumProc, LPARAM);

static EnumFunc enumDisplayMonitors;

#endif

{

QDesktopWidgetPrivate::screenCount++;

QDesktopWidgetPrivate::rects->resize(QDesktopWidgetPrivate::screenCount);

if (fEscapePressed) {

return ResultFromScode(DRAGDROP_S_CANCEL);

return ResultFromScode(DRAGDROP_S_DROP);

} else {

if (currentButtons == Qt::NoButton) {

currentButtons = keystate_to_mousebutton(grfKeyState);

} else {

#include "qbitmap.h"

#include "qdesktopwidget.h"

#include "qevent.h"

#include "qiodevice.h"

#include "qpointer.h"

#include "qcursor.h"

#include "qvariant.h"

#include "qvector.h"

#include "qurl.h"

// then we could still have problems, but this is highly unlikely

QApplication::flush();

do {

XEvent event;

if (XCheckTypedEvent(X11->display, ClientMessage, &event))

qApp->x11ProcessEvent(&event);

// sleep 50 ms, so we don't use up CPU cycles all the time.

struct timeval usleep_tv;

usleep_tv.tv_sec = 0;

usleep_tv.tv_usec = 50000;

select(0, 0, 0, 0, &usleep_tv);

}

object = o;

ensureNSAppInitialized();

QBoolBlocker block1(blockSendPostedEvents, true);

}

currentModalSessionCached = info.session;

}

}

cocoaModalSessionStack.remove(i);

currentModalSessionCached = 0;

[NSApp endModalSession:info.session];

}

updateChildrenWorksWhenModal();

// currentModalSession). A QCocoaModalSessionInfo is considered pending to be stopped if

// the widget pointer is zero, and the session pointer is non-zero (it will be fully

// stopped in cleanupModalSessions()).

cocoaModalSessionStack.push(info);

updateChildrenWorksWhenModal();

currentModalSessionCached = 0;

typedef struct _QCocoaModalSessionInfo {

QPointer<QWidget> widget;

NSModalSession session;

} QCocoaModalSessionInfo;

#endif

#include "qrect.h"

#include "qpoint.h"

#include "qgesture.h"

#include "private/qobject_p.h"

QT_BEGIN_NAMESPACE

QPoint lastPositions[3];

bool started;

qreal speed;

};

class QTapGesturePrivate : public QGesturePrivate

#include "private/qgesture_p.h"

#include "private/qgraphicsitem_p.h"

#include "private/qevent_p.h"

#include "qgesture.h"

#include "qevent.h"

#include "qgraphicsitem.h"

#endif

#if defined(Q_OS_WIN)

#if !defined(QT_NO_NATIVE_GESTURES)

#endif

#else

registerGestureRecognizer(new QTapAndHoldGestureRecognizer);

Reimplement this function to create a custom QGesture-derived gesture

object if necessary.

*/

QGesture *QGestureRecognizer::create(QObject *target)

{

/*!

\fn int QGridLayout::colSpacing(int col) const

*/

/*!

bool qt_wince_is_windows_mobile_65()

{

}

bool qt_wince_is_pocket_pc() {

{ 0, QT_MAC_MAP_ENUM(0) }

};

static int qt_mac_get_key(int modif, const QChar &key, int virtualKey)

{

#ifdef DEBUG_KEY_BINDINGS

}

}

//oh well

#ifdef DEBUG_KEY_BINDINGS

qDebug("Unknown case.. %s:%d %d[%d] %d", __FILE__, __LINE__, key.unicode(), key.toLatin1(), virtualKey);

}

void

{

UInt32 macVirtualKey = 0;

GetEventParameter(event, kEventParamKeyCode, typeUInt32, 0, sizeof(macVirtualKey), 0, &macVirtualKey);

qtkey = unicode.unicode();

keyLayout[macVirtualKey]->qtKey[i] = qtkey;

}

#ifdef Q_WS_MAC32

} else {

const UInt32 keyModifier = (qt_mac_get_mac_modifiers(ModsTbl[i]));

const XEvent *,

bool grab);

QXCoreDesc coreDesc;

#elif defined(Q_WS_MAC)

//#define DEBUG_KEYMAPPER

// Implemented elsewhere

extern Q_CORE_EXPORT QLocale qt_localeFromLCID(LCID id);

#ifndef LANG_PASHTO

(((KeySym)(keysym) >= 0x11000000) && ((KeySym)(keysym) <= 0x1100FFFF))

#endif

Qt::LayoutDirection *direction,

const QByteArray &layoutName,

const QByteArray &variantName)

QKeyMapperPrivate::QKeyMapperPrivate()

{

memset(&coreDesc, 0, sizeof(coreDesc));

#ifndef QT_NO_XKB

#endif

}

QList<int> QKeyMapperPrivate::possibleKeys(QKeyEvent *event)

{

#ifndef QT_NO_XKB

return possibleKeysXKB(event);

#endif

return possibleKeysCore(event);

void QKeyMapperPrivate::clearMappings()

{

#ifndef QT_NO_XKB

// try to determine the layout name and input direction by reading the _XKB_RULES_NAMES property off

// the root window

QByteArray layoutName;

p += qstrlen(p) + 1;

} while (p < end);

}

// ### ???

// if (keyboardLayoutName.isEmpty())

// qWarning("Qt: unable to determine keyboard layout, please talk to qt-bugs@trolltech.com"); ?

&keyboardInputDirection,

layoutName,

variantName);

<< "direction ="

<< keyboardInputDirection;

#endif

if (data)

XFree(data);

} else

// look at the modifier mapping, and get the correct masks for alt, meta, super, hyper, and mode_switch

#ifndef QT_NO_XKB

XkbDescPtr xkbDesc = XkbGetMap(X11->display, XkbAllClientInfoMask, XkbUseCoreKbd);

for (int i = xkbDesc->min_key_code; i < xkbDesc->max_key_code; ++i) {

const uint mask = xkbDesc->map->modmap ? xkbDesc->map->modmap[i] : 0;

XF86XK_AudioNext, Qt::Key_MediaNext,

XF86XK_AudioRecord, Qt::Key_MediaRecord,

XF86XK_Mail, Qt::Key_LaunchMail,

XF86XK_Memo, Qt::Key_Memo,

XF86XK_ToDoList, Qt::Key_ToDoList,

XF86XK_Calendar, Qt::Key_Calendar,

XF86XK_Bluetooth, Qt::Key_Bluetooth,

XF86XK_Suspend, Qt::Key_Suspend,

XF86XK_Hibernate, Qt::Key_Hibernate,

XF86XK_Launch1, Qt::Key_Launch3,

XF86XK_Launch2, Qt::Key_Launch4,

XF86XK_Launch3, Qt::Key_Launch5,

XF86XK_LaunchB, Qt::Key_LaunchD,

XF86XK_LaunchC, Qt::Key_LaunchE,

XF86XK_LaunchD, Qt::Key_LaunchF,

// Qtopia keys

QTOPIAXK_Select, Qt::Key_Select,

{ Qt::Key_Hangup, QT_TRANSLATE_NOOP("QShortcut", "Hangup") },

{ Qt::Key_Flip, QT_TRANSLATE_NOOP("QShortcut", "Flip") },

{ 0, 0 }

};

{QKeySequence::Redo, 1, Qt::CTRL | Qt::SHIFT | Qt::Key_Z, QApplicationPrivate::KB_Mac}, //different priority from above

{QKeySequence::PreviousChild, 1, Qt::CTRL | Qt::SHIFT | Qt::Key_Backtab, QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11},

{QKeySequence::PreviousChild, 0, Qt::CTRL | Qt::SHIFT | Qt::Key_Backtab, QApplicationPrivate::KB_Mac },//different priority from above

{QKeySequence::SelectStartOfDocument, 0, Qt::CTRL | Qt::SHIFT | Qt::Key_Home, QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11 | QApplicationPrivate::KB_S60},

{QKeySequence::SelectEndOfDocument, 0, Qt::CTRL | Qt::SHIFT | Qt::Key_End, QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11 | QApplicationPrivate::KB_S60},

{QKeySequence::SelectPreviousWord, 0, Qt::CTRL | Qt::SHIFT | Qt::Key_Left, QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11 | QApplicationPrivate::KB_S60},

} else if (getCf(formatetc) == CF_INETURL_W) {

QList<QUrl> urls = mimeData->urls();

QByteArray result;

result.append('\0');

result.append('\0');

return setData(result, pmedium);

} else if (getCf(formatetc) == CF_INETURL) {

QList<QUrl> urls = mimeData->urls();

return setData(result, pmedium);

}

}

QDataStream s(&ba, QIODevice::WriteOnly);

s.setByteOrder(QDataStream::LittleEndian);// Intel byte order ####

if (cf == CF_DIB) {

if (qt_write_dib(s, img))

return setData(ba, pmedium);

} else {

break;

}

action->setSoftKeyRole(softKeyRole);

return action;

}

{

Q_D(QSoftKeyManager);

bool ret = false;

ret = true;

}

}

return ret;

}

QWidget *QSoftKeyManager::softkeySource(QWidget *previousSource, bool& recursiveMerging)

{

Q_D(QSoftKeyManager);

QWidget *source = NULL;

if (!previousSource) {

// Initial source is primarily focuswidget and secondarily activeWindow

} else {

// Softkey merging is based on four criterias

// 1. Implicit merging is used whenever focus widget does not specify any softkeys

d->requestedSoftKeyActions.clear();

bool recursiveMerging = false;

QWidget *source = softkeySource(NULL, recursiveMerging);

while (source) {

if (appendSoftkeys(*source, level))

++level;

return true;

}

bool QSoftKeyManager::event(QEvent *e)

{

#ifndef QT_NO_ACTION

static QSoftKeyManager *self;

QHash<QAction*, Qt::Key> keyedActions;

QMultiHash<int, QAction*> requestedSoftKeyActions;

};

QT_END_HEADER

class QSoftKeyManagerPrivate;

class Q_AUTOTEST_EXPORT QSoftKeyManager : public QObject

{

static QAction *createAction(StandardSoftKey standardKey, QWidget *actionWidget);

static QAction *createKeyedAction(StandardSoftKey standardKey, Qt::Key key, QWidget *actionWidget);

static QString standardSoftKeyText(StandardSoftKey standardKey);

protected:

bool event(QEvent *e);

const int MSK_POSITION = 3;

const int RSK_POSITION = 2;

{

cachedCbaIconSize[0] = QSize(0,0);

cachedCbaIconSize[1] = QSize(0,0);

// Lets not update softkeys if

// 1. We don't have application panes, i.e. cba

// 2. Our CBA is not active, i.e. S60 native dialog or menu with custom CBA is shown

// Note: Cannot use IsDisplayingMenuOrDialog since CBA update can be triggered before

// menu/dialog CBA is actually displayed i.e. it is being costructed.

CEikButtonGroupContainer *appUiCba = S60->buttonGroupContainer();

CEikButtonGroupContainer *currentCba = CEikButtonGroupContainer::Current();

return true;

}

return false;

myimage->SetPicture( nBitmap, nMask ); // nBitmap and nMask ownership transfered

EikSoftkeyImage::SetImage(cba, *myimage, left); // Takes myimage ownership

ret = true;

} else {

// Restore softkey to text based

}

}

return ret;

TPtrC nativeText = qt_QString2TPtrC(text);

int command = S60_COMMAND_START + position;

setNativeSoftkey(cba, position, command, nativeText);

realSoftKeyActions.insert(command, action);

return true;

}

bool QSoftKeyManagerPrivateS60::setRightSoftkey(CEikButtonGroupContainer &cba)

{

if (!setSoftkey(cba, QAction::NegativeSoftKey, RSK_POSITION)) {

if (windowType != Qt::Dialog && windowType != Qt::Popup) {

QString text(QSoftKeyManager::tr("Exit"));

TPtrC nativeText = qt_QString2TPtrC(text);

setNativeSoftkey(cba, RSK_POSITION, EAknSoftkeyExit, nativeText);

return true;

}

}

nativeContainer->DrawDeferred(); // 3.1 needs an extra invitation

}

bool QSoftKeyManagerPrivateS60::handleCommand(int command)

{

QAction *action = realSoftKeyActions.value(command);

if (action) {

QVariant property = action->property(MENU_ACTION_PROPERTY);

if (property.isValid() && property.toBool()) {

} else if (action->menu()) {

// TODO: This is hack, in order to use exising QMenuBar implementation for Symbian

// menubar needs to have widget to which it is associated. Since we want to associate

// to action and pass that for QMenuBar. This associates the menubar to action, and we

// can have own menubar for each action.

QWidget *actionContainer = action->property("_q_action_widget").value<QWidget*>();

action->setProperty("_q_action_widget", v);

}

qt_symbian_next_menu_from_action(actionContainer);

}

}

return false;

// We mean it.

//

#include "private/qobject_p.h"

#include "private/qsoftkeymanager_common_p.h"

bool handleCommand(int command);

private:

bool skipCbaUpdate();

void ensureCbaVisibilityAndResponsiviness(CEikButtonGroupContainer &cba);

void clearSoftkeys(CEikButtonGroupContainer &cba);

private:

QHash<int, QAction*> realSoftKeyActions;

QSize cachedCbaIconSize[4];

};

supports WAVE and AU files.

\row

\o Mac OS X

are supported by Qt for Mac OS X.

\row

\o Qt for Embedded Linux

\o A built-in mixing sound server is used, accessing \c /dev/dsp

directly. Only the WAVE format is supported.

\o Symbian

\o CMdaAudioPlayerUtility is used. All formats that Symbian OS or devices support

are supported also by Qt.

NSSound * const nsSound = [[NSSound alloc] initWithContentsOfFile: nsFileName byReference:YES];

QMacSoundDelegate * const delegate = [[QMacSoundDelegate alloc] initWithQSound:qSound:this];

[nsSound setDelegate:delegate];

return nsSound;

}

switch (event->type()) {

case QEvent::TouchBegin: {

d->speed = 1;

d->started = true;

result = QGestureRecognizer::MayBeGesture;

break;

p3.screenPos().y() - d->lastPositions[2].y()) / 3;

const int distance = xDistance >= yDistance ? xDistance : yDistance;

if (!elapsedTime)

elapsedTime = 1;

d->speed = 0.9 * d->speed + distance / elapsedTime;

d->swipeAngle = QLineF(p1.startScreenPos(), p1.screenPos()).angle();

static const int MoveThreshold = 50;

d->lastPositions[0] = d->lastPositions[1] = d->lastPositions[2] = QPoint();

d->started = false;

d->speed = 0;

QGestureRecognizer::reset(state);

}

extern bool qt_sendSpontaneousEvent(QObject *receiver, QEvent *event); // qapplication.cpp;

extern QWidget * mac_mouse_grabber;

void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds)

{

// Clears the QWidget pointer that each QCocoaView holds.

void qt_mac_clearCocoaViewQWidgetPointers(QWidget *widget)

{

if (cocoaView && [cocoaView respondsToSelector:@selector(qt_qwidget)]) {

[cocoaView qt_clearQWidget];

}

UInt32 macScanCode = 1;

QKeyEventEx ke(cocoaEvent2QtEvent([event type]), qtKey, keyMods, text, [event isARepeat], qMax(1, keyLength),

macScanCode, [event keyCode], [event modifierFlags]);

}

#endif

EventRef key_event = static_cast<EventRef>(const_cast<void *>([event eventRef]));

Q_ASSERT(key_event);

if ([event type] == NSKeyDown) {

}

if (widgetToGetEvent == 0)

return false;

if (mustUseCocoaKeyEvent())

return qt_dispatchKeyEventWithCocoa(keyEvent, widgetToGetEvent);

bool isAccepted;

#endif

}

[static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(tmpView) qt_qwidget];

}

} else {

QPoint pos;

widgetToGetMouse = QApplicationPrivate::pickMouseReceiver(qwidget, qglobalPoint,

pos, eventType,

return false;

NSPoint localPoint = [tmpView convertPoint:windowPoint fromView:nil];

EventRef carbonEvent = static_cast<EventRef>(const_cast<void *>([theEvent eventRef]));

if (qt_mac_sendMacEventToWidget(widgetToGetMouse, carbonEvent))

}

[QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->localPoint = localPoint;

QMouseEvent qme(eventType, qlocalPoint, qglobalPoint, button, buttons, keyMods);

if (eventType == QEvent::MouseButtonPress && button == Qt::RightButton) {

QContextMenuEvent qcme(QContextMenuEvent::Mouse, qlocalPoint, qglobalPoint, keyMods);

qt_sendSpontaneousEvent(widgetToGetMouse, &qcme);

[(NSAutoreleasePool*)pool release];

}

QT_END_NAMESPACE

#endif

QT_END_NAMESPACE

#include <eikappui.h>

#ifdef Q_WS_S60

#include <avkon.hrh> // EEikStatusPaneUidTitle

#include <akntitle.h> // CAknTitlePane

#include <akncontext.h> // CAknContextPane

#include <eikspane.h> // CEikStatusPane

#endif

QT_BEGIN_NAMESPACE

int qtOwnsS60Environment : 1;

int supportsPremultipliedAlpha : 1;

int avkonComponentsSupportTransparency : 1;

QApplication::QS60MainApplicationFactory s60ApplicationFactory; // typedef'ed pointer type

static inline void updateScreenSize();

static inline RWsSession& wsSession();

#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

void translateAdvancedPointerEvent(const TAdvancedPointerEvent *event);

#endif

private:

static QSymbianControl *lastFocusedControl;

int xinput_eventbase;

int xinput_errorbase;

QList<QWidget *> deferred_map;

struct ScrollInProgress {

long id;

_NET_SYSTEM_TRAY_VISUAL,

// Property formats

COMPOUND_TEXT,

TEXT,

XWacomCursor,

XWacomEraser,

NPredefinedAtoms,

_QT_SETTINGS_TIMESTAMP = NPredefinedAtoms,

#ifdef Q_WS_MAC

#else

QRect screen = QApplication::desktop()->screenGeometry(getTipScreen(pos, w));

#endif

, nativeGesturePanEnabled(0)

#elif defined(Q_WS_MAC)

, needWindowChange(0)

, window_event(0)

, qd_hd(0)

#endif

qFatal("QWidget: Cannot create a QWidget when no GUI is being used");

Q_ASSERT(allWidgets);

QWidget *desktopWidget = 0;

if (parentWidget && parentWidget->windowType() == Qt::Desktop) {

if (f & Qt::MSWindowsOwnDC)

q->setAttribute(Qt::WA_NativeWindow);

q->setAttribute(Qt::WA_QuitOnClose); // might be cleared in adjustQuitOnCloseAttribute()

adjustQuitOnCloseAttribute();

}

if (QWidget *parent = parentWidget()) {

if (type & Qt::Window) {

if (!parent->testAttribute(Qt::WA_WState_Created))

parent->createWinId();

}

}

else if (!internalWinId() && isVisible()) {

qApp->d_func()->sendSyntheticEnterLeave(this);

#ifdef Q_WS_QWS

if (QWidgetPrivate::allWidgets) // might have been deleted by ~QApplication

QWidgetPrivate::allWidgets->remove(this);

}

int QWidgetPrivate::instanceCounter = 0; // Current number of widget instances

WId QWidget::winId() const

{

if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {

QWidget *that = const_cast<QWidget*>(this);

that->setAttribute(Qt::WA_NativeWindow);

that->d_func()->createWinId();

void QWidgetPrivate::createWinId(WId winid)

{

Q_Q(QWidget);

const bool forceNativeWindow = q->testAttribute(Qt::WA_NativeWindow);

if (!q->testAttribute(Qt::WA_WState_Created) || (forceNativeWindow && !q->internalWinId())) {

if (!q->isWindow()) {

void QWidget::createWinId()

{

Q_D(QWidget);

// qWarning("QWidget::createWinId is obsolete, please fix your code.");

d->createWinId();

}

QPaintEngine *paintEngine = pdev->paintEngine();

if (paintEngine) {

setRedirected(pdev, -offset);

if (sharedPainter)

paintEngine->d_func()->systemClip = toBePainted;

else

//restore

if (paintEngine) {

restoreRedirected();

if (!sharedPainter)

paintEngine->d_func()->systemRect = QRect();

const QRegion &sourceRegion, QWidget::RenderFlags renderFlags,

bool readyToRender)

{

if (!target) {

qWarning("QWidget::render: null pointer to paint device");

return;

previousProxyFocus = topData->proxyWidget->widget()->focusWidget();

if (previousProxyFocus && previousProxyFocus->focusProxy())

previousProxyFocus = previousProxyFocus->focusProxy();

}

}

#endif

// QWidget *fp = first->d_func()->focus_prev;

QWidget *fn = first->d_func()->focus_next;

return;

QWidget *sp = second->d_func()->focus_prev;

// next bit tries to move the focus if the focus widget is now

// hidden.

if (wasVisible) {

qApp->d_func()->sendSyntheticEnterLeave(q);

#endif

d->show_helper();

qApp->d_func()->sendSyntheticEnterLeave(this);

#endif

}

QWidget *widget = qobject_cast<QWidget*>(childList.at(i));

if (!widget || widget->isWindow() || widget->testAttribute(Qt::WA_WState_Hidden))

continue;

if (spontaneous)

widget->setAttribute(Qt::WA_Mapped, false);

else

widget->d_func()->hide_sys();

}

}

qApp->d_func()->sendSyntheticEnterLeave(widget);

#endif

#ifndef QT_NO_ACCESSIBILITY

// set/reset WS_DISABLED style.

if(w && w->isWindow() && w->isVisible() && w->isEnabled()) {

LONG dwStyle = GetWindowLong(w->winId(), GWL_STYLE);

if (setStyle)

else

}

}

#endif

desktopWidget = parent;

bool newParent = (parent != parentWidget()) || !wasCreated || desktopWidget;

if (newParent && parent && !desktopWidget) {

if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))

parent->d_func()->enforceNativeChildren();

#endif // QT3_SUPPORT

/*!

Sets the attribute \a attribute on this widget if \a on is true;

otherwise clears the attribute.

}

#endif

switch (attribute) {

#ifdef Q_WS_MAC

{

// We can only have one of these set at a time

}

d->macUpdateSizeAttribute();

}

}

case Qt::WA_PaintOnScreen:

d->updateIsOpaque();

// Recreate the widget if it's already created as an alien widget and

// WA_PaintOnScreen is enabled. Paint on screen widgets must have win id.

// So must their children.

case Qt::WA_X11OpenGLOverlay:

d->updateIsOpaque();

break;

#endif

case Qt::WA_DontShowOnScreen: {

if (on && isVisible()) {

#ifdef Q_WS_X11

friend void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);

friend void qt_net_remove_user_time(QWidget *tlw);

#endif

friend Q_GUI_EXPORT QWidgetData *qt_qwidget_data(QWidget *widget);

static OSWindowRef qt_root_win = 0;

QWidget *mac_mouse_grabber = 0;

QWidget *mac_keyboard_grabber = 0;

#ifndef QT_MAC_USE_COCOA

#ifdef QT_NAMESPACE

bool qt_isGenuineQWidget(const QWidget *window)

{

}

Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)

& ~Qt::WindowMaximized));

QApplication::sendSpontaneousEvent(widget, &e);

}

qt_button_down = 0;

} else if(ekind == kEventWindowCollapsed) {

if (!widget->isMinimized()) {

//we send a hide to be like X11/Windows

QEvent e(QEvent::Hide);

QApplication::sendSpontaneousEvent(widget, &e);

qt_button_down = 0;

} else if(ekind == kEventWindowToolbarSwitchMode) {

macSendToolbarChangeEvent(widget);

if (widget->isVisible() && widget->updatesEnabled()) { //process the actual paint event.

if(widget->testAttribute(Qt::WA_WState_InPaintEvent))

qWarning("QWidget::repaint: Recursive repaint detected");

QPoint redirectionOffset(0, 0);

QWidget *tl = widget->window();

widget->d_func()->restoreRedirected();

}

if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget))

CallNextEventHandler(er, event);

if (widget) {

qt_event_request_window_change(widget);

if (!HIViewIsVisible(HIViewRef(widget->winId()))) {

if (widget == qt_button_down)

qt_button_down = 0;

}

break; }

case kEventClassMouse: {

bool send_to_app = false;

if(qt_button_down)

send_to_app = true;

if(send_to_app) {

}

} else {

data.fstrut_dirty = false; // non-toplevel widgets don't have a frame, so no need to update the strut

#ifndef QT_MAC_USE_COCOA

HIRect bounds = CGRectMake(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());

HIViewSetFrame(osview, &bounds);

q->setAttribute(Qt::WA_WState_Visible, false);

q->setAttribute(Qt::WA_WState_Hidden, false);

adjustFlags(data.window_flags, q);

createWinId();

if (q->isWindow()) {

#ifndef QT_MAC_USE_COCOA

QPoint QWidget::mapToGlobal(const QPoint &pos) const

{

Q_D(const QWidget);

QPoint p = pos + data->crect.topLeft();

return isWindow() ? p : parentWidget()->mapToGlobal(p);

}

QPoint QWidget::mapFromGlobal(const QPoint &pos) const

{

Q_D(const QWidget);

QPoint p = isWindow() ? pos : parentWidget()->mapFromGlobal(pos);

return p - data->crect.topLeft();

}

#ifndef QT_MAC_USE_COCOA

HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true);

#else

#endif

return;

}

HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true); // do a complete repaint on overflow.

}

#else

#endif

}

// The window is modally shaddowed, so we need to make

// sure that we don't pop in front of the modal window:

[window orderFront:window];

}

#endif

if (q->windowType() == Qt::Popup) {

Q_Q(QWidget);

if((q->windowType() == Qt::Desktop)) //you can't hide the desktop!

return;

QMacCocoaAutoReleasePool pool;

if(q->isWindow()) {

#ifdef QT_MAC_USE_COCOA

widget, either by scrolling its contents or repainting, depending on the WA_StaticContents

flag

*/

{

#ifndef QT_MAC_USE_COCOA

HIRect bounds = CGRectMake(newRect.x(), newRect.y(),

#else

Q_UNUSED(oldRect);

NSRect bounds = NSMakeRect(newRect.x(), newRect.y(),

[qt_mac_nativeview_for(q) setFrame:bounds];

#endif

}

QRect xrect = data.crect;

QRect parentWRect;

#ifndef QT_MAC_USE_COCOA

HIViewRef parentView = HIViewGetSuperview(qt_mac_nativeview_for(q));

#else

if (parentWRect.isValid()) {

// parent is clipped, and we have to clip to the same limit as parent

xrect &= parentWRect;

wrect = xrect;

//translate from parent's to my Qt coord sys

}

}

if (jump)

q->update();

if (!q->testAttribute(Qt::WA_WState_Created) || !extra)

return;

extra->maskBits.fill(QColor(Qt::color1).rgba());

extra->maskBits.setNumColors(2);

extra->maskBits.setColor(0, QColor(Qt::color0).rgba());

[window setOpaque:(extra->imageMask == 0)];

[window invalidateShadow];

}

}

#endif

uint activated : 1; // RWindowBase::Activated has been called

/**

* Defines the behaviour of QSymbianControl::Draw.

*/

enum NativePaintMode {

Default = Blit

};

#endif

};

QMap<Qt::GestureType, Qt::GestureFlags> gestureContext;

// Bit fields.

QPalette::ColorRole fg_role : 8;

QPalette::ColorRole bg_role : 8;

uint dirtyOpaqueChildren : 1;

void setNetWmWindowTypes();

void x11UpdateIsOpaque();

bool isBackgroundInherited() const;

#elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN

uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()

uint nativeGesturePanEnabled : 1;

#elif defined(Q_WS_MAC) // <--------------------------------------------------------- MAC

// This is new stuff

uint needWindowChange : 1;

// Each wiget keeps a list of all its child and grandchild OpenGL widgets.

// This list is used to update the gl context whenever a parent and a granparent

return widgetPos;

}

void QWidget::setWindowState(Qt::WindowStates newstate)

{

Q_D(QWidget);

Qt::WindowStates oldstate = windowState();

return;

if (isWindow()) {

QSymbianControl *window = static_cast<QSymbianControl *>(effectiveWinId());

if (window && newstate & Qt::WindowMinimized) {

#ifdef Q_WS_S60

// Hide window decoration when switching to fullsccreen / minimized otherwise show decoration.

// we will avoid unnecessarty redraws

if (statusPane)

statusPane->MakeVisible(visible);

#endif // Q_WS_S60

createWinId();

Q_ASSERT(testAttribute(Qt::WA_WState_Created));

// Ensure the initial size is valid, since we store it as normalGeometry below.

adjustSize();

QTLWExtra *top = d->topData();

const QRect normalGeometry = (top->normalGeometry.width() < 0) ? geometry() : top->normalGeometry;

setGeometry(qApp->desktop()->screenGeometry(this));

setGeometry(qApp->desktop()->availableGeometry(this));

else

setGeometry(normalGeometry);

//restore normal geometry

top->normalGeometry = normalGeometry;

}

data->window_state = newstate;

{

if (!qt_nograb() && QWidgetPrivate::mouseGrabber == this) {

Q_ASSERT(testAttribute(Qt::WA_WState_Created));

QWidgetPrivate::mouseGrabber = 0;

#ifndef QT_NO_CURSOR

QApplication::restoreOverrideCursor();

static QWidget *keyboardGrb = 0;

static HHOOK journalRec = 0;

#define XCOORD_MAX 16383

#define WRECT_MAX 16383

// The procedure does nothing, but is required for mousegrabbing to work

#ifndef Q_WS_WINCE

{

return CallNextHookEx(journalRec, nCode, wParam, lParam);

}

if (!q || !q->isVisible() || !nativeGesturePanEnabled)

return;

QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();

if (!qAppPriv->SetGestureConfig)

return;

QT_BEGIN_NAMESPACE

const QString qt_reg_winclass(QWidget *w); // defined in qapplication_win.cpp

//#define TABLET_DEBUG

#define PACKETDATA (PK_X | PK_Y | PK_BUTTONS | PK_NORMAL_PRESSURE | PK_TANGENT_PRESSURE \

}

// The procedure does nothing, but is required for mousegrabbing to work

Q_UNUSED(nCode);

Q_UNUSED(wParam);

Q_UNUSED(lParam);

#include "qbitmap.h"

#include "qlayout.h"

#include "qtextcodec.h"

#include "qcursor.h"

#include "qstack.h"

#include "qcolormap.h"

return;

QApplication::flush();

XEvent ev;

t.start();

static const int maximumWaitTime = 2000;

if (!w->testAttribute(Qt::WA_WState_Created))

// ConfigureNotify ... MapNotify ... Expose

enum State {

} state = Initial;

do {

XNextEvent(X11->display, &ev);

qApp->x11ProcessEvent(&ev);

}

} else {

if (!XEventsQueued(X11->display, QueuedAfterFlush))

XWMHints wm_hints; // window manager hints

memset(&wm_hints, 0, sizeof(wm_hints)); // make valgrind happy

wm_hints.flags = InputHint | StateHint | WindowGroupHint;

wm_hints.initial_state = NormalState;

wm_hints.window_group = X11->wm_client_leader;

adjustFlags(data.window_flags, q);

// keep compatibility with previous versions, we need to preserve the created state

// (but we recreate the winId for the widget being reparented, again for compatibility)

createWinId();

if (q->isWindow() || (!parent || parent->isVisible()) || explicitlyHidden)

q->setAttribute(Qt::WA_WState_Hidden);

if (X11->userTime == 0)

X11->userTime = X11->time;

qt_net_update_user_time(tlw, X11->userTime);

}

}

xinfo->setX11Data(xd);

}

QT_END_NAMESPACE

//

#include <QGestureRecognizer>

QT_BEGIN_NAMESPACE

#include <qlayout.h>

#include <qstyle.h>

#include <qstyleoption.h>

#include <qpointer.h>

#include <qdebug.h>

#include <qx11info_x11.h>

For safety, we will not wait more than 500 ms, so that we can

preemptively workaround buggy window managers.

*/

t.start();

functorData data;