From 37e3f157c7d76f13de807fa66e36df209e1005fb Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 10 Jul 2011 15:17:53 -0500 Subject: Added TQt4 HEAD --- .../tqtinterface/qt4/src/kernel/tqwidget.h | 1547 ++++++++++++++++++++ 1 file changed, 1547 insertions(+) create mode 100644 experimental/tqtinterface/qt4/src/kernel/tqwidget.h (limited to 'experimental/tqtinterface/qt4/src/kernel/tqwidget.h') diff --git a/experimental/tqtinterface/qt4/src/kernel/tqwidget.h b/experimental/tqtinterface/qt4/src/kernel/tqwidget.h new file mode 100644 index 000000000..c0274646c --- /dev/null +++ b/experimental/tqtinterface/qt4/src/kernel/tqwidget.h @@ -0,0 +1,1547 @@ +/**************************************************************************** +** +** Definition of TQWidget class +** +** Created : 931029 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the kernel module of the TQt 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 TQt 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.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** 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 TQWIDGET_H +#define TQWIDGET_H + +#include "tqtglobaldefines.h" + +#ifndef TQT_H +#include "tqwindowdefs.h" +#include "tqobject.h" +#include "tqpaintdevice.h" +#include "tqpalette.h" +#include "tqfont.h" +#include "tqfontmetrics.h" +#include "tqfontinfo.h" +#include "tqsizepolicy.h" +#include "tqbitmap.h" +#endif // TQT_H + +#ifdef USE_QT4 +#ifndef TQFONTENGINE_P_H + +#include +#include + +#endif // TQFONTENGINE_P_H +#endif // USE_QT4 + +class TQLayout; + +#ifdef USE_QT4 + +// FIXME +// Neither TQTLWExtra nor TQWExtra are fully Qt4 compatible! + +class TQFocusData; + +// typedef struct QTLWExtra TQTLWExtra; + +struct TQTLWExtra : public QTLWExtra, virtual public TQt +{ + TQFocusData *focusData; // focus data (for TLW) + ulong fleft, fright, ftop, fbottom; + uint uspos : 1; // User defined position + uint ussize : 1; // User defined size + +#if defined(TQ_WS_X11) + WId parentWinId; // tqparent window Id (valid after reparenting) +#endif +}; + +// typedef struct QWExtra TQWExtra; + +struct TQWExtra : public QWExtra, virtual public TQt +{ + TQRect micro_focus_hint; // micro focus hint + TQPixmap *bg_pix; // background pixmap + char bg_mode; // background mode + char bg_mode_visual; // visual background mode + uint bg_origin : 2; + TQSizePolicy size_policy; + TQTLWExtra *topextra; // only useful for TLWs // WARNING: This is overriding the Qt4 builtin topextra with unknown consequences..... +}; + +#else // USE_QT4 + +struct TQWExtra; +struct TQTLWExtra; + +#endif // USE_QT4 + +class TQFocusData; +class TQCursor; +class TQWSRegionManager; +class TQStyle; + +#ifdef USE_QT4 + +#include +#include + +typedef unsigned long long WFlags; +typedef QFlags WState; + +// #define WType_Desktop Qt::Desktop +// +// #define Key_Escape Qt::Key_Escape +// #define ShiftButton Qt::ShiftModifier +// #define ControlButton Qt::ControlModifier +// +// #define WStyle_Customize 0 +// #define WType_Popup Qt::Popup +// #define WX11BypassWM Qt::X11BypassWindowManagerHint + +// #define TQWIDGETSIZE_MAX 32767 +#define TQWIDGETSIZE_MAX QWIDGETSIZE_MAX + +#define TQT_TQWIDGET_INDEPENDENT_REQUIRED_INITIALIZATION \ + setAttribute(Qt::WA_PaintOutsidePaintEvent, TRUE); \ + setAutoFillBackground(true); + +#define TQT_TQWIDGET_REQUIRED_INITIALIZATION \ + extra = 0; \ + tqt_internal_ignore_next_windowstatechange_event = FALSE; \ + tqt_internal_show_called_event = FALSE; \ + if (testWFlags(WType_Popup) && testWFlags(WType_Dialog)) \ + clearWFlags((WType_Dialog & (~WType_TopLevel))); \ + TQT_TQWIDGET_INDEPENDENT_REQUIRED_INITIALIZATION \ + setDefaultWidgetFlags(); \ + processUpperWidgetFlags(); + +#define TQT_TQWIDGET_FIX_BROKEN_POPUP_MOUSE_FOCUS \ + bool new_receiver_found = FALSE; \ + QWidget *popup = qApp->activePopupWidget(); \ + QWidget *newreceiver = this; \ + QPoint gpos = mapToGlobal(e->pos()); \ + QPoint npos = newreceiver->mapFromGlobal(gpos); \ + if (popup) { \ + while (!TQT_TQRECT_OBJECT(newreceiver->rect()).tqcontains(npos)) { \ + new_receiver_found = TRUE; \ + newreceiver = tqwidget_parent_popup_menu(newreceiver); \ + if (newreceiver) { \ + npos = newreceiver->mapFromGlobal(gpos); \ + } \ + else { \ + break; \ + } \ + } \ + if ((newreceiver) && (new_receiver_found)) { \ + if (TQT_TQRECT_OBJECT(newreceiver->rect()).tqcontains(npos)) { \ + if (tqwidget_is_popup_menu(newreceiver)) { \ + npos = newreceiver->mapFromGlobal(gpos); \ + QMouseEvent fixedevent(e->type(), npos, e->globalPos(), e->button(), e->buttons(), e->modifiers()); \ + QApplication::sendEvent(newreceiver, &fixedevent); \ + e->accept(); \ + } \ + } \ + } \ + } \ + if (!((newreceiver) && (new_receiver_found))) + +extern bool tqwidget_is_popup_menu(QWidget*); +extern QWidget* tqwidget_parent_popup_menu(QWidget*); + +// class TQ_EXPORT TQWidget : public TQObject, public QWidget +class TQ_EXPORT TQWidget : public QWidget, virtual public TQt +{ + Q_OBJECT + TQ_OBJECT +public: + TQObject *tqparent() const; + TQObjectList childrenListObject(); + const TQObjectList childrenListObject() const; + +public: +// enum FocusPolicy { +// NoFocus = 0, +// TabFocus = 0x1, +// ClickFocus = 0x2, +// StrongFocus = TabFocus | ClickFocus | 0x8, +// WheelFocus = StrongFocus | 0x4 +// }; + + enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin }; + +// TQWidget methods +public: + TQWidget( QWidget* tqparent=0, const char* name=0, WFlags f=0 ); + + void setWState( uint state ); + void clearWState( uint flags ); + WState getWState() const; + WState testWState( WState s ) const; + WState testWState( TQt::WidgetState s ) const; + + void setWFlags( WFlags flags ); + void clearWFlags( WFlags flags ); + WFlags getWFlags() const; + WFlags testWFlags( WFlags f ) const; + + uint windowState() const; + void setWindowState(uint windowState); + + void setActiveWindow( void ); + Display * x11Display( void ); + int x11Depth() const; + int x11Screen( void ); + TQWidget * parentWidget( bool sameWindow = FALSE ) const; + static TQCString normalizeSignalSlot( const char *signalSlot ); + TQMetaObject *tqmetaObject() const; + static TQWidget * tqfind( WId w ); + bool isShown() const; + TQWidget *tqchildAt( int x, int y, bool includeThis = FALSE ) const; + TQWidget *tqchildAt( const TQPoint &p, bool includeThis = FALSE ) const; + TQWidget *tqtopLevelWidget() const; + bool isA(const char *classname) const; + bool inherits( const char * ) const; +// virtual bool close( bool alsoDelete ) { TQ_UNUSED(alsoDelete); return QWidget::close(); } +// TQWExtra *extraData() { return TQT_TQWEXTRA(qt_widget_private(this)->extraData()); } + TQWExtra *extraData(); +// TQTLWExtra *topData() { return qt_widget_private(this)->topData(); } + TQTLWExtra *topData(); + void setName(const char *aName); + TQWidget *parentWidget( bool sameWindow = FALSE ); + bool isDialog() const; + TQObject *child( const char *objName, const char *inheritsClass = 0, bool recursiveSearch = TRUE ); + const TQRect tqgeometry() const; + TQLayout *tqlayout() const; + virtual TQSize tqsizeHint() const; + virtual TQSize tqminimumSizeHint() const; + virtual QSize sizeHint() const; + virtual QSize minimumSizeHint() const; + TQSize tqminimumSize() const; + TQSize tqmaximumSize() const; + TQColorGroup tqcolorGroup() const; + TQStyle &tqstyle() const; + void reparent(QWidget *parent, WFlags f, const QPoint &p, bool showIt=false); + void reparent(QWidget *parent, const QPoint &p, bool showIt=false); + void iconify(); + void constPolish() const; + bool hasMouse() const; +#ifndef QT_NO_CURSOR + bool ownCursor() const; +#endif + bool ownFont() const; + void setBackgroundPixmap(const QPixmap &pm); + virtual void tqsetBackgroundPixmap(const QPixmap &pm); + const TQPixmap *backgroundPixmap() const; + void tqsetSizePolicy(QSizePolicy qsp); + void tqsetSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical); + void tqsetSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver, bool hfw); + void setInputMethodEnabled(bool b); + bool isInputMethodEnabled() const; + bool isPopup() const; + TQString caption() const; + void setCaption(const QString &c); + TQRect tqchildrenRect() const; + TQRegion tqchildrenRegion() const; + void unsetFont(); + bool ownPalette() const; + void unsetPalette(); + const TQPalette &tqpalette() const; + bool isUpdatesEnabled() const; + void tqrepaint(int x, int y, int w, int h); + void tqrepaint(const QRect &r); + void tqrepaint(const QRegion &r); + void tqrepaint(bool eraseme); + void tqrepaint(int x, int y, int w, int h, bool); + void tqrepaint(const QRect &r, bool); + void tqrepaint(const QRegion &rgn, bool); + TQSizePolicy tqsizePolicy() const; + TQPoint backgroundOffset() const; + bool tqsignalsBlocked() const; + TQObjectList *queryList( const char *inheritsClass = 0, const char *objName = 0, bool regexpMatch = TRUE, bool recursiveSearch = TRUE ) const; + TQWidget *tqfocusWidget() const; + void setBackgroundOrigin(BackgroundOrigin); + BackgroundOrigin backgroundOrigin() const; + void setIconText(const QString &it); + void insertChild( TQObject *object ); + void removeChild( TQObject *object ); + + bool close(); + bool close(bool alsoDelete); + + void setFocus(Qt::FocusReason reason); + void setFocus(TQFocusEvent::Reason reason); + + TQt::BackgroundMode backgroundMode() const; + /*virtual*/ void setBackgroundMode( TQt::BackgroundMode tqbm ); + void setBackgroundMode(TQt::BackgroundMode, TQt::BackgroundMode); + const QColor &paletteForegroundColor() const; + void setPaletteForegroundColor(const QColor &c); + const QColor &paletteBackgroundColor() const; + /*virtual*/ void setPaletteBackgroundColor(const QColor &c); + const TQPixmap *paletteBackgroundPixmap() const; + /*virtual*/ void setPaletteBackgroundPixmap(const QPixmap &pm); + const TQColor &backgroundColor() const; + /*virtual*/ void setBackgroundColor(const QColor &c); + const TQColor &eraseColor() const; + /*virtual*/ void setEraseColor(const QColor &c); + const TQPixmap *erasePixmap() const; + /*virtual*/ void setErasePixmap(const QPixmap &pm); + const TQColor &foregroundColor() const; + + virtual void setAutoMask(bool); + bool autoMask() const; + virtual void updateMask(); + + void erase(); + void erase(int x, int y, int w, int h); + void erase(const QRect &r); + void erase(const QRegion &r); + + void drawText( int x, int y, const TQString &); + void drawText( const TQPoint &, const TQString &); + + const TQBrush& backgroundBrush() const; + void setIcon(const QPixmap &i); + const TQPixmap *icon() const; + const TQPixmap iconPixmap() const; + + const char *tqname() const; + const char *name() const; + const char *name(const char *defaultName) const; + + bool isVisibleToTLW() const; // obsolete + static TQWidget* tqt_ensure_valid_widget_painting(TQWidget* w); + + void setMask( const QBitmap ); + void setMask( const QRegion ); + +#ifndef TQT_NO_STYLE + void setStyle( TQStyle * ); + TQStyle* setStyle( const TQString& ); +#endif + +#ifndef TQT_NO_PALETTE + void tqsetPalette( const TQPalette &p, bool ); +#endif + +// static TQWidgetMapper *wmapper( void ) { return QWidgetPrivate::mapper; } + +// TQWExtra *extraData(); +// TQTLWExtra *topData(); +// TQFocusData *focusData(); + + bool isDesktop() const; + + void createTLSysExtra( void ); + void destroyInputContext( void ); + + void createExtra(); + void deleteExtra(); + + bool isFocusEnabled() const; + +// TQRect tqeffectiveRectFor(const QRect &rect); + TQRect tqclipRect() const; + TQRect visibleRect() const; + TQRegion clipRegion() const; + + virtual bool customWhatsThis() const; + + virtual void setKeyCompression(bool); + TQRect microFocusHint() const; + virtual void setMicroFocusHint(int x, int y, int w, int h, bool text=TRUE, TQFont *f = 0); + +// // Interoperability +// TQWidget* operator= (QWidget* a) +// { +// return static_cast(a); +// } + + operator TQObject*() const { return TQT_TQOBJECT(const_cast(this)); } // This implicit pointer converter doesn't work for some reason + +public: + // TQt handler + virtual bool eventFilter( TQObject *, TQEvent * ); + + // Qt4 handler interface + virtual bool eventFilter( QObject *q, QEvent *e ); + bool event( QEvent *e ); + +protected: + inline bool checkConnectArgs(const char *signal, const TQT_BASE_OBJECT_NAME *name, const char *member) { return TQT_TQOBJECT(this)->checkConnectArgs(signal, name, member); } + +// TQt event handlers +protected: + TQFocusData *focusData(); +// virtual bool event( QEvent *e ); // NOTE: All event handlers that can be subclassed must be declared here, and + // declared virtual, so that run time dynamic call resolution will occur + virtual bool event( TQEvent *e ); + virtual void mousePressEvent( TQMouseEvent * ); + virtual void mouseReleaseEvent( TQMouseEvent * ); + virtual void mouseDoubleClickEvent( TQMouseEvent * ); + virtual void mouseMoveEvent( TQMouseEvent * ); +#ifndef TQT_NO_WHEELEVENT + virtual void wheelEvent( TQWheelEvent * ); +#endif + virtual void keyPressEvent( TQKeyEvent * ); + virtual void keyReleaseEvent( TQKeyEvent * ); + virtual void focusInEvent( TQFocusEvent * ); + virtual void focusOutEvent( TQFocusEvent * ); + virtual void enterEvent( TQEvent * ); + virtual void leaveEvent( TQEvent * ); + virtual void paintEvent( TQPaintEvent * ); + virtual void moveEvent( TQMoveEvent * ); + virtual void resizeEvent( TQResizeEvent * ); + virtual void closeEvent( TQCloseEvent * ); + virtual void contextMenuEvent( TQContextMenuEvent * ); + virtual void imStartEvent( TQIMEvent * ); + virtual void imComposeEvent( TQIMEvent * ); + virtual void imEndEvent( TQIMEvent * ); + virtual void tabletEvent( TQTabletEvent * ); + +#ifndef TQT_NO_DRAGANDDROP + virtual void dragEnterEvent( TQDragEnterEvent * ); + virtual void dragMoveEvent( TQDragMoveEvent * ); + virtual void dragLeaveEvent( TQDragLeaveEvent * ); + virtual void dropEvent( TQDropEvent * ); +#endif + + virtual void showEvent( TQShowEvent * ); + virtual void hideEvent( TQHideEvent * ); + +#if defined(TQ_WS_MAC) + virtual bool macEvent( MSG * ); +#endif +#if defined(TQ_WS_WIN) + virtual bool winEvent( MSG * ); +#endif +#if defined(TQ_WS_X11) + virtual bool x11Event( XEvent * ); +#endif +#if defined(TQ_WS_TQWS) + virtual bool qwsEvent( TQWSEvent * ); +#endif + +// Qt4 event handler interface +protected: + virtual void mousePressEvent(QMouseEvent *e); + virtual void mouseReleaseEvent(QMouseEvent *e); + virtual void mouseDoubleClickEvent(QMouseEvent *e); + virtual void mouseMoveEvent(QMouseEvent *e); +#ifndef QT_NO_WHEELEVENT + virtual void wheelEvent(QWheelEvent *e); +#endif + virtual void keyPressEvent(QKeyEvent *e); + virtual void keyReleaseEvent(QKeyEvent *e); + virtual void focusInEvent(QFocusEvent *e); + virtual void focusOutEvent(QFocusEvent *e); + virtual void enterEvent(QEvent *e); + virtual void leaveEvent(QEvent *e); + virtual void paintEvent(QPaintEvent *e); + virtual void moveEvent(QMoveEvent *e); + virtual void resizeEvent(QResizeEvent *e); + virtual void closeEvent(QCloseEvent *e); +#ifndef QT_NO_CONTEXTMENU + virtual void contextMenuEvent(QContextMenuEvent *e); +#endif +#ifndef QT_NO_TABLETEVENT + virtual void tabletEvent(QTabletEvent *e); +#endif +#ifndef QT_NO_ACTION +// inline virtual void actionEvent(QActionEvent *e) { actionEvent(static_cast(e)); } +#endif + +// #ifndef QT_NO_DRAGANDDROP +// inline virtual void dragEnterEvent(QDragEnterEvent *e) { dragEnterEvent(static_cast(e)); } +// inline virtual void dragMoveEvent(QDragMoveEvent *e) { dragMoveEvent(static_cast(e)); } +// inline virtual void dragLeaveEvent(QDragLeaveEvent *e) { dragLeaveEvent(static_cast(e)); } +// inline virtual void dropEvent(QDropEvent *e) { dropEvent(static_cast(e)); } +// #endif + + virtual void showEvent(QShowEvent *e); + virtual void hideEvent(QHideEvent *e); + +// #if defined(Q_WS_MAC) +// inline virtual bool macEvent(EventHandlerCallRef e, EventRef r); +// #endif +// #if defined(Q_WS_WIN) +// inline virtual bool winEvent(MSG *message, long *result); +// #endif +// #if defined(Q_WS_X11) +// inline virtual bool x11Event(XEvent *e) +// #endif +// #if defined(Q_WS_QWS) +// inline virtual bool qwsEvent(QWSEvent *e); +// #endif + +// TQt event handlers +protected: + virtual void timerEvent( TQTimerEvent * ); + virtual void childEvent( TQChildEvent * ); + virtual void customEvent( TQCustomEvent * ); + +// Qt4 event handler interface +protected: + virtual void timerEvent(QTimerEvent *e); + virtual void childEvent(QChildEvent *e); + virtual void customEvent(QEvent *e); + +private: + mutable TQStyle* tqt_internal_stylePointer; + void erase_helper(int x, int y, int w, int h); + TQWExtra *extra; + TQFocusData *focusData( bool create ); + void createTLExtra(); + bool tqt_internal_show_called_event; + mutable bool tqt_internal_ignore_next_windowstatechange_event; + mutable TQString static_object_name; + + void showWindow(); + void hideWindow(); + + WFlags TQtUpperWidgetFlags; + void processUpperWidgetFlags(); + void setDefaultWidgetFlags(); + + friend class TQObject; + +public Q_SLOTS: + virtual void tqsetUpdatesEnabled( bool enable ); + void tqrepaint(); + virtual void setFocus(); + virtual void show(); + virtual void adjustSize(); +// inline virtual void adjustSize() { +// QApplication::sendPostedEvents( 0, TQEvent::ChildInserted ); +// QWidget::adjustSize(); +// } + virtual void polish(); +// inline virtual void setGeometry( int x, int y, int w, int h ) { return QWidget::setGeometry(x, y, w, h); } +// inline virtual void setGeometry( const TQRect &r ) { return QWidget::setGeometry(r); } + +// protected: + TQConnectionList *tqreceivers( const char* signal ) const; + TQConnectionList *tqreceivers( int signal ) const; +// + void activate_signal( int signal ); +// void activate_signal( int signal, int second ) { TQT_TQOBJECT(this)->activate_signal(signal, second); } +// void activate_signal( int signal, double second ) { TQT_TQOBJECT(this)->activate_signal(signal, second); } +// void activate_signal( int signal, TQString second ) { TQT_TQOBJECT(this)->activate_signal(signal, second); } +// void activate_signal_bool( int signal, bool second ) { TQT_TQOBJECT(this)->activate_signal(signal, second); } + void activate_signal( TQConnectionList *clist, TQUObject *o ); + + void tqt_handle_qt_destroyed(QObject* obj); + +Q_SIGNALS: + void destroyed( TQObject* obj ); +}; + +inline void TQWidget::drawText( const TQPoint &p, const TQString &s ) +{ drawText( p.x(), p.y(), s ); } + +#else // USE_QT4 + +class TQ_EXPORT TQWidget : public TQObject, public TQPaintDevice +{ + TQ_OBJECT + TQ_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( TQRect tqgeometry READ tqgeometry WRITE setGeometry ) + Q_PROPERTY( TQRect frameGeometry READ frameGeometry ) + Q_PROPERTY( int x READ x ) + Q_PROPERTY( int y READ y ) + Q_PROPERTY( TQPoint pos READ pos WRITE move DESIGNABLE false STORED false ) + Q_PROPERTY( TQSize frameSize READ frameSize ) + Q_PROPERTY( TQSize size READ size WRITE resize DESIGNABLE false STORED false ) + Q_PROPERTY( int width READ width ) + Q_PROPERTY( int height READ height ) + Q_PROPERTY( TQRect rect READ rect ) + Q_PROPERTY( TQRect tqchildrenRect READ tqchildrenRect ) + Q_PROPERTY( TQRegion tqchildrenRegion READ tqchildrenRegion ) + Q_PROPERTY( TQSizePolicy sizePolicy READ sizePolicy WRITE tqsetSizePolicy ) + Q_PROPERTY( TQSize tqminimumSize READ tqminimumSize WRITE setMinimumSize ) + Q_PROPERTY( TQSize tqmaximumSize READ tqmaximumSize 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( TQSize sizeIncrement READ sizeIncrement WRITE setSizeIncrement ) + Q_PROPERTY( TQSize baseSize READ baseSize WRITE setBaseSize ) + Q_PROPERTY( BackgroundMode backgroundMode READ backgroundMode WRITE setBackgroundMode DESIGNABLE false ) + Q_PROPERTY( TQColor paletteForegroundColor READ paletteForegroundColor WRITE setPaletteForegroundColor RESET unsetPalette ) + Q_PROPERTY( TQColor paletteBackgroundColor READ paletteBackgroundColor WRITE setPaletteBackgroundColor RESET unsetPalette ) + Q_PROPERTY( TQPixmap paletteBackgroundPixmap READ paletteBackgroundPixmap WRITE setPaletteBackgroundPixmap RESET unsetPalette ) + Q_PROPERTY( TQBrush backgroundBrush READ backgroundBrush ) + Q_PROPERTY( TQColorGroup tqcolorGroup READ tqcolorGroup ) + Q_PROPERTY( TQPalette 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( TQFont font READ font WRITE setFont RESET unsetFont STORED ownFont ) + Q_PROPERTY( bool ownFont READ ownFont ) +#ifndef TQT_NO_CURSOR + Q_PROPERTY( TQCursor cursor READ cursor WRITE setCursor RESET unsetCursor STORED ownCursor ) + Q_PROPERTY( bool ownCursor READ ownCursor ) +#endif +#ifndef TQT_NO_WIDGET_TOPEXTRA + Q_PROPERTY( TQString caption READ caption WRITE setCaption ) + Q_PROPERTY( TQPixmap icon READ icon WRITE setIcon ) + Q_PROPERTY( TQString 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( TQRect 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( TQSize tqsizeHint READ tqsizeHint ) + Q_PROPERTY( TQSize tqminimumSizeHint READ tqminimumSizeHint ) + Q_PROPERTY( TQRect 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: + TQ_EXPLICIT TQWidget( TQWidget* tqparent=0, const char* name=0, WFlags f=0 ); + ~TQWidget(); + + WId winId() const; + void setName( const char *name ); +#ifndef TQT_NO_STYLE + // GUI style setting + + TQStyle &style() const; + void setStyle( TQStyle * ); + TQStyle* setStyle( const TQString& ); +#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(TQWidget*) const; + bool isEnabledToTLW() const; + +public Q_SLOTS: + virtual void setEnabled( bool ); + void setDisabled( bool ); + + // Widget coordinates + +public: + TQRect frameGeometry() const; + const TQRect &tqgeometry() const; + int x() const; + int y() const; + TQPoint pos() const; + TQSize frameSize() const; + TQSize size() const; + int width() const; + int height() const; + TQRect rect() const; + TQRect tqchildrenRect() const; + TQRegion tqchildrenRegion() const; + + TQSize tqminimumSize() const; + TQSize tqmaximumSize() const; + int minimumWidth() const; + int minimumHeight() const; + int maximumWidth() const; + int maximumHeight() const; + void setMinimumSize( const TQSize & ); + virtual void setMinimumSize( int minw, int minh ); + void setMaximumSize( const TQSize & ); + virtual void setMaximumSize( int maxw, int maxh ); + void setMinimumWidth( int minw ); + void setMinimumHeight( int minh ); + void setMaximumWidth( int maxw ); + void setMaximumHeight( int maxh ); + + TQSize sizeIncrement() const; + void setSizeIncrement( const TQSize & ); + virtual void setSizeIncrement( int w, int h ); + TQSize baseSize() const; + void setBaseSize( const TQSize & ); + void setBaseSize( int basew, int baseh ); + + void setFixedSize( const TQSize & ); + void setFixedSize( int w, int h ); + void setFixedWidth( int w ); + void setFixedHeight( int h ); + + // Widget coordinate mapping + + TQPoint mapToGlobal( const TQPoint & ) const; + TQPoint mapFromGlobal( const TQPoint & ) const; + TQPoint mapToParent( const TQPoint & ) const; + TQPoint mapFromParent( const TQPoint & ) const; + TQPoint mapTo( TQWidget *, const TQPoint & ) const; + TQPoint mapFrom( TQWidget *, const TQPoint & ) const; + + TQWidget *tqtopLevelWidget() const; + + // Widget attribute functions + + BackgroundMode backgroundMode() const; + virtual void setBackgroundMode( BackgroundMode ); + void setBackgroundMode( BackgroundMode, BackgroundMode ); + + const TQColor & foregroundColor() const; + + const TQColor & eraseColor() const; + virtual void setEraseColor( const TQColor & ); + + const TQPixmap * erasePixmap() const; + virtual void setErasePixmap( const TQPixmap & ); + +#ifndef TQT_NO_PALETTE + const TQColorGroup & tqcolorGroup() const; + const TQPalette & palette() const; + bool ownPalette() const; + virtual void setPalette( const TQPalette & ); + void unsetPalette(); +#endif + + const TQColor & paletteForegroundColor() const; + void setPaletteForegroundColor( const TQColor & ); + + const TQColor & paletteBackgroundColor() const; + virtual void setPaletteBackgroundColor( const TQColor & ); + + const TQPixmap * paletteBackgroundPixmap() const; + virtual void setPaletteBackgroundPixmap( const TQPixmap & ); + + const TQBrush& backgroundBrush() const; + + TQFont font() const; + bool ownFont() const; + virtual void setFont( const TQFont & ); + void unsetFont(); + TQFontMetrics fontMetrics() const; + TQFontInfo fontInfo() const; + +#ifndef TQT_NO_CURSOR + const TQCursor &cursor() const; + bool ownCursor() const; + virtual void setCursor( const TQCursor & ); + virtual void unsetCursor(); +#endif +#ifndef TQT_NO_WIDGET_TOPEXTRA + TQString caption() const; + const TQPixmap *icon() const; + TQString iconText() const; +#endif + bool hasMouseTracking() const; + bool hasMouse() const; + + virtual void setMask( const TQBitmap & ); + virtual void setMask( const TQRegion & ); + void clearMask(); + + const TQColor & backgroundColor() const; // obsolete, use eraseColor() + virtual void setBackgroundColor( const TQColor & ); // obsolete, use setEraseColor() + const TQPixmap * backgroundPixmap() const; // obsolete, use erasePixmap() + virtual void setBackgroundPixmap( const TQPixmap & ); // obsolete, use setErasePixmap() + +public Q_SLOTS: +#ifndef TQT_NO_WIDGET_TOPEXTRA + virtual void setCaption( const TQString &); + virtual void setIcon( const TQPixmap & ); + virtual void setIconText( const TQString &); +#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( TQWidget *, TQWidget * ); + virtual void setFocusProxy( TQWidget * ); + TQWidget * focusProxy() const; + + void setInputMethodEnabled( bool b ); + bool isInputMethodEnabled() const; + // Grab functions + + void grabMouse(); +#ifndef TQT_NO_CURSOR + void grabMouse( const TQCursor & ); +#endif + void releaseMouse(); + void grabKeyboard(); + void releaseKeyboard(); + static TQWidget * mouseGrabber(); + static TQWidget * keyboardGrabber(); + + // Update/refresh functions + + bool isUpdatesEnabled() const; + +#if 0 //def TQ_WS_TQWS + void repaintUnclipped( const TQRegion &, bool erase = TRUE ); +#endif +public Q_SLOTS: + virtual void setUpdatesEnabled( bool enable ); + void update(); + void update( int x, int y, int w, int h ); + void update( const TQRect& ); + void tqrepaint(); + void tqrepaint( bool erase ); + void tqrepaint( int x, int y, int w, int h, bool erase=TRUE ); + void tqrepaint( const TQRect &, bool erase = TRUE ); + void tqrepaint( const TQRegion &, bool erase = TRUE ); + + // Widget management functions + + virtual void show(); + virtual void hide(); + void setShown( bool show ); + void setHidden( bool hide ); +#ifndef TQT_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( TQWidget* ); + virtual void move( int x, int y ); + void move( const TQPoint & ); + virtual void resize( int w, int h ); + void resize( const TQSize & ); + virtual void setGeometry( int x, int y, int w, int h ); + virtual void setGeometry( const TQRect & ); // ### make non virtual in TQt 4? + +public: + virtual bool close( bool alsoDelete ); + bool isVisible() const; + bool isVisibleTo(TQWidget*) const; + bool isVisibleToTLW() const; // obsolete + TQRect 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 TQSize tqsizeHint() const; + virtual TQSize tqminimumSizeHint() const; + virtual TQSizePolicy sizePolicy() const; + virtual void tqsetSizePolicy( TQSizePolicy ); + void tqsetSizePolicy( TQSizePolicy::SizeType hor, TQSizePolicy::SizeType ver, bool hfw = FALSE ); + virtual int heightForWidth(int) const; + + TQRegion clipRegion() const; + +// ### move together with other Q_SLOTS in TQt 4.0 +public Q_SLOTS: + virtual void adjustSize(); + +public: +#ifndef TQT_NO_LAYOUT + TQLayout * tqlayout() const { return lay_out; } +#endif + void updateGeometry(); + virtual void reparent( TQWidget *tqparent, WFlags, const TQPoint &, + bool showIt=FALSE ); + void reparent( TQWidget *tqparent, const TQPoint &, + bool showIt=FALSE ); +#ifndef TQT_NO_COMPAT + void recreate( TQWidget *tqparent, WFlags f, const TQPoint & p, + bool showIt=FALSE ) { reparent(tqparent,f,p,showIt); } +#endif + + void erase(); + void erase( int x, int y, int w, int h ); + void erase( const TQRect & ); + void erase( const TQRegion & ); + void scroll( int dx, int dy ); + void scroll( int dx, int dy, const TQRect& ); + + void drawText( int x, int y, const TQString &); + void drawText( const TQPoint &, const TQString &); + + // Misc. functions + + TQWidget * tqfocusWidget() const; + TQRect 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; + TQPoint backgroundOffset() const; + + // whats this help + virtual bool customWhatsThis() const; + + TQWidget * parentWidget( bool sameWindow = FALSE ) const; + WState testWState( WState s ) const; + WFlags testWFlags( WFlags f ) const; + static TQWidget * tqfind( WId ); + static TQWidgetMapper *wmapper(); + + TQWidget *tqchildAt( int x, int y, bool includeThis = FALSE ) const; + TQWidget *tqchildAt( const TQPoint &, bool includeThis = FALSE ) const; + +#if defined(TQ_WS_TQWS) + virtual TQGfx * graphicsContext(bool clip_tqchildren=TRUE) const; +#endif +#if defined(TQ_WS_MAC) + TQRegion clippedRegion(bool do_tqchildren=TRUE); + uint clippedSerial(bool do_tqchildren=TRUE); +#ifndef TQMAC_NO_TQUARTZ + CGContextRef macCGContext(bool clipped=TRUE) const; +#endif +#endif + + void setWindowOpacity(double level); + double windowOpacity() const; + +protected: + // Event handlers + virtual bool event( TQEvent * ); + virtual void mousePressEvent( TQMouseEvent * ); + virtual void mouseReleaseEvent( TQMouseEvent * ); + virtual void mouseDoubleClickEvent( TQMouseEvent * ); + virtual void mouseMoveEvent( TQMouseEvent * ); +#ifndef TQT_NO_WHEELEVENT + virtual void wheelEvent( TQWheelEvent * ); +#endif + virtual void keyPressEvent( TQKeyEvent * ); + virtual void keyReleaseEvent( TQKeyEvent * ); + virtual void focusInEvent( TQFocusEvent * ); + virtual void focusOutEvent( TQFocusEvent * ); + virtual void enterEvent( TQEvent * ); + virtual void leaveEvent( TQEvent * ); + virtual void paintEvent( TQPaintEvent * ); + virtual void moveEvent( TQMoveEvent * ); + virtual void resizeEvent( TQResizeEvent * ); + virtual void closeEvent( TQCloseEvent * ); + virtual void contextMenuEvent( TQContextMenuEvent * ); + virtual void imStartEvent( TQIMEvent * ); + virtual void imComposeEvent( TQIMEvent * ); + virtual void imEndEvent( TQIMEvent * ); + virtual void tabletEvent( TQTabletEvent * ); + +#ifndef TQT_NO_DRAGANDDROP + virtual void dragEnterEvent( TQDragEnterEvent * ); + virtual void dragMoveEvent( TQDragMoveEvent * ); + virtual void dragLeaveEvent( TQDragLeaveEvent * ); + virtual void dropEvent( TQDropEvent * ); +#endif + + virtual void showEvent( TQShowEvent * ); + virtual void hideEvent( TQHideEvent * ); + +#if defined(TQ_WS_MAC) + virtual bool macEvent( MSG * ); +#endif +#if defined(TQ_WS_WIN) + virtual bool winEvent( MSG * ); +#endif +#if defined(TQ_WS_X11) + virtual bool x11Event( XEvent * ); +#endif +#if defined(TQ_WS_TQWS) + virtual bool qwsEvent( TQWSEvent * ); + virtual unsigned char *scanLine( int ) const; + virtual int bytesPerLine() const; +#endif + + virtual void updateMask(); + + // Misc. protected functions + +#ifndef TQT_NO_STYLE + virtual void styleChange( TQStyle& ); +#endif + virtual void enabledChange( bool oldEnabled ); +#ifndef TQT_NO_PALETTE + virtual void paletteChange( const TQPalette & ); +#endif + virtual void fontChange( const TQFont & ); + virtual void windowActivationChange( bool oldActive ); + + int metric( int ) const; + + 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 ); + + TQWExtra *extraData(); + TQTLWExtra *topData(); + TQFocusData *focusData(); + + virtual void setKeyCompression(bool); + virtual void setMicroFocusHint(int x, int y, int w, int h, bool text=TRUE, TQFont *f = 0); + +#if defined(TQ_WS_MAC) + void dirtyClippedRegion(bool); + bool isClippedRegionDirty(); + virtual void setRegionDirty(bool); + virtual void macWidgetChangedWindow(); +#endif + +private Q_SLOTS: + void focusProxyDestroyed(); + +private: + void setFontSys( TQFont *f = 0 ); +#if defined(TQ_WS_X11) + void createInputContext(); + void destroyInputContext(); + void focusInputContext(); + void checkChildrenDnd(); +#elif defined(TQ_WS_MAC) + uint own_id : 1, macDropEnabled : 1; + EventHandlerRef window_event; + //mac event functions + void propagateUpdates(bool update_rgn=TRUE); + void update( const TQRegion& ); + //friends, way too many - fix this immediately! + friend void qt_clean_root_win(); + friend bool qt_recreate_root_win(); + friend TQPoint posInWindow(TQWidget *); + friend bool qt_mac_update_sizer(TQWidget *, int); + friend TQWidget *qt_recursive_match(TQWidget *widg, int x, int y); + friend bool qt_paint_childrenListObject(TQWidget *,TQRegion &, uchar ops); + friend TQMAC_PASCAL OStqStatus qt_window_event(EventHandlerCallRef er, EventRef event, void *); + friend void qt_event_request_updates(TQWidget *, const TQRegion &, bool subtract); + friend bool qt_window_rgn(WId, short, RgnHandle, bool); + friend class TQDragManager; +#endif + +#ifndef TQT_NO_LAYOUT + void setLayout( TQLayout *l ); +#endif + void setWinId( WId ); + void showWindow(); + void hideWindow(); + void showChildren( bool spontaneous ); + void hideChildren( bool spontaneous ); + void reparentSys( TQWidget *tqparent, WFlags, const TQPoint &, 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( TQWidget * ); + TQFocusData *focusData( bool create ); + void setBackgroundFromMode(); + void setBackgroundColorDirect( const TQColor & ); + void setBackgroundPixmapDirect( const TQPixmap & ); + void setBackgroundModeDirect( BackgroundMode ); + void setBackgroundEmpty(); + void updateFrameStrut() const; +#if defined(TQ_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; + TQRect crect; + TQColor bg_col; +#ifndef TQT_NO_PALETTE + TQPalette pal; +#endif + TQFont fnt; +#ifndef TQT_NO_LAYOUT + TQLayout *lay_out; +#endif + TQWExtra *extra; +#if defined(TQ_WS_TQWS) + TQRegion req_region; // Requested region + mutable TQRegion paintable_region; // Paintable region + mutable bool paintable_region_dirty;// needs to be recalculated + mutable TQRegion alloc_region; // Allocated region + mutable bool alloc_region_dirty; // needs to be recalculated + mutable int overlapping_tqchildren; // Handle overlapping tqchildren + + int alloc_region_index; + int alloc_region_revision; + + void updateOverlappingChildren() const; + void setChildrenAllocatedDirty(); + void setChildrenAllocatedDirty( const TQRegion &r, const TQWidget *dirty=0 ); + bool isAllocatedRegionDirty() const; + void updateRequestedRegion( const TQPoint &gpos ); + TQRegion requestedRegion() const; + TQRegion allocatedRegion() const; + TQRegion paintableRegion() const; + + void updateGraphicsContext( TQGfx *qgfx_qws, bool clip_tqchildren ) const; +#ifndef TQT_NO_CURSOR + void updateCursor( const TQRegion &r ) const; +#endif + + // used to accumulate dirty region when tqchildren moved/resized. + TQRegion dirtyChildren; + bool isSettingGeometry; + friend class TQWSManager; +#endif + static int instanceCounter; // Current number of widget instances + static int maxInstances; // Maximum number of widget instances + + static void createMapper(); + static void destroyMapper(); + static TQWidgetList *wList(); + static TQWidgetList *tlwList(); + static TQWidgetMapper *mapper; + friend class TQApplication; + friend class TQBaseApplication; + friend class TQPainter; + friend class TQFontMetrics; + friend class TQFontInfo; + friend class TQETWidget; + friend class TQLayout; + +private: // Disabled copy constructor and operator= +#if defined(TQ_DISABLE_COPY) + TQWidget( const TQWidget & ); + TQWidget &operator=( const TQWidget & ); +#endif + +public: // obsolete functions to dissappear or to become inline in 3.0 +#ifndef TQT_NO_PALETTE + void setPalette( const TQPalette &p, bool ) { setPalette( p ); } +#endif + void setFont( const TQFont &f, bool ) { setFont( f ); } +}; + + +inline TQt::WState TQWidget::testWState( WState s ) const +{ return (widget_state & s); } + +inline TQt::WFlags TQWidget::testWFlags( WFlags f ) const +{ return (widget_flags & f); } + + +inline WId TQWidget::winId() const +{ return winid; } + +inline bool TQWidget::isTopLevel() const +{ return testWFlags(WType_TopLevel); } + +inline bool TQWidget::isDialog() const +{ return testWFlags(WType_Dialog); } + +inline bool TQWidget::isPopup() const +{ return testWFlags(WType_Popup); } + +inline bool TQWidget::isDesktop() const +{ return testWFlags(WType_Desktop); } + +inline bool TQWidget::isEnabled() const +{ return !testWState(WState_Disabled); } + +inline bool TQWidget::isModal() const +{ return testWFlags(WShowModal); } + +inline bool TQWidget::isEnabledToTLW() const +{ return isEnabled(); } + +inline const TQRect &TQWidget::tqgeometry() const +{ return crect; } + +inline TQSize TQWidget::size() const +{ return crect.size(); } + +inline int TQWidget::width() const +{ return crect.width(); } + +inline int TQWidget::height() const +{ return crect.height(); } + +inline TQRect TQWidget::rect() const +{ return TQRect(0,0,crect.width(),crect.height()); } + +inline int TQWidget::minimumWidth() const +{ return tqminimumSize().width(); } + +inline int TQWidget::minimumHeight() const +{ return tqminimumSize().height(); } + +inline int TQWidget::maximumWidth() const +{ return tqmaximumSize().width(); } + +inline int TQWidget::maximumHeight() const +{ return tqmaximumSize().height(); } + +inline void TQWidget::setMinimumSize( const TQSize &s ) +{ setMinimumSize(s.width(),s.height()); } + +inline void TQWidget::setMaximumSize( const TQSize &s ) +{ setMaximumSize(s.width(),s.height()); } + +inline void TQWidget::setSizeIncrement( const TQSize &s ) +{ setSizeIncrement(s.width(),s.height()); } + +inline void TQWidget::setBaseSize( const TQSize &s ) +{ setBaseSize(s.width(),s.height()); } + +inline const TQColor &TQWidget::eraseColor() const +{ return bg_col; } + +#ifndef TQT_NO_PALETTE +inline const TQPalette &TQWidget::palette() const +{ return pal; } +#endif + +inline TQFont TQWidget::font() const +{ return fnt; } + +inline TQFontMetrics TQWidget::fontMetrics() const +{ return TQFontMetrics(font()); } + +inline TQFontInfo TQWidget::fontInfo() const +{ return TQFontInfo(font()); } + +inline bool TQWidget::hasMouseTracking() const +{ return testWState(WState_MouseTracking); } + +inline bool TQWidget::hasMouse() const +{ return testWState(WState_HasMouse); } + +inline bool TQWidget::isFocusEnabled() const +{ return (FocusPolicy)focus_policy != NoFocus; } + +inline TQWidget::FocusPolicy TQWidget::focusPolicy() const +{ return (FocusPolicy)focus_policy; } + +inline bool TQWidget::isUpdatesEnabled() const +{ return !testWState(WState_BlockUpdates); } + +inline void TQWidget::update( const TQRect &r ) +{ update( r.x(), r.y(), r.width(), r.height() ); } + +inline void TQWidget::tqrepaint() +{ tqrepaint( TRUE ); } + +inline void TQWidget::tqrepaint( const TQRect &r, bool erase ) +{ tqrepaint( r.x(), r.y(), r.width(), r.height(), erase ); } + +inline void TQWidget::erase() +{ erase( 0, 0, crect.width(), crect.height() ); } + +inline void TQWidget::erase( const TQRect &r ) +{ erase( r.x(), r.y(), r.width(), r.height() ); } + +inline bool TQWidget::close() +{ return close( FALSE ); } + +inline bool TQWidget::isVisible() const +{ return testWState(WState_Visible); } + +inline bool TQWidget::isVisibleToTLW() const // obsolete +{ return isVisible(); } + +inline bool TQWidget::isHidden() const +{ return testWState(WState_ForceHide); } + +inline bool TQWidget::isShown() const +{ return !testWState(WState_ForceHide); } + +inline void TQWidget::move( const TQPoint &p ) +{ move( p.x(), p.y() ); } + +inline void TQWidget::resize( const TQSize &s ) +{ resize( s.width(), s.height()); } + +inline void TQWidget::setGeometry( const TQRect &r ) +{ setGeometry( r.left(), r.top(), r.width(), r.height() ); } + +inline void TQWidget::drawText( const TQPoint &p, const TQString &s ) +{ drawText( p.x(), p.y(), s ); } + +inline TQWidget *TQWidget::parentWidget( bool sameWindow ) const +{ + if ( sameWindow ) + return isTopLevel() ? 0 : (TQWidget *)TQObject::tqparent(); + return (TQWidget *)TQObject::tqparent(); +} + +inline TQWidgetMapper *TQWidget::wmapper() +{ return mapper; } + +inline uint TQWidget::getWState() const +{ return widget_state; } + +inline void TQWidget::setWState( uint f ) +{ widget_state |= f; } + +inline void TQWidget::clearWState( uint f ) +{ widget_state &= ~f; } + +inline TQt::WFlags TQWidget::getWFlags() const +{ return widget_flags; } + +inline void TQWidget::setWFlags( WFlags f ) +{ widget_flags |= f; } + +inline void TQWidget::clearWFlags( WFlags f ) +{ widget_flags &= ~f; } + +inline void TQWidget::constPolish() const +{ + if ( !testWState(WState_Polished) ) { + TQWidget* that = (TQWidget*) this; + that->polish(); + that->setWState(WState_Polished); // be on the safe side... + } +} +#ifndef TQT_NO_CURSOR +inline bool TQWidget::ownCursor() const +{ + return testWState( WState_OwnCursor ); +} +#endif +inline bool TQWidget::ownFont() const +{ + return own_font; +} +#ifndef TQT_NO_PALETTE +inline bool TQWidget::ownPalette() const +{ + return own_palette; +} +#endif + +inline void TQWidget::tqsetSizePolicy( TQSizePolicy::SizeType hor, TQSizePolicy::SizeType ver, bool hfw ) +{ + tqsetSizePolicy( TQSizePolicy( hor, ver, hfw) ); +} + +inline bool TQWidget::isInputMethodEnabled() const +{ + return (bool)im_enabled; +} + +// Extra TQWidget data +// - to minimize memory usage for members that are seldom used. +// - top-level widgets have extra extra data to reduce cost further + +class TQFocusData; +class TQWSManager; +#if defined(TQ_WS_WIN) +class TQOleDropTarget; +#endif +#if defined(TQ_WS_MAC) +class TQMacDndExtra; +#endif + +#endif // USE_QT4 + +#ifdef USE_QT4 + +#else // USE_QT4 + +struct TQ_EXPORT TQTLWExtra { +#ifndef TQT_NO_WIDGET_TOPEXTRA + TQString caption; // widget caption + TQString iconText; // widget icon text + TQPixmap *icon; // widget icon +#endif + TQFocusData *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( TQ_WS_WIN ) || defined( TQ_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(TQ_WS_X11) + WId parentWinId; // tqparent window Id (valid after reparenting) + uint embedded : 1; // window is embedded in another TQt 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 + void *xic; // XIM Input Context +#endif +#if defined(TQ_WS_MAC) + WindowGroupRef group; + uint is_moved: 1; + uint resizer : 4; +#endif +#if defined(TQ_WS_TQWS) && !defined ( TQT_NO_TQWS_MANAGER ) + TQRegion decor_allocated_region; // decoration allocated region + TQWSManager *qwsManager; +#endif +#if defined(TQ_WS_WIN) + HICON winIcon; // internal Windows icon +#endif + TQRect normalGeometry; // used by showMin/maximized/FullScreen +#ifdef TQ_WS_WIN + uint style, exstyle; +#endif +}; + + +#define TQWIDGETSIZE_MAX 32767 + +// dear user: you can see this struct, but it is internal. do not touch. + +struct TQ_EXPORT TQWExtra { + TQ_INT16 minw, minh; // minimum size + TQ_INT16 maxw, maxh; // maximum size + TQPixmap *bg_pix; // background pixmap + TQWidget *focus_proxy; +#ifndef TQT_NO_CURSOR + TQCursor *curs; +#endif + TQTLWExtra *topextra; // only useful for TLWs +#if defined(TQ_WS_WIN) + TQOleDropTarget *dropTarget; // drop target +#endif +#if defined(TQ_WS_X11) + WId xDndProxy; // XDND forwarding to embedded windows +#endif +#if defined(TQ_WS_MAC) + TQRegion clip_saved, clip_sibs, clip_tqchildren; + TQMacDndExtra *macDndExtra; + TQRegion dirty_area; + uint clip_dirty : 1, clip_serial : 15; + uint child_dirty : 1, child_serial : 15; +#ifndef TQMAC_NO_TQUARTZ + uint ctx_tqchildren_clipped:1; +#endif // TQMAC_NO_TQUARTZ + uint has_dirty_area:1; +#endif // TQ_WS_MAC + uint bg_origin : 2; +#if defined(TQ_WS_X11) + uint tqchildren_use_dnd : 1; + uint compress_events : 1; +#endif +#if defined(TQ_WS_TQWS) || defined(TQ_WS_MAC) + TQRegion tqmask; // widget tqmask +#endif + char bg_mode; // background mode + char bg_mode_visual; // visual background mode +#ifndef TQT_NO_STYLE + TQStyle* style; +#endif + TQRect micro_focus_hint; // micro focus hint + TQSizePolicy size_policy; +}; + +#endif // USE_QT4 + +#define TQ_DEFINED_TQWIDGET +#include "tqwinexport.h" + +#endif // TQWIDGET_H -- cgit v1.2.1