Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

qapplication_pm.cpp

Last change on this file was 195, checked in by rudi, 14 years ago
Fix for redrawing problems (ticket #47)
Property svn:keywords set to `Id`
File size: 130.8 KB

Rev	Line
[8]	1	/****************************************************************************
	2	** $Id: qapplication_pm.cpp 195 2011-06-18 05:23:01Z rudi $
	3	**
	4	** Implementation of OS/2 startup routines and event handling
	5	**
	6	** Copyright (C) 1992-2003 Trolltech AS. All rights reserved.
	7	** Copyright (C) 2004 Norman ASA. Initial OS/2 Port.
[136]	8	** Copyright (C) 2005-2006 netlabs.org. Further OS/2 Development.
[8]	9	**
	10	** This file is part of the kernel module of the Qt GUI Toolkit.
	11	**
	12	** This file may be distributed under the terms of the Q Public License
	13	** as defined by Trolltech AS of Norway and appearing in the file
	14	** LICENSE.QPL included in the packaging of this file.
	15	**
	16	** This file may be distributed and/or modified under the terms of the
	17	** GNU General Public License version 2 as published by the Free Software
	18	** Foundation and appearing in the file LICENSE.GPL included in the
	19	** packaging of this file.
	20	**
	21	** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
	22	** licenses may use this file in accordance with the Qt Commercial License
	23	** Agreement provided with the Software.
	24	**
	25	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	26	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	27	**
	28	** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
	29	** information about Qt Commercial License Agreements.
	30	** See http://www.trolltech.com/qpl/ for QPL licensing information.
	31	** See http://www.trolltech.com/gpl/ for GPL licensing information.
	32	**
	33	** Contact info@trolltech.com if any conditions of this licensing are
	34	** not clear to you.
	35	**
	36	**********************************************************************/
	37
	38	// GCC headers do not define this when INCL_BASE is defined,
	39	// but we need it for IOCTL_KEYBOARD etc. constants
	40	#ifndef INCL_DOSDEVIOCTL
	41	#define INCL_DOSDEVIOCTL
	42	#endif
	43
	44	#include "qapplication.h"
	45	#include "private/qapplication_p.h"
	46	#include "qwidget.h"
	47	#include "qwidgetlist.h"
	48	#include "qwidgetintdict.h"
	49	#include "qobjectlist.h"
	50	#include "qpainter.h"
	51	#include "qpixmapcache.h"
	52	#include "qdatetime.h"
[77]	53	#include "qsessionmanager.h"
[8]	54	#include "qmime.h"
	55	#include "qguardedptr.h"
	56	#include "qclipboard.h"
	57	#include "qthread.h"
	58	#include "qwhatsthis.h" // ######## dependency
	59	#include "qthread.h"
	60	#include "qlibrary.h"
	61	#include "qt_os2.h"
	62	#include "qcursor.h"
	63	#include "private/qinternal_p.h"
	64	#include "private/qcriticalsection_p.h"
[77]	65	/// @todo (dmik) remove?
[8]	66	//#include "private/qinputcontext_p.h"
	67	#include "qstyle.h"
	68	#include "qmetaobject.h"
	69
	70	#include <limits.h>
	71	#include <string.h>
	72	#include <ctype.h>
	73	#include <stdlib.h>
	74
	75	extern void qt_ensure_pm();
	76
[77]	77	/// @todo (dmik) hmm, extended keys under OS/2?
[8]	78	//// support for multi-media-keys on ME/2000/XP
	79	//#ifndef WM_APPCOMMAND
	80	//#define WM_APPCOMMAND 0x0319
	81	//
	82	//#define FAPPCOMMAND_MOUSE 0x8000
	83	//#define FAPPCOMMAND_KEY 0
	84	//#define FAPPCOMMAND_OEM 0x1000
	85	//#define FAPPCOMMAND_MASK 0xF000
	86	//#define GET_APPCOMMAND_LPARAM(lParam) ((short)(HIWORD(lParam) & ~FAPPCOMMAND_MASK))
	87	//#define GET_DEVICE_LPARAM(lParam) ((WORD)(HIWORD(lParam) & FAPPCOMMAND_MASK))
	88	//#define GET_MOUSEORKEY_LPARAM GET_DEVICE_LPARAM
	89	//#define GET_FLAGS_LPARAM(lParam) (LOWORD(lParam))
	90	//#define GET_KEYSTATE_LPARAM(lParam) GET_FLAGS_LPARAM(lParam)
	91	//
	92	//#define APPCOMMAND_BROWSER_BACKWARD 1
	93	//#define APPCOMMAND_BROWSER_FORWARD 2
	94	//#define APPCOMMAND_BROWSER_REFRESH 3
	95	//#define APPCOMMAND_BROWSER_STOP 4
	96	//#define APPCOMMAND_BROWSER_SEARCH 5
	97	//#define APPCOMMAND_BROWSER_FAVORITES 6
	98	//#define APPCOMMAND_BROWSER_HOME 7
	99	//#define APPCOMMAND_VOLUME_MUTE 8
	100	//#define APPCOMMAND_VOLUME_DOWN 9
	101	//#define APPCOMMAND_VOLUME_UP 10
	102	//#define APPCOMMAND_MEDIA_NEXTTRACK 11
	103	//#define APPCOMMAND_MEDIA_PREVIOUSTRACK 12
	104	//#define APPCOMMAND_MEDIA_STOP 13
	105	//#define APPCOMMAND_MEDIA_PLAY_PAUSE 14
	106	//#define APPCOMMAND_LAUNCH_MAIL 15
	107	//#define APPCOMMAND_LAUNCH_MEDIA_SELECT 16
	108	//#define APPCOMMAND_LAUNCH_APP1 17
	109	//#define APPCOMMAND_LAUNCH_APP2 18
	110	//#define APPCOMMAND_BASS_DOWN 19
	111	//#define APPCOMMAND_BASS_BOOST 20
	112	//#define APPCOMMAND_BASS_UP 21
	113	//#define APPCOMMAND_TREBLE_DOWN 22
	114	//#define APPCOMMAND_TREBLE_UP 23
	115	//#endif
	116
	117	extern void qt_dispatchEnterLeave( QWidget, QWidget ); // qapplication.cpp
	118
	119	extern void qt_erase_background(
	120	HPS hps, int x, int y, int w, int h,
	121	const QColor &bg_color,
	122	const QPixmap *bg_pixmap, int off_x, int off_y, int devh
	123	);
	124
	125	/*
	126	Internal functions.
	127	*/
	128
	129	Q_EXPORT
	130	void qt_draw_tiled_pixmap( HPS, int, int, int, int,
	131	const QPixmap *, int, int, int );
	132
[174]	133	Q_EXPORT
[8]	134	QRgb qt_sysclr2qrgb( LONG sysClr )
	135	{
	136	// QRgb has the same RGB format (0xaarrggbb) as OS/2 uses (ignoring the
	137	// highest alpha byte) so we just cast OS/2 LONG RGB value to qRgb
	138	// which is an unsigned int actually.
	139	return ((QRgb) WinQuerySysColor( HWND_DESKTOP, sysClr, 0 )) & RGB_MASK;
	140	}
	141
[174]	142	static
	143	QFont qt_sysfont2qfont( const PSZ scope )
	144	{
[8]	145	static const PSZ app = "PM_SystemFonts";
[174]	146	static const PSZ def = "10.System Proportional";
[8]	147	ULONG keyLen = 0;
[174]	148	QFont f( "System Proportional", 10 );
[8]	149
	150	if ( PrfQueryProfileSize( HINI_USERPROFILE, app, scope, &keyLen ) && keyLen ) {
	151	keyLen ++; // reserve space for a dot
	152	char *buf = new char [keyLen];
	153	ULONG realLen =
	154	PrfQueryProfileString( HINI_USERPROFILE, app, scope, def, buf, keyLen );
	155	realLen --; // excude zero terminator
	156
	157	// parse the font definition
	158	int height = 0;
	159	char dot = strchr( buf, '.' ), dot2 = 0;
	160	if ( dot ) {
	161	*dot = 0;
	162	height = strtoul( buf, NULL, 10 );
	163	dot2 = strchr( ++ dot, '.' );
	164	if ( dot2 ) {
	165	// process simulated styles
	166	buf[realLen] = '.';
	167	buf[realLen+1] = 0;
	168	strupr( dot2 );
[77]	169	/// @todo (dmik) currently, simulated bold and italic font styles are not
[8]	170	// supported by Qt/OS2 because Qt doesn't support style simulation
	171	// explicitly. the code below is commented out to prevent selecting
	172	// true fonts when simulated ones are actually requested.
	173	// if ( strstr( dot2, ".BOLD." ) ) f.setBold( TRUE );
	174	// if ( strstr( dot2, ".ITALIC.") ) f.setItalic( TRUE );
	175	if ( strstr( dot2, ".UNDERSCORE.") ) f.setUnderline( TRUE );
	176	if ( strstr( dot2, ".UNDERLINED.") ) f.setUnderline( TRUE );
	177	if ( strstr( dot2, ".STRIKEOUT.") ) f.setStrikeOut( TRUE );
	178	*dot2 = 0;
	179	}
	180	// query non-simulated styles
	181	FONTMETRICS fm;
	182	LONG cnt = 1; // use the first match
	183	GpiQueryFonts(
	184	qt_display_ps(), QF_PUBLIC, dot, &cnt, sizeof(FONTMETRICS), &fm );
	185	if ( cnt ) {
	186	// the code below is mostly from QFontDatabasePrivate::reload()
	187	if ( fm.fsSelection & FM_SEL_ITALIC ) f.setItalic( TRUE );
	188	if ( fm.fsType & FM_TYPE_FIXED ) f.setFixedPitch( TRUE );
	189	USHORT weight = fm.usWeightClass;
	190	USHORT width = fm.usWidthClass;
	191	if ( weight < 4 ) f.setWeight( QFont::Light );
	192	else if ( weight < 6 ) f.setWeight( QFont::Normal );
	193	else if ( weight < 7 ) f.setWeight( QFont::DemiBold );
	194	else if ( weight < 8 ) f.setWeight( QFont::Bold );
	195	else f.setWeight( QFont::Black );
	196	switch ( width ) {
	197	case 1: f.setStretch( QFont::UltraCondensed ); break;
	198	case 2: f.setStretch( QFont::ExtraCondensed ); break;
	199	case 3: f.setStretch( QFont::Condensed ); break;
	200	case 4: f.setStretch( QFont::SemiCondensed ); break;
	201	case 5: f.setStretch( QFont::Unstretched ); break;
	202	case 6: f.setStretch( QFont::SemiExpanded ); break;
	203	case 7: f.setStretch( QFont::Expanded ); break;
	204	case 8: f.setStretch( QFont::ExtraExpanded ); break;
	205	case 9: f.setStretch( QFont::UltraExpanded ); break;
	206	default: f.setStretch( QFont::Unstretched ); break;
	207	}
	208	f.setFamily( fm.szFamilyname );
	209	f.setPointSize( height );
	210	}
	211	}
	212	delete[] buf;
	213	}
	214	return f;
	215	}
	216
	217	/*****************************************************************************
	218	Internal variables and functions
	219	*****************************************************************************/
	220
	221	static HWND curWin = 0; // current window
	222	static HPS displayPS = 0; // display presentation space
	223
[77]	224	#if !defined (QT_NO_SESSIONMANAGER)
[8]	225
[77]	226	// Session management
	227	static bool sm_blockUserInput = FALSE;
	228	static bool sm_smActive = FALSE;
	229	extern QSessionManager* qt_session_manager_self;
	230	static bool sm_cancel = FALSE;
	231	static bool sm_gracefulShutdown = FALSE;
[78]	232	static bool sm_quitSkipped = FALSE;
	233	bool qt_about_to_destroy_wnd = FALSE;
[77]	234
	235	//#define DEBUG_SESSIONMANAGER
	236
	237	#endif
	238
[8]	239	static bool replayPopupMouseEvent = FALSE; // replay handling when popups close
	240
	241	static bool ignoreNextMouseReleaseEvent = FALSE; // ignore the next release event if
	242	// return from a modal widget
	243	#if defined(QT_DEBUG)
	244	static bool appNoGrab = FALSE; // mouse/keyboard grabbing
	245	#endif
	246
	247	static bool app_do_modal = FALSE; // modal mode
	248	extern QWidgetList *qt_modal_stack;
	249	extern QDesktopWidget *qt_desktopWidget;
	250	static QWidget *popupButtonFocus = 0;
	251	static bool popupCloseDownMode = FALSE;
	252	static bool qt_try_modal( QWidget , QMSG , int& ret );
	253
	254	QWidget *qt_button_down = 0; // widget got last button-down
	255
	256	extern bool qt_tryAccelEvent( QWidget, QKeyEvent ); // def in qaccel.cpp
	257
	258	static HWND autoCaptureWnd = 0;
	259	static bool autoCaptureReleased = FALSE;
	260	static void setAutoCapture( HWND ); // automatic capture
	261	static void releaseAutoCapture();
	262
	263	//@@TODO (dmik):
	264	// do we really need this filter stuff or qApp->pmEventFilter()
	265	// is enough?
	266	typedef int (QPMEventFilter) (QMSG);
	267	static QPMEventFilter qt_pm_event_filter = 0;
	268
	269	Q_EXPORT QPMEventFilter qt_set_pm_event_filter( QPMEventFilter filter )
	270	{
	271	QPMEventFilter old_filter = qt_pm_event_filter;
	272	qt_pm_event_filter = filter;
	273	return old_filter;
	274	}
	275
	276	typedef bool (QPMEventFilterEx) (QMSG,MRESULT&);
	277	static QPMEventFilterEx qt_pm_event_filter_ex = 0;
	278
	279	Q_EXPORT QPMEventFilterEx qt_set_pm_event_filter_ex( QPMEventFilterEx filter )
	280	{
	281	QPMEventFilterEx old = qt_pm_event_filter_ex;
	282	qt_pm_event_filter_ex = filter;
	283	return old;
	284	}
	285
	286	bool qt_pmEventFilter( QMSG* msg, MRESULT &result )
	287	{
	288	result = NULL;
	289	if ( qt_pm_event_filter && qt_pm_event_filter( msg ) )
	290	return TRUE;
	291	if ( qt_pm_event_filter_ex && qt_pm_event_filter_ex( msg, result ) )
	292	return TRUE;
	293	return qApp->pmEventFilter( msg );
	294	}
	295
	296	static void unregWinClasses();
	297
	298	extern QCursor *qt_grab_cursor();
	299
	300	extern "C" MRESULT EXPENTRY QtWndProc( HWND, ULONG, MPARAM, MPARAM );
	301
	302	class QETWidget : public QWidget // event translator widget
	303	{
	304	public:
	305	void setWFlags( WFlags f ) { QWidget::setWFlags(f); }
	306	void clearWFlags( WFlags f ) { QWidget::clearWFlags(f); }
	307	void setWState( WState f ) { QWidget::setWState(f); }
	308	void clearWState( WState f ) { QWidget::clearWState(f); }
	309	QWExtra *xtra() { return QWidget::extraData(); }
	310	QTLWExtra *top() { return QWidget::topData(); }
	311	bool pmEvent( QMSG *m ) { return QWidget::pmEvent(m); }
	312	#if defined(Q_CC_GNU)
	313	void markFrameStrutDirty() { fstrut_dirty = 1; }
	314	#else
	315	void markFrameStrutDirty() { QWidget::fstrut_dirty = 1; }
	316	#endif
[102]	317	void updateFrameStrut() { QWidget::updateFrameStrut(); }
[8]	318	bool translateMouseEvent( const QMSG &qmsg );
	319	bool translateKeyEvent( const QMSG &qmsg, bool grab );
	320	#ifndef QT_NO_WHEELEVENT
	321	bool translateWheelEvent( const QMSG &qmsg );
	322	#endif
	323	bool sendKeyEvent( QEvent::Type type, int code, int ascii,
	324	int state, bool grab, const QString& text,
	325	bool autor = FALSE );
	326	bool translatePaintEvent( const QMSG &qmsg );
	327	bool translateConfigEvent( const QMSG &qmsg );
	328	bool translateCloseEvent( const QMSG &qmsg );
	329	//@@TODO (dmik): later
	330	// void repolishStyle( QStyle &style ) { styleChange( style ); }
	331	//@@TODO (dmik): it seems we don't need this
	332	// void reparentWorkaround();
	333	void showChildren(bool spontaneous) { QWidget::showChildren(spontaneous); }
	334	void hideChildren(bool spontaneous) { QWidget::hideChildren(spontaneous); }
	335	};
	336
	337	//@@TODO (dmik): it seems we don't need this
	338	//void QETWidget::reparentWorkaround()
	339	//{
	340	// ((QWidgetIntDict*)QWidget::wmapper())->remove((long)winid);
	341	// clearWState(WState_Created \| WState_Visible \| WState_ForceHide);
	342	// winid = 0;
	343	// QRect geom = geometry();
	344	// create(0, FALSE, FALSE);
	345	// setGeometry(geom);
	346	// QWidget *p = parentWidget();
	347	// while (p) {
	348	// if (!p->isVisible())
	349	// return;
	350	// p = p->parentWidget();
	351	// }
	352	// show();
	353	//}
	354
	355
	356	static bool qt_show_system_menu( QWidget* tlw )
	357	{
	358	HWND fId = tlw->winFId();
	359	HWND sysMenu = WinWindowFromID( fId, FID_SYSMENU );
	360	if ( !sysMenu )
	361	return FALSE; // no menu for this window
	362	WinPostMsg( sysMenu, MM_STARTMENUMODE, MPFROM2SHORT(TRUE, FALSE), 0 );
	363	return TRUE;
	364	}
	365
	366	// Palette handling
	367	extern QPalette *qt_std_pal;
	368	extern void qt_create_std_palette();
	369
	370	static void qt_set_pm_resources()
	371	{
	372	// Do the font settings
	373
[174]	374	#ifndef QT_PM_NO_DEFAULTFONT_OVERRIDE
[8]	375	QFont windowFont = qt_sysfont2qfont( "WindowText" );
[174]	376	#else
	377	QFont windowFont = qt_sysfont2qfont( "DefaultFont" );
	378	#endif
[8]	379	QFont menuFont = qt_sysfont2qfont( "Menus" );
	380	QFont iconFont = qt_sysfont2qfont( "IconText" );
	381	QFont titleFont = qt_sysfont2qfont( "WindowTitles" );
	382
	383	QApplication::setFont( windowFont, TRUE );
	384	QApplication::setFont( menuFont, TRUE, "QPopupMenu" );
	385	QApplication::setFont( menuFont, TRUE, "QMenuBar" );
	386	QApplication::setFont( iconFont, TRUE, "QTipLabel" );
	387	QApplication::setFont( iconFont, TRUE, "QStatusBar" );
	388	QApplication::setFont( titleFont, TRUE, "QTitleBar" );
	389	QApplication::setFont( titleFont, TRUE, "QDockWindowTitleBar" );
	390
	391	if ( qt_std_pal && *qt_std_pal != QApplication::palette() )
	392	return;
	393
	394	// Do the color settings
	395
	396	// active colors
	397	QColorGroup acg;
	398	acg.setColor( QColorGroup::Foreground,
	399	QColor( qt_sysclr2qrgb( SYSCLR_WINDOWTEXT ) ) );
	400	acg.setColor( QColorGroup::Background,
	401	QColor( qt_sysclr2qrgb( SYSCLR_DIALOGBACKGROUND ) ) );
	402	acg.setColor( QColorGroup::ButtonText,
	403	QColor( qt_sysclr2qrgb( SYSCLR_MENUTEXT ) ) );
	404	acg.setColor( QColorGroup::Button,
	405	QColor( qt_sysclr2qrgb( SYSCLR_BUTTONMIDDLE ) ) );
	406	acg.setColor( QColorGroup::Light,
	407	QColor( qt_sysclr2qrgb( SYSCLR_BUTTONLIGHT ) ) );
	408	acg.setColor( QColorGroup::Dark,
	409	QColor( qt_sysclr2qrgb( SYSCLR_BUTTONDARK ) ) );
	410	acg.setColor( QColorGroup::Midlight,
	411	QColor( (acg.light().red() + acg.button().red()) / 2,
	412	(acg.light().green() + acg.button().green()) / 2,
	413	(acg.light().blue() + acg.button().blue()) / 2 ) );
	414	acg.setColor( QColorGroup::Mid,
	415	QColor( (acg.dark().red() + acg.button().red()) / 2,
	416	(acg.dark().green() + acg.button().green()) / 2,
	417	(acg.dark().blue() + acg.button().blue()) / 2 ) );
	418	acg.setColor( QColorGroup::Text,
	419	QColor( qt_sysclr2qrgb( SYSCLR_MENUTEXT ) ) );
	420	acg.setColor( QColorGroup::Base,
	421	QColor( qt_sysclr2qrgb( SYSCLR_ENTRYFIELD ) ) );
	422	acg.setColor( QColorGroup::BrightText,
	423	QColor( qt_sysclr2qrgb( SYSCLR_BUTTONLIGHT ) ) );
	424	acg.setColor( QColorGroup::Shadow,
	425	Qt::black );
	426	acg.setColor( QColorGroup::Highlight,
	427	QColor( qt_sysclr2qrgb( SYSCLR_HILITEBACKGROUND ) ) );
	428	acg.setColor( QColorGroup::HighlightedText,
	429	QColor( qt_sysclr2qrgb( SYSCLR_HILITEFOREGROUND ) ) );
	430
	431	// these colors are not present in the PM system palette
	432	acg.setColor( QColorGroup::Link, Qt::blue );
	433	acg.setColor( QColorGroup::LinkVisited, Qt::magenta );
	434
	435	// disabled colors
	436	QColorGroup dcg = acg;
	437	dcg.setColor( QColorGroup::Foreground,
	438	QColor( qt_sysclr2qrgb( SYSCLR_MENUDISABLEDTEXT ) ) );
	439	dcg.setColor( QColorGroup::Text,
	440	QColor( qt_sysclr2qrgb( SYSCLR_MENUDISABLEDTEXT ) ) );
	441
	442	// inactive colors are currently the same as active
	443	QColorGroup icg = acg;
	444
	445	QPalette pal( acg, dcg, icg );
	446	QApplication::setPalette( pal, TRUE );
	447	*qt_std_pal = pal;
	448
[174]	449	// special palettes
	450	QColorGroup scg;
	451
	452	// menus
	453	scg = acg;
	454	scg.setColor( QColorGroup::Background,
	455	QColor( qt_sysclr2qrgb( SYSCLR_MENU ) ) );
	456	scg.setColor( QColorGroup::Highlight,
[8]	457	QColor( qt_sysclr2qrgb( SYSCLR_MENUHILITEBGND ) ) );
[174]	458	scg.setColor( QColorGroup::HighlightedText,
[8]	459	QColor( qt_sysclr2qrgb( SYSCLR_MENUHILITE ) ) );
[174]	460	pal.setActive( scg );
	461	pal.setInactive( scg );
	462	QApplication::setPalette( pal, TRUE, "QPopupMenu" );
	463	QApplication::setPalette( pal, TRUE, "QMenuBar" );
	464
	465	// static widget texts
	466	scg = acg;
	467	QColor staticTextCol( qt_sysclr2qrgb( SYSCLR_WINDOWSTATICTEXT ) );
	468	scg.setColor( QColorGroup::Foreground, staticTextCol );
	469	scg.setColor( QColorGroup::Text, staticTextCol );
	470	pal.setActive( scg );
	471	pal.setInactive( scg );
	472	QApplication::setPalette( pal, TRUE, "QLabel" );
	473	QApplication::setPalette( pal, TRUE, "QGroupBox" );
[8]	474	}
	475
	476	/*****************************************************************************
	477	qt_init() - initializes Qt for OS/2
	478	*****************************************************************************/
	479
[139]	480	// wrapper for QtOS2SysXcptMainHandler to provide local access to private data
	481	class QtOS2SysXcptMainHandlerInternal : public QtOS2SysXcptMainHandler
	482	{
	483	public:
[174]	484	static bool &installed() { return QtOS2SysXcptMainHandler::installed; }
[139]	485	static ERR &libcHandler() { return QtOS2SysXcptMainHandler::libcHandler; }
	486	static ERR handler() { return QtOS2SysXcptMainHandler::handler; }
	487	};
[136]	488
[139]	489	#define XcptMainHandler QtOS2SysXcptMainHandlerInternal
	490
[8]	491	// need to get default font?
	492	extern bool qt_app_has_font;
	493
	494	void qt_init( int argcptr, char *argv, QApplication::Type )
	495	{
[139]	496	#if !defined(QT_OS2_NO_SYSEXCEPTIONS)
	497	// Even if the user didn't install the exception handler for the main
	498	// thread using QtOS2SysXcptMainHandler prior to constructing a QApplication
	499	// instance, we still want it to be installed to catch system traps. But
	500	// since the exception registration record can only be located on the stack,
[136]	501	// we can enable our exception handling on the main thread only if the LIBC
	502	// library of the compiler provides an exception handler (already allocated
	503	// on the stack before main() is called). In this case, we replace the LIBC
	504	// exception handler's pointer with our own (not nice but what to do?) and
	505	// call the former (to let it do signal processing and the stuff) after we
[139]	506	// generate the trap file. Note that in this tricky case, the user has no
	507	// possibility to install the exception handler callback (since it's only
	508	// possible using QtOS2SysXcptMainHandler).
	509
	510	PTIB ptib = NULL;
	511	DosGetInfoBlocks( &ptib, NULL );
	512	Q_ASSERT( ptib && ptib->tib_ptib2 );
[174]	513
[139]	514	if ( ptib && ptib->tib_ptib2 ) {
[174]	515	// must be called only on the main (first) thread
[139]	516	Q_ASSERT( ptib->tib_ptib2->tib2_ultid == 1 );
	517	// also make sure that QtOS2SysXcptMainHandler was not already
	518	// instantiated on the main thread
	519	if ( ptib->tib_ptib2->tib2_ultid == 1 &&
	520	XcptMainHandler::installed() == FALSE )
	521	{
[136]	522	if ( ptib->tib_pexchain != END_OF_CHAIN ) {
[139]	523	PEXCEPTIONREGISTRATIONRECORD r =
[136]	524	(PEXCEPTIONREGISTRATIONRECORD) ptib->tib_pexchain;
[139]	525	XcptMainHandler::libcHandler() = r->ExceptionHandler;
	526	r->ExceptionHandler = XcptMainHandler::handler();
	527	XcptMainHandler::installed() = TRUE;
[136]	528	} else {
	529	Q_ASSERT( 0 /* no exception handler for the main thread */ );
	530	}
	531	}
	532	}
	533	#endif
[8]	534
	535	#if defined(QT_DEBUG)
	536	int argc = *argcptr;
	537	int i, j;
	538
	539	// Get command line params
	540
	541	j = argc ? 1 : 0;
	542	for ( i=1; i<argc; i++ ) {
	543	if ( argv[i] && *argv[i] != '-' ) {
	544	argv[j++] = argv[i];
	545	continue;
	546	}
	547	QCString arg = argv[i];
	548	if ( arg == "-nograb" )
	549	appNoGrab = !appNoGrab;
	550	else
	551	argv[j++] = argv[i];
	552	}
	553	*argcptr = j;
	554	#else
	555	Q_UNUSED( argcptr );
	556	Q_UNUSED( argv );
	557	#endif // QT_DEBUG
	558
	559	// Ensure we are in PM mode
	560	qt_ensure_pm();
[115]	561	// Force creation of the main event queue to make it possible to
	562	// create windows before the application invokes exec()
[8]	563	QApplication::eventLoop();
	564
	565	// Misc. initialization
	566	QPMMime::initialize();
	567	QColor::initialize();
	568	QFont::initialize();
	569	QCursor::initialize();
	570	QPainter::initialize();
	571	#if defined(QT_THREAD_SUPPORT)
	572	QThread::initialize();
	573	#endif
	574	qApp->setName( qAppName() );
	575
	576	// default font
	577	if ( !qt_app_has_font )
[174]	578	QApplication::setFont( QFont( "System Proportional", 10 ) );
[8]	579
	580	// QFont::locale_init(); ### Uncomment when it does something on OS/2
	581
	582	if ( !qt_std_pal )
	583	qt_create_std_palette();
	584
	585	if ( QApplication::desktopSettingsAware() )
	586	qt_set_pm_resources();
	587
[115]	588	/// @todo (dmik) remove?
[8]	589	// QInputContext::init();
	590	}
	591
	592	/*****************************************************************************
	593	qt_cleanup() - cleans up when the application is finished
	594	*****************************************************************************/
	595
	596	void qt_cleanup()
	597	{
	598	unregWinClasses();
	599	QPixmapCache::clear();
	600	QPainter::cleanup();
	601	QCursor::cleanup();
	602	QFont::cleanup();
	603	QColor::cleanup();
	604	QSharedDoubleBuffer::cleanup();
	605	#if defined(QT_THREAD_SUPPORT)
	606	QThread::cleanup();
	607	#endif
	608	if ( displayPS ) {
	609	WinReleasePS( displayPS );
	610	displayPS = 0;
	611	}
	612
	613	//@@TODO (dmik): remove?
	614	// QInputContext::shutdown();
[136]	615
[139]	616	#if !defined(QT_OS2_NO_SYSEXCEPTIONS)
[174]	617	// remove the exception handler if it was installed in qt_init()
[139]	618	PTIB ptib = NULL;
	619	DosGetInfoBlocks( &ptib, NULL );
	620	Q_ASSERT( ptib && ptib->tib_ptib2 );
[174]	621
[139]	622	if ( ptib && ptib->tib_ptib2 ) {
[174]	623	// must be called only on the main (first) thread
[139]	624	Q_ASSERT( ptib->tib_ptib2->tib2_ultid == 1 );
	625	// also make sure the handler was really installed by qt_init()
	626	if ( ptib->tib_ptib2->tib2_ultid == 1 &&
	627	XcptMainHandler::installed() == TRUE &&
	628	XcptMainHandler::libcHandler() != NULL )
	629	{
[136]	630	Q_ASSERT( ptib->tib_pexchain != END_OF_CHAIN );
	631	if ( ptib->tib_pexchain != END_OF_CHAIN ) {
[139]	632	PEXCEPTIONREGISTRATIONRECORD r =
[136]	633	(PEXCEPTIONREGISTRATIONRECORD) ptib->tib_pexchain;
[139]	634	Q_ASSERT( r->ExceptionHandler == XcptMainHandler::handler() );
	635	if ( r->ExceptionHandler == XcptMainHandler::handler() ) {
	636	r->ExceptionHandler = XcptMainHandler::libcHandler();
	637	XcptMainHandler::libcHandler() = NULL;
	638	XcptMainHandler::installed() = FALSE;
[136]	639	}
	640	}
	641	}
	642	}
	643	#endif
[8]	644	}
	645
	646
	647	/*****************************************************************************
	648	Platform specific global and internal functions
	649	*****************************************************************************/
	650
	651	Q_EXPORT const char *qAppFileName() // get application file name
	652	{
	653	static char appFileName[CCHMAXPATH] = "\0";
	654	if ( !appFileName[0] ) {
	655	PPIB ppib;
	656	DosGetInfoBlocks( NULL, &ppib );
	657	DosQueryModuleName( ppib->pib_hmte, sizeof(appFileName), appFileName );
	658	}
	659	return appFileName;
	660	}
	661
	662	Q_EXPORT const char *qAppName() // get application name
	663	{
	664	static char appName[CCHMAXPATH] = "\0";
	665	if ( !appName[0] ) {
	666	const char *p = strrchr( qAppFileName(), '\\' ); // skip path
	667	if ( p )
	668	memcpy( appName, p+1, qstrlen(p) );
	669	int l = qstrlen( appName );
	670	if ( (l > 4) && !qstricmp( appName + l - 4, ".exe" ) )
	671	appName[l-4] = '\0'; // drop .exe extension
	672	}
	673	return appName;
	674	}
	675
	676	Q_EXPORT HPS qt_display_ps() // get display PS
	677	{
	678	if ( !displayPS )
	679	displayPS = WinGetScreenPS( HWND_DESKTOP );
	680	return displayPS;
	681	}
	682
	683	bool qt_nograb() // application no-grab option
	684	{
	685	#if defined(QT_DEBUG)
	686	return appNoGrab;
	687	#else
	688	return FALSE;
	689	#endif
	690	}
	691
	692
	693	static QAsciiDict<int> *winclassNames = 0;
	694
	695	const QString qt_reg_winclass( int flags ) // register window class
	696	{
	697	if ( flags & Qt::WType_Desktop )
	698	return QString();
	699
	700	if ( !winclassNames ) {
	701	winclassNames = new QAsciiDict<int>;
	702	Q_CHECK_PTR( winclassNames );
	703	}
	704
	705	ULONG style = 0;
	706	QString cname;
	707	if ( flags & Qt::WType_TopLevel ) {
	708	if ( flags & Qt::WType_Popup ) {
	709	cname = "QPopup";
	710	} else {
	711	// this class is for frame window clients when WC_FRAME is used.
	712	cname = "QClient";
	713	style \|= CS_MOVENOTIFY;
	714	}
	715	} else {
	716	cname = "QWidget";
	717	}
	718
	719	if ( winclassNames->find(cname.latin1()) ) // already registered
	720	return cname;
	721
	722	// QT_EXTRAWINDATASIZE is defined in qwindowdefs_pm.h.
	723	WinRegisterClass( 0, cname.latin1(), QtWndProc, style, QT_EXTRAWINDATASIZE );
	724
	725	winclassNames->insert( cname.latin1(), (int*)1 );
	726	return cname;
	727	}
	728
	729	static void unregWinClasses()
	730	{
	731	if ( !winclassNames )
	732	return;
	733	// there is no need to unregister private window classes -- it is done
	734	// automatically upon process termination.
	735	delete winclassNames;
	736	winclassNames = 0;
	737	}
	738
	739
	740	/*****************************************************************************
	741	Platform specific QApplication members
	742	*****************************************************************************/
	743
	744	void QApplication::setMainWidget( QWidget *mainWidget )
	745	{
	746	main_widget = mainWidget;
	747	}
	748
	749	//@@TODO (dmik): later (os/2 version?)
	750	//Qt::WindowsVersion QApplication::winVersion()
	751	//{
	752	// return qt_winver;
	753	//}
	754
	755	#ifndef QT_NO_CURSOR
	756
	757	/*****************************************************************************
	758	QApplication cursor stack
	759	*****************************************************************************/
	760
	761	typedef QPtrList<QCursor> QCursorList;
	762
	763	static QCursorList *cursorStack = 0;
	764
	765	void QApplication::setOverrideCursor( const QCursor &cursor, bool replace )
	766	{
	767	if ( !cursorStack ) {
	768	cursorStack = new QCursorList;
	769	Q_CHECK_PTR( cursorStack );
	770	cursorStack->setAutoDelete( TRUE );
	771	}
	772	app_cursor = new QCursor( cursor );
	773	Q_CHECK_PTR( app_cursor );
	774	if ( replace )
	775	cursorStack->removeLast();
	776	cursorStack->append( app_cursor );
	777	WinSetPointer( HWND_DESKTOP, app_cursor->handle() );
	778	}
	779
	780	void QApplication::restoreOverrideCursor()
	781	{
	782	if ( !cursorStack ) // no cursor stack
	783	return;
	784	cursorStack->removeLast();
	785	app_cursor = cursorStack->last();
	786	if ( app_cursor ) {
	787	WinSetPointer( HWND_DESKTOP, app_cursor->handle() );
	788	} else {
	789	delete cursorStack;
	790	cursorStack = 0;
	791	QWidget *w = QWidget::find( curWin );
	792	if ( w )
	793	WinSetPointer( HWND_DESKTOP, w->cursor().handle() );
	794	else
	795	WinSetPointer( HWND_DESKTOP, arrowCursor.handle() );
	796	}
	797	}
	798
	799	#endif
	800
	801	/*
	802	Internal function called from QWidget::setCursor()
	803	*/
	804
	805	void qt_set_cursor( QWidget w, const QCursor& / c */)
	806	{
	807	if ( !curWin )
	808	return;
	809	QWidget* cW = QWidget::find( curWin );
	810	if ( !cW \|\| cW->topLevelWidget() != w->topLevelWidget() \|\|
	811	!cW->isVisible() \|\| !cW->hasMouse() \|\| cursorStack )
	812	return;
	813
	814	WinSetPointer( HWND_DESKTOP, cW->cursor().handle() );
	815	}
	816
	817
	818	void QApplication::setGlobalMouseTracking( bool enable )
	819	{
	820	bool tellAllWidgets;
	821	if ( enable ) {
	822	tellAllWidgets = (++app_tracking == 1);
	823	} else {
	824	tellAllWidgets = (--app_tracking == 0);
	825	}
	826	if ( tellAllWidgets ) {
	827	QWidgetIntDictIt it( ((QWidgetIntDict)QWidget::mapper) );
	828	register QWidget *w;
	829	while ( (w=it.current()) ) {
	830	if ( app_tracking > 0 ) { // switch on
	831	if ( !w->testWState(WState_MouseTracking) ) {
	832	w->setMouseTracking( TRUE );
	833	}
	834	} else { // switch off
	835	if ( w->testWState(WState_MouseTracking) ) {
	836	w->setMouseTracking( FALSE );
	837	}
	838	}
	839	++it;
	840	}
	841	}
	842	}
	843
	844
	845	/*****************************************************************************
	846	Routines to find a Qt widget from a screen position
	847	*****************************************************************************/
	848
	849	static QWidget findChildWidget( const QWidget p, const QPoint &pos )
	850	{
	851	if ( p->children() ) {
	852	QWidget *w;
	853	QObjectListIt it( *p->children() );
	854	it.toLast();
	855	while ( it.current() ) {
	856	if ( it.current()->isWidgetType() ) {
	857	w = (QWidget*)it.current();
	858	if ( w->isVisible() && w->geometry().contains(pos) ) {
	859	QWidget *c = findChildWidget( w, w->mapFromParent(pos) );
	860	return c ? c : w;
	861	}
	862	}
	863	--it;
	864	}
	865	}
	866	return 0;
	867	}
	868
	869	QWidget *QApplication::widgetAt( int x, int y, bool child )
	870	{
	871	// flip y coordinate
	872	y = desktop()->height() - (y + 1);
	873	POINTL ptl = { x, y };
	874	HWND win = WinWindowFromPoint( HWND_DESKTOP, &ptl, child );
	875	if ( !win )
	876	return 0;
	877
	878	QWidget *w = QWidget::find( win );
	879	if( !w && !child )
	880	return 0;
	881	//@@TODO (dmik): can it ever happen that a child window is a not Qt window
	882	// but its (grand) parent is?
	883	while (
	884	!w && (win = WinQueryWindow( win, QW_PARENT )) != desktop()->winId()
	885	) {
	886	w = QWidget::find( win );
	887	}
	888	return w;
	889	}
	890
	891	void QApplication::beep()
	892	{
	893	WinAlarm( HWND_DESKTOP, WA_WARNING );
	894	}
	895
	896	/*****************************************************************************
	897	OS/2-specific drawing used here
	898	*****************************************************************************/
	899
	900	static void drawTile( HPS hps, int x, int y, int w, int h,
	901	const QPixmap *pixmap, int xOffset, int yOffset, int devh )
	902	{
	903	int yPos, xPos, drawH, drawW, yOff, xOff;
	904	yPos = y;
	905	yOff = yOffset;
	906	while( yPos < y + h ) {
	907	drawH = pixmap->height() - yOff; // Cropping first row
	908	if ( yPos + drawH > y + h ) // Cropping last row
	909	drawH = y + h - yPos;
	910	xPos = x;
	911	xOff = xOffset;
	912	while( xPos < x + w ) {
	913	drawW = pixmap->width() - xOff; // Cropping first column
	914	if ( xPos + drawW > x + w ) // Cropping last column
	915	drawW = x + w - xPos;
	916	//@@TODO (dmik): optimize: flip y only once and change loops accodringly
	917	// flip y coordinates
	918	POINTL ptls[] = {
	919	{ xPos, yPos }, { xPos + drawW, drawH },
	920	{ xOff, pixmap->height() - (yOff + drawH) }
	921	};
	922	if ( devh ) ptls[0].y = devh - (ptls[0].y + drawH);
	923	ptls[1].y += ptls[0].y;
	924	GpiBitBlt( hps, pixmap->handle(), 3, ptls, ROP_SRCCOPY, BBO_IGNORE );
	925	xPos += drawW;
	926	xOff = 0;
	927	}
	928	yPos += drawH;
	929	yOff = 0;
	930	}
	931	}
	932
	933	//@@TODO (dmik): implement as fill pattern?
	934	// masks and transforms are not used here.
	935	Q_EXPORT
	936	void qt_fill_tile( QPixmap *tile, const QPixmap &pixmap )
	937	{
	938	copyBlt( tile, 0, 0, &pixmap, 0, 0, -1, -1);
	939	int x = pixmap.width();
	940	while ( x < tile->width() ) {
	941	copyBlt( tile, x, 0, tile, 0, 0, x, pixmap.height() );
	942	x *= 2;
	943	}
	944	int y = pixmap.height();
	945	while ( y < tile->height() ) {
	946	copyBlt( tile, 0, y, tile, 0, 0, tile->width(), y );
	947	y *= 2;
	948	}
	949	}
	950
	951	//@@TODO (dmik): implement as fill pattern?
	952	// masks and transforms are not used here.
	953	Q_EXPORT
	954	void qt_draw_tiled_pixmap( HPS hps, int x, int y, int w, int h,
	955	const QPixmap *bg_pixmap,
	956	int off_x, int off_y, int devh )
	957	{
	958	QPixmap *tile = 0;
	959	QPixmap *pm;
	960	int sw = bg_pixmap->width(), sh = bg_pixmap->height();
	961	if ( swsh < 8192 && swsh < 16wh ) {
	962	int tw = sw, th = sh;
	963	while ( tw*th < 32678 && tw < w/2 )
	964	tw *= 2;
	965	while ( tw*th < 32678 && th < h/2 )
	966	th *= 2;
	967	tile = new QPixmap( tw, th, bg_pixmap->depth(),
	968	QPixmap::NormalOptim );
	969	qt_fill_tile( tile, *bg_pixmap );
	970	pm = tile;
	971	} else {
	972	pm = (QPixmap*)bg_pixmap;
	973	}
	974	drawTile( hps, x, y, w, h, pm, off_x, off_y, devh );
	975	if ( tile )
	976	delete tile;
	977	}
	978
	979
	980
	981	/*****************************************************************************
	982	Main event loop
	983	*****************************************************************************/
	984
	985	extern uint qGlobalPostedEventsCount();
	986
[97]	987	#ifndef QT_NO_DRAGANDDROP
	988	extern MRESULT qt_dispatchDragAndDrop( QWidget *, const QMSG & ); // qdnd_pm.cpp
	989	#endif
	990
[8]	991	/*!
	992	The message procedure calls this function for every message
	993	received. Reimplement this function if you want to process window
	994	messages \e msg that are not processed by Qt. If you don't want
	995	the event to be processed by Qt, then return TRUE; otherwise
	996	return FALSE.
	997	*/
	998	bool QApplication::pmEventFilter( QMSG * /msg/ ) // OS/2 PM event filter
	999	{
	1000	return FALSE;
	1001	}
	1002
	1003	/*!
	1004	If \a gotFocus is TRUE, \a widget will become the active window.
	1005	Otherwise the active window is reset to NULL.
	1006	*/
	1007	void QApplication::pmFocus( QWidget *widget, bool gotFocus )
	1008	{
	1009	if ( gotFocus ) {
	1010	setActiveWindow( widget );
	1011	if ( active_window && active_window->testWFlags( WType_Dialog ) ) {
	1012	// raise the entire application, not just the dialog
	1013	QWidget* mw = active_window;
	1014	while( mw->parentWidget() && mw->testWFlags( WType_Dialog) )
	1015	mw = mw->parentWidget()->topLevelWidget();
	1016	if ( mw != active_window )
	1017	WinSetWindowPos( mw->winFId(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER );
	1018	}
	1019	} else {
	1020	setActiveWindow( 0 );
	1021	}
	1022	}
	1023
	1024	//
	1025	// QtWndProc() receives all messages from the main event loop
	1026	//
	1027
	1028	enum {
[110]	1029	// some undocumented messages (they have the WM_U_ prefix for clarity)
[174]	1030
[64]	1031	// sent to hwnd that has been entered to by a mouse pointer.
[8]	1032	// FID_CLIENT also receives enter messages of its WC_FRAME.
	1033	// mp1 = hwnd that is entered, mp2 = hwnd that is left
	1034	WM_U_MOUSEENTER = 0x41E,
[64]	1035	// sent to hwnd that has been left by a mouse pointer.
[8]	1036	// FID_CLIENT also receives leave messages of its WC_FRAME.
	1037	// mp1 = hwnd that is left, mp2 = hwnd that is entered
	1038	WM_U_MOUSELEAVE = 0x41F,
[110]	1039
	1040	// some undocumented system values
	1041
[169]	1042	SV_WORKAREA_YTOP = 51,
	1043	SV_WORKAREA_YBOTTOM = 52,
	1044	SV_WORKAREA_XRIGHT = 53,
[110]	1045	SV_WORKAREA_XLEFT = 54,
[8]	1046	};
	1047
	1048	static bool inLoop = FALSE;
	1049
	1050	#define RETURN(x) { inLoop = FALSE; return (MRESULT) (x); }
	1051
	1052	inline bool qt_sendSpontaneousEvent( QObject receiver, QEvent event )
	1053	{
	1054	return QApplication::sendSpontaneousEvent( receiver, event );
	1055	}
	1056
	1057	extern "C" MRESULT EXPENTRY QtWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
	1058	{
	1059	// message handling indicators: if result is true at the end of message
	1060	// processing, no default window proc is called but rc is returned.
	1061	bool result = TRUE;
	1062	MRESULT rc = (MRESULT) 0;
	1063
	1064	QEvent::Type evt_type = QEvent::None;
	1065	QETWidget *widget = 0;
	1066	bool isMouseEvent = FALSE;
	1067
	1068	if ( !qApp ) // unstable app state
	1069	goto do_default;
	1070
	1071	// make sure we show widgets (e.g. scrollbars) when the user resizes
	1072	if ( inLoop && qApp->loopLevel() )
	1073	qApp->sendPostedEvents( 0, QEvent::ShowWindowRequest );
	1074
	1075	inLoop = TRUE;
	1076
	1077	isMouseEvent =
	1078	(msg >= WM_MOUSEFIRST && msg <= WM_MOUSELAST) \|\|
	1079	(msg >= WM_EXTMOUSEFIRST && msg <= WM_EXTMOUSELAST);
	1080	//@@TODO (dmik): later (extra buttons)
	1081	// (message >= WM_XBUTTONDOWN && message <= WM_XBUTTONDBLCLK)
	1082
	1083	QMSG qmsg; // create QMSG structure
	1084	qmsg.hwnd = hwnd;
	1085	qmsg.msg = msg;
	1086	qmsg.mp1 = mp1;
	1087	qmsg.mp2 = mp2;
	1088	qmsg.time = WinQueryMsgTime( 0 );
	1089	if ( isMouseEvent \|\| msg == WM_CONTEXTMENU ) {
	1090	qmsg.ptl.x = (short)SHORT1FROMMP(mp1);
	1091	qmsg.ptl.y = (short)SHORT2FROMMP(mp1);
	1092	WinMapWindowPoints( qmsg.hwnd, HWND_DESKTOP, &qmsg.ptl, 1 );
	1093	} else {
	1094	WinQueryMsgPos( 0, &qmsg.ptl );
	1095	}
	1096	// flip y coordinate
	1097	qmsg.ptl.y = QApplication::desktop()->height() - (qmsg.ptl.y + 1);
	1098
	1099	if ( qt_pmEventFilter( &qmsg, rc ) ) // send through app filter
	1100	RETURN( rc );
	1101
	1102	switch ( msg ) {
[77]	1103	#if !defined (QT_NO_SESSIONMANAGER)
	1104	case WM_SAVEAPPLICATION: {
[78]	1105	#if defined (DEBUG_SESSIONMANAGER)
[77]	1106	qDebug( "WM_SAVEAPPLICATION: sm_gracefulShutdown=%d "
[78]	1107	"qt_about_to_destroy_wnd=%d (mp1=%p mp2=%p)",
	1108	sm_gracefulShutdown, qt_about_to_destroy_wnd,
	1109	mp1, mp2 );
	1110	#endif
[77]	1111	// PM seems to post this message to all top-level windows on system
	1112	// shutdown, so react only to the first one. Also, this message is
	1113	// always sent by WinDestroyWindow(), where it must be also ignored.
[78]	1114	if ( !qt_about_to_destroy_wnd && !sm_smActive &&
	1115	!sm_gracefulShutdown ) {
	1116	sm_smActive = TRUE;
[77]	1117	sm_gracefulShutdown = TRUE;
[78]	1118	sm_blockUserInput = TRUE; // prevent user-interaction outside interaction windows
	1119	sm_cancel = FALSE;
	1120	sm_quitSkipped = FALSE;
	1121	if ( qt_session_manager_self )
	1122	qApp->commitData( *qt_session_manager_self );
	1123	sm_smActive = FALSE; // session management has been finished
	1124	if ( sm_cancel ) {
	1125	// Here we try to cancel the Extended XWorkplace shutdown.
	1126	// If it's XWorkplace who sent us WM_SAVEAPPLICATION, then
	1127	// it probably passed us non-NULL parameters, so that
	1128	// mp1 = it's window handle and mp2 = WM_COMMAND code to
	1129	// cancel the shutdown procedure.
	1130	HWND shutdownHwnd = HWNDFROMMP(mp1);
	1131	if ( WinIsWindow( 0, shutdownHwnd ) ) {
	1132	WinPostMsg( shutdownHwnd, WM_COMMAND, mp2, 0 );
	1133	// Ensure we will get WM_QUIT anyway, even if xwp was
	1134	// not that fast to post it yet (we need it to correctly
	1135	// finish the graceful shutdown procedure)
	1136	sm_quitSkipped = TRUE;
	1137	}
	1138	}
	1139	// repost WM_QUIT to ourselves because we might have ignored
	1140	// it in qt_app_canQuit(), so will not get one anymore
	1141	if ( sm_quitSkipped )
	1142	WinPostMsg( hwnd, WM_QUIT, 0, 0 );
[77]	1143	}
	1144	// PMREF recommends to pass it to WinDefWindowProc()
	1145	rc = WinDefWindowProc( hwnd, msg, mp1, mp2 );
	1146	RETURN( rc );
	1147	}
	1148	#endif
[78]	1149
[110]	1150	case WM_SYSVALUECHANGED: {
	1151	// This message is sent to all top-level widgets, handle only once
	1152	QWidgetList *list = QApplication::topLevelWidgets();
	1153	bool firstWidget = list->first()->winId() == hwnd;
	1154	delete list;
	1155	if ( !firstWidget )
	1156	break;
	1157	LONG from = (LONG) mp1;
	1158	LONG to = (LONG) mp2;
	1159	#define _IS_SV(sv) (from >= (sv) && to <= (sv))
	1160	if ( _IS_SV( SV_WORKAREA_XLEFT ) \|\| _IS_SV( SV_WORKAREA_XRIGHT ) \|\|
	1161	_IS_SV( SV_WORKAREA_YBOTTOM ) \|\| _IS_SV( SV_WORKAREA_YTOP ) ) {
	1162	// send a special invalid resize event to QDesktopWidget
	1163	QResizeEvent re( QSize( -1, -1 ), QSize( -1, -1 ) );
	1164	QApplication::sendEvent( qt_desktopWidget, &re );
	1165	/// @todo (dmik) enumerate all top-level widgets and
	1166	// remaximize those that are maximized
	1167	} else {
	1168	/// @todo (dmik) call qt_set_pm_resources() in the way it is
	1169	// done in WM_SYSCOLORCHANGE for relevant SV_ values.
	1170	}
	1171	#undef _IS_SV
	1172	break;
	1173	}
[8]	1174
[110]	1175	case WM_SYSCOLORCHANGE: {
	1176	// This message is sent to all top-level widgets, handle only once
	1177	QWidgetList *list = QApplication::topLevelWidgets();
	1178	bool firstWidget = list->first()->winId() == hwnd;
	1179	delete list;
	1180	if ( !firstWidget )
	1181	break;
	1182	if ( qApp->type() == QApplication::Tty )
	1183	break;
	1184	if ( QApplication::desktopSettingsAware() ) {
	1185	widget = (QETWidget*)QWidget::find( hwnd );
	1186	if ( widget && !widget->parentWidget() )
	1187	qt_set_pm_resources();
	1188	}
	1189	break;
	1190	}
	1191
[8]	1192	case WM_BUTTON1DOWN:
	1193	case WM_BUTTON2DOWN:
	1194	case WM_BUTTON3DOWN:
	1195	if ( ignoreNextMouseReleaseEvent )
	1196	ignoreNextMouseReleaseEvent = FALSE;
	1197	break;
	1198	case WM_BUTTON1UP:
	1199	case WM_BUTTON2UP:
	1200	case WM_BUTTON3UP:
	1201	if ( ignoreNextMouseReleaseEvent ) {
	1202	ignoreNextMouseReleaseEvent = FALSE;
	1203	if ( qt_button_down && qt_button_down->winId() == autoCaptureWnd ) {
	1204	releaseAutoCapture();
	1205	qt_button_down = 0;
	1206	}
	1207	RETURN( TRUE );
	1208	}
	1209	break;
	1210
	1211	default:
	1212	break;
	1213	}
	1214
	1215	if ( !widget )
	1216	widget = (QETWidget*)QWidget::find( hwnd );
	1217	if ( !widget ) // don't know this widget
	1218	goto do_default;
	1219
	1220	if ( app_do_modal ) { // modal event handling
	1221	int ret = 0;
	1222	if ( !qt_try_modal( widget, &qmsg, ret ) )
	1223	return MRESULT( ret );
	1224	}
	1225
[171]	1226	// send through widget filter
	1227	// (WM_CHAR will be handled later)
	1228	if ( msg != WM_CHAR )
	1229	if ( widget->pmEvent( &qmsg ) )
	1230	RETURN( TRUE );
[8]	1231
	1232	if ( isMouseEvent ) { // mouse events
[171]	1233	if ( qApp->activePopupWidget() != 0 ) { // in popup mode
	1234	QWidget* w = QApplication::widgetAt( qmsg.ptl.x, qmsg.ptl.y, TRUE );
	1235	if ( w ) {
[52]	1236	POINTL ptl = { SHORT1FROMMP(qmsg.mp1), SHORT2FROMMP(qmsg.mp1) };
	1237	WinMapWindowPoints( qmsg.hwnd, w->winId(), &ptl, 1 );
	1238	qmsg.mp1 = MPFROM2SHORT( ptl.x, ptl.y );
[171]	1239	widget = (QETWidget*)w;
[52]	1240	}
[171]	1241	}
[8]	1242	result = widget->translateMouseEvent( qmsg );
	1243	rc = (MRESULT) result;
	1244	#ifndef QT_NO_WHEELEVENT
	1245	} else if ( msg == WM_VSCROLL \|\| msg == WM_HSCROLL ) {
[171]	1246	result = widget->translateWheelEvent( qmsg );
[8]	1247	rc = (MRESULT) result;
	1248	#endif
[97]	1249	#ifndef QT_NO_DRAGANDDROP
	1250	} else if ( msg >= WM_DRAGFIRST && msg <= WM_DRAGLAST ) {
	1251	RETURN( qt_dispatchDragAndDrop( widget, qmsg ) );
	1252	#endif
[8]	1253	} else {
[171]	1254	switch ( msg ) {
	1255
[8]	1256	case WM_TRANSLATEACCEL:
	1257	if ( widget->isTopLevel() ) {
	1258	rc = WinDefWindowProc( hwnd, msg, mp1, mp2 );
	1259	if ( rc ) {
	1260	QMSG &qmsg = (QMSG) mp1;
	1261	if (
	1262	qmsg.msg == WM_SYSCOMMAND &&
	1263	WinWindowFromID( widget->winFId(), FID_SYSMENU )
	1264	) {
	1265	switch ( SHORT1FROMMP(qmsg.mp1) ) {
	1266	case SC_CLOSE:
	1267	case SC_TASKMANAGER:
	1268	RETURN( TRUE );
	1269	default:
	1270	break;
	1271	}
	1272	}
	1273	}
	1274	}
	1275	// return FALSE in all other cases to let Qt process keystrokes
	1276	// that are in the system-wide frame accelerator table.
	1277	RETURN( FALSE );
	1278
	1279	case WM_CHAR: { // keyboard event
[106]	1280	#if 0
	1281	qDebug( "WM_CHAR: [%s]", widget->name() );
[169]	1282	#endif
[8]	1283	QWidget *g = QWidget::keyboardGrabber();
	1284	if ( g )
	1285	widget = (QETWidget*)g;
	1286	else if ( qApp->focusWidget() )
	1287	widget = (QETWidget*)qApp->focusWidget();
	1288	else if ( !widget )
[106]	1289	/// @todo (dmik) currently we don't use WinSetFocus(). what for? Qt seems
[8]	1290	// to completely handle focus traversal itself.
	1291	// \|\| widget->winId() == WinQueryFocus( HWND_DESKTOP ) ) // We faked the message to go to exactly that widget.
	1292	widget = (QETWidget*)widget->topLevelWidget();
[171]	1293
	1294	if ( widget->pmEvent( &qmsg ) )
	1295	RETURN( TRUE );
	1296
[8]	1297	if ( widget->isEnabled() ) {
[106]	1298	/// @todo (dmik) we should not pass WM_CHAR to the default window proc,
[8]	1299	// otherwise it will come to us again through the widget parent (owner in PM)
	1300	// if the widget is not top-level, and will be treated by translateKeyEvent()
	1301	// as a key repeat (in case of key down) or a lost key (in case of key up).
	1302	// NOTE: currently we don't use WinSetFocus(), so the active top-level window
	1303	// will always have the focus, so it doesn't matter wheither we pass WM_CHAR
	1304	// to the default window proc or not.
	1305	// result = widget->translateKeyEvent( qmsg, g != 0 );
	1306	// rc = (MRESULT) result;
	1307	RETURN( widget->translateKeyEvent( qmsg, g != 0 ) );
	1308	}
	1309	break;
	1310	}
	1311
[169]	1312	case WM_QUERYCONVERTPOS :
	1313	{
	1314	// Ooops, how to get caret pos ?
	1315	/// @todo (r=dmik) we should make usage of the QIMEvent
	1316	// to query widgets about IME data (see how/where this event
	1317	// is used across the sources)
	1318
	1319	PRECTL pcp = ( PRECTL )mp1;
	1320	CURSORINFO ci;
	1321
	1322	WinQueryCursorInfo( HWND_DESKTOP, &ci );
	1323
	1324	memset( pcp, 0xFF, sizeof( RECTL ));
	1325
	1326	pcp->xLeft = ci.x;
	1327	pcp->yBottom = ci.y;
	1328	WinMapWindowPoints( ci.hwnd, hwnd, ( PPOINTL )pcp, 2 );
	1329
	1330	RETURN( QCP_CONVERT );
	1331	}
	1332
[106]	1333	/// @todo (dmik) later
[8]	1334	// case WM_APPCOMMAND:
	1335	// {
	1336	// uint cmd = GET_APPCOMMAND_LPARAM(lParam);
	1337	// uint uDevice = GET_DEVICE_LPARAM(lParam);
	1338	// uint dwKeys = GET_KEYSTATE_LPARAM(lParam);
	1339	//
	1340	// int state = translateButtonState( dwKeys, QEvent::KeyPress, 0 );
	1341	//
	1342	// switch ( uDevice ) {
	1343	// case FAPPCOMMAND_KEY:
	1344	// {
	1345	// int key = 0;
	1346	//
	1347	// switch( cmd ) {
	1348	// case APPCOMMAND_BASS_BOOST:
	1349	// key = Qt::Key_BassBoost;
	1350	// break;
	1351	// case APPCOMMAND_BASS_DOWN:
	1352	// key = Qt::Key_BassDown;
	1353	// break;
	1354	// case APPCOMMAND_BASS_UP:
	1355	// key = Qt::Key_BassUp;
	1356	// break;
	1357	// case APPCOMMAND_BROWSER_BACKWARD:
	1358	// key = Qt::Key_Back;
	1359	// break;
	1360	// case APPCOMMAND_BROWSER_FAVORITES:
	1361	// key = Qt::Key_Favorites;
	1362	// break;
	1363	// case APPCOMMAND_BROWSER_FORWARD:
	1364	// key = Qt::Key_Forward;
	1365	// break;
	1366	// case APPCOMMAND_BROWSER_HOME:
	1367	// key = Qt::Key_HomePage;
	1368	// break;
	1369	// case APPCOMMAND_BROWSER_REFRESH:
	1370	// key = Qt::Key_Refresh;
	1371	// break;
	1372	// case APPCOMMAND_BROWSER_SEARCH:
	1373	// key = Qt::Key_Search;
	1374	// break;
	1375	// case APPCOMMAND_BROWSER_STOP:
	1376	// key = Qt::Key_Stop;
	1377	// break;
	1378	// case APPCOMMAND_LAUNCH_APP1:
	1379	// key = Qt::Key_Launch0;
	1380	// break;
	1381	// case APPCOMMAND_LAUNCH_APP2:
	1382	// key = Qt::Key_Launch1;
	1383	// break;
	1384	// case APPCOMMAND_LAUNCH_MAIL:
	1385	// key = Qt::Key_LaunchMail;
	1386	// break;
	1387	// case APPCOMMAND_LAUNCH_MEDIA_SELECT:
	1388	// key = Qt::Key_LaunchMedia;
	1389	// break;
	1390	// case APPCOMMAND_MEDIA_NEXTTRACK:
	1391	// key = Qt::Key_MediaNext;
	1392	// break;
	1393	// case APPCOMMAND_MEDIA_PLAY_PAUSE:
	1394	// key = Qt::Key_MediaPlay;
	1395	// break;
	1396	// case APPCOMMAND_MEDIA_PREVIOUSTRACK:
	1397	// key = Qt::Key_MediaPrev;
	1398	// break;
	1399	// case APPCOMMAND_MEDIA_STOP:
	1400	// key = Qt::Key_MediaStop;
	1401	// break;
	1402	// case APPCOMMAND_TREBLE_DOWN:
	1403	// key = Qt::Key_TrebleDown;
	1404	// break;
	1405	// case APPCOMMAND_TREBLE_UP:
	1406	// key = Qt::Key_TrebleUp;
	1407	// break;
	1408	// case APPCOMMAND_VOLUME_DOWN:
	1409	// key = Qt::Key_VolumeDown;
	1410	// break;
	1411	// case APPCOMMAND_VOLUME_MUTE:
	1412	// key = Qt::Key_VolumeMute;
	1413	// break;
	1414	// case APPCOMMAND_VOLUME_UP:
	1415	// key = Qt::Key_VolumeUp;
	1416	// break;
	1417	// default:
	1418	// break;
	1419	// }
	1420	// if ( key ) {
	1421	// bool res = FALSE;
	1422	// QWidget *g = QWidget::keyboardGrabber();
	1423	// if ( g )
	1424	// widget = (QETWidget*)g;
	1425	// else if ( qApp->focusWidget() )
	1426	// widget = (QETWidget*)qApp->focusWidget();
	1427	// else
	1428	// widget = (QETWidget*)widget->topLevelWidget();
	1429	// if ( widget->isEnabled() )
	1430	// res = ((QETWidget*)widget)->sendKeyEvent( QEvent::KeyPress, key, 0, state, FALSE, QString::null, g != 0 );
	1431	// if ( res )
	1432	// return TRUE;
	1433	// }
	1434	// }
	1435	// break;
	1436	//
	1437	// default:
	1438	// break;
	1439	// }
	1440	//
	1441	// result = FALSE;
	1442	// }
	1443	// break;
	1444
	1445	//@@TODO (dmik):
	1446	// we can cause WC_FRAME to send equivalents of WM_NCMOUSEMOVE,
	1447	// but is it really necesary? We already do some similar stuff in WM_HITTEST
	1448	//#ifndef Q_OS_TEMP
	1449	// case WM_NCMOUSEMOVE:
	1450	// {
	1451	// // span the application wide cursor over the
	1452	// // non-client area.
	1453	// QCursor *c = qt_grab_cursor();
	1454	// if ( !c )
	1455	// c = QApplication::overrideCursor();
	1456	// if ( c ) // application cursor defined
	1457	// SetCursor( c->handle() );
	1458	// else
	1459	// result = FALSE;
	1460	// // generate leave event also when the caret enters
	1461	// // the non-client area.
	1462	// qt_dispatchEnterLeave( 0, QWidget::find(curWin) );
	1463	// curWin = 0;
	1464	// }
	1465	// break;
	1466	//#endif
	1467
[115]	1468	/// @todo (dmik) later (WM_KBDLAYERCHANGED (0xBD4)?)
[8]	1469	// case WM_SETTINGCHANGE:
	1470	// if ( !msg.wParam ) {
	1471	// QString area = QT_WA_INLINE( QString::fromUcs2( (unsigned short *)msg.lParam ),
	1472	// QString::fromLocal8Bit( (char*)msg.lParam ) );
	1473	// if ( area == "intl" )
	1474	// QApplication::postEvent( widget, new QEvent( QEvent::LocaleChange ) );
	1475	// }
	1476	// break;
	1477	//
	1478	case WM_PAINT: // paint event
	1479	result = widget->translatePaintEvent( qmsg );
	1480	break;
	1481	case WM_ERASEBACKGROUND: // erase window background
	1482	// flush WM_PAINT messages here to update window contents
	1483	// instantly while tracking the resize frame (normally these
	1484	// messages are delivered after the user has stopped resizing
	1485	// for some time). this slows down resizing slightly but gives a
	1486	// better look (no invalid window contents can be seen during
	1487	// resize). the alternative could be to erase the background only,
	1488	// but we need to do it for every non-toplevel window, which can
	1489	// also be time-consuming (WM_ERASEBACKGROUND is sent to WC_FRAME
	1490	// clients only, so we would have to do all calculations ourselves).
	1491	WinUpdateWindow( widget->winId() );
	1492	RETURN( FALSE );
	1493	break;
	1494	case WM_CALCVALIDRECTS:
	1495	// we must always return this value here to cause PM to reposition
	1496	// our children accordingly (othwerwise we would have to do it
	1497	// ourselves to keep them top-left aligned).
	1498	RETURN( CVR_ALIGNLEFT \| CVR_ALIGNTOP );
	1499	break;
	1500
	1501	case WM_MOVE: // move window
	1502	case WM_SIZE: // resize window
	1503	result = widget->translateConfigEvent( qmsg );
	1504	break;
	1505
	1506	case WM_ACTIVATE:
[61]	1507	#if 0
	1508	qDebug( "WM_ACTIVATE: [%s] %d", widget->name(), SHORT1FROMMP(mp1) );
[78]	1509	#endif
[8]	1510	qApp->pmFocus( widget, SHORT1FROMMP(mp1) );
	1511	break;
	1512
	1513	case WM_SETFOCUS:
[78]	1514	#if 0
[61]	1515	qDebug( "WM_SETFOCUS: [%s] %s [%s]", widget->name(),
	1516	SHORT1FROMMP(mp2) ? "<=" : "=>",
	1517	QWidget::find( (HWND)mp1 ) ? QWidget::find( (HWND)mp1 )->name()
	1518	: "{foreign}" );
[78]	1519	#endif
[8]	1520	result = FALSE;
	1521	if ( !SHORT1FROMMP(mp2) ) {
	1522	// we're losing focus
	1523	if ( !QWidget::find( (HWND)mp1 ) ) {
	1524	if ( QApplication::activePopupWidget() ) {
	1525	// Another application was activated while our popups are open,
	1526	// then close all popups. In case some popup refuses to close,
	1527	// we give up after 1024 attempts (to avoid an infinite loop).
	1528	int maxiter = 1024;
	1529	QWidget *popup;
	1530	while ( (popup=QApplication::activePopupWidget()) && maxiter-- )
	1531	popup->close();
	1532	}
	1533	if (
	1534	// non-Qt ownees of our WC_FRAME window (such as
	1535	// FID_SYSMENU) should not cause the focus to be lost.
	1536	WinQueryWindow( (HWND)mp1, QW_OWNER ) ==
	1537	widget->topLevelWidget()->winFId()
	1538	)
	1539	break;
	1540	if ( !widget->isTopLevel() )
	1541	qApp->pmFocus( widget, SHORT1FROMMP(mp2) );
	1542	}
	1543	}
	1544	break;
	1545
[61]	1546	/// @todo (dmik) remove?
[8]	1547	//#ifndef Q_OS_TEMP
	1548	// case WM_MOUSEACTIVATE:
	1549	// {
	1550	// const QWidget *tlw = widget->topLevelWidget();
	1551	// // Do not change activation if the clicked widget is inside a floating dock window
	1552	// if ( tlw->inherits( "QDockWindow" ) && qApp->activeWindow()
	1553	// && !qApp->activeWindow()->inherits("QDockWindow") )
	1554	// RETURN(MA_NOACTIVATE);
	1555	// }
	1556	// result = FALSE;
	1557	// break;
	1558	//#endif
	1559
	1560	case WM_SHOW:
	1561	if ( !SHORT1FROMMP(mp1) && autoCaptureWnd == widget->winId() )
	1562	releaseAutoCapture();
	1563	result = FALSE;
	1564	break;
[61]	1565	/// @todo (dmik) remove later
[8]	1566	// case WM_SHOWWINDOW:
	1567	//#ifndef Q_OS_TEMP
	1568	// if ( lParam == SW_PARENTOPENING ) {
	1569	// if ( widget->testWState(Qt::WState_ForceHide) )
	1570	// RETURN(0);
	1571	// }
	1572	//#endif
	1573	// if (!wParam && autoCaptureWnd == widget->winId())
	1574	// releaseAutoCapture();
	1575	// result = FALSE;
	1576	// break;
	1577
	1578	case WM_REALIZEPALETTE: // realize own palette
	1579	if ( QColor::hPal() ) {
	1580	HPS hps = WinGetPS( widget->winId() );
	1581	GpiSelectPalette( hps, QColor::hPal() );
	1582	ULONG cclr;
	1583	WinRealizePalette( widget->winId(), hps, &cclr );
	1584	WinReleasePS( hps );
	1585	// on OS/2, the value returned by WinRealizePalette() does not
	1586	// necessarily reflect the number of colors that have been
	1587	// remapped. therefore, we cannot rely on it and must always
	1588	// invalidate the window.
	1589	WinInvalidateRect( widget->winId(), NULL, TRUE );
	1590	RETURN( 0 );
	1591	}
	1592	break;
	1593
	1594	case WM_CLOSE: // close window
	1595	widget->translateCloseEvent( qmsg );
	1596	RETURN(0); // always handled
	1597
[61]	1598	/// @todo (dmik) it seems we don't need this
[8]	1599	// case WM_DESTROY: // destroy window
	1600	// if ( hwnd == curWin ) {
	1601	// QEvent leave( QEvent::Leave );
	1602	// QApplication::sendEvent( widget, &leave );
	1603	// curWin = 0;
	1604	// }
	1605	// // We are blown away when our parent reparents, so we have to
	1606	// // recreate the handle
	1607	// if (widget->testWState(Qt::WState_Created))
	1608	// ((QETWidget*)widget)->reparentWorkaround();
	1609	// if ( widget == popupButtonFocus )
	1610	// popupButtonFocus = 0;
	1611	// result = FALSE;
	1612	// break;
	1613
	1614	case WM_CONTEXTMENU:
	1615	if ( SHORT2FROMMP(mp2) ) {
	1616	// keyboard event
	1617	QWidget *fw = qApp->focusWidget();
	1618	if ( fw ) {
	1619	QContextMenuEvent e(
	1620	QContextMenuEvent::Keyboard,
	1621	QPoint( 5, 5 ),
	1622	fw->mapToGlobal( QPoint( 5, 5 ) ),
	1623	0
	1624	);
	1625	result = qt_sendSpontaneousEvent( fw, &e );
	1626	rc = (MRESULT) result;
	1627	}
	1628	} else {
	1629	// mouse event
	1630	result = widget->translateMouseEvent( qmsg );
	1631	rc = (MRESULT) result;
	1632	}
	1633	break;
	1634
[97]	1635	/// @todo (dmik) remove?
[8]	1636	// case WM_IME_STARTCOMPOSITION:
	1637	// result = QInputContext::startComposition();
	1638	// break;
	1639	// case WM_IME_ENDCOMPOSITION:
	1640	// result = QInputContext::endComposition();
	1641	// break;
	1642	// case WM_IME_COMPOSITION:
	1643	// result = QInputContext::composition( lParam );
	1644	// break;
	1645
	1646	#ifndef QT_NO_CLIPBOARD
	1647	case WM_DRAWCLIPBOARD:
	1648	case WM_RENDERFMT:
	1649	case WM_RENDERALLFMTS:
	1650	case WM_DESTROYCLIPBOARD:
	1651	if ( qt_clipboard ) {
	1652	QCustomEvent e( QEvent::Clipboard, &qmsg );
	1653	qt_sendSpontaneousEvent( qt_clipboard, &e );
	1654	RETURN(0);
	1655	}
	1656	result = FALSE;
	1657	break;
	1658	#endif
	1659
[77]	1660	/// @todo (dmik) remove? functionality is implemented in WM_SETFOCUS above.
[8]	1661	// case WM_KILLFOCUS:
	1662	// if ( !QWidget::find( (HWND)wParam ) ) { // we don't get focus, so unset it now
	1663	// if ( !widget->hasFocus() ) // work around Windows bug after minimizing/restoring
	1664	// widget = (QETWidget*)qApp->focusWidget();
	1665	// HWND focus = ::GetFocus();
	1666	// if ( !widget \|\| (focus && ::IsChild( widget->winId(), focus )) ) {
	1667	// result = FALSE;
	1668	// } else {
	1669	// widget->clearFocus();
	1670	// result = TRUE;
	1671	// }
	1672	// } else {
	1673	// result = FALSE;
	1674	// }
	1675	// break;
	1676
	1677	//@@TODO (dmik): later
	1678	// case WM_THEMECHANGED:
	1679	// if ( widget->testWFlags( Qt::WType_Desktop ) \|\| !qApp \|\| qApp->closingDown()
	1680	// \|\| qApp->type() == QApplication::Tty )
	1681	// break;
	1682	//
	1683	// if ( widget->testWState(Qt::WState_Polished) )
	1684	// qApp->style().unPolish(widget);
	1685	//
	1686	// if ( widget->testWState(Qt::WState_Polished) )
	1687	// qApp->style().polish(widget);
	1688	// widget->repolishStyle( qApp->style() );
	1689	// if ( widget->isVisible() )
	1690	// widget->update();
	1691	// break;
	1692	//
	1693	// case WM_COMMAND:
	1694	// result = (wParam == 0x1);
	1695	// if ( result )
	1696	// QApplication::postEvent( widget, new QEvent( QEvent::OkRequest ) );
	1697	// break;
	1698	// case WM_HELP:
	1699	// QApplication::postEvent( widget, new QEvent( QEvent::HelpRequest ) );
	1700	// result = TRUE;
	1701	// break;
	1702	//#endif
	1703
	1704	case WM_U_MOUSELEAVE:
	1705	// We receive a mouse leave for curWin, meaning
	1706	// the mouse was moved outside our widgets
	1707	if ( widget->winId() == curWin && (HWND) mp1 == curWin ) {
	1708	bool dispatch = !widget->hasMouse();
	1709	// hasMouse is updated when dispatching enter/leave,
	1710	// so test if it is actually up-to-date
	1711	if ( !dispatch ) {
	1712	QRect geom = widget->geometry();
	1713	if ( widget->parentWidget() && !widget->isTopLevel() ) {
	1714	QPoint gp = widget->parentWidget()->mapToGlobal( widget->pos() );
	1715	geom.setX( gp.x() );
	1716	geom.setY( gp.y() );
	1717	}
	1718	QPoint cpos = QCursor::pos();
	1719	dispatch = !geom.contains( cpos );
	1720	}
	1721	if ( dispatch ) {
	1722	qt_dispatchEnterLeave( 0, QWidget::find( (WId)curWin ) );
	1723	curWin = 0;
	1724	}
	1725	}
	1726	break;
	1727
[77]	1728	/// @todo (dmik) remove? functionality is implemented in WM_SETFOCUS above.
[8]	1729	// case WM_CANCELMODE:
	1730	// if ( qApp->focusWidget() ) {
	1731	// QFocusEvent::setReason( QFocusEvent::ActiveWindow );
	1732	// QFocusEvent e( QEvent::FocusOut );
	1733	// QApplication::sendEvent( qApp->focusWidget(), &e );
	1734	// QFocusEvent::resetReason();
	1735	// }
	1736	// break;
	1737
	1738	default:
	1739	result = FALSE; // event was not processed
	1740	break;
	1741	}
	1742	}
	1743
	1744	if ( evt_type != QEvent::None ) { // simple event
	1745	QEvent e( evt_type );
	1746	result = qt_sendSpontaneousEvent( widget, &e );
	1747	}
	1748	if ( result )
	1749	RETURN( rc );
	1750
	1751	do_default:
	1752	RETURN( WinDefWindowProc( hwnd, msg, mp1, mp2 ) );
[77]	1753	/// @todo (dmik) remove?
[8]	1754	// RETURN( QInputContext::DefWindowProc(hwnd,message,wParam,lParam) )
	1755	}
	1756
	1757	PFNWP QtOldFrameProc = 0;
	1758
	1759	extern "C" MRESULT EXPENTRY QtFrameProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
	1760	{
	1761	// message handling indicators: if result is true at the end of message
	1762	// processing, no default window proc is called but rc is returned.
	1763	bool result = FALSE;
	1764	MRESULT rc = (MRESULT) FALSE;
	1765	QETWidget *widget = 0;
	1766	HWND hwndC = 0;
	1767
	1768	if ( !qApp ) // unstable app state
	1769	goto do_default;
	1770
	1771	// make sure we show widgets (e.g. scrollbars) when the user resizes
	1772	if ( inLoop && qApp->loopLevel() )
	1773	qApp->sendPostedEvents( 0, QEvent::ShowWindowRequest );
	1774
	1775	inLoop = TRUE;
	1776
	1777	hwndC = WinWindowFromID( hwnd, FID_CLIENT );
	1778	widget = (QETWidget*)QWidget::find( hwndC );
	1779	if ( !widget ) // don't know this widget
	1780	goto do_default;
	1781
	1782	switch ( msg ) {
	1783	case WM_HITTEST: {
	1784	if ( !WinIsWindowEnabled( hwnd ) ) {
	1785	if (
	1786	qApp->activePopupWidget() &&
	1787	(WinQueryQueueStatus( HWND_DESKTOP ) & QS_MOUSEBUTTON)
	1788	) {
	1789	// the user has clicked over the Qt window that is disabled
	1790	// by some modal widget, therefore we close all popups. In
	1791	// case some popup refuses to close, we give up after 1024
	1792	// attempts (to avoid an infinite loop).
	1793	int maxiter = 1024;
	1794	QWidget *popup;
	1795	while ( (popup=QApplication::activePopupWidget()) && maxiter-- )
	1796	popup->close();
	1797	}
	1798	#ifndef QT_NO_CURSOR
	1799	else {
	1800	QCursor *c = qt_grab_cursor();
	1801	if ( !c )
	1802	c = QApplication::overrideCursor();
	1803	if ( c ) // application cursor defined
	1804	WinSetPointer( HWND_DESKTOP, c->handle() );
	1805	else
	1806	WinSetPointer( HWND_DESKTOP, Qt::arrowCursor.handle() );
	1807	}
	1808	#endif
	1809	}
	1810	break;
	1811	}
	1812
	1813	case WM_ADJUSTWINDOWPOS: {
	1814	SWP &swp = *(PSWP) mp1;
	1815	if ( swp.fl & SWP_MAXIMIZE ) {
	1816	QWExtra *x = widget->xtra();
	1817	if ( x ) {
	1818	result = TRUE;
	1819	rc = QtOldFrameProc( hwnd, msg, mp1, mp2 );
	1820	int maxw = QWIDGETSIZE_MAX, maxh = QWIDGETSIZE_MAX;
	1821	QTLWExtra *top = widget->top();
	1822	if ( x->maxw < QWIDGETSIZE_MAX )
	1823	maxw = x->maxw + top->fleft + top->fright;
	1824	if ( x->maxh < QWIDGETSIZE_MAX )
	1825	maxh = x->maxh + top->ftop + top->fbottom;
	1826	if ( maxw < QWIDGETSIZE_MAX ) swp.cx = maxw;
	1827	if ( maxh < QWIDGETSIZE_MAX ) {
	1828	swp.y = swp.y + swp.cy - maxh;
	1829	swp.cy = maxh;
	1830	}
	1831	}
	1832	}
[102]	1833	if ( (swp.fl & SWP_RESTORE) &&
	1834	!(swp.fl & (SWP_MOVE \| SWP_SIZE)) ) {
	1835	QRect r = widget->top()->normalGeometry;
	1836	if ( r.isValid() ) {
	1837	// store normal geometry in window words
	1838	USHORT x = r.x();
	1839	USHORT y = r.y();
	1840	USHORT w = r.width();
	1841	USHORT h = r.height();
[169]	1842	// flip y coordinate
[102]	1843	y = QApplication::desktop()->height() - (y + h);
	1844	WinSetWindowUShort( hwnd, QWS_XRESTORE, x );
	1845	WinSetWindowUShort( hwnd, QWS_YRESTORE, y );
	1846	WinSetWindowUShort( hwnd, QWS_CXRESTORE, w );
	1847	WinSetWindowUShort( hwnd, QWS_CYRESTORE, h );
	1848	widget->top()->normalGeometry.setWidth( 0 );
	1849	}
	1850	}
[8]	1851	if ( swp.fl & (SWP_ACTIVATE \| SWP_ZORDER) ) {
	1852	// get the modal widget that made this window blocked
	1853	QWidget *m =
[153]	1854	(QWidget*) WinQueryWindowPtr( widget->winId(), QWL_QTMODAL );
[8]	1855	if( m ) {
	1856	if ( swp.fl & SWP_ACTIVATE ) {
	1857	QWidget *a = qt_modal_stack->first();
	1858	if ( !a->isActiveWindow() )
	1859	a->setActiveWindow();
	1860	swp.fl &= ~SWP_ACTIVATE;
	1861	}
	1862	if ( swp.fl & SWP_ZORDER ) {
	1863	QWidget *mp = m->parentWidget();
	1864	if ( mp ) {
	1865	mp = mp->topLevelWidget();
	1866	if ( !mp->isDesktop() && mp != widget )
	1867	m = mp;
	1868	}
	1869	HWND hm = m->winFId();
	1870	if ( swp.hwndInsertBehind != hm ) {
	1871	swp.hwndInsertBehind = hm;
	1872	}
	1873	}
	1874	}
	1875	}
	1876	break;
	1877	}
	1878
	1879	case WM_QUERYTRACKINFO: {
	1880	QWExtra *x = widget->xtra();
	1881	if ( x ) {
	1882	result = TRUE;
	1883	rc = QtOldFrameProc( hwnd, msg, mp1, mp2 );
	1884	PTRACKINFO pti = (PTRACKINFO) mp2;
	1885	int minw = 0, minh = 0;
	1886	int maxw = QWIDGETSIZE_MAX, maxh = QWIDGETSIZE_MAX;
	1887	QTLWExtra *top = widget->top();
	1888	if ( x->minw > 0 )
	1889	minw = x->minw + top->fleft + top->fright;
	1890	if ( x->minh > 0 )
	1891	minh = x->minh + top->ftop + top->fbottom;
	1892	if ( x->maxw < QWIDGETSIZE_MAX )
	1893	maxw = x->maxw + top->fleft + top->fright;
	1894	if ( x->maxh < QWIDGETSIZE_MAX )
	1895	maxh = x->maxh + top->ftop + top->fbottom;
	1896	// obey system recommended minimum size (to emulate Qt/Win32)
	1897	pti->ptlMinTrackSize.x = QMAX( minw, pti->ptlMinTrackSize.x );
	1898	pti->ptlMinTrackSize.y = QMAX( minh, pti->ptlMinTrackSize.y );
	1899	pti->ptlMaxTrackSize.x = maxw;
	1900	pti->ptlMaxTrackSize.y = maxh;
	1901	}
	1902	break;
	1903	}
	1904
	1905	case WM_TRACKFRAME: {
	1906	if ( QApplication::activePopupWidget() ) {
	1907	// The user starts to size/move the frame window, therefore
	1908	// we close all popups. In case some popup refuses to close,
	1909	// we give up after 1024 attempts (to avoid an infinite loop).
	1910	int maxiter = 1024;
	1911	QWidget *popup;
	1912	while ( (popup=QApplication::activePopupWidget()) && maxiter-- )
	1913	popup->close();
	1914	}
	1915	break;
	1916	}
	1917
[102]	1918	case WM_WINDOWPOSCHANGED: {
	1919	// We detect spontaneous min/max/restore events here instead of
	1920	// WM_MINMAXFRAME, because WM_MINMAXFRAME is a pre-process message
	1921	// (i.e. no actual changes have been made) We need actual changes
[169]	1922	// in order to update the frame strut and send WindowStateChange.
[102]	1923	result = TRUE;
	1924	rc = QtOldFrameProc( hwnd, msg, mp1, mp2 );
	1925	ULONG awp = LONGFROMMP( mp2 );
	1926	bool window_state_change = FALSE;
	1927	if ( awp & AWP_MAXIMIZED ) {
	1928	window_state_change = TRUE;
	1929	widget->setWState( Qt::WState_Maximized );
	1930	widget->clearWState( Qt::WState_FullScreen );
	1931	if ( widget->isMinimized() ) {
	1932	widget->clearWState( Qt::WState_Minimized );
	1933	widget->showChildren( TRUE );
	1934	QShowEvent e;
	1935	qt_sendSpontaneousEvent( widget, &e );
	1936	}
	1937	} else if ( awp & AWP_MINIMIZED ) {
	1938	window_state_change = TRUE;
	1939	widget->setWState( Qt::WState_Minimized );
	1940	widget->clearWState( Qt::WState_Maximized );
	1941	widget->clearWState( Qt::WState_FullScreen );
	1942	if ( widget->isVisible() ) {
	1943	QHideEvent e;
	1944	qt_sendSpontaneousEvent( widget, &e );
	1945	widget->hideChildren( TRUE );
	1946	}
	1947	} else if ( awp & AWP_RESTORED ) {
	1948	window_state_change = TRUE;
	1949	if ( widget->isMinimized() ) {
	1950	widget->showChildren( TRUE );
	1951	QShowEvent e;
	1952	qt_sendSpontaneousEvent( widget, &e );
	1953	}
	1954	widget->clearWState( Qt::WState_Minimized );
	1955	widget->clearWState( Qt::WState_Maximized );
	1956	}
	1957	if ( window_state_change ) {
	1958	widget->updateFrameStrut();
	1959	if ( !widget->top()->in_sendWindowState ) {
	1960	// send WindowStateChange event if this message is NOT
	1961	// originated from QWidget::setWindowState().
	1962	QEvent e( QEvent::WindowStateChange );
	1963	qt_sendSpontaneousEvent( widget, &e );
	1964	}
	1965	}
	1966	break;
	1967	}
	1968
[8]	1969	default:
	1970	break;
	1971	}
	1972
	1973	if ( result )
	1974	RETURN( rc );
	1975
	1976	do_default:
	1977	RETURN( QtOldFrameProc( hwnd, msg, mp1, mp2 ) );
	1978	}
	1979
	1980	/*****************************************************************************
	1981	Modal widgets; We have implemented our own modal widget mechanism
	1982	to get total control.
	1983	A modal widget without a parent becomes application-modal.
	1984	A modal widget with a parent becomes modal to its parent and grandparents..
	1985
	1986	//@@TODO (dmik): the above comment is not correct (outdated?): for example,
	1987	// in accordance with the current Qt logic, a modal widget with a parent
	1988	// becomes modal to its (grand)parents upto the first of them that has the
	1989	// WGroupLeader flag, not necessarily to all...
	1990
	1991	qt_enter_modal()
	1992	Enters modal state
	1993	Arguments:
	1994	QWidget *widget A modal widget
	1995
	1996	qt_leave_modal()
	1997	Leaves modal state for a widget
	1998	Arguments:
	1999	QWidget *widget A modal widget
	2000	*****************************************************************************/
	2001
	2002	Q_EXPORT bool qt_modal_state()
	2003	{
	2004	return app_do_modal;
	2005	}
	2006
	2007	// helper for qt_dispatchBlocked().
	2008	// sends block events to the given widget and its children.
	2009	void qt_sendBlocked( QObject obj, QWidget modal, QEvent *e, bool override )
	2010	{
	2011	if ( obj == modal ) {
	2012	// don't touch modal itself and its children
	2013	return;
	2014	}
	2015	bool blocked = e->type() == QEvent::WindowBlocked;
	2016
	2017	if ( obj->isWidgetType() ) {
	2018	QWidget w = (QWidget) obj;
	2019	if ( w->isTopLevel() ) {
	2020	if ( w->testWFlags( Qt::WGroupLeader ) && !override ) {
	2021	// stop sending on group leaders
	2022	return;
	2023	}
	2024	QWidget *blockedBy =
[153]	2025	(QWidget*) WinQueryWindowPtr( w->winId(), QWL_QTMODAL );
[8]	2026	if ( blocked ) {
	2027	// stop sending on alreay blocked widgets
	2028	if ( blockedBy )
	2029	return;
	2030	} else {
	2031	// stop sending on widgets blocked by another modal
	2032	if ( blockedBy != modal )
	2033	return;
	2034	}
[153]	2035	WinSetWindowPtr( w->winId(), QWL_QTMODAL, blocked ? modal : NULL );
[8]	2036	WinEnableWindow( w->winFId(), !blocked );
	2037	}
	2038	}
	2039	QApplication::sendEvent( obj, e );
	2040
	2041	// now send blocked to children
	2042	if ( obj->children() ) {
	2043	QObjectListIt it( *obj->children() );
	2044	QObject *o;
	2045	while( ( o = it.current() ) != 0 ) {
	2046	++it;
[153]	2047	qt_sendBlocked( o, modal, e, blocked ? FALSE : TRUE );
[8]	2048	}
	2049	}
	2050	}
	2051
	2052	// sends blocked/unblocked events to top-level widgets depending on the
	2053	// modal widget given and the WGroupLeader flag presence.
	2054	static void qt_dispatchBlocked( QWidget *modal, bool blocked )
	2055	{
	2056	// we process those top-level windows that must be blocked
	2057	// by the given modal -- this should correlate with the
	2058	// qt_tryModalHelper() logic that is widget-centric (i.e. a try
	2059	// to block a particular widget given the current set of
	2060	// modals) rather than modal-centric (a try to block the current set
	2061	// of widgets given a particular modal); currently it blocks events
	2062	// for a top-level widget if the widget doesn't have (a parent with
	2063	// with) the WGroupLeader flag or it has but (this parent) has a child
	2064	// among the current set of modals. So, the modal-centric logic is
	2065	// to block any top-level widget unless it has (a parent with) the
	2066	// WGroupLeader flag and (this parent) is not (a child of) the modal's
	2067	// group leader.
	2068
	2069	QEvent e( blocked ? QEvent::WindowBlocked : QEvent::WindowUnblocked );
	2070
[153]	2071	if ( !blocked ) {
	2072	// For unblocking, we go through all top-level widgets and unblock
	2073	// those that have been blocked by the given modal widget. It means that
	2074	// we don't select widgets to unblock based on widget flags (as we do
	2075	// below when blocking) because these flags might have been changed
	2076	// so that we could skip widgets that we would have to unblock. Although
	2077	// normally widget flags should never be changed after widget creation
	2078	// (except that by QWidget::reparentSys() that takes blocking into
	2079	// account and corrects it as needed), nothing stops one from doing so,
	2080	// leading to a case when the QWL_QTMODAL word of some widget still
	2081	// points to a widget that has been deleted (so that any attempt to
	2082	// access it results into a nasty segfault).
	2083	QWidgetList *list = QApplication::topLevelWidgets();
	2084	for( QWidget *w = list->first(); w; w = list->next() ) {
	2085	if ( WinQueryWindowPtr( w->winId(), QWL_QTMODAL ) == modal )
	2086	qt_sendBlocked( w, modal, &e, TRUE );
	2087	}
	2088	delete list;
	2089	return;
	2090	}
[174]	2091
[8]	2092	// find the modal's group leader
	2093	QWidget *mgl = modal->parentWidget();
	2094	while ( mgl && !mgl->testWFlags( Qt::WGroupLeader ) )
	2095	mgl = mgl->parentWidget();
	2096	if ( mgl ) {
	2097	mgl = mgl->topLevelWidget();
	2098	if ( mgl->isDesktop() )
	2099	mgl = 0;
	2100	}
	2101
	2102	QWidgetList *list = QApplication::topLevelWidgets();
	2103	for( QWidget *w = list->first(); w; w = list->next() ) {
	2104	if (
[153]	2105	!w->isDesktop() && !w->isPopup() &&
[8]	2106	!w->testWFlags( Qt::WGroupLeader ) &&
	2107	(!w->parentWidget() \|\| w->parentWidget()->isDesktop())
	2108	) {
	2109	qt_sendBlocked( w, modal, &e, FALSE );
	2110	}
	2111	}
[110]	2112	delete list;
[8]	2113
	2114	if ( mgl ) {
	2115	// send blocked to modal's group leader
	2116	qt_sendBlocked( mgl, modal, &e, TRUE );
	2117	}
	2118	// qt_tryModalHelper() also assumes that the toppest modal widget blocks
	2119	// other modals, regardless of WGroupLeader flags in parents. do the same.
[153]	2120	// Note: the given modal is not yet at the stack here.
[8]	2121	if ( qt_modal_stack ) {
	2122	QWidget *m = qt_modal_stack->first();
	2123	while ( m ) {
	2124	qt_sendBlocked( m, modal, &e, TRUE );
	2125	m = qt_modal_stack->next();
	2126	}
	2127	}
	2128	}
	2129
[154]	2130	static inline bool isChildOf( QWidget * child, QWidget * parent )
	2131	{
	2132	if ( !parent \|\| !child )
	2133	return FALSE;
	2134	QWidget * w = child;
	2135	while( w && w != parent )
	2136	w = w->parentWidget();
	2137	return w != 0;
	2138	}
	2139
[8]	2140	Q_EXPORT void qt_enter_modal( QWidget *widget )
	2141	{
	2142	if ( !qt_modal_stack ) { // create modal stack
	2143	qt_modal_stack = new QWidgetList;
	2144	Q_CHECK_PTR( qt_modal_stack );
	2145	}
	2146
	2147	if ( qt_modal_stack->containsRef( widget ) )
	2148	return; // already modal
	2149
[154]	2150	QWidget *m = qt_modal_stack->first();
	2151	while ( m ) {
	2152	if ( isChildOf( m, widget ) )
	2153	return; // child is already modal (prevent endless recursion)
	2154	m = qt_modal_stack->next();
	2155	}
	2156
[8]	2157	//@@TODO (dmik): Qt/Win32 sends WindowBlocked/WindowUnblocked events only
	2158	// to the direct parent of the modal widget. Why? We use qt_dispatchBlocked()
	2159	// to send them to all windows that do not get input when the given widget
	2160	// is modal; also we disable/enable that windows there, which is essential
	2161	// for modality support in Qt/OS2 (code in QtOldFrameProc() and qt_try_modal()
	2162	// functionality depend on it).
	2163	//
	2164	// if (widget->parentWidget()) {
	2165	// QEvent e(QEvent::WindowBlocked);
	2166	// QApplication::sendEvent(widget->parentWidget(), &e);
	2167	// WinEnableWindow( widget->parentWidget()->winFId(), FALSE );
	2168	// }
	2169	qt_dispatchBlocked( widget, TRUE );
	2170
	2171	releaseAutoCapture();
	2172	qt_dispatchEnterLeave( 0, QWidget::find((WId)curWin));
	2173	qt_modal_stack->insert( 0, widget );
	2174	app_do_modal = TRUE;
	2175	curWin = 0;
	2176	qt_button_down = 0;
	2177	ignoreNextMouseReleaseEvent = FALSE;
	2178	}
	2179
	2180
	2181	Q_EXPORT void qt_leave_modal( QWidget *widget )
	2182	{
	2183	if ( qt_modal_stack && qt_modal_stack->removeRef(widget) ) {
	2184	if ( qt_modal_stack->isEmpty() ) {
	2185	delete qt_modal_stack;
	2186	qt_modal_stack = 0;
	2187	QPoint p( QCursor::pos() );
	2188	app_do_modal = FALSE; // necessary, we may get recursively into qt_try_modal below
	2189	QWidget* w = QApplication::widgetAt( p.x(), p.y(), TRUE );
	2190	qt_dispatchEnterLeave( w, QWidget::find( curWin ) ); // send synthetic enter event
	2191	curWin = w? w->winId() : 0;
	2192	}
	2193	ignoreNextMouseReleaseEvent = TRUE;
	2194
	2195	qt_dispatchBlocked( widget, FALSE );
	2196	}
	2197	app_do_modal = qt_modal_stack != 0;
	2198
	2199	//@@TODO (dmik): see the comments inside qt_enter_modal()
	2200	//
	2201	// if (widget->parentWidget()) {
	2202	// WinEnableWindow( widget->parentWidget()->winFId(), TRUE );
	2203	// QEvent e(QEvent::WindowUnblocked);
	2204	// QApplication::sendEvent(widget->parentWidget(), &e);
	2205	// }
	2206	}
	2207
	2208	static bool qt_blocked_modal( QWidget *widget )
	2209	{
	2210	if ( !app_do_modal )
	2211	return FALSE;
	2212	if ( qApp->activePopupWidget() )
	2213	return FALSE;
	2214	if ( widget->testWFlags(Qt::WStyle_Tool) ) // allow tool windows
	2215	return FALSE;
	2216
	2217	QWidget modal=0, top=qt_modal_stack->getFirst();
	2218
	2219	widget = widget->topLevelWidget();
	2220	if ( widget->testWFlags(Qt::WShowModal) ) // widget is modal
	2221	modal = widget;
	2222	if ( !top \|\| modal == top ) // don't block event
	2223	return FALSE;
	2224	return TRUE;
	2225	}
	2226
	2227	static bool qt_try_modal( QWidget widget, QMSG qmsg, int &ret )
	2228	{
	2229	QWidget * top = 0;
	2230
	2231	if ( qt_tryModalHelper( widget, &top ) )
	2232	return TRUE;
	2233
	2234	bool block_event = FALSE;
	2235	ULONG type = qmsg->msg;
	2236
	2237	if ( type == WM_CLOSE ) {
	2238	block_event = TRUE;
	2239	}
	2240
	2241	return !block_event;
	2242	}
	2243
	2244
	2245	/*****************************************************************************
	2246	Popup widget mechanism
	2247
	2248	openPopup()
	2249	Adds a widget to the list of popup widgets
	2250	Arguments:
	2251	QWidget *widget The popup widget to be added
	2252
	2253	closePopup()
	2254	Removes a widget from the list of popup widgets
	2255	Arguments:
	2256	QWidget *widget The popup widget to be removed
	2257	*****************************************************************************/
	2258
	2259	void QApplication::openPopup( QWidget *popup )
	2260	{
	2261	if ( !popupWidgets ) { // create list
	2262	popupWidgets = new QWidgetList;
	2263	Q_CHECK_PTR( popupWidgets );
	2264	}
	2265	popupWidgets->append( popup ); // add to end of list
	2266	if ( !popup->isEnabled() )
	2267	return;
	2268
	2269	if ( popupWidgets->count() == 1 && !qt_nograb() )
	2270	setAutoCapture( popup->winId() ); // grab mouse/keyboard
	2271	// Popups are not focus-handled by the window system (the first
	2272	// popup grabbed the keyboard), so we have to do that manually: A
	2273	// new popup gets the focus
	2274	QFocusEvent::setReason( QFocusEvent::Popup );
	2275	if ( popup->focusWidget())
	2276	popup->focusWidget()->setFocus();
	2277	else
	2278	popup->setFocus();
	2279	QFocusEvent::resetReason();
	2280	}
	2281
	2282	void QApplication::closePopup( QWidget *popup )
	2283	{
	2284	if ( !popupWidgets )
	2285	return;
	2286	popupWidgets->removeRef( popup );
	2287	POINTL curPos;
	2288	WinQueryPointerPos( HWND_DESKTOP, &curPos );
	2289	// flip y coordinate
	2290	curPos.y = desktop()->height() - (curPos.y + 1);
	2291	replayPopupMouseEvent = !popup->geometry().contains( QPoint(curPos.x, curPos.y) );
	2292	if ( popupWidgets->count() == 0 ) { // this was the last popup
	2293	popupCloseDownMode = TRUE; // control mouse events
	2294	delete popupWidgets;
	2295	popupWidgets = 0;
	2296	if ( !popup->isEnabled() )
	2297	return;
	2298	if ( !qt_nograb() ) // grabbing not disabled
	2299	releaseAutoCapture();
	2300	if ( active_window ) {
	2301	QFocusEvent::setReason( QFocusEvent::Popup );
	2302	if ( active_window->focusWidget() )
	2303	active_window->focusWidget()->setFocus();
	2304	else
	2305	active_window->setFocus();
	2306	QFocusEvent::resetReason();
	2307	}
	2308	} else {
	2309	// Popups are not focus-handled by the window system (the
	2310	// first popup grabbed the keyboard), so we have to do that
	2311	// manually: A popup was closed, so the previous popup gets
	2312	// the focus.
	2313	QFocusEvent::setReason( QFocusEvent::Popup );
	2314	QWidget* aw = popupWidgets->getLast();
	2315	if ( popupWidgets->count() == 1 )
	2316	setAutoCapture( aw->winId() );
	2317	if (aw->focusWidget())
	2318	aw->focusWidget()->setFocus();
	2319	else
	2320	aw->setFocus();
	2321	QFocusEvent::resetReason();
	2322	}
	2323	}
	2324
	2325
	2326
	2327	/*****************************************************************************
	2328	Event translation; translates OS/2 PM events to Qt events
	2329	*****************************************************************************/
	2330
	2331	// State holder for LWIN/RWIN and ALTGr keys
	2332	// (ALTGr is also necessary since OS/2 doesn't report ALTGr as KC_ALT)
	2333	static int qt_extraKeyState = 0;
	2334
[97]	2335	static int mouseButtonState()
	2336	{
	2337	int state = 0;
[8]	2338
[97]	2339	if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON1 ) & 0x8000 )
	2340	state \|= Qt::LeftButton;
	2341	if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON2 ) & 0x8000 )
	2342	state \|= Qt::RightButton;
	2343	if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON3 ) & 0x8000 )
	2344	state \|= Qt::MidButton;
	2345
	2346	return state;
	2347	}
	2348
