Add Qt3 development HEAD version

1 files changed, 1074 insertions, 0 deletions

diff --git a/src/kernel/qwidget.h b/src/kernel/qwidget.h
new file mode 100644
index 0000000..c83acb5
--- /dev/null
+++ b/src/kernel/qwidget.h
@@ -0,0 +1,1074 @@
+/****************************************************************************
+**
+** Definition of QWidget class
+**
+** Created : 931029
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QWIDGET_H
+#define QWIDGET_H
+
+#ifndef QT_H
+#include "qwindowdefs.h"
+#include "qobject.h"
+#include "qpaintdevice.h"
+#include "qpalette.h"
+#include "qfont.h"
+#include "qfontmetrics.h"
+#include "qfontinfo.h"
+#include "qsizepolicy.h"
+#endif // QT_H
+
+#if defined(Q_WS_X11) && !defined(QT_NO_IM)
+class QInputContext;
+#endif
+
+class QLayout;
+struct QWExtra;
+struct QTLWExtra;
+class QFocusData;
+class QCursor;
+class QWSRegionManager;
+class QStyle;
+
+class Q_EXPORT QWidget : public QObject, public QPaintDevice
+{
+    Q_OBJECT
+    Q_ENUMS( BackgroundMode FocusPolicy BackgroundOrigin )
+    Q_PROPERTY( bool isTopLevel READ isTopLevel )
+    Q_PROPERTY( bool isDialog READ isDialog )
+    Q_PROPERTY( bool isModal READ isModal )
+    Q_PROPERTY( bool isPopup READ isPopup )
+    Q_PROPERTY( bool isDesktop READ isDesktop )
+    Q_PROPERTY( bool enabled READ isEnabled WRITE setEnabled )
+    Q_PROPERTY( QRect geometry READ geometry WRITE setGeometry )
+    Q_PROPERTY( QRect frameGeometry READ frameGeometry )
+    Q_PROPERTY( int x READ x )
+    Q_PROPERTY( int y READ y )
+    Q_PROPERTY( QPoint pos READ pos WRITE move DESIGNABLE false STORED false )
+    Q_PROPERTY( QSize frameSize READ frameSize )
+    Q_PROPERTY( QSize size READ size WRITE resize DESIGNABLE false STORED false )
+    Q_PROPERTY( int width READ width )
+    Q_PROPERTY( int height READ height )
+    Q_PROPERTY( QRect rect READ rect )
+    Q_PROPERTY( QRect childrenRect READ childrenRect )
+    Q_PROPERTY( QRegion childrenRegion READ childrenRegion )
+    Q_PROPERTY( QSizePolicy sizePolicy READ sizePolicy WRITE setSizePolicy )
+    Q_PROPERTY( QSize minimumSize READ minimumSize WRITE setMinimumSize )
+    Q_PROPERTY( QSize maximumSize READ maximumSize WRITE setMaximumSize )
+    Q_PROPERTY( int minimumWidth READ minimumWidth WRITE setMinimumWidth STORED false DESIGNABLE false )
+    Q_PROPERTY( int minimumHeight READ minimumHeight WRITE setMinimumHeight STORED false DESIGNABLE false )
+    Q_PROPERTY( int maximumWidth READ maximumWidth WRITE setMaximumWidth STORED false DESIGNABLE false )
+    Q_PROPERTY( int maximumHeight READ maximumHeight WRITE setMaximumHeight STORED false DESIGNABLE false )
+    Q_PROPERTY( QSize sizeIncrement READ sizeIncrement WRITE setSizeIncrement )
+    Q_PROPERTY( QSize baseSize READ baseSize WRITE setBaseSize )
+    Q_PROPERTY( BackgroundMode backgroundMode READ backgroundMode WRITE setBackgroundMode DESIGNABLE false )
+    Q_PROPERTY( QColor paletteForegroundColor READ paletteForegroundColor WRITE setPaletteForegroundColor RESET unsetPalette )
+    Q_PROPERTY( QColor paletteBackgroundColor READ paletteBackgroundColor WRITE setPaletteBackgroundColor RESET unsetPalette )
+    Q_PROPERTY( QPixmap paletteBackgroundPixmap READ paletteBackgroundPixmap WRITE setPaletteBackgroundPixmap RESET unsetPalette )
+    Q_PROPERTY( QBrush backgroundBrush READ backgroundBrush )
+    Q_PROPERTY( QColorGroup colorGroup READ colorGroup )
+    Q_PROPERTY( QPalette palette READ palette WRITE setPalette RESET unsetPalette  STORED ownPalette )
+    Q_PROPERTY( BackgroundOrigin backgroundOrigin READ backgroundOrigin WRITE setBackgroundOrigin )
+    Q_PROPERTY( bool ownPalette READ ownPalette )
+    Q_PROPERTY( QFont font READ font WRITE setFont RESET unsetFont STORED ownFont )
+    Q_PROPERTY( bool ownFont READ ownFont )
+#ifndef QT_NO_CURSOR
+    Q_PROPERTY( QCursor cursor READ cursor WRITE setCursor RESET unsetCursor STORED ownCursor )
+    Q_PROPERTY( bool ownCursor READ ownCursor )
+#endif
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    Q_PROPERTY( QString caption READ caption WRITE setCaption )
+    Q_PROPERTY( QPixmap icon READ icon WRITE setIcon )
+    Q_PROPERTY( QString iconText READ iconText WRITE setIconText )
+#endif
+    Q_PROPERTY( bool mouseTracking READ hasMouseTracking WRITE setMouseTracking )
+    Q_PROPERTY( bool underMouse READ hasMouse )
+    Q_PROPERTY( bool isActiveWindow READ isActiveWindow )
+    Q_PROPERTY( bool focusEnabled READ isFocusEnabled )
+    Q_PROPERTY( FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy )
+    Q_PROPERTY( bool focus READ hasFocus )
+    Q_PROPERTY( bool updatesEnabled READ isUpdatesEnabled WRITE setUpdatesEnabled DESIGNABLE false )
+    Q_PROPERTY( bool visible READ isVisible )
+    Q_PROPERTY( QRect visibleRect READ visibleRect ) // obsolete
+    Q_PROPERTY( bool hidden READ isHidden WRITE setHidden DESIGNABLE false SCRIPTABLE false )
+    Q_PROPERTY( bool shown READ isShown WRITE setShown DESIGNABLE false SCRIPTABLE false )
+    Q_PROPERTY( bool minimized READ isMinimized )
+    Q_PROPERTY( bool maximized READ isMaximized )
+    Q_PROPERTY( bool fullScreen READ isFullScreen )
+    Q_PROPERTY( QSize sizeHint READ sizeHint )
+    Q_PROPERTY( QSize minimumSizeHint READ minimumSizeHint )
+    Q_PROPERTY( QRect microFocusHint READ microFocusHint )
+    Q_PROPERTY( bool acceptDrops READ acceptDrops WRITE setAcceptDrops )
+    Q_PROPERTY( bool autoMask READ autoMask WRITE setAutoMask DESIGNABLE false SCRIPTABLE false )
+    Q_PROPERTY( bool customWhatsThis READ customWhatsThis )
+    Q_PROPERTY( bool inputMethodEnabled READ isInputMethodEnabled WRITE setInputMethodEnabled DESIGNABLE false SCRIPTABLE false )
+    Q_PROPERTY( double windowOpacity READ windowOpacity WRITE setWindowOpacity DESIGNABLE false )
+
+public:
+    Q_EXPLICIT QWidget( QWidget* parent=0, const char* name=0, WFlags f=0 );
+    ~QWidget();
+
+    WId		 winId() const;
+    void	 setName( const char *name );
+#ifndef QT_NO_STYLE
+    // GUI style setting
+
+    QStyle     &style() const;
+    void        setStyle( QStyle * );
+    QStyle*	setStyle( const QString& );
+#endif
+    // Widget types and states
+
+    bool	 isTopLevel()	const;
+    bool	 isDialog()	const;
+    bool	 isPopup()	const;
+    bool	 isDesktop()	const;
+    bool	 isModal()	const;
+
+    bool	 isEnabled()	const;
+    bool	 isEnabledTo(QWidget*) const;
+    bool	 isEnabledToTLW() const;
+
+public slots:
+    virtual void setEnabled( bool );
+    void setDisabled( bool );
+
+    // Widget coordinates
+
+public:
+    QRect	 frameGeometry() const;
+    const QRect &geometry()	const;
+    int		 x()		const;
+    int		 y()		const;
+    QPoint	 pos()		const;
+    QSize	 frameSize()    const;
+    QSize	 size()		const;
+    int		 width()	const;
+    int		 height()	const;
+    QRect	 rect()		const;
+    QRect	 childrenRect() const;
+    QRegion	 childrenRegion() const;
+
+    QSize	 minimumSize()	 const;
+    QSize	 maximumSize()	 const;
+    int		 minimumWidth()	 const;
+    int		 minimumHeight() const;
+    int		 maximumWidth()	 const;
+    int		 maximumHeight() const;
+    void	 setMinimumSize( const QSize & );
+    virtual void setMinimumSize( int minw, int minh );
+    void	 setMaximumSize( const QSize & );
+    virtual void setMaximumSize( int maxw, int maxh );
+    void	 setMinimumWidth( int minw );
+    void	 setMinimumHeight( int minh );
+    void	 setMaximumWidth( int maxw );
+    void	 setMaximumHeight( int maxh );
+
+    QSize	 sizeIncrement() const;
+    void	 setSizeIncrement( const QSize & );
+    virtual void setSizeIncrement( int w, int h );
+    QSize	 baseSize() const;
+    void	 setBaseSize( const QSize & );
+    void	 setBaseSize( int basew, int baseh );
+
+    void	setFixedSize( const QSize & );
+    void	setFixedSize( int w, int h );
+    void	setFixedWidth( int w );
+    void	setFixedHeight( int h );
+
+    // Widget coordinate mapping
+
+    QPoint	 mapToGlobal( const QPoint & )	 const;
+    QPoint	 mapFromGlobal( const QPoint & ) const;
+    QPoint	 mapToParent( const QPoint & )	 const;
+    QPoint	 mapFromParent( const QPoint & ) const;
+    QPoint	 mapTo( QWidget *, const QPoint & ) const;
+    QPoint	 mapFrom( QWidget *, const QPoint & ) const;
+
+    QWidget	*topLevelWidget()   const;
+
+    // Widget attribute functions
+
+    BackgroundMode	backgroundMode() const;
+    virtual void	setBackgroundMode( BackgroundMode );
+    void 		setBackgroundMode( BackgroundMode, BackgroundMode );
+
+    const QColor &	foregroundColor() const;
+
+    const QColor &	eraseColor() const;
+    virtual void	setEraseColor( const QColor & );
+
+    const QPixmap *	erasePixmap() const;
+    virtual void	setErasePixmap( const QPixmap & );
+
+#ifndef QT_NO_PALETTE
+    const QColorGroup & colorGroup() const;
+    const QPalette &	palette()    const;
+    bool		ownPalette() const;
+    virtual void	setPalette( const QPalette & );
+    void		unsetPalette();
+#endif
+
+    const QColor &	paletteForegroundColor() const;
+    void		setPaletteForegroundColor( const QColor & );
+
+    const QColor &	paletteBackgroundColor() const;
+    virtual void	setPaletteBackgroundColor( const QColor & );
+
+    const QPixmap *	paletteBackgroundPixmap() const;
+    virtual void 	setPaletteBackgroundPixmap( const QPixmap & );
+
+    const QBrush&	backgroundBrush() const;
+
+    QFont		font() const;
+    bool		ownFont() const;
+    virtual void	setFont( const QFont & );
+    void		unsetFont();
+    QFontMetrics	fontMetrics() const;
+    QFontInfo	 	fontInfo() const;
+
+#ifndef QT_NO_CURSOR
+    const QCursor      &cursor() const;
+    bool		ownCursor() const;
+    virtual void	setCursor( const QCursor & );
+    virtual void	unsetCursor();
+#endif
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    QString		caption() const;
+    const QPixmap      *icon() const;
+    QString		iconText() const;
+#endif
+    bool		hasMouseTracking() const;
+    bool		hasMouse() const;
+
+    virtual void	setMask( const QBitmap & );
+    virtual void	setMask( const QRegion & );
+    void		clearMask();
+
+    const QColor &	backgroundColor() const; // obsolete, use eraseColor()
+    virtual void	setBackgroundColor( const QColor & ); // obsolete, use setEraseColor()
+    const QPixmap *	backgroundPixmap() const; // obsolete, use erasePixmap()
+    virtual void	setBackgroundPixmap( const QPixmap & ); // obsolete, use setErasePixmap()
+
+public slots:
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    virtual void	setCaption( const QString &);
+    virtual void	setIcon( const QPixmap & );
+    virtual void	setIconText( const QString &);
+#endif
+    virtual void	setMouseTracking( bool enable );
+
+    // Keyboard input focus functions
+
+    virtual void	setFocus();
+    void		clearFocus();
+
+public:
+    enum FocusPolicy {
+	NoFocus = 0,
+	TabFocus = 0x1,
+	ClickFocus = 0x2,
+	StrongFocus = TabFocus | ClickFocus | 0x8,
+	WheelFocus = StrongFocus | 0x4
+    };
+
+    bool		isActiveWindow() const;
+    virtual void	setActiveWindow();
+    bool		isFocusEnabled() const;
+
+    FocusPolicy		focusPolicy() const;
+    virtual void	setFocusPolicy( FocusPolicy );
+    bool		hasFocus() const;
+    static void		setTabOrder( QWidget *, QWidget * );
+    virtual void	setFocusProxy( QWidget * );
+    QWidget *		focusProxy() const;
+
+    void setInputMethodEnabled( bool b );
+    bool isInputMethodEnabled() const;
+    // Grab functions
+
+    void		grabMouse();
+#ifndef QT_NO_CURSOR
+    void		grabMouse( const QCursor & );
+#endif
+    void		releaseMouse();
+    void		grabKeyboard();
+    void		releaseKeyboard();
+    static QWidget *	mouseGrabber();
+    static QWidget *	keyboardGrabber();
+
+    // Update/refresh functions
+
+    bool	 	isUpdatesEnabled() const;
+
+#if 0 //def Q_WS_QWS
+    void		repaintUnclipped( const QRegion &, bool erase = TRUE );
+#endif
+public slots:
+    virtual void	setUpdatesEnabled( bool enable );
+    void		update();
+    void		update( int x, int y, int w, int h );
+    void		update( const QRect& );
+    void		repaint();
+    void		repaint( bool erase );
+    void		repaint( int x, int y, int w, int h, bool erase=TRUE );
+    void		repaint( const QRect &, bool erase = TRUE );
+    void		repaint( const QRegion &, bool erase = TRUE );
+
+    // Widget management functions
+
+    virtual void	show();
+    virtual void	hide();
+    void		setShown( bool show );
+    void		setHidden( bool hide );
+#ifndef QT_NO_COMPAT
+    void		iconify() { showMinimized(); }
+#endif
+    virtual void	showMinimized();
+    virtual void	showMaximized();
+    void		showFullScreen();
+    virtual void	showNormal();
+    virtual void	polish();
+    void 		constPolish() const;
+    bool		close();
+
+    void		raise();
+    void		lower();
+    void		stackUnder( QWidget* );
+    virtual void	move( int x, int y );
+    void		move( const QPoint & );
+    virtual void	resize( int w, int h );
+    void		resize( const QSize & );
+    virtual void	setGeometry( int x, int y, int w, int h );
+    virtual void	setGeometry( const QRect & ); // ### make non virtual in Qt 4?
+
+public:
+    virtual bool	close( bool alsoDelete );
+    bool		isVisible()	const;
+    bool		isVisibleTo(QWidget*) const;
+    bool		isVisibleToTLW() const; // obsolete
+    QRect		visibleRect() const; // obsolete
+    bool 		isHidden() const;
+    bool 		isShown() const;
+    bool		isMinimized() const;
+    bool		isMaximized() const;
+    bool		isFullScreen() const;
+
+    uint windowState() const;
+    void setWindowState(uint windowState);
+
+    virtual QSize	sizeHint() const;
+    virtual QSize	minimumSizeHint() const;
+    virtual QSizePolicy	sizePolicy() const;
+    virtual void	setSizePolicy( QSizePolicy );
+    void 		setSizePolicy( QSizePolicy::SizeType hor, QSizePolicy::SizeType ver, bool hfw = FALSE );
+    virtual int heightForWidth(int) const;
+
+    QRegion	clipRegion() const;
+
+// ### move together with other slots in Qt 4.0
+public slots:
+    virtual void  	adjustSize();
+
+public:
+#ifndef QT_NO_LAYOUT
+    QLayout *		layout() const { return lay_out; }
+#endif
+    void		updateGeometry();
+    virtual void 	reparent( QWidget *parent, WFlags, const QPoint &,
+				  bool showIt=FALSE );
+    void		reparent( QWidget *parent, const QPoint &,
+				  bool showIt=FALSE );
+#ifndef QT_NO_COMPAT
+    void		recreate( QWidget *parent, WFlags f, const QPoint & p,
+				  bool showIt=FALSE ) { reparent(parent,f,p,showIt); }
+#endif
+
+    void		erase();
+    void		erase( int x, int y, int w, int h );
+    void		erase( const QRect & );
+    void		erase( const QRegion & );
+    void		scroll( int dx, int dy );
+    void		scroll( int dx, int dy, const QRect& );
+
+    void		drawText( int x, int y, const QString &);
+    void		drawText( const QPoint &, const QString &);
+
+    // Misc. functions
+
+    QWidget *		focusWidget() const;
+    QRect               microFocusHint() const;
+
+    // drag and drop
+
+    bool		acceptDrops() const;
+    virtual void	setAcceptDrops( bool on );
+
+    // transparency and pseudo transparency
+
+    virtual void	setAutoMask(bool);
+    bool		autoMask() const;
+
+    enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin };
+
+    virtual void setBackgroundOrigin( BackgroundOrigin );
+    BackgroundOrigin backgroundOrigin() const;
+    QPoint backgroundOffset() const;
+
+    // whats this help
+    virtual bool customWhatsThis() const;
+
+    QWidget *		parentWidget( bool sameWindow = FALSE ) const;
+    WState		testWState( WState s ) const;
+    WFlags		testWFlags( WFlags f ) const;
+    static QWidget *	find( WId );
+    static QWidgetMapper *wmapper();
+
+    QWidget  *childAt( int x, int y, bool includeThis = FALSE ) const;
+    QWidget  *childAt( const QPoint &, bool includeThis = FALSE ) const;
+
+#if defined(Q_WS_QWS)
+    virtual QGfx * graphicsContext(bool clip_children=TRUE) const;
+#endif
+#if defined(Q_WS_MAC)
+    QRegion clippedRegion(bool do_children=TRUE);
+    uint clippedSerial(bool do_children=TRUE);
+#ifndef QMAC_NO_QUARTZ
+    CGContextRef macCGContext(bool clipped=TRUE) const;
+#endif
+#endif
+#if defined(Q_WS_X11)
+    enum X11WindowType {
+        X11WindowTypeSelect,
+        X11WindowTypeCombo,
+        X11WindowTypeDND,
+        X11WindowTypeTooltip,
+        X11WindowTypeMenu, // torn-off
+        X11WindowTypeDropdown,
+        X11WindowTypePopup
+    };
+    void x11SetWindowType( X11WindowType type = X11WindowTypeSelect );
+    void x11SetWindowTransient( QWidget* parent );
+#endif
+    void setWindowOpacity(double level);
+    double windowOpacity() const;
+
+protected:
+    // Event handlers
+    bool	 event( QEvent * );
+    virtual void mousePressEvent( QMouseEvent * );
+    virtual void mouseReleaseEvent( QMouseEvent * );
+    virtual void mouseDoubleClickEvent( QMouseEvent * );
+    virtual void mouseMoveEvent( QMouseEvent * );
+#ifndef QT_NO_WHEELEVENT
+    virtual void wheelEvent( QWheelEvent * );
+#endif
+    virtual void keyPressEvent( QKeyEvent * );
+    virtual void keyReleaseEvent( QKeyEvent * );
+    virtual void focusInEvent( QFocusEvent * );
+    virtual void focusOutEvent( QFocusEvent * );
+    virtual void enterEvent( QEvent * );
+    virtual void leaveEvent( QEvent * );
+    virtual void paintEvent( QPaintEvent * );
+    virtual void moveEvent( QMoveEvent * );
+    virtual void resizeEvent( QResizeEvent * );
+    virtual void closeEvent( QCloseEvent * );
+    virtual void contextMenuEvent( QContextMenuEvent * );
+    virtual void imStartEvent( QIMEvent * );
+    virtual void imComposeEvent( QIMEvent * );
+    virtual void imEndEvent( QIMEvent * );
+    virtual void tabletEvent( QTabletEvent * );
+
+#ifndef QT_NO_DRAGANDDROP
+    virtual void dragEnterEvent( QDragEnterEvent * );
+    virtual void dragMoveEvent( QDragMoveEvent * );
+    virtual void dragLeaveEvent( QDragLeaveEvent * );
+    virtual void dropEvent( QDropEvent * );
+#endif
+
+    virtual void showEvent( QShowEvent * );
+    virtual void hideEvent( QHideEvent * );
+
+#if defined(Q_WS_MAC)
+    virtual bool macEvent( MSG * );
+#endif
+#if defined(Q_WS_WIN)
+    virtual bool winEvent( MSG * );
+#endif
+#if defined(Q_WS_X11)
+    virtual bool x11Event( XEvent * );
+#endif
+#if defined(Q_WS_QWS)
+    virtual bool qwsEvent( QWSEvent * );
+    virtual unsigned char *scanLine( int ) const;
+    virtual int bytesPerLine() const;
+#endif
+
+    virtual void updateMask();
+
+    // Misc. protected functions
+
+#ifndef QT_NO_STYLE
+    virtual void styleChange( QStyle& );
+#endif
+    virtual void enabledChange( bool oldEnabled );
+#ifndef QT_NO_PALETTE
+    virtual void paletteChange( const QPalette & );
+#endif
+    virtual void fontChange( const QFont & );
+    virtual void windowActivationChange( bool oldActive );
+
+    int		 metric( int )	const;
+
+#if defined(Q_WS_X11)
+#if !defined(QT_NO_IM_EXTENSIONS)
+    virtual QWidget *icHolderWidget();
+#else
+    QWidget *icHolderWidget();
+#endif
+    QInputContext *getInputContext();
+    void	 changeInputContext( const QString & );
+    void	 sendMouseEventToInputContext( int x, QEvent::Type type,
+					       Qt::ButtonState button,
+					       Qt::ButtonState state );
+#endif
+    void	 resetInputContext();
+
+    virtual void create( WId = 0, bool initializeWindow = TRUE,
+			 bool destroyOldWindow = TRUE );
+    virtual void destroy( bool destroyWindow = TRUE,
+			  bool destroySubWindows = TRUE );
+    uint	 getWState() const;
+    virtual void setWState( uint );
+    void	 clearWState( uint n );
+    WFlags	 getWFlags() const;
+    virtual void setWFlags( WFlags );
+    void	 clearWFlags( WFlags n );
+
+    virtual bool focusNextPrevChild( bool next );
+
+    QWExtra	*extraData();
+    QTLWExtra	*topData();
+    QFocusData	*focusData();
+
+    virtual void setKeyCompression(bool);
+    virtual void setMicroFocusHint(int x, int y, int w, int h, bool text=TRUE, QFont *f = 0);
+
+#if defined(Q_WS_MAC)
+    void dirtyClippedRegion(bool);
+    bool isClippedRegionDirty();
+    virtual void setRegionDirty(bool);
+    virtual void macWidgetChangedWindow();
+#endif
+
+private slots:
+    void	 focusProxyDestroyed();
+#if defined(Q_WS_X11)
+    void	 destroyInputContext();
+#endif
+
+private:
+    void	 setFontSys( QFont *f = 0 );
+#if defined(Q_WS_X11)
+    void	 createInputContext();
+    void	 focusInputContext();
+    void	 unfocusInputContext();
+    void	 checkChildrenDnd();
+
+#ifndef QT_NO_XSYNC
+    void        createSyncCounter();
+    void        destroySyncCounter();
+    void        incrementSyncCounter();
+    void        handleSyncRequest( void* ev );
+#endif
+
+#elif defined(Q_WS_MAC)
+    uint    own_id : 1, macDropEnabled : 1;
+    EventHandlerRef window_event;
+    //mac event functions
+    void    propagateUpdates(bool update_rgn=TRUE);
+    void    update( const QRegion& );
+    //friends, way too many - fix this immediately!
+    friend void qt_clean_root_win();
+    friend bool qt_recreate_root_win();
+    friend QPoint posInWindow(QWidget *);
+    friend bool qt_mac_update_sizer(QWidget *, int);
+    friend QWidget *qt_recursive_match(QWidget *widg, int x, int y);
+    friend bool qt_paint_children(QWidget *,QRegion &, uchar ops);
+    friend QMAC_PASCAL OSStatus qt_window_event(EventHandlerCallRef er, EventRef event, void *);
+    friend void qt_event_request_updates(QWidget *, const QRegion &, bool subtract);
+    friend bool qt_window_rgn(WId, short, RgnHandle, bool);
+    friend class QDragManager;
+#endif
+
+#ifndef QT_NO_LAYOUT
+    void 	 setLayout( QLayout *l );
+#endif
+    void	 setWinId( WId );
+    void	 showWindow();
+    void	 hideWindow();
+    void	 showChildren( bool spontaneous );
+    void	 hideChildren( bool spontaneous );
+    void	 reparentSys( QWidget *parent, WFlags, const QPoint &,  bool showIt);
+    void	 createTLExtra();
+    void	 createExtra();
+    void	 deleteExtra();
+    void	 createSysExtra();
+    void	 deleteSysExtra();
+    void	 createTLSysExtra();
+    void	 deleteTLSysExtra();
+    void	 deactivateWidgetCleanup();
+    void	 internalSetGeometry( int, int, int, int, bool );
+    void	 reparentFocusWidgets( QWidget * );
+    QFocusData	*focusData( bool create );
+    void         setBackgroundFromMode();
+    void         setBackgroundColorDirect( const QColor & );
+    void   	 setBackgroundPixmapDirect( const QPixmap & );
+    void         setBackgroundModeDirect( BackgroundMode );
+    void         setBackgroundEmpty();
+    void	 updateFrameStrut() const;
+#if defined(Q_WS_X11)
+    void         setBackgroundX11Relative();
+#endif
+
+    WId		 winid;
+    uint	 widget_state;
+    uint	 widget_flags;
+    uint	 focus_policy : 4;
+    uint 	 own_font :1;
+    uint 	 own_palette :1;
+    uint 	 sizehint_forced :1;
+    uint 	 is_closing :1;
+    uint 	 in_show : 1;
+    uint 	 in_show_maximized : 1;
+    uint	 fstrut_dirty : 1;
+    uint	 im_enabled : 1;
+    QRect	 crect;
+    QColor	 bg_col;
+#ifndef QT_NO_PALETTE
+    QPalette	 pal;
+#endif
+    QFont	 fnt;
+#ifndef QT_NO_LAYOUT
+    QLayout 	*lay_out;
+#endif
+#if defined(Q_WS_X11) && !defined(QT_NO_IM) && !defined(QT_NO_IM_EXTENSIONS)
+    QInputContext *ic;				// Input Context
+#endif
+    QWExtra	*extra;
+#if defined(Q_WS_QWS)
+    QRegion	 req_region;			// Requested region
+    mutable QRegion	 paintable_region;	// Paintable region
+    mutable bool         paintable_region_dirty;// needs to be recalculated
+    mutable QRegion      alloc_region;          // Allocated region
+    mutable bool         alloc_region_dirty;    // needs to be recalculated
+    mutable int          overlapping_children;  // Handle overlapping children
+
+    int		 alloc_region_index;
+    int		 alloc_region_revision;
+
+    void updateOverlappingChildren() const;
+    void setChildrenAllocatedDirty();
+    void setChildrenAllocatedDirty( const QRegion &r, const QWidget *dirty=0 );
+    bool isAllocatedRegionDirty() const;
+    void updateRequestedRegion( const QPoint &gpos );
+    QRegion requestedRegion() const;
+    QRegion allocatedRegion() const;
+    QRegion paintableRegion() const;
+
+    void updateGraphicsContext( QGfx *qgfx_qws, bool clip_children ) const;
+#ifndef QT_NO_CURSOR
+    void updateCursor( const QRegion &r ) const;
+#endif
+
+    // used to accumulate dirty region when children moved/resized.
+    QRegion dirtyChildren;
+    bool isSettingGeometry;
+    friend class QWSManager;
+#endif
+    static int instanceCounter;  // Current number of widget instances
+    static int maxInstances;     // Maximum number of widget instances
+
+    static void	 createMapper();
+    static void	 destroyMapper();
+    static QWidgetList	 *wList();
+    static QWidgetList	 *tlwList();
+    static QWidgetMapper *mapper;
+    friend class QApplication;
+    friend class QBaseApplication;
+    friend class QPainter;
+    friend class QFontMetrics;
+    friend class QFontInfo;
+    friend class QETWidget;
+    friend class QLayout;
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QWidget( const QWidget & );
+    QWidget &operator=( const QWidget & );
+#endif
+
+public: // obsolete functions to dissappear or to become inline in 3.0
+#ifndef QT_NO_PALETTE
+    void setPalette( const QPalette &p, bool ) { setPalette( p ); }
+#endif
+    void setFont( const QFont &f, bool ) { setFont( f ); }
+};
+
+
+inline Qt::WState QWidget::testWState( WState s ) const
+{ return (widget_state & s); }
+
+inline Qt::WFlags QWidget::testWFlags( WFlags f ) const
+{ return (widget_flags & f); }
+
+
+inline WId QWidget::winId() const
+{ return winid; }
+
+inline bool QWidget::isTopLevel() const
+{ return testWFlags(WType_TopLevel); }
+
+inline bool QWidget::isDialog() const
+{ return testWFlags(WType_Dialog); }
+
+inline bool QWidget::isPopup() const
+{ return testWFlags(WType_Popup); }
+
+inline bool QWidget::isDesktop() const
+{ return testWFlags(WType_Desktop); }
+
+inline bool QWidget::isEnabled() const
+{ return !testWState(WState_Disabled); }
+
+inline bool QWidget::isModal() const
+{ return testWFlags(WShowModal); }
+
+inline bool QWidget::isEnabledToTLW() const
+{ return isEnabled(); }
+
+inline const QRect &QWidget::geometry() const
+{ return crect; }
+
+inline QSize QWidget::size() const
+{ return crect.size(); }
+
+inline int QWidget::width() const
+{ return crect.width(); }
+
+inline int QWidget::height() const
+{ return crect.height(); }
+
+inline QRect QWidget::rect() const
+{ return QRect(0,0,crect.width(),crect.height()); }
+
+inline int QWidget::minimumWidth() const
+{ return minimumSize().width(); }
+
+inline int QWidget::minimumHeight() const
+{ return minimumSize().height(); }
+
+inline int QWidget::maximumWidth() const
+{ return maximumSize().width(); }
+
+inline int QWidget::maximumHeight() const
+{ return maximumSize().height(); }
+
+inline void QWidget::setMinimumSize( const QSize &s )
+{ setMinimumSize(s.width(),s.height()); }
+
+inline void QWidget::setMaximumSize( const QSize &s )
+{ setMaximumSize(s.width(),s.height()); }
+
+inline void QWidget::setSizeIncrement( const QSize &s )
+{ setSizeIncrement(s.width(),s.height()); }
+
+inline void QWidget::setBaseSize( const QSize &s )
+{ setBaseSize(s.width(),s.height()); }
+
+inline const QColor &QWidget::eraseColor() const
+{ return bg_col; }
+
+#ifndef QT_NO_PALETTE
+inline const QPalette &QWidget::palette() const
+{ return pal; }
+#endif
+
+inline QFont QWidget::font() const
+{ return fnt; }
+
+inline QFontMetrics QWidget::fontMetrics() const
+{ return QFontMetrics(font()); }
+
+inline QFontInfo QWidget::fontInfo() const
+{ return QFontInfo(font()); }
+
+inline bool QWidget::hasMouseTracking() const
+{ return testWState(WState_MouseTracking); }
+
+inline bool QWidget::hasMouse() const
+{ return testWState(WState_HasMouse); }
+
+inline bool  QWidget::isFocusEnabled() const
+{ return (FocusPolicy)focus_policy != NoFocus; }
+
+inline QWidget::FocusPolicy QWidget::focusPolicy() const
+{ return (FocusPolicy)focus_policy; }
+
+inline bool QWidget::isUpdatesEnabled() const
+{ return !testWState(WState_BlockUpdates); }
+
+inline void QWidget::update( const QRect &r )
+{ update( r.x(), r.y(), r.width(), r.height() ); }
+
+inline void QWidget::repaint()
+{ repaint( TRUE ); }
+
+inline void QWidget::repaint( const QRect &r, bool erase )
+{ repaint( r.x(), r.y(), r.width(), r.height(), erase ); }
+
+inline void QWidget::erase()
+{ erase( 0, 0, crect.width(), crect.height() ); }
+
+inline void QWidget::erase( const QRect &r )
+{ erase( r.x(), r.y(), r.width(), r.height() ); }
+
+inline bool QWidget::close()
+{ return close( FALSE ); }
+
+inline bool QWidget::isVisible() const
+{ return testWState(WState_Visible); }
+
+inline bool QWidget::isVisibleToTLW() const // obsolete
+{ return isVisible(); }
+
+inline bool QWidget::isHidden() const
+{ return testWState(WState_ForceHide); }
+
+inline bool QWidget::isShown() const
+{ return !testWState(WState_ForceHide); }
+
+inline void QWidget::move( const QPoint &p )
+{ move( p.x(), p.y() ); }
+
+inline void QWidget::resize( const QSize &s )
+{ resize( s.width(), s.height()); }
+
+inline void QWidget::setGeometry( const QRect &r )
+{ setGeometry( r.left(), r.top(), r.width(), r.height() ); }
+
+inline void QWidget::drawText( const QPoint &p, const QString &s )
+{ drawText( p.x(), p.y(), s ); }
+
+inline QWidget *QWidget::parentWidget( bool sameWindow ) const
+{
+    if ( sameWindow )
+	return isTopLevel() ? 0 : (QWidget *)QObject::parent();
+    return (QWidget *)QObject::parent();
+}
+
+inline QWidgetMapper *QWidget::wmapper()
+{ return mapper; }
+
+inline uint QWidget::getWState() const
+{ return widget_state; }
+
+inline void QWidget::setWState( uint f )
+{ widget_state |= f; }
+
+inline void QWidget::clearWState( uint f )
+{ widget_state &= ~f; }
+
+inline Qt::WFlags QWidget::getWFlags() const
+{ return widget_flags; }
+
+inline void QWidget::setWFlags( WFlags f )
+{ widget_flags |= f; }
+
+inline void QWidget::clearWFlags( WFlags f )
+{ widget_flags &= ~f; }
+
+inline void QWidget::constPolish() const
+{
+    if ( !testWState(WState_Polished) ) {
+	QWidget* that = (QWidget*) this;
+	that->polish();
+        that->setWState(WState_Polished); // be on the safe side...
+    }
+}
+#ifndef QT_NO_CURSOR
+inline bool QWidget::ownCursor() const
+{
+    return testWState( WState_OwnCursor );
+}
+#endif
+inline bool QWidget::ownFont() const
+{
+    return own_font;
+}
+#ifndef QT_NO_PALETTE
+inline bool QWidget::ownPalette() const
+{
+    return own_palette;
+}
+#endif
+
+inline void QWidget::setSizePolicy( QSizePolicy::SizeType hor, QSizePolicy::SizeType ver, bool hfw )
+{
+    setSizePolicy( QSizePolicy( hor, ver, hfw) );
+}
+
+inline bool QWidget::isInputMethodEnabled() const
+{
+    return (bool)im_enabled;
+}
+
+// Extra QWidget data
+//  - to minimize memory usage for members that are seldom used.
+//  - top-level widgets have extra extra data to reduce cost further
+
+class QFocusData;
+class QWSManager;
+#if defined(Q_WS_WIN)
+class QOleDropTarget;
+#endif
+#if defined(Q_WS_MAC)
+class QMacDndExtra;
+#endif
+
+struct Q_EXPORT QTLWExtra {
+#ifndef QT_NO_WIDGET_TOPEXTRA
+    QString  caption;				// widget caption
+    QString  iconText;				// widget icon text
+    QPixmap *icon;				// widget icon
+#endif
+    QFocusData *focusData;			// focus data (for TLW)
+    short    incw, inch;			// size increments
+    // frame strut
+    ulong    fleft, fright, ftop, fbottom;
+    uint     unused : 8;                       // not used at this point...
+#if defined( Q_WS_WIN ) || defined( Q_WS_MAC )
+    uint     opacity : 8;		       // Stores opacity level on Windows/Mac OS X.
+#endif
+    uint     savedFlags;			// Save widgetflags while showing fullscreen
+    short    basew, baseh;			// base sizes
+#if defined(Q_WS_X11)
+    WId  parentWinId;				// parent window Id (valid after reparenting)
+    uint     embedded : 1;			// window is embedded in another Qt application
+    uint     spont_unmapped: 1;			// window was spontaneously unmapped
+    uint     reserved: 1;			// reserved
+    uint     dnd : 1;				// DND properties installed
+    uint     uspos : 1;				// User defined position
+    uint     ussize : 1;			// User defined size
+#if defined(QT_NO_IM_EXTENSIONS)
+    void    *xic;				// Input Context
+#endif
+#ifndef QT_NO_XSYNC
+    ulong    syncCounter;
+    uint     syncRequestValue[2];
+#endif
+#endif
+#if defined(Q_WS_MAC)
+    WindowGroupRef group;
+    uint     is_moved: 1;
+    uint     resizer : 4;
+#endif
+#if defined(Q_WS_QWS) && !defined ( QT_NO_QWS_MANAGER )
+    QRegion decor_allocated_region;		// decoration allocated region
+    QWSManager *qwsManager;
+#endif
+#if defined(Q_WS_WIN)
+    HICON    winIcon;				// internal Windows icon
+#endif
+    QRect    normalGeometry;			// used by showMin/maximized/FullScreen
+#ifdef Q_WS_WIN
+    uint style, exstyle;
+#endif
+};
+
+
+#define QWIDGETSIZE_MAX 32767
+
+// dear user: you can see this struct, but it is internal. do not touch.
+
+struct Q_EXPORT QWExtra {
+    Q_INT16  minw, minh;			// minimum size
+    Q_INT16  maxw, maxh;			// maximum size
+    QPixmap *bg_pix;				// background pixmap
+    QWidget *focus_proxy;
+#ifndef QT_NO_CURSOR
+    QCursor *curs;
+#endif
+    QTLWExtra *topextra;			// only useful for TLWs
+#if defined(Q_WS_WIN)
+    QOleDropTarget *dropTarget;			// drop target
+#endif
+#if defined(Q_WS_X11)
+    WId xDndProxy;				// XDND forwarding to embedded windows
+#endif
+#if defined(Q_WS_MAC)
+    QRegion clip_saved, clip_sibs, clip_children;
+    QMacDndExtra *macDndExtra;
+    QRegion dirty_area;
+    uint clip_dirty : 1, clip_serial : 15;
+    uint child_dirty : 1, child_serial : 15;
+#ifndef QMAC_NO_QUARTZ
+    uint ctx_children_clipped:1;
+#endif // QMAC_NO_QUARTZ
+    uint has_dirty_area:1;
+#endif // Q_WS_MAC
+    uint bg_origin : 2;
+#if defined(Q_WS_X11)
+    uint children_use_dnd : 1;
+    uint compress_events : 1;
+#endif
+#if defined(Q_WS_QWS) || defined(Q_WS_MAC)
+    QRegion mask;				// widget mask
+#endif
+    char     bg_mode;				// background mode
+    char     bg_mode_visual;			// visual background mode
+#ifndef QT_NO_STYLE
+    QStyle* style;
+#endif
+    QRect micro_focus_hint;			// micro focus hint
+    QSizePolicy size_policy;
+};
+
+#define Q_DEFINED_QWIDGET
+#include "qwinexport.h"
+
+#endif // QWIDGET_H