m&qsqleditorfactory.h /* */ #ifndef QSQLEDITORFACTORY_H #define QSQLEDITORFACTORY_H #ifndef QT_H #include "qeditorfactory.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL_EDIT_WIDGETS class QSqlField; class QM_EXPORT_SQL QSqlEditorFactory : public QEditorFactory { public: QSqlEditorFactory ( QObject * parent = 0, const char * name = 0 ); ~QSqlEditorFactory(); virtual QWidget * createEditor( QWidget * parent, const QVariant & variant ); virtual QWidget * createEditor( QWidget * parent, const QSqlField * field ); static QSqlEditorFactory * defaultFactory(); static void installDefaultFactory( QSqlEditorFactory * factory ); private: #if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator= QSqlEditorFactory( const QSqlEditorFactory & ); QSqlEditorFactory &operator=( const QSqlEditorFactory & ); #endif }; #endif // QT_NO_SQL #endif // QSQLEDITORFACTORY_H $qsqldriverplugin.h)/* */ #ifndef QSQLDRIVERPLUGIN_H #define QSQLDRIVERPLUGIN_H #ifndef QT_H #include "qgplugin.h" #include "qstringlist.h" #endif // QT_H #ifndef QT_NO_SQL #ifndef QT_NO_COMPONENT class QSqlDriver; class QSqlDriverPluginPrivate; class Q_EXPORT QSqlDriverPlugin : public QGPlugin { Q_OBJECT public: QSqlDriverPlugin(); ~QSqlDriverPlugin(); virtual QStringList keys() const = 0; virtual QSqlDriver *create( const QString &key ) = 0; private: QSqlDriverPluginPrivate *d; }; #endif // QT_NO_COMPONENT #endif // QT_NO_SQL #endif // QSQLDRIVERPLUGIN_H qwmatrix.h/* */ #ifndef QWMATRIX_H #define QWMATRIX_H #ifndef QT_H #include "qwindowdefs.h" #include "qpointarray.h" #include "qrect.h" #include "qregion.h" #endif // QT_H #ifndef QT_NO_WMATRIX class Q_EXPORT QWMatrix // 2D transform matrix { public: QWMatrix(); QWMatrix( double m11, double m12, double m21, double m22, double dx, double dy ); void setMatrix( double m11, double m12, double m21, double m22, double dx, double dy ); double m11() const { return _m11; } double m12() const { return _m12; } double m21() const { return _m21; } double m22() const { return _m22; } double dx() const { return _dx; } double dy() const { return _dy; } void map( int x, int y, int *tx, int *ty ) const; void map( double x, double y, double *tx, double *ty ) const; QRect mapRect( const QRect & ) const; QPoint map( const QPoint &p ) const { return operator *( p ); } QRect map( const QRect &r ) const { return mapRect ( r ); } QPointArray map( const QPointArray &a ) const { return operator * ( a ); } QRegion map( const QRegion &r ) const { return operator *( r ); } QRegion mapToRegion( const QRect &r ) const { return operator *( r ); } QPointArray mapToPolygon( const QRect &r ) const; void reset(); bool isIdentity() const; QWMatrix &translate( double dx, double dy ); QWMatrix &scale( double sx, double sy ); QWMatrix &shear( double sh, double sv ); QWMatrix &rotate( double a ); bool isInvertible() const { return (_m11*_m22 - _m12*_m21) != 0; } double det() const { return _m11*_m22 - _m12*_m21; } QWMatrix invert( bool * = 0 ) const; bool operator==( const QWMatrix & ) const; bool operator!=( const QWMatrix & ) const; QWMatrix &operator*=( const QWMatrix & ); /* */ QPoint operator * (const QPoint & ) const; QRegion operator * (const QRect & ) const; QRegion operator * (const QRegion & ) const; QPointArray operator * ( const QPointArray &a ) const; enum TransformationMode { Points, Areas }; static void setTransformationMode( QWMatrix::TransformationMode m ); static TransformationMode transformationMode(); private: double _m11, _m12; double _m21, _m22; double _dx, _dy; }; Q_EXPORT QWMatrix operator*( const QWMatrix &, const QWMatrix & ); /* */ Q_EXPORT QDataStream &operator<<( QDataStream &, const QWMatrix & ); Q_EXPORT QDataStream &operator>>( QDataStream &, QWMatrix & ); #endif // QT_NO_WMATRIX #endif // QWMATRIX_H qt_mac9.h Y/* */ #ifndef QT_MAC9_H #define QT_MAC9_H #include "qglobal.h" #ifdef Q_WS_MAC9 //these don't belong here, but will be moved to an //appropriate place later //features #ifndef QT_NO_IMAGEIO_JPEG #define QT_NO_IMAGEIO_JPEG #endif #ifndef QT_NO_IMAGEIO_MNG #define QT_NO_IMAGEIO_MNG #endif #ifndef QT_NO_SQL #define QT_NO_SQL #endif #define QT_FATAL_ASSERT #define QT_NO_XINERAMA #define QT_NO_OPENGL #define QT_NO_STYLE_WINDOWSXP //mac thingy #ifndef QMAC_ONE_PIXEL_LOCK #define QMAC_ONE_PIXEL_LOCK #endif //carbon things #define ALLOW_OLD_CARBON #define _EVENT_HANDLERS 0 #define ALLOW_OLD_CREATE_FOO_CONTROL_PARAMETERS 0 #define CARBON_ON_MAC_O 1 #define ALLOW_OLD_BLOCKING_APIS 0 //hacks to work around wchar problems #define __WCHARTDEF__ //#define __NO_WIDE_CHAR 1 #undef wchar_t typedef unsigned short hide_wchar_t; #define wchar_t hide_wchar_t #include #include //pull in some posix stuff using std::calloc; using std::free; using std::realloc; //hacks to work around malloc(0) returning NULL static inline void *_mac9_malloc(size_t s) { return std::malloc(s ? s : 1); } #define malloc(x) _mac9_malloc(x) #endif //MAC9 #endif //MAC9_H qwidget.h/* */ #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 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 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; 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(); private: void setFontSys( QFont *f = 0 ); #if defined(Q_WS_X11) void createInputContext(); void destroyInputContext(); void focusInputContext(); void checkChildrenDnd(); #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 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 void *xic; // XIM Input Context #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 }; #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 qxtwidget.h/* */ #ifndef QXTWIDGET_H #define QXTWIDGET_H #include #include class QXtWidget : public QWidget { Q_OBJECT Widget xtw; Widget xtparent; bool need_reroot; void init(const char* name, WidgetClass widget_class, Widget parent, QWidget* qparent, ArgList args, Cardinal num_args, bool managed); friend void qwidget_realize( Widget widget, XtValueMask* mask, XSetWindowAttributes* attributes ); public: QXtWidget(const char* name, Widget parent, bool managed=FALSE); QXtWidget(const char* name, WidgetClass widget_class, QWidget *parent=0, ArgList args=0, Cardinal num_args=0, bool managed=FALSE); ~QXtWidget(); Widget xtWidget() const { return xtw; } bool isActiveWindow() const; void setActiveWindow(); protected: void moveEvent( QMoveEvent* ); void resizeEvent( QResizeEvent* ); bool x11Event( XEvent * ); }; #endif // QXTWIDGET_H qtoolbutton.h/* */ #ifndef QTOOLBUTTON_H #define QTOOLBUTTON_H #ifndef QT_H #include "qbutton.h" #include "qstring.h" #include "qpixmap.h" #include "qiconset.h" #endif // QT_H #ifndef QT_NO_TOOLBUTTON class QToolButtonPrivate; class QToolBar; class QPopupMenu; class Q_EXPORT QToolButton : public QButton { Q_OBJECT Q_ENUMS( TextPosition ) Q_PROPERTY( QIconSet iconSet READ iconSet WRITE setIconSet ) Q_PROPERTY( QIconSet onIconSet READ onIconSet WRITE setOnIconSet DESIGNABLE false STORED false ) Q_PROPERTY( QIconSet offIconSet READ offIconSet WRITE setOffIconSet DESIGNABLE false STORED false ) Q_PROPERTY( bool usesBigPixmap READ usesBigPixmap WRITE setUsesBigPixmap ) Q_PROPERTY( bool usesTextLabel READ usesTextLabel WRITE setUsesTextLabel ) Q_PROPERTY( QString textLabel READ textLabel WRITE setTextLabel ) Q_PROPERTY( int popupDelay READ popupDelay WRITE setPopupDelay ) Q_PROPERTY( bool autoRaise READ autoRaise WRITE setAutoRaise ) Q_PROPERTY( TextPosition textPosition READ textPosition WRITE setTextPosition ) Q_OVERRIDE( bool toggleButton WRITE setToggleButton ) Q_OVERRIDE( bool on WRITE setOn ) Q_OVERRIDE( QPixmap pixmap DESIGNABLE false STORED false ) Q_OVERRIDE( BackgroundMode backgroundMode DESIGNABLE true) public: enum TextPosition { BesideIcon, BelowIcon, Right = BesideIcon, // obsolete Under = BelowIcon // obsolete }; QToolButton( QWidget * parent, const char* name=0 ); #ifndef QT_NO_TOOLBAR QToolButton( const QIconSet& s, const QString &textLabel, const QString& grouptext, QObject * receiver, const char* slot, QToolBar * parent, const char* name=0 ); #endif QToolButton( ArrowType type, QWidget *parent, const char* name=0 ); ~QToolButton(); QSize sizeHint() const; QSize minimumSizeHint() const; #ifndef QT_NO_COMPAT void setOnIconSet( const QIconSet& ); void setOffIconSet( const QIconSet& ); void setIconSet( const QIconSet &, bool on ); QIconSet onIconSet() const; QIconSet offIconSet( ) const; QIconSet iconSet( bool on ) const; #endif virtual void setIconSet( const QIconSet & ); QIconSet iconSet() const; bool usesBigPixmap() const { return ubp; } bool usesTextLabel() const { return utl; } QString textLabel() const { return tl; } #ifndef QT_NO_POPUPMENU void setPopup( QPopupMenu* popup ); QPopupMenu* popup() const; void setPopupDelay( int delay ); int popupDelay() const; void openPopup(); #endif void setAutoRaise( bool enable ); bool autoRaise() const; TextPosition textPosition() const; void setText( const QString &txt ); public slots: virtual void setUsesBigPixmap( bool enable ); virtual void setUsesTextLabel( bool enable ); virtual void setTextLabel( const QString &, bool ); virtual void setToggleButton( bool enable ); virtual void setOn( bool enable ); void toggle(); void setTextLabel( const QString & ); void setTextPosition( TextPosition pos ); protected: void mousePressEvent( QMouseEvent * ); void drawButton( QPainter * ); void drawButtonLabel(QPainter *); void enterEvent( QEvent * ); void leaveEvent( QEvent * ); void moveEvent( QMoveEvent * ); // ### Make virtual in 4.0, maybe act like QPushButton with // regards to setFlat() instead? Andy bool uses3D() const; #if (QT_VERSION >= 0x040000) #error "Some functions need to be changed to virtual for Qt 4.0" #endif bool eventFilter( QObject *o, QEvent *e ); #ifndef QT_NO_PALETTE void paletteChange( const QPalette & ); #endif private slots: void popupTimerDone(); void popupPressed(); private: void init(); QPixmap bp; int bpID; QPixmap sp; int spID; QString tl; QToolButtonPrivate *d; QIconSet *s; uint utl : 1; uint ubp : 1; uint hasArrow : 1; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QToolButton( const QToolButton & ); QToolButton& operator=( const QToolButton & ); #endif }; #endif // QT_NO_TOOLBUTTON #endif // QTOOLBUTTON_H qstack.hA/* */ #ifndef QSTACK_H #define QSTACK_H #ifndef QT_NO_COMPAT #include "qptrstack.h" #endif #endif qtoolbar.h B/* */ #ifndef QTOOLBAR_H #define QTOOLBAR_H #ifndef QT_H #include "qdockwindow.h" #endif // QT_H #ifndef QT_NO_TOOLBAR class QMainWindow; class QButton; class QBoxLayout; class QToolBarPrivate; class Q_EXPORT QToolBar: public QDockWindow { Q_OBJECT Q_PROPERTY( QString label READ label WRITE setLabel ) public: QToolBar( const QString &label, QMainWindow *, ToolBarDock = DockTop, bool newLine = FALSE, const char* name=0 ); QToolBar( const QString &label, QMainWindow *, QWidget *, bool newLine = FALSE, const char* name=0, WFlags f = 0 ); QToolBar( QMainWindow* parent=0, const char* name=0 ); ~QToolBar(); void addSeparator(); void show(); void hide(); QMainWindow * mainWindow() const; virtual void setStretchableWidget( QWidget * ); bool event( QEvent * e ); virtual void setLabel( const QString & ); QString label() const; virtual void clear(); QSize minimumSize() const; QSize minimumSizeHint() const; void setOrientation( Orientation o ); void setMinimumSize( int minw, int minh ); protected: void resizeEvent( QResizeEvent *e ); void styleChange( QStyle & ); private slots: void createPopup(); private: void init(); void checkForExtension( const QSize &sz ); QToolBarPrivate * d; QMainWindow * mw; QWidget * sw; QString l; friend class QMainWindow; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QToolBar( const QToolBar & ); QToolBar& operator=( const QToolBar & ); #endif }; #endif // QT_NO_TOOLBAR #endif // QTOOLBAR_H qwidgetstack.h /* */ #ifndef QWIDGETSTACK_H #define QWIDGETSTACK_H #ifndef QT_H #include "qframe.h" #include "qintdict.h" #include "qptrdict.h" #endif // QT_H #ifndef QT_NO_WIDGETSTACK class QWidgetStackPrivate; class Q_EXPORT QWidgetStack: public QFrame { Q_OBJECT public: QWidgetStack( QWidget* parent=0, const char* name=0 ); QWidgetStack( QWidget* parent, const char* name, WFlags f); ~QWidgetStack(); int addWidget( QWidget *, int = -1 ); void removeWidget( QWidget * ); QSize sizeHint() const; QSize minimumSizeHint() const; void show(); QWidget * widget( int ) const; int id( QWidget * ) const; QWidget * visibleWidget() const; void setFrameRect( const QRect & ); signals: void aboutToShow( int ); void aboutToShow( QWidget * ); public slots: void raiseWidget( int ); void raiseWidget( QWidget * ); protected: void frameChanged(); void resizeEvent( QResizeEvent * ); virtual void setChildGeometries(); void childEvent( QChildEvent * ); private: void init(); QWidgetStackPrivate * d; QIntDict * dict; QPtrDict * focusWidgets; QWidget * topWidget; QWidget * invisible; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QWidgetStack( const QWidgetStack & ); QWidgetStack& operator=( const QWidgetStack & ); #endif }; #endif // QT_NO_WIDGETSTACK #endif // QWIDGETSTACK_H qwidgetfactory.h/* */ #ifndef QWIDGETFACTORY_H #define QWIDGETFACTORY_H #ifndef QT_H #include #include #include #include #include #include #include #endif // QT_H class QDomDocument; class QDomElement; class QLayout; class QListView; class QListViewItem; class QMenuBar; class QTable; class QWidget; class QWidgetFactoryPrivate; class UibStrTable; class QWidgetFactory { public: QWidgetFactory(); virtual ~QWidgetFactory(); static QWidget *create( const QString &uiFile, QObject *connector = 0, QWidget *parent = 0, const char *name = 0 ); static QWidget *create( QIODevice *dev, QObject *connector = 0, QWidget *parent = 0, const char *name = 0 ); static void addWidgetFactory( QWidgetFactory *factory ); static void loadImages( const QString &dir ); virtual QWidget *createWidget( const QString &className, QWidget *parent, const char *name ) const; static QStringList widgets(); static bool supportsWidget( const QString &widget ); private: enum LayoutType { HBox, VBox, Grid, NoLayout }; void loadImageCollection( const QDomElement &e ); void loadConnections( const QDomElement &e, QObject *connector ); void loadTabOrder( const QDomElement &e ); QWidget *createWidgetInternal( const QDomElement &e, QWidget *parent, QLayout* layout, const QString &classNameArg ); QLayout *createLayout( QWidget *widget, QLayout* layout, LayoutType type, bool isQLayoutWidget = FALSE ); LayoutType layoutType( QLayout *l ) const; void setProperty( QObject* widget, const QString &prop, QVariant value ); void setProperty( QObject* widget, const QString &prop, const QDomElement &e ); void createSpacer( const QDomElement &e, QLayout *layout ); QImage loadFromCollection( const QString &name ); QPixmap loadPixmap( const QString &name ); QPixmap loadPixmap( const QDomElement &e ); QColorGroup loadColorGroup( const QDomElement &e ); void createListViewColumn( QListView *lv, const QString& txt, const QPixmap& pix, bool clickable, bool resizable ); #ifndef QT_NO_TABLE void createTableColumnOrRow( QTable *table, const QString& txt, const QPixmap& pix, const QString& field, bool isRow ); #endif void createColumn( const QDomElement &e, QWidget *widget ); void loadItem( const QDomElement &e, QPixmap &pix, QString &txt, bool &hasPixmap ); void createItem( const QDomElement &e, QWidget *widget, QListViewItem *i = 0 ); void loadChildAction( QObject *parent, const QDomElement &e ); void loadActions( const QDomElement &e ); void loadToolBars( const QDomElement &e ); void loadMenuBar( const QDomElement &e ); void loadPopupMenu( QPopupMenu *p, const QDomElement &e ); void loadFunctions( const QDomElement &e ); QAction *findAction( const QString &name ); void loadExtraSource(); QString translate( const char *sourceText, const char *comment = "" ); QString translate( const QString& sourceText, const QString& comment = QString::null ); void unpackUInt16( QDataStream& in, Q_UINT16& n ); void unpackUInt32( QDataStream& in, Q_UINT32& n ); void unpackByteArray( QDataStream& in, QByteArray& array ); void unpackCString( const UibStrTable& strings, QDataStream& in, QCString& cstr ); void unpackString( const UibStrTable& strings, QDataStream& in, QString& str ); void unpackStringSplit( const UibStrTable& strings, QDataStream& in, QString& str ); void unpackVariant( const UibStrTable& strings, QDataStream& in, QVariant& value ); void inputSpacer( const UibStrTable& strings, QDataStream& in, QLayout *parent ); void inputColumnOrRow( const UibStrTable& strings, QDataStream& in, QObject *parent, bool isRow ); void inputItem( const UibStrTable& strings, QDataStream& in, QObject *parent, QListViewItem *parentItem = 0 ); void inputMenuItem( QObject **objects, const UibStrTable& strings, QDataStream& in, QMenuBar *menuBar ); QObject *inputObject( QObject **objects, int& numObjects, const UibStrTable& strings, QDataStream& in, QWidget *ancestorWidget, QObject *parent, QCString className = "" ); QWidget *createFromUiFile( QDomDocument doc, QObject *connector, QWidget *parent, const char *name ); QWidget *createFromUibFile( QDataStream& in, QObject *connector, QWidget *parent, const char *name ); private: struct Image { QImage img; QString name; bool operator==( const Image &i ) const { return ( i.name == name && i.img == img ); } }; struct Field { Field() {} Field( const QString &s1, const QPixmap &p, const QString &s2 ) : name( s1 ), pix( p ), field( s2 ) {} QString name; QPixmap pix; QString field; Q_DUMMY_COMPARISON_OPERATOR( Field ) }; struct SqlWidgetConnection { SqlWidgetConnection() {} SqlWidgetConnection( const QString &c, const QString &t ) : conn( c ), table( t ), dbControls( new QMap() ) {} QString conn; QString table; QMap *dbControls; Q_DUMMY_COMPARISON_OPERATOR( SqlWidgetConnection ) }; QValueList images; QWidget *toplevel; QWidgetFactoryPrivate *d; QMap *dbControls; QMap dbTables; QMap sqlWidgetConnections; QMap buddies; QMap > fieldMaps; QPtrList actionList; QMap languageSlots; QStringList noDatabaseWidgets; bool usePixmapCollection; int defMargin; int defSpacing; QString code; QString uiFileVersion; }; #endif qwindowsstyle.h/* */ #ifndef QWINDOWSSTYLE_H #define QWINDOWSSTYLE_H #ifndef QT_H #include "qcommonstyle.h" #endif // QT_H #if !defined(QT_NO_STYLE_WINDOWS) || defined(QT_PLUGIN) #if defined(QT_PLUGIN) #define Q_EXPORT_STYLE_WINDOWS #else #define Q_EXPORT_STYLE_WINDOWS Q_EXPORT #endif class Q_EXPORT_STYLE_WINDOWS QWindowsStyle : public QCommonStyle { Q_OBJECT public: QWindowsStyle(); ~QWindowsStyle(); void polish(QApplication*); void unPolish(QApplication*); void polish(QWidget*); void unPolish(QWidget*); void polish( QPalette & ); virtual void polishPopupMenu( QPopupMenu* ); // new stuff void drawPrimitive( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const; void drawControl( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const; void drawComplexControl( ComplexControl control, QPainter* p, const QWidget* widget, const QRect& r, const QColorGroup& cg, SFlags flags = Style_Default, #ifdef Q_QDOC SCFlags sub = SC_All, #else SCFlags sub = (uint)SC_All, #endif SCFlags subActive = SC_None, const QStyleOption& = QStyleOption::Default ) const; int pixelMetric( PixelMetric metric, const QWidget *widget = 0 ) const; QSize sizeFromContents( ContentsType contents, const QWidget *widget, const QSize &contentsSize, const QStyleOption& = QStyleOption::Default ) const; int styleHint(StyleHint sh, const QWidget *, const QStyleOption & = QStyleOption::Default, QStyleHintReturn* = 0) const; QPixmap stylePixmap( StylePixmap stylepixmap, const QWidget *widget = 0, const QStyleOption& = QStyleOption::Default ) const; QRect subRect( SubRect r, const QWidget *widget ) const; private: class Private; Private *d; // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QWindowsStyle( const QWindowsStyle & ); QWindowsStyle& operator=( const QWindowsStyle & ); #endif }; #endif // QT_NO_STYLE_WINDOWS #endif // QWINDOWSSTYLE_H qwizard.h/* */ #ifndef QWIZARDDIALOG_H #define QWIZARDDIALOG_H #ifndef QT_H #include "qdialog.h" #endif // QT_H #ifndef QT_NO_WIZARD class QHBoxLayout; class QWizardPrivate; class Q_EXPORT QWizard : public QDialog { Q_OBJECT Q_PROPERTY( QFont titleFont READ titleFont WRITE setTitleFont ) public: QWizard( QWidget* parent=0, const char* name=0, bool modal=FALSE, WFlags f=0 ); ~QWizard(); void show(); void setFont( const QFont & font ); virtual void addPage( QWidget *, const QString & ); virtual void insertPage( QWidget*, const QString&, int ); virtual void removePage( QWidget * ); QString title( QWidget * ) const; void setTitle( QWidget *, const QString & ); QFont titleFont() const; void setTitleFont( const QFont & ); virtual void showPage( QWidget * ); QWidget * currentPage() const; QWidget* page( int ) const; int pageCount() const; int indexOf( QWidget* ) const; virtual bool appropriate( QWidget * ) const; virtual void setAppropriate( QWidget *, bool ); QPushButton * backButton() const; QPushButton * nextButton() const; QPushButton * finishButton() const; QPushButton * cancelButton() const; QPushButton * helpButton() const; bool eventFilter( QObject *, QEvent * ); public slots: virtual void setBackEnabled( QWidget *, bool ); virtual void setNextEnabled( QWidget *, bool ); virtual void setFinishEnabled( QWidget *, bool ); virtual void setHelpEnabled( QWidget *, bool ); // obsolete virtual void setFinish( QWidget *, bool ) {} protected slots: virtual void back(); virtual void next(); virtual void help(); signals: void helpClicked(); void selected( const QString& ); protected: virtual void layOutButtonRow( QHBoxLayout * ); virtual void layOutTitleRow( QHBoxLayout *, const QString & ); private: void setBackEnabled( bool ); void setNextEnabled( bool ); void setHelpEnabled( bool ); void setNextPage( QWidget * ); void updateButtons(); void layOut(); QWizardPrivate *d; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QWizard( const QWizard & ); QWizard& operator=( const QWizard & ); #endif }; #endif // QT_NO_WIZARD #endif // QWIZARD_H 0qwshydrodecoration_qws.h/* */ #ifndef QWSHYDRODECORATION_QWS_H #define QWSHYDRODECORATION_QWS_H #ifndef QT_H #include "qwsdefaultdecoration_qws.h" #endif // QT_H #ifndef QT_NO_QWS_HYDRO_WM_STYLE class QWSHydroDecoration : public QWSDefaultDecoration { public: QWSHydroDecoration(); virtual ~QWSHydroDecoration(); virtual QRegion region(const QWidget *, const QRect &rect, Region); virtual void paint(QPainter *, const QWidget *); virtual void paintButton(QPainter *, const QWidget *, Region, int state); protected: // virtual int getTitleWidth(const QWidget *); virtual int getTitleHeight(const QWidget *); virtual const char **menuPixmap(); virtual const char **closePixmap(); virtual const char **minimizePixmap(); virtual const char **maximizePixmap(); virtual const char **normalizePixmap(); }; #endif // QT_NO_QWS_HYDRO_WM_STYLE #endif // QWSHYDRODECORATION_QWS_H qxt.h Q/* */ #ifndef QXT_H #define QXT_H #include #include #include #ifdef Bool #undef Bool #endif // Bool class QXtApplication : public QApplication { Q_OBJECT void init(); public: QXtApplication(int& argc, char** argv, const char* appclass=0, XrmOptionDescRec *options=0, int num_options=0, const char** resources=0); QXtApplication(Display *, HANDLE = 0, HANDLE = 0); QXtApplication(Display *, int, char **, HANDLE = 0, HANDLE = 0); ~QXtApplication(); }; class QXtWidget : public QWidget { Q_OBJECT Widget xtw; Widget xtparent; bool need_reroot; void init(const char* name, WidgetClass widget_class, Widget parent, QWidget* qparent, ArgList args, Cardinal num_args, bool managed); friend void qwidget_realize( Widget widget, XtValueMask* mask, XSetWindowAttributes* attributes ); public: QXtWidget(const char* name, Widget parent, bool managed=FALSE); QXtWidget(const char* name, WidgetClass widget_class, QWidget *parent=0, ArgList args=0, Cardinal num_args=0, bool managed=FALSE); ~QXtWidget(); Widget xtWidget() const { return xtw; } bool isActiveWindow() const; void setActiveWindow(); protected: void moveEvent( QMoveEvent* ); void resizeEvent( QResizeEvent* ); bool x11Event( XEvent * ); }; #endif qtabwidget.hB/* */ #ifndef QTABWIDGET_H #define QTABWIDGET_H #ifndef QT_H #include "qwidget.h" #include "qiconset.h" #endif // QT_H #ifndef QT_NO_TABWIDGET class QTabBar; class QTabWidgetData; class QTab; class QWidgetStack; class Q_EXPORT QTabWidget : public QWidget { Q_OBJECT Q_ENUMS( TabPosition ) Q_ENUMS( TabShape ) Q_PROPERTY( TabPosition tabPosition READ tabPosition WRITE setTabPosition ) Q_PROPERTY( TabShape tabShape READ tabShape WRITE setTabShape ) Q_PROPERTY( int margin READ margin WRITE setMargin ) Q_PROPERTY( int currentPage READ currentPageIndex WRITE setCurrentPage ) Q_PROPERTY( int count READ count ) Q_OVERRIDE( bool autoMask DESIGNABLE true SCRIPTABLE true ) public: QTabWidget( QWidget *parent = 0, const char *name = 0, WFlags f = 0 ); ~QTabWidget(); virtual void addTab( QWidget *, const QString & ); // ### make these inline in 4.0 virtual void addTab( QWidget *child, const QIconSet& iconset, const QString &label ); virtual void addTab( QWidget *, QTab* ); virtual void insertTab( QWidget *, const QString &, int index = -1 ); virtual void insertTab( QWidget *child, const QIconSet& iconset, const QString &label, int index = -1 ); virtual void insertTab( QWidget *, QTab*, int index = -1 ); void changeTab( QWidget *, const QString &); void changeTab( QWidget *child, const QIconSet& iconset, const QString &label ); bool isTabEnabled( QWidget * ) const; void setTabEnabled( QWidget *, bool ); void setCornerWidget( QWidget * w, Qt::Corner corner = Qt::TopRight ); QWidget * cornerWidget( Qt::Corner corner = Qt::TopRight ) const; QString tabLabel( QWidget * ) const; void setTabLabel( QWidget *p, const QString &l ); QIconSet tabIconSet( QWidget * w ) const; void setTabIconSet( QWidget * w, const QIconSet & iconset ); void removeTabToolTip( QWidget * w ); void setTabToolTip( QWidget * w, const QString & tip ); QString tabToolTip( QWidget * w ) const; QWidget * currentPage() const; QWidget *page( int ) const; QString label( int ) const; int currentPageIndex() const; int indexOf( QWidget * ) const; QSize sizeHint() const; QSize minimumSizeHint() const; enum TabPosition { Top, Bottom }; TabPosition tabPosition() const; void setTabPosition( TabPosition ); enum TabShape { Rounded, Triangular }; TabShape tabShape() const; void setTabShape( TabShape s ); int margin() const; void setMargin( int ); int count() const; public slots: void setCurrentPage( int ); virtual void showPage( QWidget * ); virtual void removePage( QWidget * ); protected: void showEvent( QShowEvent * ); void resizeEvent( QResizeEvent * ); void setTabBar( QTabBar * ); QTabBar* tabBar() const; void styleChange( QStyle& ); void updateMask(); bool eventFilter( QObject *, QEvent * ); signals: void currentChanged( QWidget * ); #ifndef Q_QDOC void selected( const QString& ); #endif private slots: void showTab( int ); private: QTabWidgetData *d; void setUpLayout( bool = FALSE ); friend class QTabDialog; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTabWidget( const QTabWidget & ); QTabWidget& operator=( const QTabWidget & ); #endif }; #endif // QT_NO_TABWIDGET #endif // QTABWIDGET_H qwindowdefs.h/* */ #ifndef QWINDOWDEFS_H #define QWINDOWDEFS_H #ifndef QT_H #include "qobjectdefs.h" #include "qstring.h" #include "qnamespace.h" #endif // QT_H // Class forward definitions class QPaintDevice; class QPaintDeviceMetrics; class QWidget; class QWidgetMapper; class QDialog; class QColor; class QColorGroup; class QPalette; class QCursor; class QPoint; class QSize; class QRect; class QPointArray; class QPainter; class QRegion; class QFont; class QFontMetrics; class QFontInfo; class QPen; class QBrush; class QWMatrix; class QPixmap; class QBitmap; class QMovie; class QImage; class QImageIO; class QPicture; class QPrinter; class QAccel; class QTimer; class QTime; class QClipboard; // Widget list (defined in qwidgetlist.h) class QWidgetList; class QWidgetListIt; // Window system dependent definitions #if defined(Q_WS_MAC) #if QT_MACOSX_VERSION < 0x1020 typedef struct OpaqueEventLoopTimerRef* EventLoopTimerRef; typedef struct OpaqueMenuHandle *MenuRef; #else typedef struct __EventLoopTimer* EventLoopTimerRef; typedef struct OpaqueMenuRef* MenuRef; #endif #ifndef Q_WS_MACX typedef struct CGContext *CGContextRef; #endif typedef struct OpaqueWindowGroupRef *WindowGroupRef; typedef struct OpaqueGrafPtr *CGrafPtr; typedef struct OpaquePMPrintSession *PMPrintSession; typedef struct OpaquePMPrintSettings *PMPrintSettings; typedef struct OpaquePMPageFormat *PMPageFormat; typedef struct Point Point; typedef struct OpaqueEventHandlerRef* EventHandlerRef; typedef struct OpaqueEventHandlerCallRef* EventHandlerCallRef; typedef struct OpaqueEventRef* EventRef; typedef long int OSStatus; typedef struct OpaqueScrapRef *ScrapRef; typedef struct OpaqueRgnHandle *RgnHandle; typedef struct OpaqueWindowPtr *WindowPtr; typedef WindowPtr WindowRef; typedef struct OpaqueGrafPtr *GWorldPtr; typedef GWorldPtr GrafPtr; typedef struct GDevice **GDHandle; typedef struct ColorTable ColorTable; typedef struct BitMap BitMap; typedef struct EventRecord EventRecord; typedef void * MSG; typedef int WId; typedef struct AEDesc AppleEvent; #endif // Q_WS_MAC #if defined(Q_WS_WIN) #include "qwindowdefs_win.h" #endif // Q_WS_WIN #if defined(Q_OS_TEMP) #include "qwinfunctions_wce.h" #endif // Q_OS_TEMP #if defined(Q_WS_X11) typedef struct _XDisplay Display; typedef union _XEvent XEvent; typedef struct _XGC *GC; typedef struct _XRegion *Region; typedef unsigned long WId; Q_EXPORT Display *qt_xdisplay(); Q_EXPORT int qt_xscreen(); Q_EXPORT WId qt_xrootwin(); // ### REMOVE 4.0 Q_EXPORT WId qt_xrootwin( int scrn ); // ### 4.0 add default arg of -1 Q_EXPORT GC qt_xget_readonly_gc( int scrn, bool monochrome ); Q_EXPORT GC qt_xget_temp_gc( int scrn, bool monochrome ); Q_EXPORT const char *qAppClass(); // get application class #endif // Q_WS_X11 #if defined(Q_WS_QWS) typedef unsigned long WId; struct QWSEvent; class QGfx; #endif // Q_WS_QWS class QApplication; #if defined(NEEDS_QMAIN) #define main qMain #endif // Global platform-independent types and functions typedef Q_INT32 QCOORD; // coordinate type const QCOORD QCOORD_MAX = 2147483647; const QCOORD QCOORD_MIN = -QCOORD_MAX - 1; typedef unsigned int QRgb; // RGB triplet Q_EXPORT const char *qAppName(); // get application name // Misc functions typedef void (*QtCleanUpFunction)(); Q_EXPORT void qAddPostRoutine( QtCleanUpFunction ); Q_EXPORT void qRemovePostRoutine( QtCleanUpFunction ); #if !defined(QT_CLEAN_NAMESPACE) // source compatibility with Qt 2.x typedef QtCleanUpFunction Q_CleanUpFunction; #endif #endif // QWINDOWDEFS_H qtsciicodec.h/* */ // Most of the code here was originally written by Hans Petter Bieker, // and is included in Qt with the author's permission, and the grateful // thanks of the Trolltech team. /* */ #ifndef QTSCIICODEC_H #define QTSCIICODEC_H #ifndef QT_H #include "qtextcodec.h" #endif // QT_H #ifndef QT_NO_CODECS class Q_EXPORT QTsciiCodec : public QTextCodec { public: virtual int mibEnum() const; const char* name() const; #if !defined(Q_NO_USING_KEYWORD) using QTextCodec::fromUnicode; #endif QCString fromUnicode(const QString& uc, int& lenInOut) const; QString toUnicode(const char* chars, int len) const; int heuristicContentMatch(const char* chars, int len) const; int heuristicNameMatch(const char* hint) const; }; #endif #endif qthreadstorage.h 2/* */ #ifndef QTHREADSTORAGE_H #define QTHREADSTORAGE_H #ifdef QT_THREAD_SUPPORT #ifndef QT_H #include "qglobal.h" #endif // QT_H class Q_EXPORT QThreadStorageData { public: QThreadStorageData( void (*func)(void *) ); ~QThreadStorageData(); void** get() const; void** set( void* p ); static void finish( void** ); int id; }; template class QThreadStorage { private: QThreadStorageData d; #if defined(Q_DISABLE_COPY) // disable copy constructor and operator= QThreadStorage( const QThreadStorage & ); QThreadStorage &operator=( const QThreadStorage & ); #endif // Q_DISABLE_COPY static void deleteData( void *x ) { delete (T)x; } public: inline QThreadStorage() : d( deleteData ) { } inline ~QThreadStorage() { } inline bool hasLocalData() const { return d.get() != 0; } inline T& localData() { void **v = d.get(); if ( !v ) v = d.set( 0 ); return *(T*)v; } inline T localData() const { void **v = d.get(); return ( v ? *(T*)v : 0 ); } inline void setLocalData( T t ) { (void) d.set( t ); } }; #endif // QT_THREAD_SUPPORT #endif // QTHREADSTORAGE_H qt_windows.h /* */ #ifndef QT_WINDOWS_H #define QT_WINDOWS_H #if defined(Q_CC_BOR) // Borland's windows.h does not set these correctly, resulting in // unusable WinSDK standard dialogs #ifndef WINVER #define WINVER 0x400 #endif #ifndef _WIN32_WINNT #define _WIN32_WINNT 0x400 #endif #endif #include "qwindowdefs.h" #include #if defined(Q_CC_BOR) // windef.h (included by windows.h) defines FALSE and TRUE to 0 resp. 1 -- with // these defines, Borland Builder 6 has problems distinguishing the different // overloads of the QBitmap constructors. #undef TRUE #undef FALSE #endif // already defined when compiled with WINVER >= 0x0500 // and we only use them in WV_2000 and WV_98 #ifndef SPI_SETMENUANIMATION #define SPI_SETMENUANIMATION 0x1003 #endif #ifndef SPI_SETMENUFADE #define SPI_SETMENUFADE 0x1013 #endif #ifndef SPI_SETCOMBOBOXANIMATION #define SPI_SETCOMBOBOXANIMATION 0x1005 #endif #ifndef SPI_SETTOOLTIPANIMATION #define SPI_SETTOOLTIPANIMATION 0x1017 #endif #ifndef SPI_SETTOOLTIPFADE #define SPI_SETTOOLTIPFADE 0x1019 #endif #ifndef SPI_SETUIEFFECTS #define SPI_SETUIEFFECTS 0x103F #endif #ifndef SPI_GETMENUANIMATION #define SPI_GETMENUANIMATION 0x1002 #endif #ifndef SPI_GETMENUFADE #define SPI_GETMENUFADE 0x1012 #endif #ifndef SPI_GETCOMBOBOXANIMATION #define SPI_GETCOMBOBOXANIMATION 0x1004 #endif #ifndef SPI_GETTOOLTIPANIMATION #define SPI_GETTOOLTIPANIMATION 0x1016 #endif #ifndef SPI_GETTOOLTIPFADE #define SPI_GETTOOLTIPFADE 0x1018 #endif #ifndef SPI_GETUIEFFECTS #define SPI_GETUIEFFECTS 0x103E #endif #ifndef SPI_GETKEYBOARDCUES #define SPI_GETKEYBOARDCUES 0x100A #endif #ifndef IDC_HAND #define IDC_HAND MAKEINTRESOURCE(32649) #endif #ifndef WM_MOUSEWHEEL #define WM_MOUSEWHEEL 0x020A #endif #endif // QT_WINDOWS_H qsqlrecord.h/* */ #ifndef QSQLRECORD_H #define QSQLRECORD_H #ifndef QT_H #include "qstring.h" #include "qstringlist.h" #include "qvariant.h" #include "qsqlfield.h" #endif // QT_H #ifndef QT_NO_SQL class QSqlRecordPrivate; class QSqlRecordShared : public QShared { public: QSqlRecordShared( QSqlRecordPrivate* sqlRecordPrivate ) : d( sqlRecordPrivate ) {} virtual ~QSqlRecordShared(); QSqlRecordPrivate* d; }; class Q_EXPORT QSqlRecord { public: QSqlRecord(); QSqlRecord( const QSqlRecord& other ); QSqlRecord& operator=( const QSqlRecord& other ); virtual ~QSqlRecord(); virtual QVariant value( int i ) const; virtual QVariant value( const QString& name ) const; virtual void setValue( int i, const QVariant& val ); virtual void setValue( const QString& name, const QVariant& val ); bool isGenerated( int i ) const; bool isGenerated( const QString& name ) const; virtual void setGenerated( const QString& name, bool generated ); virtual void setGenerated( int i, bool generated ); virtual void setNull( int i ); virtual void setNull( const QString& name ); bool isNull( int i ); // remove in 4.0 bool isNull( const QString& name ); // remove in 4.0 bool isNull( int i ) const; bool isNull( const QString& name ) const; int position( const QString& name ) const; QString fieldName( int i ) const; QSqlField* field( int i ); QSqlField* field( const QString& name ); const QSqlField* field( int i ) const; const QSqlField* field( const QString& name ) const; virtual void append( const QSqlField& field ); virtual void insert( int pos, const QSqlField& field ); virtual void remove( int pos ); bool isEmpty() const; bool contains( const QString& name ) const; virtual void clear(); virtual void clearValues( bool nullify = FALSE ); uint count() const; virtual QString toString( const QString& prefix = QString::null, const QString& sep = "," ) const; virtual QStringList toStringList( const QString& prefix = QString::null ) const; private: QString createField( int i, const QString& prefix ) const; void deref(); bool checkDetach(); QSqlRecordShared* sh; }; /* */ /* */ /* */ #if defined(Q_TEMPLATEDLL) // MOC_SKIP_BEGIN Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; // MOC_SKIP_END #endif typedef QValueList QSqlFieldInfoList; class Q_EXPORT QSqlRecordInfo: public QSqlFieldInfoList { public: QSqlRecordInfo(): QSqlFieldInfoList() {} QSqlRecordInfo( const QSqlFieldInfoList& other ): QSqlFieldInfoList( other ) {} QSqlRecordInfo( const QSqlRecord& other ); size_type contains( const QString& fieldName ) const; QSqlFieldInfo find( const QString& fieldName ) const; QSqlRecord toRecord() const; }; #endif // QT_NO_SQL #endif qt.h$T/* */ #ifndef QT_H #define QT_H #include "qglobal.h" #include "qfeatures.h" #include "qshared.h" #include "qptrcollection.h" #include "qglist.h" #include "qobjectdefs.h" #include "qnamespace.h" #include "qgarray.h" #include "qmemarray.h" #include "qcstring.h" #include "qstring.h" #include "qptrlist.h" #include "qiodevice.h" #include "qkeysequence.h" #include "qwindowdefs.h" #include "qgdict.h" #include "qfont.h" #include "qdatastream.h" #include "qpair.h" #include "qpoint.h" #include #include "qtextstream.h" #include "qfontinfo.h" #include "qsizepolicy.h" #include "qtl.h" #include "qsize.h" #include "qrect.h" #include "qbitarray.h" #include "qregion.h" #include "qsql.h" #include "qstrlist.h" #include "qvaluelist.h" #include "qmap.h" #include "qdatetime.h" #include "qmime.h" #include "qasciidict.h" #include "qpaintdevice.h" #include "qfontmetrics.h" #include "qdict.h" #include "qevent.h" #include "qhostaddress.h" #include "qstringlist.h" #include "qcolor.h" #include #include "qobject.h" #include #include "qbrush.h" #include "qpalette.h" #include "qwidget.h" #include "qjpunicode.h" #include "qtextcodec.h" #include "qstyle.h" #include "qframe.h" #include "qfile.h" #include "qfileinfo.h" #include "qurlinfo.h" #include "qwidgetlist.h" #include #include "qgroupbox.h" #include "qdialog.h" #include #include "qdockwindow.h" #include "qcommonstyle.h" #include "qnetworkprotocol.h" #include #include #include "qgcache.h" #include "qpixmap.h" #include #include #include #include #include "qgplugin.h" #include #include "qrangecontrol.h" #include "qbuttongroup.h" #include #include "qgvector.h" #include "qhbox.h" #include #include "qiconset.h" #include #include "qsocketnotifier.h" #include #include #include #include "qbuffer.h" #include "qimage.h" #include #include "qlineedit.h" #include #include "qintdict.h" #include "qmotifstyle.h" #include "qpicture.h" #include #include #include #include #include "qlabel.h" #include "qlayout.h" #include #include #include #include "qscrollbar.h" #include "qscrollview.h" #include "qdir.h" #include "qwindowsstyle.h" #include "qconnection.h" #include "qbitmap.h" #include "qvariant.h" #include "qsignal.h" #include #include "qmetaobject.h" #include "qheader.h" #include #include #include #include "qptrvector.h" #include "qmutex.h" #include "qbutton.h" #include #include #include "qguardedptr.h" #include #include "qsqlfield.h" #include #include #include #include #include "qpointarray.h" #include "qmenudata.h" #include #include "qpen.h" #include "qdragobject.h" #include #include #include #include #include #include #include #include "qpopupmenu.h" #include #include #include #include "qprogressbar.h" #include "qsemimodal.h" #include #include "qptrdict.h" #include #include #include #include "qstylesheet.h" #include #include #include #include #include "qregexp.h" #include #include #include #include #include "qsemaphore.h" #include #include "qsocketdevice.h" #include #include #include #include #include "qtimer.h" #include #include #include #include "qwmatrix.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "qsqlerror.h" #include "qeditorfactory.h" #include "qsqlquery.h" #include "qsqlrecord.h" #include #include "qsqlindex.h" #include "qsqlcursor.h" #include #include #include "qtable.h" #include #include #include #include #include #include #include #include #include "qtranslator.h" #include #include #include #include #include "qtextedit.h" #include #include #include #include "qsqleditorfactory.h" #include #include #include #include #include #include #include "qtoolbar.h" #include #include "qwaitcondition.h" #include #include #include #include #include #include #include "qdesktopwidget.h" #include #include "qurl.h" #include "qurloperator.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined( QT_MOC_CPP ) || defined( QT_H_CPP ) || defined( Q_OS_MACX ) #include #include #include "private/qgfxdriverinterface_p.h" #include "private/qcom_p.h" #include "private/qimageformatinterface_p.h" #include "private/qisciicodec_p.h" #include "private/qkbddriverinterface_p.h" #include "private/qlayoutengine_p.h" #include "private/qcomlibrary_p.h" #include "private/qmousedriverinterface_p.h" #include "private/qeffects_p.h" #include "private/qgpluginmanager_p.h" #include "private/qinternal_p.h" #include "private/qsqldriverinterface_p.h" #include "private/qsqlmanager_p.h" #include "private/qlock_p.h" #include "private/qcomponentfactory_p.h" #include "private/qstyleinterface_p.h" #include "private/qrichtext_p.h" #include "private/qsvgdevice_p.h" #include "private/qfontcodecs_p.h" #include "private/qtextcodecinterface_p.h" #include "private/qpsprinter_p.h" #include "private/qtitlebar_p.h" #include "private/qucom_p.h" #include "private/qucomextra_p.h" #include "private/qpluginmanager_p.h" #include "private/qdir_p.h" #include "private/qsettings_p.h" #include "private/qsqlextension_p.h" #include "private/qdialogbuttons_p.h" #include "private/qwidgetinterface_p.h" #include "private/qwidgetresizehandler_p.h" #include "private/qlibrary_p.h" #endif // Private headers #ifdef Q_WS_MAC #include #include #endif // Q_WS_MAC #ifdef Q_WS_WIN #include #endif #ifdef Q_WS_QWS #include #include "qfontmanager_qws.h" #include #include #include #include #include #include #include #include #include #include #include "qmemorymanager_qws.h" #include #include #ifndef Q_OS_MAC # include #endif #include "qgfx_qws.h" #include #include "qwsdisplay_qws.h" #include "qwssocket_qws.h" #include "qwsdecoration_qws.h" #include "qwsutils_qws.h" #include #include "qwsmanager_qws.h" #include "qwsdefaultdecoration_qws.h" #include #include "qwscommand_qws.h" #include #include #include #include #include "qwsproperty_qws.h" #include #include "qwsevent_qws.h" #include #include #endif // Q_WS_QWS #ifdef Q_WS_WCE #include #endif // Q_WS_WCE #endif // QT_H qwaitcondition.h/* */ #ifndef QWAITCONDITION_H #define QWAITCONDITION_H #ifndef QT_H #include "qglobal.h" #endif // QT_H #if defined(QT_THREAD_SUPPORT) #include class QWaitConditionPrivate; class QMutex; class Q_EXPORT QWaitCondition { public: QWaitCondition(); virtual ~QWaitCondition(); // default argument causes thread to block indefinately bool wait( unsigned long time = ULONG_MAX ); bool wait( QMutex *mutex, unsigned long time = ULONG_MAX ); void wakeOne(); void wakeAll(); private: QWaitConditionPrivate * d; #if defined(Q_DISABLE_COPY) QWaitCondition( const QWaitCondition & ); QWaitCondition &operator=( const QWaitCondition & ); #endif }; #endif #endif qtstream.h+/* */ #ifndef QTSTREAM_H #define QTSTREAM_H #include "qtextstream.h" #endif qwsevent_qws.hB/* */ #ifndef QWSEVENT_QWS_H #define QWSEVENT_QWS_H #ifndef QT_H #include "qwsutils_qws.h" #include "qwscommand_qws.h" //QWSProtocolItem lives there, for now #endif // QT_H struct QWSMouseEvent; struct QWSEvent : QWSProtocolItem { QWSEvent( int t, int len, char *ptr ) : QWSProtocolItem(t,len,ptr) {} enum Type { NoEvent, Connected, Mouse, Focus, Key, RegionModified, Creation, PropertyNotify, PropertyReply, SelectionClear, SelectionRequest, SelectionNotify, MaxWindowRect, QCopMessage, WindowOperation, IMEvent, NEvent }; QWSMouseEvent *asMouse() { return type == Mouse ? (QWSMouseEvent*)this : 0; } int window() { return *((int*)simpleDataPtr); } static QWSEvent *factory( int type ); }; //All events must start with windowID struct QWSConnectedEvent : QWSEvent { QWSConnectedEvent() : QWSEvent( QWSEvent::Connected, sizeof( simpleData ), (char*)&simpleData ) {} void setData( char *d, int len, bool allocateMem = TRUE ) { QWSEvent::setData( d, len, allocateMem ); display = (char*)rawDataPtr; } struct SimpleData { int window; int len; int clientId; } simpleData; char *display; }; struct QWSMaxWindowRectEvent : QWSEvent { QWSMaxWindowRectEvent() : QWSEvent( MaxWindowRect, sizeof( simpleData ), (char*)&simpleData ) { } struct SimpleData { int window; QRect rect; } simpleData; }; struct QWSMouseEvent : QWSEvent { QWSMouseEvent() : QWSEvent( QWSEvent::Mouse, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int window; int x_root, y_root, state; int time; // milliseconds } simpleData; }; struct QWSFocusEvent : QWSEvent { QWSFocusEvent() : QWSEvent( QWSEvent::Focus, sizeof( simpleData ), (char*)&simpleData ) { memset((char*)&simpleData,0,sizeof(simpleData)); } struct SimpleData { int window; uint get_focus:1; } simpleData; }; struct QWSKeyEvent: QWSEvent { QWSKeyEvent() : QWSEvent( QWSEvent::Key, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int window; ushort unicode; ushort keycode; int modifiers; uint is_press:1; uint is_auto_repeat:1; } simpleData; }; struct QWSCreationEvent : QWSEvent { QWSCreationEvent() : QWSEvent( QWSEvent::Creation, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int objectid; } simpleData; }; #ifndef QT_NO_QWS_PROPERTIES struct QWSPropertyNotifyEvent : QWSEvent { QWSPropertyNotifyEvent() : QWSEvent( QWSEvent::PropertyNotify, sizeof( simpleData ), (char*)&simpleData ) {} enum State { PropertyNewValue, PropertyDeleted }; struct SimpleData { int window; int property; int state; } simpleData; }; #endif struct QWSSelectionClearEvent : QWSEvent { QWSSelectionClearEvent() : QWSEvent( QWSEvent::SelectionClear, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int window; } simpleData; }; struct QWSSelectionRequestEvent : QWSEvent { QWSSelectionRequestEvent() : QWSEvent( QWSEvent::SelectionRequest, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int window; int requestor; // window which wants the selection int property; // property on requestor into which the selection should be stored, normally QWSProperty::PropSelection int mimeTypes; // Value is stored in the property mimeType on the requestor window. This value may contain // multiple mimeTypes separated by ;; where the order reflects the priority } simpleData; }; struct QWSSelectionNotifyEvent : QWSEvent { QWSSelectionNotifyEvent() : QWSEvent( QWSEvent::SelectionNotify, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int window; int requestor; // the window which wanted the selection and to which this event is sent int property; // property of requestor in which the data of the selection is stored int mimeType; // a property on the requestor in which the mime type in which the selection is, is stored } simpleData; }; //complex events: struct QWSRegionModifiedEvent : QWSEvent { QWSRegionModifiedEvent() : QWSEvent( QWSEvent::RegionModified, sizeof( simpleData ), (char*)&simpleData ) { memset((char*)&simpleData,0,sizeof(simpleData)); } void setData( char *d, int len, bool allocateMem = TRUE ) { QWSEvent::setData( d, len, allocateMem ); rectangles = (QRect*)rawDataPtr; } struct SimpleData { int window; int nrectangles; uint is_ack:1; } simpleData; QRect *rectangles; }; #ifndef QT_NO_QWS_PROPERTIES struct QWSPropertyReplyEvent : QWSEvent { QWSPropertyReplyEvent() : QWSEvent( QWSEvent::PropertyReply, sizeof( simpleData ), (char*)&simpleData ) {} void setData( char *d, int len, bool allocateMem = TRUE ) { QWSEvent::setData( d, len, allocateMem ); data = (char*)rawDataPtr; } struct SimpleData { int window; int property; int len; } simpleData; char *data; }; #endif //QT_NO_QWS_PROPERTIES #ifndef QT_NO_COP struct QWSQCopMessageEvent : QWSEvent { QWSQCopMessageEvent() : QWSEvent( QWSEvent::QCopMessage, sizeof( simpleData ), (char*)&simpleData ) { memset((char*)&simpleData,0,sizeof(simpleData)); } void setData( char *d, int len, bool allocateMem = TRUE ) { QWSEvent::setData( d, len, allocateMem ); char* p = (char*) rawDataPtr; channel = QCString( p, simpleData.lchannel + 1 ); p += simpleData.lchannel; message = QCString( p, simpleData.lmessage + 1 ); p += simpleData.lmessage; data.duplicate( p, simpleData.ldata ); } struct SimpleData { bool is_response; int lchannel; int lmessage; int ldata; } simpleData; QCString channel; QCString message; QByteArray data; }; #endif struct QWSWindowOperationEvent : QWSEvent { QWSWindowOperationEvent() : QWSEvent( WindowOperation, sizeof( simpleData ), (char*)&simpleData ) { } enum Operation { Show, Hide, ShowMaximized, ShowNormal, ShowMinimized, Close }; struct SimpleData { int window; Operation op; } simpleData; }; #ifndef QT_NO_QWS_IM struct QWSIMEvent : QWSEvent { QWSIMEvent() : QWSEvent( IMEvent, sizeof( simpleData ), (char*)&simpleData ) { } struct SimpleData { int window; int type; int cpos; int selLen; int textLen; } simpleData; void setData( char *d, int len, bool allocateMem = TRUE ) { QWSEvent::setData( d, len, allocateMem ); text = (QChar*)rawDataPtr; } QChar *text; }; #endif #endif // QWSEVENT_QWS_H qurloperator.h/* */ #ifndef QURLOPERATOR_H #define QURLOPERATOR_H #ifndef QT_H #include "qobject.h" #include "qurl.h" #include "qptrlist.h" #include "qnetworkprotocol.h" #include "qstringlist.h" // QString->QStringList conversion #endif // QT_H #ifndef QT_NO_NETWORKPROTOCOL class QUrlInfo; class QUrlOperatorPrivate; class Q_EXPORT QUrlOperator : public QObject, public QUrl { friend class QNetworkProtocol; Q_OBJECT public: QUrlOperator(); QUrlOperator( const QString &urL ); QUrlOperator( const QUrlOperator& url ); QUrlOperator( const QUrlOperator& url, const QString& relUrl, bool checkSlash = FALSE ); virtual ~QUrlOperator(); virtual void setPath( const QString& path ); virtual bool cdUp(); virtual const QNetworkOperation *listChildren(); virtual const QNetworkOperation *mkdir( const QString &dirname ); virtual const QNetworkOperation *remove( const QString &filename ); virtual const QNetworkOperation *rename( const QString &oldname, const QString &newname ); virtual const QNetworkOperation *get( const QString &location = QString::null ); virtual const QNetworkOperation *put( const QByteArray &data, const QString &location = QString::null ); virtual QPtrList copy( const QString &from, const QString &to, bool move = FALSE, bool toPath = TRUE ); virtual void copy( const QStringList &files, const QString &dest, bool move = FALSE ); virtual bool isDir( bool *ok = 0 ); virtual void setNameFilter( const QString &nameFilter ); QString nameFilter() const; virtual QUrlInfo info( const QString &entry ) const; QUrlOperator& operator=( const QUrlOperator &url ); QUrlOperator& operator=( const QString &url ); virtual void stop(); signals: void newChildren( const QValueList &, QNetworkOperation *res ); void finished( QNetworkOperation *res ); void start( QNetworkOperation *res ); void createdDirectory( const QUrlInfo &, QNetworkOperation *res ); void removed( QNetworkOperation *res ); void itemChanged( QNetworkOperation *res ); void data( const QByteArray &, QNetworkOperation *res ); void dataTransferProgress( int bytesDone, int bytesTotal, QNetworkOperation *res ); void startedNextCopy( const QPtrList &lst ); void connectionStateChanged( int state, const QString &data ); protected: void reset(); bool parse( const QString& url ); virtual bool checkValid(); virtual void clearEntries(); void getNetworkProtocol(); void deleteNetworkProtocol(); private slots: const QNetworkOperation *startOperation( QNetworkOperation *op ); void copyGotData( const QByteArray &data, QNetworkOperation *op ); void continueCopy( QNetworkOperation *op ); void finishedCopy(); void addEntry( const QValueList &i ); void slotItemChanged( QNetworkOperation *op ); private: void deleteOperation( QNetworkOperation *op ); QUrlOperatorPrivate *d; }; #endif // QT_NO_NETWORKPROTOCOL #endif // QURLOPERATOR_H ,qwskdedecoration_qws.hw/* */ #ifndef QWSKDEDECORATION_QWS_H #define QWSKDEDECORATION_QWS_H #ifndef QT_H #include "qwsdefaultdecoration_qws.h" #endif // QT_H #ifndef QT_NO_QWS_KDE_WM_STYLE class QWSKDEDecoration : public QWSDefaultDecoration { public: QWSKDEDecoration(); virtual ~QWSKDEDecoration(); virtual QRegion region(const QWidget *, const QRect &rect, Region); virtual void paint(QPainter *, const QWidget *); virtual void paintButton(QPainter *, const QWidget *, Region, int state); protected: /* */ }; #endif // QT_NO_QWS_KDE_WM_STYLE #endif // QWSKDEDECORATION_QWS_H (qsyntaxhighlighter.h /* */ #ifndef QSYNTAXHIGHLIGHTER_H #define QSYNTAXHIGHLIGHTER_H #ifndef QT_H #include "qfont.h" #include "qcolor.h" #include "qstring.h" #endif // QT_H class QTextEdit; class QSyntaxHighlighterInternal; class QSyntaxHighlighterPrivate; class QTextParagraph; class Q_EXPORT QSyntaxHighlighter : public Qt { friend class QSyntaxHighlighterInternal; public: QSyntaxHighlighter( QTextEdit *textEdit ); virtual ~QSyntaxHighlighter(); virtual int highlightParagraph( const QString &text, int endStateOfLastPara ) = 0; void setFormat( int start, int count, const QFont &font, const QColor &color ); void setFormat( int start, int count, const QColor &color ); void setFormat( int start, int count, const QFont &font ); QTextEdit *textEdit() const { return edit; } void rehighlight(); int currentParagraph() const; private: QTextParagraph *para; QTextEdit *edit; QSyntaxHighlighterPrivate *d; }; #endif qtable.hH5/* */ #ifndef QTABLE_H #define QTABLE_H #ifndef QT_H #include "qscrollview.h" #include "qpixmap.h" #include "qptrvector.h" #include "qheader.h" #include "qmemarray.h" #include "qptrlist.h" #include "qguardedptr.h" #include "qshared.h" #include "qintdict.h" #include "qstringlist.h" #endif // QT_H #ifndef QT_NO_TABLE #if !defined( QT_MODULE_TABLE ) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_TABLE ) #define QM_EXPORT_TABLE #ifndef QM_TEMPLATE_EXTERN_TABLE # define QM_TEMPLATE_EXTERN_TABLE #endif #else #define QM_EXPORT_TABLE Q_EXPORT #define QM_TEMPLATE_EXTERN_TABLE Q_TEMPLATE_EXTERN #endif class QTableHeader; class QValidator; class QTable; class QPaintEvent; class QTimer; class QResizeEvent; class QComboBox; class QCheckBox; class QDragObject; struct QTablePrivate; struct QTableHeaderPrivate; class QM_EXPORT_TABLE QTableSelection { public: QTableSelection(); QTableSelection( int start_row, int start_col, int end_row, int end_col ); void init( int row, int col ); void expandTo( int row, int col ); bool operator==( const QTableSelection &s ) const; bool operator!=( const QTableSelection &s ) const { return !(operator==(s)); } int topRow() const { return tRow; } int bottomRow() const { return bRow; } int leftCol() const { return lCol; } int rightCol() const { return rCol; } int anchorRow() const { return aRow; } int anchorCol() const { return aCol; } int numRows() const; int numCols() const; bool isActive() const { return active; } bool isEmpty() const { return numRows() == 0; } private: uint active : 1; uint inited : 1; int tRow, lCol, bRow, rCol; int aRow, aCol; }; #define Q_DEFINED_QTABLE_SELECTION #include "qwinexport.h" class QM_EXPORT_TABLE QTableItem : public Qt { friend class QTable; public: enum EditType { Never, OnTyping, WhenCurrent, Always }; QTableItem( QTable *table, EditType et ); QTableItem( QTable *table, EditType et, const QString &text ); QTableItem( QTable *table, EditType et, const QString &text, const QPixmap &p ); virtual ~QTableItem(); virtual QPixmap pixmap() const; virtual QString text() const; virtual void setPixmap( const QPixmap &p ); virtual void setText( const QString &t ); QTable *table() const { return t; } virtual int alignment() const; virtual void setWordWrap( bool b ); bool wordWrap() const; EditType editType() const; virtual QWidget *createEditor() const; virtual void setContentFromEditor( QWidget *w ); virtual void setReplaceable( bool ); bool isReplaceable() const; virtual QString key() const; virtual QSize sizeHint() const; virtual void setSpan( int rs, int cs ); int rowSpan() const; int colSpan() const; virtual void setRow( int r ); virtual void setCol( int c ); int row() const; int col() const; virtual void paint( QPainter *p, const QColorGroup &cg, const QRect &cr, bool selected ); void updateEditor( int oldRow, int oldCol ); virtual void setEnabled( bool b ); bool isEnabled() const; virtual int rtti() const; static int RTTI; private: QString txt; QPixmap pix; QTable *t; EditType edType; uint wordwrap : 1; uint tcha : 1; uint enabled : 1; int rw, cl; int rowspan, colspan; #if (QT_VERSION >= 0x040000) #error "Add a setAlignment() function in 4.0 (but no d pointer)" #endif }; #define Q_DEFINED_QTABLE_ITEM #include "qwinexport.h" class QM_EXPORT_TABLE QComboTableItem : public QTableItem { public: QComboTableItem( QTable *table, const QStringList &list, bool editable = FALSE ); ~QComboTableItem(); virtual QWidget *createEditor() const; virtual void setContentFromEditor( QWidget *w ); virtual void paint( QPainter *p, const QColorGroup &cg, const QRect &cr, bool selected ); virtual void setCurrentItem( int i ); virtual void setCurrentItem( const QString &i ); int currentItem() const; QString currentText() const; int count() const; #if !defined(Q_NO_USING_KEYWORD) using QTableItem::text; #endif QString text( int i ) const; virtual void setEditable( bool b ); bool isEditable() const; virtual void setStringList( const QStringList &l ); int rtti() const; static int RTTI; QSize sizeHint() const; private: QComboBox *cb; QStringList entries; int current; bool edit; static QComboBox *fakeCombo; static QWidget *fakeComboWidget; static int fakeRef; }; class QM_EXPORT_TABLE QCheckTableItem : public QTableItem { public: QCheckTableItem( QTable *table, const QString &txt ); void setText( const QString &t ); virtual QWidget *createEditor() const; virtual void setContentFromEditor( QWidget *w ); virtual void paint( QPainter *p, const QColorGroup &cg, const QRect &cr, bool selected ); virtual void setChecked( bool b ); bool isChecked() const; int rtti() const; static int RTTI; QSize sizeHint() const; private: QCheckBox *cb; bool checked; }; class QM_EXPORT_TABLE QTable : public QScrollView { Q_OBJECT Q_ENUMS( SelectionMode FocusStyle ) Q_PROPERTY( int numRows READ numRows WRITE setNumRows ) Q_PROPERTY( int numCols READ numCols WRITE setNumCols ) Q_PROPERTY( bool showGrid READ showGrid WRITE setShowGrid ) Q_PROPERTY( bool rowMovingEnabled READ rowMovingEnabled WRITE setRowMovingEnabled ) Q_PROPERTY( bool columnMovingEnabled READ columnMovingEnabled WRITE setColumnMovingEnabled ) Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly ) Q_PROPERTY( bool sorting READ sorting WRITE setSorting ) Q_PROPERTY( SelectionMode selectionMode READ selectionMode WRITE setSelectionMode ) Q_PROPERTY( FocusStyle focusStyle READ focusStyle WRITE setFocusStyle ) Q_PROPERTY( int numSelections READ numSelections ) friend class QTableHeader; friend class QComboTableItem; friend class QCheckTableItem; friend class QTableItem; public: QTable( QWidget* parent=0, const char* name=0 ); QTable( int numRows, int numCols, QWidget* parent=0, const char* name=0 ); ~QTable(); QHeader *horizontalHeader() const; QHeader *verticalHeader() const; enum SelectionMode { Single, Multi, SingleRow, MultiRow, NoSelection }; virtual void setSelectionMode( SelectionMode mode ); SelectionMode selectionMode() const; virtual void setItem( int row, int col, QTableItem *item ); virtual void setText( int row, int col, const QString &text ); virtual void setPixmap( int row, int col, const QPixmap &pix ); virtual QTableItem *item( int row, int col ) const; virtual QString text( int row, int col ) const; virtual QPixmap pixmap( int row, int col ) const; virtual void clearCell( int row, int col ); virtual QRect cellGeometry( int row, int col ) const; virtual int columnWidth( int col ) const; virtual int rowHeight( int row ) const; virtual int columnPos( int col ) const; virtual int rowPos( int row ) const; virtual int columnAt( int x ) const; virtual int rowAt( int y ) const; virtual int numRows() const; virtual int numCols() const; void updateCell( int row, int col ); bool eventFilter( QObject * o, QEvent * ); int currentRow() const { return curRow; } int currentColumn() const { return curCol; } void ensureCellVisible( int row, int col ); bool isSelected( int row, int col ) const; bool isRowSelected( int row, bool full = FALSE ) const; bool isColumnSelected( int col, bool full = FALSE ) const; int numSelections() const; QTableSelection selection( int num ) const; virtual int addSelection( const QTableSelection &s ); virtual void removeSelection( const QTableSelection &s ); virtual void removeSelection( int num ); virtual int currentSelection() const; void selectCells( int start_row, int start_col, int end_row, int end_col ); void selectRow( int row ); void selectColumn( int col ); bool showGrid() const; bool columnMovingEnabled() const; bool rowMovingEnabled() const; virtual void sortColumn( int col, bool ascending = TRUE, bool wholeRows = FALSE ); bool sorting() const; virtual void takeItem( QTableItem *i ); virtual void setCellWidget( int row, int col, QWidget *e ); virtual QWidget *cellWidget( int row, int col ) const; virtual void clearCellWidget( int row, int col ); virtual QRect cellRect( int row, int col ) const; virtual void paintCell( QPainter *p, int row, int col, const QRect &cr, bool selected ); virtual void paintCell( QPainter *p, int row, int col, const QRect &cr, bool selected, const QColorGroup &cg ); virtual void paintFocus( QPainter *p, const QRect &r ); QSize sizeHint() const; bool isReadOnly() const; bool isRowReadOnly( int row ) const; bool isColumnReadOnly( int col ) const; void setEnabled( bool b ); void repaintSelections(); enum FocusStyle { FollowStyle, SpreadSheet }; virtual void setFocusStyle( FocusStyle fs ); FocusStyle focusStyle() const; void updateHeaderStates(); public slots: virtual void setNumRows( int r ); virtual void setNumCols( int r ); virtual void setShowGrid( bool b ); virtual void hideRow( int row ); virtual void hideColumn( int col ); virtual void showRow( int row ); virtual void showColumn( int col ); bool isRowHidden( int row ) const; bool isColumnHidden( int col ) const; virtual void setColumnWidth( int col, int w ); virtual void setRowHeight( int row, int h ); virtual void adjustColumn( int col ); virtual void adjustRow( int row ); virtual void setColumnStretchable( int col, bool stretch ); virtual void setRowStretchable( int row, bool stretch ); bool isColumnStretchable( int col ) const; bool isRowStretchable( int row ) const; virtual void setSorting( bool b ); virtual void swapRows( int row1, int row2, bool swapHeader = FALSE ); virtual void swapColumns( int col1, int col2, bool swapHeader = FALSE ); virtual void swapCells( int row1, int col1, int row2, int col2 ); virtual void setLeftMargin( int m ); virtual void setTopMargin( int m ); virtual void setCurrentCell( int row, int col ); void clearSelection( bool repaint = TRUE ); virtual void setColumnMovingEnabled( bool b ); virtual void setRowMovingEnabled( bool b ); virtual void setReadOnly( bool b ); virtual void setRowReadOnly( int row, bool ro ); virtual void setColumnReadOnly( int col, bool ro ); virtual void setDragEnabled( bool b ); bool dragEnabled() const; virtual void insertRows( int row, int count = 1 ); virtual void insertColumns( int col, int count = 1 ); virtual void removeRow( int row ); virtual void removeRows( const QMemArray &rows ); virtual void removeColumn( int col ); virtual void removeColumns( const QMemArray &cols ); virtual void editCell( int row, int col, bool replace = FALSE ); void setRowLabels( const QStringList &labels ); void setColumnLabels( const QStringList &labels ); protected: enum EditMode { NotEditing, Editing, Replacing }; void drawContents( QPainter *p, int cx, int cy, int cw, int ch ); void contentsMousePressEvent( QMouseEvent* ); void contentsMouseMoveEvent( QMouseEvent* ); void contentsMouseDoubleClickEvent( QMouseEvent* ); void contentsMouseReleaseEvent( QMouseEvent* ); void contentsContextMenuEvent( QContextMenuEvent * e ); void keyPressEvent( QKeyEvent* ); void focusInEvent( QFocusEvent* ); void focusOutEvent( QFocusEvent* ); void viewportResizeEvent( QResizeEvent * ); void showEvent( QShowEvent *e ); void paintEvent( QPaintEvent *e ); void setEditMode( EditMode mode, int row, int col ); #ifndef QT_NO_DRAGANDDROP virtual void contentsDragEnterEvent( QDragEnterEvent *e ); virtual void contentsDragMoveEvent( QDragMoveEvent *e ); virtual void contentsDragLeaveEvent( QDragLeaveEvent *e ); virtual void contentsDropEvent( QDropEvent *e ); virtual QDragObject *dragObject(); virtual void startDrag(); #endif virtual void paintEmptyArea( QPainter *p, int cx, int cy, int cw, int ch ); virtual void activateNextCell(); virtual QWidget *createEditor( int row, int col, bool initFromCell ) const; virtual void setCellContentFromEditor( int row, int col ); virtual QWidget *beginEdit( int row, int col, bool replace ); virtual void endEdit( int row, int col, bool accept, bool replace ); virtual void resizeData( int len ); virtual void insertWidget( int row, int col, QWidget *w ); int indexOf( int row, int col ) const; void windowActivationChange( bool ); bool isEditing() const; EditMode editMode() const; int currEditRow() const; int currEditCol() const; protected slots: virtual void columnWidthChanged( int col ); virtual void rowHeightChanged( int row ); virtual void columnIndexChanged( int section, int fromIndex, int toIndex ); virtual void rowIndexChanged( int section, int fromIndex, int toIndex ); virtual void columnClicked( int col ); signals: void currentChanged( int row, int col ); void clicked( int row, int col, int button, const QPoint &mousePos ); void doubleClicked( int row, int col, int button, const QPoint &mousePos ); void pressed( int row, int col, int button, const QPoint &mousePos ); void selectionChanged(); void valueChanged( int row, int col ); void contextMenuRequested( int row, int col, const QPoint &pos ); #ifndef QT_NO_DRAGANDDROP void dropped( QDropEvent *e ); #endif private slots: void doAutoScroll(); void doValueChanged(); void updateGeometriesSlot(); private: void contentsMousePressEventEx( QMouseEvent* ); void drawContents( QPainter* ); void updateGeometries(); void repaintSelections( QTableSelection *oldSelection, QTableSelection *newSelection, bool updateVertical = TRUE, bool updateHorizontal = TRUE ); QRect rangeGeometry( int topRow, int leftCol, int bottomRow, int rightCol, bool &optimize ); void fixRow( int &row, int y ); void fixCol( int &col, int x ); void init( int numRows, int numCols ); QSize tableSize() const; void repaintCell( int row, int col ); void contentsToViewport2( int x, int y, int& vx, int& vy ); QPoint contentsToViewport2( const QPoint &p ); void viewportToContents2( int vx, int vy, int& x, int& y ); QPoint viewportToContents2( const QPoint &p ); void updateRowWidgets( int row ); void updateColWidgets( int col ); bool isSelected( int row, int col, bool includeCurrent ) const; void setCurrentCell( int row, int col, bool updateSelections, bool ensureVisible = FALSE ); void fixCell( int &row, int &col, int key ); void delayedUpdateGeometries(); struct TableWidget { TableWidget( QWidget *w, int r, int c ) : wid( w ), row( r ), col ( c ) {} QWidget *wid; int row, col; }; void saveContents( QPtrVector &tmp, QPtrVector &tmp2 ); void updateHeaderAndResizeContents( QTableHeader *header, int num, int colRow, int width, bool &updateBefore ); void restoreContents( QPtrVector &tmp, QPtrVector &tmp2 ); void finishContentsResze( bool updateBefore ); private: QPtrVector contents; QPtrVector widgets; int curRow; int curCol; QTableHeader *leftHeader, *topHeader; EditMode edMode; int editCol, editRow; QPtrList selections; QTableSelection *currentSel; QTimer *autoScrollTimer; int lastSortCol; bool sGrid : 1; bool mRows : 1; bool mCols : 1; bool asc : 1; bool doSort : 1; bool unused : 1; bool readOnly : 1; bool shouldClearSelection : 1; bool dEnabled : 1; bool context_menu : 1; bool drawActiveSelection : 1; bool was_visible : 1; SelectionMode selMode; int pressedRow, pressedCol; QTablePrivate *d; QIntDict roRows; QIntDict roCols; int startDragRow; int startDragCol; QPoint dragStartPos; int oldCurrentRow, oldCurrentCol; QWidget *unused_topLeftCorner; //### remove in 4.0 FocusStyle focusStl; QSize unused_cachedSizeHint; // ### remove in 4.0 #if defined(Q_DISABLE_COPY) QTable( const QTable & ); QTable &operator=( const QTable & ); #endif }; #define Q_DEFINED_QTABLE #include "qwinexport.h" #endif // QT_NO_TABLE #endif // TABLE_H qwidgetintdict.h /* */ #ifndef QWIDGETINTDICT_H #define QWIDGETINTDICT_H #ifndef QT_H #include "qwidget.h" #include "qintdict.h" #endif // QT_H #if defined(Q_TEMPLATEDLL) //Q_TEMPLATE_EXTERN template class Q_EXPORT QIntDict; //Q_TEMPLATE_EXTERN template class Q_EXPORT QIntDictIterator; #endif class Q_EXPORT QWidgetIntDict : public QIntDict { public: QWidgetIntDict(int size=17) : QIntDict(size) {} QWidgetIntDict( const QWidgetIntDict &dict ) : QIntDict(dict) {} ~QWidgetIntDict() { clear(); } QWidgetIntDict &operator=(const QWidgetIntDict &dict) { return (QWidgetIntDict&)QIntDict::operator=(dict); } }; class Q_EXPORT QWidgetIntDictIt : public QIntDictIterator { public: QWidgetIntDictIt( const QWidgetIntDict &d ) : QIntDictIterator(d) {} QWidgetIntDictIt &operator=(const QWidgetIntDictIt &i) { return (QWidgetIntDictIt&)QIntDictIterator::operator=(i); } }; #endif qstylesheet.h/* */ #ifndef QSTYLESHEET_H #define QSTYLESHEET_H #ifndef QT_H #include "qstring.h" #include "qvaluelist.h" #include "qptrvector.h" #include "qdict.h" #include "qobject.h" #endif // QT_H #ifndef QT_NO_RICHTEXT class QStyleSheet; class QTextDocument; template class QMap; class QStyleSheetItemData; class Q_EXPORT QStyleSheetItem : public Qt { public: QStyleSheetItem( QStyleSheet* parent, const QString& name ); QStyleSheetItem( const QStyleSheetItem & ); ~QStyleSheetItem(); QStyleSheetItem& operator=( const QStyleSheetItem& other ); QString name() const; QStyleSheet* styleSheet(); const QStyleSheet* styleSheet() const; enum AdditionalStyleValues { Undefined = - 1}; enum DisplayMode { DisplayBlock, DisplayInline, DisplayListItem, DisplayNone #ifndef Q_QDOC , DisplayModeUndefined = -1 #endif }; DisplayMode displayMode() const; void setDisplayMode(DisplayMode m); int alignment() const; void setAlignment( int f); enum VerticalAlignment { VAlignBaseline, VAlignSub, VAlignSuper }; VerticalAlignment verticalAlignment() const; void setVerticalAlignment( VerticalAlignment valign ); int fontWeight() const; void setFontWeight(int w); int logicalFontSize() const; void setLogicalFontSize(int s); int logicalFontSizeStep() const; void setLogicalFontSizeStep( int s ); int fontSize() const; void setFontSize(int s); QString fontFamily() const; void setFontFamily( const QString& ); int numberOfColumns() const; void setNumberOfColumns(int ncols); QColor color() const; void setColor( const QColor &); bool fontItalic() const; void setFontItalic( bool ); bool definesFontItalic() const; bool fontUnderline() const; void setFontUnderline( bool ); bool definesFontUnderline() const; bool fontStrikeOut() const; void setFontStrikeOut( bool ); bool definesFontStrikeOut() const; bool isAnchor() const; void setAnchor(bool anc); enum WhiteSpaceMode { WhiteSpaceNormal, WhiteSpacePre, WhiteSpaceNoWrap #ifndef Q_QDOC , WhiteSpaceModeUndefined = -1 #endif }; WhiteSpaceMode whiteSpaceMode() const; void setWhiteSpaceMode(WhiteSpaceMode m); enum Margin { MarginLeft, MarginRight, MarginTop, MarginBottom, MarginFirstLine, MarginAll, MarginVertical, MarginHorizontal #ifndef Q_QDOC , MarginUndefined = -1 #endif }; int margin( Margin m) const; void setMargin( Margin, int); enum ListStyle { ListDisc, ListCircle, ListSquare, ListDecimal, ListLowerAlpha, ListUpperAlpha #ifndef Q_QDOC , ListStyleUndefined = -1 #endif }; ListStyle listStyle() const; void setListStyle( ListStyle ); QString contexts() const; void setContexts( const QString& ); bool allowedInContext( const QStyleSheetItem* ) const; bool selfNesting() const; void setSelfNesting( bool ); void setLineSpacing( int ls ); int lineSpacing() const; private: void init(); QStyleSheetItemData* d; }; #if defined(Q_TEMPLATEDLL) // MOC_SKIP_BEGIN Q_TEMPLATE_EXTERN template class Q_EXPORT QDict; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList< QPtrVector >; Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrVector; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; // MOC_SKIP_END #endif #ifndef QT_NO_TEXTCUSTOMITEM class QTextCustomItem; #endif class Q_EXPORT QStyleSheet : public QObject { Q_OBJECT public: QStyleSheet( QObject *parent=0, const char *name=0 ); virtual ~QStyleSheet(); static QStyleSheet* defaultSheet(); static void setDefaultSheet( QStyleSheet* ); QStyleSheetItem* item( const QString& name); const QStyleSheetItem* item( const QString& name) const; void insert( QStyleSheetItem* item); #ifndef QT_NO_TEXTCUSTOMITEM virtual QTextCustomItem* tag( const QString& name, const QMap &attr, const QString& context, const QMimeSourceFactory& factory, bool emptyTag, QTextDocument *doc ) const; #endif static QString escape( const QString& ); static QString convertFromPlainText( const QString&, QStyleSheetItem::WhiteSpaceMode mode = QStyleSheetItem::WhiteSpacePre ); static bool mightBeRichText( const QString& ); virtual void scaleFont( QFont& font, int logicalSize ) const; virtual void error( const QString& ) const; private: void init(); QDict styles; QStyleSheetItem* nullstyle; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QStyleSheet( const QStyleSheet & ); QStyleSheet &operator=( const QStyleSheet & ); #endif }; #endif // QT_NO_RICHTEXT #endif // QSTYLESHEET_H qthread.h /* */ #ifndef QTHREAD_H #define QTHREAD_H #if defined(QT_THREAD_SUPPORT) #ifndef QT_H #include "qwindowdefs.h" #ifndef QT_NO_COMPAT #include "qmutex.h" #include "qsemaphore.h" #include "qwaitcondition.h" #endif // QT_NO_COMPAT #endif // QT_H #include class QThreadInstance; class Q_EXPORT QThread : public Qt { public: static Qt::HANDLE currentThread(); #ifndef QT_NO_COMPAT static void postEvent( QObject *,QEvent * ); #endif static void initialize(); static void cleanup(); static void exit(); #ifdef Q_QDOC QThread( unsigned int stackSize = 0 ); #else QThread( unsigned int stackSize ); QThread(); #endif virtual ~QThread(); // default argument causes thread to block indefinately bool wait( unsigned long time = ULONG_MAX ); enum Priority { IdlePriority, LowestPriority, LowPriority, NormalPriority, HighPriority, HighestPriority, TimeCriticalPriority, InheritPriority }; #ifdef Q_QDOC void start( Priority = InheritPriority ); #else void start( Priority ); void start(); #endif void terminate(); bool finished() const; bool running() const; protected: virtual void run() = 0; static void sleep( unsigned long ); static void msleep( unsigned long ); static void usleep( unsigned long ); private: QThreadInstance * d; friend class QThreadInstance; #if defined(Q_DISABLE_COPY) QThread( const QThread & ); QThread &operator=( const QThread & ); #endif // Q_DISABLE_COPY }; #endif // QT_THREAD_SUPPORT #endif // QTHREAD_H qvgroupbox.h*/********************************************************************** ** $Id: $ ** ** Definition of QVGroupBox widget class ** ** Created : 990602 ** ** Copyright (C) 1999-2000 Trolltech AS. All rights reserved. ** ** This file is part of the widgets module of the Qt GUI Toolkit. ** ** This file may be distributed under the terms of the Q Public License ** as defined by Trolltech AS of Norway and appearing in the file ** LICENSE.QPL included in the packaging of this file. ** ** This file may be distributed and/or modified under the terms of the ** GNU General Public License version 2 as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL included in the ** packaging of this file. ** ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition ** 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 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ** ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for ** information about Qt Commercial License Agreements. ** See http://www.trolltech.com/qpl/ for QPL licensing information. ** See http://www.trolltech.com/gpl/ for GPL licensing information. ** ** Contact info@trolltech.com if any conditions of this licensing are ** not clear to you. ** **********************************************************************/ #ifndef QVGROUPBOX_H #define QVGROUPBOX_H #ifndef QT_H #include "qgroupbox.h" #endif // QT_H #ifndef QT_NO_VGROUPBOX class Q_EXPORT QVGroupBox : public QGroupBox { Q_OBJECT public: QVGroupBox( QWidget* parent=0, const char* name=0 ); QVGroupBox( const QString &title, QWidget* parent=0, const char* name=0 ); ~QVGroupBox(); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QVGroupBox( const QVGroupBox & ); QVGroupBox &operator=( const QVGroupBox & ); #endif }; #endif // QT_NO_VGROUPBOX #endif // QVGROUPBOX_H qsqlfield.h/* */ #ifndef QSQLFIELD_H #define QSQLFIELD_H #ifndef QT_H #include "qstring.h" #include "qvariant.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL class QSqlFieldPrivate { public: QVariant::Type type; }; class QM_EXPORT_SQL QSqlField { public: QSqlField( const QString& fieldName = QString::null, QVariant::Type type = QVariant::Invalid ); QSqlField( const QSqlField& other ); QSqlField& operator=( const QSqlField& other ); bool operator==(const QSqlField& other) const; virtual ~QSqlField(); virtual void setValue( const QVariant& value ); virtual QVariant value() const; virtual void setName( const QString& name ); QString name() const; virtual void setNull(); bool isNull() const; virtual void setReadOnly( bool readOnly ); bool isReadOnly() const; void clear( bool nullify = TRUE ); QVariant::Type type() const; private: QString nm; QVariant val; uint ro: 1; uint nul: 1; QSqlFieldPrivate* d; }; inline QVariant QSqlField::value() const { return val; } inline QString QSqlField::name() const { return nm; } inline bool QSqlField::isNull() const { return nul; } inline bool QSqlField::isReadOnly() const { return ro; } inline QVariant::Type QSqlField::type() const { return d->type; } /* */ /* */ /* */ struct QSqlFieldInfoPrivate; class QM_EXPORT_SQL QSqlFieldInfo { public: QSqlFieldInfo( const QString& name = QString::null, QVariant::Type typ = QVariant::Invalid, int required = -1, int len = -1, int prec = -1, const QVariant& defValue = QVariant(), int sqlType = 0, bool generated = TRUE, bool trim = FALSE, bool calculated = FALSE ); QSqlFieldInfo( const QSqlFieldInfo & other ); QSqlFieldInfo( const QSqlField & other, bool generated = TRUE ); virtual ~QSqlFieldInfo(); QSqlFieldInfo& operator=( const QSqlFieldInfo& other ); bool operator==( const QSqlFieldInfo& f ) const; QSqlField toField() const; int isRequired() const; QVariant::Type type() const; int length() const; int precision() const; QVariant defaultValue() const; QString name() const; int typeID() const; bool isGenerated() const; bool isTrim() const; bool isCalculated() const; virtual void setTrim( bool trim ); virtual void setGenerated( bool gen ); virtual void setCalculated( bool calc ); private: QSqlFieldInfoPrivate* d; }; #endif // QT_NO_SQL #endif qstatusbar.h |/* */ #ifndef QSTATUSBAR_H #define QSTATUSBAR_H #ifndef QT_H #include "qwidget.h" #endif // QT_H #ifndef QT_NO_STATUSBAR class QStatusBarPrivate; class Q_EXPORT QStatusBar: public QWidget { Q_OBJECT Q_PROPERTY( bool sizeGripEnabled READ isSizeGripEnabled WRITE setSizeGripEnabled ) public: QStatusBar( QWidget* parent=0, const char* name=0 ); virtual ~QStatusBar(); virtual void addWidget( QWidget *, int stretch = 0, bool = FALSE ); virtual void removeWidget( QWidget * ); void setSizeGripEnabled(bool); bool isSizeGripEnabled() const; public slots: void message( const QString &); void message( const QString &, int ); void clear(); signals: void messageChanged( const QString &text ); protected: void paintEvent( QPaintEvent * ); void resizeEvent( QResizeEvent * ); void reformat(); void hideOrShow(); bool event( QEvent *); private: QStatusBarPrivate * d; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QStatusBar( const QStatusBar & ); QStatusBar& operator=( const QStatusBar & ); #endif }; #endif // QT_NO_STATUSBAR #endif // QSTATUSBAR_H qworkspace.hK/* */ #ifndef QWORKSPACE_H #define QWORKSPACE_H #ifndef QT_H #include "qwidget.h" #include "qwidgetlist.h" #endif // QT_H #ifndef QT_NO_WORKSPACE #if !defined( QT_MODULE_WORKSPACE ) || defined( QT_INTERNAL_WORKSPACE ) #define QM_EXPORT_WORKSPACE #else #define QM_EXPORT_WORKSPACE Q_EXPORT #endif class QWorkspaceChild; class QShowEvent; class QWorkspacePrivate; class QPopupMenu; class QDockWindow; class QM_EXPORT_WORKSPACE QWorkspace : public QWidget { Q_OBJECT Q_PROPERTY( bool scrollBarsEnabled READ scrollBarsEnabled WRITE setScrollBarsEnabled ) #ifdef QT_WORKSPACE_WINDOWMODE public: #endif enum WindowMode { TopLevel, MDI, AutoDetect }; WindowMode windowMode() const; #ifdef QT_WORKSPACE_WINDOWMODE private: #endif public: #ifdef QT_WORKSPACE_WINDOWMODE QWorkspace( WindowMode mode, QWidget* parent=0, const char* name=0 ); #endif QWorkspace( QWidget* parent=0, const char* name=0 ); ~QWorkspace(); enum WindowOrder { CreationOrder, StackingOrder }; QWidget* activeWindow() const; QWidgetList windowList() const; // ### merge with below in 4.0 QWidgetList windowList( WindowOrder order ) const; QSize sizeHint() const; bool scrollBarsEnabled() const; void setScrollBarsEnabled( bool enable ); void setPaletteBackgroundColor( const QColor & ); void setPaletteBackgroundPixmap( const QPixmap & ); signals: void windowActivated( QWidget* w); public slots: void cascade(); void tile(); void closeActiveWindow(); void closeAllWindows(); void activateNextWindow(); void activatePrevWindow(); protected: #ifndef QT_NO_STYLE void styleChange( QStyle& ); #endif void childEvent( QChildEvent * ); void resizeEvent( QResizeEvent * ); bool eventFilter( QObject *, QEvent * ); void showEvent( QShowEvent *e ); void hideEvent( QHideEvent *e ); #ifndef QT_NO_WHEELEVENT void wheelEvent( QWheelEvent *e ); #endif private slots: void normalizeActiveWindow(); void minimizeActiveWindow(); void showOperationMenu(); void popupOperationMenu( const QPoint& ); void operationMenuActivated( int ); void operationMenuAboutToShow(); void toolMenuAboutToShow(); void activatePreviousWindow(); // ### remove in Qt 4.0 void dockWindowsShow(); void scrollBarChanged(); private: void init(); void handleUndock( QDockWindow* w); void insertIcon( QWidget* w); void removeIcon( QWidget* w); void place( QWidget* ); QWorkspaceChild* findChild( QWidget* w); void showMaximizeControls(); void hideMaximizeControls(); void activateWindow( QWidget* w, bool change_focus = TRUE ); void showWindow( QWidget* w); void maximizeWindow( QWidget* w); void minimizeWindow( QWidget* w); void normalizeWindow( QWidget* w); QRect updateWorkspace(); QPopupMenu* popup; QWorkspacePrivate* d; friend class QWorkspacePrivate; friend class QWorkspaceChild; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QWorkspace( const QWorkspace & ); QWorkspace& operator=( const QWorkspace & ); #endif }; #endif // QT_NO_WORKSPACE #endif // QWORKSPACE_H qwinexport.h(/* */ #if defined(Q_TEMPLATEDLL) && ( !defined(Q_CC_BOR) || !defined(QT_MAKEDLL) || defined(Q_EXPORT_TEMPLATES) ) // MOC_SKIP_BEGIN #if defined(Q_DEFINED_QASCIIDICT) && defined(Q_DEFINED_QCONNECTION_LIST) && !defined(Q_EXPORTED_QASCIIDICT_TEMPLATES) #define Q_EXPORTED_QASCIIDICT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QAsciiDictIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QAsciiDict; #endif #if defined(Q_DEFINED_QSTYLESHEET) && defined(Q_DEFINED_QDICT) && !defined(Q_EXPORTED_QSTYLESHEET_TEMPLATES) #define Q_EXPORTED_QSTYLESHEET_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QDict; #endif #if defined(Q_DEFINED_QLIBRARY) && defined(Q_DEFINED_QDICT) && !defined(Q_EXPORTED_QDICTLIBRARY_TEMPLATES) #define Q_EXPORTED_QDICTLIBRARY_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QDict; // for Qtopia #endif #if defined(Q_DEFINED_QGUARDEDPTR) && defined(Q_DEFINED_QOBJECT) && !defined(Q_EXPORTED_QGUARDEDPTROBJECT_TEMPLATES) #define Q_EXPORTED_QGUARDEDPTROBJECT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QGuardedPtr; #endif // needed for Qtopia #if defined(Q_DEFINED_QGUARDEDPTR) && defined(Q_DEFINED_QWIDGET) && !defined(Q_EXPORTED_QGUARDEDPTRQWIDGET_TEMPLATES) #define Q_EXPORTED_QGUARDEDPTRQWIDGET_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QGuardedPtr; #endif #if defined(Q_DEFINED_QGUARDEDPTR) && defined(Q_DEFINED_QACCESSIBLE_OBJECT) && !defined(Q_EXPORTED_QACCESSIBLEOBJECT_TEMPLATES) #define Q_EXPORTED_QACCESSIBLEOBJECT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QGuardedPtr; #endif #if defined(Q_DEFINED_QINTDICT) && !defined(Q_EXPORTED_QINTDICT_TEMPLATES) #define Q_EXPORTED_QINTDICT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QIntDict; #endif #if defined(Q_DEFINED_QINTDICT) && defined(Q_DEFINED_QWIDGET) && !defined(Q_EXPORTED__TEMPLATES) #define Q_EXPORTED__TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QIntDictIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QIntDict; #endif #if defined(Q_DEFINED_QMAP) && !defined(Q_EXPORTED_QMAPBASIC_TEMPLATES) #define Q_EXPORTED_QMAPBASIC_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QMap; // for Qtopia Q_TEMPLATE_EXTERN template class Q_EXPORT QMap; // for Qtopia #endif #if defined(Q_DEFINED_QMAP) && defined(Q_DEFINED_QSTRING) && !defined(Q_EXPORTED_QMAPQSTRING_TEMPLATES) #define Q_EXPORTED_QMAPQSTRING_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QMap; Q_TEMPLATE_EXTERN template class Q_EXPORT QMap; // for Qtopia Q_TEMPLATE_EXTERN template class Q_EXPORT QMap; // for Qtopia #endif #if defined(Q_DEFINED_QMEMARRAY) && !defined(Q_EXPORTED_QMEMARRAY_BASIC_TEMPLATES) #define Q_EXPORTED_QMEMARRAY_BASIC_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QMemArray; Q_TEMPLATE_EXTERN template class Q_EXPORT QMemArray; Q_TEMPLATE_EXTERN template class Q_EXPORT QMemArray; #endif #if defined(Q_DEFINED_QMEMARRAY) && defined(Q_DEFINED_QPOINT) && !defined(Q_EXPORTED_QMEMARAYPOINT_TEMPLATES) #define Q_EXPORTED_QMEMARAYPOINT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QMemArray; #endif #if defined(Q_DEFINED_QPTRLIST) && !defined(Q_EXPORTED_QPTRLIST_BASIC_TEMPLATES) #define Q_EXPORTED_QPTRLIST_BASIC_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList; #endif #if defined(Q_DEFINED_QPTRLIST) && defined(Q_DEFINED_QWIDGET) && !defined(Q_EXPORTED_QPTRLISTWIDGET_TEMPLATES) #define Q_EXPORTED_QPTRLISTWIDGET_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList; #endif #if defined(Q_DEFINED_QPTRLIST) && defined(Q_DEFINED_QCONNECTION) && !defined(Q_EXPORTED_QPTRLISTCONNECTION_TEMPLATES) #define Q_EXPORTED_QPTRLISTCONNECTION_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList; #endif #if defined(Q_DEFINED_QPTRLIST) && defined(Q_DEFINED_QOBJECT) && !defined(Q_EXPORTED_QPTRLISTOBJECT_TEMPLATES) #define Q_EXPORTED_QPTRLISTOBJECT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList; #endif #if defined(Q_DEFINED_QPTRLIST) && defined(Q_DEFINED_QDOCKWINDOW) && !defined(Q_EXPORTED_QPTRLISTDOCWINDOW_TEMPLATES) #define Q_EXPORTED_QPTRLISTDOCWINDOW_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrList; #endif #if defined(Q_DEFINED_QPTRVECTOR) && !defined(Q_EXPORTED_QPTRVECTOR_BASIC_TEMPLATES) #define Q_EXPORTED_QPTRVECTOR_BASIC_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrVector; #endif #if defined(Q_DEFINED_QPTRVECTOR) && defined(Q_DEFINED_QSTYLESHEET) && !defined(Q_EXPORTED_QPTRVECTORSTYLESHEETITEM_TEMPLATES) #define Q_EXPORTED_QPTRVECTORSTYLESHEETITEM_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrVector; #endif #if defined(Q_DEFINED_QPTRVECTOR) && defined(Q_DEFINED_QWIDGET) && !defined(Q_EXPORTED_QPTRVECTORWIDGET_TEMPLATES) #define Q_EXPORTED_QPTRVECTORWIDGET_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrVector; #endif #if defined(Q_DEFINED_QPTRVECTOR) && defined(Q_DEFINED_QCONNECTION_LIST) && !defined(Q_EXPORTED_QPTRVECTORCONNECTTIONLIST_TEMPLATES) #define Q_EXPORTED_QPTRVECTORCONNECTTIONLIST_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrVector; #endif #if defined(Q_DEFINED_QVALUELIST) && !defined(Q_EXPORTED_QVALUELIST_BASIC_TEMPLATES) #define Q_EXPORTED_QVALUELIST_BASIC_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QValueListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; #endif #if defined(Q_DEFINED_QVALUELIST) && defined(Q_DEFINED_QRECT) && !defined(Q_EXPORTED_QVALUELISTRECT_TEMPLATES) #define Q_EXPORTED_QVALUELISTRECT_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QValueListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; #endif #if defined(Q_DEFINED_QVALUELIST) && defined(Q_DEFINED_QSTRING) && !defined(Q_EXPORTED_QVALUELISTSTRING_TEMPLATES) #define Q_EXPORTED_QVALUELISTSTRING_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QValueListIterator; Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; #endif // QStylesheet template exports #if defined(Q_DEFINED_QVALUELIST) && defined(Q_DEFINED_QPTRVECTOR) && defined(Q_DEFINED_QSTYLESHEET) && !defined(Q_EXPORTED_QSTYLESHEETITEM1_TEMPLATES) #define Q_EXPORTED_QSTYLESHEETITEM1_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList< QPtrVector< QStyleSheetItem> >; #endif #if defined(Q_DEFINED_QVALUELIST) && defined(Q_DEFINED_QSTYLESHEET) && !defined(Q_EXPORTED_QSTYLESHEETITEM2_TEMPLATES) #define Q_EXPORTED_QSTYLESHEETITEM2_TEMPLATES Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; #endif // qcanvas template exports #if defined(Q_DEFINED_QPTRLIST) && defined(Q_DEFINED_QCANVAS) && !defined(Q_EXPORTED_QCANVAS1_TEMPLATES) #define Q_EXPORTED_QCANVAS1_TEMPLATES QM_TEMPLATE_EXTERN_CANVAS template class QM_EXPORT_CANVAS QPtrListIterator< QCanvasItem >; QM_TEMPLATE_EXTERN_CANVAS template class QM_EXPORT_CANVAS QPtrList< QCanvasItem >; QM_TEMPLATE_EXTERN_CANVAS template class QM_EXPORT_CANVAS QPtrListIterator< QCanvasView >; QM_TEMPLATE_EXTERN_CANVAS template class QM_EXPORT_CANVAS QPtrList< QCanvasView >; #endif // qtable template exports #if defined(Q_DEFINED_QPTRLIST) && defined(Q_DEFINED_QTABLE_SELECTION) && !defined(Q_EXPORTED_QTABLESELECTION_TEMPLATES) #define Q_EXPORTED_QTABLESELECTION_TEMPLATES QM_TEMPLATE_EXTERN_TABLE template class QM_EXPORT_TABLE QPtrList; #endif #if defined(Q_DEFINED_QTABLE_ITEM) && defined(Q_DEFINED_QPTRVECTOR) && !defined(Q_EXPORTED_QTABLEITEM_TEMPLATES) #define Q_EXPORTED_QTABLEITEM_TEMPLATES QM_TEMPLATE_EXTERN_TABLE template class QM_EXPORT_TABLE QPtrVector; #endif #if defined(Q_DEFINED_QTABLE) && defined(Q_DEFINED_QPTRVECTOR) //Q_TEMPLATE_EXTERN template class Q_EXPORT QPtrVector; #endif // qsqlextension template exports #if defined(Q_DEFINED_QSQLEXTENSION) && defined(Q_DEFINED_QMAP) && defined(Q_DEFINED_QVALUEVECTOR) && defined(Q_DEFINED_QSTRING) && !defined(Q_EXPORTED_QSQLEXTENSION_TEMPLATES) #define Q_EXPORTED_QSQLEXTENSION_TEMPLATES QM_TEMPLATE_EXTERN_SQL template class QM_EXPORT_SQL QMap; QM_TEMPLATE_EXTERN_SQL template class QM_EXPORT_SQL QValueVector; #endif // MOC_SKIP_END #endif // template defined qwscommand_qws.h2-/* */ #ifndef QWSCOMMAND_QWS_H #define QWSCOMMAND_QWS_H #ifndef QT_H #include "qwsutils_qws.h" #endif // QT_H #define QTE_PIPE "QtEmbedded-%1" /* */ #ifndef QT_NO_QWS_MULTIPROCESS void qws_write_command( QWSSocket *socket, int type, char *simpleData, int simpleLen, char *rawData, int rawLen ); bool qws_read_command( QWSSocket *socket, char *&simpleData, int &simpleLen, char *&rawData, int &rawLen, int &bytesRead ); #endif /* */ struct QWSProtocolItem { // ctor - dtor QWSProtocolItem( int t, int len, char *ptr ) : type( t ), simpleLen( len ), rawLen( -1 ), deleteRaw(FALSE), simpleDataPtr( ptr ), rawDataPtr( 0 ), bytesRead( 0 ) { } virtual ~QWSProtocolItem(); // data int type; int simpleLen; int rawLen; bool deleteRaw; // functions #ifndef QT_NO_QWS_MULTIPROCESS void write( QWSSocket *s ); bool read( QWSSocket *s ); #endif void copyFrom( const QWSProtocolItem *item ); virtual void setData( char *data, int len, bool allocateMem = TRUE ); char *simpleDataPtr; char *rawDataPtr; // temp variables int bytesRead; }; struct QWSCommand : QWSProtocolItem { QWSCommand( int t, int len, char *ptr ) : QWSProtocolItem(t,len,ptr) {} enum Type { Unknown = 0, Create, Destroy, Region, RegionMove, RegionDestroy, SetProperty, AddProperty, RemoveProperty, GetProperty, SetSelectionOwner, ConvertSelection, RequestFocus, ChangeAltitude, DefineCursor, SelectCursor, GrabMouse, PlaySound, QCopRegisterChannel, QCopSend, RegionName, Identify, GrabKeyboard, RepaintRegion, SetMicroFocus, ResetIM }; static QWSCommand *factory( int type ); }; /* */ struct QWSIdentifyCommand : public QWSCommand { QWSIdentifyCommand() : QWSCommand( QWSCommand::Identify, sizeof( simpleData ), (char *)&simpleData ) {} void setData( char *d, int len, bool allocateMem ) { QWSCommand::setData( d, len, allocateMem ); id = QString((QChar*)d, simpleData.idLen/2); } void setId( const QString& i ) { id = i; int l = simpleData.idLen = id.length()*2; QByteArray ba(l); char *d = ba.data(); memcpy( d, id.unicode(), simpleData.idLen ); setData( d, l, TRUE ); } struct SimpleData { int idLen; } simpleData; QString id; }; struct QWSCreateCommand : public QWSCommand { QWSCreateCommand() : QWSCommand( QWSCommand::Create, 0, 0 ) {} }; struct QWSRegionNameCommand : public QWSCommand { QWSRegionNameCommand() : QWSCommand( QWSCommand::RegionName, sizeof( simpleData ), (char *)&simpleData ) {} void setData( char *d, int len, bool allocateMem ) { QWSCommand::setData( d, len, allocateMem ); name = QString((QChar*)d, simpleData.nameLen/2); d += simpleData.nameLen; caption = QString((QChar*)d, simpleData.captionLen/2); } void setName( const QString& n, const QString &c ) { name = n; caption = c; int l = simpleData.nameLen = name.length()*2; l += simpleData.captionLen = caption.length()*2; QByteArray ba(l); char *d = ba.data(); memcpy( d, name.unicode(), simpleData.nameLen ); memcpy( d+simpleData.nameLen, caption.unicode(), simpleData.captionLen ); setData( d, l, TRUE ); } struct SimpleData { int windowid; int nameLen; int captionLen; } simpleData; QString name; QString caption; }; struct QWSRegionCommand : public QWSCommand { QWSRegionCommand() : QWSCommand( QWSCommand::Region, sizeof( simpleData ), (char*)&simpleData ) {} void setData( char *d, int len, bool allocateMem = TRUE ) { QWSCommand::setData( d, len, allocateMem ); rectangles = (QRect*)rawDataPtr; } struct SimpleData { int windowid; int nrectangles; } simpleData; QRect *rectangles; }; struct QWSRegionMoveCommand : public QWSCommand { QWSRegionMoveCommand() : QWSCommand( QWSCommand::RegionMove, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid; int dx; int dy; } simpleData; }; struct QWSRegionDestroyCommand : public QWSCommand { QWSRegionDestroyCommand() : QWSCommand( QWSCommand::RegionDestroy, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid; } simpleData; }; struct QWSRequestFocusCommand : public QWSCommand { QWSRequestFocusCommand() : QWSCommand( QWSCommand::RequestFocus, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid; int flag; } simpleData; }; struct QWSChangeAltitudeCommand : public QWSCommand { QWSChangeAltitudeCommand() : QWSCommand( QWSCommand::ChangeAltitude, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid; int altitude; bool fixed; } simpleData; }; struct QWSAddPropertyCommand : public QWSCommand { QWSAddPropertyCommand() : QWSCommand( QWSCommand::AddProperty, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid, property; } simpleData; }; struct QWSSetPropertyCommand : public QWSCommand { QWSSetPropertyCommand() : QWSCommand( QWSCommand::SetProperty, sizeof( simpleData ), (char*)&simpleData ) { data = 0; } void setData( char *d, int len, bool allocateMem = TRUE ) { QWSCommand::setData( d, len, allocateMem ); data = rawDataPtr; } struct SimpleData { int windowid, property, mode; } simpleData; char *data; }; struct QWSRepaintRegionCommand : public QWSCommand { QWSRepaintRegionCommand() : QWSCommand( QWSCommand::RepaintRegion, sizeof( simpleData ), (char*)&simpleData ) {} void setData( char *d, int len, bool allocateMem = TRUE ) { QWSCommand::setData( d, len, allocateMem ); rectangles = (QRect *)rawDataPtr; } struct SimpleData { int numrects; } simpleData; QRect * rectangles; }; struct QWSRemovePropertyCommand : public QWSCommand { QWSRemovePropertyCommand() : QWSCommand( QWSCommand::RemoveProperty, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid, property; } simpleData; }; struct QWSGetPropertyCommand : public QWSCommand { QWSGetPropertyCommand() : QWSCommand( QWSCommand::GetProperty, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid, property; } simpleData; }; struct QWSSetSelectionOwnerCommand : public QWSCommand { QWSSetSelectionOwnerCommand() : QWSCommand( QWSCommand::SetSelectionOwner, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int windowid; int hour, minute, sec, ms; // time } simpleData; }; struct QWSConvertSelectionCommand : public QWSCommand { QWSConvertSelectionCommand() : QWSCommand( QWSCommand::ConvertSelection, sizeof( simpleData ), (char*)&simpleData ) {} struct SimpleData { int requestor; // requestor window of the selection int selection; // property on requestor into which the selection should be stored int mimeTypes; // property ion requestor in which the mimetypes, in which the selection may be, are stored } simpleData; }; struct QWSDefineCursorCommand : public QWSCommand { QWSDefineCursorCommand() : QWSCommand( QWSCommand::DefineCursor, sizeof( simpleData ), (char *)&simpleData ) {} void setData( char *d, int len, bool allocateMem = TRUE ) { QWSCommand::setData( d, len, allocateMem ); data = (unsigned char *)rawDataPtr; } struct SimpleData { int width; int height; int hotX; int hotY; int id; } simpleData; unsigned char *data; }; struct QWSSelectCursorCommand : public QWSCommand { QWSSelectCursorCommand() : QWSCommand( QWSCommand::SelectCursor, sizeof( simpleData ), (char *)&simpleData ) {} struct SimpleData { int windowid; int id; } simpleData; }; struct QWSGrabMouseCommand : public QWSCommand { QWSGrabMouseCommand() : QWSCommand( QWSCommand::GrabMouse, sizeof( simpleData ), (char *)&simpleData ) {} struct SimpleData { int windowid; bool grab; // grab or ungrab? } simpleData; }; struct QWSGrabKeyboardCommand : public QWSCommand { QWSGrabKeyboardCommand() : QWSCommand( QWSCommand::GrabKeyboard, sizeof( simpleData ), (char *)&simpleData ) {} struct SimpleData { int windowid; bool grab; // grab or ungrab? } simpleData; }; #ifndef QT_NO_SOUND struct QWSPlaySoundCommand : public QWSCommand { QWSPlaySoundCommand() : QWSCommand( QWSCommand::PlaySound, sizeof( simpleData ), (char *)&simpleData ) {} void setData( char *d, int len, bool allocateMem ) { QWSCommand::setData( d, len, allocateMem ); filename = QString((QChar*)rawDataPtr,len/2); } void setFileName( const QString& n ) { setData( (char*)n.unicode(), n.length()*2, TRUE ); } struct SimpleData { int windowid; } simpleData; QString filename; }; #endif #ifndef QT_NO_COP struct QWSQCopRegisterChannelCommand : public QWSCommand { QWSQCopRegisterChannelCommand() : QWSCommand( QWSCommand::QCopRegisterChannel, sizeof( simpleData ), (char *)&simpleData ) {} void setData( char *d, int len, bool allocateMem ) { QWSCommand::setData( d, len, allocateMem ); channel = QCString( d, len ); } void setChannel( const QCString& n ) { setData( (char*)n.data(), n.length()+1, TRUE ); } struct SimpleData { bool unused; // we may need it } simpleData; QString channel; }; struct QWSQCopSendCommand : public QWSCommand { QWSQCopSendCommand() : QWSCommand( QWSCommand::QCopSend, sizeof( simpleData ), (char *)&simpleData ) {} void setData( char *d, int len, bool allocateMem ) { QWSCommand::setData( d, len, allocateMem ); channel = QCString( d, simpleData.clen + 1 ); d += simpleData.clen; message = QCString( d, simpleData.mlen + 1 ); d += simpleData.mlen; data.duplicate( d, simpleData.dlen ); } void setMessage( const QCString &c, const QCString &m, const QByteArray &data ) { int l = simpleData.clen = c.length(); l += simpleData.mlen = m.length(); l += simpleData.dlen = data.size(); QByteArray tmp( l ); char *d = tmp.data(); memcpy( d, c.data(), simpleData.clen ); d += simpleData.clen; memcpy( d, m.data(), simpleData.mlen ); d += simpleData.mlen; memcpy( d, data.data(), simpleData.dlen ); setData( (char*)tmp.data(), l, TRUE ); } struct SimpleData { int clen; int mlen; int dlen; } simpleData; QCString channel; QCString message; QByteArray data; }; #endif #ifndef QT_NO_QWS_IM struct QWSSetMicroFocusCommand : public QWSCommand { QWSSetMicroFocusCommand() : QWSCommand( QWSCommand::SetMicroFocus, sizeof( simpleData ), (char *)&simpleData ) {} struct SimpleData { int windowid; int x; int y; //bool textInput; } simpleData; //XXX Font??? }; struct QWSResetIMCommand : public QWSCommand { QWSResetIMCommand() : QWSCommand( QWSCommand::ResetIM, sizeof( simpleData ), (char *)&simpleData ) {} struct SimpleData { int windowid; } simpleData; }; #endif #endif // QWSCOMMAND_QWS_H qwsutils_qws.h/* */ #ifndef QWSUTILS_QWS_H #define QWSUTILS_QWS_H #ifndef QT_H #include "qwssocket_qws.h" #endif // QT_H /* */ #ifndef QT_NO_QWS_MULTIPROCESS inline int qws_read_uint( QWSSocket *socket ) { if ( !socket || socket->size() < sizeof( int ) ) return -1; int i; socket->readBlock( (char*)&i, sizeof( i ) ); return i; } inline void qws_write_uint( QWSSocket *socket, int i ) { if ( !socket ) return; socket->writeBlock( (char*)&i, sizeof( i ) ); } #endif // QT_NO_QWS_MULTIPROCESS #endif // QWSUTILS_QWS_H qxml.h?/* */ #ifndef QXML_H #define QXML_H #ifndef QT_H #include "qtextstream.h" #include "qfile.h" #include "qstring.h" #include "qstringlist.h" #include "qvaluevector.h" #endif // QT_H #if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML ) #define QM_EXPORT_XML #else #define QM_EXPORT_XML Q_EXPORT #endif #ifndef QT_NO_XML class QXmlNamespaceSupport; class QXmlAttributes; class QXmlContentHandler; class QXmlDefaultHandler; class QXmlDTDHandler; class QXmlEntityResolver; class QXmlErrorHandler; class QXmlLexicalHandler; class QXmlDeclHandler; class QXmlInputSource; class QXmlLocator; class QXmlNamespaceSupport; class QXmlParseException; class QXmlReader; class QXmlSimpleReader; class QXmlSimpleReaderPrivate; class QXmlNamespaceSupportPrivate; class QXmlAttributesPrivate; class QXmlInputSourcePrivate; class QXmlParseExceptionPrivate; class QXmlLocatorPrivate; class QXmlDefaultHandlerPrivate; // // SAX Namespace Support // class QM_EXPORT_XML QXmlNamespaceSupport { public: QXmlNamespaceSupport(); ~QXmlNamespaceSupport(); void setPrefix( const QString&, const QString& ); QString prefix( const QString& ) const; QString uri( const QString& ) const; void splitName( const QString&, QString&, QString& ) const; void processName( const QString&, bool, QString&, QString& ) const; QStringList prefixes() const; QStringList prefixes( const QString& ) const; void pushContext(); void popContext(); void reset(); private: QXmlNamespaceSupportPrivate *d; friend class QXmlSimpleReader; }; // // SAX Attributes // class QM_EXPORT_XML QXmlAttributes { public: QXmlAttributes() {} virtual ~QXmlAttributes() {} int index( const QString& qName ) const; int index( const QString& uri, const QString& localPart ) const; int length() const; int count() const; QString localName( int index ) const; QString qName( int index ) const; QString uri( int index ) const; QString type( int index ) const; QString type( const QString& qName ) const; QString type( const QString& uri, const QString& localName ) const; QString value( int index ) const; QString value( const QString& qName ) const; QString value( const QString& uri, const QString& localName ) const; void clear(); void append( const QString &qName, const QString &uri, const QString &localPart, const QString &value ); private: QStringList qnameList; QStringList uriList; QStringList localnameList; QStringList valueList; QXmlAttributesPrivate *d; }; // // SAX Input Source // class QM_EXPORT_XML QXmlInputSource { public: QXmlInputSource(); QXmlInputSource( QIODevice *dev ); QXmlInputSource( QFile& file ); // obsolete QXmlInputSource( QTextStream& stream ); // obsolete virtual ~QXmlInputSource(); virtual void setData( const QString& dat ); virtual void setData( const QByteArray& dat ); virtual void fetchData(); virtual QString data(); virtual QChar next(); virtual void reset(); static const QChar EndOfData; static const QChar EndOfDocument; protected: virtual QString fromRawData( const QByteArray &data, bool beginning = FALSE ); private: void init(); QIODevice *inputDevice; QTextStream *inputStream; QString str; const QChar *unicode; int pos; int length; bool nextReturnedEndOfData; QTextDecoder *encMapper; QXmlInputSourcePrivate *d; }; // // SAX Exception Classes // class QM_EXPORT_XML QXmlParseException { public: QXmlParseException( const QString& name="", int c=-1, int l=-1, const QString& p="", const QString& s="" ) : msg( name ), column( c ), line( l ), pub( p ), sys( s ) { } int columnNumber() const; int lineNumber() const; QString publicId() const; QString systemId() const; QString message() const; private: QString msg; int column; int line; QString pub; QString sys; QXmlParseExceptionPrivate *d; }; // // XML Reader // class QM_EXPORT_XML QXmlReader { public: virtual bool feature( const QString& name, bool *ok = 0 ) const = 0; virtual void setFeature( const QString& name, bool value ) = 0; virtual bool hasFeature( const QString& name ) const = 0; virtual void* property( const QString& name, bool *ok = 0 ) const = 0; virtual void setProperty( const QString& name, void* value ) = 0; virtual bool hasProperty( const QString& name ) const = 0; virtual void setEntityResolver( QXmlEntityResolver* handler ) = 0; virtual QXmlEntityResolver* entityResolver() const = 0; virtual void setDTDHandler( QXmlDTDHandler* handler ) = 0; virtual QXmlDTDHandler* DTDHandler() const = 0; virtual void setContentHandler( QXmlContentHandler* handler ) = 0; virtual QXmlContentHandler* contentHandler() const = 0; virtual void setErrorHandler( QXmlErrorHandler* handler ) = 0; virtual QXmlErrorHandler* errorHandler() const = 0; virtual void setLexicalHandler( QXmlLexicalHandler* handler ) = 0; virtual QXmlLexicalHandler* lexicalHandler() const = 0; virtual void setDeclHandler( QXmlDeclHandler* handler ) = 0; virtual QXmlDeclHandler* declHandler() const = 0; virtual bool parse( const QXmlInputSource& input ) = 0; virtual bool parse( const QXmlInputSource* input ) = 0; }; class QM_EXPORT_XML QXmlSimpleReader : public QXmlReader { public: QXmlSimpleReader(); virtual ~QXmlSimpleReader(); bool feature( const QString& name, bool *ok = 0 ) const; void setFeature( const QString& name, bool value ); bool hasFeature( const QString& name ) const; void* property( const QString& name, bool *ok = 0 ) const; void setProperty( const QString& name, void* value ); bool hasProperty( const QString& name ) const; void setEntityResolver( QXmlEntityResolver* handler ); QXmlEntityResolver* entityResolver() const; void setDTDHandler( QXmlDTDHandler* handler ); QXmlDTDHandler* DTDHandler() const; void setContentHandler( QXmlContentHandler* handler ); QXmlContentHandler* contentHandler() const; void setErrorHandler( QXmlErrorHandler* handler ); QXmlErrorHandler* errorHandler() const; void setLexicalHandler( QXmlLexicalHandler* handler ); QXmlLexicalHandler* lexicalHandler() const; void setDeclHandler( QXmlDeclHandler* handler ); QXmlDeclHandler* declHandler() const; bool parse( const QXmlInputSource& input ); bool parse( const QXmlInputSource* input ); virtual bool parse( const QXmlInputSource* input, bool incremental ); virtual bool parseContinue(); private: // variables QXmlContentHandler *contentHnd; QXmlErrorHandler *errorHnd; QXmlDTDHandler *dtdHnd; QXmlEntityResolver *entityRes; QXmlLexicalHandler *lexicalHnd; QXmlDeclHandler *declHnd; QXmlInputSource *inputSource; QChar c; // the character at reading position int lineNr; // number of line int columnNr; // position in line int nameArrayPos; QChar nameArray[256]; // only used for names QString nameValue; // only used for names int refArrayPos; QChar refArray[256]; // only used for references QString refValue; // only used for references int stringArrayPos; QChar stringArray[256]; // used for any other strings that are parsed QString stringValue; // used for any other strings that are parsed QXmlSimpleReaderPrivate* d; const QString &string(); void stringClear(); inline void stringAddC() { stringAddC(c); } void stringAddC(const QChar&); const QString& name(); void nameClear(); inline void nameAddC() { nameAddC(c); } void nameAddC(const QChar&); const QString& ref(); void refClear(); inline void refAddC() { refAddC(c); } void refAddC(const QChar&); // used by parseReference() and parsePEReference() enum EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD }; // private functions bool eat_ws(); bool next_eat_ws(); void next(); bool atEnd(); void init( const QXmlInputSource* i ); void initData(); bool entityExist( const QString& ) const; bool parseBeginOrContinue( int state, bool incremental ); bool parseProlog(); bool parseElement(); bool processElementEmptyTag(); bool processElementETagBegin2(); bool processElementAttribute(); bool parseMisc(); bool parseContent(); bool parsePI(); bool parseDoctype(); bool parseComment(); bool parseName(); bool parseNmtoken(); bool parseAttribute(); bool parseReference(); bool processReference(); bool parseExternalID(); bool parsePEReference(); bool parseMarkupdecl(); bool parseAttlistDecl(); bool parseAttType(); bool parseAttValue(); bool parseElementDecl(); bool parseNotationDecl(); bool parseChoiceSeq(); bool parseEntityDecl(); bool parseEntityValue(); bool parseString(); bool insertXmlRef( const QString&, const QString&, bool ); bool reportEndEntities(); void reportParseError( const QString& error ); typedef bool (QXmlSimpleReader::*ParseFunction) (); void unexpectedEof( ParseFunction where, int state ); void parseFailed( ParseFunction where, int state ); void pushParseState( ParseFunction function, int state ); void setUndefEntityInAttrHack(bool b); friend class QXmlSimpleReaderPrivate; friend class QXmlSimpleReaderLocator; friend class QDomDocumentPrivate; }; // // SAX Locator // class QM_EXPORT_XML QXmlLocator { public: QXmlLocator(); virtual ~QXmlLocator(); virtual int columnNumber() = 0; virtual int lineNumber() = 0; // QString getPublicId() // QString getSystemId() }; // // SAX handler classes // class QM_EXPORT_XML QXmlContentHandler { public: virtual void setDocumentLocator( QXmlLocator* locator ) = 0; virtual bool startDocument() = 0; virtual bool endDocument() = 0; virtual bool startPrefixMapping( const QString& prefix, const QString& uri ) = 0; virtual bool endPrefixMapping( const QString& prefix ) = 0; virtual bool startElement( const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts ) = 0; virtual bool endElement( const QString& namespaceURI, const QString& localName, const QString& qName ) = 0; virtual bool characters( const QString& ch ) = 0; virtual bool ignorableWhitespace( const QString& ch ) = 0; virtual bool processingInstruction( const QString& target, const QString& data ) = 0; virtual bool skippedEntity( const QString& name ) = 0; virtual QString errorString() = 0; }; class QM_EXPORT_XML QXmlErrorHandler { public: virtual bool warning( const QXmlParseException& exception ) = 0; virtual bool error( const QXmlParseException& exception ) = 0; virtual bool fatalError( const QXmlParseException& exception ) = 0; virtual QString errorString() = 0; }; class QM_EXPORT_XML QXmlDTDHandler { public: virtual bool notationDecl( const QString& name, const QString& publicId, const QString& systemId ) = 0; virtual bool unparsedEntityDecl( const QString& name, const QString& publicId, const QString& systemId, const QString& notationName ) = 0; virtual QString errorString() = 0; }; class QM_EXPORT_XML QXmlEntityResolver { public: virtual bool resolveEntity( const QString& publicId, const QString& systemId, QXmlInputSource*& ret ) = 0; virtual QString errorString() = 0; }; class QM_EXPORT_XML QXmlLexicalHandler { public: virtual bool startDTD( const QString& name, const QString& publicId, const QString& systemId ) = 0; virtual bool endDTD() = 0; virtual bool startEntity( const QString& name ) = 0; virtual bool endEntity( const QString& name ) = 0; virtual bool startCDATA() = 0; virtual bool endCDATA() = 0; virtual bool comment( const QString& ch ) = 0; virtual QString errorString() = 0; }; class QM_EXPORT_XML QXmlDeclHandler { public: virtual bool attributeDecl( const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value ) = 0; virtual bool internalEntityDecl( const QString& name, const QString& value ) = 0; virtual bool externalEntityDecl( const QString& name, const QString& publicId, const QString& systemId ) = 0; virtual QString errorString() = 0; }; class QM_EXPORT_XML QXmlDefaultHandler : public QXmlContentHandler, public QXmlErrorHandler, public QXmlDTDHandler, public QXmlEntityResolver, public QXmlLexicalHandler, public QXmlDeclHandler { public: QXmlDefaultHandler() { } virtual ~QXmlDefaultHandler() { } void setDocumentLocator( QXmlLocator* locator ); bool startDocument(); bool endDocument(); bool startPrefixMapping( const QString& prefix, const QString& uri ); bool endPrefixMapping( const QString& prefix ); bool startElement( const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts ); bool endElement( const QString& namespaceURI, const QString& localName, const QString& qName ); bool characters( const QString& ch ); bool ignorableWhitespace( const QString& ch ); bool processingInstruction( const QString& target, const QString& data ); bool skippedEntity( const QString& name ); bool warning( const QXmlParseException& exception ); bool error( const QXmlParseException& exception ); bool fatalError( const QXmlParseException& exception ); bool notationDecl( const QString& name, const QString& publicId, const QString& systemId ); bool unparsedEntityDecl( const QString& name, const QString& publicId, const QString& systemId, const QString& notationName ); bool resolveEntity( const QString& publicId, const QString& systemId, QXmlInputSource*& ret ); bool startDTD( const QString& name, const QString& publicId, const QString& systemId ); bool endDTD(); bool startEntity( const QString& name ); bool endEntity( const QString& name ); bool startCDATA(); bool endCDATA(); bool comment( const QString& ch ); bool attributeDecl( const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value ); bool internalEntityDecl( const QString& name, const QString& value ); bool externalEntityDecl( const QString& name, const QString& publicId, const QString& systemId ); QString errorString(); private: QXmlDefaultHandlerPrivate *d; }; // // inlines // inline bool QXmlSimpleReader::atEnd() { return (c.unicode()|0x0001) == 0xffff; } inline int QXmlAttributes::count() const { return length(); } #endif //QT_NO_XML #endif qvbox.h/* */ #ifndef QVBOX_H #define QVBOX_H #ifndef QT_H #include "qhbox.h" #endif // QT_H #ifndef QT_NO_VBOX class Q_EXPORT QVBox : public QHBox { Q_OBJECT public: QVBox( QWidget* parent=0, const char* name=0, WFlags f=0 ); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QVBox( const QVBox & ); QVBox& operator=( const QVBox & ); #endif }; #endif // QT_NO_VBOX #endif // QVBOX_H qutfcodec.h L/* */ #ifndef QUTFCODEC_H #define QUTFCODEC_H #ifndef QT_H #include "qtextcodec.h" #endif // QT_H #ifndef QT_NO_TEXTCODEC class Q_EXPORT QUtf8Codec : public QTextCodec { public: virtual int mibEnum() const; const char* name() const; QTextDecoder* makeDecoder() const; #if !defined(Q_NO_USING_KEYWORD) using QTextCodec::fromUnicode; #endif QCString fromUnicode(const QString& uc, int& lenInOut) const; QString toUnicode(const char* chars, int len) const; int heuristicContentMatch(const char* chars, int len) const; }; class Q_EXPORT QUtf16Codec : public QTextCodec { public: virtual int mibEnum() const; const char* name() const; QTextDecoder* makeDecoder() const; QTextEncoder* makeEncoder() const; int heuristicContentMatch(const char* chars, int len) const; }; #endif //QT_NO_TEXTCODEC #endif // QUTFCODEC_H qsqlerror.h i/* */ #ifndef QSQLERROR_H #define QSQLERROR_H #ifndef QT_H #include "qstring.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL class QM_EXPORT_SQL QSqlError { public: enum Type { None, Connection, Statement, Transaction, Unknown }; QSqlError( const QString& driverText = QString::null, const QString& databaseText = QString::null, int type = QSqlError::None, int number = -1 ); QSqlError( const QSqlError& other ); QSqlError& operator=( const QSqlError& other ); virtual ~QSqlError(); QString driverText() const; virtual void setDriverText( const QString& driverText ); QString databaseText() const; virtual void setDatabaseText( const QString& databaseText ); int type() const; virtual void setType( int type ); int number() const; virtual void setNumber( int number ); QString text() const; void showMessage( const QString& msg = QString::null ) const; private: QString driverError; QString databaseError; int errorType; int errorNumber; }; #endif // QT_NO_SQL #endif qsqlresult.h Z/* */ #ifndef QSQLRESULT_H #define QSQLRESULT_H #ifndef QT_H #include "qstring.h" #include "qvariant.h" #include "qsqlerror.h" #include "qsqlfield.h" #include "qsql.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL class QSqlDriver; class QSql; class QSqlResultPrivate; class QSqlExtension; class QM_EXPORT_SQL QSqlResult { friend class QSqlQuery; friend class QSqlResultShared; public: virtual ~QSqlResult(); // BCI HACK - remove in 4.0 void setExtension( QSqlExtension * ext ); QSqlExtension * extension(); protected: QSqlResult(const QSqlDriver * db ); int at() const; QString lastQuery() const; QSqlError lastError() const; bool isValid() const; bool isActive() const; bool isSelect() const; bool isForwardOnly() const; const QSqlDriver* driver() const; virtual void setAt( int at ); virtual void setActive( bool a ); virtual void setLastError( const QSqlError& e ); virtual void setQuery( const QString& query ); virtual void setSelect( bool s ); virtual void setForwardOnly( bool forward ); virtual QVariant data( int i ) = 0; virtual bool isNull( int i ) = 0; virtual bool reset ( const QString& sqlquery ) = 0; virtual bool fetch( int i ) = 0; virtual bool fetchNext(); virtual bool fetchPrev(); virtual bool fetchFirst() = 0; virtual bool fetchLast() = 0; virtual int size() = 0; virtual int numRowsAffected() = 0; private: QSqlResultPrivate* d; bool forwardOnly; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QSqlResult( const QSqlResult & ); QSqlResult &operator=( const QSqlResult & ); #endif }; #endif // QT_NO_SQL #endif qwsmanager_qws.h /* */ #ifndef QWSMANAGER_QWS_H #define QWSMANAGER_QWS_H #ifndef QT_H #include "qpixmap.h" #include "qobject.h" #include "qwsdecoration_qws.h" #endif // QT_H #ifndef QT_NO_QWS_MANAGER class QPixmap; class QWidget; class QPopupMenu; class QRegion; class QMouseEvent; class QWSButton; class QWSManager; class QWSManager : public QObject { Q_OBJECT public: QWSManager(QWidget *); ~QWSManager(); static QWSDecoration *newDefaultDecoration(); QRegion region(); QWidget *widget() { return managed; } void maximize(); static QWidget *grabbedMouse() { return active; } protected slots: void menuActivated(int); void styleMenuActivated(int); protected: void handleMove(); virtual QWSDecoration::Region pointInRegion(const QPoint &); virtual bool event(QEvent *e); virtual void mouseMoveEvent(QMouseEvent *); virtual void mousePressEvent(QMouseEvent *); virtual void mouseReleaseEvent(QMouseEvent *); virtual void mouseDoubleClickEvent(QMouseEvent *) {} virtual void paintEvent(QPaintEvent *); void menu(const QPoint &); void close(); void minimize(); void toggleMaximize(); QWSDecoration::Region activeRegion; QWidget *managed; QPopupMenu *popup; QRect normalSize; QWSButton *menuBtn; QWSButton *closeBtn; QWSButton *minimizeBtn; QWSButton *maximizeBtn; int dx; int dy; int skipCount; static QWidget *active; static QPoint mousePos; private: friend class QWidget; inline void releaseGrab() { active = 0; activeRegion = QWSDecoration::None; } }; class QWSButton { public: QWSButton(QWSManager *m, QWSDecoration::Region t, bool tb = false); enum State { MouseOver = 0x01, Clicked = 0x02, On = 0x04 }; int state() { return flags; } void setMouseOver(bool); void setClicked(bool); void setOn(bool); protected: void paint(); private: int flags; bool toggle; QWSDecoration::Region type; QWSManager *manager; }; // class QWSDefaultDecoration : public QWSDecoration; #include "qwsdefaultdecoration_qws.h" #endif // QT_NO_QWS_MANAGER #endif // QWSMANAGER_QWS_H qtextview.h /* */ #ifndef QTEXTVIEW_H #define QTEXTVIEW_H #ifndef QT_H #include "qtextedit.h" #endif // QT_H #ifndef QT_NO_TEXTVIEW class Q_EXPORT QTextView : public QTextEdit { Q_OBJECT Q_OVERRIDE( int undoDepth DESIGNABLE false SCRIPTABLE false ) Q_OVERRIDE( bool overwriteMode DESIGNABLE false SCRIPTABLE false ) Q_OVERRIDE( bool modified SCRIPTABLE false) Q_OVERRIDE( bool readOnly DESIGNABLE false SCRIPTABLE false ) Q_OVERRIDE( bool undoRedoEnabled DESIGNABLE false SCRIPTABLE false ) public: QTextView( const QString& text, const QString& context = QString::null, QWidget* parent=0, const char* name=0); QTextView( QWidget* parent=0, const char* name=0 ); virtual ~QTextView(); private: #if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator= QTextView( const QTextView & ); QTextView &operator=( const QTextView & ); #endif }; #endif //QT_NO_TEXTVIEW #endif //QTEXTVIEW_H qwsmouse_qnx4.hd/* */ #ifndef QWSMOUSE_QNX4_H #define QWSMOUSE_QNX4_H #ifndef QT_H #include "qwindowsystem_qws.h" #endif // QT_H #ifdef Q_OS_QNX4 #include "qwsevent_qws.h" #include "qwscommand_qws.h" #include "qwsutils_qws.h" #include "qwsmouse_qws.h" #include #include #include #ifndef QQNX4MOUSEHANDLERPRIVATEIMPL #define QQNX4MOUSEHANDLERPRIVATEIMPL struct mouse_event; class QQnx4MouseHandlerPrivate : public QWSMouseHandler { Q_OBJECT public: QQnx4MouseHandlerPrivate(MouseProtocol &, QString); ~QQnx4MouseHandlerPrivate(); void clearCalibration(); void calibrate(); void getCalibration( QWSPointerCalibrationData * ); private: QSocketNotifier *mouseNotifier; int mouseFD, read_in; mouse_event *mpack; private slots: void readMouseData(int); }; #endif #endif #endif // QWSMOUSE_QNX4_H qtooltip.hO/* */ #ifndef QTOOLTIP_H #define QTOOLTIP_H #ifndef QT_H #include "qwidget.h" #endif // QT_H #ifndef QT_NO_TOOLTIP class QTipManager; class QIconViewToolTip; class QListViewToolTip; class Q_EXPORT QToolTipGroup: public QObject { Q_OBJECT Q_PROPERTY( bool delay READ delay WRITE setDelay ) Q_PROPERTY( bool enabled READ enabled WRITE setEnabled ) public: QToolTipGroup( QObject *parent, const char *name = 0 ); ~QToolTipGroup(); bool delay() const; bool enabled() const; public slots: void setDelay( bool ); void setEnabled( bool ); signals: void showTip( const QString &); void removeTip(); private: uint del:1; uint ena:1; friend class QTipManager; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QToolTipGroup( const QToolTipGroup & ); QToolTipGroup& operator=( const QToolTipGroup & ); #endif }; class Q_EXPORT QToolTip: public Qt { public: QToolTip( QWidget *, QToolTipGroup * = 0 ); //### add virtual d'tor for 4.0 static void add( QWidget *, const QString &); static void add( QWidget *, const QString &, QToolTipGroup *, const QString& ); static void remove( QWidget * ); static void add( QWidget *, const QRect &, const QString &); static void add( QWidget *, const QRect &, const QString &, QToolTipGroup *, const QString& ); static void remove( QWidget *, const QRect & ); static QString textFor( QWidget *, const QPoint & pos = QPoint() ); static void hide(); static QFont font(); static void setFont( const QFont & ); static QPalette palette(); static void setPalette( const QPalette & ); #ifndef QT_NO_COMPAT static void setEnabled( bool enable ) { setGloballyEnabled( enable ); } static bool enabled() { return isGloballyEnabled(); } #endif static void setGloballyEnabled( bool ); static bool isGloballyEnabled(); static void setWakeUpDelay(int); protected: virtual void maybeTip( const QPoint & ) = 0; void tip( const QRect &, const QString &); void tip( const QRect &, const QString& , const QString &); void tip( const QRect &, const QString &, const QRect & ); void tip( const QRect &, const QString&, const QString &, const QRect &); void clear(); public: QWidget *parentWidget() const { return p; } QToolTipGroup *group() const { return g; } private: QWidget *p; QToolTipGroup *g; static QFont *ttFont; static QPalette *ttPalette; friend class QTipManager; }; #endif // QT_NO_TOOLTIP #endif // QTOOLTIP_H qvaluestack.h/* */ #ifndef QVALUESTACK_H #define QVALUESTACK_H #ifndef QT_H #include "qvaluelist.h" #endif // QT_H template class QValueStack : public QValueList { public: QValueStack() {} ~QValueStack() {} void push( const T& d ) { this->append(d); } T pop() { T elem( this->last() ); if ( !this->isEmpty() ) this->remove( this->fromLast() ); return elem; } T& top() { return this->last(); } const T& top() const { return this->last(); } }; #endif qsqldriver.h/* */ #ifndef QSQLDRIVER_H #define QSQLDRIVER_H #ifndef QT_H #include "qobject.h" #include "qptrdict.h" #include "qstring.h" #include "qsqlerror.h" #include "qsqlquery.h" #include "qsqlfield.h" #include "qsqlindex.h" #include "qstringlist.h" #include "qmap.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL class QSqlDriverExtension; class QSqlDatabase; class QM_EXPORT_SQL QSqlDriver : public QObject { friend class QSqlDatabase; Q_OBJECT public: enum DriverFeature { Transactions, QuerySize, BLOB, Unicode, PreparedQueries, NamedPlaceholders, PositionalPlaceholders }; QSqlDriver( QObject * parent=0, const char * name=0 ); ~QSqlDriver(); bool isOpen() const; bool isOpenError() const; virtual bool beginTransaction(); virtual bool commitTransaction(); virtual bool rollbackTransaction(); virtual QStringList tables( const QString& tableType ) const; virtual QSqlIndex primaryIndex( const QString& tableName ) const; virtual QSqlRecord record( const QString& tableName ) const; virtual QSqlRecord record( const QSqlQuery& query ) const; virtual QSqlRecordInfo recordInfo( const QString& tablename ) const; virtual QSqlRecordInfo recordInfo( const QSqlQuery& query ) const; virtual QString nullText() const; virtual QString formatValue( const QSqlField* field, bool trimStrings = FALSE ) const; QSqlError lastError() const; virtual bool hasFeature( DriverFeature f ) const = 0; virtual bool open( const QString & db, const QString & user = QString::null, const QString & password = QString::null, const QString & host = QString::null, int port = -1 ) = 0; virtual void close() = 0; virtual QSqlQuery createQuery() const = 0; // ### remove for 4.0 bool open( const QString& db, const QString& user, const QString& password, const QString& host, int port, const QString& connOpts ); protected: virtual void setOpen( bool o ); virtual void setOpenError( bool e ); virtual void setLastError( const QSqlError& e ); private: // ### This class needs a d-pointer in 4.0. int dbState; QSqlError error; #if defined(Q_DISABLE_COPY) QSqlDriver( const QSqlDriver & ); QSqlDriver &operator=( const QSqlDriver & ); #endif }; #endif // QT_NO_SQL #endif qtl.h/* */ #ifndef QTL_H #define QTL_H #ifndef QT_H #include "qglobal.h" #include "qtextstream.h" #include "qstring.h" #endif // QT_H #ifndef QT_NO_TEXTSTREAM template class QTextOStreamIterator { protected: QTextOStream& stream; QString separator; public: QTextOStreamIterator( QTextOStream& s) : stream( s ) {} QTextOStreamIterator( QTextOStream& s, const QString& sep ) : stream( s ), separator( sep ) {} QTextOStreamIterator& operator= ( const T& x ) { stream << x; if ( !separator.isEmpty() ) stream << separator; return *this; } QTextOStreamIterator& operator*() { return *this; } QTextOStreamIterator& operator++() { return *this; } QTextOStreamIterator& operator++(int) { return *this; } }; #endif //QT_NO_TEXTSTREAM template inline OutputIterator qCopy( InputIterator _begin, InputIterator _end, OutputIterator _dest ) { while( _begin != _end ) *_dest++ = *_begin++; return _dest; } template inline BiOutputIterator qCopyBackward( BiIterator _begin, BiIterator _end, BiOutputIterator _dest ) { while ( _begin != _end ) *--_dest = *--_end; return _dest; } template inline bool qEqual( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 ) { // ### compare using !(*first1 == *first2) in Qt 4.0 for ( ; first1 != last1; ++first1, ++first2 ) if ( *first1 != *first2 ) return FALSE; return TRUE; } template inline void qFill( ForwardIterator first, ForwardIterator last, const T& val ) { for ( ; first != last; ++first ) *first = val; } #if 0 template inline OutputIterator qReverseCopy( BiIterator _begin, BiIterator _end, OutputIterator _dest ) { while ( _begin != _end ) { --_end; *_dest = *_end; ++_dest; } return _dest; } #endif template inline InputIterator qFind( InputIterator first, InputIterator last, const T& val ) { while ( first != last && *first != val ) ++first; return first; } template inline void qCount( InputIterator first, InputIterator last, const T& value, Size& n ) { for ( ; first != last; ++first ) if ( *first == value ) ++n; } template inline void qSwap( T& _value1, T& _value2 ) { T tmp = _value1; _value1 = _value2; _value2 = tmp; } template Q_INLINE_TEMPLATES void qBubbleSort( InputIterator b, InputIterator e ) { // Goto last element; InputIterator last = e; --last; // only one element or no elements ? if ( last == b ) return; // So we have at least two elements in here while( b != last ) { bool swapped = FALSE; InputIterator swap_pos = b; InputIterator x = e; InputIterator y = x; y--; do { --x; --y; if ( *x < *y ) { swapped = TRUE; qSwap( *x, *y ); swap_pos = y; } } while( y != b ); if ( !swapped ) return; b = swap_pos; b++; } } template inline void qBubbleSort( Container &c ) { qBubbleSort( c.begin(), c.end() ); } template Q_INLINE_TEMPLATES void qHeapSortPushDown( Value* heap, int first, int last ) { int r = first; while ( r <= last / 2 ) { if ( last == 2 * r ) { // node r has only one child if ( heap[2 * r] < heap[r] ) qSwap( heap[r], heap[2 * r] ); r = last; } else { // node r has two children if ( heap[2 * r] < heap[r] && !(heap[2 * r + 1] < heap[2 * r]) ) { // swap with left child qSwap( heap[r], heap[2 * r] ); r *= 2; } else if ( heap[2 * r + 1] < heap[r] && heap[2 * r + 1] < heap[2 * r] ) { // swap with right child qSwap( heap[r], heap[2 * r + 1] ); r = 2 * r + 1; } else { r = last; } } } } template Q_INLINE_TEMPLATES void qHeapSortHelper( InputIterator b, InputIterator e, Value, uint n ) { // Create the heap InputIterator insert = b; Value* realheap = new Value[n]; // Wow, what a fake. But I want the heap to be indexed as 1...n Value* heap = realheap - 1; int size = 0; for( ; insert != e; ++insert ) { heap[++size] = *insert; int i = size; while( i > 1 && heap[i] < heap[i / 2] ) { qSwap( heap[i], heap[i / 2] ); i /= 2; } } // Now do the sorting for( uint i = n; i > 0; i-- ) { *b++ = heap[1]; if ( i > 1 ) { heap[1] = heap[i]; qHeapSortPushDown( heap, 1, (int)i - 1 ); } } delete[] realheap; } template Q_INLINE_TEMPLATES void qHeapSort( InputIterator b, InputIterator e ) { // Empty ? if ( b == e ) return; // How many entries have to be sorted ? InputIterator it = b; uint n = 0; while ( it != e ) { ++n; ++it; } // The second last parameter is a hack to retrieve the value type // Do the real sorting here qHeapSortHelper( b, e, *b, n ); } template Q_INLINE_TEMPLATES void qHeapSort( Container &c ) { if ( c.begin() == c.end() ) return; // The second last parameter is a hack to retrieve the value type // Do the real sorting here qHeapSortHelper( c.begin(), c.end(), *(c.begin()), (uint)c.count() ); } template class QBackInsertIterator { public: Q_EXPLICIT QBackInsertIterator( Container &c ) : container( &c ) { } QBackInsertIterator& operator=( const Q_TYPENAME Container::value_type &value ) { container->push_back( value ); return *this; } QBackInsertIterator& operator*() { return *this; } QBackInsertIterator& operator++() { return *this; } QBackInsertIterator& operator++(int) { return *this; } protected: Container *container; }; template inline QBackInsertIterator qBackInserter( Container &c ) { return QBackInsertIterator( c ); } #endif qtranslator.hO/* */ #ifndef QTRANSLATOR_H #define QTRANSLATOR_H #ifndef QT_H #include "qobject.h" #include "qvaluelist.h" #endif // QT_H #ifndef QT_NO_TRANSLATION class QTranslatorPrivate; class Q_EXPORT QTranslatorMessage { public: QTranslatorMessage(); QTranslatorMessage( const char * context, const char * sourceText, const char * comment, const QString& translation = QString::null ); QTranslatorMessage( QDataStream & ); QTranslatorMessage( const QTranslatorMessage & m ); QTranslatorMessage & operator=( const QTranslatorMessage & m ); uint hash() const { return h; } const char *context() const { return cx; } const char *sourceText() const { return st; } const char *comment() const { return cm; } void setTranslation( const QString & translation ) { tn = translation; } QString translation() const { return tn; } enum Prefix { NoPrefix, Hash, HashContext, HashContextSourceText, HashContextSourceTextComment }; void write( QDataStream & s, bool strip = FALSE, Prefix prefix = HashContextSourceTextComment ) const; Prefix commonPrefix( const QTranslatorMessage& ) const; bool operator==( const QTranslatorMessage& m ) const; bool operator!=( const QTranslatorMessage& m ) const { return !operator==( m ); } bool operator<( const QTranslatorMessage& m ) const; bool operator<=( const QTranslatorMessage& m ) const { return !m.operator<( *this ); } bool operator>( const QTranslatorMessage& m ) const { return m.operator<( *this ); } bool operator>=( const QTranslatorMessage& m ) const { return !operator<( m ); } private: uint h; QCString cx; QCString st; QCString cm; QString tn; enum Tag { Tag_End = 1, Tag_SourceText16, Tag_Translation, Tag_Context16, Tag_Hash, Tag_SourceText, Tag_Context, Tag_Comment, Tag_Obsolete1 }; }; class Q_EXPORT QTranslator: public QObject { Q_OBJECT public: QTranslator( QObject * parent = 0, const char * name = 0 ); ~QTranslator(); #ifndef QT_NO_COMPAT QString find( const char *context, const char *sourceText, const char * comment = 0 ) const { return findMessage( context, sourceText, comment ).translation(); } #endif virtual QTranslatorMessage findMessage( const char *, const char *, const char * = 0 ) const; bool load( const QString & filename, const QString & directory = QString::null, const QString & search_delimiters = QString::null, const QString & suffix = QString::null ); bool load( const uchar *data, int len ) { clear(); return do_load( data, len ); } void clear(); #ifndef QT_NO_TRANSLATION_BUILDER enum SaveMode { Everything, Stripped }; bool save( const QString & filename, SaveMode mode = Everything ); void insert( const QTranslatorMessage& ); void insert( const char *context, const char *sourceText, const QString &translation ) { insert( QTranslatorMessage(context, sourceText, "", translation) ); } void remove( const QTranslatorMessage& ); void remove( const char *context, const char *sourceText ) { remove( QTranslatorMessage(context, sourceText, "") ); } bool contains( const char *, const char *, const char * comment = 0 ) const; void squeeze( SaveMode = Everything ); void unsqueeze(); QValueList messages() const; #endif bool isEmpty() const; private: #if defined(Q_DISABLE_COPY) QTranslator( const QTranslator & ); QTranslator &operator=( const QTranslator & ); #endif bool do_load( const uchar *data, int len ); QTranslatorPrivate * d; }; #endif // QT_NO_TRANSLATION #endif qwidgetlist.h/* */ #ifndef QWIDGETLIST_H #define QWIDGETLIST_H #ifndef QT_H #include "qwidget.h" #include "qptrlist.h" #endif // QT_H class Q_EXPORT QWidgetList : public QPtrList { public: QWidgetList() : QPtrList() {} QWidgetList( const QWidgetList &list ) : QPtrList(list) {} ~QWidgetList() { clear(); } QWidgetList &operator=(const QWidgetList &list) { return (QWidgetList&)QPtrList::operator=(list); } }; class Q_EXPORT QWidgetListIt : public QPtrListIterator { public: QWidgetListIt( const QWidgetList &l ) : QPtrListIterator(l) {} QWidgetListIt &operator=(const QWidgetListIt &i) { return (QWidgetListIt&)QPtrListIterator::operator=(i); } }; #endif // QWIDGETLIST_H qwscursor_qws.h /* */ #ifndef QWSCURSOR_QWS_H #define QWSCURSOR_QWS_H #ifndef QT_H #include "qimage.h" #endif // QT_H class QWSCursor : public Qt { public: QWSCursor() {} QWSCursor(const uchar *data, const uchar *mask, int width, int height, int hotX, int hotY) { set(data, mask, width, height, hotX, hotY); } void set(const uchar *data, const uchar *mask, int width, int height, int hotX, int hotY); QPoint hotSpot() const { return hot; } QImage &image() { return cursor; } const QRegion region() const { return rgn; } static QWSCursor *systemCursor(int id); private: static void createSystemCursor( int id ); void createDropShadow(int dropx, int dropy); private: QPoint hot; QImage cursor; QRegion rgn; }; #endif // QWSCURSOR_QWS_H qt_mac.h-k/* */ #ifndef QT_MAC_H #define QT_MAC_H #undef OLD_DEBUG #ifdef DEBUG #define OLD_DEBUG DEBUG #undef DEBUG #endif #define DEBUG 0 #ifndef __IMAGECAPTURE__ #define __IMAGECAPTURE__ #endif #include #include #undef QT_BUILD_KEY #include //We need this to get QT_MACOSX_VERSION #include "qglobal.h" #ifdef Q_OS_MAC9 # define QMAC_DEFAULT_STYLE "QPlatinumStyle" //Default style # include "qt_mac9.h" #elif defined(Q_OS_MACX) # define QMAC_DEFAULT_STYLE "QMacStyle" //DefaultStyle #endif #if !defined(Q_WS_MACX) || QT_MACOSX_VERSION < 0x1020 || QT_MACOSX_VERSION >= 0x1030 # define QMAC_NO_FAKECURSOR #endif /* */ //#define QMAC_USE_APPLICATION_EVENT_LOOP #undef DEBUG #ifdef OLD_DEBUG #define DEBUG OLD_DEBUG #endif #undef OLD_DEBUG #ifdef Q_WS_MAC #include "qpainter.h" #include "qwidget.h" extern int mac_window_count; //qwidget_mac.cpp #ifdef QT_THREAD_SUPPORT #include "qthread.h" extern QMutex *qt_mac_port_mutex; //qapplication_mac.cpp #endif class QMacBlockingFunction : public QObject //done in qapplication_mac.cpp { private: static int block; public: QMacBlockingFunction(); ~QMacBlockingFunction() { block--; } static bool blocking() { return block != 0; } protected: void timerEvent(QTimerEvent *); }; class QMacSavedFontInfo { private: void init(CGrafPtr); protected: short tfont, tface; int tsize; public: inline QMacSavedFontInfo() { GWorldPtr w; GDHandle h; GetGWorld(&w, &h); init(w); } inline QMacSavedFontInfo(CGrafPtr w) { init(w); } ~QMacSavedFontInfo(); }; inline QMacSavedFontInfo::~QMacSavedFontInfo() { if(mac_window_count) { TextFont(tfont); TextFace(tface); TextSize(tsize); } } inline void QMacSavedFontInfo::init(CGrafPtr w) { if(mac_window_count) { tfont = GetPortTextFont(w); tface = GetPortTextFace(w); tsize = GetPortTextSize(w); } } class QMacFontInfo { public: inline QMacFontInfo() : fi_fnum(0), fi_face(0), fi_size(0), fi_enc(0), fi_astyle(0) { } inline ~QMacFontInfo() { if(fi_astyle && fi_astyle->deref()) { ATSUDisposeStyle(fi_astyle->style); delete fi_astyle; } } inline QMacFontInfo &operator=(const QMacFontInfo &rhs) { setEncoding(rhs.encoding()); setFont(rhs.font()); setStyle(rhs.style()); setSize(rhs.size()); if(rhs.atsuStyle()) { rhs.atsuStyle()->ref(); setATSUStyle(rhs.atsuStyle()); } else { if(fi_astyle && fi_astyle->deref()) { ATSUDisposeStyle(fi_astyle->style); delete fi_astyle; } setStyle(0); } return *this; } inline TextEncoding encoding() const { return fi_enc; } inline void setEncoding(TextEncoding f) { fi_enc = f; } inline short font() const { return fi_fnum; } inline void setFont(short f) { fi_fnum = f; } inline short style() const { return fi_face; } inline void setStyle(short f) { fi_face = f; } inline int size() const { return fi_size; } inline void setSize(int f) { fi_size = f; } struct QATSUStyle : public QShared { ATSUStyle style; RGBColor rgb; }; inline QATSUStyle *atsuStyle() const { return fi_astyle; } inline void setATSUStyle(QATSUStyle *s) { fi_astyle = s; } private: short fi_fnum, fi_face; int fi_size; TextEncoding fi_enc; QATSUStyle *fi_astyle; }; class QFontEngine; class QFontDef; class QFontPrivate; class QMacSetFontInfo : public QMacSavedFontInfo, public QMacFontInfo { private: static QMacFontInfo *createFontInfo(const QFontEngine *fe, const QFontDef *def, QPaintDevice *pdev); public: //create this for temporary font settting inline QMacSetFontInfo(const QFontPrivate *d, QPaintDevice *pdev) : QMacSavedFontInfo(), QMacFontInfo() { setMacFont(d, this, pdev); } inline QMacSetFontInfo(const QFontEngine *fe, QPaintDevice *pdev) : QMacSavedFontInfo(), QMacFontInfo() { setMacFont(fe, this, pdev); } //you can use these to cause font setting, without restoring old static bool setMacFont(const QMacFontInfo *f, QMacSetFontInfo *sfi=NULL); static bool setMacFont(const QFontPrivate *d, QMacSetFontInfo *sfi=NULL, QPaintDevice *pdev=NULL); static bool setMacFont(const QFontEngine *fe, QMacSetFontInfo *sfi=NULL, QPaintDevice *pdev=NULL); }; #include "qptrlist.h" #include "qpaintdevice.h" extern QPaintDevice *qt_mac_safe_pdev; //qapplication_mac.cpp extern QPainter *qt_mac_current_painter; //qpainter_mac.cpp class QMacSavedPortInfo { RgnHandle clip; GWorldPtr world; GDHandle handle; PenState pen; //go pennstate RGBColor back, fore; QMacSavedFontInfo *fi; QPainter *painter; bool valid_gworld; void init(); public: inline QMacSavedPortInfo() { init(); } inline QMacSavedPortInfo(QPaintDevice *pd) { init(); setPaintDevice(pd); } inline QMacSavedPortInfo(QWidget *w, bool set_clip=FALSE) { init(); setPaintDevice(w, set_clip); } inline QMacSavedPortInfo(QPaintDevice *pd, const QRect &r) { init(); setPaintDevice(pd); setClipRegion(r); } inline QMacSavedPortInfo(QPaintDevice *pd, const QRegion &r) { init(); setPaintDevice(pd); setClipRegion(r); } ~QMacSavedPortInfo(); static bool setClipRegion(const QRect &r); static bool setClipRegion(const QRegion &r); static bool setPaintDevice(QPaintDevice *); static bool setPaintDevice(QWidget *, bool set_clip=FALSE, bool with_child=TRUE); static bool flush(QPaintDevice *); static bool flush(QPaintDevice *, QRegion r, bool force=FALSE); static void setWindowAlpha(QWidget *, float); }; inline bool QMacSavedPortInfo::flush(QPaintDevice *pdev) { #ifdef Q_WS_MACX if(pdev->devType() == QInternal::Widget) { QWidget *w = (QWidget *)pdev; if(!w->isHidden() && QDIsPortBuffered(GetWindowPort((WindowPtr)w->handle()))) { QDFlushPortBuffer(GetWindowPort((WindowPtr)w->handle()), NULL); return TRUE; } } #else Q_UNUSED(pdev); #endif return FALSE; } inline bool QMacSavedPortInfo::flush(QPaintDevice *pdev, QRegion r, bool force) { #ifdef Q_WS_MACX if(pdev->devType() == QInternal::Widget) { QWidget *w = (QWidget *)pdev; r.translate(w->topLevelWidget()->geometry().x(), w->topLevelWidget()->geometry().y()); if(!w->isHidden() || QDIsPortBuffered(GetWindowPort((WindowPtr)w->handle()))) { QDFlushPortBuffer(GetWindowPort((WindowPtr)w->handle()), r.handle(force)); return TRUE; } } #else Q_UNUSED(pdev); Q_UNUSED(r); Q_UNUSED(force); #endif return FALSE; } #ifdef Q_WS_MACX extern "C" { typedef struct CGSConnection *CGSConnectionRef; typedef struct CGSWindow *CGSWindowRef; extern OSStatus CGSSetWindowAlpha(CGSConnectionRef, CGSWindowRef, float); extern CGSWindowRef GetNativeWindowFromWindowRef(WindowRef); extern CGSConnectionRef _CGSDefaultConnection(); } #endif inline void QMacSavedPortInfo::setWindowAlpha(QWidget *w, float l) { #ifdef Q_WS_MACX CGSSetWindowAlpha(_CGSDefaultConnection(), GetNativeWindowFromWindowRef((WindowRef)w->handle()), l); #else Q_UNUSED(w); Q_UNUSED(l); #endif } inline bool QMacSavedPortInfo::setClipRegion(const QRect &rect) { Rect r; SetRect(&r, rect.x(), rect.y(), rect.right()+1, rect.bottom()+1); #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->lock(); #endif qt_mac_current_painter = NULL; ClipRect(&r); #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->unlock(); #endif return TRUE; } inline bool QMacSavedPortInfo::setClipRegion(const QRegion &r) { if(r.isNull()) return setClipRegion(QRect()); else if(!r.handle()) return setClipRegion(r.boundingRect()); #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->lock(); #endif qt_mac_current_painter = NULL; SetClip(r.handle()); #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->unlock(); #endif return TRUE; } inline bool QMacSavedPortInfo::setPaintDevice(QWidget *w, bool set_clip, bool with_child) { if(!w) return FALSE; if(!setPaintDevice((QPaintDevice *)w)) return FALSE; if(set_clip) return setClipRegion(w->clippedRegion(with_child)); return TRUE; } inline bool QMacSavedPortInfo::setPaintDevice(QPaintDevice *pd) { if(!pd) return FALSE; #if 0 if(qt_mac_current_painter && qt_mac_current_painter->handle() == pd->handle()) return TRUE; #endif bool ret = TRUE; #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->lock(); #endif // if(qt_mac_current_painter && qt_mac_current_painter->handle() != pd->handle()) qt_mac_current_painter = NULL; if(pd->devType() == QInternal::Widget) SetPortWindowPort((WindowPtr)pd->handle()); else if(pd->devType() == QInternal::Pixmap || pd->devType() == QInternal::Printer) SetGWorld((GrafPtr)pd->handle(), 0); //set the gworld else ret = FALSE; #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->unlock(); #endif return ret; } inline void QMacSavedPortInfo::init() { #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->lock(); #endif fi = NULL; painter = qt_mac_current_painter; if(mac_window_count) { GetBackColor(&back); GetForeColor(&fore); GetGWorld(&world, &handle); valid_gworld = TRUE; fi = new QMacSavedFontInfo(world); clip = NewRgn(); GetClip(clip); GetPenState(&pen); } } inline QMacSavedPortInfo::~QMacSavedPortInfo() { if(mac_window_count) { bool set_state = false; if(valid_gworld) { set_state = IsValidPort(world); if(set_state) SetGWorld(world,handle); //always do this one first } else { setPaintDevice(qt_mac_safe_pdev); } if(set_state) { SetClip(clip); SetPenState(&pen); RGBForeColor(&fore); RGBBackColor(&back); } DisposeRgn(clip); } if(fi) delete fi; qt_mac_current_painter = painter; #if defined(QT_THREAD_SUPPORT) if(qt_mac_port_mutex) qt_mac_port_mutex->unlock(); #endif } #endif //Q_WS_MAC #endif // QT_MAC_H qstrvec.h q/* */ #ifndef QSTRVEC_H #define QSTRVEC_H #ifndef QT_H #include "qstring.h" #include "qptrvector.h" #include "qdatastream.h" #endif // QT_H class Q_EXPORT QStrVec : public QPtrVector { public: QStrVec() { dc = TRUE; } QStrVec( uint size, bool deepc = TRUE ) : QPtrVector(size) {dc=deepc;} ~QStrVec() { clear(); } private: Item newItem( Item d ) { return dc ? qstrdup( (const char*)d ) : d; } void deleteItem( Item d ) { if ( dc ) delete[] (char*)d; } int compareItems( Item s1, Item s2 ) { return qstrcmp((const char*)s1, (const char*)s2); } #ifndef QT_NO_DATASTREAM QDataStream &read( QDataStream &s, Item &d ) { s >> (char *&)d; return s; } QDataStream &write( QDataStream &s, Item d ) const { return s << (const char*)d; } #endif bool dc; }; class Q_EXPORT QStrIVec : public QStrVec // case insensitive string vec { public: QStrIVec() {} QStrIVec( uint size, bool dc = TRUE ) : QStrVec( size, dc ) {} ~QStrIVec() { clear(); } private: int compareItems( Item s1, Item s2 ) { return qstricmp((const char*)s1, (const char*)s2); } }; #endif // QSTRVEC_H qwindow.hA/* */ #ifndef QWINDOW_H #define QWINDOW_H #error "QWindow has gone away" #endif // QWINDOW_H quuid.h/* */ #ifndef QUUID_H #define QUUID_H #ifndef QT_H #include "qstring.h" #endif // QT_H #include #if defined(Q_OS_WIN32) #ifndef GUID_DEFINED #define GUID_DEFINED typedef struct _GUID { ulong Data1; ushort Data2; ushort Data3; uchar Data4[ 8 ]; } GUID, *REFGUID, *LPGUID; #endif #endif struct Q_EXPORT QUuid { enum Variant { VarUnknown =-1, NCS = 0, // 0 - - DCE = 2, // 1 0 - Microsoft = 6, // 1 1 0 Reserved = 7 // 1 1 1 }; enum Version { VerUnknown =-1, Time = 1, // 0 0 0 1 EmbeddedPOSIX = 2, // 0 0 1 0 Name = 3, // 0 0 1 1 Random = 4 // 0 1 0 0 }; QUuid() { memset( this, 0, sizeof(QUuid) ); } QUuid( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 ) { data1 = l; data2 = w1; data3 = w2; data4[0] = b1; data4[1] = b2; data4[2] = b3; data4[3] = b4; data4[4] = b5; data4[5] = b6; data4[6] = b7; data4[7] = b8; } QUuid( const QUuid &uuid ) { memcpy( this, &uuid, sizeof(QUuid) ); } #ifndef QT_NO_QUUID_STRING QUuid( const QString & ); QUuid( const char * ); QString toString() const; operator QString() const { return toString(); } #endif bool isNull() const; QUuid &operator=(const QUuid &orig ) { memcpy( this, &orig, sizeof(QUuid) ); return *this; } bool operator==(const QUuid &orig ) const { uint i; if ( data1 != orig.data1 || data2 != orig.data2 || data3 != orig.data3 ) return FALSE; for( i = 0; i < 8; i++ ) if ( data4[i] != orig.data4[i] ) return FALSE; return TRUE; } bool operator!=(const QUuid &orig ) const { return !( *this == orig ); } bool operator<(const QUuid &other ) const; bool operator>(const QUuid &other ) const; #if defined(Q_OS_WIN32) // On Windows we have a type GUID that is used by the platform API, so we // provide convenience operators to cast from and to this type. QUuid( const GUID &guid ) { memcpy( this, &guid, sizeof(GUID) ); } QUuid &operator=(const GUID &orig ) { memcpy( this, &orig, sizeof(QUuid) ); return *this; } operator GUID() const { GUID guid = { data1, data2, data3, { data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7] } }; return guid; } bool operator==( const GUID &guid ) const { uint i; if ( data1 != guid.Data1 || data2 != guid.Data2 || data3 != guid.Data3 ) return FALSE; for( i = 0; i < 8; i++ ) if ( data4[i] != guid.Data4[i] ) return FALSE; return TRUE; } bool operator!=( const GUID &guid ) const { return !( *this == guid ); } #endif static QUuid createUuid(); QUuid::Variant variant() const; QUuid::Version version() const; uint data1; ushort data2; ushort data3; uchar data4[ 8 ]; }; #ifndef QT_NO_DATASTREAM Q_EXPORT QDataStream &operator<<( QDataStream &, const QUuid & ); Q_EXPORT QDataStream &operator>>( QDataStream &, QUuid & ); #endif #endif //QUUID_H qurlinfo.h/* */ #ifndef QURLINFO_H #define QURLINFO_H #ifndef QT_H #include "qdatetime.h" #include "qstring.h" #if defined(QT_ABI_QT4) #include "qiodevice.h" #endif #endif // QT_H class QUrlOperator; class QUrl; class QUrlInfoPrivate; class Q_EXPORT QUrlInfo { public: enum PermissionSpec { ReadOwner = 00400, WriteOwner = 00200, ExeOwner = 00100, ReadGroup = 00040, WriteGroup = 00020, ExeGroup = 00010, ReadOther = 00004, WriteOther = 00002, ExeOther = 00001 }; QUrlInfo(); QUrlInfo( const QUrlOperator &path, const QString &file ); QUrlInfo( const QUrlInfo &ui ); #if (QT_VERSION-0 >= 0x040000) #error "QUrlInfo::QUrlInfo() should accept QIODevice::Offset instead of uint" #elif defined(QT_ABI_QT4) QUrlInfo( const QString &name, int permissions, const QString &owner, const QString &group, QIODevice::Offset size, const QDateTime &lastModified, const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable ); QUrlInfo( const QUrl &url, int permissions, const QString &owner, const QString &group, QIODevice::Offset size, const QDateTime &lastModified, const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable ); #else QUrlInfo( const QString &name, int permissions, const QString &owner, const QString &group, uint size, const QDateTime &lastModified, const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable ); QUrlInfo( const QUrl &url, int permissions, const QString &owner, const QString &group, uint size, const QDateTime &lastModified, const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable ); #endif QUrlInfo &operator=( const QUrlInfo &ui ); virtual ~QUrlInfo(); virtual void setName( const QString &name ); virtual void setDir( bool b ); virtual void setFile( bool b ); virtual void setSymLink( bool b ); virtual void setOwner( const QString &s ); virtual void setGroup( const QString &s ); #if (QT_VERSION-0 >= 0x040000) #error "QUrlInfo::setSize() should accept QIODevice::Offset instead of uint" #elif defined(QT_ABI_QT4) virtual void setSize( QIODevice::Offset size ); #else virtual void setSize( uint size ); #endif virtual void setWritable( bool b ); virtual void setReadable( bool b ); virtual void setPermissions( int p ); virtual void setLastModified( const QDateTime &dt ); bool isValid() const; QString name() const; int permissions() const; QString owner() const; QString group() const; #if (QT_VERSION-0 >= 0x040000) #error "QUrlInfo::size() should return QIODevice::Offset instead of uint" #elif defined(QT_ABI_QT4) QIODevice::Offset size() const; #else uint size() const; #endif QDateTime lastModified() const; QDateTime lastRead() const; bool isDir() const; bool isFile() const; bool isSymLink() const; bool isWritable() const; bool isReadable() const; bool isExecutable() const; static bool greaterThan( const QUrlInfo &i1, const QUrlInfo &i2, int sortBy ); static bool lessThan( const QUrlInfo &i1, const QUrlInfo &i2, int sortBy ); static bool equal( const QUrlInfo &i1, const QUrlInfo &i2, int sortBy ); bool operator==( const QUrlInfo &i ) const; private: QUrlInfoPrivate *d; }; #endif qtabbar.h/* */ #ifndef QTABBAR_H #define QTABBAR_H #ifndef QT_H #include "qwidget.h" #include "qptrlist.h" #endif // QT_H #ifndef QT_NO_TABBAR class QTabBar; class QIconSet; class Q_EXPORT QTab : public Qt { friend class QTabBar; friend class QTabWidget; public: QTab(); virtual ~QTab(); QTab( const QString& text ); QTab( const QIconSet& icon, const QString& text = QString::null ); void setText( const QString& text); QString text() const { return label; } void setIconSet( const QIconSet& icon ); QIconSet* iconSet() const { return iconset; } void setRect( const QRect& rect ) { r = rect; } QRect rect() const { return r; } void setEnabled( bool enable ) { enabled = enable; } bool isEnabled() const { return enabled; } void setIdentifier( int i ) { id = i; } int identifier() const { return id; } private: void setTabBar( QTabBar *tb ); QString label; QRect r; // the bounding rectangle of this (may overlap with others) bool enabled; int id; QIconSet* iconset; // optional iconset QTabBar *tb; }; struct QTabPrivate; //class *QAccel; class Q_EXPORT QTabBar: public QWidget { Q_OBJECT Q_ENUMS( Shape ) Q_PROPERTY( Shape shape READ shape WRITE setShape ) Q_PROPERTY( int currentTab READ currentTab WRITE setCurrentTab ) Q_PROPERTY( int count READ count ) Q_PROPERTY( int keyboardFocusTab READ keyboardFocusTab ) public: QTabBar( QWidget* parent=0, const char* name=0 ); ~QTabBar(); enum Shape { RoundedAbove, RoundedBelow, TriangularAbove, TriangularBelow }; Shape shape() const; virtual void setShape( Shape ); void show(); virtual int addTab( QTab * ); virtual int insertTab( QTab *, int index = -1 ); virtual void removeTab( QTab * ); virtual void setTabEnabled( int, bool ); bool isTabEnabled( int ) const; QSize sizeHint() const; QSize minimumSizeHint() const; int currentTab() const; int keyboardFocusTab() const; QTab * tab( int ) const; QTab * tabAt( int ) const; int indexOf( int ) const; int count() const; virtual void layoutTabs(); virtual QTab * selectTab( const QPoint & p ) const; void removeToolTip( int index ); void setToolTip( int index, const QString & tip ); QString toolTip( int index ) const; public slots: virtual void setCurrentTab( int ); virtual void setCurrentTab( QTab * ); signals: void selected( int ); void layoutChanged(); protected: virtual void paint( QPainter *, QTab *, bool ) const; // ### not const virtual void paintLabel( QPainter*, const QRect&, QTab*, bool ) const; void focusInEvent( QFocusEvent *e ); void focusOutEvent( QFocusEvent *e ); void resizeEvent( QResizeEvent * ); void paintEvent( QPaintEvent * ); void mousePressEvent ( QMouseEvent * ); void mouseMoveEvent ( QMouseEvent * ); void mouseReleaseEvent ( QMouseEvent * ); void keyPressEvent( QKeyEvent * ); void styleChange( QStyle& ); void fontChange ( const QFont & ); bool event( QEvent *e ); QPtrList * tabList(); private slots: void scrollTabs(); private: QPtrList * l; QPtrList * lstatic; void makeVisible( QTab* t = 0 ); void updateArrowButtons(); QTabPrivate * d; friend class QTabBarToolTip; friend class QTab; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTabBar( const QTabBar & ); QTabBar& operator=( const QTabBar & ); #endif }; #endif // QT_NO_TABBAR #endif // QTABBAR_H qstylefactory.h/* */ #ifndef QSTYLEFACTORY_H #define QSTYLEFACTORY_H #ifndef QT_H #include "qstringlist.h" #endif // QT_H #ifndef QT_NO_STYLE class QString; class QStyle; class Q_EXPORT QStyleFactory { public: #ifndef QT_NO_STRINGLIST static QStringList keys(); #endif static QStyle *create( const QString& ); }; #endif //QT_NO_STYLE #endif //QSTYLEFACTORY_H qsqlindex.h /* */ #ifndef QSQLINDEX_H #define QSQLINDEX_H #ifndef QT_H #include "qstring.h" #include "qstringlist.h" #include "qsqlfield.h" #include "qsqlrecord.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #define QM_TEMPLATE_EXTERN_SQL #else #define QM_EXPORT_SQL Q_EXPORT #define QM_TEMPLATE_EXTERN_SQL Q_TEMPLATE_EXTERN #endif #ifndef QT_NO_SQL class QSqlCursor; class QM_EXPORT_SQL QSqlIndex : public QSqlRecord { public: QSqlIndex( const QString& cursorName = QString::null, const QString& name = QString::null ); QSqlIndex( const QSqlIndex& other ); ~QSqlIndex(); QSqlIndex& operator=( const QSqlIndex& other ); virtual void setCursorName( const QString& cursorName ); QString cursorName() const { return cursor; } virtual void setName( const QString& name ); QString name() const { return nm; } void append( const QSqlField& field ); virtual void append( const QSqlField& field, bool desc ); bool isDescending( int i ) const; virtual void setDescending( int i, bool desc ); QString toString( const QString& prefix = QString::null, const QString& sep = ",", bool verbose = TRUE ) const; QStringList toStringList( const QString& prefix = QString::null, bool verbose = TRUE ) const; static QSqlIndex fromStringList( const QStringList& l, const QSqlCursor* cursor ); private: QString createField( int i, const QString& prefix, bool verbose ) const; QString cursor; QString nm; QValueList sorts; }; #define Q_DEFINED_QSQLINDEX #include "qwinexport.h" #endif // QT_NO_SQL #endif 4qwswindowsdecoration_qws.h/* */ #ifndef QWSWINDOWSDECORATION_QWS_H #define QWSWINDOWSDECORATION_QWS_H #ifndef QT_H #include "qwsdefaultdecoration_qws.h" #endif // QT_H #ifndef QT_NO_QWS_WINDOWS_WM_STYLE class QWSWindowsDecoration : public QWSDefaultDecoration { public: QWSWindowsDecoration(); virtual ~QWSWindowsDecoration(); virtual QRegion region(const QWidget *, const QRect &rect, Region); virtual void paint(QPainter *, const QWidget *); virtual void paintButton(QPainter *, const QWidget *, Region, int state); protected: virtual int getTitleWidth(const QWidget *); // virtual int getTitleHeight(const QWidget *); virtual const char **menuPixmap(); virtual const char **closePixmap(); virtual const char **minimizePixmap(); virtual const char **maximizePixmap(); virtual const char **normalizePixmap(); }; #endif // QT_NO_QWS_WINDOWS_WM_STYLE #endif // QWSWINDOWSDECORATION_QWS_H qvector.hD/* */ #ifndef QVECTOR_H #define QVECTOR_H #ifndef QT_NO_COMPAT #include "qptrvector.h" #endif #endif qwsdisplay_qws.h/* */ #ifndef QWSDISPLAY_QWS_H #define QWSDISPLAY_QWS_H #include "qobject.h" #include "qregion.h" #include "private/qlock_p.h" #include "qwindowdefs.h" #include "qptrlist.h" // Class forward definitions class QWSRegionManager; class QWSEvent; class QWSMouseEvent; class QWSQCopMessageEvent; class QGfx; class QWSWindowInfo { public: int winid; unsigned int clientid; QString name; }; #define QT_QWS_PROPERTY_CONVERTSELECTION 999 #define QT_QWS_PROPERTY_WINDOWNAME 998 class QWSDisplay { public: QWSDisplay(); ~QWSDisplay(); bool eventPending() const; QWSEvent *getEvent(); QGfx * screenGfx(); QWSRegionManager *regionManager() const; uchar* frameBuffer() const; int width() const; int height() const; int depth() const; int pixmapDepth() const; bool supportsDepth(int) const; uchar *sharedRam() const; int sharedRamSize() const; void addProperty( int winId, int property ); void setProperty( int winId, int property, int mode, const QByteArray &data ); void setProperty( int winId, int property, int mode, const char * data ); void removeProperty( int winId, int property ); bool getProperty( int winId, int property, char *&data, int &len ); QPtrList * windowList(); void setIdentity(const QString &appName); void nameRegion( int winId, const QString& n, const QString &c ); void requestRegion( int winId, QRegion ); void moveRegion( int winId, int dx, int dy ); void destroyRegion( int winId ); void requestFocus(int winId, bool get); void setAltitude( int winId, int altitude, bool fixed = FALSE ); int takeId(); void setSelectionOwner( int winId, const QTime &time ); void convertSelection( int winId, int selectionProperty, const QString &mimeTypes ); void defineCursor(int id, const QBitmap &curs, const QBitmap &mask, int hotX, int hotY); void selectCursor( QWidget *w, unsigned int id ); void grabMouse( QWidget *w, bool grab ); void grabKeyboard( QWidget *w, bool grab ); void playSoundFile( const QString& ); void registerChannel( const QCString& channel ); void sendMessage(const QCString &channel, const QCString &msg, const QByteArray &data ); #ifndef QT_NO_QWS_REPEATER void repaintRegion(QRegion &); #endif #ifndef QT_NO_QWS_IM void setMicroFocus( int x, int y ); void resetIM(); #endif QWSQCopMessageEvent* waitForQCopResponse(); void setCaption( QWidget *w, const QString & ); // Lock display for access only by this process static bool initLock( const QString &filename, bool create = FALSE ); static bool grabbed() { return lock->locked(); } static void grab() { lock->lock( QLock::Read ); } static void grab( bool write ) { lock->lock( write ? QLock::Write : QLock::Read ); } static void ungrab() { lock->unlock(); } #ifdef QT_QWS_DYNAMIC_TRANSFORMATION static void setTransformation( int t ); #endif static void setRawMouseEventFilter( void (*filter)(QWSMouseEvent *) ); private: friend class QApplication; friend class QCopChannel; class Data; Data *d; int getPropertyLen; char *getPropertyData; static QLock *lock; }; extern QWSDisplay *qt_fbdpy; #endif // QWSDISPLAY_QWS_H qwssocket_qws.h/* */ #ifndef QWSSOCKET_QWS_H #define QWSSOCKET_QWS_H #ifndef QT_H #include "qsocket.h" #include "qserversocket.h" #endif // QT_H #ifndef QT_NO_QWS_MULTIPROCESS class QWSSocket : public QSocket { Q_OBJECT public: QWSSocket( QObject *parent=0, const char *name=0 ); ~QWSSocket(); virtual void connectToLocalFile( const QString &file ); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QWSSocket( const QWSSocket & ); QWSSocket &operator=( const QWSSocket & ); #endif }; class QWSServerSocket : public QServerSocket { Q_OBJECT public: QWSServerSocket( const QString& file, int backlog = 0, QObject *parent=0, const char *name=0 ); ~QWSServerSocket(); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QWSServerSocket( const QWSServerSocket & ); QWSServerSocket &operator=( const QWSServerSocket & ); #endif }; #endif // QT_NO_QWS_MULTIPROCESS #endif // QWSSOCKET_QWS_H qstrlist.h /* */ #ifndef QSTRLIST_H #define QSTRLIST_H #ifndef QT_H #include "qstring.h" #include "qptrlist.h" #include "qdatastream.h" #endif // QT_H #if defined(Q_QDOC) class QStrListIterator : public QPtrListIterator { }; #else typedef QPtrListIterator QStrListIterator; #endif class Q_EXPORT QStrList : public QPtrList { public: QStrList( bool deepCopies=TRUE ) { dc = deepCopies; del_item = deepCopies; } QStrList( const QStrList & ); ~QStrList() { clear(); } QStrList& operator=( const QStrList & ); private: QPtrCollection::Item newItem( QPtrCollection::Item d ) { return dc ? qstrdup( (const char*)d ) : d; } void deleteItem( QPtrCollection::Item d ) { if ( del_item ) delete[] (char*)d; } int compareItems( QPtrCollection::Item s1, QPtrCollection::Item s2 ) { return qstrcmp((const char*)s1, (const char*)s2); } #ifndef QT_NO_DATASTREAM QDataStream &read( QDataStream &s, QPtrCollection::Item &d ) { s >> (char *&)d; return s; } QDataStream &write( QDataStream &s, QPtrCollection::Item d ) const { return s << (const char *)d; } #endif bool dc; }; class Q_EXPORT QStrIList : public QStrList // case insensitive string list { public: QStrIList( bool deepCopies=TRUE ) : QStrList( deepCopies ) {} ~QStrIList() { clear(); } private: int compareItems( QPtrCollection::Item s1, QPtrCollection::Item s2 ) { return qstricmp((const char*)s1, (const char*)s2); } }; inline QStrList & QStrList::operator=( const QStrList &strList ) { clear(); dc = strList.dc; del_item = dc; QPtrList::operator=( strList ); return *this; } inline QStrList::QStrList( const QStrList &strList ) : QPtrList( strList ) { dc = FALSE; operator=( strList ); } #endif // QSTRLIST_H qvaluevector.h0%/* */ #ifndef QVALUEVECTOR_H #define QVALUEVECTOR_H #ifndef QT_H #include "qtl.h" #include "qshared.h" #include "qdatastream.h" #endif // QT_H #ifndef QT_NO_STL #include #endif template class QValueVectorPrivate : public QShared { public: typedef T value_type; typedef T* pointer; QValueVectorPrivate() : start( 0 ), finish( 0 ), end( 0 ) { } QValueVectorPrivate( const QValueVectorPrivate& x ); QValueVectorPrivate( size_t size ); void derefAndDelete() // work-around for hp-cc { if ( deref() ) delete this; } #if defined(Q_TEMPLATEDLL) // Workaround MS bug in memory de/allocation in DLL vs. EXE virtual #endif ~QValueVectorPrivate() { delete[] start; } size_t size() const { return finish - start; } bool empty() const { return start == finish; } size_t capacity() const { return end - start; } void insert( pointer pos, const T& x ); void insert( pointer pos, size_t n, const T& x ); void reserve( size_t n ); void clear() { delete[] start; start = 0; finish = 0; end = 0; } pointer start; pointer finish; pointer end; private: pointer growAndCopy( size_t n, pointer s, pointer f ); QValueVectorPrivate& operator=( const QValueVectorPrivate& x ); }; template Q_INLINE_TEMPLATES QValueVectorPrivate::QValueVectorPrivate( const QValueVectorPrivate& x ) : QShared() { int i = x.size(); if ( i > 0 ) { start = new T[ i ]; finish = start + i; end = start + i; #if defined(__xlC__) && __xlC__ < 0x400 // xlC 3.6 confused by const qCopy( (pointer)x.start, (pointer)x.finish, start ); #else qCopy( x.start, x.finish, start ); #endif } else { start = 0; finish = 0; end = 0; } } template Q_INLINE_TEMPLATES QValueVectorPrivate::QValueVectorPrivate( size_t size ) { if ( size > 0 ) { start = new T[size]; finish = start + size; end = start + size; } else { start = 0; finish = 0; end = 0; } } template Q_INLINE_TEMPLATES void QValueVectorPrivate::insert( pointer pos, const T& x ) { const size_t lastSize = size(); const size_t n = lastSize !=0 ? 2*lastSize : 1; const size_t offset = pos - start; pointer newStart = new T[n]; pointer newFinish = newStart + offset; qCopy( start, pos, newStart ); *newFinish = x; qCopy( pos, finish, ++newFinish ); delete[] start; start = newStart; finish = newStart + lastSize + 1; end = newStart + n; } template Q_INLINE_TEMPLATES void QValueVectorPrivate::insert( pointer pos, size_t n, const T& x ) { if ( size_t( end - finish ) >= n ) { // enough room const size_t elems_after = finish - pos; pointer old_finish = finish; if ( elems_after > n ) { qCopy( finish - n, finish, finish ); finish += n; qCopyBackward( pos, old_finish - n, old_finish ); qFill( pos, pos + n, x ); } else { pointer filler = finish; size_t i = n - elems_after; for ( ; i > 0; --i, ++filler ) *filler = x; finish += n - elems_after; qCopy( pos, old_finish, finish ); finish += elems_after; qFill( pos, old_finish, x ); } } else { // not enough room const size_t lastSize = size(); const size_t len = lastSize + QMAX( lastSize, n ); pointer newStart = new T[len]; pointer newFinish = qCopy( start, pos, newStart ); // fill up inserted space size_t i = n; for ( ; i > 0; --i, ++newFinish ) *newFinish = x; newFinish = qCopy( pos, finish, newFinish ); delete[] start; start = newStart; finish = newFinish; end = newStart + len; } } template Q_INLINE_TEMPLATES void QValueVectorPrivate::reserve( size_t n ) { const size_t lastSize = size(); pointer tmp = growAndCopy( n, start, finish ); start = tmp; finish = tmp + lastSize; end = start + n; } template Q_INLINE_TEMPLATES Q_TYPENAME QValueVectorPrivate::pointer QValueVectorPrivate::growAndCopy( size_t n, pointer s, pointer f ) { pointer newStart = new T[n]; qCopy( s, f, newStart ); delete[] start; return newStart; } template class QDeepCopy; template class QValueVector { public: typedef T value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef size_t size_type; #ifndef QT_NO_STL typedef ptrdiff_t difference_type; #else typedef int difference_type; #endif QValueVector() { sh = new QValueVectorPrivate; } QValueVector( const QValueVector& v ) { sh = v.sh; sh->ref(); } QValueVector( size_type n, const T& val = T() ); #ifndef QT_NO_STL QValueVector( std::vector& v ) // ### remove in 4.0 { sh = new QValueVectorPrivate( v.size() ); qCopy( v.begin(), v.end(), begin() ); } QValueVector( const std::vector& v ) { sh = new QValueVectorPrivate( v.size() ); qCopy( v.begin(), v.end(), begin() ); } #endif ~QValueVector() { sh->derefAndDelete(); } QValueVector& operator= ( const QValueVector& v ) { v.sh->ref(); sh->derefAndDelete(); sh = v.sh; return *this; } #ifndef QT_NO_STL QValueVector& operator= ( const std::vector& v ) { clear(); resize( v.size() ); qCopy( v.begin(), v.end(), begin() ); return *this; } #endif size_type size() const { return sh->size(); } bool empty() const { return sh->empty(); } size_type capacity() const { return size_type( sh->capacity() ); } iterator begin() { detach(); return sh->start; } const_iterator begin() const { return sh->start; } const_iterator constBegin() const { return sh->start; } iterator end() { detach(); return sh->finish; } const_iterator end() const { return sh->finish; } const_iterator constEnd() const { return sh->finish; } reference at( size_type i, bool* ok = 0 ) { detach(); if ( ok ) *ok = ( i < size() ); return *( begin() + i ); } const_reference at( size_type i, bool* ok = 0 ) const { if ( ok ) *ok = ( i < size() ); return *( begin() + i ); } reference operator[]( size_type i ) { detach(); return *( begin() + i ); } const_reference operator[]( size_type i ) const { return *( begin() + i ); } reference front() { Q_ASSERT( !empty() ); detach(); return *begin(); } const_reference front() const { Q_ASSERT( !empty() ); return *begin(); } reference back() { Q_ASSERT( !empty() ); detach(); return *( end() - 1 ); } const_reference back() const { Q_ASSERT( !empty() ); return *( end() - 1 ); } void push_back( const T& x ) { detach(); if ( sh->finish == sh->end ) { sh->reserve( size()+size()/2+1 ); } *sh->finish = x; ++sh->finish; } void pop_back() { detach(); if ( empty() ) return; --sh->finish; } iterator insert( iterator pos, const T& x ); iterator insert( iterator pos, size_type n, const T& x ); void reserve( size_type n ) { if ( capacity() < n ) { detach(); sh->reserve( n ); } } void resize( size_type n, const T& val = T() ) { if ( n < size() ) erase( begin() + n, end() ); else insert( end(), n - size(), val ); } void clear() { detach(); sh->clear(); } iterator erase( iterator pos ) { detach(); if ( pos + 1 != end() ) qCopy( pos + 1, sh->finish, pos ); --sh->finish; return pos; } iterator erase( iterator first, iterator last ) { detach(); qCopy( last, sh->finish, first ); sh->finish = sh->finish - ( last - first ); return first; } // ### remove in Qt 4.0 bool operator==( const QValueVector& x ) { return size()==x.size() ? qEqual( constBegin(), constEnd(), x.begin()) : FALSE; } bool operator==( const QValueVector& x ) const { return size()==x.size() ? qEqual( begin(), end(), x.begin() ) : FALSE; } typedef T ValueType; typedef ValueType *Iterator; typedef const ValueType *ConstIterator; size_type count() const { return size(); } bool isEmpty() const { return empty(); } reference first() { return front(); } const_reference first() const { return front(); } reference last() { return back(); } const_reference last() const { return back(); } void append( const T& x ) { push_back( x ); } protected: void detach() { if ( sh->count > 1 ) { detachInternal(); } } void detachInternal(); QValueVectorPrivate* sh; private: friend class QDeepCopy< QValueVector >; }; template Q_INLINE_TEMPLATES QValueVector::QValueVector( size_type n, const T& val ) { sh = new QValueVectorPrivate( n ); qFill( begin(), end(), val ); } template Q_INLINE_TEMPLATES void QValueVector::detachInternal() { sh->deref(); sh = new QValueVectorPrivate( *sh ); } template Q_INLINE_TEMPLATES Q_TYPENAME QValueVector::iterator QValueVector::insert( iterator pos, const T& x ) { size_type offset = pos - sh->start; detach(); if ( pos == end() ) { if ( sh->finish == sh->end ) push_back( x ); else { *sh->finish = x; ++sh->finish; } } else { if ( sh->finish == sh->end ) { sh->insert( pos, x ); } else { *sh->finish = *(sh->finish - 1); ++sh->finish; qCopyBackward( pos, sh->finish - 2, sh->finish - 1 ); *pos = x; } } return begin() + offset; } template Q_INLINE_TEMPLATES Q_TYPENAME QValueVector::iterator QValueVector::insert( iterator pos, size_type n, const T& x ) { if ( n != 0 ) { size_type offset = pos - sh->start; detach(); pos = begin() + offset; sh->insert( pos, n, x ); } return pos; } #ifndef QT_NO_DATASTREAM template Q_INLINE_TEMPLATES QDataStream& operator>>( QDataStream& s, QValueVector& v ) { v.clear(); Q_UINT32 c; s >> c; v.resize( c ); for( Q_UINT32 i = 0; i < c; ++i ) { T t; s >> t; v[i] = t; } return s; } template Q_INLINE_TEMPLATES QDataStream& operator<<( QDataStream& s, const QValueVector& v ) { s << (Q_UINT32)v.size(); // ### use typename QValueVector::const_iterator once all supported // ### compilers know about the 'typename' keyword. const T* it = v.begin(); for( ; it != v.end(); ++it ) s << *it; return s; } #endif // QT_NO_DATASTREAM #define Q_DEFINED_QVALUEVECTOR #include "qwinexport.h" #endif // QVALUEVECTOR_H qvfbhdr.h/* */ #ifndef QVFBHDR_H #define QVFBHDR_H #ifndef QT_H #include "qcolor.h" #include "qrect.h" #endif // QT_H #define QT_VFB_MOUSE_PIPE "/tmp/.qtvfb_mouse-%1" #define QT_VFB_KEYBOARD_PIPE "/tmp/.qtvfb_keyboard-%1" struct QVFbHeader { int width; int height; int depth; int linestep; int dataoffset; QRect update; bool dirty; int numcols; QRgb clut[256]; }; struct QVFbKeyData { unsigned int unicode; unsigned int modifiers; bool press; bool repeat; }; #endif .qwskde2decoration_qws.h/* */ #ifndef QWSKDE2DECORATION_QWS_H #define QWSKDE2DECORATION_QWS_H #ifndef QT_H #include "qwsdefaultdecoration_qws.h" #endif // QT_H #ifndef QT_NO_QWS_KDE2_WM_STYLE class QWSKDE2Decoration : public QWSDefaultDecoration { public: QWSKDE2Decoration(); virtual ~QWSKDE2Decoration(); virtual QRegion region(const QWidget *, const QRect &rect, Region); virtual void paint(QPainter *, const QWidget *); virtual void paintButton(QPainter *, const QWidget *, Region, int state); protected: /* */ }; #endif // QT_NO_QWS_KDE2_WM_STYLE #endif // QWSKDE2DECORATION_QWS_H 4qwsdefaultdecoration_qws.h |/* */ #ifndef QWSDEFAULTDECORATION_QWS_H #define QWSDEFAULTDECORATION_QWS_H #ifndef QT_H #include "qwsmanager_qws.h" #endif // QT_H #ifndef QT_NO_QWS_MANAGER #define CORNER_GRAB 16 #define BORDER_WIDTH 4 #define BOTTOM_BORDER_WIDTH 2*BORDER_WIDTH class QWSDefaultDecoration : public QWSDecoration { public: QWSDefaultDecoration(); virtual ~QWSDefaultDecoration(); virtual QRegion region(const QWidget *, const QRect &rect, Region); virtual void paint(QPainter *, const QWidget *); virtual void paintButton(QPainter *, const QWidget *, Region, int state); protected: virtual const QPixmap* pixmapFor(const QWidget *, Region, bool, int&, int&); /* */ virtual int getTitleWidth(const QWidget *); virtual int getTitleHeight(const QWidget *); #ifndef QT_NO_IMAGEIO_XPM virtual const char **menuPixmap(); virtual const char **closePixmap(); virtual const char **minimizePixmap(); virtual const char **maximizePixmap(); virtual const char **normalizePixmap(); #endif private: static QPixmap * staticMenuPixmap; static QPixmap * staticClosePixmap; static QPixmap * staticMinimizePixmap; static QPixmap * staticMaximizePixmap; static QPixmap * staticNormalizePixmap; }; #endif // QT_NO_QWS_MANAGER #endif // QWSDEFAULTDECORATION_QWS_H ,qwsregionmanager_qws.hy/* */ #ifndef QWSREGIONMANAGER_QWS_H #define QWSREGIONMANAGER_QWS_H #ifndef QT_H #include "qptrvector.h" #include "qregion.h" #endif // QT_H class QWSRegionHeader; class QWSRegionIndex; class QWSRegionManager { public: QWSRegionManager( const QString &filename, bool c = TRUE ); ~QWSRegionManager(); // for clients const int *revision( int idx ) const; QRegion region( int idx ); int find( int id ); // for server int add( int id, QRegion region ); void set( int idx, QRegion region ); void remove( int idx ); void markUpdated( int idx ); void commit(); private: QRect *rects( int offset ); bool attach( const QString &filename ); void detach(); private: bool client; QPtrVector regions; QWSRegionHeader *regHdr; QWSRegionIndex *regIdx; unsigned char *data; int shmId; }; #endif // QWSREGIONMANAGER_QWS_H qtextstream.h(8/* */ #ifndef QTEXTSTREAM_H #define QTEXTSTREAM_H #ifndef QT_H #include "qiodevice.h" #include "qstring.h" #include #endif // QT_H #ifndef QT_NO_TEXTSTREAM class QTextCodec; class QTextDecoder; class QTextStreamPrivate; class Q_EXPORT QTextStream // text stream class { public: enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder, UnicodeReverse, RawUnicode, UnicodeUTF8 }; void setEncoding( Encoding ); #ifndef QT_NO_TEXTCODEC void setCodec( QTextCodec* ); QTextCodec *codec(); #endif QTextStream(); QTextStream( QIODevice * ); QTextStream( QString*, int mode ); QTextStream( QString&, int mode ); // obsolete QTextStream( QByteArray, int mode ); QTextStream( FILE *, int mode ); virtual ~QTextStream(); QIODevice *device() const; void setDevice( QIODevice * ); void unsetDevice(); bool atEnd() const; bool eof() const; QTextStream &operator>>( QChar & ); QTextStream &operator>>( char & ); QTextStream &operator>>( signed short & ); QTextStream &operator>>( unsigned short & ); QTextStream &operator>>( signed int & ); QTextStream &operator>>( unsigned int & ); QTextStream &operator>>( signed long & ); QTextStream &operator>>( unsigned long & ); QTextStream &operator>>( float & ); QTextStream &operator>>( double & ); QTextStream &operator>>( char * ); QTextStream &operator>>( QString & ); QTextStream &operator>>( QCString & ); QTextStream &operator<<( QChar ); QTextStream &operator<<( char ); QTextStream &operator<<( signed short ); QTextStream &operator<<( unsigned short ); QTextStream &operator<<( signed int ); QTextStream &operator<<( unsigned int ); QTextStream &operator<<( signed long ); QTextStream &operator<<( unsigned long ); QTextStream &operator<<( float ); QTextStream &operator<<( double ); QTextStream &operator<<( const char* ); QTextStream &operator<<( const QString & ); QTextStream &operator<<( const QCString & ); QTextStream &operator<<( void * ); // any pointer QTextStream &readRawBytes( char *, uint len ); QTextStream &writeRawBytes( const char* , uint len ); QString readLine(); QString read(); void skipWhiteSpace(); enum { skipws = 0x0001, // skip whitespace on input left = 0x0002, // left-adjust output right = 0x0004, // right-adjust output internal = 0x0008, // pad after sign bin = 0x0010, // binary format integer oct = 0x0020, // octal format integer dec = 0x0040, // decimal format integer hex = 0x0080, // hex format integer showbase = 0x0100, // show base indicator showpoint = 0x0200, // force decimal point (float) uppercase = 0x0400, // upper-case hex output showpos = 0x0800, // add '+' to positive integers scientific= 0x1000, // scientific float output fixed = 0x2000 // fixed float output }; static const int basefield; // bin | oct | dec | hex static const int adjustfield; // left | right | internal static const int floatfield; // scientific | fixed int flags() const; int flags( int f ); int setf( int bits ); int setf( int bits, int mask ); int unsetf( int bits ); void reset(); int width() const; int width( int ); int fill() const; int fill( int ); int precision() const; int precision( int ); private: long input_int(); void init(); QTextStream &output_int( int, ulong, bool ); QIODevice *dev; int fflags; int fwidth; int fillchar; int fprec; bool doUnicodeHeader; bool owndev; QTextCodec *mapper; QTextStreamPrivate * d; QChar unused1; // ### remove in Qt 4.0 bool latin1; bool internalOrder; bool networkOrder; void *unused2; // ### remove in Qt 4.0 QChar eat_ws(); uint ts_getline( QChar* ); void ts_ungetc( QChar ); QChar ts_getc(); uint ts_getbuf( QChar*, uint ); void ts_putc(int); void ts_putc(QChar); bool ts_isspace(QChar); bool ts_isdigit(QChar); ulong input_bin(); ulong input_oct(); ulong input_dec(); ulong input_hex(); double input_double(); QTextStream &writeBlock( const char* p, uint len ); QTextStream &writeBlock( const QChar* p, uint len ); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTextStream( const QTextStream & ); QTextStream &operator=( const QTextStream & ); #endif }; typedef QTextStream QTS; class Q_EXPORT QTextIStream : public QTextStream { public: QTextIStream( const QString* s ) : QTextStream((QString*)s,IO_ReadOnly) { } QTextIStream( QByteArray ba ) : QTextStream(ba,IO_ReadOnly) { } QTextIStream( FILE *f ) : QTextStream(f,IO_ReadOnly) { } private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTextIStream( const QTextIStream & ); QTextIStream &operator=( const QTextIStream & ); #endif }; class Q_EXPORT QTextOStream : public QTextStream { public: QTextOStream( QString* s ) : QTextStream(s,IO_WriteOnly) { } QTextOStream( QByteArray ba ) : QTextStream(ba,IO_WriteOnly) { } QTextOStream( FILE *f ) : QTextStream(f,IO_WriteOnly) { } private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTextOStream( const QTextOStream & ); QTextOStream &operator=( const QTextOStream & ); #endif }; /* */ inline QIODevice *QTextStream::device() const { return dev; } inline bool QTextStream::atEnd() const { return dev ? dev->atEnd() : FALSE; } inline bool QTextStream::eof() const { return atEnd(); } inline int QTextStream::flags() const { return fflags; } inline int QTextStream::flags( int f ) { int oldf = fflags; fflags = f; return oldf; } inline int QTextStream::setf( int bits ) { int oldf = fflags; fflags |= bits; return oldf; } inline int QTextStream::setf( int bits, int mask ) { int oldf = fflags; fflags = (fflags & ~mask) | (bits & mask); return oldf; } inline int QTextStream::unsetf( int bits ) { int oldf = fflags; fflags &= ~bits; return oldf; } inline int QTextStream::width() const { return fwidth; } inline int QTextStream::width( int w ) { int oldw = fwidth; fwidth = w; return oldw; } inline int QTextStream::fill() const { return fillchar; } inline int QTextStream::fill( int f ) { int oldc = fillchar; fillchar = f; return oldc; } inline int QTextStream::precision() const { return fprec; } inline int QTextStream::precision( int p ) { int oldp = fprec; fprec = p; return oldp; } /* */ inline QChar QTextStream::ts_getc() { QChar r; return ( ts_getbuf( &r,1 ) == 1 ? r : QChar((ushort)0xffff) ); } /* */ typedef QTextStream & (*QTSFUNC)(QTextStream &);// manipulator function typedef int (QTextStream::*QTSMFI)(int); // manipulator w/int argument class Q_EXPORT QTSManip { // text stream manipulator public: QTSManip( QTSMFI m, int a ) { mf=m; arg=a; } void exec( QTextStream &s ) { (s.*mf)(arg); } private: QTSMFI mf; // QTextStream member function int arg; // member function argument }; Q_EXPORT inline QTextStream &operator>>( QTextStream &s, QTSFUNC f ) { return (*f)( s ); } Q_EXPORT inline QTextStream &operator<<( QTextStream &s, QTSFUNC f ) { return (*f)( s ); } Q_EXPORT inline QTextStream &operator<<( QTextStream &s, QTSManip m ) { m.exec(s); return s; } Q_EXPORT QTextStream &bin( QTextStream &s ); // set bin notation Q_EXPORT QTextStream &oct( QTextStream &s ); // set oct notation Q_EXPORT QTextStream &dec( QTextStream &s ); // set dec notation Q_EXPORT QTextStream &hex( QTextStream &s ); // set hex notation Q_EXPORT QTextStream &endl( QTextStream &s ); // insert EOL ('\n') Q_EXPORT QTextStream &flush( QTextStream &s ); // flush output Q_EXPORT QTextStream &ws( QTextStream &s ); // eat whitespace on input Q_EXPORT QTextStream &reset( QTextStream &s ); // set default flags Q_EXPORT inline QTSManip qSetW( int w ) { QTSMFI func = &QTextStream::width; return QTSManip(func,w); } Q_EXPORT inline QTSManip qSetFill( int f ) { QTSMFI func = &QTextStream::fill; return QTSManip(func,f); } Q_EXPORT inline QTSManip qSetPrecision( int p ) { QTSMFI func = &QTextStream::precision; return QTSManip(func,p); } #endif // QT_NO_TEXTSTREAM #endif // QTEXTSTREAM_H qwhatsthis.h /* */ #ifndef QWHATSTHIS_H #define QWHATSTHIS_H #ifndef QT_H #include "qobject.h" #endif // QT_H #ifndef QT_NO_WHATSTHIS #include "qcursor.h" class QToolButton; class QPopupMenu; class QStyleSheet; class Q_EXPORT QWhatsThis: public Qt { public: QWhatsThis( QWidget *); virtual ~QWhatsThis(); virtual QString text( const QPoint & ); virtual bool clicked( const QString& href ); // the common static functions static void setFont( const QFont &font ); static void add( QWidget *, const QString &); static void remove( QWidget * ); static QString textFor( QWidget *, const QPoint & pos = QPoint(), bool includeParents = FALSE ); static QToolButton * whatsThisButton( QWidget * parent ); static void enterWhatsThisMode(); static bool inWhatsThisMode(); static void leaveWhatsThisMode( const QString& = QString::null, const QPoint& pos = QCursor::pos(), QWidget* w = 0 ); static void display( const QString& text, const QPoint& pos = QCursor::pos(), QWidget* w = 0 ); }; #endif // QT_NO_WHATSTHIS #endif // QWHATSTHIS_H $qwskeyboard_qnx4.h G /* */ #ifndef QWSKEYBOARD_QNX4_H #define QWSKEYBOARD_QNX4_H #ifndef QT_H #include "qwindowsystem_qws.h" #include "qwsutils_qws.h" #include "qgfx_qws.h" #endif // QT_H #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(Q_OS_QNX4) #ifndef QWSQNX4KB_H #define QWSQNX4KB_H #include class QWSQnx4KeyboardHandler : public QWSKeyboardHandler { Q_OBJECT public: QWSQnx4KeyboardHandler(); ~QWSQnx4KeyboardHandler(); void doKey(uchar); public slots: void readKbdData(int); private: enum GuidantState { GuidantNone, GuidantPressed, GuidantReleased, GuidantDropped } gState; int shift; int alt; int ctrl; bool extended; bool caps; int modifiers; int prevuni; int prevkey; int kbdFD; QList notifiers; }; #endif #endif #endif // QWSKEYBOARD_QNX4_H qtabdlg.h(/* */ #ifndef QTABDLG_H #define QTABDLG_H #include "qtabdialog.h" #endif qsqlform.h /* */ #ifndef QSQLFORM_H #define QSQLFORM_H #ifndef QT_H #include "qobject.h" #include "qmap.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL_FORM class QSqlField; class QSqlRecord; class QSqlEditorFactory; class QSqlPropertyMap; class QWidget; class QSqlFormPrivate; class QM_EXPORT_SQL QSqlForm : public QObject { Q_OBJECT public: QSqlForm( QObject * parent = 0, const char * name = 0 ); ~QSqlForm(); virtual void insert( QWidget * widget, const QString& field ); virtual void remove( const QString& field ); uint count() const; QWidget * widget( uint i ) const; QSqlField * widgetToField( QWidget * widget ) const; QWidget * fieldToWidget( QSqlField * field ) const; void installPropertyMap( QSqlPropertyMap * map ); virtual void setRecord( QSqlRecord* buf ); public slots: virtual void readField( QWidget * widget ); virtual void writeField( QWidget * widget ); virtual void readFields(); virtual void writeFields(); virtual void clear(); virtual void clearValues( bool nullify = FALSE ); protected: virtual void insert( QWidget * widget, QSqlField * field ); virtual void remove( QWidget * widget ); void clearMap(); private: virtual void sync(); QSqlFormPrivate* d; #if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator= QSqlForm( const QSqlForm & ); QSqlForm &operator=( const QSqlForm & ); #endif }; #endif // QT_NO_SQL #endif // QSQLFORM_H qvaluelist.hG/* */ #ifndef QVALUELIST_H #define QVALUELIST_H #ifndef QT_H #include "qtl.h" #include "qshared.h" #include "qdatastream.h" #endif // QT_H #ifndef QT_NO_STL #include #include #endif //#define QT_CHECK_VALUELIST_RANGE #if defined(Q_CC_MSVC) #pragma warning(disable:4284) // "return type for operator -> is not a UDT" #endif template class QValueListNode { public: QValueListNode( const T& t ) : data( t ) { } QValueListNode() { } #if defined(Q_TEMPLATEDLL) // Workaround MS bug in memory de/allocation in DLL vs. EXE virtual ~QValueListNode() { } #endif QValueListNode* next; QValueListNode* prev; T data; }; template class QValueListIterator { public: /* */ typedef QValueListNode* NodePtr; #ifndef QT_NO_STL typedef std::bidirectional_iterator_tag iterator_category; #endif typedef T value_type; typedef size_t size_type; #ifndef QT_NO_STL typedef ptrdiff_t difference_type; #else typedef int difference_type; #endif typedef T* pointer; typedef T& reference; /* */ NodePtr node; /* */ QValueListIterator() : node( 0 ) {} QValueListIterator( NodePtr p ) : node( p ) {} QValueListIterator( const QValueListIterator& it ) : node( it.node ) {} bool operator==( const QValueListIterator& it ) const { return node == it.node; } bool operator!=( const QValueListIterator& it ) const { return node != it.node; } const T& operator*() const { return node->data; } T& operator*() { return node->data; } // UDT for T = x* // T* operator->() const { return &node->data; } QValueListIterator& operator++() { node = node->next; return *this; } QValueListIterator operator++(int) { QValueListIterator tmp = *this; node = node->next; return tmp; } QValueListIterator& operator--() { node = node->prev; return *this; } QValueListIterator operator--(int) { QValueListIterator tmp = *this; node = node->prev; return tmp; } QValueListIterator& operator+=( int j ) { while ( j-- ) node = node->next; return *this; } QValueListIterator& operator-=( int j ) { while ( j-- ) node = node->prev; return *this; } }; template class QValueListConstIterator { public: /* */ typedef QValueListNode* NodePtr; #ifndef QT_NO_STL typedef std::bidirectional_iterator_tag iterator_category; #endif typedef T value_type; typedef size_t size_type; #ifndef QT_NO_STL typedef ptrdiff_t difference_type; #else typedef int difference_type; #endif typedef const T* pointer; typedef const T& reference; /* */ NodePtr node; /* */ QValueListConstIterator() : node( 0 ) {} QValueListConstIterator( NodePtr p ) : node( p ) {} QValueListConstIterator( const QValueListConstIterator& it ) : node( it.node ) {} QValueListConstIterator( const QValueListIterator& it ) : node( it.node ) {} bool operator==( const QValueListConstIterator& it ) const { return node == it.node; } bool operator!=( const QValueListConstIterator& it ) const { return node != it.node; } const T& operator*() const { return node->data; } // UDT for T = x* // const T* operator->() const { return &node->data; } QValueListConstIterator& operator++() { node = node->next; return *this; } QValueListConstIterator operator++(int) { QValueListConstIterator tmp = *this; node = node->next; return tmp; } QValueListConstIterator& operator--() { node = node->prev; return *this; } QValueListConstIterator operator--(int) { QValueListConstIterator tmp = *this; node = node->prev; return tmp; } }; template class QValueListPrivate : public QShared { public: /* */ typedef QValueListIterator Iterator; typedef QValueListConstIterator ConstIterator; typedef QValueListNode Node; typedef QValueListNode* NodePtr; typedef size_t size_type; /* */ QValueListPrivate(); QValueListPrivate( const QValueListPrivate& _p ); void derefAndDelete() // ### hack to get around hp-cc brain damage { if ( deref() ) delete this; } #if defined(Q_TEMPLATEDLL) // Workaround MS bug in memory de/allocation in DLL vs. EXE virtual #endif ~QValueListPrivate(); Iterator insert( Iterator it, const T& x ); Iterator remove( Iterator it ); NodePtr find( NodePtr start, const T& x ) const; int findIndex( NodePtr start, const T& x ) const; uint contains( const T& x ) const; uint remove( const T& x ); NodePtr at( size_type i ) const; void clear(); NodePtr node; size_type nodes; }; template Q_INLINE_TEMPLATES QValueListPrivate::QValueListPrivate() { node = new Node; node->next = node->prev = node; nodes = 0; } template Q_INLINE_TEMPLATES QValueListPrivate::QValueListPrivate( const QValueListPrivate& _p ) : QShared() { node = new Node; node->next = node->prev = node; nodes = 0; Iterator b( _p.node->next ); Iterator e( _p.node ); Iterator i( node ); while( b != e ) insert( i, *b++ ); } template Q_INLINE_TEMPLATES QValueListPrivate::~QValueListPrivate() { NodePtr p = node->next; while( p != node ) { NodePtr x = p->next; delete p; p = x; } delete node; } template Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate::Iterator QValueListPrivate::insert( Q_TYPENAME QValueListPrivate::Iterator it, const T& x ) { NodePtr p = new Node( x ); p->next = it.node; p->prev = it.node->prev; it.node->prev->next = p; it.node->prev = p; nodes++; return p; } template Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate::Iterator QValueListPrivate::remove( Q_TYPENAME QValueListPrivate::Iterator it ) { Q_ASSERT ( it.node != node ); NodePtr next = it.node->next; NodePtr prev = it.node->prev; prev->next = next; next->prev = prev; delete it.node; nodes--; return Iterator( next ); } template Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate::NodePtr QValueListPrivate::find( Q_TYPENAME QValueListPrivate::NodePtr start, const T& x ) const { ConstIterator first( start ); ConstIterator last( node ); while( first != last) { if ( *first == x ) return first.node; ++first; } return last.node; } template Q_INLINE_TEMPLATES int QValueListPrivate::findIndex( Q_TYPENAME QValueListPrivate::NodePtr start, const T& x ) const { ConstIterator first( start ); ConstIterator last( node ); int pos = 0; while( first != last) { if ( *first == x ) return pos; ++first; ++pos; } return -1; } template Q_INLINE_TEMPLATES uint QValueListPrivate::contains( const T& x ) const { uint result = 0; Iterator first = Iterator( node->next ); Iterator last = Iterator( node ); while( first != last) { if ( *first == x ) ++result; ++first; } return result; } template Q_INLINE_TEMPLATES uint QValueListPrivate::remove( const T& _x ) { const T x = _x; uint result = 0; Iterator first = Iterator( node->next ); Iterator last = Iterator( node ); while( first != last) { if ( *first == x ) { first = remove( first ); ++result; } else ++first; } return result; } template Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate::NodePtr QValueListPrivate::at( size_type i ) const { Q_ASSERT( i <= nodes ); NodePtr p = node->next; for( size_type x = 0; x < i; ++x ) p = p->next; return p; } template Q_INLINE_TEMPLATES void QValueListPrivate::clear() { nodes = 0; NodePtr p = node->next; while( p != node ) { NodePtr next = p->next; delete p; p = next; } node->next = node->prev = node; } #ifdef QT_CHECK_RANGE # if !defined( QT_NO_DEBUG ) && defined( QT_CHECK_VALUELIST_RANGE ) # define QT_CHECK_INVALID_LIST_ELEMENT if ( empty() ) qWarning( "QValueList: Warning invalid element" ) # define QT_CHECK_INVALID_LIST_ELEMENT_FATAL Q_ASSERT( !empty() ); # else # define QT_CHECK_INVALID_LIST_ELEMENT # define QT_CHECK_INVALID_LIST_ELEMENT_FATAL # endif #else # define QT_CHECK_INVALID_LIST_ELEMENT # define QT_CHECK_INVALID_LIST_ELEMENT_FATAL #endif template class QDeepCopy; template class QValueList { public: /* */ typedef QValueListIterator iterator; typedef QValueListConstIterator const_iterator; typedef T value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef size_t size_type; #ifndef QT_NO_STL typedef ptrdiff_t difference_type; #else typedef int difference_type; #endif /* */ QValueList() { sh = new QValueListPrivate; } QValueList( const QValueList& l ) { sh = l.sh; sh->ref(); } #ifndef QT_NO_STL QValueList( const std::list& l ) { sh = new QValueListPrivate; qCopy( l.begin(), l.end(), std::back_inserter( *this ) ); } #endif ~QValueList() { sh->derefAndDelete(); } QValueList& operator= ( const QValueList& l ) { l.sh->ref(); sh->derefAndDelete(); sh = l.sh; return *this; } #ifndef QT_NO_STL QValueList& operator= ( const std::list& l ) { detach(); qCopy( l.begin(), l.end(), std::back_inserter( *this ) ); return *this; } bool operator== ( const std::list& l ) const { if ( size() != l.size() ) return FALSE; const_iterator it2 = begin(); #if !defined(Q_CC_MIPS) typename #endif std::list::const_iterator it = l.begin(); for ( ; it2 != end(); ++it2, ++it ) if ( !((*it2) == (*it)) ) return FALSE; return TRUE; } #endif bool operator== ( const QValueList& l ) const; bool operator!= ( const QValueList& l ) const { return !( *this == l ); } iterator begin() { detach(); return iterator( sh->node->next ); } const_iterator begin() const { return const_iterator( sh->node->next ); } const_iterator constBegin() const { return const_iterator( sh->node->next ); } iterator end() { detach(); return iterator( sh->node ); } const_iterator end() const { return const_iterator( sh->node ); } const_iterator constEnd() const { return const_iterator( sh->node ); } iterator insert( iterator it, const T& x ) { detach(); return sh->insert( it, x ); } uint remove( const T& x ) { detach(); return sh->remove( x ); } void clear(); // ### 4.0: move out of class QValueList& operator<< ( const T& x ) { append( x ); return *this; } size_type size() const { return sh->nodes; } bool empty() const { return sh->nodes == 0; } void push_front( const T& x ) { detach(); sh->insert( begin(), x ); } void push_back( const T& x ) { detach(); sh->insert( end(), x ); } iterator erase( iterator pos ) { detach(); return sh->remove( pos ); } iterator erase( iterator first, iterator last ); reference front() { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *begin(); } const_reference front() const { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *begin(); } reference back() { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *(--end()); } const_reference back() const { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *(--end()); } void pop_front() { QT_CHECK_INVALID_LIST_ELEMENT; erase( begin() ); } void pop_back() { QT_CHECK_INVALID_LIST_ELEMENT; iterator tmp = end(); erase( --tmp ); } void insert( iterator pos, size_type n, const T& x ); // Some compilers (incl. vc++) would instantiate this function even if // it is not used; this would constrain QValueList to classes that provide // an operator< /* */ QValueList operator+ ( const QValueList& l ) const; QValueList& operator+= ( const QValueList& l ); iterator fromLast() { detach(); return iterator( sh->node->prev ); } const_iterator fromLast() const { return const_iterator( sh->node->prev ); } bool isEmpty() const { return ( sh->nodes == 0 ); } iterator append( const T& x ) { detach(); return sh->insert( end(), x ); } iterator prepend( const T& x ) { detach(); return sh->insert( begin(), x ); } iterator remove( iterator it ) { detach(); return sh->remove( it ); } T& first() { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh->node->next->data; } const T& first() const { QT_CHECK_INVALID_LIST_ELEMENT; return sh->node->next->data; } T& last() { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh->node->prev->data; } const T& last() const { QT_CHECK_INVALID_LIST_ELEMENT; return sh->node->prev->data; } T& operator[] ( size_type i ) { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh->at(i)->data; } const T& operator[] ( size_type i ) const { QT_CHECK_INVALID_LIST_ELEMENT; return sh->at(i)->data; } iterator at( size_type i ) { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return iterator( sh->at(i) ); } const_iterator at( size_type i ) const { QT_CHECK_INVALID_LIST_ELEMENT; return const_iterator( sh->at(i) ); } iterator find ( const T& x ) { detach(); return iterator( sh->find( sh->node->next, x) ); } const_iterator find ( const T& x ) const { return const_iterator( sh->find( sh->node->next, x) ); } iterator find ( iterator it, const T& x ) { detach(); return iterator( sh->find( it.node, x ) ); } const_iterator find ( const_iterator it, const T& x ) const { return const_iterator( sh->find( it.node, x ) ); } int findIndex( const T& x ) const { return sh->findIndex( sh->node->next, x) ; } size_type contains( const T& x ) const { return sh->contains( x ); } size_type count() const { return sh->nodes; } QValueList& operator+= ( const T& x ) { append( x ); return *this; } typedef QValueListIterator Iterator; typedef QValueListConstIterator ConstIterator; typedef T ValueType; protected: /* */ void detach() { if ( sh->count > 1 ) detachInternal(); } /* */ QValueListPrivate* sh; private: void detachInternal(); friend class QDeepCopy< QValueList >; }; template Q_INLINE_TEMPLATES bool QValueList::operator== ( const QValueList& l ) const { if ( size() != l.size() ) return FALSE; const_iterator it2 = begin(); const_iterator it = l.begin(); for( ; it != l.end(); ++it, ++it2 ) if ( !( *it == *it2 ) ) return FALSE; return TRUE; } template Q_INLINE_TEMPLATES void QValueList::clear() { if ( sh->count == 1 ) sh->clear(); else { sh->deref(); sh = new QValueListPrivate; } } template Q_INLINE_TEMPLATES Q_TYPENAME QValueList::iterator QValueList::erase( Q_TYPENAME QValueList::iterator first, Q_TYPENAME QValueList::iterator last ) { while ( first != last ) erase( first++ ); return last; } template Q_INLINE_TEMPLATES void QValueList::insert( Q_TYPENAME QValueList::iterator pos, size_type n, const T& x ) { for ( ; n > 0; --n ) insert( pos, x ); } template Q_INLINE_TEMPLATES QValueList QValueList::operator+ ( const QValueList& l ) const { QValueList l2( *this ); for( const_iterator it = l.begin(); it != l.end(); ++it ) l2.append( *it ); return l2; } template Q_INLINE_TEMPLATES QValueList& QValueList::operator+= ( const QValueList& l ) { QValueList copy = l; for( const_iterator it = copy.begin(); it != copy.end(); ++it ) append( *it ); return *this; } template Q_INLINE_TEMPLATES void QValueList::detachInternal() { sh->deref(); sh = new QValueListPrivate( *sh ); } #ifndef QT_NO_DATASTREAM template Q_INLINE_TEMPLATES QDataStream& operator>>( QDataStream& s, QValueList& l ) { l.clear(); Q_UINT32 c; s >> c; for( Q_UINT32 i = 0; i < c; ++i ) { T t; s >> t; l.append( t ); if ( s.atEnd() ) break; } return s; } template Q_INLINE_TEMPLATES QDataStream& operator<<( QDataStream& s, const QValueList& l ) { s << (Q_UINT32)l.size(); QValueListConstIterator it = l.begin(); for( ; it != l.end(); ++it ) s << *it; return s; } #endif // QT_NO_DATASTREAM #define Q_DEFINED_QVALUELIST #define Q_DEFINED_QVALUELIST #include "qwinexport.h" #endif // QVALUELIST_H "qwsproperty_qws.h/* */ #ifndef QWSPROPERTY_QWS_H #define QWSPROPERTY_QWS_H #ifndef QT_H #include "qwscommand_qws.h" #endif // QT_H /* */ #ifndef QT_NO_QWS_PROPERTIES class QWSPropertyManager { public: enum Mode { PropReplace = 0, PropPrepend, PropAppend }; // pre-defined properties enum Atom { PropSelection = 0 }; QWSPropertyManager(); ~QWSPropertyManager(); bool setProperty( int winId, int property, int mode, const char *data, int len ); bool hasProperty( int winId, int property ); bool removeProperty( int winId, int property ); bool addProperty( int winId, int property ); bool getProperty( int winId, int property, char *&data, int &len ); bool removeProperties( int winId ); private: class Data; Data* d; }; #endif // QT_NO_QWS_PROPERTIES #endif // QWSPROPERTY_QWS_H qtabdialog.h/* */ #ifndef QTABDIALOG_H #define QTABDIALOG_H #ifndef QT_H #include "qdialog.h" #include "qiconset.h" #endif // QT_H #ifndef QT_NO_TABDIALOG class QTabBar; class QTab; class QTabDialogPrivate; class Q_EXPORT QTabDialog : public QDialog { Q_OBJECT public: QTabDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE, WFlags f=0 ); ~QTabDialog(); void show(); void setFont( const QFont & font ); void addTab( QWidget *, const QString &); void addTab( QWidget *child, const QIconSet& iconset, const QString &label); void addTab( QWidget *, QTab* ); void insertTab( QWidget *, const QString &, int index = -1); void insertTab( QWidget *child, const QIconSet& iconset, const QString &label, int index = -1); void insertTab( QWidget *, QTab*, int index = -1 ); void changeTab( QWidget *, const QString &); void changeTab( QWidget *child, const QIconSet& iconset, const QString &label); bool isTabEnabled( QWidget * ) const; void setTabEnabled( QWidget *, bool ); bool isTabEnabled( const char* ) const; // compatibility void setTabEnabled( const char*, bool ); // compatibility void showPage( QWidget * ); void removePage( QWidget * ); QString tabLabel( QWidget * ); QWidget * currentPage() const; void setDefaultButton( const QString &text ); void setDefaultButton(); bool hasDefaultButton() const; void setHelpButton( const QString &text ); void setHelpButton(); bool hasHelpButton() const; void setCancelButton( const QString &text ); void setCancelButton(); bool hasCancelButton() const; void setApplyButton( const QString &text ); void setApplyButton(); bool hasApplyButton() const; #ifndef Q_QDOC void setOKButton( const QString &text = QString::null ); #endif void setOkButton( const QString &text ); void setOkButton(); bool hasOkButton() const; protected: void paintEvent( QPaintEvent * ); void resizeEvent( QResizeEvent * ); void styleChange( QStyle& ); void setTabBar( QTabBar* ); QTabBar* tabBar() const; signals: void aboutToShow(); void applyButtonPressed(); void cancelButtonPressed(); void defaultButtonPressed(); void helpButtonPressed(); void currentChanged( QWidget * ); void selected( const QString& ); // obsolete private slots: void showTab( int i ); private: void setSizes(); void setUpLayout(); QTabDialogPrivate *d; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTabDialog( const QTabDialog & ); QTabDialog& operator=( const QTabDialog & ); #endif }; #endif // QT_NO_TABDIALOG #endif // QTABDIALOG_H qsqldatabase.h/* */ #ifndef QSQLDATABASE_H #define QSQLDATABASE_H #ifndef QT_H #include "qobject.h" #include "qstring.h" #include "qsqlquery.h" #include "qstringlist.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL class QSqlError; class QSqlDriver; class QSqlIndex; class QSqlRecord; class QSqlRecordInfo; class QSqlDatabasePrivate; class QM_EXPORT_SQL QSqlDriverCreatorBase { public: virtual QSqlDriver* createObject() = 0; }; template class QM_EXPORT_SQL QSqlDriverCreator: public QSqlDriverCreatorBase { public: QSqlDriver* createObject() { return new type; } }; class QM_EXPORT_SQL QSqlDatabase : public QObject { Q_OBJECT Q_PROPERTY( QString databaseName READ databaseName WRITE setDatabaseName ) Q_PROPERTY( QString userName READ userName WRITE setUserName ) Q_PROPERTY( QString password READ password WRITE setPassword ) Q_PROPERTY( QString hostName READ hostName WRITE setHostName ) Q_PROPERTY( int port READ port WRITE setPort ) Q_PROPERTY( QString connectOptions READ connectOptions WRITE setConnectOptions ) public: ~QSqlDatabase(); bool open(); bool open( const QString& user, const QString& password ); void close(); bool isOpen() const; bool isOpenError() const; QStringList tables() const; QStringList tables( QSql::TableType type ) const; QSqlIndex primaryIndex( const QString& tablename ) const; QSqlRecord record( const QString& tablename ) const; QSqlRecord record( const QSqlQuery& query ) const; QSqlRecordInfo recordInfo( const QString& tablename ) const; QSqlRecordInfo recordInfo( const QSqlQuery& query ) const; QSqlQuery exec( const QString& query = QString::null ) const; QSqlError lastError() const; bool transaction(); bool commit(); bool rollback(); virtual void setDatabaseName( const QString& name ); virtual void setUserName( const QString& name ); virtual void setPassword( const QString& password ); virtual void setHostName( const QString& host ); virtual void setPort( int p ); void setConnectOptions( const QString& options = QString::null ); QString databaseName() const; QString userName() const; QString password() const; QString hostName() const; QString driverName() const; int port() const; QString connectOptions() const; QSqlDriver* driver() const; // MOC_SKIP_BEGIN QT_STATIC_CONST char * const defaultConnection; // MOC_SKIP_END static QSqlDatabase* addDatabase( const QString& type, const QString& connectionName = defaultConnection ); static QSqlDatabase* addDatabase( QSqlDriver* driver, const QString& connectionName = defaultConnection ); static QSqlDatabase* database( const QString& connectionName = defaultConnection, bool open = TRUE ); static void removeDatabase( const QString& connectionName ); static void removeDatabase( QSqlDatabase* db ); static bool contains( const QString& connectionName = defaultConnection ); static QStringList drivers(); static void registerSqlDriver( const QString& name, const QSqlDriverCreatorBase* creator ); // ### 4.0: creator should not be const static bool isDriverAvailable( const QString& name ); protected: QSqlDatabase( const QString& type, const QString& name, QObject * parent=0, const char * objname=0 ); QSqlDatabase( QSqlDriver* driver, QObject * parent=0, const char * objname=0 ); private: void init( const QString& type, const QString& name ); QSqlDatabasePrivate* d; #if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator= QSqlDatabase( const QSqlDatabase & ); QSqlDatabase &operator=( const QSqlDatabase & ); #endif }; #endif // QT_NO_SQL #endif $qtextcodecplugin.hz/* */ #ifndef QTEXTCODECPLUGIN_H #define QTEXTCODECPLUGIN_H #ifndef QT_H #include "qgplugin.h" #include "qstringlist.h" #endif // QT_H #ifndef QT_NO_TEXTCODECPLUGIN class QTextCodec; class QTextCodecPluginPrivate; class Q_EXPORT QTextCodecPlugin : public QGPlugin { Q_OBJECT public: QTextCodecPlugin(); ~QTextCodecPlugin(); virtual QStringList names() const = 0; virtual QTextCodec *createForName( const QString &name ) = 0; virtual QValueList mibEnums() const = 0; virtual QTextCodec *createForMib( int mib ) = 0; private: QTextCodecPluginPrivate *d; }; #endif // QT_NO_TEXTCODECPLUGIN #endif // QTEXTCODECPLUGIN_H qstringlist.h J/* */ #ifndef QSTRINGLIST_H #define QSTRINGLIST_H #ifndef QT_H #include "qvaluelist.h" #include "qstring.h" #include "qstrlist.h" #endif // QT_H #ifndef QT_NO_STRINGLIST class QRegExp; template class QDeepCopy; #if defined(Q_TEMPLATEDLL) // MOC_SKIP_BEGIN //Q_TEMPLATE_EXTERN template class Q_EXPORT QValueList; // MOC_SKIP_END #endif class Q_EXPORT QStringList : public QValueList { public: QStringList() { } QStringList( const QStringList& l ) : QValueList(l) { } QStringList( const QValueList& l ) : QValueList(l) { } QStringList( const QString& i ) { append(i); } #ifndef QT_NO_CAST_ASCII QStringList( const char* i ) { append(i); } #endif static QStringList fromStrList(const QStrList&); void sort(); static QStringList split( const QString &sep, const QString &str, bool allowEmptyEntries = FALSE ); static QStringList split( const QChar &sep, const QString &str, bool allowEmptyEntries = FALSE ); #ifndef QT_NO_REGEXP static QStringList split( const QRegExp &sep, const QString &str, bool allowEmptyEntries = FALSE ); #endif QString join( const QString &sep ) const; QStringList grep( const QString &str, bool cs = TRUE ) const; #ifndef QT_NO_REGEXP QStringList grep( const QRegExp &expr ) const; #endif QStringList& gres( const QString &before, const QString &after, bool cs = TRUE ); #ifndef QT_NO_REGEXP_CAPTURE QStringList& gres( const QRegExp &expr, const QString &after ); #endif protected: void detach() { QValueList::detach(); } friend class QDeepCopy< QStringList >; }; #ifndef QT_NO_DATASTREAM class QDataStream; extern Q_EXPORT QDataStream &operator>>( QDataStream &, QStringList& ); extern Q_EXPORT QDataStream &operator<<( QDataStream &, const QStringList& ); #endif #endif // QT_NO_STRINGLIST #endif // QSTRINGLIST_H "qsqlpropertymap.h a/* */ #ifndef QSQLPROPERTYMAP_H #define QSQLPROPERTYMAP_H #ifndef QT_H #include "qvariant.h" #include "qstring.h" #endif // QT_H #ifndef QT_NO_SQL_FORM class QWidget; class QSqlPropertyMapPrivate; class Q_EXPORT QSqlPropertyMap { public: QSqlPropertyMap(); virtual ~QSqlPropertyMap(); QVariant property( QWidget * widget ); virtual void setProperty( QWidget * widget, const QVariant & value ); void insert( const QString & classname, const QString & property ); void remove( const QString & classname ); static QSqlPropertyMap * defaultMap(); static void installDefaultMap( QSqlPropertyMap * map ); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QSqlPropertyMap( const QSqlPropertyMap & ); QSqlPropertyMap &operator=( const QSqlPropertyMap & ); #endif QSqlPropertyMapPrivate* d; }; #endif // QT_NO_SQL_FORM #endif // QSQLPROPERTYMAP_H qvalidator.h=/* */ #ifndef QVALIDATOR_H #define QVALIDATOR_H #ifndef QT_H #include "qobject.h" #include "qstring.h" // char*->QString conversion #include "qregexp.h" // QString->QRegExp conversion #endif // QT_H #ifndef QT_NO_VALIDATOR class Q_EXPORT QValidator : public QObject { Q_OBJECT public: QValidator( QObject * parent, const char *name = 0 ); ~QValidator(); enum State { Invalid, Intermediate, Valid=Intermediate, Acceptable }; virtual State validate( QString &, int & ) const = 0; virtual void fixup( QString & ) const; private: #if defined(Q_DISABLE_COPY) QValidator( const QValidator & ); QValidator& operator=( const QValidator & ); #endif }; class Q_EXPORT QIntValidator : public QValidator { Q_OBJECT Q_PROPERTY( int bottom READ bottom WRITE setBottom ) Q_PROPERTY( int top READ top WRITE setTop ) public: QIntValidator( QObject * parent, const char *name = 0 ); QIntValidator( int bottom, int top, QObject * parent, const char *name = 0 ); ~QIntValidator(); QValidator::State validate( QString &, int & ) const; void setBottom( int ); void setTop( int ); virtual void setRange( int bottom, int top ); int bottom() const { return b; } int top() const { return t; } private: #if defined(Q_DISABLE_COPY) QIntValidator( const QIntValidator & ); QIntValidator& operator=( const QIntValidator & ); #endif int b, t; }; #ifndef QT_NO_REGEXP class Q_EXPORT QDoubleValidator : public QValidator { Q_OBJECT Q_PROPERTY( double bottom READ bottom WRITE setBottom ) Q_PROPERTY( double top READ top WRITE setTop ) Q_PROPERTY( int decimals READ decimals WRITE setDecimals ) public: QDoubleValidator( QObject * parent, const char *name = 0 ); QDoubleValidator( double bottom, double top, int decimals, QObject * parent, const char *name = 0 ); ~QDoubleValidator(); QValidator::State validate( QString &, int & ) const; virtual void setRange( double bottom, double top, int decimals = 0 ); void setBottom( double ); void setTop( double ); void setDecimals( int ); double bottom() const { return b; } double top() const { return t; } int decimals() const { return d; } private: #if defined(Q_DISABLE_COPY) QDoubleValidator( const QDoubleValidator & ); QDoubleValidator& operator=( const QDoubleValidator & ); #endif double b, t; int d; }; class Q_EXPORT QRegExpValidator : public QValidator { Q_OBJECT // Q_PROPERTY( QRegExp regExp READ regExp WRITE setRegExp ) public: QRegExpValidator( QObject *parent, const char *name = 0 ); QRegExpValidator( const QRegExp& rx, QObject *parent, const char *name = 0 ); ~QRegExpValidator(); virtual QValidator::State validate( QString& input, int& pos ) const; void setRegExp( const QRegExp& rx ); const QRegExp& regExp() const { return r; } private: #if defined(Q_DISABLE_COPY) QRegExpValidator( const QRegExpValidator& ); QRegExpValidator& operator=( const QRegExpValidator& ); #endif QRegExp r; }; #endif // QT_NO_REGEXP #endif // QT_NO_VALIDATOR #endif // QVALIDATOR_H qvariant.h'/* */ #ifndef QVARIANT_H #define QVARIANT_H #ifndef QT_H #include "qstring.h" #endif // QT_H #ifndef QT_NO_VARIANT class QString; class QCString; class QFont; class QPixmap; class QBrush; class QRect; class QPoint; class QImage; class QSize; class QColor; class QPalette; class QColorGroup; class QIconSet; class QDataStream; class QPointArray; class QRegion; class QBitmap; class QCursor; class QStringList; class QSizePolicy; class QDate; class QTime; class QDateTime; class QBitArray; class QKeySequence; class QPen; // Some headers rejected after QVariant declaration for GCC 2.7.* compatibility class QVariant; #ifndef QT_NO_TEMPLATE_VARIANT template class QValueList; template class QValueListConstIterator; template class QValueListNode; template class QMap; template class QMapConstIterator; #endif class Q_EXPORT QVariant { public: enum Type { Invalid, Map, List, String, StringList, Font, Pixmap, Brush, Rect, Size, Color, Palette, ColorGroup, IconSet, Point, Image, Int, UInt, Bool, Double, CString, PointArray, Region, Bitmap, Cursor, SizePolicy, Date, Time, DateTime, ByteArray, BitArray, KeySequence, Pen, LongLong, ULongLong }; QVariant(); ~QVariant(); QVariant( const QVariant& ); #ifndef QT_NO_DATASTREAM QVariant( QDataStream& s ); #endif QVariant( const QString& ); QVariant( const QCString& ); QVariant( const char* ); #ifndef QT_NO_STRINGLIST QVariant( const QStringList& ); #endif QVariant( const QFont& ); QVariant( const QPixmap& ); QVariant( const QImage& ); QVariant( const QBrush& ); QVariant( const QPoint& ); QVariant( const QRect& ); QVariant( const QSize& ); QVariant( const QColor& ); QVariant( const QPalette& ); QVariant( const QColorGroup& ); QVariant( const QIconSet& ); QVariant( const QPointArray& ); QVariant( const QRegion& ); QVariant( const QBitmap& ); QVariant( const QCursor& ); QVariant( const QDate& ); QVariant( const QTime& ); QVariant( const QDateTime& ); QVariant( const QByteArray& ); QVariant( const QBitArray& ); #ifndef QT_NO_ACCEL QVariant( const QKeySequence& ); #endif QVariant( const QPen& ); #ifndef QT_NO_TEMPLATE_VARIANT QVariant( const QValueList& ); QVariant( const QMap& ); #endif QVariant( int ); QVariant( uint ); QVariant( Q_LLONG ); QVariant( Q_ULLONG ); // ### Problems on some compilers ? QVariant( bool, int ); QVariant( double ); QVariant( QSizePolicy ); QVariant& operator= ( const QVariant& ); bool operator==( const QVariant& ) const; bool operator!=( const QVariant& ) const; Type type() const; const char* typeName() const; bool canCast( Type ) const; bool cast( Type ); bool isValid() const; bool isNull() const; void clear(); const QString toString() const; const QCString toCString() const; #ifndef QT_NO_STRINGLIST const QStringList toStringList() const; #endif const QFont toFont() const; const QPixmap toPixmap() const; const QImage toImage() const; const QBrush toBrush() const; const QPoint toPoint() const; const QRect toRect() const; const QSize toSize() const; const QColor toColor() const; const QPalette toPalette() const; const QColorGroup toColorGroup() const; const QIconSet toIconSet() const; const QPointArray toPointArray() const; const QBitmap toBitmap() const; const QRegion toRegion() const; const QCursor toCursor() const; const QDate toDate() const; const QTime toTime() const; const QDateTime toDateTime() const; const QByteArray toByteArray() const; const QBitArray toBitArray() const; #ifndef QT_NO_ACCEL const QKeySequence toKeySequence() const; #endif const QPen toPen() const; int toInt( bool * ok=0 ) const; uint toUInt( bool * ok=0 ) const; Q_LLONG toLongLong( bool * ok=0 ) const; Q_ULLONG toULongLong( bool * ok=0 ) const; bool toBool() const; double toDouble( bool * ok=0 ) const; #ifndef QT_NO_TEMPLATE_VARIANT const QValueList toList() const; const QMap toMap() const; #endif QSizePolicy toSizePolicy() const; #ifndef QT_NO_TEMPLATE_VARIANT QValueListConstIterator stringListBegin() const; QValueListConstIterator stringListEnd() const; QValueListConstIterator listBegin() const; QValueListConstIterator listEnd() const; QMapConstIterator mapBegin() const; QMapConstIterator mapEnd() const; QMapConstIterator mapFind( const QString& ) const; #endif QString& asString(); QCString& asCString(); #ifndef QT_NO_STRINGLIST QStringList& asStringList(); #endif QFont& asFont(); QPixmap& asPixmap(); QImage& asImage(); QBrush& asBrush(); QPoint& asPoint(); QRect& asRect(); QSize& asSize(); QColor& asColor(); QPalette& asPalette(); QColorGroup& asColorGroup(); QIconSet& asIconSet(); QPointArray& asPointArray(); QBitmap& asBitmap(); QRegion& asRegion(); QCursor& asCursor(); QDate& asDate(); QTime& asTime(); QDateTime& asDateTime(); QByteArray& asByteArray(); QBitArray& asBitArray(); #ifndef QT_NO_ACCEL QKeySequence& asKeySequence(); #endif QPen& asPen(); int& asInt(); uint& asUInt(); Q_LLONG& asLongLong(); Q_ULLONG& asULongLong(); bool& asBool(); double& asDouble(); #ifndef QT_NO_TEMPLATE_VARIANT QValueList& asList(); QMap& asMap(); #endif QSizePolicy& asSizePolicy(); #ifndef QT_NO_DATASTREAM void load( QDataStream& ); void save( QDataStream& ) const; #endif static const char* typeToName( Type typ ); static Type nameToType( const char* name ); private: void detach(); class Private : public QShared { public: Private(); Private( Private* ); ~Private(); void clear(); Type typ; union { uint u; int i; Q_LLONG ll; Q_ULLONG ull; bool b; double d; void *ptr; } value; uint is_null : 1; // ## 4.0 merge with typ }; Private* d; public: void* rawAccess( void* ptr = 0, Type typ = Invalid, bool deepCopy = FALSE ); }; // down here for GCC 2.7.* compatibility #ifndef QT_H #include "qvaluelist.h" #include "qstringlist.h" #include "qmap.h" #endif // QT_H inline QVariant::Type QVariant::type() const { return d->typ; } inline bool QVariant::isValid() const { return (d->typ != Invalid); } #ifndef QT_NO_TEMPLATE_VARIANT inline QValueListConstIterator QVariant::stringListBegin() const { if ( d->typ != StringList ) return QValueListConstIterator(); return ((const QStringList*)d->value.ptr)->begin(); } inline QValueListConstIterator QVariant::stringListEnd() const { if ( d->typ != StringList ) return QValueListConstIterator(); return ((const QStringList*)d->value.ptr)->end(); } inline QValueListConstIterator QVariant::listBegin() const { if ( d->typ != List ) return QValueListConstIterator(); return ((const QValueList*)d->value.ptr)->begin(); } inline QValueListConstIterator QVariant::listEnd() const { if ( d->typ != List ) return QValueListConstIterator(); return ((const QValueList*)d->value.ptr)->end(); } inline QMapConstIterator QVariant::mapBegin() const { if ( d->typ != Map ) return QMapConstIterator(); return ((const QMap*)d->value.ptr)->begin(); } inline QMapConstIterator QVariant::mapEnd() const { if ( d->typ != Map ) return QMapConstIterator(); return ((const QMap*)d->value.ptr)->end(); } inline QMapConstIterator QVariant::mapFind( const QString& key ) const { if ( d->typ != Map ) return QMapConstIterator(); return ((const QMap*)d->value.ptr)->find( key ); } #endif #ifndef QT_NO_DATASTREAM Q_EXPORT QDataStream& operator>> ( QDataStream& s, QVariant& p ); Q_EXPORT QDataStream& operator<< ( QDataStream& s, const QVariant& p ); Q_EXPORT QDataStream& operator>> ( QDataStream& s, QVariant::Type& p ); Q_EXPORT QDataStream& operator<< ( QDataStream& s, const QVariant::Type p ); #endif #endif //QT_NO_VARIANT #endif // QVARIANT_H qwindefs.h+/* */ #ifndef QWINDEFS_H #define QWINDEFS_H #include "qwindowdefs.h" #endif &qwsdecoration_qws.h/* */ #ifndef QWSDECORATION_QWS_H #define QWSDECORATION_QWS_H #ifndef QT_H #include "qregion.h" #endif // QT_H class QPopupMenu; /* */ class QWSDecoration { public: QWSDecoration() {} virtual ~QWSDecoration() {} enum Region { None=0, All=1, Title=2, Top=3, Bottom=4, Left=5, Right=6, TopLeft=7, TopRight=8, BottomLeft=9, BottomRight=10, Close=11, Minimize=12, Maximize=13, Normalize=14, Menu=15, LastRegion=Menu }; virtual QRegion region(const QWidget *, const QRect &rect, Region r=All) = 0; virtual void close( QWidget * ); virtual void minimize( QWidget * ); virtual void maximize( QWidget * ); #ifndef QT_NO_POPUPMENU virtual QPopupMenu *menu(const QWidget *, const QPoint &); #endif virtual void paint(QPainter *, const QWidget *) = 0; virtual void paintButton(QPainter *, const QWidget *, Region, int state) = 0; }; #endif // QWSDECORATION_QWS_H qstyleplugin.h/* */ #ifndef QSTYLEPLUGIN_H #define QSTYLEPLUGIN_H #ifndef QT_H #include "qgplugin.h" #include "qstringlist.h" #endif // QT_H #ifndef QT_NO_STYLE #ifndef QT_NO_COMPONENT class QStyle; class QStylePluginPrivate; class Q_EXPORT QStylePlugin : public QGPlugin { Q_OBJECT public: QStylePlugin(); ~QStylePlugin(); virtual QStringList keys() const = 0; virtual QStyle *create( const QString &key ) = 0; private: QStylePluginPrivate *d; }; #endif // QT_NO_COMPONENT #endif // QT_NO_STYLE #endif // QSTYLEPLUGIN_H qtextbrowser.h X/* */ #ifndef QTEXTBROWSER_H #define QTEXTBROWSER_H #ifndef QT_H #include "qptrlist.h" #include "qpixmap.h" #include "qcolor.h" #include "qtextedit.h" #endif // QT_H #ifndef QT_NO_TEXTBROWSER class QTextBrowserData; class Q_EXPORT QTextBrowser : public QTextEdit { Q_OBJECT Q_PROPERTY( QString source READ source WRITE setSource ) Q_OVERRIDE( int undoDepth DESIGNABLE false SCRIPTABLE false ) Q_OVERRIDE( bool overwriteMode DESIGNABLE false SCRIPTABLE false ) Q_OVERRIDE( bool modified SCRIPTABLE false) Q_OVERRIDE( bool readOnly DESIGNABLE false SCRIPTABLE false ) Q_OVERRIDE( bool undoRedoEnabled DESIGNABLE false SCRIPTABLE false ) public: QTextBrowser( QWidget* parent=0, const char* name=0 ); ~QTextBrowser(); QString source() const; public slots: virtual void setSource(const QString& name); virtual void backward(); virtual void forward(); virtual void home(); virtual void reload(); void setText( const QString &txt ) { setText( txt, QString::null ); } virtual void setText( const QString &txt, const QString &context ); signals: void backwardAvailable( bool ); void forwardAvailable( bool ); void sourceChanged( const QString& ); void highlighted( const QString& ); void linkClicked( const QString& ); void anchorClicked( const QString&, const QString& ); protected: void keyPressEvent( QKeyEvent * e); private: void popupDetail( const QString& contents, const QPoint& pos ); bool linksEnabled() const { return TRUE; } void emitHighlighted( const QString &s ); void emitLinkClicked( const QString &s ); QTextBrowserData *d; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTextBrowser( const QTextBrowser & ); QTextBrowser& operator=( const QTextBrowser & ); #endif }; #endif // QT_NO_TEXTBROWSER #endif // QTEXTBROWSER_H .qwsbeosdecoration_qws.h/* */ #ifndef QWSBEOSDECORATION_QWS_H #define QWSBEOSDECORATION_QWS_H #ifndef QT_H #include "qwsdefaultdecoration_qws.h" #endif // QT_H #ifndef QT_NO_QWS_BEOS_WM_STYLE class QWSBeOSDecoration : public QWSDefaultDecoration { public: QWSBeOSDecoration(); virtual ~QWSBeOSDecoration(); virtual QRegion region(const QWidget *, const QRect &rect, Region); virtual void paint(QPainter *, const QWidget *); virtual void paintButton(QPainter *, const QWidget *, Region, int state); protected: virtual int getTitleWidth(const QWidget *); virtual int getTitleHeight(const QWidget *); virtual const char **menuPixmap(); // virtual const char **normalizePixmap(); }; #endif // QT_NO_QWS_BEOS_WM_STYLE #endif // QWSBEOSDECORATION_QWS_H "qwindowdefs_win.h /* */ #ifndef QWINDOWDEFS_WIN_H #ifndef QT_H #endif // QT_H #define QWINDOWDEFS_WIN_H #ifndef QT_H #endif // QT_H #if defined(Q_CC_BOR) && !defined(__CONSOLE__) #define NEEDS_QMAIN #elif defined(Q_CC_WAT) #define NEEDS_QMAIN #endif #if !defined(Q_NOWINSTRICT) #define Q_WINSTRICT #endif #if defined(Q_WINSTRICT) #if !defined(STRICT) #define STRICT #endif #undef NO_STRICT #define Q_DECLARE_HANDLE(name) struct name##__; typedef struct name##__ *name #else #if !defined(NO_STRICT) #define NO_STRICT #endif #undef STRICT #define Q_DECLARE_HANDLE(name) typedef HANDLE name #endif #ifndef HINSTANCE Q_DECLARE_HANDLE(HINSTANCE); #endif #ifndef HDC Q_DECLARE_HANDLE(HDC); #endif #ifndef HWND Q_DECLARE_HANDLE(HWND); #endif #ifndef HFONT Q_DECLARE_HANDLE(HFONT); #endif #ifndef HPEN Q_DECLARE_HANDLE(HPEN); #endif #ifndef HBRUSH Q_DECLARE_HANDLE(HBRUSH); #endif #ifndef HBITMAP Q_DECLARE_HANDLE(HBITMAP); #endif #ifndef HICON Q_DECLARE_HANDLE(HICON); #endif #ifndef HCURSOR typedef HICON HCURSOR; #endif #ifndef HPALETTE Q_DECLARE_HANDLE(HPALETTE); #endif #ifndef HRGN Q_DECLARE_HANDLE(HRGN); #endif #ifndef HMONITOR Q_DECLARE_HANDLE(HMONITOR); #endif #ifndef HRESULT typedef long HRESULT; #endif typedef struct tagMSG MSG; typedef HWND WId; Q_EXPORT HINSTANCE qWinAppInst(); Q_EXPORT HINSTANCE qWinAppPrevInst(); Q_EXPORT int qWinAppCmdShow(); Q_EXPORT HDC qt_display_dc(); #define QT_WIN_PAINTER_MEMBERS \ HDC hdc; \ HPEN hpen; \ HFONT hfont; \ HBRUSH hbrush; \ HBITMAP hbrushbm; \ HPALETTE holdpal; \ uint nocolBrush : 1;\ uint pixmapBrush : 1;\ uint usingNativeXForm : 1; \ uint hasUsedNativeXForm : 1;\ bool nativeXForm( bool ); #endif qtextedit.hJ/* */ #ifndef QTEXTEDIT_H #define QTEXTEDIT_H #ifndef QT_H #include "qscrollview.h" #include "qstylesheet.h" #include "qptrvector.h" #include "qvaluelist.h" #include "qptrlist.h" #endif // QT_H #ifndef QT_NO_TEXTEDIT // uncomment below to enable optimization mode - also uncomment the // optimDoAutoScroll() private slot since moc ignores #ifdefs.. #define QT_TEXTEDIT_OPTIMIZATION class QPainter; class QTextDocument; class QTextCursor; class QKeyEvent; class QResizeEvent; class QMouseEvent; class QTimer; class QTextString; class QTextCommand; class QTextParagraph; class QTextFormat; class QFont; class QColor; class QTextEdit; class QTextBrowser; class QTextString; struct QUndoRedoInfoPrivate; class QPopupMenu; class QTextEditPrivate; class QSyntaxHighlighter; #ifdef QT_TEXTEDIT_OPTIMIZATION class QTextEditOptimPrivate { public: // Note: no left-tag has any value for leftTag or parent, and // no right-tag has any formatting flags set. enum TagType { Color = 0, Format = 1 }; struct Tag { TagType type:2; bool bold:1; bool italic:1; bool underline:1; int line; int index; Tag * leftTag; // ptr to left-tag in a left-right tag pair Tag * parent; // ptr to parent left-tag in a nested tag Tag * prev; Tag * next; QString tag; }; QTextEditOptimPrivate() { len = numLines = maxLineWidth = 0; selStart.line = selStart.index = -1; selEnd.line = selEnd.index = -1; search.line = search.index = 0; tags = lastTag = 0; } void clearTags() { Tag * itr = tags; while ( tags ) { itr = tags; tags = tags->next; delete itr; } tags = lastTag = 0; tagIndex.clear(); } ~QTextEditOptimPrivate() { clearTags(); } int len; int numLines; int maxLineWidth; struct Selection { int line; int index; }; Selection selStart, selEnd, search; Tag * tags, * lastTag; QMap lines; QMap tagIndex; }; #endif class Q_EXPORT QTextEdit : public QScrollView { friend class QTextBrowser; friend class QSyntaxHighlighter; Q_OBJECT Q_ENUMS( WordWrap WrapPolicy ) Q_SETS( AutoFormatting ) Q_PROPERTY( TextFormat textFormat READ textFormat WRITE setTextFormat ) Q_PROPERTY( QString text READ text WRITE setText ) Q_PROPERTY( QBrush paper READ paper WRITE setPaper ) Q_PROPERTY( bool linkUnderline READ linkUnderline WRITE setLinkUnderline ) Q_PROPERTY( QString documentTitle READ documentTitle ) Q_PROPERTY( int length READ length ) Q_PROPERTY( WordWrap wordWrap READ wordWrap WRITE setWordWrap ) Q_PROPERTY( int wrapColumnOrWidth READ wrapColumnOrWidth WRITE setWrapColumnOrWidth ) Q_PROPERTY( WrapPolicy wrapPolicy READ wrapPolicy WRITE setWrapPolicy ) Q_PROPERTY( bool hasSelectedText READ hasSelectedText ) Q_PROPERTY( QString selectedText READ selectedText ) Q_PROPERTY( int undoDepth READ undoDepth WRITE setUndoDepth ) Q_PROPERTY( bool overwriteMode READ isOverwriteMode WRITE setOverwriteMode ) Q_PROPERTY( bool modified READ isModified WRITE setModified DESIGNABLE false ) Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly ) Q_PROPERTY( bool undoRedoEnabled READ isUndoRedoEnabled WRITE setUndoRedoEnabled ) Q_PROPERTY( int tabStopWidth READ tabStopWidth WRITE setTabStopWidth ) Q_PROPERTY( bool tabChangesFocus READ tabChangesFocus WRITE setTabChangesFocus ) Q_PROPERTY( AutoFormatting autoFormatting READ autoFormatting WRITE setAutoFormatting ) public: enum WordWrap { NoWrap, WidgetWidth, FixedPixelWidth, FixedColumnWidth }; enum WrapPolicy { AtWordBoundary, AtWhiteSpace = AtWordBoundary, // AtWhiteSpace is deprecated Anywhere, AtWordOrDocumentBoundary }; enum AutoFormatting { AutoNone = 0, AutoBulletList = 0x00000001, AutoAll = 0xffffffff }; enum KeyboardAction { ActionBackspace, ActionDelete, ActionReturn, ActionKill, ActionWordBackspace, ActionWordDelete }; enum CursorAction { MoveBackward, MoveForward, MoveWordBackward, MoveWordForward, MoveUp, MoveDown, MoveLineStart, MoveLineEnd, MoveHome, MoveEnd, MovePgUp, MovePgDown }; enum VerticalAlignment { AlignNormal, AlignSuperScript, AlignSubScript }; enum TextInsertionFlags { RedoIndentation = 0x0001, CheckNewLines = 0x0002, RemoveSelected = 0x0004 }; QTextEdit( const QString& text, const QString& context = QString::null, QWidget* parent=0, const char* name=0); QTextEdit( QWidget* parent=0, const char* name=0 ); virtual ~QTextEdit(); void setPalette( const QPalette & ); QString text() const; QString text( int para ) const; TextFormat textFormat() const; QString context() const; QString documentTitle() const; void getSelection( int *paraFrom, int *indexFrom, int *paraTo, int *indexTo, int selNum = 0 ) const; virtual bool find( const QString &expr, bool cs, bool wo, bool forward = TRUE, int *para = 0, int *index = 0 ); int paragraphs() const; int lines() const; int linesOfParagraph( int para ) const; int lineOfChar( int para, int chr ); int length() const; QRect paragraphRect( int para ) const; int paragraphAt( const QPoint &pos ) const; int charAt( const QPoint &pos, int *para ) const; int paragraphLength( int para ) const; QStyleSheet* styleSheet() const; #ifndef QT_NO_MIME QMimeSourceFactory* mimeSourceFactory() const; #endif QBrush paper() const; bool linkUnderline() const; int heightForWidth( int w ) const; bool hasSelectedText() const; QString selectedText() const; bool isUndoAvailable() const; bool isRedoAvailable() const; WordWrap wordWrap() const; int wrapColumnOrWidth() const; WrapPolicy wrapPolicy() const; int tabStopWidth() const; QString anchorAt( const QPoint& pos ); QString anchorAt( const QPoint& pos, AnchorAttribute a ); QSize sizeHint() const; bool isReadOnly() const { return readonly; } void getCursorPosition( int *parag, int *index ) const; bool isModified() const; bool italic() const; bool bold() const; bool underline() const; QString family() const; int pointSize() const; QColor color() const; QFont font() const; QFont currentFont() const; int alignment() const; int undoDepth() const; // do not use, will go away virtual bool getFormat( int para, int index, QFont *font, QColor *color, VerticalAlignment *verticalAlignment ); // do not use, will go away virtual bool getParagraphFormat( int para, QFont *font, QColor *color, VerticalAlignment *verticalAlignment, int *alignment, QStyleSheetItem::DisplayMode *displayMode, QStyleSheetItem::ListStyle *listStyle, int *listDepth ); bool isOverwriteMode() const { return overWrite; } QColor paragraphBackgroundColor( int para ) const; bool isUndoRedoEnabled() const; bool eventFilter( QObject *o, QEvent *e ); bool tabChangesFocus() const; void setAutoFormatting( uint features ); uint autoFormatting() const; QSyntaxHighlighter *syntaxHighlighter() const; public slots: void setEnabled( bool ); #ifndef QT_NO_MIME virtual void setMimeSourceFactory( QMimeSourceFactory* factory ); #endif virtual void setStyleSheet( QStyleSheet* styleSheet ); virtual void scrollToAnchor( const QString& name ); virtual void setPaper( const QBrush& pap ); virtual void setLinkUnderline( bool ); virtual void setWordWrap( WordWrap mode ); virtual void setWrapColumnOrWidth( int ); virtual void setWrapPolicy( WrapPolicy policy ); virtual void copy(); virtual void append( const QString& text ); void setText( const QString &txt ) { setText( txt, QString::null ); } virtual void setText( const QString &txt, const QString &context ); virtual void setTextFormat( TextFormat f ); virtual void selectAll( bool select = TRUE ); virtual void setTabStopWidth( int ts ); virtual void zoomIn( int range ); virtual void zoomIn() { zoomIn( 1 ); } virtual void zoomOut( int range ); virtual void zoomOut() { zoomOut( 1 ); } virtual void zoomTo( int size ); virtual void sync(); virtual void setReadOnly( bool b ); virtual void undo(); virtual void redo(); virtual void cut(); virtual void paste(); #ifndef QT_NO_CLIPBOARD virtual void pasteSubType( const QCString &subtype ); #endif virtual void clear(); virtual void del(); virtual void indent(); virtual void setItalic( bool b ); virtual void setBold( bool b ); virtual void setUnderline( bool b ); virtual void setFamily( const QString &f ); virtual void setPointSize( int s ); virtual void setColor( const QColor &c ); virtual void setFont( const QFont &f ); virtual void setVerticalAlignment( VerticalAlignment a ); virtual void setAlignment( int a ); // do not use, will go away virtual void setParagType( QStyleSheetItem::DisplayMode dm, QStyleSheetItem::ListStyle listStyle ); virtual void setCursorPosition( int parag, int index ); virtual void setSelection( int parag_from, int index_from, int parag_to, int index_to, int selNum = 0 ); virtual void setSelectionAttributes( int selNum, const QColor &back, bool invertText ); virtual void setModified( bool m ); virtual void resetFormat(); virtual void setUndoDepth( int d ); virtual void setFormat( QTextFormat *f, int flags ); virtual void ensureCursorVisible(); virtual void placeCursor( const QPoint &pos, QTextCursor *c = 0 ); virtual void moveCursor( CursorAction action, bool select ); virtual void doKeyboardAction( KeyboardAction action ); virtual void removeSelectedText( int selNum = 0 ); virtual void removeSelection( int selNum = 0 ); virtual void setCurrentFont( const QFont &f ); virtual void setOverwriteMode( bool b ) { overWrite = b; } virtual void scrollToBottom(); void insert( const QString &text, uint insertionFlags = CheckNewLines | RemoveSelected ); // ## virtual in 4.0 // obsolete virtual void insert( const QString &text, bool, bool = TRUE, bool = TRUE ); virtual void insertAt( const QString &text, int para, int index ); virtual void removeParagraph( int para ); virtual void insertParagraph( const QString &text, int para ); virtual void setParagraphBackgroundColor( int para, const QColor &bg ); virtual void clearParagraphBackground( int para ); virtual void setUndoRedoEnabled( bool b ); void setTabChangesFocus( bool b ); // ### make virtual in 4.0 #ifdef QT_TEXTEDIT_OPTIMIZATION void polish(); void setMaxLogLines( int numLines ); int maxLogLines(); #endif signals: void textChanged(); void selectionChanged(); void copyAvailable( bool ); void undoAvailable( bool yes ); void redoAvailable( bool yes ); void currentFontChanged( const QFont &f ); void currentColorChanged( const QColor &c ); void currentAlignmentChanged( int a ); void currentVerticalAlignmentChanged( VerticalAlignment a ); void cursorPositionChanged( QTextCursor *c ); void cursorPositionChanged( int para, int pos ); void returnPressed(); void modificationChanged( bool m ); void clicked( int parag, int index ); void doubleClicked( int parag, int index ); protected: void repaintChanged(); void updateStyles(); void drawContents( QPainter *p, int cx, int cy, int cw, int ch ); bool event( QEvent *e ); void keyPressEvent( QKeyEvent *e ); void resizeEvent( QResizeEvent *e ); void viewportResizeEvent( QResizeEvent* ); void contentsMousePressEvent( QMouseEvent *e ); void contentsMouseMoveEvent( QMouseEvent *e ); void contentsMouseReleaseEvent( QMouseEvent *e ); void contentsMouseDoubleClickEvent( QMouseEvent *e ); #ifndef QT_NO_WHEELEVENT void contentsWheelEvent( QWheelEvent *e ); #endif void imStartEvent( QIMEvent * ); void imComposeEvent( QIMEvent * ); void imEndEvent( QIMEvent * ); #ifndef QT_NO_DRAGANDDROP void contentsDragEnterEvent( QDragEnterEvent *e ); void contentsDragMoveEvent( QDragMoveEvent *e ); void contentsDragLeaveEvent( QDragLeaveEvent *e ); void contentsDropEvent( QDropEvent *e ); #endif void contentsContextMenuEvent( QContextMenuEvent *e ); bool focusNextPrevChild( bool next ); QTextDocument *document() const; QTextCursor *textCursor() const; void setDocument( QTextDocument *doc ); virtual QPopupMenu *createPopupMenu( const QPoint& pos ); virtual QPopupMenu *createPopupMenu(); void drawCursor( bool visible ); void windowActivationChange( bool ); protected slots: virtual void doChangeInterval(); void sliderReleased(); // ### make virtual in 4.0 #if (QT_VERSION >= 0x040000) #error "Some functions need to be changed to virtual for Qt 4.0" #endif private slots: void formatMore(); void doResize(); void autoScrollTimerDone(); void blinkCursor(); void setModified(); void startDrag(); void documentWidthChanged( int w ); void clipboardChanged(); private: struct Q_EXPORT UndoRedoInfo { enum Type { Invalid, Insert, Delete, Backspace, Return, RemoveSelected, Format, Style }; UndoRedoInfo( QTextDocument *dc ); ~UndoRedoInfo(); void clear(); bool valid() const; QUndoRedoInfoPrivate *d; int id; int index; int eid; int eindex; QTextFormat *format; int flags; Type type; QTextDocument *doc; QByteArray styleInformation; }; private: void updateCursor( const QPoint & pos ); void handleMouseMove( const QPoint& pos ); void drawContents( QPainter * ); virtual bool linksEnabled() const { return FALSE; } void init(); void checkUndoRedoInfo( UndoRedoInfo::Type t ); void updateCurrentFormat(); bool handleReadOnlyKeyEvent( QKeyEvent *e ); void makeParagVisible( QTextParagraph *p ); void normalCopy(); void copyToClipboard(); #ifndef QT_NO_MIME QCString pickSpecial(QMimeSource* ms, bool always_ask, const QPoint&); QTextDrag *dragObject( QWidget *parent = 0 ) const; #endif #ifndef QT_NO_MIMECLIPBOARD void pasteSpecial(const QPoint&); #endif void setFontInternal( const QFont &f ); virtual void emitHighlighted( const QString & ) {} virtual void emitLinkClicked( const QString & ) {} void readFormats( QTextCursor &c1, QTextCursor &c2, QTextString &text, bool fillStyles = FALSE ); void clearUndoRedo(); void paintDocument( bool drawAll, QPainter *p, int cx = -1, int cy = -1, int cw = -1, int ch = -1 ); void moveCursor( CursorAction action ); void ensureFormatted( QTextParagraph *p ); void placeCursor( const QPoint &pos, QTextCursor *c, bool link ); void updateMicroFocusHint(); #ifdef QT_TEXTEDIT_OPTIMIZATION bool checkOptimMode(); QString optimText() const; void optimSetText( const QString &str ); void optimAppend( const QString &str ); void optimInsert( const QString &str, int line, int index ); void optimDrawContents( QPainter * p, int cx, int cy, int cw, int ch ); void optimMousePressEvent( QMouseEvent * e ); void optimMouseReleaseEvent( QMouseEvent * e ); void optimMouseMoveEvent( QMouseEvent * e ); int optimCharIndex( const QString &str, int mx ) const; void optimSelectAll(); void optimRemoveSelection(); void optimSetSelection( int startLine, int startIdx, int endLine, int endIdx ); bool optimHasSelection() const; QString optimSelectedText() const; bool optimFind( const QString & str, bool, bool, bool, int *, int * ); void optimParseTags( QString * str, int lineNo = -1, int indexOffset = 0 ); QTextEditOptimPrivate::Tag * optimPreviousLeftTag( int line ); void optimSetTextFormat( QTextDocument *, QTextCursor *, QTextFormat * f, int, int, QTextEditOptimPrivate::Tag * t ); QTextEditOptimPrivate::Tag * optimAppendTag( int index, const QString & tag ); QTextEditOptimPrivate::Tag * optimInsertTag( int line, int index, const QString & tag ); void optimCheckLimit( const QString& str ); bool optimHasBoldMetrics( int line ); private slots: void optimDoAutoScroll(); #endif // QT_TEXTEDIT_OPTIMIZATION private: #ifndef QT_NO_CLIPBOARD void pasteSubType( const QCString &subtype, QMimeSource *m ); #endif private: QTextDocument *doc; QTextCursor *cursor; QTimer *formatTimer, *scrollTimer, *changeIntervalTimer, *blinkTimer, *dragStartTimer; QTextParagraph *lastFormatted; int interval; UndoRedoInfo undoRedoInfo; QTextFormat *currentFormat; int currentAlignment; QPoint oldMousePos, mousePos; QPoint dragStartPos; QString onLink; WordWrap wrapMode; WrapPolicy wPolicy; int wrapWidth; QString pressedLink; QTextEditPrivate *d; bool inDoubleClick : 1; bool mousePressed : 1; bool cursorVisible : 1; bool blinkCursorVisible : 1; bool readOnly : 1; bool modified : 1; bool mightStartDrag : 1; bool inDnD : 1; bool readonly : 1; bool undoEnabled : 1; bool overWrite : 1; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTextEdit( const QTextEdit & ); QTextEdit &operator=( const QTextEdit & ); #endif }; inline QTextDocument *QTextEdit::document() const { return doc; } inline QTextCursor *QTextEdit::textCursor() const { return cursor; } inline void QTextEdit::setCurrentFont( const QFont &f ) { QTextEdit::setFontInternal( f ); } #endif //QT_NO_TEXTEDIT #endif //QTEXTVIEW_H "qwindowsxpstyle.hT/* */ #ifndef QWINDOWSXPSTYLE_H #define QWINDOWSXPSTYLE_H #ifndef QT_H #include "qwindowsstyle.h" #endif // QT_H #if !defined(QT_NO_STYLE_WINDOWSXP) || defined(QT_PLUGIN) #if defined(QT_PLUGIN) #define Q_EXPORT_STYLE_WINDOWSXP #else #define Q_EXPORT_STYLE_WINDOWSXP Q_EXPORT #endif class QWindowsXPStylePrivate; class Q_EXPORT_STYLE_WINDOWSXP QWindowsXPStyle : public QWindowsStyle { Q_OBJECT public: QWindowsXPStyle(); ~QWindowsXPStyle(); void unPolish( QApplication* ); void polish( QApplication* ); void polish( QWidget* ); void unPolish( QWidget* ); void drawPrimitive( PrimitiveElement op, QPainter *p, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const; void drawControl( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags how = Style_Default, const QStyleOption& = QStyleOption::Default ) const; void drawControlMask( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption& = QStyleOption::Default ) const; void drawComplexControl( ComplexControl control, QPainter* p, const QWidget* w, const QRect& r, const QColorGroup& cg, SFlags flags = Style_Default, SCFlags sub = SC_All, SCFlags subActive = SC_None, const QStyleOption& = QStyleOption::Default ) const; int pixelMetric( PixelMetric metic, const QWidget *widget = 0 ) const; QRect querySubControlMetrics( ComplexControl control, const QWidget *widget, SubControl sc, const QStyleOption& = QStyleOption::Default ) const; QSize sizeFromContents( ContentsType contents, const QWidget *widget, const QSize &contentsSize, const QStyleOption& = QStyleOption::Default ) const; int styleHint( StyleHint stylehint, const QWidget *widget = 0, const QStyleOption& = QStyleOption::Default, QStyleHintReturn* returnData = 0 ) const; protected: bool eventFilter( QObject *o, QEvent *e ); void updateRegion( QWidget *widget ); protected slots: void activeTabChanged(); private: QWindowsXPStylePrivate *d; friend class QStyleFactory; friend class QWindowsXPStylePrivate; static bool resolveSymbols(); #if defined(Q_DISABLE_COPY) QWindowsXPStyle( const QWindowsXPStyle & ); QWindowsXPStyle& operator=( const QWindowsXPStyle & ); #endif }; #endif // QT_NO_STYLE_WINDOWSXP #endif // QWINDOWSXPSTYLE_H qstyle.hJo/* */ #ifndef QSTYLE_H #define QSTYLE_H #ifndef QT_H #include "qobject.h" #endif // QT_H #ifndef QT_NO_STYLE class QPopupMenu; class QStylePrivate; class QMenuItem; class QTab; class QListViewItem; class QCheckListItem; class QStyleOption { public: enum StyleOptionDefault { Default }; QStyleOption(StyleOptionDefault=Default) : def(TRUE) {} // Note: we don't use default arguments since that is unnecessary // initialization. QStyleOption(int in1) : def(FALSE), i1(in1) {} QStyleOption(int in1, int in2) : def(FALSE), i1(in1), i2(in2) {} QStyleOption(int in1, int in2, int in3, int in4) : def(FALSE), i1(in1), i2(in2), i3(in3), i4(in4) {} QStyleOption(QMenuItem* m) : def(FALSE), mi(m) {} QStyleOption(QMenuItem* m, int in1) : def(FALSE), mi(m), i1(in1) {} QStyleOption(QMenuItem* m, int in1, int in2) : def(FALSE), mi(m), i1(in1), i2(in2) {} QStyleOption(const QColor& c) : def(FALSE), cl(&c) {} QStyleOption(QTab* t) : def(FALSE), tb(t) {} QStyleOption(QListViewItem* i) : def(FALSE), li(i) {} QStyleOption(QCheckListItem* i) : def(FALSE), cli(i) {} QStyleOption(Qt::ArrowType a) : def(FALSE), i1((int)a) {} QStyleOption(const QRect& r) : def(FALSE), i1(r.x()), i2(r.y()), i3(r.width()),i4(r.height()){} QStyleOption(QWidget *w) : def(FALSE), p1((void*)w) {} bool isDefault() const { return def; } int day() const { return i1; } int lineWidth() const { return i1; } int midLineWidth() const { return i2; } int frameShape() const { return i3; } int frameShadow() const { return i4; } int headerSection() const { return i1; } QMenuItem* menuItem() const { return mi; } int maxIconWidth() const { return i1; } int tabWidth() const { return i2; } const QColor& color() const { return *cl; } QTab* tab() const { return tb; } QCheckListItem* checkListItem() const { return cli; } QListViewItem* listViewItem() const { return li; } Qt::ArrowType arrowType() const { return (Qt::ArrowType)i1; } QRect rect() const { return QRect( i1, i2, i3, i4 ); } QWidget* widget() const { return (QWidget*)p1; } private: // NOTE: none of these components have constructors. bool def; bool b1,b2,b3; // reserved QMenuItem* mi; QTab* tb; QListViewItem* li; const QColor* cl; int i1, i2, i3, i4; int i5, i6; // reserved QCheckListItem* cli; void *p1, *p2, *p3, *p4; // reserved // (padded to 64 bytes on some architectures) }; class QStyleHintReturn; // not defined yet class Q_EXPORT QStyle: public QObject { Q_OBJECT public: QStyle(); virtual ~QStyle(); // New QStyle API - most of these should probably be pure virtual virtual void polish( QWidget * ); virtual void unPolish( QWidget * ); virtual void polish( QApplication * ); virtual void unPolish( QApplication * ); virtual void polish( QPalette & ); virtual void polishPopupMenu( QPopupMenu* ) = 0; virtual QRect itemRect( QPainter *p, const QRect &r, int flags, bool enabled, const QPixmap *pixmap, const QString &text, int len = -1 ) const; virtual void drawItem( QPainter *p, const QRect &r, int flags, const QColorGroup &g, bool enabled, const QPixmap *pixmap, const QString &text, int len = -1, const QColor *penColor = 0 ) const; enum PrimitiveElement { PE_ButtonCommand, PE_ButtonDefault, PE_ButtonBevel, PE_ButtonTool, PE_ButtonDropDown, PE_FocusRect, PE_ArrowUp, PE_ArrowDown, PE_ArrowRight, PE_ArrowLeft, PE_SpinWidgetUp, PE_SpinWidgetDown, PE_SpinWidgetPlus, PE_SpinWidgetMinus, PE_Indicator, PE_IndicatorMask, PE_ExclusiveIndicator, PE_ExclusiveIndicatorMask, PE_DockWindowHandle, PE_DockWindowSeparator, PE_DockWindowResizeHandle, PE_Splitter, PE_Panel, PE_PanelPopup, PE_PanelMenuBar, PE_PanelDockWindow, PE_TabBarBase, PE_HeaderSection, PE_HeaderArrow, PE_StatusBarSection, PE_GroupBoxFrame, PE_Separator, PE_SizeGrip, PE_CheckMark, PE_ScrollBarAddLine, PE_ScrollBarSubLine, PE_ScrollBarAddPage, PE_ScrollBarSubPage, PE_ScrollBarSlider, PE_ScrollBarFirst, PE_ScrollBarLast, PE_ProgressBarChunk, PE_PanelLineEdit, PE_PanelTabWidget, PE_WindowFrame, PE_CheckListController, PE_CheckListIndicator, PE_CheckListExclusiveIndicator, PE_PanelGroupBox, PE_RubberBand, // do not add any values below/greater this PE_CustomBase = 0xf000000 }; enum StyleFlags { Style_Default = 0x00000000, Style_Enabled = 0x00000001, Style_Raised = 0x00000002, Style_Sunken = 0x00000004, Style_Off = 0x00000008, Style_NoChange = 0x00000010, Style_On = 0x00000020, Style_Down = 0x00000040, Style_Horizontal = 0x00000080, Style_HasFocus = 0x00000100, Style_Top = 0x00000200, Style_Bottom = 0x00000400, Style_FocusAtBorder = 0x00000800, Style_AutoRaise = 0x00001000, Style_MouseOver = 0x00002000, Style_Up = 0x00004000, Style_Selected = 0x00008000, Style_Active = 0x00010000, Style_ButtonDefault = 0x00020000 }; typedef uint SFlags; virtual void drawPrimitive( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const = 0; enum ControlElement { CE_PushButton, CE_PushButtonLabel, CE_CheckBox, CE_CheckBoxLabel, CE_RadioButton, CE_RadioButtonLabel, CE_TabBarTab, CE_TabBarLabel, CE_ProgressBarGroove, CE_ProgressBarContents, CE_ProgressBarLabel, CE_PopupMenuItem, CE_MenuBarItem, CE_ToolButtonLabel, CE_MenuBarEmptyArea, CE_PopupMenuScroller, CE_DockWindowEmptyArea, CE_PopupMenuVerticalExtra, CE_PopupMenuHorizontalExtra, CE_ToolBoxTab, CE_HeaderLabel, // do not add any values below/greater than this CE_CustomBase = 0xf0000000 }; virtual void drawControl( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags how = Style_Default, const QStyleOption& = QStyleOption::Default ) const = 0; virtual void drawControlMask( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption& = QStyleOption::Default ) const = 0; enum SubRect { SR_PushButtonContents, SR_PushButtonFocusRect, SR_CheckBoxIndicator, SR_CheckBoxContents, SR_CheckBoxFocusRect, SR_RadioButtonIndicator, SR_RadioButtonContents, SR_RadioButtonFocusRect, SR_ComboBoxFocusRect, SR_SliderFocusRect, SR_DockWindowHandleRect, SR_ProgressBarGroove, SR_ProgressBarContents, SR_ProgressBarLabel, SR_ToolButtonContents, SR_DialogButtonAccept, SR_DialogButtonReject, SR_DialogButtonApply, SR_DialogButtonHelp, SR_DialogButtonAll, SR_DialogButtonAbort, SR_DialogButtonIgnore, SR_DialogButtonRetry, SR_DialogButtonCustom, SR_ToolBoxTabContents, // do not add any values below/greater than this SR_CustomBase = 0xf0000000 }; virtual QRect subRect( SubRect r, const QWidget *widget ) const = 0; enum ComplexControl{ CC_SpinWidget, CC_ComboBox, CC_ScrollBar, CC_Slider, CC_ToolButton, CC_TitleBar, CC_ListView, // do not add any values below/greater than this CC_CustomBase = 0xf0000000 }; enum SubControl { SC_None = 0x00000000, SC_ScrollBarAddLine = 0x00000001, SC_ScrollBarSubLine = 0x00000002, SC_ScrollBarAddPage = 0x00000004, SC_ScrollBarSubPage = 0x00000008, SC_ScrollBarFirst = 0x00000010, SC_ScrollBarLast = 0x00000020, SC_ScrollBarSlider = 0x00000040, SC_ScrollBarGroove = 0x00000080, SC_SpinWidgetUp = 0x00000001, SC_SpinWidgetDown = 0x00000002, SC_SpinWidgetFrame = 0x00000004, SC_SpinWidgetEditField = 0x00000008, SC_SpinWidgetButtonField = 0x00000010, SC_ComboBoxFrame = 0x00000001, SC_ComboBoxEditField = 0x00000002, SC_ComboBoxArrow = 0x00000004, SC_ComboBoxListBoxPopup = 0x00000008, SC_SliderGroove = 0x00000001, SC_SliderHandle = 0x00000002, SC_SliderTickmarks = 0x00000004, SC_ToolButton = 0x00000001, SC_ToolButtonMenu = 0x00000002, SC_TitleBarLabel = 0x00000001, SC_TitleBarSysMenu = 0x00000002, SC_TitleBarMinButton = 0x00000004, SC_TitleBarMaxButton = 0x00000008, SC_TitleBarCloseButton = 0x00000010, SC_TitleBarNormalButton = 0x00000020, SC_TitleBarShadeButton = 0x00000040, SC_TitleBarUnshadeButton = 0x00000080, SC_ListView = 0x00000001, SC_ListViewBranch = 0x00000002, SC_ListViewExpand = 0x00000004, SC_All = 0xffffffff }; typedef uint SCFlags; virtual void drawComplexControl( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags how = Style_Default, #ifdef Q_QDOC SCFlags sub = SC_All, #else SCFlags sub = (uint)SC_All, #endif SCFlags subActive = SC_None, const QStyleOption& = QStyleOption::Default ) const = 0; virtual void drawComplexControlMask( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption& = QStyleOption::Default ) const = 0; virtual QRect querySubControlMetrics( ComplexControl control, const QWidget *widget, SubControl sc, const QStyleOption& = QStyleOption::Default ) const = 0; virtual SubControl querySubControl( ComplexControl control, const QWidget *widget, const QPoint &pos, const QStyleOption& = QStyleOption::Default ) const = 0; enum PixelMetric { PM_ButtonMargin, PM_ButtonDefaultIndicator, PM_MenuButtonIndicator, PM_ButtonShiftHorizontal, PM_ButtonShiftVertical, PM_DefaultFrameWidth, PM_SpinBoxFrameWidth, PM_MaximumDragDistance, PM_ScrollBarExtent, PM_ScrollBarSliderMin, PM_SliderThickness, // total slider thickness PM_SliderControlThickness, // thickness of the business part PM_SliderLength, // total length of slider PM_SliderTickmarkOffset, // PM_SliderSpaceAvailable, // available space for slider to move PM_DockWindowSeparatorExtent, PM_DockWindowHandleExtent, PM_DockWindowFrameWidth, PM_MenuBarFrameWidth, PM_TabBarTabOverlap, PM_TabBarTabHSpace, PM_TabBarTabVSpace, PM_TabBarBaseHeight, PM_TabBarBaseOverlap, PM_ProgressBarChunkWidth, PM_SplitterWidth, PM_TitleBarHeight, PM_IndicatorWidth, PM_IndicatorHeight, PM_ExclusiveIndicatorWidth, PM_ExclusiveIndicatorHeight, PM_PopupMenuScrollerHeight, PM_CheckListButtonSize, PM_CheckListControllerSize, PM_PopupMenuFrameHorizontalExtra, PM_PopupMenuFrameVerticalExtra, PM_DialogButtonsSeparator, PM_DialogButtonsButtonWidth, PM_DialogButtonsButtonHeight, PM_MDIFrameWidth, PM_MDIMinimizedWidth, PM_HeaderMargin, PM_HeaderMarkSize, PM_HeaderGripMargin, PM_TabBarTabShiftHorizontal, PM_TabBarTabShiftVertical, PM_TabBarScrollButtonWidth, PM_MenuBarItemSpacing, PM_ToolBarItemSpacing, // do not add any values below/greater than this PM_CustomBase = 0xf0000000 }; virtual int pixelMetric( PixelMetric metric, const QWidget *widget = 0 ) const = 0; enum ContentsType { CT_PushButton, CT_CheckBox, CT_RadioButton, CT_ToolButton, CT_ComboBox, CT_Splitter, CT_DockWindow, CT_ProgressBar, CT_PopupMenuItem, CT_TabBarTab, CT_Slider, CT_Header, CT_LineEdit, CT_MenuBar, CT_SpinBox, CT_SizeGrip, CT_TabWidget, CT_DialogButtons, // do not add any values below/greater than this CT_CustomBase = 0xf0000000 }; virtual QSize sizeFromContents( ContentsType contents, const QWidget *widget, const QSize &contentsSize, const QStyleOption& = QStyleOption::Default ) const = 0; enum StyleHint { // ... // the general hints // ... // disabled text should be etched, ala Windows SH_EtchDisabledText, // the GUI style enum, argh! SH_GUIStyle, // ... // widget specific hints // ... SH_ScrollBar_BackgroundMode, SH_ScrollBar_MiddleClickAbsolutePosition, SH_ScrollBar_ScrollWhenPointerLeavesControl, // QEvent::Type - which mouse event to select a tab SH_TabBar_SelectMouseType, SH_TabBar_Alignment, SH_Header_ArrowAlignment, // bool - sliders snap to values while moving, ala Windows SH_Slider_SnapToValue, // bool - key presses handled in a sloppy manner - ie. left on a vertical // slider subtracts a line SH_Slider_SloppyKeyEvents, // bool - center button on progress dialogs, ala Motif, else right aligned // perhaps this should be a Qt::Alignment value SH_ProgressDialog_CenterCancelButton, // Qt::AlignmentFlags - text label alignment in progress dialogs // Center on windows, Auto|VCenter otherwize SH_ProgressDialog_TextLabelAlignment, // bool - right align buttons on print dialog, ala Windows SH_PrintDialog_RightAlignButtons, // bool - 1 or 2 pixel space between the menubar and the dockarea, ala Windows // this *REALLY* needs a better name SH_MainWindow_SpaceBelowMenuBar, // bool - select the text in the line edit about the listbox when selecting // an item from the listbox, or when the line edit receives focus, ala Windows SH_FontDialog_SelectAssociatedText, // bool - allows disabled menu items to be active SH_PopupMenu_AllowActiveAndDisabled, // bool - pressing space activates item, ala Motif SH_PopupMenu_SpaceActivatesItem, // int - number of milliseconds to wait before opening a submenu // 256 on windows, 96 on motif SH_PopupMenu_SubMenuPopupDelay, // bool - should scrollviews draw their frame only around contents (ala Motif), // or around contents, scrollbars and corner widgets (ala Windows) ? SH_ScrollView_FrameOnlyAroundContents, // bool - menubars items are navigatable by pressing alt, followed by using // the arrow keys to select the desired item SH_MenuBar_AltKeyNavigation, // bool - mouse tracking in combobox dropdown lists SH_ComboBox_ListMouseTracking, // bool - mouse tracking in popupmenus SH_PopupMenu_MouseTracking, // bool - mouse tracking in menubars SH_MenuBar_MouseTracking, // bool - gray out selected items when loosing focus SH_ItemView_ChangeHighlightOnFocus, // bool - supports shared activation among modeless widgets SH_Widget_ShareActivation, // bool - workspace should just maximize the client area SH_Workspace_FillSpaceOnMaximize, // bool - supports popup menu comboboxes SH_ComboBox_Popup, // bool - titlebar has no border SH_TitleBar_NoBorder, // bool - stop scrollbar at mouse SH_ScrollBar_StopMouseOverSlider, //bool - blink cursort with selected text SH_BlinkCursorWhenTextSelected, //bool - richtext selections extend the full width of the docuemnt SH_RichText_FullWidthSelection, //bool - popupmenu supports scrolling instead of multicolumn mode SH_PopupMenu_Scrollable, // Qt::AlignmentFlags - text label vertical alignment in groupboxes // Center on windows, Auto|VCenter otherwize SH_GroupBox_TextLabelVerticalAlignment, // Qt::QRgb - text label color in groupboxes SH_GroupBox_TextLabelColor, // bool - popupmenu supports sloppy submenus SH_PopupMenu_SloppySubMenus, // Qt::QRgb - table grid color SH_Table_GridLineColor, // QChar - Unicode character for password char SH_LineEdit_PasswordCharacter, // QDialogButtons::Button - default button SH_DialogButtons_DefaultButton, // QToolBox - Boldness of the selected page title SH_ToolBox_SelectedPageTitleBold, //bool - if a tabbar prefers not to have scroller arrows SH_TabBar_PreferNoArrows, //bool - if left button should cause an absolute position SH_ScrollBar_LeftClickAbsolutePosition, // QEvent::Type - which mouse event to select a list view expansion SH_ListViewExpand_SelectMouseType, //bool - if underline for accelerators SH_UnderlineAccelerator, // bool - QToolButton - if tool buttons should use a 3D frame // when the mouse is over the button SH_ToolButton_Uses3D, // do not add any values below/greater than this SH_CustomBase = 0xf0000000 }; virtual int styleHint( StyleHint stylehint, const QWidget *widget = 0, const QStyleOption& = QStyleOption::Default, QStyleHintReturn* returnData = 0 ) const = 0; enum StylePixmap { SP_TitleBarMinButton, SP_TitleBarMaxButton, SP_TitleBarCloseButton, SP_TitleBarNormalButton, SP_TitleBarShadeButton, SP_TitleBarUnshadeButton, SP_DockWindowCloseButton, SP_MessageBoxInformation, SP_MessageBoxWarning, SP_MessageBoxCritical, SP_MessageBoxQuestion, // do not add any values below/greater than this SP_CustomBase = 0xf0000000 }; virtual QPixmap stylePixmap( StylePixmap stylepixmap, const QWidget *widget = 0, const QStyleOption& = QStyleOption::Default ) const = 0; static QRect visualRect( const QRect &logical, const QWidget *w ); static QRect visualRect( const QRect &logical, const QRect &bounding ); // Old 2.x QStyle API #ifndef QT_NO_COMPAT int defaultFrameWidth() const { return pixelMetric( PM_DefaultFrameWidth ); } void tabbarMetrics( const QWidget* t, int& hf, int& vf, int& ov ) const { hf = pixelMetric( PM_TabBarTabHSpace, t ); vf = pixelMetric( PM_TabBarTabVSpace, t ); ov = pixelMetric( PM_TabBarBaseOverlap, t ); } QSize scrollBarExtent() const { return QSize(pixelMetric(PM_ScrollBarExtent), pixelMetric(PM_ScrollBarExtent)); } #endif private: QStylePrivate * d; #if defined(Q_DISABLE_COPY) QStyle( const QStyle & ); QStyle& operator=( const QStyle & ); #endif }; #endif // QT_NO_STYLE #endif // QSTYLE_H qvbuttongroup.hZ/* */ #ifndef QVBUTTONGROUP_H #define QVBUTTONGROUP_H #ifndef QT_H #include "qbuttongroup.h" #endif // QT_H #ifndef QT_NO_VBUTTONGROUP class Q_EXPORT QVButtonGroup : public QButtonGroup { Q_OBJECT public: QVButtonGroup( QWidget* parent=0, const char* name=0 ); QVButtonGroup( const QString &title, QWidget* parent=0, const char* name=0 ); ~QVButtonGroup(); private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QVButtonGroup( const QVButtonGroup & ); QVButtonGroup &operator=( const QVButtonGroup & ); #endif }; #endif // QT_NO_VBUTTONGROUP #endif // QVBUTTONGROUP_H qtoolbox.h/* */ #ifndef QTOOLBOX_H #define QTOOLBOX_H #ifndef QT_H #include #include #endif // QT_H #ifndef QT_NO_TOOLBOX class QToolBoxPrivate; class QWidgetList; class Q_EXPORT QToolBox : public QFrame { Q_OBJECT Q_PROPERTY( int currentIndex READ currentIndex WRITE setCurrentIndex ) Q_PROPERTY( int count READ count ) public: QToolBox( QWidget *parent = 0, const char *name = 0, WFlags f = 0 ); ~QToolBox(); int addItem( QWidget *item, const QString &label ); int addItem( QWidget *item, const QIconSet &iconSet, const QString &label ); int insertItem( int index, QWidget *item, const QString &label ); int insertItem( int index, QWidget *item, const QIconSet &iconSet, const QString &label ); int removeItem( QWidget *item ); void setItemEnabled( int index, bool enabled ); bool isItemEnabled( int index ) const; void setItemLabel( int index, const QString &label ); QString itemLabel( int index ) const; void setItemIconSet( int index, const QIconSet &iconSet ); QIconSet itemIconSet( int index ) const; void setItemToolTip( int index, const QString &toolTip ); QString itemToolTip( int index ) const; QWidget *currentItem() const; void setCurrentItem( QWidget *item ); int currentIndex() const; QWidget *item( int index ) const; int indexOf( QWidget *item ) const; int count() const; public slots: void setCurrentIndex( int index ); signals: void currentChanged( int index ); private slots: void buttonClicked(); void itemDestroyed(QObject*); protected: virtual void itemInserted( int index ); virtual void itemRemoved( int index ); void showEvent( QShowEvent *e ); void frameChanged(); void styleChange(QStyle&); private: void relayout(); private: QToolBoxPrivate *d; }; inline int QToolBox::addItem( QWidget *item, const QString &label ) { return insertItem( -1, item, QIconSet(), label ); } inline int QToolBox::addItem( QWidget *item, const QIconSet &iconSet, const QString &label ) { return insertItem( -1, item, iconSet, label ); } inline int QToolBox::insertItem( int index, QWidget *item, const QString &label ) { return insertItem( index, item, QIconSet(), label ); } #endif // QT_NO_TOOLBOX #endif qtextcodec.hX/* */ #ifndef QTEXTCODEC_H #define QTEXTCODEC_H #ifndef QT_H #include "qstring.h" #endif // QT_H #ifndef QT_NO_TEXTCODEC class QTextCodec; class QIODevice; class QFont; class Q_EXPORT QTextEncoder { public: virtual ~QTextEncoder(); virtual QCString fromUnicode(const QString& uc, int& lenInOut) = 0; }; class Q_EXPORT QTextDecoder { public: virtual ~QTextDecoder(); virtual QString toUnicode(const char* chars, int len) = 0; }; class Q_EXPORT QTextCodec { public: virtual ~QTextCodec(); #ifndef QT_NO_CODECS static QTextCodec* loadCharmap(QIODevice*); static QTextCodec* loadCharmapFile(QString filename); #endif //QT_NO_CODECS static QTextCodec* codecForMib(int mib); static QTextCodec* codecForName(const char* hint, int accuracy=0); static QTextCodec* codecForContent(const char* chars, int len); static QTextCodec* codecForIndex(int i); static QTextCodec* codecForLocale(); static void setCodecForLocale(QTextCodec *c); static QTextCodec* codecForTr(); static void setCodecForTr(QTextCodec *c); static QTextCodec* codecForCStrings(); static void setCodecForCStrings(QTextCodec *c); static void deleteAllCodecs(); static const char* locale(); virtual const char* name() const = 0; virtual const char* mimeName() const; virtual int mibEnum() const = 0; virtual QTextDecoder* makeDecoder() const; virtual QTextEncoder* makeEncoder() const; virtual QString toUnicode(const char* chars, int len) const; virtual QCString fromUnicode(const QString& uc, int& lenInOut) const; QCString fromUnicode(const QString& uc) const; QString toUnicode(const QByteArray&, int len) const; QString toUnicode(const QByteArray&) const; QString toUnicode(const QCString&, int len) const; QString toUnicode(const QCString&) const; QString toUnicode(const char* chars) const; virtual bool canEncode( QChar ) const; virtual bool canEncode( const QString& ) const; virtual int heuristicContentMatch(const char* chars, int len) const = 0; virtual int heuristicNameMatch(const char* hint) const; virtual QByteArray fromUnicode(const QString& uc, int from, int len) const; virtual unsigned short characterFromUnicode(const QString &str, int pos) const; protected: QTextCodec(); static int simpleHeuristicNameMatch(const char* name, const char* hint); private: friend class QFont; friend class QFontEngineXLFD; void fromUnicodeInternal( const QChar *in, unsigned short *out, int length ); static QTextCodec *cftr; static QTextCodec *cfcs; }; inline QTextCodec* QTextCodec::codecForTr() { return cftr; } inline void QTextCodec::setCodecForTr(QTextCodec *c) { cftr = c; } inline QTextCodec* QTextCodec::codecForCStrings() { return cfcs; } inline void QTextCodec::setCodecForCStrings(QTextCodec *c) { cfcs = c; } #endif // QT_NO_TEXTCODEC #endif // QTEXTCODEC_H &qwindowsystem_qws.h@/* */ #ifndef QWINDOWSYSTEM_QWS_H #define QWINDOWSYSTEM_QWS_H #ifndef QT_H #include "qwssocket_qws.h" #include "qmap.h" #include "qdatetime.h" #include "qptrlist.h" #include "qimage.h" #include "qwsproperty_qws.h" #include "qwscommand_qws.h" #include "qwsevent_qws.h" #endif // QT_H #include "qkbd_qws.h" struct SWCursorData; class QWSCursor; class QWSClient; class QWSRegionManager; class QGfx; class QWSServerData; class QWSInternalWindowInfo { public: int winid; unsigned int clientid; QString name; // Corresponds to QObject name of top-level widget }; struct QWSWindowData; class QWSScreenSaver { public: virtual ~QWSScreenSaver(); virtual void restore()=0; virtual bool save(int level)=0; }; class QWSWindow { friend class QWSServer; public: QWSWindow(int i, QWSClient* client); ~QWSWindow(); int winId() const { return id; } const QString &name() const { return rgnName; } const QString &caption() const { return rgnCaption; } QWSClient* client() const { return c; } QRegion requested() const { return requested_region; } QRegion allocation() const { return allocated_region; } bool isVisible() const { return !requested_region.isEmpty(); } bool isPartiallyObscured() const { return requested_region!=allocated_region; } bool isFullyObscured() const { return allocated_region.isEmpty(); } void raise(); void lower(); void show(); void hide(); void setActiveWindow(); private: bool hidden() const { return requested_region.isEmpty(); } bool forClient(const QWSClient* cl) const { return cl==c; } void setName( const QString &n ); void setCaption( const QString &c ); void addAllocation( QWSRegionManager *, const QRegion & ); void removeAllocation( QWSRegionManager *, const QRegion & ); int allocationIndex() const { return alloc_region_idx; } void setAllocationIndex( int i ) { alloc_region_idx = i; modified = TRUE; } void updateAllocation(); void setNeedAck( bool n ) { needAck = n; } void focus(bool get); int focusPriority() const { return last_focus_time; } void operation( QWSWindowOperationEvent::Operation o ); void shuttingDown() { last_focus_time=0; } private: int id; QString rgnName; QString rgnCaption; int alloc_region_idx; bool modified; bool needAck; bool onTop; QWSClient* c; QRegion requested_region; QRegion allocated_region; QRegion exposed; int last_focus_time; QWSWindowData *d; }; #ifndef QT_NO_SOUND class QWSSoundServer; #ifdef QT_USE_OLD_QWS_SOUND class QWSSoundServerData; class QWSSoundServer : public QObject { Q_OBJECT public: QWSSoundServer(QObject* parent); ~QWSSoundServer(); void playFile(const QString& filename); private slots: void feedDevice(int fd); private: QWSSoundServerData* d; }; #endif #endif /* */ class QWSMouseHandler; struct QWSCommandStruct; #ifndef QT_NO_QWS_MULTIPROCESS class QWSServer : public QWSServerSocket #else class QWSServer : public QObject #endif { friend class QCopChannel; friend class QWSMouseHandler; friend class QWSWindow; friend class QWSDisplay; friend class QWSInputMethod; Q_OBJECT public: QWSServer( int flags = 0, QObject *parent=0, const char *name=0 ); ~QWSServer(); enum ServerFlags { DisableKeyboard = 0x01, DisableMouse = 0x02 }; enum GUIMode { NoGui = FALSE, NormalGUI = TRUE, Server }; static void sendKeyEvent(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat); static void processKeyEvent(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat); #ifndef QT_NO_QWS_IM enum IMState { IMStart, IMCompose, IMEnd }; void sendIMEvent( IMState state, const QString& txt, int cpos, int selLen ); #endif #ifndef QT_NO_QWS_KEYBOARD typedef struct KeyMap { int key_code; ushort unicode; ushort shift_unicode; ushort ctrl_unicode; }; typedef struct KeyOverride { ushort scan_code; KeyMap map; }; static const KeyMap *keyMap(); static void setOverrideKeys( const KeyOverride* ); class KeyboardFilter { public: virtual bool filter(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat)=0; }; static void setKeyboardFilter( KeyboardFilter *f ); #endif #ifndef QT_NO_QWS_IM static void setCurrentInputMethod( QWSInputMethod *im ); static void resetInputMethod(); static void setMicroFocus( int x, int y ); #endif static void setDefaultMouse( const char * ); static void setDefaultKeyboard( const char * ); static void setMaxWindowRect(const QRect&); static void sendMouseEvent(const QPoint& pos, int state); static void setDesktopBackground( const QImage &img ); static void setDesktopBackground( const QColor & ); static QWSMouseHandler *mouseHandler(); static void setMouseHandler(QWSMouseHandler*); #ifndef QT_NO_QWS_KEYBOARD static QWSKeyboardHandler* keyboardHandler(); static void setKeyboardHandler(QWSKeyboardHandler* kh); #endif QWSWindow *windowAt( const QPoint& pos ); // For debugging only at this time const QPtrList &clientWindows() { return windows; } void openMouse(); void closeMouse(); #ifndef QT_NO_QWS_KEYBOARD void openKeyboard(); void closeKeyboard(); #endif static void setScreenSaver(QWSScreenSaver*); static void setScreenSaverIntervals(int* ms); static void setScreenSaverInterval(int); static bool screenSaverActive(); static void screenSaverActivate(bool); // the following are internal. void refresh(); void refresh(QRegion &); void enablePainting(bool); static void processEventQueue(); static QPtrList * windowList(); void sendPropertyNotifyEvent( int property, int state ); #ifndef QT_NO_QWS_PROPERTIES QWSPropertyManager *manager() { return &propertyManager; } #endif static QPoint mousePosition; static void startup( int flags ); static void closedown(); static void beginDisplayReconfigure(); static void endDisplayReconfigure(); #ifndef QT_NO_QWS_CURSOR static void setCursorVisible( bool ); static bool isCursorVisible(); #endif enum WindowEvent { Create=0x0001, Destroy=0x0002, Hide=0x0004, Show=0x0008, Raise=0x0010, Lower=0x0020, Geometry=0x0040, Active = 0x0080, Name=0x0100 }; signals: void windowEvent( QWSWindow *w, QWSServer::WindowEvent e ); #ifndef QT_NO_COP void newChannel( const QString& channel); void removedChannel(const QString& channel); #endif private: #ifndef QT_NO_COP static void sendQCopEvent( QWSClient *c, const QCString &ch, const QCString &msg, const QByteArray &data, bool response = FALSE ); #endif void move_region( const QWSRegionMoveCommand * ); void set_altitude( const QWSChangeAltitudeCommand * ); void request_focus( const QWSRequestFocusCommand * ); void request_region( int, QRegion ); void destroy_region( const QWSRegionDestroyCommand * ); void name_region( const QWSRegionNameCommand * ); void set_identity( const QWSIdentifyCommand * ); #ifndef QT_NO_QWS_IM void set_micro_focus( const QWSSetMicroFocusCommand * ); void reset_im( const QWSResetIMCommand * ); static void sendKeyEventUnfiltered(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat); #endif static void emergency_cleanup(); static QColor *bgColor; static QImage *bgImage; void sendMaxWindowRectEvents(); #ifndef QT_NO_QWS_MULTIPROCESS void newConnection( int socket ); #endif void invokeIdentify( const QWSIdentifyCommand *cmd, QWSClient *client ); void invokeCreate( QWSCreateCommand *cmd, QWSClient *client ); void invokeRegionName( const QWSRegionNameCommand *cmd, QWSClient *client ); void invokeRegion( QWSRegionCommand *cmd, QWSClient *client ); void invokeRegionMove( const QWSRegionMoveCommand *cmd, QWSClient *client ); void invokeRegionDestroy( const QWSRegionDestroyCommand *cmd, QWSClient *client ); void invokeSetAltitude( const QWSChangeAltitudeCommand *cmd, QWSClient *client ); #ifndef QT_NO_QWS_PROPERTIES void invokeAddProperty( QWSAddPropertyCommand *cmd ); void invokeSetProperty( QWSSetPropertyCommand *cmd ); void invokeRemoveProperty( QWSRemovePropertyCommand *cmd ); void invokeGetProperty( QWSGetPropertyCommand *cmd, QWSClient *client ); #endif //QT_NO_QWS_PROPERTIES void invokeSetSelectionOwner( QWSSetSelectionOwnerCommand *cmd ); void invokeConvertSelection( QWSConvertSelectionCommand *cmd ); void invokeSetFocus( const QWSRequestFocusCommand *cmd, QWSClient *client ); void initIO(); void setFocus( QWSWindow*, bool gain ); #ifndef QT_NO_QWS_CURSOR void invokeDefineCursor( QWSDefineCursorCommand *cmd, QWSClient *client ); void invokeSelectCursor( QWSSelectCursorCommand *cmd, QWSClient *client ); #endif void invokeGrabMouse( QWSGrabMouseCommand *cmd, QWSClient *client ); void invokeGrabKeyboard( QWSGrabKeyboardCommand *cmd, QWSClient *client ); #ifndef QT_NO_SOUND void invokePlaySound( QWSPlaySoundCommand *cmd, QWSClient *client ); #endif #ifndef QT_NO_COP void invokeRegisterChannel( QWSQCopRegisterChannelCommand *cmd, QWSClient *client ); void invokeQCopSend( QWSQCopSendCommand *cmd, QWSClient *client ); #endif void invokeRepaintRegion( QWSRepaintRegionCommand *cmd, QWSClient *client ); #ifndef QT_NO_QWS_IM void invokeSetMicroFocus( const QWSSetMicroFocusCommand *cmd, QWSClient *client ); void invokeResetIM( const QWSResetIMCommand *cmd, QWSClient *client ); #endif QWSMouseHandler* newMouseHandler(const QString& spec); void openDisplay(); void closeDisplay(); void showCursor(); void hideCursor(); void initializeCursor(); void paintServerRegion(); void paintBackground( const QRegion & ); void clearRegion( const QRegion &r, const QColor &c ); void refreshBackground(); void resetGfx(); private slots: #ifndef QT_NO_QWS_MULTIPROCESS void clientClosed(); void doClient(); void deleteWindowsLater(); #endif void screenSaverWake(); void screenSaverSleep(); void screenSaverTimeout(); private: void disconnectClient( QWSClient * ); void screenSave(int level); void doClient( QWSClient * ); typedef QMapIterator ClientIterator; typedef QMap ClientMap; void releaseMouse(QWSWindow* w); void releaseKeyboard(QWSWindow* w); void updateClientCursorPos(); uchar* sharedram; int ramlen; QGfx *gfx; ClientMap client; #ifndef QT_NO_QWS_PROPERTIES QWSPropertyManager propertyManager; #endif struct SelectionOwner { int windowid; struct Time { void set( int h, int m, int s, int s2 ) { hour = h; minute = m; sec = s; ms = s2; } int hour, minute, sec, ms; } time; } selectionOwner; QTime timer; QWSServerData* d; int* screensaverinterval; QWSWindow *focusw; QWSWindow *mouseGrabber; bool mouseGrabbing; int swidth, sheight, sdepth; #ifndef QT_NO_QWS_CURSOR bool haveviscurs; QWSCursor *cursor; // cursor currently shown QWSCursor *nextCursor; // cursor to show once grabbing is off #endif QRegion screenRegion; // the entire display region QRegion serverRegion; QRegion dirtyBackground; bool disablePainting; QPtrList mousehandlers; #ifndef QT_NO_QWS_KEYBOARD QPtrList keyboardhandlers; #endif QPtrList commandQueue; QWSRegionManager *rgnMan; // Window management QPtrList windows; // first=topmost QWSWindow* newWindow(int id, QWSClient* client); QWSWindow* findWindow(int windowid, QWSClient* client); void moveWindowRegion(QWSWindow*, int dx, int dy ); QRegion setWindowRegion(QWSWindow*, QRegion r ); void raiseWindow( QWSWindow *, int = 0); void lowerWindow( QWSWindow *, int = -1); void exposeRegion( QRegion , int index = 0 ); void notifyModified( QWSWindow *active = 0 ); void syncRegions( QWSWindow *active = 0 ); void setCursor(QWSCursor *curs); // multimedia #ifndef QT_NO_SOUND QWSSoundServer *soundserver; #endif #ifndef QT_NO_COP QMap > channels; #endif #ifndef QT_NO_QWS_IM bool microF; int microX; int microY; #endif }; extern QWSServer *qwsServer; //there can be only one #ifndef QT_NO_QWS_IM class QWSInputMethod { public: QWSInputMethod(); virtual ~QWSInputMethod(); virtual bool filter(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat)=0; virtual void reset(); virtual void setMicroFocus( int x, int y ); virtual void setFont( const QFont& ); protected: void sendIMEvent( QWSServer::IMState, const QString& txt, int cpos, int selLen = 0 ); //void sendKeyEvent( int unicode, int keycode, int modifiers, // bool isPress, bool autoRepeat); }; inline void QWSInputMethod::sendIMEvent( QWSServer::IMState state, const QString &txt, int cpos, int selLen ) { qwsServer->sendIMEvent( state, txt, cpos, selLen ); } #endif /* */ struct QWSMouseEvent; typedef QMap QWSCursorMap; class QWSClient : public QObject { Q_OBJECT public: QWSClient( QObject* parent, int socket, int id ); ~QWSClient(); int socket() const; void setIdentity(const QString&); QString identity() const { return id; } void sendEvent( QWSEvent* event ); void sendConnectedEvent( const char *display_spec ); void sendMaxWindowRectEvent(); void sendRegionModifyEvent( int winid, QRegion exposed, bool ack ); void sendFocusEvent( int winid, bool get ); void sendPropertyNotifyEvent( int property, int state ); void sendPropertyReplyEvent( int property, int len, char *data ); void sendSelectionClearEvent( int windowid ); void sendSelectionRequestEvent( QWSConvertSelectionCommand *cmd, int windowid ); QWSCommand* readMoreCommand(); int clientId() const { return cid; } QWSCursorMap cursors; // cursors defined by this client signals: void connectionClosed(); void readyRead(); private slots: void closeHandler(); void errorHandler( int ); private: int s; // XXX csocket->d->socket->socket() is this value #ifndef QT_NO_QWS_MULTIPROCESS QWSSocket *csocket; #endif QWSCommand* command; uint isClosed : 1; QString id; int cid; }; #endif // QWINDOWSYSTEM_QWS_H $qsqlselectcursor.h /* */ #ifndef QSQLSELECTCURSOR_H #define QSQLSELECTCURSOR_H #ifndef QT_H #include "qsqlcursor.h" #endif // QT_H #if !defined( QT_MODULE_SQL ) || defined( QT_LICENSE_PROFESSIONAL ) #define QM_EXPORT_SQL #else #define QM_EXPORT_SQL Q_EXPORT #endif #ifndef QT_NO_SQL class QSqlSelectCursorPrivate; class QM_EXPORT_SQL QSqlSelectCursor : public QSqlCursor { public: QSqlSelectCursor( const QString& query = QString::null, QSqlDatabase* db = 0 ); QSqlSelectCursor( const QSqlSelectCursor& other ); ~QSqlSelectCursor(); bool exec( const QString& query ); bool select() { return QSqlCursor::select(); } protected: QSqlIndex primaryIndex( bool = TRUE ) const { return QSqlIndex(); } QSqlIndex index( const QStringList& ) const { return QSqlIndex(); } QSqlIndex index( const QString& ) const { return QSqlIndex(); } QSqlIndex index( const char* ) const { return QSqlIndex(); } void setPrimaryIndex( const QSqlIndex& ) {} void append( const QSqlFieldInfo& ) {} void insert( int, const QSqlFieldInfo& ) {} void remove( int ) {} void clear() {} void setGenerated( const QString&, bool ) {} void setGenerated( int, bool ) {} QSqlRecord* editBuffer( bool = FALSE ) { return 0; } QSqlRecord* primeInsert() { return 0; } QSqlRecord* primeUpdate() { return 0; } QSqlRecord* primeDelete() { return 0; } int insert( bool = TRUE ) { return 0; } int update( bool = TRUE ) { return 0; } int del( bool = TRUE ) { return 0; } void setMode( int ) {} void setSort( const QSqlIndex& ) {} QSqlIndex sort() const { return QSqlIndex(); } void setFilter( const QString& ) {} QString filter() const { return QString::null; } void setName( const QString&, bool = TRUE ) {} QString name() const { return QString::null; } QString toString( const QString& = QString::null, const QString& = "," ) const { return QString::null; } bool select( const QString &, const QSqlIndex& = QSqlIndex() ); private: void populateCursor(); QSqlSelectCursorPrivate * d; }; #endif // QT_NO_SQL #endif // QSQLSELECTCURSOR_H qwsgfx_qnx6.h /* */ #ifndef QWSGFX_QNX6_H #define QWSGFX_QNX6_H #ifndef QT_H #include #include #include #include #include #include #include #endif // QT_H // QnxFb Gfx class template class QQnxFbGfx : public QGfxRaster { public: QQnxFbGfx(); ~QQnxFbGfx(); int bitDepth(){ return DISP_BITS_PER_PIXEL ( ctx.dsurf->pixel_format );}; void sync (); // void fillRect (int,int,int,int); // void blt (int,int,int,int,int,int); // void hlineUnclipped ( int, int, int); private: disp_draw_context_t ctx; }; // Screen class class QQnxScreen : public QScreen { public: QQnxScreen(int display_id):QScreen(display_id){}; ~QQnxScreen(){}; bool connect(const QString & spec); void disconnect(); bool initDevice(); void shutdownDevice(); void setMode(int, int, int); QGfx* createGfx (unsigned char*, int, int, int, int); int initCursor(void *, bool); }; #ifndef QT_NO_QWS_CURSOR class QQnxCursor : public QScreenCursor { public: QQnxCursor(){}; ~QQnxCursor(){}; virtual void init(SWCursorData *,bool=FALSE); virtual void set( const QImage &image, int hotx, int hoty ); virtual void move( int x, int y ); virtual void show(); virtual void hide(); virtual bool restoreUnder( const QRect &, QGfxRasterBase * = 0 ) { return FALSE; } virtual void saveUnder() {} virtual void drawCursor() {} virtual void draw() {} virtual bool supportsAlphaCursor() { return FALSE; } static bool enabled() { return FALSE; } private: int hotx; int hoty; QBitArray cursor,mask; QColor colour0,colour1; }; #endif // QT_NO_QWS_CURSOR #endif // QWSGFX_QNX6_H qsqlquery.hn/* */ #ifndef QSQLQUERY_H #define QSQLQUERY_H #ifndef QT_H #include "qobject.h" #include "qstring.h" #include "qvariant.h" #include "qvaluelist.h" #include "qsqlerror.h" #include "qsqlfield.h" #include "qsql.h" #endif // QT_H #ifndef QT_NO_SQL class QSqlDriver; class QSqlResult; class QSqlDatabase; class Q_EXPORT QSqlResultShared : public QObject, public QShared { Q_OBJECT public: QSqlResultShared( QSqlResult* result ); virtual ~QSqlResultShared(); QSqlResult* sqlResult; QString executedQuery; private slots: void slotResultDestroyed(); }; class Q_EXPORT QSqlQuery { public: QSqlQuery( QSqlResult * r ); QSqlQuery( const QString& query = QString::null, QSqlDatabase* db = 0 ); Q_EXPLICIT QSqlQuery( QSqlDatabase* db ); QSqlQuery( const QSqlQuery& other ); QSqlQuery& operator=( const QSqlQuery& other ); virtual ~QSqlQuery(); bool isValid() const; bool isActive() const; bool isNull( int field ) const; int at() const; QString lastQuery() const; int numRowsAffected() const; QSqlError lastError() const; bool isSelect() const; int size() const; const QSqlDriver* driver() const; const QSqlResult* result() const; bool isForwardOnly() const; void setForwardOnly( bool forward ); virtual bool exec ( const QString& query ); virtual QVariant value( int i ) const; virtual bool seek( int i, bool relative = FALSE ); virtual bool next(); virtual bool prev(); virtual bool first(); virtual bool last(); // prepared query support bool exec(); bool prepare( const QString& query ); void bindValue( const QString& placeholder, const QVariant& val ); void bindValue( int pos, const QVariant& val ); void addBindValue( const QVariant& val ); // remove these overloads in 4.0 void bindValue( const QString& placeholder, const QVariant& val, QSql::ParameterType type ); void bindValue( int pos, const QVariant& val, QSql::ParameterType type ); void addBindValue( const QVariant& val, QSql::ParameterType type ); QVariant boundValue( const QString& placeholder ) const; QVariant boundValue( int pos ) const; QMap boundValues() const; QString executedQuery() const; protected: virtual void beforeSeek(); virtual void afterSeek(); private: void init( const QString& query, QSqlDatabase* db ); void deref(); bool checkDetach(); QSqlResultShared* d; }; #endif // QT_NO_SQL #endif qstring.h;/* */ #ifndef QSTRING_H #define QSTRING_H #ifndef QT_H #include "qcstring.h" #endif // QT_H #ifndef QT_NO_CAST_ASCII #include #endif #ifndef QT_NO_STL #if defined ( Q_CC_MSVC_NET ) && _MSV_VER < 1310 // Avoids nasty warning for xlocale, line 450 # pragma warning ( push ) # pragma warning ( disable : 4189 ) # include # pragma warning ( pop ) #else # include #endif #if defined(Q_WRONG_SB_CTYPE_MACROS) && defined(_SB_CTYPE_MACROS) #undef _SB_CTYPE_MACROS #endif #endif /* */ class QRegExp; class QString; class QCharRef; template class QDeepCopy; class Q_EXPORT QChar { public: QChar(); QChar( char c ); QChar( uchar c ); QChar( uchar c, uchar r ); QChar( const QChar& c ); // ### remove in 4.0 to allow compiler optimization QChar( ushort rc ); QChar( short rc ); QChar( uint rc ); QChar( int rc ); QT_STATIC_CONST QChar null; // 0000 QT_STATIC_CONST QChar replacement; // FFFD QT_STATIC_CONST QChar byteOrderMark; // FEFF QT_STATIC_CONST QChar byteOrderSwapped; // FFFE QT_STATIC_CONST QChar nbsp; // 00A0 // Unicode information enum Category { NoCategory, Mark_NonSpacing, // Mn Mark_SpacingCombining, // Mc Mark_Enclosing, // Me Number_DecimalDigit, // Nd Number_Letter, // Nl Number_Other, // No Separator_Space, // Zs Separator_Line, // Zl Separator_Paragraph, // Zp Other_Control, // Cc Other_Format, // Cf Other_Surrogate, // Cs Other_PrivateUse, // Co Other_NotAssigned, // Cn Letter_Uppercase, // Lu Letter_Lowercase, // Ll Letter_Titlecase, // Lt Letter_Modifier, // Lm Letter_Other, // Lo Punctuation_Connector, // Pc Punctuation_Dash, // Pd Punctuation_Dask = Punctuation_Dash, // oops Punctuation_Open, // Ps Punctuation_Close, // Pe Punctuation_InitialQuote, // Pi Punctuation_FinalQuote, // Pf Punctuation_Other, // Po Symbol_Math, // Sm Symbol_Currency, // Sc Symbol_Modifier, // Sk Symbol_Other // So }; enum Direction { DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON, DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN }; enum Decomposition { Single, Canonical, Font, NoBreak, Initial, Medial, Final, Isolated, Circle, Super, Sub, Vertical, Wide, Narrow, Small, Square, Compat, Fraction }; enum Joining { OtherJoining, Dual, Right, Center }; enum CombiningClass { Combining_BelowLeftAttached = 200, Combining_BelowAttached = 202, Combining_BelowRightAttached = 204, Combining_LeftAttached = 208, Combining_RightAttached = 210, Combining_AboveLeftAttached = 212, Combining_AboveAttached = 214, Combining_AboveRightAttached = 216, Combining_BelowLeft = 218, Combining_Below = 220, Combining_BelowRight = 222, Combining_Left = 224, Combining_Right = 226, Combining_AboveLeft = 228, Combining_Above = 230, Combining_AboveRight = 232, Combining_DoubleBelow = 233, Combining_DoubleAbove = 234, Combining_IotaSubscript = 240 }; // ****** WHEN ADDING FUNCTIONS, CONSIDER ADDING TO QCharRef TOO int digitValue() const; QChar lower() const; QChar upper() const; Category category() const; Direction direction() const; Joining joining() const; bool mirrored() const; QChar mirroredChar() const; const QString &decomposition() const; // ### return just QString in 4.0 Decomposition decompositionTag() const; unsigned char combiningClass() const; char latin1() const { return ucs > 0xff ? 0 : (char) ucs; } ushort unicode() const { return ucs; } #ifdef Q_NO_PACKED_REFERENCE ushort &unicode() { return *(&ucs); } #else ushort &unicode() { return ucs; } #endif #ifndef QT_NO_CAST_ASCII // like all ifdef'd code this is undocumented operator char() const { return latin1(); } #endif bool isNull() const { return unicode()==0; } bool isPrint() const; bool isPunct() const; bool isSpace() const; bool isMark() const; bool isLetter() const; bool isNumber() const; bool isLetterOrNumber() const; bool isDigit() const; bool isSymbol() const; uchar cell() const { return ((uchar) ucs & 0xff); } uchar row() const { return ((uchar) (ucs>>8)&0xff); } void setCell( uchar cell ) { ucs = (ucs & 0xff00) + cell; } void setRow( uchar row ) { ucs = (((ushort) row)<<8) + (ucs&0xff); } static bool networkOrdered() { int wordSize; bool bigEndian = FALSE; qSysInfo( &wordSize, &bigEndian ); return bigEndian; } friend inline bool operator==( char ch, QChar c ); friend inline bool operator==( QChar c, char ch ); friend inline bool operator==( QChar c1, QChar c2 ); friend inline bool operator!=( QChar c1, QChar c2 ); friend inline bool operator!=( char ch, QChar c ); friend inline bool operator!=( QChar c, char ch ); friend inline bool operator<=( QChar c, char ch ); friend inline bool operator<=( char ch, QChar c ); friend inline bool operator<=( QChar c1, QChar c2 ); private: ushort ucs; #if defined(QT_QSTRING_UCS_4) ushort grp; #endif } Q_PACKED; inline QChar::QChar() : ucs( 0 ) #ifdef QT_QSTRING_UCS_4 , grp( 0 ) #endif { } inline QChar::QChar( char c ) : ucs( (uchar)c ) #ifdef QT_QSTRING_UCS_4 , grp( 0 ) #endif { } inline QChar::QChar( uchar c ) : ucs( c ) #ifdef QT_QSTRING_UCS_4 , grp( 0 ) #endif { } inline QChar::QChar( uchar c, uchar r ) : ucs( (r << 8) | c ) #ifdef QT_QSTRING_UCS_4 , grp( 0 ) #endif { } inline QChar::QChar( const QChar& c ) : ucs( c.ucs ) #ifdef QT_QSTRING_UCS_4 , grp( c.grp ) #endif { } inline QChar::QChar( ushort rc ) : ucs( rc ) #ifdef QT_QSTRING_UCS_4 , grp( 0 ) #endif { } inline QChar::QChar( short rc ) : ucs( (ushort) rc ) #ifdef QT_QSTRING_UCS_4 , grp( 0 ) #endif { } inline QChar::QChar( uint rc ) : ucs( (ushort ) (rc & 0xffff) ) #ifdef QT_QSTRING_UCS_4 , grp( (ushort) ((rc >> 16) & 0xffff) ) #endif { } inline QChar::QChar( int rc ) : ucs( (ushort) (rc & 0xffff) ) #ifdef QT_QSTRING_UCS_4 , grp( (ushort) ((rc >> 16) & 0xffff) ) #endif { } inline bool operator==( char ch, QChar c ) { return ((uchar) ch) == c.ucs; } inline bool operator==( QChar c, char ch ) { return ((uchar) ch) == c.ucs; } inline bool operator==( QChar c1, QChar c2 ) { return c1.ucs == c2.ucs; } inline bool operator!=( QChar c1, QChar c2 ) { return c1.ucs != c2.ucs; } inline bool operator!=( char ch, QChar c ) { return ((uchar)ch) != c.ucs; } inline bool operator!=( QChar c, char ch ) { return ((uchar) ch) != c.ucs; } inline bool operator<=( QChar c, char ch ) { return c.ucs <= ((uchar) ch); } inline bool operator<=( char ch, QChar c ) { return ((uchar) ch) <= c.ucs; } inline bool operator<=( QChar c1, QChar c2 ) { return c1.ucs <= c2.ucs; } inline bool operator>=( QChar c, char ch ) { return ch <= c; } inline bool operator>=( char ch, QChar c ) { return c <= ch; } inline bool operator>=( QChar c1, QChar c2 ) { return c2 <= c1; } inline bool operator<( QChar c, char ch ) { return !(ch<=c); } inline bool operator<( char ch, QChar c ) { return !(c<=ch); } inline bool operator<( QChar c1, QChar c2 ) { return !(c2<=c1); } inline bool operator>( QChar c, char ch ) { return !(ch>=c); } inline bool operator>( char ch, QChar c ) { return !(c>=ch); } inline bool operator>( QChar c1, QChar c2 ) { return !(c2>=c1); } // internal struct Q_EXPORT QStringData : public QShared { QStringData() : QShared(), unicode(0), ascii(0), len(0), issimpletext(TRUE), maxl(0), islatin1(FALSE) { ref(); } QStringData(QChar *u, uint l, uint m) : QShared(), unicode(u), ascii(0), len(l), issimpletext(FALSE), maxl(m), islatin1(FALSE) { } ~QStringData() { if ( unicode ) delete[] ((char*)unicode); if ( ascii ) delete[] ascii; } void deleteSelf(); QChar *unicode; char *ascii; void setDirty() { if ( ascii ) { delete [] ascii; ascii = 0; } issimpletext = FALSE; } #ifdef Q_OS_MAC9 uint len; #else uint len : 30; #endif uint issimpletext : 1; #ifdef Q_OS_MAC9 uint maxl; #else uint maxl : 30; #endif uint islatin1 : 1; private: #if defined(Q_DISABLE_COPY) QStringData( const QStringData& ); QStringData& operator=( const QStringData& ); #endif }; class Q_EXPORT QString { public: QString(); // make null string QString( QChar ); // one-char string QString( const QString & ); // impl-shared copy QString( const QByteArray& ); // deep copy QString( const QChar* unicode, uint length ); // deep copy #ifndef QT_NO_CAST_ASCII QString( const char *str ); // deep copy #endif #ifndef QT_NO_STL QString( const std::string& ); // deep copy #endif ~QString(); QString &operator=( const QString & ); // impl-shared copy QString &operator=( const char * ); // deep copy #ifndef QT_NO_STL QString &operator=( const std::string& ); // deep copy #endif QString &operator=( const QCString& ); // deep copy QString &operator=( QChar c ); QString &operator=( char c ); QT_STATIC_CONST QString null; bool isNull() const; bool isEmpty() const; uint length() const; void truncate( uint pos ); QString & fill( QChar c, int len = -1 ); QString copy() const; QString arg( long a, int fieldWidth = 0, int base = 10 ) const; QString arg( ulong a, int fieldWidth = 0, int base = 10 ) const; QString arg( Q_LLONG a, int fieldwidth=0, int base=10 ) const; QString arg( Q_ULLONG a, int fieldwidth=0, int base=10 ) const; QString arg( int a, int fieldWidth = 0, int base = 10 ) const; QString arg( uint a, int fieldWidth = 0, int base = 10 ) const; QString arg( short a, int fieldWidth = 0, int base = 10 ) const; QString arg( ushort a, int fieldWidth = 0, int base = 10 ) const; QString arg( double a, int fieldWidth = 0, char fmt = 'g', int prec = -1 ) const; QString arg( char a, int fieldWidth = 0 ) const; QString arg( QChar a, int fieldWidth = 0 ) const; QString arg( const QString& a, int fieldWidth = 0 ) const; QString arg( const QString& a1, const QString& a2 ) const; QString arg( const QString& a1, const QString& a2, const QString& a3 ) const; QString arg( const QString& a1, const QString& a2, const QString& a3, const QString& a4 ) const; #ifndef QT_NO_SPRINTF QString &sprintf( const char* format, ... ) #if defined(Q_CC_GNU) && !defined(__INSURE__) __attribute__ ((format (printf, 2, 3))) #endif ; #endif int find( QChar c, int index=0, bool cs=TRUE ) const; int find( char c, int index=0, bool cs=TRUE ) const; int find( const QString &str, int index=0, bool cs=TRUE ) const; #ifndef QT_NO_REGEXP int find( const QRegExp &, int index=0 ) const; #endif #ifndef QT_NO_CAST_ASCII int find( const char* str, int index=0 ) const; #endif int findRev( QChar c, int index=-1, bool cs=TRUE) const; int findRev( char c, int index=-1, bool cs=TRUE) const; int findRev( const QString &str, int index=-1, bool cs=TRUE) const; #ifndef QT_NO_REGEXP int findRev( const QRegExp &, int index=-1 ) const; #endif #ifndef QT_NO_CAST_ASCII int findRev( const char* str, int index=-1 ) const; #endif int contains( QChar c, bool cs=TRUE ) const; int contains( char c, bool cs=TRUE ) const { return contains(QChar(c), cs); } #ifndef QT_NO_CAST_ASCII int contains( const char* str, bool cs=TRUE ) const; #endif int contains( const QString &str, bool cs=TRUE ) const; #ifndef QT_NO_REGEXP int contains( const QRegExp & ) const; #endif enum SectionFlags { SectionDefault = 0x00, SectionSkipEmpty = 0x01, SectionIncludeLeadingSep = 0x02, SectionIncludeTrailingSep = 0x04, SectionCaseInsensitiveSeps = 0x08 }; QString section( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; QString section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; #ifndef QT_NO_CAST_ASCII QString section( const char *in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; #endif QString section( const QString &in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; #ifndef QT_NO_REGEXP QString section( const QRegExp ®, int start, int end = 0xffffffff, int flags = SectionDefault ) const; #endif QString left( uint len ) const; QString right( uint len ) const; QString mid( uint index, uint len=0xffffffff) const; QString leftJustify( uint width, QChar fill=' ', bool trunc=FALSE)const; QString rightJustify( uint width, QChar fill=' ',bool trunc=FALSE)const; QString lower() const; QString upper() const; QString stripWhiteSpace() const; QString simplifyWhiteSpace() const; QString &insert( uint index, const QString & ); #ifndef QT_NO_CAST_ASCII QString &insert( uint index, const QByteArray & ); QString &insert( uint index, const char * ); #endif QString &insert( uint index, const QChar*, uint len ); QString &insert( uint index, QChar ); QString &insert( uint index, char c ) { return insert(index,QChar(c)); } QString &append( char ); QString &append( QChar ); QString &append( const QString & ); #ifndef QT_NO_CAST_ASCII QString &append( const QByteArray & ); QString &append( const char * ); #endif #if !defined(QT_NO_STL) && !defined(QT_NO_CAST_ASCII) QString &append( const std::string& ); #endif QString &prepend( char ); QString &prepend( QChar ); QString &prepend( const QString & ); #ifndef QT_NO_CAST_ASCII QString &prepend( const QByteArray & ); QString &prepend( const char * ); #endif #if !defined(QT_NO_STL) && !defined(QT_NO_CAST_ASCII) QString &prepend( const std::string& ); #endif QString &remove( uint index, uint len ); #if defined(Q_QDOC) QString &remove( const QString & str, bool cs = TRUE ); #else // ### Qt 4.0: merge these two into one, and remove Q_QDOC hack QString &remove( const QString & ); QString &remove( const QString &, bool cs ); #endif QString &remove( QChar c ); QString &remove( char c ) { return remove( QChar(c) ); } #ifndef QT_NO_CAST_ASCII QString &remove( const char * ); #endif #ifndef QT_NO_REGEXP QString &remove( const QRegExp & ); #endif QString &replace( uint index, uint len, const QString & ); QString &replace( uint index, uint len, const QChar*, uint clen ); QString &replace( uint index, uint len, QChar ); QString &replace( uint index, uint len, char c ) { return replace( index, len, QChar(c) ); } #if defined(Q_QDOC) QString &replace( QChar c, const QString & after, bool cs = TRUE ); QString &replace( char c, const QString & after, bool cs = TRUE ); QString &replace( const QString & before, const QString & after, bool cs = TRUE ); #else // ### Qt 4.0: merge these two into one, and remove Q_QDOC hack QString &replace( QChar c, const QString & ); QString &replace( QChar c, const QString &, bool ); // ### Qt 4.0: merge these two into one, and remove Q_QDOC hack QString &replace( char c, const QString & after ) { return replace( QChar(c), after, TRUE ); } QString &replace( char c, const QString & after, bool cs ) { return replace( QChar(c), after, cs ); } // ### Qt 4.0: merge these two into one, and remove Q_QDOC hack QString &replace( const QString &, const QString & ); QString &replace( const QString &, const QString &, bool ); #endif #ifndef QT_NO_REGEXP_CAPTURE QString &replace( const QRegExp &, const QString & ); #endif QString &replace( QChar, QChar ); short toShort( bool *ok=0, int base=10 ) const; ushort toUShort( bool *ok=0, int base=10 ) const; int toInt( bool *ok=0, int base=10 ) const; uint toUInt( bool *ok=0, int base=10 ) const; long toLong( bool *ok=0, int base=10 ) const; ulong toULong( bool *ok=0, int base=10 ) const; Q_LLONG toLongLong( bool *ok=0, int base=10 ) const; Q_ULLONG toULongLong( bool *ok=0, int base=10 ) const; float toFloat( bool *ok=0 ) const; double toDouble( bool *ok=0 ) const; QString &setNum( short, int base=10 ); QString &setNum( ushort, int base=10 ); QString &setNum( int, int base=10 ); QString &setNum( uint, int base=10 ); QString &setNum( long, int base=10 ); QString &setNum( ulong, int base=10 ); QString &setNum( Q_LLONG, int base=10 ); QString &setNum( Q_ULLONG, int base=10 ); QString &setNum( float, char f='g', int prec=6 ); QString &setNum( double, char f='g', int prec=6 ); static QString number( long, int base=10 ); static QString number( ulong, int base=10); static QString number( Q_LLONG, int base=10 ); static QString number( Q_ULLONG, int base=10); static QString number( int, int base=10 ); static QString number( uint, int base=10); static QString number( double, char f='g', int prec=6 ); void setExpand( uint index, QChar c ); QString &operator+=( const QString &str ); #ifndef QT_NO_CAST_ASCII QString &operator+=( const QByteArray &str ); QString &operator+=( const char *str ); #endif #if !defined(QT_NO_STL) && !defined(QT_NO_CAST_ASCII) QString &operator+=( const std::string& ); #endif QString &operator+=( QChar c ); QString &operator+=( char c ); QChar at( uint i ) const { return i < d->len ? d->unicode[i] : QChar::null; } QChar operator[]( int i ) const { return at((uint)i); } QCharRef at( uint i ); QCharRef operator[]( int i ); QChar constref(uint i) const { return at(i); } QChar& ref(uint i) { // Optimized for easy-inlining by simple compilers. if ( d->count != 1 || i >= d->len ) subat( i ); d->setDirty(); return d->unicode[i]; } const QChar* unicode() const { return d->unicode; } const char* ascii() const; static QString fromAscii(const char*, int len=-1); const char* latin1() const; static QString fromLatin1(const char*, int len=-1); QCString utf8() const; static QString fromUtf8(const char*, int len=-1); QCString local8Bit() const; static QString fromLocal8Bit(const char*, int len=-1); bool operator!() const; #ifndef QT_NO_ASCII_CAST operator const char *() const { return ascii(); } #endif #ifndef QT_NO_STL operator std::string() const { return ascii() ? ascii() : ""; } #endif static QString fromUcs2( const unsigned short *ucs2 ); const unsigned short *ucs2() const; QString &setUnicode( const QChar* unicode, uint len ); QString &setUnicodeCodes( const ushort* unicode_as_ushorts, uint len ); QString &setAscii( const char*, int len=-1 ); QString &setLatin1( const char*, int len=-1 ); int compare( const QString& s ) const; static int compare( const QString& s1, const QString& s2 ) { return s1.compare( s2 ); } int localeAwareCompare( const QString& s ) const; static int localeAwareCompare( const QString& s1, const QString& s2 ) { return s1.localeAwareCompare( s2 ); } #ifndef QT_NO_DATASTREAM friend Q_EXPORT QDataStream &operator>>( QDataStream &, QString & ); #endif void compose(); #ifndef QT_NO_COMPAT const char* data() const { return ascii(); } #endif #if defined(Q_QDOC) bool startsWith( const QString& str, bool cs = TRUE ) const; bool endsWith( const QString& str, bool cs = TRUE ) const; #else // ### Qt 4.0: merge these two into one, and remove Q_QDOC hack bool startsWith( const QString& str ) const; bool startsWith( const QString& str, bool cs ) const; // ### Qt 4.0: merge these two into one, and remove Q_QDOC hack bool endsWith( const QString& str ) const; bool endsWith( const QString& str, bool cs ) const; #endif void setLength( uint newLength ); uint capacity() const; void reserve( uint minCapacity ); void squeeze(); bool simpleText() const { if ( !d->issimpletext ) checkSimpleText(); return (bool)d->issimpletext; } bool isRightToLeft() const; private: QString( int size, bool /* */ ); // allocate size incl. \0 void deref(); void real_detach(); void subat( uint ); QString multiArg( int numArgs, const QString& a1, const QString& a2, const QString& a3 = QString::null, const QString& a4 = QString::null ) const; void checkSimpleText() const; void grow( uint newLength ); #ifndef QT_NO_CAST_ASCII QString &insertHelper( uint index, const char *s, uint len=UINT_MAX ); QString &operatorPlusEqHelper( const char *s, uint len2=UINT_MAX ); #endif static QChar* latin1ToUnicode( const char*, uint * len, uint maxlen=(uint)-1 ); static QChar* latin1ToUnicode( const QByteArray&, uint * len ); static char* unicodeToLatin1( const QChar*, uint len ); QStringData *d; static QStringData* shared_null; static QStringData* makeSharedNull(); friend class QConstString; friend class QTextStream; QString( QStringData* dd, bool /* */ ) : d(dd) { } // needed for QDeepCopy void detach(); friend class QDeepCopy; }; class Q_EXPORT QCharRef { friend class QString; QString& s; uint p; QCharRef(QString* str, uint pos) : s(*str), p(pos) { } public: // most QChar operations repeated here // all this is not documented: We just say "like QChar" and let it be. #ifndef Q_QDOC ushort unicode() const { return s.constref(p).unicode(); } char latin1() const { return s.constref(p).latin1(); } // An operator= for each QChar cast constructors QCharRef operator=(char c ) { s.ref(p)=c; return *this; } QCharRef operator=(uchar c ) { s.ref(p)=c; return *this; } QCharRef operator=(QChar c ) { s.ref(p)=c; return *this; } QCharRef operator=(const QCharRef& c ) { s.ref(p)=c.unicode(); return *this; } QCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; } QCharRef operator=(short rc ) { s.ref(p)=rc; return *this; } QCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; } QCharRef operator=(int rc ) { s.ref(p)=rc; return *this; } operator QChar () const { return s.constref(p); } // each function... bool isNull() const { return unicode()==0; } bool isPrint() const { return s.constref(p).isPrint(); } bool isPunct() const { return s.constref(p).isPunct(); } bool isSpace() const { return s.constref(p).isSpace(); } bool isMark() const { return s.constref(p).isMark(); } bool isLetter() const { return s.constref(p).isLetter(); } bool isNumber() const { return s.constref(p).isNumber(); } bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); } bool isDigit() const { return s.constref(p).isDigit(); } int digitValue() const { return s.constref(p).digitValue(); } QChar lower() const { return s.constref(p).lower(); } QChar upper() const { return s.constref(p).upper(); } QChar::Category category() const { return s.constref(p).category(); } QChar::Direction direction() const { return s.constref(p).direction(); } QChar::Joining joining() const { return s.constref(p).joining(); } bool mirrored() const { return s.constref(p).mirrored(); } QChar mirroredChar() const { return s.constref(p).mirroredChar(); } const QString &decomposition() const { return s.constref(p).decomposition(); } QChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); } unsigned char combiningClass() const { return s.constref(p).combiningClass(); } // Not the non-const ones of these. uchar cell() const { return s.constref(p).cell(); } uchar row() const { return s.constref(p).row(); } #endif }; inline QCharRef QString::at( uint i ) { return QCharRef(this,i); } inline QCharRef QString::operator[]( int i ) { return at((uint)i); } class Q_EXPORT QConstString : private QString { public: QConstString( const QChar* unicode, uint length ); ~QConstString(); const QString& string() const { return *this; } }; /* */ #ifndef QT_NO_DATASTREAM Q_EXPORT QDataStream &operator<<( QDataStream &, const QString & ); Q_EXPORT QDataStream &operator>>( QDataStream &, QString & ); #endif /* */ // These two move code into makeSharedNull() and deletesData() // to improve cache-coherence (and reduce code bloat), while // keeping the common cases fast. // // No safe way to pre-init shared_null on ALL compilers/linkers. inline QString::QString() : d(shared_null ? shared_null : makeSharedNull()) { d->ref(); } // inline QString::~QString() { if ( d->deref() ) { if ( d != shared_null ) d->deleteSelf(); } } // needed for QDeepCopy inline void QString::detach() { real_detach(); } inline QString QString::section( QChar sep, int start, int end, int flags ) const { return section(QString(sep), start, end, flags); } inline QString QString::section( char sep, int start, int end, int flags ) const { return section(QChar(sep), start, end, flags); } #ifndef QT_NO_CAST_ASCII inline QString QString::section( const char *in_sep, int start, int end, int flags ) const { return section(QString(in_sep), start, end, flags); } #endif inline QString &QString::operator=( QChar c ) { *this = QString(c); return *this; } inline QString &QString::operator=( char c ) { *this = QString(QChar(c)); return *this; } inline bool QString::isNull() const { return unicode() == 0; } inline bool QString::operator!() const { return isNull(); } inline uint QString::length() const { return d->len; } inline uint QString::capacity() const { return d->maxl; } inline bool QString::isEmpty() const { return length() == 0; } inline QString QString::copy() const { return QString( *this ); } #ifndef QT_NO_CAST_ASCII inline QString &QString::insert( uint index, const char *s ) { return insertHelper( index, s ); } inline QString &QString::insert( uint index, const QByteArray &s ) { int pos = s.find( 0 ); return insertHelper( index, s, pos==-1 ? s.size() : pos ); } #endif inline QString &QString::prepend( const QString & s ) { return insert(0,s); } inline QString &QString::prepend( QChar c ) { return insert(0,c); } inline QString &QString::prepend( char c ) { return insert(0,c); } #ifndef QT_NO_CAST_ASCII inline QString &QString::prepend( const QByteArray & s ) { return insert(0,s); } #endif #ifndef QT_NO_CAST_ASCII inline QString &QString::operator+=( const QByteArray &s ) { int pos = s.find( 0 ); return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos ); } #endif inline QString &QString::append( const QString & s ) { return operator+=(s); } #ifndef QT_NO_CAST_ASCII inline QString &QString::append( const QByteArray &s ) { return operator+=(s); } inline QString &QString::append( const char * s ) { return operator+=(s); } #endif inline QString &QString::append( QChar c ) { return operator+=(c); } inline QString &QString::append( char c ) { return operator+=(c); } #ifndef QT_NO_STL inline QString &QString::operator=( const std::string& str ) { return operator=(str.c_str()); } #ifndef QT_NO_CAST_ASCII inline QString &QString::operator+=( const std::string& s ) { return operator+=(s.c_str()); } inline QString &QString::append( const std::string& s ) { return operator+=(s); } inline QString &QString::prepend( const std::string& s ) { return insert(0, s); } #endif #endif inline QString &QString::setNum( short n, int base ) { return setNum((Q_LLONG)n, base); } inline QString &QString::setNum( ushort n, int base ) { return setNum((Q_ULLONG)n, base); } inline QString &QString::setNum( int n, int base ) { return setNum((Q_LLONG)n, base); } inline QString &QString::setNum( uint n, int base ) { return setNum((Q_ULLONG)n, base); } inline QString &QString::setNum( float n, char f, int prec ) { return setNum((double)n,f,prec); } inline QString QString::arg( int a, int fieldWidth, int base ) const { return arg( (Q_LLONG)a, fieldWidth, base ); } inline QString QString::arg( uint a, int fieldWidth, int base ) const { return arg( (Q_ULLONG)a, fieldWidth, base ); } inline QString QString::arg( short a, int fieldWidth, int base ) const { return arg( (Q_LLONG)a, fieldWidth, base ); } inline QString QString::arg( ushort a, int fieldWidth, int base ) const { return arg( (Q_ULLONG)a, fieldWidth, base ); } inline QString QString::arg( const QString& a1, const QString& a2 ) const { return multiArg( 2, a1, a2 ); } inline QString QString::arg( const QString& a1, const QString& a2, const QString& a3 ) const { return multiArg( 3, a1, a2, a3 ); } inline QString QString::arg( const QString& a1, const QString& a2, const QString& a3, const QString& a4 ) const { return multiArg( 4, a1, a2, a3, a4 ); } inline int QString::find( char c, int index, bool cs ) const { return find(QChar(c), index, cs); } inline int QString::findRev( char c, int index, bool cs ) const { return findRev( QChar(c), index, cs ); } #ifndef QT_NO_CAST_ASCII inline int QString::find( const char* str, int index ) const { return find(QString::fromAscii(str), index); } inline int QString::findRev( const char* str, int index ) const { return findRev(QString::fromAscii(str), index); } #endif /* */ Q_EXPORT bool operator!=( const QString &s1, const QString &s2 ); Q_EXPORT bool operator<( const QString &s1, const QString &s2 ); Q_EXPORT bool operator<=( const QString &s1, const QString &s2 ); Q_EXPORT bool operator==( const QString &s1, const QString &s2 ); Q_EXPORT bool operator>( const QString &s1, const QString &s2 ); Q_EXPORT bool operator>=( const QString &s1, const QString &s2 ); #ifndef QT_NO_CAST_ASCII Q_EXPORT bool operator!=( const QString &s1, const char *s2 ); Q_EXPORT bool operator<( const QString &s1, const char *s2 ); Q_EXPORT bool operator<=( const QString &s1, const char *s2 ); Q_EXPORT bool operator==( const QString &s1, const char *s2 ); Q_EXPORT bool operator>( const QString &s1, const char *s2 ); Q_EXPORT bool operator>=( const QString &s1, const char *s2 ); Q_EXPORT bool operator!=( const char *s1, const QString &s2 ); Q_EXPORT bool operator<( const char *s1, const QString &s2 ); Q_EXPORT bool operator<=( const char *s1, const QString &s2 ); Q_EXPORT bool operator==( const char *s1, const QString &s2 ); //Q_EXPORT bool operator>( const char *s1, const QString &s2 ); // MSVC++ Q_EXPORT bool operator>=( const char *s1, const QString &s2 ); #endif Q_EXPORT inline const QString operator+( const QString &s1, const QString &s2 ) { QString tmp( s1 ); tmp += s2; return tmp; } #ifndef QT_NO_CAST_ASCII Q_EXPORT inline const QString operator+( const QString &s1, const char *s2 ) { QString tmp( s1 ); tmp += QString::fromAscii(s2); return tmp; } Q_EXPORT inline const QString operator+( const char *s1, const QString &s2 ) { QString tmp = QString::fromAscii( s1 ); tmp += s2; return tmp; } #endif Q_EXPORT inline const QString operator+( const QString &s1, QChar c2 ) { QString tmp( s1 ); tmp += c2; return tmp; } Q_EXPORT inline const QString operator+( const QString &s1, char c2 ) { QString tmp( s1 ); tmp += c2; return tmp; } Q_EXPORT inline const QString operator+( QChar c1, const QString &s2 ) { QString tmp; tmp += c1; tmp += s2; return tmp; } Q_EXPORT inline const QString operator+( char c1, const QString &s2 ) { QString tmp; tmp += c1; tmp += s2; return tmp; } #ifndef QT_NO_STL Q_EXPORT inline const QString operator+(const QString& s1, const std::string& s2) { return s1 + QString(s2); } Q_EXPORT inline const QString operator+(const std::string& s1, const QString& s2) { QString tmp(s2); return QString(tmp.prepend(s1)); } #endif #if defined(Q_OS_WIN32) extern Q_EXPORT QString qt_winQString(void*); extern Q_EXPORT const void* qt_winTchar(const QString& str, bool addnul); extern Q_EXPORT void* qt_winTchar_new(const QString& str); extern Q_EXPORT QCString qt_winQString2MB( const QString& s, int len=-1 ); extern Q_EXPORT QString qt_winMB2QString( const char* mb, int len=-1 ); #endif #define Q_DEFINED_QSTRING #include "qwinexport.h" #endif // QSTRING_H qurl.h /* */ #ifndef QURL_H #define QURL_H #ifndef QT_H #include "qstring.h" #endif // QT_H #ifndef QT_NO_URL class QUrlPrivate; class Q_EXPORT QUrl { public: QUrl(); QUrl( const QString& url ); QUrl( const QUrl& url ); QUrl( const QUrl& url, const QString& relUrl, bool checkSlash = FALSE ); virtual ~QUrl(); QString protocol() const; virtual void setProtocol( const QString& protocol ); QString user() const; virtual void setUser( const QString& user ); bool hasUser() const; QString password() const; virtual void setPassword( const QString& pass ); bool hasPassword() const; QString host() const; virtual void setHost( const QString& user ); bool hasHost() const; int port() const; virtual void setPort( int port ); bool hasPort() const; QString path( bool correct = TRUE ) const; virtual void setPath( const QString& path ); bool hasPath() const; virtual void setEncodedPathAndQuery( const QString& enc ); QString encodedPathAndQuery(); virtual void setQuery( const QString& txt ); QString query() const; QString ref() const; virtual void setRef( const QString& txt ); bool hasRef() const; bool isValid() const; bool isLocalFile() const; virtual void addPath( const QString& path ); virtual void setFileName( const QString& txt ); QString fileName() const; QString dirPath() const; QUrl& operator=( const QUrl& url ); QUrl& operator=( const QString& url ); bool operator==( const QUrl& url ) const; bool operator==( const QString& url ) const; static void decode( QString& url ); static void encode( QString& url ); operator QString() const; virtual QString toString( bool encodedPath = FALSE, bool forcePrependProtocol = TRUE ) const; virtual bool cdUp(); static bool isRelativeUrl( const QString &url ); protected: virtual void reset(); virtual bool parse( const QString& url ); private: QUrlPrivate *d; }; #endif //QT_NO_URL #endif qwidcoll.hG/* */ #ifndef QWIDCOLL_H #define QWIDCOLL_H #include "qwidgetlist.h" #include "qwidgetintdict.h" #endif &qtextcodecfactory.h@/* */ #ifndef QTEXTCODECFACTORY_H #define QTEXTCODECFACTORY_H #ifndef QT_H #include "qstringlist.h" #endif // QT_H #ifndef QT_NO_TEXTCODEC class QTextCodec; class Q_EXPORT QTextCodecFactory { public: static QTextCodec *createForName( const QString & ); static QTextCodec *createForMib( int ); }; #endif // QT_NO_TEXTCODEC #endif // QTEXTCODECFACTORY_H qwidgetplugin.h/* */ #ifndef QWIDGETPLUGIN_H #define QWIDGETPLUGIN_H #ifndef QT_H #include "qgplugin.h" #include "qstringlist.h" #include "qiconset.h" #endif // QT_H #ifndef QT_NO_WIDGETPLUGIN #ifdef Q_WS_WIN #ifdef QT_PLUGIN #define QT_WIDGET_PLUGIN_EXPORT __declspec(dllexport) #else #define QT_WIDGET_PLUGIN_EXPORT __declspec(dllimport) #endif #else #define QT_WIDGET_PLUGIN_EXPORT #endif class QWidgetPluginPrivate; class QWidget; class Q_EXPORT QWidgetPlugin : public QGPlugin { Q_OBJECT public: QWidgetPlugin(); ~QWidgetPlugin(); virtual QStringList keys() const = 0; virtual QWidget *create( const QString &key, QWidget *parent = 0, const char *name = 0 ) = 0; virtual QString group( const QString &key ) const; virtual QIconSet iconSet( const QString &key ) const; virtual QString includeFile( const QString &key ) const; virtual QString toolTip( const QString &key ) const; virtual QString whatsThis( const QString &key ) const; virtual bool isContainer( const QString &key ) const; private: QWidgetPluginPrivate *d; }; #ifdef QT_CONTAINER_CUSTOM_WIDGETS class QWidgetContainerPluginPrivate; class Q_EXPORT QWidgetContainerPlugin : public QWidgetPlugin { public: QWidgetContainerPlugin(); ~QWidgetContainerPlugin(); virtual QWidget* containerOfWidget( const QString &key, QWidget *container ) const; virtual bool isPassiveInteractor( const QString &key, QWidget *container ) const; virtual bool supportsPages( const QString &key ) const; virtual QWidget *addPage( const QString &key, QWidget *container, const QString &name, int index ) const; virtual void insertPage( const QString &key, QWidget *container, const QString &name, int index, QWidget *page ) const; virtual void removePage( const QString &key, QWidget *container, int index ) const; virtual void movePage( const QString &key, QWidget *container, int fromIndex, int toIndex ) const; virtual int count( const QString &key, QWidget *container ) const; virtual int currentIndex( const QString &key, QWidget *container ) const; virtual QString pageLabel( const QString &key, QWidget *container, int index ) const; virtual QWidget *page( const QString &key, QWidget *container, int index ) const; virtual void renamePage( const QString &key, QWidget *container, int index, const QString &newName ) const; virtual QWidgetList pages( const QString &key, QWidget *container ) const; virtual QString createCode( const QString &key, const QString &container, const QString &page, const QString &pageName ) const; }; #endif // QT_CONTAINER_CUSTOM_WIDGETS #endif // QT_NO_WIDGETPLUGIN #endif // QWIDGETPLUGIN_H qtimer.h 9/* */ #ifndef QTIMER_H #define QTIMER_H #ifndef QT_H #include "qobject.h" #endif // QT_H class Q_EXPORT QTimer : public QObject { Q_OBJECT public: QTimer( QObject *parent=0, const char *name=0 ); ~QTimer(); bool isActive() const; int start( int msec, bool sshot = FALSE ); void changeInterval( int msec ); void stop(); static void singleShot( int msec, QObject *receiver, const char *member ); int timerId() const { return id; } signals: void timeout(); protected: bool event( QEvent * ); private: int id; uint single : 1; uint nulltimer : 1; private: // Disabled copy constructor and operator= #if defined(Q_DISABLE_COPY) QTimer( const QTimer & ); QTimer &operator=( const QTimer & ); #endif }; inline bool QTimer::isActive() const { return id >= 0; } #endif // QTIMER_H &qwinfunctions_wce.h/* */ #ifndef QWINFUNCTIONS_WCE_H #define QWINFUNCTIONS_WCE_H #ifndef QT_H #endif // QT_H #include "qfunctions_wce.h" #endif // QWINFUNCTIONS_WCE_H