[8]	2349	//
	2350	// Auto-capturing for mouse press and mouse release
	2351	//
	2352
	2353	static void setAutoCapture( HWND h )
	2354	{
	2355	if ( autoCaptureWnd )
	2356	releaseAutoCapture();
	2357	autoCaptureWnd = h;
	2358
[97]	2359	if ( !mouseButtonState() ) {
[8]	2360	// all buttons released, we don't actually capture the mouse
	2361	// (see QWidget::translateMouseEvent())
	2362	autoCaptureReleased = TRUE;
	2363	} else {
	2364	autoCaptureReleased = FALSE;
	2365	WinSetCapture( HWND_DESKTOP, h );
	2366	}
	2367	}
	2368
	2369	static void releaseAutoCapture()
	2370	{
	2371	if ( autoCaptureWnd ) {
	2372	if ( !autoCaptureReleased ) {
	2373	WinSetCapture( HWND_DESKTOP, 0 );
	2374	autoCaptureReleased = TRUE;
	2375	}
	2376	autoCaptureWnd = 0;
	2377	}
	2378	}
	2379
	2380
	2381	//
	2382	// Mouse event translation
	2383	//
	2384
	2385	static ushort mouseTbl[] = {
	2386	WM_MOUSEMOVE, QEvent::MouseMove, 0,
	2387	WM_BUTTON1DOWN, QEvent::MouseButtonPress, Qt::LeftButton,
	2388	WM_BUTTON1UP, QEvent::MouseButtonRelease, Qt::LeftButton,
	2389	WM_BUTTON1DBLCLK, QEvent::MouseButtonDblClick, Qt::LeftButton,
	2390	WM_BUTTON2DOWN, QEvent::MouseButtonPress, Qt::RightButton,
	2391	WM_BUTTON2UP, QEvent::MouseButtonRelease, Qt::RightButton,
	2392	WM_BUTTON2DBLCLK, QEvent::MouseButtonDblClick, Qt::RightButton,
	2393	WM_BUTTON3DOWN, QEvent::MouseButtonPress, Qt::MidButton,
	2394	WM_BUTTON3UP, QEvent::MouseButtonRelease, Qt::MidButton,
	2395	WM_BUTTON3DBLCLK, QEvent::MouseButtonDblClick, Qt::MidButton,
	2396	//@@TODO (dmik): later (extra buttons)
	2397	// WM_XBUTTONDOWN, QEvent::MouseButtonPress, Qt::MidButton*2, //### Qt::XButton1/2
	2398	// WM_XBUTTONUP, QEvent::MouseButtonRelease, Qt::MidButton*2,
	2399	// WM_XBUTTONDBLCLK, QEvent::MouseButtonDblClick, Qt::MidButton*2,
	2400	WM_CONTEXTMENU, QEvent::ContextMenu, 0,
	2401	0, 0, 0
	2402	};
	2403
	2404	static int translateButtonState( USHORT s, int type, int button )
	2405	{
[97]	2406	int bst = mouseButtonState();
[8]	2407
	2408	if ( type == QEvent::ContextMenu ) {
	2409	if ( WinGetKeyState( HWND_DESKTOP, VK_SHIFT ) & 0x8000 )
	2410	bst \|= Qt::ShiftButton;
	2411	if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 )
	2412	bst \|= Qt::AltButton;
	2413	if ( WinGetKeyState( HWND_DESKTOP, VK_CTRL ) & 0x8000 )
	2414	bst \|= Qt::ControlButton;
	2415	} else {
	2416	if ( s & KC_SHIFT )
	2417	bst \|= Qt::ShiftButton;
	2418	if ( (s & KC_ALT) )
	2419	bst \|= Qt::AltButton;
	2420	if ( s & KC_CTRL )
	2421	bst \|= Qt::ControlButton;
	2422	}
	2423	if ( (qt_extraKeyState & Qt::AltButton) )
	2424	bst \|= Qt::AltButton;
	2425	if ( qt_extraKeyState & Qt::MetaButton )
	2426	bst \|= Qt::MetaButton;
	2427
	2428	// Translate from OS/2-style "state after event"
	2429	// to X-style "state before event"
	2430	if ( type == QEvent::MouseButtonPress \|\|
	2431	type == QEvent::MouseButtonDblClick )
	2432	bst &= ~button;
	2433	else if ( type == QEvent::MouseButtonRelease )
	2434	bst \|= button;
	2435
	2436	return bst;
	2437	}
	2438
