2140 lines
74 KiB
C++
2140 lines
74 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** 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
|
|
** contained in the Technology Preview License Agreement accompanying
|
|
** this package.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 2.1 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 2.1 requirements
|
|
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** If you have questions regarding the use of this file, please contact
|
|
** Nokia at qt-info@nokia.com.
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qapplication.h"
|
|
#include "qapplication_p.h"
|
|
#include "qbitmap.h"
|
|
#include "qcursor.h"
|
|
#include "qdesktopwidget.h"
|
|
#include "qevent.h"
|
|
#include "qimage.h"
|
|
#include "qlayout.h"
|
|
#include "qpainter.h"
|
|
#include "qstack.h"
|
|
#include "qt_windows.h"
|
|
#include "qwidget.h"
|
|
#include "qwidget_p.h"
|
|
#include "private/qbackingstore_p.h"
|
|
#include "private/qwindowsurface_raster_p.h"
|
|
|
|
#include "qscrollbar.h"
|
|
#include "qabstractscrollarea.h"
|
|
#include <private/qabstractscrollarea_p.h>
|
|
|
|
#include <qdebug.h>
|
|
|
|
#include <private/qapplication_p.h>
|
|
#include <private/qwininputcontext_p.h>
|
|
#include <private/qpaintengine_raster_p.h>
|
|
#include <private/qsystemlibrary_p.h>
|
|
|
|
#if defined(Q_WS_WINCE)
|
|
#include "qguifunctions_wince.h"
|
|
QT_USE_NAMESPACE
|
|
extern void qt_wince_maximize(QWidget *widget); //defined in qguifunctions_wince.cpp
|
|
extern void qt_wince_unmaximize(QWidget *widget); //defined in qguifunctions_wince.cpp
|
|
extern void qt_wince_minimize(HWND hwnd); //defined in qguifunctions_wince.cpp
|
|
extern void qt_wince_full_screen(HWND hwnd, bool fullScreen, UINT swpf); //defined in qguifunctions_wince.cpp
|
|
extern bool qt_wince_is_mobile(); //defined in qguifunctions_wince.cpp
|
|
#endif
|
|
|
|
typedef BOOL (WINAPI *PtrSetLayeredWindowAttributes)(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
|
|
static PtrSetLayeredWindowAttributes ptrSetLayeredWindowAttributes = 0;
|
|
|
|
#ifndef QT_NO_DIRECTDRAW
|
|
#include <ddraw.h>
|
|
#include <private/qimage_p.h>
|
|
static IDirectDraw *qt_ddraw_object;
|
|
static IDirectDrawSurface *qt_ddraw_primary;
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(QT_NON_COMMERCIAL)
|
|
#include "qnc_win.h"
|
|
#endif
|
|
|
|
#if !defined(WS_EX_TOOLWINDOW)
|
|
#define WS_EX_TOOLWINDOW 0x00000080
|
|
#endif
|
|
|
|
#if !defined(GWLP_WNDPROC)
|
|
#define GWLP_WNDPROC GWL_WNDPROC
|
|
#endif
|
|
|
|
//#define TABLET_DEBUG
|
|
#define PACKETDATA (PK_X | PK_Y | PK_BUTTONS | PK_NORMAL_PRESSURE | PK_TANGENT_PRESSURE \
|
|
| PK_ORIENTATION | PK_CURSOR | PK_Z)
|
|
#define PACKETMODE 0
|
|
#include <wintab.h>
|
|
#include <pktdef.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
typedef HCTX (API *PtrWTOpen)(HWND, LPLOGCONTEXT, BOOL);
|
|
typedef BOOL (API *PtrWTClose)(HCTX);
|
|
typedef UINT (API *PtrWTInfo)(UINT, UINT, LPVOID);
|
|
typedef BOOL (API *PtrWTEnable)(HCTX, BOOL);
|
|
typedef BOOL (API *PtrWTOverlap)(HCTX, BOOL);
|
|
typedef int (API *PtrWTPacketsGet)(HCTX, int, LPVOID);
|
|
typedef BOOL (API *PtrWTGet)(HCTX, LPLOGCONTEXT);
|
|
typedef int (API *PtrWTQueueSizeGet)(HCTX);
|
|
typedef BOOL (API *PtrWTQueueSizeSet)(HCTX, int);
|
|
|
|
static PtrWTOpen ptrWTOpen = 0;
|
|
static PtrWTClose ptrWTClose = 0;
|
|
static PtrWTInfo ptrWTInfo = 0;
|
|
static PtrWTQueueSizeGet ptrWTQueueSizeGet = 0;
|
|
static PtrWTQueueSizeSet ptrWTQueueSizeSet = 0;
|
|
#ifndef QT_NO_TABLETEVENT
|
|
static void init_wintab_functions();
|
|
static void qt_tablet_init();
|
|
static void qt_tablet_cleanup();
|
|
#endif // QT_NO_TABLETEVENT
|
|
extern HCTX qt_tablet_context;
|
|
extern bool qt_tablet_tilt_support;
|
|
|
|
static QWidget *qt_tablet_widget = 0;
|
|
QWidget* qt_get_tablet_widget()
|
|
{
|
|
return qt_tablet_widget;
|
|
}
|
|
|
|
extern bool qt_is_gui_used;
|
|
|
|
#ifndef QT_NO_TABLETEVENT
|
|
static void init_wintab_functions()
|
|
{
|
|
#if defined(Q_OS_WINCE)
|
|
return;
|
|
#else
|
|
if (!qt_is_gui_used)
|
|
return;
|
|
QSystemLibrary library(QLatin1String("wintab32"));
|
|
ptrWTOpen = (PtrWTOpen)library.resolve("WTOpenW");
|
|
ptrWTInfo = (PtrWTInfo)library.resolve("WTInfoW");
|
|
ptrWTClose = (PtrWTClose)library.resolve("WTClose");
|
|
ptrWTQueueSizeGet = (PtrWTQueueSizeGet)library.resolve("WTQueueSizeGet");
|
|
ptrWTQueueSizeSet = (PtrWTQueueSizeSet)library.resolve("WTQueueSizeSet");
|
|
#endif // Q_OS_WINCE
|
|
}
|
|
|
|
static void qt_tablet_init()
|
|
{
|
|
static bool firstTime = true;
|
|
if (!firstTime)
|
|
return;
|
|
firstTime = false;
|
|
qt_tablet_widget = new QWidget(0);
|
|
qt_tablet_widget->createWinId();
|
|
qt_tablet_widget->setObjectName(QLatin1String("Qt internal tablet widget"));
|
|
// We don't need this internal widget to appear in QApplication::topLevelWidgets()
|
|
if (QWidgetPrivate::allWidgets)
|
|
QWidgetPrivate::allWidgets->remove(qt_tablet_widget);
|
|
LOGCONTEXT lcMine;
|
|
qAddPostRoutine(qt_tablet_cleanup);
|
|
struct tagAXIS tpOri[3];
|
|
init_wintab_functions();
|
|
if (ptrWTInfo && ptrWTOpen && ptrWTQueueSizeGet && ptrWTQueueSizeSet) {
|
|
// make sure we have WinTab
|
|
if (!ptrWTInfo(0, 0, NULL)) {
|
|
#ifdef TABLET_DEBUG
|
|
qWarning("QWidget: Wintab services not available");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// some tablets don't support tilt, check if it is possible,
|
|
qt_tablet_tilt_support = ptrWTInfo(WTI_DEVICES, DVC_ORIENTATION, &tpOri);
|
|
if (qt_tablet_tilt_support) {
|
|
// check for azimuth and altitude
|
|
qt_tablet_tilt_support = tpOri[0].axResolution && tpOri[1].axResolution;
|
|
}
|
|
// build our context from the default context
|
|
ptrWTInfo(WTI_DEFSYSCTX, 0, &lcMine);
|
|
// Go for the raw coordinates, the tablet event will return good stuff
|
|
lcMine.lcOptions |= CXO_MESSAGES | CXO_CSRMESSAGES;
|
|
lcMine.lcPktData = PACKETDATA;
|
|
lcMine.lcPktMode = PACKETMODE;
|
|
lcMine.lcMoveMask = PACKETDATA;
|
|
lcMine.lcOutOrgX = 0;
|
|
lcMine.lcOutExtX = lcMine.lcInExtX;
|
|
lcMine.lcOutOrgY = 0;
|
|
lcMine.lcOutExtY = -lcMine.lcInExtY;
|
|
qt_tablet_context = ptrWTOpen(qt_tablet_widget->winId(), &lcMine, true);
|
|
#ifdef TABLET_DEBUG
|
|
qDebug("Tablet is %p", qt_tablet_context);
|
|
#endif
|
|
if (!qt_tablet_context) {
|
|
#ifdef TABLET_DEBUG
|
|
qWarning("QWidget: Failed to open the tablet");
|
|
#endif
|
|
return;
|
|
}
|
|
// Set the size of the Packet Queue to the correct size...
|
|
int currSize = ptrWTQueueSizeGet(qt_tablet_context);
|
|
if (!ptrWTQueueSizeSet(qt_tablet_context, QT_TABLET_NPACKETQSIZE)) {
|
|
// Ideally one might want to use a smaller
|
|
// multiple, but for now, since we managed to destroy
|
|
// the existing Q with the previous call, set it back
|
|
// to the other size, which should work. If not,
|
|
// there will be trouble.
|
|
if (!ptrWTQueueSizeSet(qt_tablet_context, currSize)) {
|
|
Q_ASSERT_X(0, "Qt::Internal", "There is no packet queue for"
|
|
" the tablet. The tablet will not work");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void qt_tablet_cleanup()
|
|
{
|
|
if (ptrWTClose)
|
|
ptrWTClose(qt_tablet_context);
|
|
delete qt_tablet_widget;
|
|
qt_tablet_widget = 0;
|
|
}
|
|
#endif // QT_NO_TABLETEVENT
|
|
|
|
const QString qt_reg_winclass(QWidget *w); // defined in qapplication_win.cpp
|
|
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
void qt_olednd_unregister(QWidget* widget, QOleDropTarget *dst); // dnd_win
|
|
QOleDropTarget* qt_olednd_register(QWidget* widget);
|
|
#endif
|
|
|
|
extern bool qt_nograb();
|
|
extern HRGN qt_win_bitmapToRegion(const QBitmap& bitmap);
|
|
|
|
static QWidget *mouseGrb = 0;
|
|
static QCursor *mouseGrbCur = 0;
|
|
static QWidget *keyboardGrb = 0;
|
|
static HHOOK journalRec = 0;
|
|
|
|
extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
#define XCOORD_MAX 16383
|
|
#define WRECT_MAX 16383
|
|
|
|
/*****************************************************************************
|
|
QWidget member functions
|
|
*****************************************************************************/
|
|
|
|
#ifndef Q_WS_WINCE
|
|
void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyOldWindow)
|
|
{
|
|
Q_Q(QWidget);
|
|
static int sw = -1, sh = -1;
|
|
|
|
Qt::WindowType type = q->windowType();
|
|
Qt::WindowFlags flags = data.window_flags;
|
|
|
|
bool topLevel = (flags & Qt::Window);
|
|
bool popup = (type == Qt::Popup);
|
|
bool dialog = (type == Qt::Dialog
|
|
|| type == Qt::Sheet
|
|
|| (flags & Qt::MSWindowsFixedSizeDialogHint));
|
|
bool desktop = (type == Qt::Desktop);
|
|
bool tool = (type == Qt::Tool || type == Qt::Drawer);
|
|
|
|
HINSTANCE appinst = qWinAppInst();
|
|
HWND parentw, destroyw = 0;
|
|
WId id = 0;
|
|
|
|
QString windowClassName = qt_reg_winclass(q);
|
|
|
|
if (!window) // always initialize
|
|
initializeWindow = true;
|
|
|
|
if (popup)
|
|
flags |= Qt::WindowStaysOnTopHint; // a popup stays on top
|
|
|
|
if (sw < 0) { // get the (primary) screen size
|
|
sw = GetSystemMetrics(SM_CXSCREEN);
|
|
sh = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
|
|
if (desktop && !q->testAttribute(Qt::WA_DontShowOnScreen)) { // desktop widget
|
|
popup = false; // force this flags off
|
|
data.crect.setRect(GetSystemMetrics(76 /* SM_XVIRTUALSCREEN */), GetSystemMetrics(77 /* SM_YVIRTUALSCREEN */),
|
|
GetSystemMetrics(78 /* SM_CXVIRTUALSCREEN */), GetSystemMetrics(79 /* SM_CYVIRTUALSCREEN */));
|
|
}
|
|
|
|
parentw = q->parentWidget() ? q->parentWidget()->effectiveWinId() : 0;
|
|
|
|
QString title;
|
|
int style = WS_CHILD;
|
|
int exsty = 0;
|
|
|
|
if (window) {
|
|
style = GetWindowLong(window, GWL_STYLE);
|
|
if (!style)
|
|
qErrnoWarning("QWidget::create: GetWindowLong failed");
|
|
topLevel = false; // #### needed for some IE plugins??
|
|
} else if (popup || (type == Qt::ToolTip) || (type == Qt::SplashScreen)) {
|
|
style = WS_POPUP;
|
|
} else if (topLevel && !desktop) {
|
|
if (flags & Qt::FramelessWindowHint)
|
|
style = WS_POPUP; // no border
|
|
else if (flags & Qt::WindowTitleHint)
|
|
style = WS_OVERLAPPED;
|
|
else
|
|
style = 0;
|
|
}
|
|
if (!desktop) {
|
|
// if (!testAttribute(Qt::WA_PaintUnclipped))
|
|
// ### Commented out for now as it causes some problems, but
|
|
// this should be correct anyway, so dig some more into this
|
|
#ifndef Q_FLATTEN_EXPOSE
|
|
style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN ;
|
|
#endif
|
|
if (topLevel) {
|
|
if ((type == Qt::Window || dialog || tool)) {
|
|
if (!(flags & Qt::FramelessWindowHint)) {
|
|
style |= WS_POPUP;
|
|
if (!(flags & Qt::MSWindowsFixedSizeDialogHint))
|
|
style |= WS_THICKFRAME;
|
|
else
|
|
style |= WS_DLGFRAME;
|
|
}
|
|
if (flags & Qt::WindowTitleHint)
|
|
style |= WS_CAPTION;
|
|
if (flags & Qt::WindowSystemMenuHint)
|
|
style |= WS_SYSMENU;
|
|
if (flags & Qt::WindowMinimizeButtonHint)
|
|
style |= WS_MINIMIZEBOX;
|
|
if (shouldShowMaximizeButton())
|
|
style |= WS_MAXIMIZEBOX;
|
|
if (tool)
|
|
exsty |= WS_EX_TOOLWINDOW;
|
|
if (flags & Qt::WindowContextHelpButtonHint)
|
|
exsty |= WS_EX_CONTEXTHELP;
|
|
} else {
|
|
exsty |= WS_EX_TOOLWINDOW;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flags & Qt::WindowTitleHint) {
|
|
title = q->isWindow() ? qAppName() : q->objectName();
|
|
}
|
|
|
|
// The Qt::WA_WState_Created flag is checked by translateConfigEvent() in
|
|
// qapplication_win.cpp. We switch it off temporarily to avoid move
|
|
// and resize events during creationt
|
|
q->setAttribute(Qt::WA_WState_Created, false);
|
|
|
|
if (window) { // override the old window
|
|
if (destroyOldWindow)
|
|
destroyw = data.winid;
|
|
id = window;
|
|
setWinId(window);
|
|
LONG res = SetWindowLong(window, GWL_STYLE, style);
|
|
if (!res)
|
|
qErrnoWarning("QWidget::create: Failed to set window style");
|
|
#ifdef _WIN64
|
|
res = SetWindowLongPtr( window, GWLP_WNDPROC, (LONG_PTR)QtWndProc );
|
|
#else
|
|
res = SetWindowLong( window, GWL_WNDPROC, (LONG)QtWndProc );
|
|
#endif
|
|
if (!res)
|
|
qErrnoWarning("QWidget::create: Failed to set window procedure");
|
|
} else if (desktop) { // desktop widget
|
|
id = GetDesktopWindow();
|
|
// QWidget *otherDesktop = QWidget::find(id); // is there another desktop?
|
|
// if (otherDesktop && otherDesktop->testWFlags(Qt::WPaintDesktop)) {
|
|
// otherDesktop->d_func()->setWinId(0); // remove id from widget mapper
|
|
// d->setWinId(id); // make sure otherDesktop is
|
|
// otherDesktop->d_func()->setWinId(id); // found first
|
|
// } else {
|
|
setWinId(id);
|
|
// }
|
|
} else if (topLevel) { // create top-level widget
|
|
if (popup)
|
|
parentw = 0;
|
|
|
|
const bool wasMoved = q->testAttribute(Qt::WA_Moved);
|
|
int x = wasMoved ? data.crect.left() : CW_USEDEFAULT;
|
|
int y = wasMoved ? data.crect.top() : CW_USEDEFAULT;
|
|
int w = CW_USEDEFAULT;
|
|
int h = CW_USEDEFAULT;
|
|
|
|
// Adjust for framestrut when needed
|
|
RECT rect = {0,0,0,0};
|
|
bool isVisibleOnScreen = !q->testAttribute(Qt::WA_DontShowOnScreen);
|
|
if (isVisibleOnScreen && AdjustWindowRectEx(&rect, style & ~WS_OVERLAPPED, FALSE, exsty)) {
|
|
QTLWExtra *td = maybeTopData();
|
|
if (wasMoved && (td && !td->posFromMove)) {
|
|
x = data.crect.x() + rect.left;
|
|
y = data.crect.y() + rect.top;
|
|
}
|
|
|
|
if (q->testAttribute(Qt::WA_Resized)) {
|
|
w = data.crect.width() + (rect.right - rect.left);
|
|
h = data.crect.height() + (rect.bottom - rect.top);
|
|
}
|
|
}
|
|
//update position & initial size of POPUP window
|
|
if (isVisibleOnScreen && topLevel && initializeWindow && (style & WS_POPUP)) {
|
|
if (!q->testAttribute(Qt::WA_Resized)) {
|
|
w = sw/2;
|
|
h = 4*sh/10;
|
|
if (extra) {
|
|
int dx = rect.right - rect.left;
|
|
int dy = rect.bottom - rect.top;
|
|
w = qMin(w, extra->maxw + dx);
|
|
h = qMin(h, extra->maxh + dy);
|
|
w = qMax(w, extra->minw + dx);
|
|
h = qMax(h, extra->minh + dy);
|
|
}
|
|
}
|
|
if (!wasMoved) {
|
|
x = sw/2 - w/2;
|
|
y = sh/2 - h/2;
|
|
}
|
|
}
|
|
|
|
id = CreateWindowEx(exsty, reinterpret_cast<const wchar_t *>(windowClassName.utf16()),
|
|
reinterpret_cast<const wchar_t *>(title.utf16()), style,
|
|
x, y, w, h,
|
|
parentw, NULL, appinst, NULL);
|
|
if (!id)
|
|
qErrnoWarning("QWidget::create: Failed to create window");
|
|
setWinId(id);
|
|
if ((flags & Qt::WindowStaysOnTopHint) || (type == Qt::ToolTip)) {
|
|
SetWindowPos(id, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
|
|
if (flags & Qt::WindowStaysOnBottomHint)
|
|
qWarning() << "QWidget: Incompatible window flags: the window can't be on top and on bottom at the same time";
|
|
} else if (flags & Qt::WindowStaysOnBottomHint)
|
|
SetWindowPos(id, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
|
|
winUpdateIsOpaque();
|
|
} else if (q->testAttribute(Qt::WA_NativeWindow) || paintOnScreen()) { // create child widget
|
|
id = CreateWindowEx(exsty, reinterpret_cast<const wchar_t *>(windowClassName.utf16()),
|
|
reinterpret_cast<const wchar_t *>(title.utf16()), style,
|
|
data.crect.left(), data.crect.top(), data.crect.width(), data.crect.height(),
|
|
parentw, NULL, appinst, NULL);
|
|
if (!id)
|
|
qErrnoWarning("QWidget::create: Failed to create window");
|
|
SetWindowPos(id, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
|
setWinId(id);
|
|
}
|
|
|
|
if (desktop) {
|
|
q->setAttribute(Qt::WA_WState_Visible);
|
|
} else if (topLevel && !q->testAttribute(Qt::WA_DontShowOnScreen)) {
|
|
RECT cr;
|
|
GetClientRect(id, &cr);
|
|
// one cannot trust cr.left and cr.top, use a correction POINT instead
|
|
POINT pt;
|
|
pt.x = 0;
|
|
pt.y = 0;
|
|
ClientToScreen(id, &pt);
|
|
|
|
if (data.crect.width() == 0 || data.crect.height() == 0) {
|
|
data.crect = QRect(pt.x, pt.y, data.crect.width(), data.crect.height());
|
|
} else {
|
|
data.crect = QRect(QPoint(pt.x, pt.y),
|
|
QPoint(pt.x + cr.right - 1, pt.y + cr.bottom - 1));
|
|
}
|
|
|
|
if (data.fstrut_dirty) {
|
|
// be nice to activeqt
|
|
updateFrameStrut();
|
|
}
|
|
}
|
|
|
|
if (topLevel) {
|
|
if (data.window_flags & Qt::CustomizeWindowHint
|
|
&& data.window_flags & Qt::WindowTitleHint) {
|
|
HMENU systemMenu = GetSystemMenu((HWND)q->internalWinId(), FALSE);
|
|
if (data.window_flags & Qt::WindowCloseButtonHint)
|
|
EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_ENABLED);
|
|
else
|
|
EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_GRAYED);
|
|
}
|
|
}
|
|
|
|
q->setAttribute(Qt::WA_WState_Created); // accept move/resize events
|
|
hd = 0; // no display context
|
|
|
|
if (q->testAttribute(Qt::WA_AcceptTouchEvents))
|
|
registerTouchWindow();
|
|
|
|
if (window) { // got window from outside
|
|
if (IsWindowVisible(window))
|
|
q->setAttribute(Qt::WA_WState_Visible);
|
|
else
|
|
q->setAttribute(Qt::WA_WState_Visible, false);
|
|
}
|
|
|
|
if (extra && !extra->mask.isEmpty())
|
|
setMask_sys(extra->mask);
|
|
|
|
#if defined(QT_NON_COMMERCIAL)
|
|
QT_NC_WIDGET_CREATE
|
|
#endif
|
|
|
|
if (q->hasFocus() && q->testAttribute(Qt::WA_InputMethodEnabled))
|
|
q->inputContext()->setFocusWidget(q);
|
|
|
|
if (destroyw) {
|
|
DestroyWindow(destroyw);
|
|
}
|
|
|
|
#ifndef QT_NO_TABLETEVENT
|
|
if (q != qt_tablet_widget && QWidgetPrivate::mapper)
|
|
qt_tablet_init();
|
|
#endif // QT_NO_TABLETEVENT
|
|
|
|
if (q->testAttribute(Qt::WA_DropSiteRegistered))
|
|
registerDropSite(true);
|
|
|
|
if (maybeTopData() && maybeTopData()->opacity != 255)
|
|
q->setWindowOpacity(maybeTopData()->opacity/255.);
|
|
|
|
if (topLevel && (data.crect.width() == 0 || data.crect.height() == 0)) {
|
|
q->setAttribute(Qt::WA_OutsideWSRange, true);
|
|
}
|
|
|
|
if (!topLevel && q->testAttribute(Qt::WA_NativeWindow) && q->testAttribute(Qt::WA_Mapped)) {
|
|
Q_ASSERT(q->internalWinId());
|
|
ShowWindow(q->internalWinId(), SW_SHOW);
|
|
}
|
|
}
|
|
|
|
#endif //Q_WS_WINCE
|
|
|
|
|
|
void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
|
|
{
|
|
Q_D(QWidget);
|
|
d->aboutToDestroy();
|
|
if (!isWindow() && parentWidget())
|
|
parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
|
|
d->deactivateWidgetCleanup();
|
|
if (testAttribute(Qt::WA_WState_Created)) {
|
|
setAttribute(Qt::WA_WState_Created, false);
|
|
for(int i = 0; i < d->children.size(); ++i) { // destroy all widget children
|
|
register QObject *obj = d->children.at(i);
|
|
if (obj->isWidgetType())
|
|
((QWidget*)obj)->destroy(destroySubWindows,
|
|
destroySubWindows);
|
|
}
|
|
if (mouseGrb == this)
|
|
releaseMouse();
|
|
if (keyboardGrb == this)
|
|
releaseKeyboard();
|
|
if (testAttribute(Qt::WA_ShowModal)) // just be sure we leave modal
|
|
QApplicationPrivate::leaveModal(this);
|
|
else if ((windowType() == Qt::Popup))
|
|
qApp->d_func()->closePopup(this);
|
|
if (destroyWindow && !(windowType() == Qt::Desktop) && internalWinId()) {
|
|
DestroyWindow(internalWinId());
|
|
}
|
|
#ifdef Q_WS_WINCE
|
|
if (destroyWindow && (windowType() == Qt::Desktop) && !GetDesktopWindow()) {
|
|
DestroyWindow(internalWinId());
|
|
}
|
|
|
|
#endif
|
|
QT_TRY {
|
|
d->setWinId(0);
|
|
} QT_CATCH (const std::bad_alloc &) {
|
|
// swallow - destructors must not throw
|
|
}
|
|
}
|
|
}
|
|
|
|
void QWidgetPrivate::reparentChildren()
|
|
{
|
|
Q_Q(QWidget);
|
|
QObjectList chlist = q->children();
|
|
for(int i = 0; i < chlist.size(); ++i) { // reparent children
|
|
QObject *obj = chlist.at(i);
|
|
if (obj->isWidgetType()) {
|
|
QWidget *w = (QWidget *)obj;
|
|
if ((w->windowType() == Qt::Popup)) {
|
|
;
|
|
} else if (w->isWindow()) {
|
|
bool showIt = w->isVisible();
|
|
QPoint old_pos = w->pos();
|
|
w->setParent(q, w->windowFlags());
|
|
w->move(old_pos);
|
|
if (showIt)
|
|
w->show();
|
|
} else {
|
|
w->d_func()->invalidateBuffer(w->rect());
|
|
SetParent(w->effectiveWinId(), q->effectiveWinId());
|
|
w->d_func()->reparentChildren();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
|
|
{
|
|
Q_Q(QWidget);
|
|
bool wasCreated = q->testAttribute(Qt::WA_WState_Created);
|
|
if (q->isVisible() && q->parentWidget() && parent != q->parentWidget())
|
|
q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(q->geometry()));
|
|
|
|
WId old_winid = data.winid;
|
|
// hide and reparent our own window away. Otherwise we might get
|
|
// destroyed when emitting the child remove event below. See QWorkspace.
|
|
if (q->isVisible() && data.winid) {
|
|
ShowWindow(data.winid, SW_HIDE);
|
|
SetParent(data.winid, 0);
|
|
}
|
|
bool dropSiteWasRegistered = false;
|
|
if (q->testAttribute(Qt::WA_DropSiteRegistered)) {
|
|
dropSiteWasRegistered = true;
|
|
q->setAttribute(Qt::WA_DropSiteRegistered, false); // ole dnd unregister (we will register again below)
|
|
}
|
|
|
|
if ((q->windowType() == Qt::Desktop))
|
|
old_winid = 0;
|
|
setWinId(0);
|
|
|
|
QObjectPrivate::setParent_helper(parent);
|
|
bool explicitlyHidden = q->testAttribute(Qt::WA_WState_Hidden) && q->testAttribute(Qt::WA_WState_ExplicitShowHide);
|
|
|
|
data.window_flags = f;
|
|
data.fstrut_dirty = true;
|
|
q->setAttribute(Qt::WA_WState_Created, false);
|
|
q->setAttribute(Qt::WA_WState_Visible, false);
|
|
q->setAttribute(Qt::WA_WState_Hidden, false);
|
|
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)
|
|
if (wasCreated || (!q->isWindow() && parent->testAttribute(Qt::WA_WState_Created)))
|
|
createWinId();
|
|
if (q->isWindow() || (!parent || parent->isVisible()) || explicitlyHidden)
|
|
q->setAttribute(Qt::WA_WState_Hidden);
|
|
q->setAttribute(Qt::WA_WState_ExplicitShowHide, explicitlyHidden);
|
|
|
|
if (wasCreated) {
|
|
reparentChildren();
|
|
}
|
|
|
|
if (extra && !extra->mask.isEmpty()) {
|
|
QRegion r = extra->mask;
|
|
extra->mask = QRegion();
|
|
q->setMask(r);
|
|
}
|
|
if (extra && extra->topextra && !extra->topextra->caption.isEmpty()) {
|
|
setWindowIcon_sys(true);
|
|
setWindowTitle_helper(extra->topextra->caption);
|
|
}
|
|
if (old_winid)
|
|
DestroyWindow(old_winid);
|
|
|
|
if (q->testAttribute(Qt::WA_AcceptDrops) || dropSiteWasRegistered
|
|
|| (!q->isWindow() && q->parentWidget() && q->parentWidget()->testAttribute(Qt::WA_DropSiteRegistered)))
|
|
q->setAttribute(Qt::WA_DropSiteRegistered, true);
|
|
|
|
#ifdef Q_WS_WINCE
|
|
// Show borderless toplevel windows in tasklist & NavBar
|
|
if (!parent) {
|
|
QString txt = q->windowTitle().isEmpty()?qAppName():q->windowTitle();
|
|
SetWindowText(q->internalWinId(), (wchar_t*)txt.utf16());
|
|
}
|
|
#endif
|
|
invalidateBuffer(q->rect());
|
|
}
|
|
|
|
|
|
QPoint QWidget::mapToGlobal(const QPoint &pos) const
|
|
{
|
|
Q_D(const QWidget);
|
|
QWidget *parentWindow = window();
|
|
QWExtra *extra = parentWindow->d_func()->extra;
|
|
if (!isVisible() || parentWindow->isMinimized() || !testAttribute(Qt::WA_WState_Created) || !internalWinId()
|
|
|| (extra
|
|
#ifndef QT_NO_GRAPHICSVIEW
|
|
&& extra->proxyWidget
|
|
#endif //QT_NO_GRAPHICSVIEW
|
|
)) {
|
|
if (extra && extra->topextra && extra->topextra->embedded) {
|
|
QPoint pt = mapTo(parentWindow, pos);
|
|
POINT p = {pt.x(), pt.y()};
|
|
ClientToScreen(parentWindow->effectiveWinId(), &p);
|
|
return QPoint(p.x, p.y);
|
|
} else {
|
|
QPoint toGlobal = mapTo(parentWindow, pos) + parentWindow->pos();
|
|
// Adjust for window decorations
|
|
toGlobal += parentWindow->geometry().topLeft() - parentWindow->frameGeometry().topLeft();
|
|
return toGlobal;
|
|
}
|
|
}
|
|
POINT p;
|
|
QPoint tmp = d->mapToWS(pos);
|
|
p.x = tmp.x();
|
|
p.y = tmp.y();
|
|
ClientToScreen(internalWinId(), &p);
|
|
return QPoint(p.x, p.y);
|
|
}
|
|
|
|
QPoint QWidget::mapFromGlobal(const QPoint &pos) const
|
|
{
|
|
Q_D(const QWidget);
|
|
QWidget *parentWindow = window();
|
|
QWExtra *extra = parentWindow->d_func()->extra;
|
|
if (!isVisible() || parentWindow->isMinimized() || !testAttribute(Qt::WA_WState_Created) || !internalWinId()
|
|
|| (extra
|
|
#ifndef QT_NO_GRAPHICSVIEW
|
|
&& extra->proxyWidget
|
|
#endif //QT_NO_GRAPHICSVIEW
|
|
)) {
|
|
if (extra && extra->topextra && extra->topextra->embedded) {
|
|
POINT p = {pos.x(), pos.y()};
|
|
ScreenToClient(parentWindow->effectiveWinId(), &p);
|
|
return mapFrom(parentWindow, QPoint(p.x, p.y));
|
|
} else {
|
|
QPoint fromGlobal = mapFrom(parentWindow, pos - parentWindow->pos());
|
|
// Adjust for window decorations
|
|
fromGlobal -= parentWindow->geometry().topLeft() - parentWindow->frameGeometry().topLeft();
|
|
return fromGlobal;
|
|
}
|
|
}
|
|
POINT p;
|
|
p.x = pos.x();
|
|
p.y = pos.y();
|
|
ScreenToClient(internalWinId(), &p);
|
|
return d->mapFromWS(QPoint(p.x, p.y));
|
|
}
|
|
|
|
void QWidgetPrivate::updateSystemBackground() {}
|
|
|
|
#ifndef QT_NO_CURSOR
|
|
void QWidgetPrivate::setCursor_sys(const QCursor &cursor)
|
|
{
|
|
Q_UNUSED(cursor);
|
|
Q_Q(QWidget);
|
|
qt_win_set_cursor(q, false);
|
|
}
|
|
|
|
void QWidgetPrivate::unsetCursor_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
qt_win_set_cursor(q, false);
|
|
}
|
|
#endif
|
|
|
|
void QWidgetPrivate::setWindowTitle_sys(const QString &caption)
|
|
{
|
|
Q_Q(QWidget);
|
|
if (!q->isWindow())
|
|
return;
|
|
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
SetWindowText(q->internalWinId(), (wchar_t*)caption.utf16());
|
|
}
|
|
|
|
HICON qt_createIcon(QIcon icon, int xSize, int ySize, QPixmap **cache)
|
|
{
|
|
HICON result = 0;
|
|
if (!icon.isNull()) { // valid icon
|
|
QSize size = icon.actualSize(QSize(xSize, ySize));
|
|
QPixmap pm = icon.pixmap(size);
|
|
if (pm.isNull())
|
|
return 0;
|
|
|
|
result = pm.toWinHICON();
|
|
|
|
if (cache) {
|
|
delete *cache;
|
|
*cache = new QPixmap(pm);;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
|
|
{
|
|
Q_Q(QWidget);
|
|
if (!q->testAttribute(Qt::WA_WState_Created) || !q->isWindow())
|
|
return;
|
|
QTLWExtra* x = topData();
|
|
if (x->iconPixmap && !forceReset)
|
|
// already been set
|
|
return;
|
|
|
|
if (x->winIconBig) {
|
|
DestroyIcon(x->winIconBig);
|
|
x->winIconBig = 0;
|
|
}
|
|
if (x->winIconSmall) {
|
|
DestroyIcon(x->winIconSmall);
|
|
x->winIconSmall = 0;
|
|
}
|
|
|
|
x->winIconSmall = qt_createIcon(q->windowIcon(),
|
|
GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
|
|
&(x->iconPixmap));
|
|
x->winIconBig = qt_createIcon(q->windowIcon(),
|
|
GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON),
|
|
&(x->iconPixmap));
|
|
if (x->winIconBig) {
|
|
SendMessage(q->internalWinId(), WM_SETICON, 0 /* ICON_SMALL */, (LPARAM)x->winIconSmall);
|
|
SendMessage(q->internalWinId(), WM_SETICON, 1 /* ICON_BIG */, (LPARAM)x->winIconBig);
|
|
} else {
|
|
SendMessage(q->internalWinId(), WM_SETICON, 0 /* ICON_SMALL */, (LPARAM)x->winIconSmall);
|
|
SendMessage(q->internalWinId(), WM_SETICON, 1 /* ICON_BIG */, (LPARAM)x->winIconSmall);
|
|
}
|
|
}
|
|
|
|
|
|
void QWidgetPrivate::setWindowIconText_sys(const QString &iconText)
|
|
{
|
|
Q_UNUSED(iconText);
|
|
}
|
|
|
|
|
|
QCursor *qt_grab_cursor()
|
|
{
|
|
return mouseGrbCur;
|
|
}
|
|
|
|
// The procedure does nothing, but is required for mousegrabbing to work
|
|
#ifndef Q_WS_WINCE
|
|
LRESULT QT_WIN_CALLBACK qJournalRecordProc(int nCode, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return CallNextHookEx(journalRec, nCode, wParam, lParam);
|
|
}
|
|
#endif //Q_WS_WINCE
|
|
|
|
/* Works only as long as pointer is inside the application's window,
|
|
which is good enough for QDockWidget.
|
|
|
|
Doesn't call SetWindowsHookEx() - this function causes a system-wide
|
|
freeze if any other app on the system installs a hook and fails to
|
|
process events. */
|
|
void QWidgetPrivate::grabMouseWhileInWindow()
|
|
{
|
|
Q_Q(QWidget);
|
|
if (!qt_nograb()) {
|
|
if (mouseGrb)
|
|
mouseGrb->releaseMouse();
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
SetCapture(q->effectiveWinId());
|
|
mouseGrb = q;
|
|
#ifndef QT_NO_CURSOR
|
|
mouseGrbCur = new QCursor(mouseGrb->cursor());
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifndef Q_WS_WINCE
|
|
void QWidget::grabMouse()
|
|
{
|
|
if (!qt_nograb()) {
|
|
if (mouseGrb)
|
|
mouseGrb->releaseMouse();
|
|
journalRec = SetWindowsHookEx(WH_JOURNALRECORD, (HOOKPROC)qJournalRecordProc, GetModuleHandle(0), 0);
|
|
Q_ASSERT(testAttribute(Qt::WA_WState_Created));
|
|
SetCapture(effectiveWinId());
|
|
mouseGrb = this;
|
|
#ifndef QT_NO_CURSOR
|
|
mouseGrbCur = new QCursor(mouseGrb->cursor());
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifndef QT_NO_CURSOR
|
|
void QWidget::grabMouse(const QCursor &cursor)
|
|
{
|
|
if (!qt_nograb()) {
|
|
if (mouseGrb)
|
|
mouseGrb->releaseMouse();
|
|
journalRec = SetWindowsHookEx(WH_JOURNALRECORD, (HOOKPROC)qJournalRecordProc, GetModuleHandle(0), 0);
|
|
Q_ASSERT(testAttribute(Qt::WA_WState_Created));
|
|
SetCapture(effectiveWinId());
|
|
mouseGrbCur = new QCursor(cursor);
|
|
SetCursor(mouseGrbCur->handle());
|
|
mouseGrb = this;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void QWidget::releaseMouse()
|
|
{
|
|
if (!qt_nograb() && mouseGrb == this) {
|
|
ReleaseCapture();
|
|
if (journalRec) {
|
|
UnhookWindowsHookEx(journalRec);
|
|
journalRec = 0;
|
|
}
|
|
if (mouseGrbCur) {
|
|
delete mouseGrbCur;
|
|
mouseGrbCur = 0;
|
|
}
|
|
mouseGrb = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void QWidget::grabKeyboard()
|
|
{
|
|
if (!qt_nograb()) {
|
|
if (keyboardGrb)
|
|
keyboardGrb->releaseKeyboard();
|
|
keyboardGrb = this;
|
|
}
|
|
}
|
|
|
|
void QWidget::releaseKeyboard()
|
|
{
|
|
if (!qt_nograb() && keyboardGrb == this)
|
|
keyboardGrb = 0;
|
|
}
|
|
|
|
|
|
QWidget *QWidget::mouseGrabber()
|
|
{
|
|
return mouseGrb;
|
|
}
|
|
|
|
QWidget *QWidget::keyboardGrabber()
|
|
{
|
|
return keyboardGrb;
|
|
}
|
|
|
|
void QWidget::activateWindow()
|
|
{
|
|
window()->createWinId();
|
|
SetForegroundWindow(window()->internalWinId());
|
|
}
|
|
|
|
#ifndef Q_WS_WINCE
|
|
void QWidget::setWindowState(Qt::WindowStates newstate)
|
|
{
|
|
Q_D(QWidget);
|
|
Qt::WindowStates oldstate = windowState();
|
|
if (oldstate == newstate)
|
|
return;
|
|
|
|
int max = SW_MAXIMIZE;
|
|
int min = SW_MINIMIZE;
|
|
|
|
int normal = SW_SHOWNOACTIVATE;
|
|
if (newstate & Qt::WindowActive) {
|
|
max = SW_SHOWMAXIMIZED;
|
|
min = SW_SHOWMINIMIZED;
|
|
normal = SW_SHOWNORMAL;
|
|
}
|
|
|
|
if (isWindow()) {
|
|
createWinId();
|
|
Q_ASSERT(testAttribute(Qt::WA_WState_Created));
|
|
|
|
// Ensure the initial size is valid, since we store it as normalGeometry below.
|
|
if (!testAttribute(Qt::WA_Resized) && !isVisible())
|
|
adjustSize();
|
|
|
|
if ((oldstate & Qt::WindowMaximized) != (newstate & Qt::WindowMaximized)) {
|
|
if (newstate & Qt::WindowMaximized && !(oldstate & Qt::WindowFullScreen))
|
|
d->topData()->normalGeometry = geometry();
|
|
if (isVisible() && !(newstate & Qt::WindowMinimized)) {
|
|
ShowWindow(internalWinId(), (newstate & Qt::WindowMaximized) ? max : normal);
|
|
if (!(newstate & Qt::WindowFullScreen)) {
|
|
QRect r = d->topData()->normalGeometry;
|
|
if (!(newstate & Qt::WindowMaximized) && r.width() >= 0) {
|
|
if (pos() != r.topLeft() || size() !=r.size()) {
|
|
d->topData()->normalGeometry = QRect(0,0,-1,-1);
|
|
setGeometry(r);
|
|
}
|
|
}
|
|
} else {
|
|
d->updateFrameStrut();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((oldstate & Qt::WindowFullScreen) != (newstate & Qt::WindowFullScreen)) {
|
|
if (newstate & Qt::WindowFullScreen) {
|
|
if (d->topData()->normalGeometry.width() < 0 && !(oldstate & Qt::WindowMaximized))
|
|
d->topData()->normalGeometry = geometry();
|
|
d->topData()->savedFlags = Qt::WindowFlags(GetWindowLong(internalWinId(), GWL_STYLE));
|
|
#ifndef Q_FLATTEN_EXPOSE
|
|
UINT style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_POPUP;
|
|
#else
|
|
UINT style = WS_POPUP;
|
|
#endif
|
|
if (ulong(d->topData()->savedFlags) & WS_SYSMENU)
|
|
style |= WS_SYSMENU;
|
|
if (isVisible())
|
|
style |= WS_VISIBLE;
|
|
SetWindowLong(internalWinId(), GWL_STYLE, style);
|
|
QRect r = QApplication::desktop()->screenGeometry(this);
|
|
UINT swpf = SWP_FRAMECHANGED;
|
|
if (newstate & Qt::WindowActive)
|
|
swpf |= SWP_NOACTIVATE;
|
|
|
|
SetWindowPos(internalWinId(), HWND_TOP, r.left(), r.top(), r.width(), r.height(), swpf);
|
|
d->updateFrameStrut();
|
|
} else {
|
|
UINT style = d->topData()->savedFlags;
|
|
if (isVisible())
|
|
style |= WS_VISIBLE;
|
|
SetWindowLong(internalWinId(), GWL_STYLE, style);
|
|
|
|
UINT swpf = SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE;
|
|
if (newstate & Qt::WindowActive)
|
|
swpf |= SWP_NOACTIVATE;
|
|
SetWindowPos(internalWinId(), 0, 0, 0, 0, 0, swpf);
|
|
d->updateFrameStrut();
|
|
|
|
// preserve maximized state
|
|
if (isVisible())
|
|
ShowWindow(internalWinId(), (newstate & Qt::WindowMaximized) ? max : normal);
|
|
|
|
if (!(newstate & Qt::WindowMaximized)) {
|
|
QRect r = d->topData()->normalGeometry;
|
|
d->topData()->normalGeometry = QRect(0,0,-1,-1);
|
|
if (r.isValid())
|
|
setGeometry(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((oldstate & Qt::WindowMinimized) != (newstate & Qt::WindowMinimized)) {
|
|
if (isVisible())
|
|
ShowWindow(internalWinId(), (newstate & Qt::WindowMinimized) ? min :
|
|
(newstate & Qt::WindowMaximized) ? max : normal);
|
|
}
|
|
}
|
|
data->window_state = newstate;
|
|
QWindowStateChangeEvent e(oldstate);
|
|
QApplication::sendEvent(this, &e);
|
|
}
|
|
#endif //Q_WS_WINCE
|
|
|
|
|
|
/*
|
|
\internal
|
|
Platform-specific part of QWidget::hide().
|
|
*/
|
|
|
|
void QWidgetPrivate::hide_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
deactivateWidgetCleanup();
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
#ifdef Q_WS_WINCE
|
|
if (!qt_wince_is_mobile() && q->isFullScreen()) {
|
|
HWND handle = FindWindow(L"HHTaskBar", L"");
|
|
if (handle) {
|
|
ShowWindow(handle, 1);
|
|
EnableWindow(handle, true);
|
|
}
|
|
}
|
|
#endif
|
|
if (q->windowFlags() != Qt::Desktop) {
|
|
if ((q->windowFlags() & Qt::Popup) && q->internalWinId())
|
|
ShowWindow(q->internalWinId(), SW_HIDE);
|
|
else if (q->internalWinId())
|
|
SetWindowPos(q->internalWinId(),0, 0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER);
|
|
}
|
|
if (q->isWindow()) {
|
|
if (QWidgetBackingStore *bs = maybeBackingStore())
|
|
bs->releaseBuffer();
|
|
} else {
|
|
invalidateBuffer(q->rect());
|
|
}
|
|
q->setAttribute(Qt::WA_Mapped, false);
|
|
}
|
|
|
|
|
|
/*
|
|
\internal
|
|
Platform-specific part of QWidget::show().
|
|
*/
|
|
#ifndef Q_WS_WINCE
|
|
void QWidgetPrivate::show_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
#if defined(QT_NON_COMMERCIAL)
|
|
QT_NC_SHOW_WINDOW
|
|
#endif
|
|
if (q->testAttribute(Qt::WA_OutsideWSRange))
|
|
return;
|
|
q->setAttribute(Qt::WA_Mapped);
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
|
|
if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
|
|
invalidateBuffer(q->rect());
|
|
return;
|
|
}
|
|
|
|
if (data.window_flags & Qt::Window) {
|
|
QTLWExtra *extra = topData();
|
|
if (!extra->hotkeyRegistered) {
|
|
// Try to set the hotkey using information from STARTUPINFO
|
|
STARTUPINFO startupInfo;
|
|
GetStartupInfo(&startupInfo);
|
|
// If STARTF_USEHOTKEY is set, hStdInput is the virtual keycode
|
|
if (startupInfo.dwFlags & 0x00000200) {
|
|
WPARAM hotKey = (WPARAM)startupInfo.hStdInput;
|
|
SendMessage(data.winid, WM_SETHOTKEY, hotKey, 0);
|
|
}
|
|
extra->hotkeyRegistered = 1;
|
|
}
|
|
}
|
|
|
|
int sm = SW_SHOWNORMAL;
|
|
bool fakedMaximize = false;
|
|
if (q->isWindow()) {
|
|
if (q->isMinimized()) {
|
|
sm = SW_SHOWMINIMIZED;
|
|
if (!IsWindowVisible(q->internalWinId()))
|
|
sm = SW_SHOWMINNOACTIVE;
|
|
} else if (q->isMaximized()) {
|
|
sm = SW_SHOWMAXIMIZED;
|
|
// Windows will not behave correctly when we try to maximize a window which does not
|
|
// have minimize nor maximize buttons in the window frame. Windows would then ignore
|
|
// non-available geometry, and rather maximize the widget to the full screen, minus the
|
|
// window frame (caption). So, we do a trick here, by adding a maximize button before
|
|
// maximizing the widget, and then remove the maximize button afterwards.
|
|
Qt::WindowFlags &flags = data.window_flags;
|
|
if (flags & Qt::WindowTitleHint &&
|
|
!(flags & (Qt::WindowMinMaxButtonsHint | Qt::FramelessWindowHint))) {
|
|
fakedMaximize = TRUE;
|
|
int style = GetWindowLong(q->internalWinId(), GWL_STYLE);
|
|
SetWindowLong(q->internalWinId(), GWL_STYLE, style | WS_MAXIMIZEBOX);
|
|
}
|
|
}
|
|
}
|
|
if (q->testAttribute(Qt::WA_ShowWithoutActivating)
|
|
|| (q->windowType() == Qt::Popup)
|
|
|| (q->windowType() == Qt::ToolTip)
|
|
|| (q->windowType() == Qt::Tool)) {
|
|
sm = SW_SHOWNOACTIVATE;
|
|
}
|
|
|
|
|
|
if (q->internalWinId())
|
|
ShowWindow(q->internalWinId(), sm);
|
|
|
|
if (fakedMaximize) {
|
|
int style = GetWindowLong(q->internalWinId(), GWL_STYLE);
|
|
SetWindowLong(q->internalWinId(), GWL_STYLE, style & ~WS_MAXIMIZEBOX);
|
|
SetWindowPos(q->internalWinId(), 0, 0, 0, 0, 0,
|
|
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER
|
|
| SWP_FRAMECHANGED);
|
|
}
|
|
|
|
if (q->internalWinId()) {
|
|
if (IsIconic(q->internalWinId()))
|
|
data.window_state |= Qt::WindowMinimized;
|
|
if (IsZoomed(q->internalWinId()))
|
|
data.window_state |= Qt::WindowMaximized;
|
|
// This is to resolve the problem where popups are opened from the
|
|
// system tray and not being implicitly activated
|
|
if (q->windowType() == Qt::Popup &&
|
|
!q->parentWidget() && !qApp->activeWindow())
|
|
q->activateWindow();
|
|
}
|
|
|
|
winSetupGestures();
|
|
|
|
invalidateBuffer(q->rect());
|
|
}
|
|
#endif //Q_WS_WINCE
|
|
|
|
void QWidgetPrivate::setFocus_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
if (q->testAttribute(Qt::WA_WState_Created) && q->window()->windowType() != Qt::Popup)
|
|
SetFocus(q->effectiveWinId());
|
|
}
|
|
|
|
void QWidgetPrivate::raise_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
if (q->internalWinId())
|
|
SetWindowPos(q->internalWinId(), HWND_TOP, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
|
|
}
|
|
|
|
void QWidgetPrivate::lower_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
if (q->internalWinId())
|
|
SetWindowPos(q->internalWinId(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
|
|
invalidateBuffer(q->rect());
|
|
}
|
|
|
|
void QWidgetPrivate::stackUnder_sys(QWidget* w)
|
|
{
|
|
Q_Q(QWidget);
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
if (q->internalWinId() && w->internalWinId())
|
|
SetWindowPos(q->internalWinId(), w->internalWinId() , 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
|
invalidateBuffer(q->rect());
|
|
}
|
|
|
|
|
|
/*
|
|
Helper function for non-toplevel widgets. Helps to map Qt's 32bit
|
|
coordinate system to Windpws's 16bit coordinate system.
|
|
|
|
This code is duplicated from the X11 code, so any changes there
|
|
should also (most likely) be reflected here.
|
|
|
|
(In all comments below: s/X/Windows/g)
|
|
*/
|
|
|
|
void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &)
|
|
{
|
|
Q_Q(QWidget);
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
|
|
/*
|
|
There are up to four different coordinate systems here:
|
|
Qt coordinate system for this widget.
|
|
X coordinate system for this widget (relative to wrect).
|
|
Qt coordinate system for parent
|
|
X coordinate system for parent (relative to parent's wrect).
|
|
*/
|
|
QRect validRange(-XCOORD_MAX,-XCOORD_MAX, 2*XCOORD_MAX, 2*XCOORD_MAX);
|
|
QRect wrectRange(-WRECT_MAX,-WRECT_MAX, 2*WRECT_MAX, 2*WRECT_MAX);
|
|
QRect wrect;
|
|
//xrect is the X geometry of my X widget. (starts out in parent's Qt coord sys, and ends up in parent's X coord sys)
|
|
QRect xrect = data.crect;
|
|
|
|
const QWidget *const parent = q->parentWidget();
|
|
QRect parentWRect = parent->data->wrect;
|
|
|
|
if (parentWRect.isValid()) {
|
|
// parent is clipped, and we have to clip to the same limit as parent
|
|
if (!parentWRect.contains(xrect)) {
|
|
xrect &= parentWRect;
|
|
wrect = xrect;
|
|
//translate from parent's to my Qt coord sys
|
|
wrect.translate(-data.crect.topLeft());
|
|
}
|
|
//translate from parent's Qt coords to parent's X coords
|
|
xrect.translate(-parentWRect.topLeft());
|
|
|
|
} else {
|
|
// parent is not clipped, we may or may not have to clip
|
|
|
|
if (data.wrect.isValid() && QRect(QPoint(),data.crect.size()).contains(data.wrect)) {
|
|
// This is where the main optimization is: we are already
|
|
// clipped, and if our clip is still valid, we can just
|
|
// move our window, and do not need to move or clip
|
|
// children
|
|
|
|
QRect vrect = xrect & parent->rect();
|
|
vrect.translate(-data.crect.topLeft()); //the part of me that's visible through parent, in my Qt coords
|
|
if (data.wrect.contains(vrect)) {
|
|
xrect = data.wrect;
|
|
xrect.translate(data.crect.topLeft());
|
|
if (q->internalWinId())
|
|
MoveWindow(q->internalWinId(), xrect.x(), xrect.y(), xrect.width(), xrect.height(), true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!validRange.contains(xrect)) {
|
|
// we are too big, and must clip
|
|
xrect &=wrectRange;
|
|
wrect = xrect;
|
|
wrect.translate(-data.crect.topLeft());
|
|
//parent's X coord system is equal to parent's Qt coord
|
|
//sys, so we don't need to map xrect.
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// unmap if we are outside the valid window system coord system
|
|
bool outsideRange = !xrect.isValid();
|
|
bool mapWindow = false;
|
|
if (q->testAttribute(Qt::WA_OutsideWSRange) != outsideRange) {
|
|
q->setAttribute(Qt::WA_OutsideWSRange, outsideRange);
|
|
if (outsideRange) {
|
|
if (q->internalWinId())
|
|
ShowWindow(q->internalWinId(), SW_HIDE);
|
|
q->setAttribute(Qt::WA_Mapped, false);
|
|
} else if (!q->isHidden()) {
|
|
mapWindow = true;
|
|
}
|
|
}
|
|
|
|
if (outsideRange)
|
|
return;
|
|
|
|
bool jump = (data.wrect != wrect);
|
|
data.wrect = wrect;
|
|
|
|
// and now recursively for all children...
|
|
for (int i = 0; i < children.size(); ++i) {
|
|
QObject *object = children.at(i);
|
|
if (object->isWidgetType()) {
|
|
QWidget *w = static_cast<QWidget *>(object);
|
|
if (!w->isWindow() && w->testAttribute(Qt::WA_WState_Created))
|
|
w->d_func()->setWSGeometry();
|
|
}
|
|
}
|
|
|
|
// move ourselves to the new position and map (if necessary) after
|
|
// the movement. Rationale: moving unmapped windows is much faster
|
|
// than moving mapped windows
|
|
if (q->internalWinId()) {
|
|
if (!parent->internalWinId())
|
|
xrect.translate(parent->mapTo(q->nativeParentWidget(), QPoint(0, 0)));
|
|
MoveWindow(q->internalWinId(), xrect.x(), xrect.y(), xrect.width(), xrect.height(), !jump);
|
|
}
|
|
if (mapWindow && !dontShow) {
|
|
q->setAttribute(Qt::WA_Mapped);
|
|
if (q->internalWinId())
|
|
ShowWindow(q->internalWinId(), SW_SHOWNOACTIVATE);
|
|
}
|
|
|
|
if (jump && q->internalWinId())
|
|
InvalidateRect(q->internalWinId(), 0, false);
|
|
|
|
}
|
|
|
|
//
|
|
// The internal qWinRequestConfig, defined in qapplication_win.cpp, stores move,
|
|
// resize and setGeometry requests for a widget that is already
|
|
// processing a config event. The purpose is to avoid recursion.
|
|
//
|
|
void qWinRequestConfig(WId, int, int, int, int, int);
|
|
|
|
void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
|
|
{
|
|
Q_Q(QWidget);
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
if (extra) { // any size restrictions?
|
|
w = qMin(w,extra->maxw);
|
|
h = qMin(h,extra->maxh);
|
|
w = qMax(w,extra->minw);
|
|
h = qMax(h,extra->minh);
|
|
}
|
|
if (q->isWindow())
|
|
topData()->normalGeometry = QRect(0, 0, -1, -1);
|
|
|
|
QSize oldSize(q->size());
|
|
QPoint oldPos(q->pos());
|
|
|
|
if (!q->isWindow())
|
|
isMove = (data.crect.topLeft() != QPoint(x, y));
|
|
bool isResize = w != oldSize.width() || h != oldSize.height();
|
|
|
|
if (!isMove && !isResize)
|
|
return;
|
|
|
|
if (isResize && !q->testAttribute(Qt::WA_StaticContents) && q->internalWinId())
|
|
ValidateRgn(q->internalWinId(), 0);
|
|
|
|
#ifdef Q_WS_WINCE
|
|
// On Windows CE we can't just fiddle around with the window state.
|
|
// Too much magic in setWindowState.
|
|
if (isResize && q->isMaximized())
|
|
q->setWindowState(q->windowState() & ~Qt::WindowMaximized);
|
|
#else
|
|
if (isResize)
|
|
data.window_state &= ~Qt::WindowMaximized;
|
|
#endif
|
|
|
|
if (data.window_state & Qt::WindowFullScreen) {
|
|
QTLWExtra *top = topData();
|
|
|
|
if (q->isWindow()) {
|
|
// We need to update these flags when we remove the full screen state
|
|
// or the frame will not be updated
|
|
UINT style = top->savedFlags;
|
|
if (q->isVisible())
|
|
style |= WS_VISIBLE;
|
|
SetWindowLong(q->internalWinId(), GWL_STYLE, style);
|
|
|
|
UINT swpf = SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE;
|
|
if (data.window_state & Qt::WindowActive)
|
|
swpf |= SWP_NOACTIVATE;
|
|
SetWindowPos(q->internalWinId(), 0, 0, 0, 0, 0, swpf);
|
|
updateFrameStrut();
|
|
}
|
|
data.window_state &= ~Qt::WindowFullScreen;
|
|
topData()->savedFlags = 0;
|
|
}
|
|
|
|
QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();
|
|
const bool inTopLevelResize = tlwExtra ? tlwExtra->inTopLevelResize : false;
|
|
const bool isTranslucentWindow = !isOpaque && ptrUpdateLayeredWindowIndirect && (data.window_flags & Qt::FramelessWindowHint)
|
|
&& GetWindowLong(q->internalWinId(), GWL_EXSTYLE) & Q_WS_EX_LAYERED;
|
|
|
|
if (q->testAttribute(Qt::WA_WState_ConfigPending)) { // processing config event
|
|
if (q->internalWinId())
|
|
qWinRequestConfig(q->internalWinId(), isMove ? 2 : 1, x, y, w, h);
|
|
} else {
|
|
if (!q->testAttribute(Qt::WA_DontShowOnScreen))
|
|
q->setAttribute(Qt::WA_WState_ConfigPending);
|
|
if (q->windowType() == Qt::Desktop) {
|
|
data.crect.setRect(x, y, w, h);
|
|
} else if (q->isWindow()) {
|
|
QRect fs(frameStrut());
|
|
if (extra) {
|
|
fs.setLeft(x - fs.left());
|
|
fs.setTop(y - fs.top());
|
|
fs.setRight((x + w - 1) + fs.right());
|
|
fs.setBottom((y + h - 1) + fs.bottom());
|
|
}
|
|
if (w == 0 || h == 0) {
|
|
q->setAttribute(Qt::WA_OutsideWSRange, true);
|
|
if (q->isVisible() && q->testAttribute(Qt::WA_Mapped))
|
|
hide_sys();
|
|
data.crect = QRect(x, y, w, h);
|
|
} else if (q->isVisible() && q->testAttribute(Qt::WA_OutsideWSRange)) {
|
|
q->setAttribute(Qt::WA_OutsideWSRange, false);
|
|
|
|
// put the window in its place and show it
|
|
MoveWindow(q->internalWinId(), fs.x(), fs.y(), fs.width(), fs.height(), true);
|
|
RECT rect;
|
|
if (!q->testAttribute(Qt::WA_DontShowOnScreen)) {
|
|
GetClientRect(q->internalWinId(), &rect);
|
|
data.crect.setRect(x, y, rect.right - rect.left, rect.bottom - rect.top);
|
|
} else {
|
|
data.crect.setRect(x, y, w, h);
|
|
}
|
|
|
|
show_sys();
|
|
} else if (!q->testAttribute(Qt::WA_DontShowOnScreen)) {
|
|
q->setAttribute(Qt::WA_OutsideWSRange, false);
|
|
#ifndef Q_WS_WINCE
|
|
// If the window is hidden and in maximized state or minimized, instead of moving the
|
|
// window, set the normal position of the window.
|
|
WINDOWPLACEMENT wndpl;
|
|
GetWindowPlacement(q->internalWinId(), &wndpl);
|
|
if ((wndpl.showCmd == SW_MAXIMIZE && !IsWindowVisible(q->internalWinId())) || wndpl.showCmd == SW_SHOWMINIMIZED) {
|
|
RECT normal = {fs.x(), fs.y(), fs.x()+fs.width(), fs.y()+fs.height()};
|
|
wndpl.rcNormalPosition = normal;
|
|
wndpl.showCmd = wndpl.showCmd == SW_SHOWMINIMIZED ? SW_SHOWMINIMIZED : SW_HIDE;
|
|
SetWindowPlacement(q->internalWinId(), &wndpl);
|
|
} else {
|
|
#else
|
|
if (data.window_state & Qt::WindowMaximized) {
|
|
qt_wince_maximize(q);
|
|
} else {
|
|
#endif
|
|
MoveWindow(q->internalWinId(), fs.x(), fs.y(), fs.width(), fs.height(), true);
|
|
}
|
|
if (!q->isVisible())
|
|
InvalidateRect(q->internalWinId(), 0, FALSE);
|
|
RECT rect;
|
|
// If the layout has heightForWidth, the MoveWindow() above can
|
|
// change the size/position, so refresh them.
|
|
|
|
if (isTranslucentWindow) {
|
|
data.crect.setRect(x, y, w, h);
|
|
} else {
|
|
GetClientRect(q->internalWinId(), &rect);
|
|
RECT rcNormalPosition ={0};
|
|
// Use (0,0) as window position for embedded ActiveQt controls.
|
|
if (!tlwExtra || !tlwExtra->embedded)
|
|
GetWindowRect(q->internalWinId(), &rcNormalPosition);
|
|
QRect fStrut(frameStrut());
|
|
data.crect.setRect(rcNormalPosition.left + fStrut.left(),
|
|
rcNormalPosition.top + fStrut.top(),
|
|
rect.right - rect.left,
|
|
rect.bottom - rect.top);
|
|
isResize = data.crect.size() != oldSize;
|
|
}
|
|
} else {
|
|
q->setAttribute(Qt::WA_OutsideWSRange, false);
|
|
data.crect.setRect(x, y, w, h);
|
|
}
|
|
} else {
|
|
QRect oldGeom(data.crect);
|
|
data.crect.setRect(x, y, w, h);
|
|
if (q->isVisible() && (!inTopLevelResize || q->internalWinId())) {
|
|
// Top-level resize optimization does not work for native child widgets;
|
|
// disable it for this particular widget.
|
|
if (inTopLevelResize)
|
|
tlwExtra->inTopLevelResize = false;
|
|
|
|
if (!isResize)
|
|
moveRect(QRect(oldPos, oldSize), x - oldPos.x(), y - oldPos.y());
|
|
else
|
|
invalidateBuffer_resizeHelper(oldPos, oldSize);
|
|
|
|
if (inTopLevelResize)
|
|
tlwExtra->inTopLevelResize = true;
|
|
}
|
|
if (q->testAttribute(Qt::WA_WState_Created))
|
|
setWSGeometry();
|
|
}
|
|
q->setAttribute(Qt::WA_WState_ConfigPending, false);
|
|
}
|
|
|
|
if (q->isWindow() && q->isVisible() && isResize && !inTopLevelResize) {
|
|
invalidateBuffer(q->rect()); //after the resize
|
|
}
|
|
|
|
// Process events immediately rather than in translateConfigEvent to
|
|
// avoid windows message process delay.
|
|
if (q->isVisible()) {
|
|
if (isMove && q->pos() != oldPos) {
|
|
QMoveEvent e(q->pos(), oldPos);
|
|
QApplication::sendEvent(q, &e);
|
|
}
|
|
if (isResize) {
|
|
static bool slowResize = qgetenv("QT_SLOW_TOPLEVEL_RESIZE").toInt();
|
|
// If we have a backing store with static contents, we have to disable the top-level
|
|
// resize optimization in order to get invalidated regions for resized widgets.
|
|
// The optimization discards all invalidateBuffer() calls since we're going to
|
|
// repaint everything anyways, but that's not the case with static contents.
|
|
const bool setTopLevelResize = !slowResize && q->isWindow() && extra && extra->topextra
|
|
&& !extra->topextra->inTopLevelResize
|
|
&& (!extra->topextra->backingStore
|
|
|| !extra->topextra->backingStore->hasStaticContents());
|
|
if (setTopLevelResize)
|
|
extra->topextra->inTopLevelResize = true;
|
|
QResizeEvent e(q->size(), oldSize);
|
|
QApplication::sendEvent(q, &e);
|
|
if (setTopLevelResize)
|
|
extra->topextra->inTopLevelResize = false;
|
|
}
|
|
} else {
|
|
if (isMove && q->pos() != oldPos)
|
|
q->setAttribute(Qt::WA_PendingMoveEvent, true);
|
|
if (isResize)
|
|
q->setAttribute(Qt::WA_PendingResizeEvent, true);
|
|
}
|
|
}
|
|
|
|
bool QWidgetPrivate::shouldShowMaximizeButton()
|
|
{
|
|
if (data.window_flags & Qt::MSWindowsFixedSizeDialogHint)
|
|
return false;
|
|
// if the user explicitly asked for the maximize button, we try to add
|
|
// it even if the window has fixed size.
|
|
if (data.window_flags & Qt::CustomizeWindowHint &&
|
|
data.window_flags & Qt::WindowMaximizeButtonHint)
|
|
return true;
|
|
if (extra) {
|
|
if ((extra->maxw && extra->maxw != QWIDGETSIZE_MAX && extra->maxw != QLAYOUTSIZE_MAX)
|
|
|| (extra->maxh && extra->maxh != QWIDGETSIZE_MAX && extra->maxh != QLAYOUTSIZE_MAX))
|
|
return false;
|
|
}
|
|
return data.window_flags & Qt::WindowMaximizeButtonHint;
|
|
}
|
|
|
|
void QWidgetPrivate::winUpdateIsOpaque()
|
|
{
|
|
#ifndef Q_WS_WINCE
|
|
Q_Q(QWidget);
|
|
|
|
if (!q->isWindow() || !q->testAttribute(Qt::WA_TranslucentBackground))
|
|
return;
|
|
|
|
if ((data.window_flags & Qt::FramelessWindowHint) == 0)
|
|
return;
|
|
|
|
if (!isOpaque && ptrUpdateLayeredWindowIndirect) {
|
|
SetWindowLong(q->internalWinId(), GWL_EXSTYLE,
|
|
GetWindowLong(q->internalWinId(), GWL_EXSTYLE) | Q_WS_EX_LAYERED);
|
|
} else {
|
|
SetWindowLong(q->internalWinId(), GWL_EXSTYLE,
|
|
GetWindowLong(q->internalWinId(), GWL_EXSTYLE) & ~Q_WS_EX_LAYERED);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void QWidgetPrivate::setConstraints_sys()
|
|
{
|
|
#ifndef Q_WS_WINCE_WM
|
|
Q_Q(QWidget);
|
|
if (q->isWindow() && q->testAttribute(Qt::WA_WState_Created)) {
|
|
int style = GetWindowLong(q->internalWinId(), GWL_STYLE);
|
|
if (shouldShowMaximizeButton())
|
|
style |= WS_MAXIMIZEBOX;
|
|
else
|
|
style &= ~WS_MAXIMIZEBOX;
|
|
SetWindowLong(q->internalWinId(), GWL_STYLE, style);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void QWidgetPrivate::scroll_sys(int dx, int dy)
|
|
{
|
|
Q_Q(QWidget);
|
|
scrollChildren(dx, dy);
|
|
|
|
if (!paintOnScreen()) {
|
|
scrollRect(q->rect(), dx, dy);
|
|
} else {
|
|
UINT flags = SW_INVALIDATE;
|
|
if (!q->testAttribute(Qt::WA_OpaquePaintEvent))
|
|
flags |= SW_ERASE;
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
ScrollWindowEx(q->internalWinId(), dx, dy, 0, 0, 0, 0, flags);
|
|
UpdateWindow(q->internalWinId());
|
|
}
|
|
}
|
|
|
|
void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &r)
|
|
{
|
|
Q_Q(QWidget);
|
|
|
|
if (!paintOnScreen()) {
|
|
scrollRect(r, dx, dy);
|
|
} else {
|
|
RECT wr;
|
|
wr.top = r.top();
|
|
wr.left = r.left();
|
|
wr.bottom = r.bottom()+1;
|
|
wr.right = r.right()+1;
|
|
|
|
UINT flags = SW_INVALIDATE;
|
|
if (!q->testAttribute(Qt::WA_OpaquePaintEvent))
|
|
flags |= SW_ERASE;
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
ScrollWindowEx(q->internalWinId(), dx, dy, &wr, &wr, 0, 0, flags);
|
|
UpdateWindow(q->internalWinId());
|
|
}
|
|
}
|
|
|
|
int QWidget::metric(PaintDeviceMetric m) const
|
|
{
|
|
Q_D(const QWidget);
|
|
int val;
|
|
if (m == PdmWidth) {
|
|
val = data->crect.width();
|
|
} else if (m == PdmHeight) {
|
|
val = data->crect.height();
|
|
} else {
|
|
HDC gdc = GetDC(0);
|
|
switch (m) {
|
|
case PdmDpiX:
|
|
case PdmPhysicalDpiX:
|
|
if (d->extra && d->extra->customDpiX)
|
|
val = d->extra->customDpiX;
|
|
else if (d->parent)
|
|
val = static_cast<QWidget *>(d->parent)->metric(m);
|
|
else
|
|
val = GetDeviceCaps(gdc, LOGPIXELSX);
|
|
break;
|
|
case PdmDpiY:
|
|
case PdmPhysicalDpiY:
|
|
if (d->extra && d->extra->customDpiY)
|
|
val = d->extra->customDpiY;
|
|
else if (d->parent)
|
|
val = static_cast<QWidget *>(d->parent)->metric(m);
|
|
else
|
|
val = GetDeviceCaps(gdc, LOGPIXELSY);
|
|
break;
|
|
case PdmWidthMM:
|
|
val = data->crect.width()
|
|
* GetDeviceCaps(gdc, HORZSIZE)
|
|
/ GetDeviceCaps(gdc, HORZRES);
|
|
break;
|
|
case PdmHeightMM:
|
|
val = data->crect.height()
|
|
* GetDeviceCaps(gdc, VERTSIZE)
|
|
/ GetDeviceCaps(gdc, VERTRES);
|
|
break;
|
|
case PdmNumColors:
|
|
if (GetDeviceCaps(gdc, RASTERCAPS) & RC_PALETTE)
|
|
val = GetDeviceCaps(gdc, SIZEPALETTE);
|
|
else {
|
|
HDC hd = d->hd ? HDC(d->hd) : gdc;
|
|
int bpp = GetDeviceCaps(hd, BITSPIXEL);
|
|
if (bpp == 32)
|
|
val = INT_MAX; // ### this is bogus, it should be 2^24 colors for 32 bit as well
|
|
else if(bpp<=8)
|
|
val = GetDeviceCaps(hd, NUMCOLORS);
|
|
else
|
|
val = 1 << (bpp * GetDeviceCaps(hd, PLANES));
|
|
}
|
|
break;
|
|
case PdmDepth:
|
|
val = GetDeviceCaps(gdc, BITSPIXEL);
|
|
break;
|
|
default:
|
|
val = 0;
|
|
qWarning("QWidget::metric: Invalid metric command");
|
|
}
|
|
ReleaseDC(0, gdc);
|
|
}
|
|
return val;
|
|
}
|
|
|
|
void QWidgetPrivate::createSysExtra()
|
|
{
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
extra->dropTarget = 0;
|
|
#endif
|
|
}
|
|
|
|
#ifndef Q_WS_WINCE
|
|
void QWidgetPrivate::deleteSysExtra()
|
|
{
|
|
}
|
|
#endif //Q_WS_WINCE
|
|
|
|
void QWidgetPrivate::createTLSysExtra()
|
|
{
|
|
extra->topextra->hotkeyRegistered = 0;
|
|
extra->topextra->savedFlags = 0;
|
|
extra->topextra->winIconBig = 0;
|
|
extra->topextra->winIconSmall = 0;
|
|
}
|
|
|
|
void QWidgetPrivate::deleteTLSysExtra()
|
|
{
|
|
if (extra->topextra->winIconSmall)
|
|
DestroyIcon(extra->topextra->winIconSmall);
|
|
if (extra->topextra->winIconBig)
|
|
DestroyIcon(extra->topextra->winIconBig);
|
|
}
|
|
|
|
void QWidgetPrivate::registerDropSite(bool on)
|
|
{
|
|
Q_Q(QWidget);
|
|
if (!q->testAttribute(Qt::WA_WState_Created))
|
|
return;
|
|
// Enablement is defined by d->extra->dropTarget != 0.
|
|
if (on) {
|
|
// Turn on.
|
|
createExtra();
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
if (!q->internalWinId())
|
|
q->nativeParentWidget()->d_func()->createExtra();
|
|
QWExtra *extra = extraData();
|
|
if (!extra->dropTarget)
|
|
extra->dropTarget = registerOleDnd(q);
|
|
#endif
|
|
} else {
|
|
// Turn off.
|
|
QWExtra *extra = extraData();
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
if (extra && extra->dropTarget) {
|
|
unregisterOleDnd(q, extra->dropTarget);
|
|
extra->dropTarget = 0;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
QOleDropTarget* QWidgetPrivate::registerOleDnd(QWidget *widget)
|
|
{
|
|
QOleDropTarget *dropTarget = new QOleDropTarget(widget);
|
|
Q_ASSERT(widget->testAttribute(Qt::WA_WState_Created));
|
|
if (!widget->internalWinId()) {
|
|
QWidget *nativeParent = widget->nativeParentWidget();
|
|
Q_ASSERT(nativeParent);
|
|
QWExtra *nativeExtra = nativeParent->d_func()->extra;
|
|
Q_ASSERT(nativeExtra);
|
|
if (!nativeParent->acceptDrops())
|
|
nativeParent->setAcceptDrops(true);
|
|
if (!nativeExtra->oleDropWidgets.contains(widget))
|
|
nativeExtra->oleDropWidgets.append(widget);
|
|
if (!nativeExtra->dropTarget) {
|
|
nativeExtra->dropTarget = registerOleDnd(nativeParent);
|
|
Q_ASSERT(nativeExtra->dropTarget);
|
|
#ifndef Q_OS_WINCE
|
|
CoLockObjectExternal(nativeExtra->dropTarget, false, true);
|
|
#endif
|
|
RegisterDragDrop(nativeParent->internalWinId(), nativeExtra->dropTarget);
|
|
}
|
|
} else {
|
|
RegisterDragDrop(widget->internalWinId(), dropTarget);
|
|
#ifndef Q_OS_WINCE
|
|
CoLockObjectExternal(dropTarget, true, true);
|
|
#endif
|
|
}
|
|
return dropTarget;
|
|
}
|
|
|
|
void QWidgetPrivate::unregisterOleDnd(QWidget *widget, QOleDropTarget *dropTarget)
|
|
{
|
|
dropTarget->releaseQt();
|
|
dropTarget->Release();
|
|
Q_ASSERT(widget->testAttribute(Qt::WA_WState_Created));
|
|
if (!widget->internalWinId()) {
|
|
QWidget *nativeParent = widget->nativeParentWidget();
|
|
Q_ASSERT(nativeParent);
|
|
QWExtra *nativeExtra = nativeParent->d_func()->extra;
|
|
Q_ASSERT(nativeExtra);
|
|
nativeExtra->oleDropWidgets.removeAll(widget);
|
|
nativeExtra->oleDropWidgets.removeAll(static_cast<QWidget *>(0));
|
|
if (nativeExtra->oleDropWidgets.isEmpty() && nativeExtra->dropTarget
|
|
&& !nativeParent->testAttribute(Qt::WA_DropSiteRegistered)) {
|
|
#ifndef Q_OS_WINCE
|
|
CoLockObjectExternal(nativeExtra->dropTarget, false, true);
|
|
#endif
|
|
RevokeDragDrop(nativeParent->internalWinId());
|
|
nativeExtra->dropTarget = 0;
|
|
}
|
|
} else {
|
|
#ifndef Q_OS_WINCE
|
|
CoLockObjectExternal(dropTarget, false, true);
|
|
#endif
|
|
RevokeDragDrop(widget->internalWinId());
|
|
}
|
|
}
|
|
|
|
#endif //QT_NO_DRAGANDDROP
|
|
|
|
// from qregion_win.cpp
|
|
extern HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom);
|
|
void QWidgetPrivate::setMask_sys(const QRegion ®ion)
|
|
{
|
|
Q_Q(QWidget);
|
|
if (!q->internalWinId())
|
|
return;
|
|
|
|
if (region.isEmpty()) {
|
|
SetWindowRgn(q->internalWinId(), 0, true);
|
|
return;
|
|
}
|
|
|
|
// Since SetWindowRegion takes ownership, and we need to translate,
|
|
// we take a copy.
|
|
HRGN wr = qt_tryCreateRegion(QRegion::Rectangle, 0,0,0,0);
|
|
CombineRgn(wr, region.handle(), 0, RGN_COPY);
|
|
|
|
QPoint offset = (q->isWindow()
|
|
? frameStrut().topLeft()
|
|
: QPoint(0, 0));
|
|
OffsetRgn(wr, offset.x(), offset.y());
|
|
|
|
Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
|
|
if (!SetWindowRgn(data.winid, wr, true))
|
|
DeleteObject(wr);
|
|
}
|
|
|
|
void QWidgetPrivate::updateFrameStrut()
|
|
{
|
|
Q_Q(QWidget);
|
|
|
|
if (!q->testAttribute(Qt::WA_WState_Created))
|
|
return;
|
|
|
|
if (!q->internalWinId()) {
|
|
data.fstrut_dirty = false;
|
|
return;
|
|
}
|
|
|
|
RECT rect = {0,0,0,0};
|
|
|
|
QTLWExtra *top = topData();
|
|
uint exstyle = GetWindowLong(q->internalWinId(), GWL_EXSTYLE);
|
|
uint style = GetWindowLong(q->internalWinId(), GWL_STYLE);
|
|
#ifndef Q_WS_WINCE
|
|
if (AdjustWindowRectEx(&rect, style & ~(WS_OVERLAPPED), FALSE, exstyle)) {
|
|
#else
|
|
if (AdjustWindowRectEx(&rect, style, FALSE, exstyle)) {
|
|
#endif
|
|
top->frameStrut.setCoords(-rect.left, -rect.top, rect.right, rect.bottom);
|
|
data.fstrut_dirty = false;
|
|
}
|
|
}
|
|
|
|
#ifndef Q_WS_WINCE
|
|
void QWidgetPrivate::setWindowOpacity_sys(qreal level)
|
|
{
|
|
Q_Q(QWidget);
|
|
|
|
if (!isOpaque && ptrUpdateLayeredWindow && (data.window_flags & Qt::FramelessWindowHint)) {
|
|
if (GetWindowLong(q->internalWinId(), GWL_EXSTYLE) & Q_WS_EX_LAYERED) {
|
|
BLENDFUNCTION blend = {AC_SRC_OVER, 0, (int)(255.0 * level), AC_SRC_ALPHA};
|
|
ptrUpdateLayeredWindow(q->internalWinId(), NULL, NULL, NULL, NULL, NULL, 0, &blend, Q_ULW_ALPHA);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static bool function_resolved = false;
|
|
if (!function_resolved) {
|
|
ptrSetLayeredWindowAttributes =
|
|
(PtrSetLayeredWindowAttributes) QSystemLibrary::resolve(QLatin1String("user32"),
|
|
"SetLayeredWindowAttributes");
|
|
function_resolved = true;
|
|
}
|
|
|
|
if (!ptrSetLayeredWindowAttributes)
|
|
return;
|
|
|
|
int wl = GetWindowLong(q->internalWinId(), GWL_EXSTYLE);
|
|
|
|
if (level != 1.0) {
|
|
if ((wl&Q_WS_EX_LAYERED) == 0)
|
|
SetWindowLong(q->internalWinId(), GWL_EXSTYLE, wl | Q_WS_EX_LAYERED);
|
|
} else if (wl&Q_WS_EX_LAYERED) {
|
|
SetWindowLong(q->internalWinId(), GWL_EXSTYLE, wl & ~Q_WS_EX_LAYERED);
|
|
}
|
|
ptrSetLayeredWindowAttributes(q->internalWinId(), 0, (int)(level * 255), Q_LWA_ALPHA);
|
|
}
|
|
#endif //Q_WS_WINCE
|
|
|
|
// class QGlobalRasterPaintEngine: public QRasterPaintEngine
|
|
// {
|
|
// public:
|
|
// inline QGlobalRasterPaintEngine() : QRasterPaintEngine() { setFlushOnEnd(false); }
|
|
// };
|
|
// Q_GLOBAL_STATIC(QGlobalRasterPaintEngine, globalRasterPaintEngine)
|
|
|
|
|
|
#ifndef QT_NO_DIRECTDRAW
|
|
static uchar *qt_primary_surface_bits;
|
|
static int qt_primary_surface_stride;
|
|
static QImage::Format qt_primary_surface_format;
|
|
|
|
void qt_win_initialize_directdraw()
|
|
{
|
|
HRESULT res;
|
|
|
|
// Some initialization...
|
|
if (!qt_ddraw_object) {
|
|
res = DirectDrawCreate(0, &qt_ddraw_object, 0);
|
|
|
|
if (res != DD_OK)
|
|
qWarning("DirectDrawCreate failed: %d", res);
|
|
|
|
qt_ddraw_object->SetCooperativeLevel(0, DDSCL_NORMAL);
|
|
|
|
DDSURFACEDESC surfaceDesc;
|
|
memset(&surfaceDesc, 0, sizeof(DDSURFACEDESC));
|
|
|
|
surfaceDesc.dwSize = sizeof(DDSURFACEDESC);
|
|
surfaceDesc.dwFlags = DDSD_CAPS;
|
|
surfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
|
|
|
|
res = qt_ddraw_object->CreateSurface(&surfaceDesc, &qt_ddraw_primary, 0);
|
|
if (res != DD_OK)
|
|
qWarning("CreateSurface failed: %d", res);
|
|
|
|
memset(&surfaceDesc, 0, sizeof(DDSURFACEDESC));
|
|
surfaceDesc.dwSize = sizeof(DDSURFACEDESC);
|
|
res = qt_ddraw_primary->Lock(0, &surfaceDesc, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, 0);
|
|
if (res != DD_OK)
|
|
qWarning("Locking surface failed: %d", res);
|
|
|
|
if (surfaceDesc.ddpfPixelFormat.dwFlags == DDPF_RGB) {
|
|
qt_primary_surface_bits = (uchar *) surfaceDesc.lpSurface;
|
|
qt_primary_surface_stride = surfaceDesc.lPitch;
|
|
qt_primary_surface_format = QImage::Format_RGB32;
|
|
} else {
|
|
qWarning("QWidget painting: unsupported device depth for onscreen painting...\n");
|
|
}
|
|
|
|
qt_ddraw_primary->Unlock(0);
|
|
}
|
|
}
|
|
|
|
class QOnScreenRasterPaintEngine : public QRasterPaintEngine
|
|
{
|
|
public:
|
|
// The image allocated here leaks... Fix if this code is ifdef'ed
|
|
// in
|
|
QOnScreenRasterPaintEngine()
|
|
: QRasterPaintEngine(new QImage(qt_primary_surface_bits,
|
|
QApplication::desktop()->width(),
|
|
QApplication::desktop()->height(),
|
|
qt_primary_surface_stride,
|
|
qt_primary_surface_format))
|
|
{
|
|
device = static_cast<QImage *>(d_func()->device);
|
|
}
|
|
|
|
bool begin(QPaintDevice *)
|
|
{
|
|
QRegion clip = systemClip();
|
|
originalSystemClip = clip;
|
|
clip.translate(widget->mapToGlobal(QPoint(0, 0)));
|
|
setSystemClip(clip);
|
|
|
|
QRect bounds = clip.boundingRect();
|
|
DDSURFACEDESC surface;
|
|
surface.dwSize = sizeof(DDSURFACEDESC);
|
|
HRESULT res = qt_ddraw_primary->Lock((RECT *) &bounds, &surface, DDLOCK_WAIT, 0);
|
|
if (res != DD_OK) {
|
|
qWarning("QWidget painting: locking onscreen bits failed: %d\n", res);
|
|
return false;
|
|
}
|
|
|
|
if (surface.lpSurface == qt_primary_surface_bits) {
|
|
qt_primary_surface_bits = (uchar *) surface.lpSurface;
|
|
device->data_ptr()->data = qt_primary_surface_bits;
|
|
}
|
|
|
|
return QRasterPaintEngine::begin(device);
|
|
}
|
|
|
|
bool end()
|
|
{
|
|
HRESULT res = qt_ddraw_primary->Unlock(0);
|
|
if (res != DD_OK)
|
|
qWarning("QWidget::paint, failed to unlock DirectDraw surface: %d", res);
|
|
bool ok = QRasterPaintEngine::end();
|
|
setSystemClip(originalSystemClip);
|
|
return ok;
|
|
}
|
|
|
|
QPoint coordinateOffset() const {
|
|
return -widget->mapToGlobal(QPoint(0, 0));
|
|
}
|
|
|
|
const QWidget *widget;
|
|
QImage *device;
|
|
QRegion originalSystemClip;
|
|
};
|
|
Q_GLOBAL_STATIC(QOnScreenRasterPaintEngine, onScreenPaintEngine)
|
|
#else
|
|
void qt_win_initialize_directdraw() { }
|
|
#endif
|
|
|
|
QPaintEngine *QWidget::paintEngine() const
|
|
{
|
|
#ifndef QT_NO_DIRECTDRAW
|
|
QOnScreenRasterPaintEngine *pe = onScreenPaintEngine();
|
|
pe->widget = this;
|
|
return pe;
|
|
#endif
|
|
|
|
// We set this bit which is checked in setAttribute for
|
|
// Qt::WA_PaintOnScreen. We do this to allow these two scenarios:
|
|
//
|
|
// 1. Users accidentally set Qt::WA_PaintOnScreen on X and port to
|
|
// windows which would mean suddenly their widgets stop working.
|
|
//
|
|
// 2. Users set paint on screen and subclass paintEngine() to
|
|
// return 0, in which case we have a "hole" in the backingstore
|
|
// allowing use of GDI or DirectX directly.
|
|
//
|
|
// 1 is WRONG, but to minimize silent failures, we have set this
|
|
// bit to ignore the setAttribute call. 2. needs to be
|
|
// supported because its our only means of embeddeding native
|
|
// graphics stuff.
|
|
const_cast<QWidgetPrivate *>(d_func())->noPaintOnScreen = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
QWindowSurface *QWidgetPrivate::createDefaultWindowSurface_sys()
|
|
{
|
|
Q_Q(QWidget);
|
|
return new QRasterWindowSurface(q);
|
|
}
|
|
|
|
void QWidgetPrivate::setModal_sys()
|
|
{
|
|
}
|
|
|
|
void QWidgetPrivate::registerTouchWindow()
|
|
{
|
|
Q_Q(QWidget);
|
|
|
|
// enable WM_TOUCH* messages on our window
|
|
if (q->testAttribute(Qt::WA_WState_Created)
|
|
&& QApplicationPrivate::RegisterTouchWindow
|
|
&& q->windowType() != Qt::Desktop)
|
|
QApplicationPrivate::RegisterTouchWindow(q->effectiveWinId(), 0);
|
|
}
|
|
|
|
void QWidgetPrivate::winSetupGestures()
|
|
{
|
|
#if !defined(QT_NO_GESTURES) && !defined(QT_NO_NATIVE_GESTURES)
|
|
Q_Q(QWidget);
|
|
if (!q || !q->isVisible() || !nativeGesturePanEnabled)
|
|
return;
|
|
|
|
if (!QApplicationPrivate::HasTouchSupport)
|
|
return;
|
|
QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
|
|
if (!qAppPriv->SetGestureConfig)
|
|
return;
|
|
WId winid = q->internalWinId();
|
|
|
|
bool needh = false;
|
|
bool needv = false;
|
|
bool singleFingerPanEnabled = false;
|
|
|
|
#ifndef QT_NO_SCROLLAREA
|
|
if (QAbstractScrollArea *asa = qobject_cast<QAbstractScrollArea*>(q->parent())) {
|
|
QScrollBar *hbar = asa->horizontalScrollBar();
|
|
QScrollBar *vbar = asa->verticalScrollBar();
|
|
Qt::ScrollBarPolicy hbarpolicy = asa->horizontalScrollBarPolicy();
|
|
Qt::ScrollBarPolicy vbarpolicy = asa->verticalScrollBarPolicy();
|
|
needh = (hbarpolicy == Qt::ScrollBarAlwaysOn ||
|
|
(hbarpolicy == Qt::ScrollBarAsNeeded && hbar->minimum() < hbar->maximum()));
|
|
needv = (vbarpolicy == Qt::ScrollBarAlwaysOn ||
|
|
(vbarpolicy == Qt::ScrollBarAsNeeded && vbar->minimum() < vbar->maximum()));
|
|
singleFingerPanEnabled = asa->d_func()->singleFingerPanEnabled;
|
|
if (!winid) {
|
|
winid = q->winId(); // enforces the native winid on the viewport
|
|
}
|
|
}
|
|
#endif //QT_NO_SCROLLAREA
|
|
if (winid) {
|
|
GESTURECONFIG gc[1];
|
|
memset(gc, 0, sizeof(gc));
|
|
gc[0].dwID = GID_PAN;
|
|
if (nativeGesturePanEnabled) {
|
|
gc[0].dwWant = GC_PAN;
|
|
if (needv && singleFingerPanEnabled)
|
|
gc[0].dwWant |= GC_PAN_WITH_SINGLE_FINGER_VERTICALLY;
|
|
else
|
|
gc[0].dwBlock |= GC_PAN_WITH_SINGLE_FINGER_VERTICALLY;
|
|
if (needh && singleFingerPanEnabled)
|
|
gc[0].dwWant |= GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY;
|
|
else
|
|
gc[0].dwBlock |= GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY;
|
|
} else {
|
|
gc[0].dwBlock = GC_PAN;
|
|
}
|
|
|
|
qAppPriv->SetGestureConfig(winid, 0, sizeof(gc)/sizeof(gc[0]), gc, sizeof(gc[0]));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#ifdef Q_WS_WINCE
|
|
# include "qwidget_wince.cpp"
|
|
#endif
|