Now compiles kdelibs/dcop folder properly...

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/dependencies/tqtinterface@1158880 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1076 insertions, 0 deletions

diff --git a/qtinterface/tqt4/Qt/qwidget.h b/qtinterface/tqt4/Qt/qwidget.h
new file mode 100644
index 0000000..c709689
--- /dev/null
+++ b/qtinterface/tqt4/Qt/qwidget.h
@@ -0,0 +1,1076 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWIDGET_H
+#define QWIDGET_H
+
+#include <QtGui/qwindowdefs.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qmargins.h>
+#include <QtGui/qpaintdevice.h>
+#include <QtGui/qpalette.h>
+#include <QtGui/qfont.h>
+#include <QtGui/qfontmetrics.h>
+#include <QtGui/qfontinfo.h>
+#include <QtGui/qsizepolicy.h>
+#include <QtGui/qregion.h>
+#include <QtGui/qbrush.h>
+#include <QtGui/qcursor.h>
+#include <QtGui/qkeysequence.h>
+
+#ifdef QT_INCLUDE_COMPAT
+#include <QtGui/qevent.h>
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QLayout;
+class QWSRegionManager;
+class QStyle;
+class QAction;
+class QVariant;
+
+class QActionEvent;
+class QMouseEvent;
+class QWheelEvent;
+class QHoverEvent;
+class QKeyEvent;
+class QFocusEvent;
+class QPaintEvent;
+class QMoveEvent;
+class QResizeEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QInputMethodEvent;
+class QTabletEvent;
+class QDragEnterEvent;
+class QDragMoveEvent;
+class QDragLeaveEvent;
+class QDropEvent;
+class QShowEvent;
+class QHideEvent;
+class QInputContext;
+class QIcon;
+class QWindowSurface;
+class QLocale;
+class QGraphicsProxyWidget;
+class QGraphicsEffect;
+#if defined(Q_WS_X11)
+class QX11Info;
+#endif
+
+class QWidgetData
+{
+public:
+    WId winid;
+    uint widget_attributes;
+    Qt::WindowFlags window_flags;
+    uint window_state : 4;
+    uint focus_policy : 4;
+    uint sizehint_forced :1;
+    uint is_closing :1;
+    uint in_show : 1;
+    uint in_set_window_state : 1;
+    mutable uint fstrut_dirty : 1;
+    uint context_menu_policy : 3;
+    uint window_modality : 2;
+    uint in_destructor : 1;
+    uint unused : 13;
+    QRect crect;
+    mutable QPalette pal;
+    QFont fnt;
+#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;
+#endif
+    QRect wrect;
+};
+
+class QWidgetPrivate;
+
+class Q_GUI_EXPORT QWidget : public QObject, public QPaintDevice
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QWidget)
+
+    Q_PROPERTY(bool modal READ isModal)
+    Q_PROPERTY(Qt::WindowModality windowModality READ windowModality WRITE setWindowModality)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
+    Q_PROPERTY(QRect geometry READ geometry WRITE setGeometry)
+    Q_PROPERTY(QRect frameGeometry READ frameGeometry)
+    Q_PROPERTY(QRect normalGeometry READ normalGeometry)
+    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(QPalette palette READ palette WRITE setPalette)
+    Q_PROPERTY(QFont font READ font WRITE setFont)
+#ifndef QT_NO_CURSOR
+    Q_PROPERTY(QCursor cursor READ cursor WRITE setCursor RESET unsetCursor)
+#endif
+    Q_PROPERTY(bool mouseTracking READ hasMouseTracking WRITE setMouseTracking)
+    Q_PROPERTY(bool isActiveWindow READ isActiveWindow)
+    Q_PROPERTY(Qt::FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy)
+    Q_PROPERTY(bool focus READ hasFocus)
+    Q_PROPERTY(Qt::ContextMenuPolicy contextMenuPolicy READ contextMenuPolicy WRITE setContextMenuPolicy)
+    Q_PROPERTY(bool updatesEnabled READ updatesEnabled WRITE setUpdatesEnabled DESIGNABLE false)
+    Q_PROPERTY(bool visible READ isVisible WRITE setVisible DESIGNABLE 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(bool acceptDrops READ acceptDrops WRITE setAcceptDrops)
+    Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle DESIGNABLE isWindow)
+    Q_PROPERTY(QIcon windowIcon READ windowIcon WRITE setWindowIcon DESIGNABLE isWindow)
+    Q_PROPERTY(QString windowIconText READ windowIconText WRITE setWindowIconText DESIGNABLE isWindow)
+    Q_PROPERTY(double windowOpacity READ windowOpacity WRITE setWindowOpacity DESIGNABLE isWindow)
+    Q_PROPERTY(bool windowModified READ isWindowModified WRITE setWindowModified DESIGNABLE isWindow)
+#ifndef QT_NO_TOOLTIP
+    Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip)
+#endif
+#ifndef QT_NO_STATUSTIP
+    Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip)
+#endif
+#ifndef QT_NO_WHATSTHIS
+    Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis)
+#endif
+#ifndef QT_NO_ACCESSIBILITY
+    Q_PROPERTY(QString accessibleName READ accessibleName WRITE setAccessibleName)
+    Q_PROPERTY(QString accessibleDescription READ accessibleDescription WRITE setAccessibleDescription)
+#endif
+    Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection RESET unsetLayoutDirection)
+    QDOC_PROPERTY(Qt::WindowFlags windowFlags READ windowFlags WRITE setWindowFlags)
+    Q_PROPERTY(bool autoFillBackground READ autoFillBackground WRITE setAutoFillBackground)
+#ifndef QT_NO_STYLE_STYLESHEET
+    Q_PROPERTY(QString styleSheet READ styleSheet WRITE setStyleSheet)
+#endif
+    Q_PROPERTY(QLocale locale READ locale WRITE setLocale RESET unsetLocale)
+    Q_PROPERTY(QString windowFilePath READ windowFilePath WRITE setWindowFilePath DESIGNABLE isWindow)
+    Q_PROPERTY(Qt::InputMethodHints inputMethodHints READ inputMethodHints WRITE setInputMethodHints)
+
+public:
+    enum RenderFlag {
+        DrawWindowBackground = 0x1,
+        DrawChildren = 0x2,
+        IgnoreMask = 0x4
+    };
+    Q_DECLARE_FLAGS(RenderFlags, RenderFlag)
+
+    explicit QWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
+#ifdef QT3_SUPPORT
+    QT3_SUPPORT_CONSTRUCTOR QWidget(QWidget* parent, const char *name, Qt::WindowFlags f = 0);
+#endif
+    ~QWidget();
+
+    int devType() const;
+
+    WId winId() const;
+    void createWinId(); // internal, going away
+    inline WId internalWinId() const { return data->winid; }
+    WId effectiveWinId() const;
+
+    // GUI style setting
+    QStyle *style() const;
+    void setStyle(QStyle *);
+    // Widget types and states
+
+    bool isTopLevel() const;
+    bool isWindow() const;
+
+    bool isModal() const;
+    Qt::WindowModality windowModality() const;
+    void setWindowModality(Qt::WindowModality windowModality);
+
+    bool isEnabled() const;
+    bool isEnabledTo(QWidget*) const;
+    bool isEnabledToTLW() const;
+
+    Qt::WidgetAttribute testWState( Qt::WidgetAttribute s ) const;
+
+public Q_SLOTS:
+    void setEnabled(bool);
+    void setDisabled(bool);
+    void setWindowModified(bool);
+
+    // Widget coordinates
+
+public:
+    QRect frameGeometry() const;
+    const QRect &geometry() const;
+    QRect normalGeometry() const;
+
+    int x() const;
+    int y() const;
+    QPoint pos() const;
+    QSize frameSize() const;
+    QSize size() const;
+    inline int width() const;
+    inline int height() const;
+    inline 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 &);
+    void setMinimumSize(int minw, int minh);
+    void setMaximumSize(const QSize &);
+    void setMaximumSize(int maxw, int maxh);
+    void setMinimumWidth(int minw);
+    void setMinimumHeight(int minh);
+    void setMaximumWidth(int maxw);
+    void setMaximumHeight(int maxh);
+
+#ifdef Q_QDOC
+    void setupUi(QWidget *widget);
+#endif
+
+    QSize sizeIncrement() const;
+    void setSizeIncrement(const QSize &);
+    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 *window() const;
+    QWidget *nativeParentWidget() const;
+    inline QWidget *topLevelWidget() const { return window(); }
+
+    // Widget appearance functions
+    const QPalette &palette() const;
+    void setPalette(const QPalette &);
+
+    void setBackgroundRole(QPalette::ColorRole);
+    QPalette::ColorRole backgroundRole() const;
+
+    void setForegroundRole(QPalette::ColorRole);
+    QPalette::ColorRole foregroundRole() const;
+
+    const QFont &font() const;
+    void setFont(const QFont &);
+    QFontMetrics fontMetrics() const;
+    QFontInfo fontInfo() const;
+
+#ifndef QT_NO_CURSOR
+    QCursor cursor() const;
+    void setCursor(const QCursor &);
+    void unsetCursor();
+#endif
+
+    void setMouseTracking(bool enable);
+    bool hasMouseTracking() const;
+    bool underMouse() const;
+
+    void setMask(const QBitmap &);
+    void setMask(const QRegion &);
+    QRegion mask() const;
+    void clearMask();
+
+    void render(QPaintDevice *target, const QPoint &targetOffset = QPoint(),
+                const QRegion &sourceRegion = QRegion(),
+                RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));
+
+    void render(QPainter *painter, const QPoint &targetOffset = QPoint(),
+                const QRegion &sourceRegion = QRegion(),
+                RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));
+
+#ifndef QT_NO_GRAPHICSEFFECT
+    QGraphicsEffect *graphicsEffect() const;
+    void setGraphicsEffect(QGraphicsEffect *effect);
+#endif //QT_NO_GRAPHICSEFFECT
+
+    void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
+    void ungrabGesture(Qt::GestureType type);
+
+public Q_SLOTS:
+    void setWindowTitle(const QString &);
+#ifndef QT_NO_STYLE_STYLESHEET
+    void setStyleSheet(const QString& styleSheet);
+#endif
+public:
+#ifndef QT_NO_STYLE_STYLESHEET
+    QString styleSheet() const;
+#endif
+    QString windowTitle() const;
+    void setWindowIcon(const QIcon &icon);
+    QIcon windowIcon() const;
+    void setWindowIconText(const QString &);
+    QString windowIconText() const;
+    void setWindowRole(const QString &);
+    QString windowRole() const;
+    void setWindowFilePath(const QString &filePath);
+    QString windowFilePath() const;
+
+    void setWindowOpacity(qreal level);
+    qreal windowOpacity() const;
+
+    bool isWindowModified() const;
+#ifndef QT_NO_TOOLTIP
+    void setToolTip(const QString &);
+    QString toolTip() const;
+#endif
+#ifndef QT_NO_STATUSTIP
+    void setStatusTip(const QString &);
+    QString statusTip() const;
+#endif
+#ifndef QT_NO_WHATSTHIS
+    void setWhatsThis(const QString &);
+    QString whatsThis() const;
+#endif
+#ifndef QT_NO_ACCESSIBILITY
+    QString accessibleName() const;
+    void setAccessibleName(const QString &name);
+    QString accessibleDescription() const;
+    void setAccessibleDescription(const QString &description);
+#endif
+
+    void setLayoutDirection(Qt::LayoutDirection direction);
+    Qt::LayoutDirection layoutDirection() const;
+    void unsetLayoutDirection();
+
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+    void unsetLocale();
+
+    inline bool isRightToLeft() const { return layoutDirection() == Qt::RightToLeft; }
+    inline bool isLeftToRight() const { return layoutDirection() == Qt::LeftToRight; }
+
+public Q_SLOTS:
+    inline void setFocus() { setFocus(Qt::OtherFocusReason); }
+
+public:
+    bool isActiveWindow() const;
+    void activateWindow();
+    void clearFocus();
+
+    void setFocus(Qt::FocusReason reason);
+    Qt::FocusPolicy focusPolicy() const;
+    void setFocusPolicy(Qt::FocusPolicy policy);
+    bool hasFocus() const;
+    static void setTabOrder(QWidget *, QWidget *);
+    void setFocusProxy(QWidget *);
+    QWidget *focusProxy() const;
+    Qt::ContextMenuPolicy contextMenuPolicy() const;
+    void setContextMenuPolicy(Qt::ContextMenuPolicy policy);
+
+    // Grab functions
+    void grabMouse();
+#ifndef QT_NO_CURSOR
+    void grabMouse(const QCursor &);
+#endif
+    void releaseMouse();
+    void grabKeyboard();
+    void releaseKeyboard();
+#ifndef QT_NO_SHORTCUT
+    int grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut);
+    void releaseShortcut(int id);
+    void setShortcutEnabled(int id, bool enable = true);
+    void setShortcutAutoRepeat(int id, bool enable = true);
+#endif
+    static QWidget *mouseGrabber();
+    static QWidget *keyboardGrabber();
+
+    // Update/refresh functions
+    inline bool updatesEnabled() const;
+    void setUpdatesEnabled(bool enable);
+
+#if 0 //def Q_WS_QWS
+    void repaintUnclipped(const QRegion &, bool erase = true);
+#endif
+
+#ifndef QT_NO_GRAPHICSVIEW
+    QGraphicsProxyWidget *graphicsProxyWidget() const;
+#endif
+
+public Q_SLOTS:
+    void update();
+    void repaint();
+
+public:
+    inline void update(int x, int y, int w, int h);
+    void update(const QRect&);
+    void update(const QRegion&);
+
+    void repaint(int x, int y, int w, int h);
+    void repaint(const QRect &);
+    void repaint(const QRegion &);
+
+public Q_SLOTS:
+    // Widget management functions
+
+    virtual void setVisible(bool visible);
+    inline void setHidden(bool hidden) { setVisible(!hidden); }
+#ifndef Q_WS_WINCE
+    inline void show() { setVisible(true); }
+#else
+    void show();
+#endif
+    inline void hide() { setVisible(false); }
+    inline QT_MOC_COMPAT void setShown(bool shown) { setVisible(shown); }
+
+    void showMinimized();
+    void showMaximized();
+    void showFullScreen();
+    void showNormal();
+
+    bool close();
+    void raise();
+    void lower();
+
+public:
+    void stackUnder(QWidget*);
+    void move(int x, int y);
+    void move(const QPoint &);
+    void resize(int w, int h);
+    void resize(const QSize &);
+    inline void setGeometry(int x, int y, int w, int h);
+    void setGeometry(const QRect &);
+    QByteArray saveGeometry() const;
+    bool restoreGeometry(const QByteArray &geometry);
+    void adjustSize();
+    bool isVisible() const;
+    bool isVisibleTo(QWidget*) const;
+    // ### Qt 5: bool isVisibleTo(_const_ QWidget *) const
+    inline bool isHidden() const;
+
+    bool isMinimized() const;
+    bool isMaximized() const;
+    bool isFullScreen() const;
+
+    Qt::WindowStates windowState() const;
+    void setWindowState(Qt::WindowStates state);
+    void overrideWindowState(Qt::WindowStates state);
+
+    virtual QSize sizeHint() const;
+    virtual QSize minimumSizeHint() const;
+
+    QSizePolicy sizePolicy() const;
+    void setSizePolicy(QSizePolicy);
+    inline void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical);
+    virtual int heightForWidth(int) const;
+
+    QRegion visibleRegion() const;
+
+    void setContentsMargins(int left, int top, int right, int bottom);
+    void setContentsMargins(const QMargins &margins);
+    void getContentsMargins(int *left, int *top, int *right, int *bottom) const;
+    QMargins contentsMargins() const;
+
+    QRect contentsRect() const;
+
+public:
+    QLayout *layout() const;
+    void setLayout(QLayout *);
+    void updateGeometry();
+
+    void setParent(QWidget *parent);
+    void setParent(QWidget *parent, Qt::WindowFlags f);
+
+    void scroll(int dx, int dy);
+    void scroll(int dx, int dy, const QRect&);
+
+    // Misc. functions
+
+    QWidget *focusWidget() const;
+    QWidget *nextInFocusChain() const;
+    QWidget *previousInFocusChain() const;
+
+    // drag and drop
+    bool acceptDrops() const;
+    void setAcceptDrops(bool on);
+
+#ifndef QT_NO_ACTION
+    //actions
+    void addAction(QAction *action);
+    void addActions(QList<QAction*> actions);
+    void insertAction(QAction *before, QAction *action);
+    void insertActions(QAction *before, QList<QAction*> actions);
+    void removeAction(QAction *action);
+    QList<QAction*> actions() const;
+#endif
+
+    QWidget *parentWidget() const;
+
+    void setWindowFlags(Qt::WindowFlags type);
+    inline Qt::WindowFlags windowFlags() const;
+    void overrideWindowFlags(Qt::WindowFlags type);
+
+    inline Qt::WindowType windowType() const;
+
+    static QWidget *find(WId);
+#ifdef QT3_SUPPORT
+    static QT3_SUPPORT QWidgetMapper *wmapper();
+#endif
+    inline QWidget *childAt(int x, int y) const;
+    QWidget *childAt(const QPoint &p) const;
+
+#if defined(Q_WS_X11)
+    const QX11Info &x11Info() const;
+    Qt::HANDLE x11PictureHandle() const;
+#endif
+
+#if defined(Q_WS_MAC)
+    Qt::HANDLE macQDHandle() const;
+    Qt::HANDLE macCGHandle() const;
+#endif
+
+#if defined(Q_WS_WIN)
+    HDC getDC() const;
+    void releaseDC(HDC) const;
+#else
+    Qt::HANDLE handle() const;
+#endif
+
+    void setAttribute(Qt::WidgetAttribute, bool on = true);
+    inline bool testAttribute(Qt::WidgetAttribute) const;
+
+    QPaintEngine *paintEngine() const;
+
+    void ensurePolished() const;
+
+    QInputContext *inputContext();
+    void setInputContext(QInputContext *);
+
+    bool isAncestorOf(const QWidget *child) const;
+
+#ifdef QT_KEYPAD_NAVIGATION
+    bool hasEditFocus() const;
+    void setEditFocus(bool on);
+#endif
+
+    bool autoFillBackground() const;
+    void setAutoFillBackground(bool enabled);
+
+    void setWindowSurface(QWindowSurface *surface);
+    QWindowSurface *windowSurface() const;
+
+Q_SIGNALS:
+    void customContextMenuRequested(const QPoint &pos);
+
+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 *);
+#ifndef QT_NO_CONTEXTMENU
+    virtual void contextMenuEvent(QContextMenuEvent *);
+#endif
+#ifndef QT_NO_TABLETEVENT
+    virtual void tabletEvent(QTabletEvent *);
+#endif
+#ifndef QT_NO_ACTION
+    virtual void actionEvent(QActionEvent *);
+#endif
+
+#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(EventHandlerCallRef, EventRef);
+#endif
+#if defined(Q_WS_WIN)
+    virtual bool winEvent(MSG *message, long *result);
+#endif
+#if defined(Q_WS_X11)
+    virtual bool x11Event(XEvent *);
+#endif
+#if defined(Q_WS_QWS)
+    virtual bool qwsEvent(QWSEvent *);
+#endif
+
+    // Misc. protected functions
+    virtual void changeEvent(QEvent *);
+
+    int metric(PaintDeviceMetric) const;
+
+    virtual void inputMethodEvent(QInputMethodEvent *);
+public:
+    virtual QVariant inputMethodQuery(Qt::InputMethodQuery) const;
+
+    Qt::InputMethodHints inputMethodHints() const;
+    void setInputMethodHints(Qt::InputMethodHints hints);
+
+protected:
+    void resetInputContext();
+protected Q_SLOTS:
+    void updateMicroFocus();
+protected:
+
+    void create(WId = 0, bool initializeWindow = true,
+                         bool destroyOldWindow = true);
+    void destroy(bool destroyWindow = true,
+                 bool destroySubWindows = true);
+
+    virtual bool focusNextPrevChild(bool next);
+    inline bool focusNextChild() { return focusNextPrevChild(true); }
+    inline bool focusPreviousChild() { return focusNextPrevChild(false); }
+
+protected:
+    QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WindowFlags f);
+private:
+
+    bool testAttribute_helper(Qt::WidgetAttribute) const;
+
+    QLayout *takeLayout();
+
+    friend class QBackingStoreDevice;
+    friend class QWidgetBackingStore;
+    friend class QApplication;
+    friend class QApplicationPrivate;
+    friend class QBaseApplication;
+    friend class QPainter;
+    friend class QPainterPrivate;
+    friend class QPixmap; // for QPixmap::fill()
+    friend class QFontMetrics;
+    friend class QFontInfo;
+    friend class QETWidget;
+    friend class QLayout;
+    friend class QWidgetItem;
+    friend class QWidgetItemV2;
+    friend class QGLContext;
+    friend class QGLWidget;
+    friend class QGLWindowSurface;
+    friend class QX11PaintEngine;
+    friend class QWin32PaintEngine;
+    friend class QShortcutPrivate;
+    friend class QShortcutMap;
+    friend class QWindowSurface;
+    friend class QGraphicsProxyWidget;
+    friend class QGraphicsProxyWidgetPrivate;
+    friend class QStyleSheetStyle;
+    friend struct QWidgetExceptionCleaner;
+    friend class QGestureManager;
+    friend class QWinNativePanGestureRecognizer;
+    friend class QWidgetEffectSourcePrivate;
+
+#ifdef Q_WS_MAC
+    friend class QCoreGraphicsPaintEnginePrivate;
+    friend QPoint qt_mac_posInWindow(const QWidget *w);
+    friend OSWindowRef qt_mac_window_for(const QWidget *w);
+    friend bool qt_mac_is_metal(const QWidget *w);
+    friend OSViewRef qt_mac_nativeview_for(const QWidget *w);
+    friend void qt_event_request_window_change(QWidget *widget);
+    friend bool qt_mac_sendMacEventToWidget(QWidget *widget, EventRef ref);
+#endif
+#ifdef Q_WS_QWS
+    friend class QWSBackingStore;
+    friend class QWSManager;
+    friend class QWSManagerPrivate;
+    friend class QDecoration;
+    friend class QWSWindowSurface;
+    friend class QScreen;
+    friend class QVNCScreen;
+    friend bool isWidgetOpaque(const QWidget *);
+    friend class QGLWidgetPrivate;
+#endif
+#ifdef Q_OS_SYMBIAN
+    friend class QSymbianControl;
+    friend class QS60WindowSurface;
+#endif
+#ifdef Q_WS_X11
+    friend void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);
+    friend void qt_net_remove_user_time(QWidget *tlw);
+#endif
+
+    friend Q_GUI_EXPORT QWidgetData *qt_qwidget_data(QWidget *widget);
+    friend Q_GUI_EXPORT QWidgetPrivate *qt_widget_private(QWidget *widget);
+
+private:
+    Q_DISABLE_COPY(QWidget)
+    Q_PRIVATE_SLOT(d_func(), void _q_showIfNotHidden())
+#ifdef Q_OS_SYMBIAN
+    Q_PRIVATE_SLOT(d_func(), void _q_delayedDestroy(WId winId))
+#endif
+
+    QWidgetData *data;
+
+#ifdef QT3_SUPPORT
+public:
+    inline QT3_SUPPORT bool isUpdatesEnabled() const { return updatesEnabled(); }
+    QT3_SUPPORT QStyle *setStyle(const QString&);
+    inline QT3_SUPPORT bool isVisibleToTLW() const;
+    QT3_SUPPORT QRect visibleRect() const;
+    inline QT3_SUPPORT void iconify() { showMinimized(); }
+    inline QT3_SUPPORT void constPolish() const { ensurePolished(); }
+    inline QT3_SUPPORT void polish() { ensurePolished(); }
+    inline QT3_SUPPORT void reparent(QWidget *parent, Qt::WindowFlags f, const QPoint &p, bool showIt=false)
+    { setParent(parent, f); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); }
+    inline QT3_SUPPORT void reparent(QWidget *parent, const QPoint &p, bool showIt=false)
+    { setParent(parent, windowFlags() & ~Qt::WindowType_Mask); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); }
+    inline QT3_SUPPORT void recreate(QWidget *parent, Qt::WindowFlags f, const QPoint & p, bool showIt=false)
+    { setParent(parent, f); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); }
+    inline QT3_SUPPORT void setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver, bool hfw)
+    { QSizePolicy sp(hor, ver); sp.setHeightForWidth(hfw); setSizePolicy(sp);}
+    inline QT3_SUPPORT bool hasMouse() const { return testAttribute(Qt::WA_UnderMouse); }
+#ifndef QT_NO_CURSOR
+    inline QT3_SUPPORT bool ownCursor() const { return testAttribute(Qt::WA_SetCursor); }
+#endif
+    inline QT3_SUPPORT bool ownFont() const { return testAttribute(Qt::WA_SetFont); }
+    inline QT3_SUPPORT void unsetFont() { setFont(QFont()); }
+    inline QT3_SUPPORT bool ownPalette() const { return testAttribute(Qt::WA_SetPalette); }
+    inline QT3_SUPPORT void unsetPalette() { setPalette(QPalette()); }
+    Qt::BackgroundMode QT3_SUPPORT backgroundMode() const;
+    void QT3_SUPPORT setBackgroundMode(Qt::BackgroundMode, Qt::BackgroundMode = Qt::PaletteBackground);
+    const QT3_SUPPORT QColor &eraseColor() const;
+    void QT3_SUPPORT setEraseColor(const QColor &);
+    const QT3_SUPPORT QColor &foregroundColor() const;
+    const QT3_SUPPORT QPixmap *erasePixmap() const;
+    void QT3_SUPPORT setErasePixmap(const QPixmap &);
+    const QT3_SUPPORT QColor &paletteForegroundColor() const;
+    void QT3_SUPPORT setPaletteForegroundColor(const QColor &);
+    const QT3_SUPPORT QColor &paletteBackgroundColor() const;
+    void QT3_SUPPORT setPaletteBackgroundColor(const QColor &);
+    const QT3_SUPPORT QPixmap *paletteBackgroundPixmap() const;
+    void QT3_SUPPORT setPaletteBackgroundPixmap(const QPixmap &);
+    const QT3_SUPPORT QBrush& backgroundBrush() const;
+    const QT3_SUPPORT QColor &backgroundColor() const;
+    const QT3_SUPPORT QPixmap *backgroundPixmap() const;
+    void QT3_SUPPORT setBackgroundPixmap(const QPixmap &);
+    QT3_SUPPORT void setBackgroundColor(const QColor &);
+    QT3_SUPPORT QColorGroup colorGroup() const;
+    QT3_SUPPORT QWidget *parentWidget(bool sameWindow) const;
+    inline QT3_SUPPORT void setKeyCompression(bool b) { setAttribute(Qt::WA_KeyCompression, b); }
+    inline QT3_SUPPORT void setFont(const QFont &f, bool) { setFont(f); }
+    inline QT3_SUPPORT void setPalette(const QPalette &p, bool) { setPalette(p); }
+    enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin };
+    inline QT3_SUPPORT void setBackgroundOrigin(BackgroundOrigin) {}
+    inline QT3_SUPPORT BackgroundOrigin backgroundOrigin() const { return WindowOrigin; }
+    inline QT3_SUPPORT QPoint backgroundOffset() const { return QPoint(); }
+    inline QT3_SUPPORT void repaint(bool) { repaint(); }
+    inline QT3_SUPPORT void repaint(int x, int y, int w, int h, bool) { repaint(x,y,w,h); }
+    inline QT3_SUPPORT void repaint(const QRect &r, bool) { repaint(r); }
+    inline QT3_SUPPORT void repaint(const QRegion &rgn, bool) { repaint(rgn); }
+    QT3_SUPPORT void erase();
+    inline QT3_SUPPORT void erase(int x, int y, int w, int h) { erase_helper(x, y, w, h); }
+    QT3_SUPPORT void erase(const QRect &);
+    QT3_SUPPORT void erase(const QRegion &);
+    QT3_SUPPORT void drawText(const QPoint &p, const QString &s)
+    { drawText_helper(p.x(), p.y(), s); }
+    inline QT3_SUPPORT void drawText(int x, int y, const QString &s)
+    { drawText_helper(x, y, s); }
+    QT3_SUPPORT bool close(bool);
+    inline QT3_SUPPORT QWidget *childAt(int x, int y, bool includeThis) const
+    {
+        QWidget *w = childAt(x, y);
+        return w ? w : ((includeThis && rect().contains(x,y))?const_cast<QWidget*>(this):0);
+    }
+    inline QT3_SUPPORT QWidget *childAt(const QPoint &p, bool includeThis) const
+    {
+        QWidget *w = childAt(p);
+        return w ? w : ((includeThis && rect().contains(p))?const_cast<QWidget*>(this):0);
+    }
+    inline QT3_SUPPORT void setCaption(const QString &c)   { setWindowTitle(c); }
+    QT3_SUPPORT void setIcon(const QPixmap &i);
+    inline QT3_SUPPORT void setIconText(const QString &it) { setWindowIconText(it); }
+    inline QT3_SUPPORT QString caption() const             { return windowTitle(); }
+    QT3_SUPPORT const QPixmap *icon() const;
+    inline QT3_SUPPORT QString iconText() const            { return windowIconText(); }
+    inline QT3_SUPPORT void setInputMethodEnabled(bool b) { setAttribute(Qt::WA_InputMethodEnabled, b); }
+    inline QT3_SUPPORT bool isInputMethodEnabled() const { return testAttribute(Qt::WA_InputMethodEnabled); }
+    inline QT3_SUPPORT void setActiveWindow() { activateWindow(); }
+    inline QT3_SUPPORT bool isShown() const { return !isHidden(); }
+    inline QT3_SUPPORT bool isDialog() const { return windowType() == Qt::Dialog; }
+    inline QT3_SUPPORT bool isPopup() const { return windowType() == Qt::Popup; }
+    inline QT3_SUPPORT bool isDesktop() const { return windowType() == Qt::Desktop; }
+
+
+private:
+    void drawText_helper(int x, int y, const QString &);
+    void erase_helper(int x, int y, int w, int h);
+#endif // QT3_SUPPORT
+
+protected:
+    virtual void styleChange(QStyle&); // compat
+    virtual void enabledChange(bool);  // compat
+    virtual void paletteChange(const QPalette &);  // compat
+    virtual void fontChange(const QFont &); // compat
+    virtual void windowActivationChange(bool);  // compat
+    virtual void languageChange();  // compat
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QWidget::RenderFlags)
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QWidget *qobject_cast_helper<QWidget*>(QObject *o, QWidget *)
+{
+    if (!o || !o->isWidgetType()) return 0;
+    return (QWidget*)(o);
+}
+#else
+template <> inline QWidget *qobject_cast<QWidget*>(QObject *o)
+{
+    if (!o || !o->isWidgetType()) return 0;
+    return static_cast<QWidget*>(o);
+}
+template <> inline const QWidget *qobject_cast<const QWidget*>(const QObject *o)
+{
+    if (!o || !o->isWidgetType()) return 0;
+    return static_cast<const QWidget*>(o);
+}
+#endif
+
+inline QWidget *QWidget::childAt(int ax, int ay) const
+{ return childAt(QPoint(ax, ay)); }
+
+inline Qt::WindowType QWidget::windowType() const
+{ return static_cast<Qt::WindowType>(int(data->window_flags & Qt::WindowType_Mask)); }
+inline Qt::WindowFlags QWidget::windowFlags() const
+{ return data->window_flags; }
+
+inline bool QWidget::isTopLevel() const
+{ return (windowType() & Qt::Window); }
+
+inline bool QWidget::isWindow() const
+{ return (windowType() & Qt::Window); }
+
+inline bool QWidget::isEnabled() const
+{ return !testAttribute(Qt::WA_Disabled); }
+
+inline bool QWidget::isModal() const
+{ return data->window_modality != Qt::NonModal; }
+
+inline bool QWidget::isEnabledToTLW() const
+{ return isEnabled(); }
+
+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 QFont &QWidget::font() const
+{ return data->fnt; }
+
+inline QFontMetrics QWidget::fontMetrics() const
+{ return QFontMetrics(data->fnt); }
+
+inline QFontInfo QWidget::fontInfo() const
+{ return QFontInfo(data->fnt); }
+
+inline void QWidget::setMouseTracking(bool enable)
+{ setAttribute(Qt::WA_MouseTracking, enable); }
+
+inline bool QWidget::hasMouseTracking() const
+{ return testAttribute(Qt::WA_MouseTracking); }
+
+inline bool QWidget::underMouse() const
+{ return testAttribute(Qt::WA_UnderMouse); }
+
+inline bool QWidget::updatesEnabled() const
+{ return !testAttribute(Qt::WA_UpdatesDisabled); }
+
+inline void QWidget::update(int ax, int ay, int aw, int ah)
+{ update(QRect(ax, ay, aw, ah)); }
+
+inline bool QWidget::isVisible() const
+{ return testAttribute(Qt::WA_WState_Visible); }
+
+inline bool QWidget::isHidden() const
+{ return testAttribute(Qt::WA_WState_Hidden); }
+
+inline void QWidget::move(int ax, int ay)
+{ move(QPoint(ax, ay)); }
+
+inline void QWidget::resize(int w, int h)
+{ resize(QSize(w, h)); }
+
+inline void QWidget::setGeometry(int ax, int ay, int aw, int ah)
+{ setGeometry(QRect(ax, ay, aw, ah)); }
+
+inline QRect QWidget::rect() const
+{ return QRect(0,0,data->crect.width(),data->crect.height()); }
+
+inline const QRect &QWidget::geometry() const
+{ return data->crect; }
+
+inline QSize QWidget::size() const
+{ return data->crect.size(); }
+
+inline int QWidget::width() const
+{ return data->crect.width(); }
+
+inline int QWidget::height() const
+{ return data->crect.height(); }
+
+inline QWidget *QWidget::parentWidget() const
+{ return static_cast<QWidget *>(QObject::parent()); }
+
+inline void QWidget::setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver)
+{ setSizePolicy(QSizePolicy(hor, ver)); }
+
+inline bool QWidget::testAttribute(Qt::WidgetAttribute attribute) const
+{
+    if (attribute < int(8*sizeof(uint)))
+        return data->widget_attributes & (1<<attribute);
+    return testAttribute_helper(attribute);
+}
+
+#ifdef QT3_SUPPORT
+inline bool QWidget::isVisibleToTLW() const
+{ return isVisible(); }
+inline QWidget *QWidget::parentWidget(bool sameWindow) const
+{
+    if (sameWindow && isWindow())
+        return 0;
+    return static_cast<QWidget *>(QObject::parent());
+}
+inline QColorGroup QWidget::colorGroup() const
+{ return QColorGroup(palette()); }
+inline void QWidget::setPaletteForegroundColor(const QColor &c)
+{ QPalette p = palette(); p.setColor(foregroundRole(), c); setPalette(p); }
+inline const QBrush& QWidget::backgroundBrush() const { return palette().brush(backgroundRole()); }
+inline void QWidget::setBackgroundPixmap(const QPixmap &pm)
+{ QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); }
+inline const QPixmap *QWidget::backgroundPixmap() const { return 0; }
+inline void QWidget::setBackgroundColor(const QColor &c)
+{ QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); }
+inline const QColor & QWidget::backgroundColor() const { return palette().color(backgroundRole()); }
+inline const QColor &QWidget::foregroundColor() const { return palette().color(foregroundRole());}
+inline const QColor &QWidget::eraseColor() const { return palette().color(backgroundRole()); }
+inline void QWidget::setEraseColor(const QColor &c)
+{ QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); }
+inline const QPixmap *QWidget::erasePixmap() const { return 0; }
+inline void QWidget::setErasePixmap(const QPixmap &pm)
+{ QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); }
+inline const QColor &QWidget::paletteForegroundColor() const { return palette().color(foregroundRole());}
+inline const QColor &QWidget::paletteBackgroundColor() const { return palette().color(backgroundRole()); }
+inline void QWidget::setPaletteBackgroundColor(const QColor &c)
+{ QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); }
+inline const QPixmap *QWidget::paletteBackgroundPixmap() const
+{ return 0; }
+inline void QWidget::setPaletteBackgroundPixmap(const QPixmap &pm)
+{ QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); }
+inline QT3_SUPPORT void QWidget::erase() { erase_helper(0, 0, data->crect.width(), data->crect.height()); }
+inline QT3_SUPPORT void QWidget::erase(const QRect &r) { erase_helper(r.x(), r.y(), r.width(), r.height()); }
+#endif
+
+#define QWIDGETSIZE_MAX ((1<<24)-1)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QWIDGET_H