[97]	2439	/*! \internal
	2440	In DnD, the mouse release event never appears, so the
	2441	mouse button state machine must be manually reset
	2442	*/
	2443	void qt_pmMouseButtonUp()
	2444	{
	2445	// release any stored mouse capture
	2446	qt_button_down = 0;
	2447	autoCaptureReleased = TRUE;
	2448	releaseAutoCapture();
	2449	}
[8]	2450
	2451	bool QETWidget::translateMouseEvent( const QMSG &qmsg )
	2452	{
[52]	2453	#if 0
	2454	static const char *msgNames[] = { // 11 items
	2455	"WM_MOUSEMOVE",
	2456	"WM_BUTTON1DOWN", "WM_BUTTON1UP", "WM_BUTTON1DBLCLK",
	2457	"WM_BUTTON2DOWN", "WM_BUTTON2UP", "WM_BUTTON2DBLCLK",
	2458	"WM_BUTTON3DOWN", "WM_BUTTON3UP", "WM_BUTTON3DBLCLK",
	2459	"WM_???"
	2460	};
	2461	int msgIdx = qmsg.msg - WM_MOUSEMOVE;
	2462	if (msgIdx < 0 \|\| msgIdx > 9)
	2463	msgIdx = 10;
	2464	qDebug( "%s (%04lX): [%08lX/%p:%s/%s] %04hd,%04hd hit=%04hX fl=%04hX",
	2465	msgNames[msgIdx], qmsg.msg, qmsg.hwnd, this, name(), className(),
	2466	SHORT1FROMMP(qmsg.mp1), SHORT2FROMMP(qmsg.mp1),
	2467	SHORT1FROMMP(qmsg.mp2), SHORT2FROMMP(qmsg.mp2) );
	2468	#endif
[78]	2469
[8]	2470	static QPoint pos; // window pos (y flipped)
	2471	static POINTL gpos = { -1, -1 }; // global pos (y flipped)
	2472	QEvent::Type type; // event parameters
	2473	int button;
	2474	int state;
	2475	int i;
	2476
[52]	2477	// candidate for a double click event
	2478	static HWND dblClickCandidateWin = 0;
[78]	2479
[77]	2480	if ( sm_blockUserInput ) //block user interaction during session management
	2481	return TRUE;
[8]	2482
	2483	// Compress mouse move events
	2484	if ( qmsg.msg == WM_MOUSEMOVE ) {
	2485	QMSG mouseMsg;
	2486	mouseMsg.msg = WM_NULL;
	2487	while (
	2488	WinPeekMsg( 0, &mouseMsg, qmsg.hwnd, WM_MOUSEMOVE,
	2489	WM_MOUSEMOVE, PM_NOREMOVE )
	2490	) {
	2491	if ( mouseMsg.mp2 != qmsg.mp2 )
	2492	break; // leave the message in the queue because
	2493	// the key state has changed
	2494	// Remove the mouse move message
	2495	WinPeekMsg( 0, &mouseMsg, qmsg.hwnd, WM_MOUSEMOVE,
	2496	WM_MOUSEMOVE, PM_REMOVE );
	2497	}
	2498	// Update the passed in QMSG structure with the
	2499	// most recent one.
	2500	if ( mouseMsg.msg != WM_NULL ) {
	2501	PQMSG pqmsg = (PQMSG)&qmsg;
	2502	pqmsg->mp1 = mouseMsg.mp1;
	2503	pqmsg->mp2 = mouseMsg.mp2;
	2504	pqmsg->time = mouseMsg.time;
	2505	pqmsg->ptl.x = (short)SHORT1FROMMP(mouseMsg.mp1);
	2506	pqmsg->ptl.y = (short)SHORT2FROMMP(mouseMsg.mp1);
	2507	WinMapWindowPoints( pqmsg->hwnd, HWND_DESKTOP, &pqmsg->ptl, 1 );
	2508	// flip y coordinate
	2509	pqmsg->ptl.y = QApplication::desktop()->height() - (pqmsg->ptl.y + 1);
	2510	}
	2511	}
	2512
	2513	for ( i = 0; mouseTbl[i] && (ULONG)mouseTbl[i] != qmsg.msg; i += 3 )
	2514	;
	2515	if ( !mouseTbl[i] )
	2516	return FALSE;
	2517
	2518	type = (QEvent::Type)mouseTbl[++i]; // event type
	2519	button = mouseTbl[++i]; // which button
	2520	state = translateButtonState( SHORT2FROMMP(qmsg.mp2), type, button ); // button state
	2521
[52]	2522	// It seems, that PM remembers only the WM_BUTTONxDOWN message (instead of
	2523	// the WM_BUTTONxDOWN + WM_BUTTONxUP pair) to detect whether the next button
	2524	// press should be converted to WM_BUTTONxDBLCLK or not. As a result, the
	2525	// window gets WM_BUTTONxDBLCLK even if it didn't receive the preceeding
	2526	// WM_BUTTONxUP (this happens if we issue WinSetCapture() on the first
	2527	// WM_BUTTONxDOWN), which is obviously wrong and makes problems for QWorkspace
	2528	// and QTitleBar system menu handlers that don't expect a double click after
	2529	// they opened a popup menu. dblClickCandidateWin is reset to 0 (see a ***
	2530	// remmark below) when WinSetCapture is issued that directs messages
	2531	// to a window other than one received the first WM_BUTTONxDOWN,
	2532	// so we can fix it here. Note that if there is more than one popup window,
	2533	// WinSetCapture is issued only for the first of them, so this code doesn't
	2534	// prevent MouseButtonDblClick from being delivered to a popup when another
	2535	// popup gets closed on the first WM_BUTTONxDOWN (Qt/Win32 behaves in the
	2536	// same way, so it's left for compatibility).
	2537	if ( type == QEvent::MouseButtonPress ) {
	2538	dblClickCandidateWin = qmsg.hwnd;
	2539	} else if ( type == QEvent::MouseButtonDblClick ) {
	2540	if ( dblClickCandidateWin != qmsg.hwnd )
	2541	type = QEvent::MouseButtonPress;
	2542	dblClickCandidateWin = 0;
	2543	}
[78]	2544
[8]	2545	if ( type == QEvent::ContextMenu ) {
	2546	QPoint g = QPoint( qmsg.ptl.x, qmsg.ptl.y );
	2547	QContextMenuEvent e( QContextMenuEvent::Mouse, mapFromGlobal( g ), g, state );
	2548	QApplication::sendSpontaneousEvent( this, &e );
	2549	return TRUE;
	2550	}
	2551
	2552	if ( type == QEvent::MouseMove ) {
	2553	if ( !(state & MouseButtonMask) )
	2554	qt_button_down = 0;
	2555	#ifndef QT_NO_CURSOR
	2556	QCursor *c = qt_grab_cursor();
	2557	if ( !c )
	2558	c = QApplication::overrideCursor();
	2559	if ( c ) // application cursor defined
	2560	WinSetPointer( HWND_DESKTOP, c->handle() );
	2561	else if ( isEnabled() ) // use widget cursor if widget is enabled
	2562	WinSetPointer( HWND_DESKTOP, cursor().handle() );
	2563	else {
	2564	QWidget *parent = parentWidget();
	2565	while ( parent && !parent->isEnabled() )
	2566	parent = parent->parentWidget();
	2567	if ( parent )
	2568	WinSetPointer( HWND_DESKTOP, parent->cursor().handle() );
	2569	}
	2570	#else
	2571	// pass the msg to the default proc to let it change the pointer shape
	2572	WinDefWindowProc( qmsg.hwnd, qmsg.msg, qmsg.mp1, qmsg.mp2 );
	2573	#endif
	2574	if ( curWin != winId() ) { // new current window
[174]	2575	/// @todo (dmik)
[97]	2576	// add CS_HITTEST to our window classes and handle WM_HITTEST,
[8]	2577	// otherwise disabled windows will not get mouse events?
	2578	qt_dispatchEnterLeave( this, QWidget::find(curWin) );
	2579	curWin = winId();
	2580	}
	2581
[52]	2582	// *** PM posts a dummy WM_MOUSEMOVE message (with the same, uncahnged
	2583	// pointer coordinates) after every WinSetCapture that actually changes
	2584	// the capture target. I.e., if the argument of WinSetCapture is
	2585	// NULLHANDLE, a window under the mouse pointer gets this message,
	2586	// otherwise the specified window gets it unless it is already under the
	2587	// pointer. We use this info to check whether the window can be a double
[78]	2588	// click candidate (see above).
[52]	2589	if ( qmsg.ptl.x == gpos.x && qmsg.ptl.y == gpos.y ) {
	2590	if ( dblClickCandidateWin != qmsg.hwnd )
	2591	dblClickCandidateWin = 0;
[8]	2592	return TRUE;
[52]	2593	}
[8]	2594
	2595	gpos = qmsg.ptl;
	2596
	2597	if ( state == 0 && autoCaptureWnd == 0 && !hasMouseTracking() &&
	2598	!QApplication::hasGlobalMouseTracking() )
	2599	return TRUE; // no button
	2600
	2601	pos = mapFromGlobal( QPoint(gpos.x, gpos.y) );
	2602	} else {
	2603	if ( type == QEvent::MouseButtonPress && !isActiveWindow() )
	2604	setActiveWindow();
	2605
	2606	gpos = qmsg.ptl;
	2607	pos = mapFromGlobal( QPoint(gpos.x, gpos.y) );
	2608
	2609	if ( type == QEvent::MouseButtonPress \|\| type == QEvent::MouseButtonDblClick ) { // mouse button pressed
	2610	// Magic for masked widgets
	2611	qt_button_down = findChildWidget( this, pos );
	2612	if ( !qt_button_down \|\| !qt_button_down->testWFlags(WMouseNoMask) )
	2613	qt_button_down = this;
	2614	}
	2615	}
	2616
	2617	// detect special button states
	2618	enum { Other, SinglePressed, AllReleased } btnState = Other;
	2619	int bs = state & MouseButtonMask;
	2620	if ( (type == QEvent::MouseButtonPress \|\|
	2621	type == QEvent::MouseButtonDblClick) && bs == 0
	2622	) {
	2623	btnState = SinglePressed;
	2624	} else if ( type == QEvent::MouseButtonRelease && bs == button ) {
	2625	btnState = AllReleased;
	2626	}
	2627
	2628	if ( qApp->inPopupMode() ) { // in popup mode
	2629	if ( !autoCaptureReleased && btnState == AllReleased ) {
	2630	// in order to give non-Qt windows the opportunity to see mouse
	2631	// messages while our popups are active we need to release the
	2632	// mouse capture which is absolute in OS/2. we do it directly
	2633	// (not through releaseAutoCapture()) in order to keep
	2634	// autoCaptureWnd nonzero to keep forwarding mouse move events
	2635	// (actually sent to one of Qt widgets) to the active popup.
	2636	autoCaptureReleased = TRUE;
	2637	WinSetCapture( HWND_DESKTOP, 0 );
	2638	} else if ( autoCaptureReleased && btnState == SinglePressed ) {
	2639	// set the mouse capture back if a button is pressed.
	2640	if ( autoCaptureWnd ) {
	2641	autoCaptureReleased = FALSE;
	2642	WinSetCapture( HWND_DESKTOP, autoCaptureWnd );
	2643	}
	2644	}
	2645
	2646	replayPopupMouseEvent = FALSE;
	2647	QWidget* activePopupWidget = qApp->activePopupWidget();
	2648	QWidget *popup = activePopupWidget;
	2649
	2650	if ( popup != this ) {
	2651	if ( testWFlags(WType_Popup) && rect().contains(pos) )
	2652	popup = this;
	2653	else // send to last popup
	2654	pos = popup->mapFromGlobal( QPoint(gpos.x, gpos.y) );
	2655	}
	2656	QWidget *popupChild = findChildWidget( popup, pos );
	2657	bool releaseAfter = FALSE;
	2658	switch ( type ) {
	2659	case QEvent::MouseButtonPress:
	2660	case QEvent::MouseButtonDblClick:
	2661	popupButtonFocus = popupChild;
	2662	break;
	2663	case QEvent::MouseButtonRelease:
	2664	releaseAfter = TRUE;
	2665	break;
	2666	default:
	2667	break; // nothing for mouse move
	2668	}
	2669
	2670	if ( popupButtonFocus ) {
	2671	QMouseEvent e( type,
	2672	popupButtonFocus->mapFromGlobal(QPoint(gpos.x,gpos.y)),
	2673	QPoint(gpos.x,gpos.y), button, state );
	2674	QApplication::sendSpontaneousEvent( popupButtonFocus, &e );
	2675	if ( releaseAfter ) {
	2676	popupButtonFocus = 0;
	2677	}
[52]	2678	} else if ( popupChild ) {
[8]	2679	QMouseEvent e( type,
	2680	popupChild->mapFromGlobal(QPoint(gpos.x,gpos.y)),
	2681	QPoint(gpos.x,gpos.y), button, state );
	2682	QApplication::sendSpontaneousEvent( popupChild, &e );
	2683	} else {
	2684	QMouseEvent e( type, pos, QPoint(gpos.x,gpos.y), button, state );
[52]	2685	QApplication::sendSpontaneousEvent( popup, &e );
[8]	2686	}
	2687
	2688	if ( releaseAfter )
	2689	qt_button_down = 0;
	2690
	2691	if ( type == QEvent::MouseButtonPress
	2692	&& qApp->activePopupWidget() != activePopupWidget
	2693	&& replayPopupMouseEvent ) {
	2694	// the popup dissappeared. Replay the event
	2695	QWidget* w = QApplication::widgetAt( gpos.x, gpos.y, TRUE );
[52]	2696	if ( w && !qt_blocked_modal( w ) ) {
[8]	2697	QPoint wpos = w->mapFromGlobal(QPoint(gpos.x, gpos.y));
	2698	// flip y coordinate
	2699	wpos.ry() = w->height() - (wpos.y() + 1);
[109]	2700	// Note: it's important to post this message rather than send:
	2701	// QPushButton::popupPressed() depends on this so that
	2702	// popup->exec() must return before this message is delivered
	2703	// as QWidget::keyPressEvent().
	2704	WinPostMsg( w->winId(), qmsg.msg,
	2705	MPFROM2SHORT( wpos.x(), wpos.y() ), qmsg.mp2 );
[8]	2706	}
	2707	}
	2708	} else { // not popup mode
	2709	if ( btnState == SinglePressed && QWidget::mouseGrabber() == 0 )
	2710	setAutoCapture( winId() );
	2711	else if ( btnState == AllReleased && QWidget::mouseGrabber() == 0 )
	2712	releaseAutoCapture();
	2713
	2714	QWidget *widget = this;
	2715	QWidget *w = QWidget::mouseGrabber();
	2716	if ( !w )
	2717	w = qt_button_down;
	2718	if ( w && w != this ) {
	2719	widget = w;
	2720	pos = w->mapFromGlobal(QPoint(gpos.x, gpos.y));
	2721	}
	2722
	2723	if ( type == QEvent::MouseButtonRelease &&
	2724	(state & (~button) & ( MouseButtonMask )) == 0 ) {
	2725	qt_button_down = 0;
	2726	}
	2727
	2728	QMouseEvent e( type, pos, QPoint(gpos.x,gpos.y), button, state );
	2729	QApplication::sendSpontaneousEvent( widget, &e );
[78]	2730
[8]	2731	if ( type != QEvent::MouseMove )
	2732	pos.rx() = pos.ry() = -9999; // init for move compression
	2733	}
	2734	return TRUE;
	2735	}
	2736
	2737
	2738	//
	2739	// Keyboard event translation
	2740	//
	2741
	2742	static const ushort KeyTbl[] = { // keyboard mapping table
	2743	VK_ESC, Qt::Key_Escape, // misc keys
	2744	VK_TAB, Qt::Key_Tab,
	2745	VK_BACKTAB, Qt::Key_Backtab,
	2746	VK_BACKSPACE, Qt::Key_Backspace,
	2747	VK_ENTER, Qt::Key_Enter,
	2748	VK_NEWLINE, Qt::Key_Return,
	2749	VK_INSERT, Qt::Key_Insert,
	2750	VK_DELETE, Qt::Key_Delete,
	2751	VK_CLEAR, Qt::Key_Clear,
	2752	VK_PAUSE, Qt::Key_Pause,
	2753	VK_PRINTSCRN, Qt::Key_Print,
	2754	VK_SPACE, Qt::Key_Space,
	2755	VK_HOME, Qt::Key_Home, // cursor movement
	2756	VK_END, Qt::Key_End,
	2757	VK_LEFT, Qt::Key_Left,
	2758	VK_UP, Qt::Key_Up,
	2759	VK_RIGHT, Qt::Key_Right,
	2760	VK_DOWN, Qt::Key_Down,
	2761	VK_PAGEUP, Qt::Key_Prior,
	2762	VK_PAGEDOWN, Qt::Key_Next,
	2763	VK_SHIFT, Qt::Key_Shift, // modifiers
	2764	VK_CTRL, Qt::Key_Control,
	2765	VK_ALT, Qt::Key_Alt,
	2766	VK_CAPSLOCK, Qt::Key_CapsLock,
	2767	VK_NUMLOCK, Qt::Key_NumLock,
	2768	VK_SCRLLOCK, Qt::Key_ScrollLock,
	2769	0, 0
	2770	};
	2771
	2772	// when the compatibility mode is FALSE Qt/OS2 uses the following rule
[106]	2773	// to calculate QKeyEvent::key() codes when an alpha-numeric key is
[8]	2774	// pressed: key code is the ASCII (Latin 1) character code of that key as if
	2775	// there were no any keyboard modifiers (CTRL, SHIFT, ALT) pressed, with the
	2776	// exception that alpha characters are uppercased.
	2777	// when the compatibility mode is TRUE Qt/OS2 behaves mostly like Qt/Win32.
	2778	Q_EXPORT bool qt_kbd_compatibility = TRUE;
[106]	2779
	2780	/// @todo (dmik) currentlly, qt_kbd_compatibility is TRUE because
[8]	2781	// qt_scan2Ascii function below is not well implemented yet (in particular,
[106]	2782	// it uses the 850 code page that may not be available on some systems...).
	2783	// Once we find a way to translate scans to US ASCII regardless of the current
	2784	// code page and/or NLS state (keyboard layout), qt_kbd_compatibility may be
	2785	// set to FALSE. This, in particular, will enable more correct handling of
	2786	// Alt+letter combinations when the keyboard is in the NLS state:
	2787	// QKeyEvent::key() will return a non-null Qt::Key_XXX code corresponding to
	2788	// the ASCII code of a pressed key, which in turn will let Qt process latin
	2789	// Alt+letter shortcuts in the NLS keyboard mode together with Alt+NLS_letter
	2790	// shortcuts (nice feature imho). Note that Alt+NLS_letter shortcuts are
[174]	2791	// correctly processed in any case.
[8]	2792
	2793	// cache table to store Qt::Key_... values for 256 hardware scancodes
	2794	// (even byte is for non-shifted keys, odd byte is for shifted ones).
	2795	// used to decrease the number of calls to KbdXlate.
	2796	static uchar ScanTbl[512] = { 0xFF };
	2797
	2798	static uchar qt_scan2Ascii( uchar scan, bool shift )
	2799	{
	2800	uchar ascii = 0;
	2801	HFILE kbd;
	2802	ULONG dummy;
	2803	DosOpen( "KBD$", &kbd, &dummy, 0,
	2804	FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS,
	2805	OPEN_SHARE_DENYNONE \| OPEN_ACCESS_READWRITE, NULL );
	2806	// parameter packet
	2807	struct CPID {
	2808	USHORT idCodePage;
	2809	USHORT reserved;
	2810	} cpid = { 850, 0 };
	2811	ULONG szCpid = sizeof(CPID);
	2812	// data packet
	2813	KBDTRANS kt;
	2814	ULONG szKt = sizeof(KBDTRANS);
	2815	// reset all kbd states and modifiers
	2816	memset( &kt, 0, szKt );
	2817	// reflect Shift state to distinguish between [ and { etc.
	2818	if ( qt_kbd_compatibility && shift )
	2819	kt.fsState = KBDSTF_RIGHTSHIFT;
	2820	kt.chScan = scan;
	2821	DosDevIOCtl( kbd, IOCTL_KEYBOARD, KBD_XLATESCAN,
	2822	&cpid, szCpid, &szCpid, &kt, szKt, &szKt );
	2823	// store in cache
	2824	uint idx = scan << 1;
	2825	if ( qt_kbd_compatibility && shift )
	2826	idx++;
	2827	ascii = ScanTbl[idx] = toupper( kt.chChar );
	2828	DosClose( kbd );
	2829	return ascii;
	2830	}
	2831
	2832	// translates WM_CHAR to Qt::Key_..., ascii, state and text
[106]	2833	static void translateKeyCode( CHRMSG &chm, int &code, int &ascii, int &state,
	2834	QString &text )
	2835	{
[8]	2836	if ( chm.fs & KC_SHIFT )
	2837	state \|= Qt::ShiftButton;
	2838	if ( chm.fs & KC_CTRL )
	2839	state \|= Qt::ControlButton;
	2840	if ( chm.fs & KC_ALT )
	2841	state \|= Qt::AltButton;
	2842	if ( qt_extraKeyState & Qt::MetaButton )
	2843	state \|= Qt::MetaButton;
	2844
	2845	unsigned char ch = chm.chr;
	2846
	2847	if ( chm.fs & KC_VIRTUALKEY ) {
	2848	if ( !chm.vkey ) {
	2849	// The only known situation when KC_VIRTUALKEY is present but
	2850	// vkey is zero is when Alt+Shift is pressed to switch the
	2851	// keyboard layout state from latin to national and back.
	2852	// It seems that this way the system informs applications about
	2853	// layout changes: chm.chr is 0xF1 when the user switches
	2854	// to the national layout (i.e. presses Alt + Left Shift)
	2855	// and it is 0xF0 when he switches back (presses Alt + Right Shift).
	2856	// We assume this and restore fs, vkey, scancode and chr accordingly.
	2857	if ( chm.chr == 0xF0 \|\| chm.chr == 0xF1 ) {
	2858	chm.fs \|= KC_ALT \| KC_SHIFT;
	2859	chm.vkey = VK_SHIFT;
	2860	chm.scancode = chm.chr == 0xF1 ? 0x2A : 0x36;
	2861	chm.chr = ch = 0;
	2862	state \|= Qt::AltButton \| Qt::ShiftButton;
	2863	// code will be assigned by the normal procedure below
	2864	}
	2865	}
	2866	if ( chm.vkey >= VK_F1 && chm.vkey <= VK_F24 ) {
	2867	// function keys
	2868	code = Qt::Key_F1 + (chm.vkey - VK_F1);
	2869	} else if ( chm.vkey == VK_ALTGRAF ) {
	2870	code = Qt::Key_Alt;
	2871	if ( !(chm.fs & KC_KEYUP) )
	2872	qt_extraKeyState \|= Qt::AltButton;
	2873	else
	2874	qt_extraKeyState &= ~Qt::AltButton;
	2875	} else {
	2876	// any other keys
	2877	int i = 0;
	2878	while ( KeyTbl[i] ) {
	2879	if ( chm.vkey == (int)KeyTbl[i] ) {
	2880	code = KeyTbl[i+1];
	2881	break;
	2882	}
	2883	i += 2;
	2884	}
	2885	}
	2886	} else {
	2887	if ( qt_kbd_compatibility && ch && ch < 0x80 ) {
	2888	code = toupper( ch );
	2889	} else if ( !qt_kbd_compatibility && (chm.fs & KC_CHAR) && isalpha( ch ) ) {
	2890	code = toupper( ch );
	2891	} else {
	2892	// detect some special keys that have a pseudo char code
	2893	// in the high byte of chm.chr (probably this is less
	2894	// device-dependent than scancode)
	2895	switch ( chm.chr ) {
	2896	case 0xEC00: // LWIN
	2897	case 0xED00: // RWIN
	2898	code = Qt::Key_Meta;
	2899	if ( !(chm.fs & KC_KEYUP) )
	2900	qt_extraKeyState \|= Qt::MetaButton;
	2901	else
	2902	qt_extraKeyState &= ~Qt::MetaButton;
	2903	break;
	2904	case 0xEE00: // WINAPP (menu with arrow)
	2905	code = Qt::Key_Menu;
	2906	break;
	2907	case 0x5600: // additional '\' (0x56 is actually its scancode)
	2908	ch = state & Qt::ShiftButton ? '\|' : '\\';
	2909	if ( qt_kbd_compatibility ) code = ch;
	2910	else code = '\\';
	2911	break;
	2912	default:
[106]	2913	// break if qt_kbd_compatibility = TRUE to avoid using
	2914	// qt_scan2Ascii(), see comments to qt_kbd_compatibility
[8]	2915	if ( qt_kbd_compatibility ) break;
	2916	// deduce Qt::Key... from scancode
	2917	if ( ScanTbl[0] == 0xFF )
	2918	memset( &ScanTbl, 0, sizeof(ScanTbl) );
	2919	uint idx = chm.scancode << 1;
	2920	if ( qt_kbd_compatibility && (state & Qt::ShiftButton) )
	2921	idx++;
	2922	code = ScanTbl[idx];
	2923	if ( !code )
	2924	// not found in cache
	2925	code = qt_scan2Ascii( chm.scancode, (state & Qt::ShiftButton) );
	2926	break;
	2927	}
	2928	}
	2929	}
	2930	// check extraState AFTER updating it
	2931	if ( qt_extraKeyState & Qt::AltButton )
	2932	state \|= Qt::AltButton;
	2933
	2934	// detect numeric keypad keys
	2935	if ( chm.vkey == VK_ENTER \|\| chm.vkey == VK_NUMLOCK ) {
	2936	// these always come from the numpad
	2937	state \|= Qt::Keypad;
	2938	} else if (
	2939	((chm.vkey >= VK_PAGEUP && chm.vkey <= VK_DOWN) \|\|
	2940	chm.vkey == VK_INSERT \|\| chm.vkey == VK_DELETE)
	2941	) {
	2942	if ( ch != 0xE0 ) {
	2943	state \|= Qt::Keypad;
[126]	2944	if ( (state & Qt::AltButton) && chm.vkey != VK_DELETE ) {
	2945	// reset both code and ch to "hide" them from Qt widgets and let
	2946	// the standard OS/2 Alt+ddd shortcut (that composed chars from
	2947	// typed in ASCII codes) work correctly. If we don't do that,
	2948	// widgets will see both individual digits (or cursor movements
	2949	// if NumLock is off) and the char composed by Alt+ddd.
	2950	code = ch = 0;
	2951	} else {
	2952	if ( ch ) {
	2953	// override code to make it Qt::Key_0..Qt::Key_9 etc.
	2954	code = toupper( ch );
	2955	}
[8]	2956	}
	2957	} else {
	2958	ch = 0;
	2959	}
	2960	}
	2961	// detect other numpad keys. OS/2 doesn't assign virtual keys to them
	2962	// so use scancodes (it can be device-dependent, is there a better way?)
	2963	switch ( chm.scancode ) {
	2964	case 0x4C: // 5
	2965	state \|= Qt::Keypad;
[126]	2966	if ( state & Qt::AltButton ) {
	2967	// reset both code and ch to "hide" them from Qt (see above)
	2968	code = ch = 0;
	2969	} else {
	2970	// scancode is zero if Numlock is set
	2971	if ( !code ) code = Qt::Key_Clear;
	2972	}
[8]	2973	break;
	2974	case 0x37: // *
	2975	// OS/2 assigns VK_PRINTSCRN to it when pressed with Shift, also
	2976	// it sets chr to zero when it is released with Alt or Ctrl
	2977	// leaving vkey as zero too, and does few other strange things --
	2978	// override them all
	2979	code = Qt::Key_Asterisk;
	2980	state \|= Qt::Keypad;
	2981	break;
	2982	case 0x5C: // /
	2983	code = Qt::Key_Slash;
	2984	// fall through
	2985	case 0x4A: // -
	2986	case 0x4E: // +
	2987	// the code for the above two is obtained by KbdXlate above
	2988	state \|= Qt::Keypad;
	2989	break;
	2990	}
	2991
	2992	if ( (state & Qt::ControlButton) && !(state & Qt::Keypad) ) {
	2993	if ( !(state & Qt::AltButton) ) {
	2994	unsigned char cch = toupper( ch ), newCh = 0;
	2995	// Ctrl + A..Z etc. produce ascii from 0x01 to 0x1F
	2996	if ( cch >= 0x41 && cch <= 0x5F ) newCh = cch - 0x40;
	2997	// the below emulates OS/2 functionality. It differs from
	2998	// Win32 one.
	2999	else if ( cch == 0x36 && !(state & Qt::Keypad) ) newCh = 0x1E;
	3000	else if ( cch == 0x2D ) newCh = 0x1F;
	3001	else if ( cch >= 0x7B && cch <= 0x7D ) newCh = cch - 0x60;
	3002	if ( newCh )
	3003	ch = newCh;
	3004	}
	3005	}
	3006
	3007	ascii = ch;
	3008	if ( ascii > 0x7F ) ascii = 0;
[169]	3009	if ( ch ) {
	3010	// Note: Ignore the KC_CHAR flag when generating text for a key to get
	3011	// correct (non-null) text even for Alt+Letter combinations (that
	3012	// don't have KC_CHAR set) because processing Alt+Letter shortcuts
	3013	// for non-ASCII letters in widgets (e.g. QPushButton) depends on that.
[170]	3014	if ( (chm.fs & (KC_VIRTUALKEY \| KC_CHAR)) == KC_CHAR && (chm.chr & 0xFF00) ) {
	3015	// We assime we get a DBCS char if the above condition is met.
	3016	// DBCS chars seem to have KC_CHAR set but not KC_VIRTUALKEY; we
	3017	// use this to prevent keys like ESC (chm=0x011B) with the non-zero
	3018	// high byte to be mistakenly recognized as DBCS.
[169]	3019	text = QString::fromLocal8Bit( (char *) &chm.chr, 2 );
	3020	}
	3021	else
	3022	text = QString::fromLocal8Bit( (char*) &ch, 1 );
	3023	}
[8]	3024	}
	3025
	3026	struct KeyRec {
	3027	KeyRec(unsigned char s, int c, int a, const QString& t) :
	3028	scan(s), code(c), ascii(a), text(t) { }
	3029	KeyRec() { }
	3030	unsigned char scan;
	3031	int code, ascii;
	3032	QString text;
	3033	};
	3034
	3035	static const int maxrecs=64; // User has LOTS of fingers...
	3036	static KeyRec key_rec[maxrecs];
	3037	static int nrecs=0;
	3038
	3039	static KeyRec* find_key_rec( unsigned char scan, bool remove )
	3040	{
	3041	KeyRec *result = 0;
[170]	3042	if( scan == 0 ) // DBCS chars or user-injected keys
	3043	return result;
	3044
[8]	3045	for (int i=0; i<nrecs; i++) {
	3046	if (key_rec[i].scan == scan) {
	3047	if (remove) {
	3048	static KeyRec tmp;
	3049	tmp = key_rec[i];
	3050	while (i+1 < nrecs) {
	3051	key_rec[i] = key_rec[i+1];
	3052	i++;
	3053	}
	3054	nrecs--;
	3055	result = &tmp;
	3056	} else {
	3057	result = &key_rec[i];
	3058	}
	3059	break;
	3060	}
	3061	}
	3062	return result;
	3063	}
	3064
	3065	static KeyRec* find_key_rec( int code, bool remove )
	3066	{
	3067	KeyRec *result = 0;
[170]	3068	if( code == 0 ) // DBCS chars or user-injected keys
	3069	return result;
	3070
[8]	3071	for (int i=0; i<nrecs; i++) {
	3072	if (key_rec[i].code == code) {
	3073	if (remove) {
	3074	static KeyRec tmp;
	3075	tmp = key_rec[i];
	3076	while (i+1 < nrecs) {
	3077	key_rec[i] = key_rec[i+1];
	3078	i++;
	3079	}
	3080	nrecs--;
	3081	result = &tmp;
	3082	} else {
	3083	result = &key_rec[i];
	3084	}
	3085	break;
	3086	}
	3087	}
	3088	return result;
	3089	}
	3090
[106]	3091	static void store_key_rec( unsigned char scan, int code, int ascii,
	3092	const QString& text )
	3093	{
[170]	3094	if( scan == 0 && code == 0 ) // DBCS chars or user-injected keys
	3095	return;
	3096
[8]	3097	if ( nrecs == maxrecs ) {
	3098	#if defined(QT_CHECK_RANGE)
[169]	3099	qWarning( "Qt: Internal keyboard buffer overflow" );
[8]	3100	#endif
[169]	3101	return;
[8]	3102	}
	3103
	3104	key_rec[nrecs++] = KeyRec( scan, code, ascii, text );
	3105	}
	3106
	3107	bool QETWidget::translateKeyEvent( const QMSG &qmsg, bool grab )
	3108	{
	3109	CHRMSG chm = ((PCHRMSG)(((char)&qmsg) + sizeof(HWND) + sizeof(ULONG)));
	3110
	3111	#if 0
	3112	qDebug( "WM_CHAR: [%s] fs: %04X cRepeat: %03d scancode: %02X chr: %04X vkey: %04X %s",
	3113	name(), chm.fs, chm.cRepeat, chm.scancode, chm.chr, chm.vkey, (grab ? "{grab}" : "") );
	3114	#endif
	3115
	3116	bool k0 = FALSE, k1 = FALSE;
	3117	int code = 0, ascii = 0, state = 0;
	3118	QString text;
	3119
[77]	3120	if ( sm_blockUserInput ) // block user interaction during session management
[169]	3121	return TRUE;
[8]	3122
	3123	translateKeyCode( chm, code, ascii, state, text );
	3124
[170]	3125	// Note: code and/or chm.scancode may be zero here. We cannot ignore such
	3126	// events because, for example, all non-ASCII letters have zero virtual
	3127	// codes, and DBCS characters entered via IME have both zero virtual codes
	3128	// and zero scancodes. However, if both code and chm.scancode are zero
	3129	// (as for DBCS), store_key_rec()/find_key_rec() will do nothing which
	3130	// means that:
	3131	// 1) QKeyEvents will not have the auto-repeat flag set when a key is
	3132	// being auto-repeated by the system;
	3133	// 2) there will be no QEvent::KeyRelease event corresponding to the
	3134	// QEvent::KeyPress event.
[169]	3135
[8]	3136	// Invert state logic
	3137	if ( code == Key_Alt )
	3138	state = state ^ AltButton;
	3139	else if ( code == Key_Control )
	3140	state = state ^ ControlButton;
	3141	else if ( code == Key_Shift )
	3142	state = state ^ ShiftButton;
	3143
	3144	if ( !(chm.fs & KC_KEYUP) ) {
	3145	// KEYDOWN
	3146	KeyRec* rec = find_key_rec( chm.scancode, FALSE );
	3147
	3148	if ( state == Qt::AltButton ) {
	3149	// Special handling of global PM hotkeys
	3150	switch ( code ) {
	3151	case Qt::Key_Space:
	3152	if ( qt_show_system_menu( topLevelWidget() ) ) {
	3153	// remove the Key_Alt from the buffer (otherwise we will
	3154	// not get the next "Alt pressed" event because the
[106]	3155	// "Alt depressed" event, that must preceed it, will be
[8]	3156	// eaten by the system)
[169]	3157	find_key_rec( Qt::Key_Alt, TRUE );
[106]	3158	/// @todo (dmik) do the same for other global keys (ALT+TAB, ALT+ESC, CTRL+ESC)
[8]	3159	// by handling this situation when we obtain/loose focus)
[106]	3160	/// @todo (dmik) update: I don't actually think the above should be done, because
	3161	// it will not solve the problem of stuck modifier keys in general (there may be
	3162	// other combinations stolen by the system or other apps). More over, I guess
	3163	// that find_key_rec() above should also be removed to get identical behavior for
	3164	// all stolen keys. This will allow to solve the problem on the Qt application
[169]	3165	// level if needed (and even in a platform-independent manner).
[8]	3166	}
	3167	return TRUE;
	3168	case Qt::Key_F4:
	3169	// we handle this key combination ourselves because not
	3170	// all top-level widgets have the system menu
	3171	WinPostMsg( topLevelWidget()->winFId(), WM_CLOSE, 0, 0 );
	3172	// see the comment above
	3173	find_key_rec( Qt::Key_Alt, TRUE );
	3174	return TRUE;
	3175	default:
	3176	break;
	3177	}
	3178	}
	3179
	3180	if ( rec ) {
	3181	// it is already down (so it is auto-repeating)
	3182	if ( rec->code < Key_Shift \|\| rec->code > Key_ScrollLock ) {
	3183	k0 = sendKeyEvent( QEvent::KeyRelease, rec->code, rec->ascii,
[106]	3184	state, grab, rec->text, TRUE );
[8]	3185	k1 = sendKeyEvent( QEvent::KeyPress, rec->code, rec->ascii,
[106]	3186	state, grab, rec->text, TRUE );
[8]	3187	}
	3188	} else {
	3189	// map shift+tab to shift+backtab, QAccel knows about it
	3190	// and will handle it
	3191	if ( code == Key_Tab && ( state & ShiftButton ) == ShiftButton )
	3192	code = Key_BackTab;
	3193	store_key_rec( chm.scancode, code, ascii, text );
	3194	k0 = sendKeyEvent( QEvent::KeyPress, code, ascii,
	3195	state, grab, text );
	3196	}
	3197	} else {
	3198	// KEYUP
	3199	KeyRec* rec = find_key_rec( chm.scancode, TRUE );
	3200	if ( !rec ) {
	3201	// Someone ate the key down event
	3202	} else {
	3203	k0 = sendKeyEvent( QEvent::KeyRelease, rec->code, rec->ascii,
[106]	3204	state, grab, rec->text );
[8]	3205
	3206	// keyboard context menu event
	3207	if ( rec->code == Key_Menu && !state )
	3208	WinPostMsg( qmsg.hwnd, WM_CONTEXTMENU, 0, MPFROM2SHORT( 0, 1 ) );
	3209	}
	3210	}
	3211
[169]	3212	#if 0
[106]	3213	qDebug("WM_CHAR: RESULT = %d", (k0 \|\| k1));
[169]	3214	#endif
[8]	3215	return k0 \|\| k1;
	3216	}
	3217
	3218	#ifndef QT_NO_WHEELEVENT
	3219	bool QETWidget::translateWheelEvent( const QMSG &qmsg )
	3220	{
	3221	enum { WHEEL_DELTA = 120 };
	3222
[77]	3223	if ( sm_blockUserInput ) // block user interaction during session management
	3224	return TRUE;
[8]	3225
	3226	// consume duplicate wheel events sent by the AMouse driver to emulate
	3227	// multiline scrolls. we need this since currently Qt (QScrollBar, for
	3228	// instance) maintains the number of lines to scroll per wheel rotation
	3229	// (including the special handling of CTRL and SHIFT modifiers) on its own
	3230	// and doesn't have a setting to tell it to be aware of system settings
	3231	// for the mouse wheel. if we had processed events as they are, we would
	3232	// get a confusing behavior (too many lines scrolled etc.).
	3233	{
	3234	int devh = QApplication::desktop()->height();
	3235	QMSG wheelMsg;
	3236	while (
	3237	WinPeekMsg( 0, &wheelMsg, qmsg.hwnd, qmsg.msg, qmsg.msg, PM_NOREMOVE )
	3238	) {
	3239	// PM bug: ptl contains SHORT coordinates although fields are LONG
	3240	wheelMsg.ptl.x = (short) wheelMsg.ptl.x;
	3241	wheelMsg.ptl.y = (short) wheelMsg.ptl.y;
	3242	// flip y coordinate
	3243	wheelMsg.ptl.y = devh - (wheelMsg.ptl.y + 1);
	3244	if (
	3245	wheelMsg.mp1 != qmsg.mp1 \|\|
	3246	wheelMsg.mp2 != qmsg.mp2 \|\|
	3247	wheelMsg.ptl.x != qmsg.ptl.x \|\|
	3248	wheelMsg.ptl.y != qmsg.ptl.y
	3249	)
	3250	break;
	3251	WinPeekMsg( 0, &wheelMsg, qmsg.hwnd, qmsg.msg, qmsg.msg, PM_REMOVE );
	3252	}
	3253	}
	3254
	3255	int delta;
	3256	USHORT cmd = SHORT2FROMMP(qmsg.mp2);
	3257	switch ( cmd ) {
	3258	case SB_LINEUP:
	3259	case SB_PAGEUP:
	3260	delta = WHEEL_DELTA;
	3261	break;
	3262	case SB_LINEDOWN:
	3263	case SB_PAGEDOWN:
	3264	delta = -WHEEL_DELTA;
	3265	break;
	3266	default:
	3267	return FALSE;
	3268	}
	3269
	3270	int state = 0;
	3271	if ( WinGetKeyState( HWND_DESKTOP, VK_SHIFT ) & 0x8000 )
	3272	state \|= ShiftButton;
	3273	if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 \|\|
	3274	(qt_extraKeyState & Qt::AltButton)
	3275	)
	3276	state \|= AltButton;
	3277	if ( WinGetKeyState( HWND_DESKTOP, VK_CTRL ) & 0x8000 )
	3278	state \|= ControlButton;
	3279	if ( qt_extraKeyState & Qt::MetaButton )
	3280	state \|= MetaButton;
	3281
	3282	Orientation orient;
	3283	// Alt inverts scroll orientation (Qt/Win32 behavior)
	3284	if ( state & AltButton )
	3285	orient = qmsg.msg == WM_VSCROLL ? Horizontal : Vertical;
	3286	else
	3287	orient = qmsg.msg == WM_VSCROLL ? Vertical : Horizontal;
	3288
	3289	QPoint globalPos (qmsg.ptl.x, qmsg.ptl.y);
	3290
	3291	// if there is a widget under the mouse and it is not shadowed
	3292	// by modality, we send the event to it first
	3293	int ret = 0;
	3294	QWidget* w = QApplication::widgetAt( globalPos, TRUE );
	3295	if ( !w \|\| !qt_try_modal( w, (QMSG*)&qmsg, ret ) )
	3296	w = this;
	3297
	3298	// send the event to the widget or its ancestors
	3299	{
	3300	QWidget* popup = qApp->activePopupWidget();
	3301	if ( popup && w->topLevelWidget() != popup )
	3302	popup->close();
	3303	QWheelEvent e( w->mapFromGlobal( globalPos ), globalPos, delta, state, orient );
	3304	if ( QApplication::sendSpontaneousEvent( w, &e ) )
	3305	return TRUE;
	3306	}
	3307
	3308	// send the event to the widget that has the focus or its ancestors, if different
	3309	if ( w != qApp->focusWidget() && ( w = qApp->focusWidget() ) ) {
	3310	QWidget* popup = qApp->activePopupWidget();
	3311	if ( popup && w->topLevelWidget() != popup )
	3312	popup->close();
	3313	QWheelEvent e( w->mapFromGlobal( globalPos ), globalPos, delta, state, orient );
	3314	if ( QApplication::sendSpontaneousEvent( w, &e ) )
	3315	return TRUE;
	3316	}
	3317	return FALSE;
	3318	}
	3319	#endif
	3320
	3321	static bool isModifierKey(int code)
	3322	{
	3323	return code >= Qt::Key_Shift && code <= Qt::Key_ScrollLock;
	3324	}
	3325
	3326	bool QETWidget::sendKeyEvent( QEvent::Type type, int code, int ascii,
	3327	int state, bool grab, const QString& text,
	3328	bool autor )
	3329	{
	3330	if ( type == QEvent::KeyPress && !grab ) {
	3331	// send accel events if the keyboard is not grabbed
	3332	QKeyEvent a( type, code, ascii, state, text, autor, QMAX(1, int(text.length())) );
	3333	if ( qt_tryAccelEvent( this, &a ) )
	3334	return TRUE;
	3335	}
	3336	if ( !isEnabled() )
	3337	return FALSE;
	3338	QKeyEvent e( type, code, ascii, state, text, autor, QMAX(1, int(text.length())) );
	3339	QApplication::sendSpontaneousEvent( this, &e );
	3340	if ( !isModifierKey(code) && state == Qt::AltButton
	3341	&& ((code>=Key_A && code<=Key_Z) \|\| (code>=Key_0 && code<=Key_9))
	3342	&& type == QEvent::KeyPress && !e.isAccepted() )
	3343	QApplication::beep(); // emulate PM behavior
	3344	return e.isAccepted();
	3345	}
	3346
	3347
	3348	//
	3349	// Paint event translation
	3350	//
	3351	bool QETWidget::translatePaintEvent( const QMSG & )
	3352	{
[78]	3353	HPS displayPS = qt_display_ps();
	3354
[64]	3355	#if !defined (QT_PM_NO_WIDGETMASK)
	3356	// Since we don't use WS_CLIPSIBLINGS and WS_CLIPCHILDREN bits (see
	3357	// qwidget_pm.cpp), we have to validate areas that intersect with our
	3358	// children and siblings, taking their clip regions into account.
	3359	validateObstacles();
	3360	#endif
[78]	3361
[64]	3362	HRGN hrgn = GpiCreateRegion( displayPS, 0, NULL );
[8]	3363	LONG rc = WinQueryUpdateRegion( winId(), hrgn );
[64]	3364	if ( rc == RGN_ERROR ) {
	3365	GpiDestroyRegion( displayPS, hrgn );
[8]	3366	hps = 0;
	3367	clearWState( WState_InPaintEvent );
	3368	return FALSE;
	3369	}
	3370
	3371	setWState( WState_InPaintEvent );
	3372	RECTL rcl;
	3373	hps = WinBeginPaint( winId(), 0, &rcl );
	3374
	3375	// convert to width and height
	3376	rcl.xRight -= rcl.xLeft;
	3377	rcl.yTop -= rcl.yBottom;
	3378
	3379	// it's possible that the update rectangle is empty
	3380	if ( !rcl.xRight \|\| !rcl.yTop ) {
	3381	WinEndPaint( hps );
[64]	3382	GpiDestroyRegion( displayPS, hrgn );
[8]	3383	hps = 0;
	3384	clearWState( WState_InPaintEvent );
	3385	return TRUE;
	3386	}
	3387
[64]	3388	#if !defined (QT_PM_NO_WIDGETMASK)
	3389	if ( WinQueryClipRegion( winId(), 0 ) != QCRGN_NO_CLIP_REGION ) {
	3390	// Correct the update region by intersecting it with the clip
	3391	// region (PM doesn't do that itself). It is necessary
	3392	// to have a correct QRegion in QPaintEvent.
	3393	HRGN hcrgn = GpiCreateRegion( displayPS, 0, NULL );
	3394	WinQueryClipRegion( winId(), hcrgn );
	3395	GpiCombineRegion( displayPS, hrgn, hrgn, hcrgn, CRGN_AND );
	3396	GpiDestroyRegion( displayPS, hcrgn );
	3397	}
	3398	#endif
[78]	3399
[8]	3400	// flip y coordinate
	3401	rcl.yBottom = height() - (rcl.yBottom + rcl.yTop);
	3402
	3403	// erase background
	3404	#if !defined (DEBUG_REPAINTRESIZE)
	3405	bool erase = !( testWFlags( WRepaintNoErase ) );
	3406	#else
	3407	// Some oldish Qt widgets think that if they specify WRepaintNoErase but
	3408	// not WResizeNoErase, the background should still be erased for them
	3409	// in repaint events. The code below is left to debug these widgets
	3410	// (to ensure this is the exact cause of repaint problems)
	3411	bool erase = testWFlags( WRepaintNoErase \| WResizeNoErase ) != WRepaintNoErase \| WResizeNoErase;
	3412	#endif
	3413	if ( erase )
	3414	this->erase( rcl.xLeft, rcl.yBottom,
	3415	rcl.xRight, rcl.yTop );
	3416
	3417	#if defined (DEBUG_REPAINTRESIZE)
	3418	qDebug( "WM_PAINT: [%s/%s/%08X] %ld,%ld; %ld,%ld erase: %d",
	3419	name(), className(), widget_flags,
	3420	rcl.xLeft, rcl.yBottom, rcl.xRight, rcl.yTop, erase );
	3421	#endif
	3422
[61]	3423	// create a region that will take ownership of hrgn
	3424	QRegion rgn( hrgn, height() );
[8]	3425
[61]	3426	QPaintEvent e( rgn, QRect( rcl.xLeft, rcl.yBottom, rcl.xRight, rcl.yTop ),
	3427	erase );
[8]	3428	QApplication::sendSpontaneousEvent( this, (QEvent*) &e );
	3429
	3430	WinEndPaint( hps );
	3431	hps = 0;
	3432	clearWState( WState_InPaintEvent );
	3433	return TRUE;
	3434	}
	3435
	3436	//
	3437	// Window move and resize (configure) events
	3438	//
	3439
	3440	bool QETWidget::translateConfigEvent( const QMSG &qmsg )
	3441	{
	3442	if ( !testWState(WState_Created) ) // in QWidget::create()
	3443	return TRUE;
	3444
	3445	WId fId = winFId();
	3446	ULONG fStyle = WinQueryWindowULong( fId, QWL_STYLE );
	3447	if ( testWState( WState_ConfigPending ) ) {
	3448	// it's possible that we're trying to set the frame size smaller
	3449	// than it possible for WC_FRAME in QWidget::internalSetGeometry().
	3450	// here we correct this (crect there is set before WinSetWindowPos()
	3451	// that sends WM_SIZE).
	3452	QSize newSize( SHORT1FROMMP(qmsg.mp2), SHORT2FROMMP(qmsg.mp2) );
[64]	3453	if ( qmsg.msg == WM_SIZE && size() != newSize ) {
[102]	3454	crect.setSize( newSize );
[64]	3455	}
[8]	3456	return TRUE;
	3457	}
	3458	setWState( WState_ConfigPending ); // set config flag
	3459	QRect cr = geometry();
	3460	if ( qmsg.msg == WM_SIZE ) { // resize event
	3461	QSize oldSize = size();
	3462	QSize newSize( SHORT1FROMMP(qmsg.mp2), SHORT2FROMMP(qmsg.mp2) );
	3463	cr.setSize( newSize );
[102]	3464	crect = cr;
[8]	3465	if ( isTopLevel() ) { // update caption/icon text
	3466	createTLExtra();
	3467	QString txt;
	3468	if ( (fStyle & WS_MAXIMIZED) && !!iconText() )
	3469	txt = iconText();
	3470	else
	3471	if ( !caption().isNull() )
	3472	txt = caption();
	3473
	3474	if ( !!txt ) {
	3475	WinSetWindowText( fId, txt.local8Bit() );
	3476	}
	3477	}
[102]	3478	if ( oldSize != newSize) {
[64]	3479	#if !defined (QT_PM_NO_WIDGETMASK)
	3480	// Spontaneous (external to Qt) WM_SIZE messages should occur only
	3481	// on top-level widgets. If we get them for a non top-level widget,
	3482	// the result will most likely be incorrect because widget masks will
	3483	// not be properly processed (i.e. in the way it is done in
	3484	// QWidget::internalSetGeometry() when the geometry is changed from
	3485	// within Qt). So far, I see no need to support this (who will ever
	3486	// need to move a non top-level window of a foreign process?).
	3487	Q_ASSERT( isTopLevel() );
[78]	3488	#endif
[8]	3489	if ( isVisible() ) {
	3490	QResizeEvent e( newSize, oldSize );
	3491	QApplication::sendSpontaneousEvent( this, &e );
	3492	if ( !testWFlags( WStaticContents ) )
[195]	3493	repaint( testWFlags(WNoAutoErase) != WNoAutoErase );
[8]	3494	} else {
	3495	QResizeEvent *e = new QResizeEvent( newSize, oldSize );
	3496	QApplication::postEvent( this, e );
	3497	}
	3498	}
	3499	} else if ( qmsg.msg == WM_MOVE ) { // move event
	3500	QPoint oldPos = geometry().topLeft();
	3501	SWP swp;
	3502	if ( isTopLevel() ) {
	3503	WinQueryWindowPos( fId, &swp );
	3504	// flip y coordinate
	3505	swp.y = QApplication::desktop()->height() - ( swp.y + swp.cy );
	3506	QTLWExtra *top = topData();
	3507	swp.x += top->fleft;
	3508	swp.y += top->ftop;
	3509	} else {
	3510	WinQueryWindowPos( winId(), &swp );
	3511	// flip y coordinate
	3512	swp.y = parentWidget()->height() - ( swp.y + swp.cy );
	3513	}
	3514	QPoint newCPos( swp.x, swp.y );
	3515	if ( newCPos != oldPos ) {
	3516	cr.moveTopLeft( newCPos );
	3517	crect = cr;
	3518	if ( isVisible() ) {
	3519	QMoveEvent e( newCPos, oldPos ); // cpos (client position)
	3520	QApplication::sendSpontaneousEvent( this, &e );
	3521	} else {
	3522	QMoveEvent * e = new QMoveEvent( newCPos, oldPos );
	3523	QApplication::postEvent( this, e );
	3524	}
	3525	}
	3526	}
	3527	clearWState( WState_ConfigPending ); // clear config flag
	3528	return TRUE;
	3529	}
	3530
	3531
	3532	//
	3533	// Close window event translation.
	3534	//
	3535	// This class is a friend of QApplication because it needs to emit the
	3536	// lastWindowClosed() signal when the last top level widget is closed.
	3537	//
	3538
	3539	bool QETWidget::translateCloseEvent( const QMSG & )
	3540	{
	3541	return close(FALSE);
	3542	}
	3543
	3544	void QApplication::setCursorFlashTime( int msecs )
	3545	{
	3546	WinSetSysValue( HWND_DESKTOP, SV_CURSORRATE, msecs / 2 );
	3547	cursor_flash_time = msecs;
	3548	}
	3549
	3550	int QApplication::cursorFlashTime()
	3551	{
	3552	int blink = (int) WinQuerySysValue( HWND_DESKTOP, SV_CURSORRATE );
	3553	if ( !blink )
	3554	return cursor_flash_time;
	3555	if (blink > 0)
	3556	return 2*blink;
	3557	return 0;
	3558	}
	3559
	3560	void QApplication::setDoubleClickInterval( int ms )
	3561	{
	3562	WinSetSysValue( HWND_DESKTOP, SV_DBLCLKTIME, ms );
	3563	mouse_double_click_time = ms;
	3564	}
	3565
	3566
	3567	int QApplication::doubleClickInterval()
	3568	{
	3569	int ms = (int) WinQuerySysValue( HWND_DESKTOP, SV_DBLCLKTIME );
	3570	if ( ms != 0 )
	3571	return ms;
	3572	return mouse_double_click_time;
	3573	}
	3574
	3575	void QApplication::setWheelScrollLines( int n )
	3576	{
	3577	wheel_scroll_lines = n;
	3578	}
	3579
	3580	int QApplication::wheelScrollLines()
	3581	{
	3582	return wheel_scroll_lines;
	3583	}
	3584
	3585	void QApplication::setEffectEnabled( Qt::UIEffect effect, bool enable )
	3586	{
	3587	#ifndef QT_NO_EFFECTS
	3588	switch (effect) {
	3589	case UI_AnimateMenu:
	3590	if ( enable ) fade_menu = FALSE;
	3591	animate_menu = enable;
	3592	break;
	3593	case UI_FadeMenu:
	3594	if ( enable )
	3595	animate_menu = TRUE;
	3596	fade_menu = enable;
	3597	break;
	3598	case UI_AnimateCombo:
	3599	animate_combo = enable;
	3600	break;
	3601	case UI_AnimateTooltip:
	3602	if ( enable ) fade_tooltip = FALSE;
	3603	animate_tooltip = enable;
	3604	break;
	3605	case UI_FadeTooltip:
	3606	if ( enable )
	3607	animate_tooltip = TRUE;
	3608	fade_tooltip = enable;
	3609	break;
	3610	case UI_AnimateToolBox:
	3611	animate_toolbox = enable;
	3612	break;
	3613	default:
	3614	animate_ui = enable;
	3615	break;
	3616	}
	3617	#endif
	3618	}
	3619
	3620	bool QApplication::isEffectEnabled( Qt::UIEffect effect )
	3621	{
	3622	#ifndef QT_NO_EFFECTS
	3623	if ( QColor::numBitPlanes() < 16 \|\| !animate_ui )
	3624	return FALSE;
	3625
	3626	switch( effect ) {
	3627	case UI_AnimateMenu:
	3628	return animate_menu;
	3629	case UI_FadeMenu:
	3630	return fade_menu;
	3631	case UI_AnimateCombo:
	3632	return animate_combo;
	3633	case UI_AnimateTooltip:
	3634	return animate_tooltip;
	3635	case UI_FadeTooltip:
	3636	return fade_tooltip;
	3637	case UI_AnimateToolBox:
	3638	return animate_toolbox;
	3639	default:
	3640	return animate_ui;
	3641	}
	3642	#else
	3643	return FALSE;
	3644	#endif
	3645	}
	3646
	3647	void QApplication::flush()
	3648	{
	3649	}
	3650
[77]	3651	#if !defined (QT_NO_SESSIONMANAGER)
[8]	3652
[77]	3653	bool qt_app_canQuit()
	3654	{
[78]	3655	#if defined (DEBUG_SESSIONMANAGER)
[77]	3656	qDebug( "qt_app_canQuit(): sm_smActive=%d qt_about_to_destroy_wnd=%d "
	3657	"sm_gracefulShutdown=%d sm_cancel=%d",
	3658	sm_smActive, qt_about_to_destroy_wnd,
[78]	3659	sm_gracefulShutdown, sm_cancel );
[77]	3660	#endif
	3661
	3662	BOOL answer = FALSE;
	3663
	3664	// We can get multiple WM_QUIT messages while the "session termination
	3665	// procedure" (i.e. the QApplication::commitData() call) is still in
	3666	// progress. Ignore them.
	3667	if ( !sm_smActive ) {
[78]	3668	if ( sm_gracefulShutdown ) {
	3669	// this is WM_QUIT after WM_SAVEAPPLICATION (either posted by the OS
	3670	// or by ourselves), confirm the quit depending on what the user wants
	3671	sm_quitSkipped = FALSE;
	3672	answer = !sm_cancel;
	3673	if ( sm_cancel ) {
	3674	// the shutdown has been canceled, reset the flag to let the
	3675	// graceful shutdown happen again later
	3676	sm_gracefulShutdown = FALSE;
	3677	}
	3678	} else {
	3679	// sm_gracefulShutdown is FALSE, so allowsInteraction() and friends
	3680	// will return FALSE during commitData() (assuming that WM_QUIT w/o
	3681	// WM_SAVEAPPLICATION is an emergency termination)
	3682	sm_smActive = TRUE;
	3683	sm_blockUserInput = TRUE; // prevent user-interaction outside interaction windows
	3684	sm_cancel = FALSE;
	3685	if ( qt_session_manager_self )
	3686	qApp->commitData( *qt_session_manager_self );
	3687	sm_smActive = FALSE;
	3688	answer = TRUE; // ignore sm_cancel
	3689	}
	3690	} else {
	3691	// if this is a WM_QUIT received during WM_SAVEAPPLICATION handling,
	3692	// remember we've skipped (refused) it
	3693	if ( sm_gracefulShutdown )
	3694	sm_quitSkipped = TRUE;
[77]	3695	}
[78]	3696
	3697	#if defined (DEBUG_SESSIONMANAGER)
[77]	3698	qDebug( "qt_app_canQuit(): answer=%ld", answer );
	3699	#endif
	3700
	3701	return answer;
	3702	}
	3703
	3704	bool QSessionManager::allowsInteraction()
	3705	{
	3706	// Allow interation only when the system is being normally shutdown
	3707	// and informs us using WM_SAVEAPPLICATION. When we receive WM_QUIT directly
	3708	// (so sm_gracefulShutdown is FALSE), interaction is disallowed.
	3709	if ( sm_smActive && sm_gracefulShutdown ) {
	3710	sm_blockUserInput = FALSE;
	3711	return TRUE;
	3712	}
	3713
	3714	return FALSE;
	3715	}
	3716
	3717	bool QSessionManager::allowsErrorInteraction()
	3718	{
	3719	// Allow interation only when the system is being normally shutdown
	3720	// and informs us using WM_SAVEAPPLICATION. When we receive WM_QUIT directly
	3721	// (so sm_gracefulShutdown is FALSE), interaction is disallowed.
	3722	if ( sm_smActive && sm_gracefulShutdown ) {
	3723	sm_blockUserInput = FALSE;
	3724	return TRUE;
	3725	}
	3726
	3727	return FALSE;
	3728	}
	3729
	3730	void QSessionManager::release()
	3731	{
	3732	if ( sm_smActive && sm_gracefulShutdown )
	3733	sm_blockUserInput = TRUE;
	3734	}
	3735
	3736	void QSessionManager::cancel()
	3737	{
	3738	if ( sm_smActive && sm_gracefulShutdown )
	3739	sm_cancel = TRUE;
	3740	}
	3741
	3742	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/kernel/qapplication_pm.cpp

Download in other formats: