Trinity Qt initial conversion

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

1 files changed, 167 insertions, 167 deletions

diff --git a/kdgantt/KDGanttViewSubwidgets.h b/kdgantt/KDGanttViewSubwidgets.h
index b8d9d57a7..1a88411a3 100644
--- a/kdgantt/KDGanttViewSubwidgets.h
+++ b/kdgantt/KDGanttViewSubwidgets.h
@@ -37,24 +37,24 @@
 #define KDGANTTVIEWSUBWIDGETS_H
 
 
-#include <qwidget.h>
-#include <qlistview.h>
-#include <qsplitter.h>
-#include <qevent.h>
-#include <qvaluelist.h>
-#include <qcanvas.h>
-#include <qwhatsthis.h>
-#include <qpopupmenu.h>
-#include <qtooltip.h>
-#include <qtimer.h>
-#include <qgroupbox.h>
-#include <qvgroupbox.h>
-#include <qlayout.h>
-#include <qlabel.h>
-#include <qbrush.h>
-#include <qvbox.h>
-#include <qdockwindow.h>
-#include <qtimer.h>
+#include <tqwidget.h>
+#include <tqlistview.h>
+#include <tqsplitter.h>
+#include <tqevent.h>
+#include <tqvaluelist.h>
+#include <tqcanvas.h>
+#include <tqwhatsthis.h>
+#include <tqpopupmenu.h>
+#include <tqtooltip.h>
+#include <tqtimer.h>
+#include <tqgroupbox.h>
+#include <tqvgroupbox.h>
+#include <tqlayout.h>
+#include <tqlabel.h>
+#include <tqbrush.h>
+#include <tqvbox.h>
+#include <tqdockwindow.h>
+#include <tqtimer.h>
 
 #include "KDGanttView.h"
 #include "KDGanttViewTaskLink.h"
@@ -82,36 +82,36 @@ public:
    typedef KDGanttView::YearFormat YearFormat;
    typedef KDGanttView::HourFormat HourFormat;
    struct DateTimeColor {
-     QDateTime datetime;
-     QDateTime end;
-     QColor color;
+     TQDateTime datetime;
+     TQDateTime end;
+     TQColor color;
      Scale minScaleView;
      Scale maxScaleView;
      //KDCanvasLine* canvasLine;
      KDCanvasRectangle* canvasRect;
    };
-   typedef QValueList<DateTimeColor> ColumnColorList;
-   typedef QValueList<KDIntervalColorRectangle *> IntervalColorList;
+   typedef TQValueList<DateTimeColor> ColumnColorList;
+   typedef TQValueList<KDIntervalColorRectangle *> IntervalColorList;
    /*
      enum Scale { Minute, Hour, Day, Week, Month, Auto };
      enum YearFormat { FourDigit, TwoDigit, TwoDigitApostrophe };
      enum HourFormat { Hour_24, Hour_12 };
    */
 
-   KDTimeHeaderWidget (QWidget* parent,KDGanttView* gant);
+   KDTimeHeaderWidget (TQWidget* parent,KDGanttView* gant);
   ~KDTimeHeaderWidget();
 
-   QString getToolTipText(QPoint p);
+   TQString getToolTipText(TQPoint p);
    void zoomToFit();
    void zoom(double, bool absolute = true);
-   void zoomToSelection( QDateTime startTime, QDateTime endTime);
+   void zoomToSelection( TQDateTime startTime, TQDateTime endTime);
    double zoomFactor();
    void setAutoScaleMinorTickCount( int count );
    int autoScaleMinorTickCount();
-   void setHorizonStart( const QDateTime& start );
-   QDateTime horizonStart() const;
-   void setHorizonEnd( const QDateTime& start );
-   QDateTime horizonEnd() const;
+   void setHorizonStart( const TQDateTime& start );
+   TQDateTime horizonStart() const;
+   void setHorizonEnd( const TQDateTime& start );
+   TQDateTime horizonEnd() const;
 
    void setMaximumScale( Scale );
    KDTimeHeaderWidget::Scale maximumScale() const;
@@ -133,38 +133,38 @@ public:
    void setShowMinorTicks( bool );
    void setScale( Scale unit);
    bool showMinorTicks() const;
-   void setColumnBackgroundColor( const QDateTime& column,
-				  const QColor& color,
+   void setColumnBackgroundColor( const TQDateTime& column,
+				  const TQColor& color,
 				  Scale mini =  KDGanttView::Minute ,
 				  Scale maxi =  KDGanttView::Month);
 #if 0
    // This API has been replaced with KDIntervalColorRectangle and addIntervalBackgroundColor
-   void setIntervalBackgroundColor( const QDateTime& start,
-				    const QDateTime& end,
-				  const QColor& color,
+   void setIntervalBackgroundColor( const TQDateTime& start,
+				    const TQDateTime& end,
+				  const TQColor& color,
 				  Scale mini =  KDGanttView::Minute ,
 				  Scale maxi =  KDGanttView::Month);
-   bool changeBackgroundInterval( const QDateTime& oldstart,
-				  const QDateTime& oldend,
-				  const QDateTime& newstart,
-				  const QDateTime& newend );
-   bool deleteBackgroundInterval( const QDateTime& start,
-				  const QDateTime& end );
+   bool changeBackgroundInterval( const TQDateTime& oldstart,
+				  const TQDateTime& oldend,
+				  const TQDateTime& newstart,
+				  const TQDateTime& newend );
+   bool deleteBackgroundInterval( const TQDateTime& start,
+				  const TQDateTime& end );
 #endif
    void addIntervalBackgroundColor( KDIntervalColorRectangle* newItem );
    void clearBackgroundColor();
-   QColor columnBackgroundColor( const QDateTime& column ) const;
-   void setWeekendBackgroundColor( const QColor& color );
-   QColor weekendBackgroundColor() const;
-   void setWeekdayBackgroundColor( const QColor& color, int weekday );
-   QColor weekdayBackgroundColor(int weekday) const;
+   TQColor columnBackgroundColor( const TQDateTime& column ) const;
+   void setWeekendBackgroundColor( const TQColor& color );
+   TQColor weekendBackgroundColor() const;
+   void setWeekdayBackgroundColor( const TQColor& color, int weekday );
+   TQColor weekdayBackgroundColor(int weekday) const;
    void setWeekendDays( int start, int end );
    void weekendDays( int& start, int& end ) const;
    void computeTicks(bool doNotComputeRealScale = false);
-   void paintEvent(QPaintEvent *);
-   int getCoordX(QDate);
-   int getCoordX(QDateTime);
-   QDateTime getDateTimeForIndex(int coordX, bool local = true );
+   void paintEvent(TQPaintEvent *);
+   int getCoordX(TQDate);
+   int getCoordX(TQDateTime);
+   TQDateTime getDateTimeForIndex(int coordX, bool local = true );
    void setShowPopupMenu( bool show, bool showZoom, bool showScale,bool showTime,
                           bool showYear,bool showGrid, bool showPrint);
    bool registerStartTime();
@@ -173,10 +173,10 @@ public:
    ColumnColorList columnBackgroundColorList() const {
       return ccList;
     }
-   QColor weekdayColor[8];
-   void repaintMe(int left, int wid, QPainter *p = 0);
+   TQColor weekdayColor[8];
+   void repaintMe(int left, int wid, TQPainter *p = 0);
 
-   void centerDateTime( const QDateTime& center );
+   void centerDateTime( const TQDateTime& center );
 
 public slots:
     void setSettings(int);
@@ -192,22 +192,22 @@ private:
     friend class KDGanttViewItem;
     friend class KDGanttView;
     friend class KDGanttCanvasView; // calls computeIntervals
-    virtual void mousePressEvent ( QMouseEvent * e );
-    virtual void mouseReleaseEvent ( QMouseEvent * e );
-    virtual void mouseDoubleClickEvent ( QMouseEvent * e );
-    virtual void mouseMoveEvent ( QMouseEvent * e );
-    double secsFromTo( QDateTime begin, QDateTime end );
+    virtual void mousePressEvent ( TQMouseEvent * e );
+    virtual void mouseReleaseEvent ( TQMouseEvent * e );
+    virtual void mouseDoubleClickEvent ( TQMouseEvent * e );
+    virtual void mouseMoveEvent ( TQMouseEvent * e );
+    double secsFromTo( TQDateTime begin, TQDateTime end );
     void updateTimeTable();
     void computeIntervals( int height );
-    bool getColumnColor(QColor& col,int coordLow, int coordHigh);
+    bool getColumnColor(TQColor& col,int coordLow, int coordHigh);
     void moveTimeLineTo(int x);
-    //void  mousePressEvent ( QMouseEvent * ) ;
-    void resizeEvent ( QResizeEvent * ) ;
-    QValueList<int> majorTicks;
-    QValueList<QString> minorText;
-    QValueList<QString> majorText;
-    QDateTime myHorizonStart, myHorizonEnd, myRealEnd,myRealStart;
-    QDateTime myCenterDateTime;
+    //void  mousePressEvent ( TQMouseEvent * ) ;
+    void resizeEvent ( TQResizeEvent * ) ;
+    TQValueList<int> majorTicks;
+    TQValueList<TQString> minorText;
+    TQValueList<TQString> majorText;
+    TQDateTime myHorizonStart, myHorizonEnd, myRealEnd,myRealStart;
+    TQDateTime myCenterDateTime;
     void saveCenterDateTime();
     Scale myScale,myRealScale,myMaxScale,myMinScale;
     YearFormat myYearFormat;
@@ -217,21 +217,21 @@ private:
     bool flagShowZoom, flagShowScale ,flagShowTime ,flagShowYear;
     bool flagShowGrid ,flagShowPrint;
     bool flagStartTimeSet,flagEndTimeSet;
-    QColor myWeekendBackgroundColor;
+    TQColor myWeekendBackgroundColor;
     int myWeekendDaysStart, myWeekendDaysEnd;
     ColumnColorList ccList;
     IntervalColorList icList;
     int myMinorScaleCount,myMajorScaleCount;
     int myRealMinorScaleCount,myRealMajorScaleCount;
     bool flagDoNotRecomputeAfterChange,flagDoNotRepaintAfterChange;
-    QString getYear(QDate);
-    QString getHour(QTime);
-    QDateTime getEvenTimeDate(QDateTime ,Scale);
-    void computeRealScale(QDateTime start);
+    TQString getYear(TQDate);
+    TQString getHour(TQTime);
+    TQDateTime getEvenTimeDate(TQDateTime ,Scale);
+    void computeRealScale(TQDateTime start);
     int myGridMinorWidth;
     int myMajorGridHeight;
-    QPopupMenu * myPopupMenu, *scalePopupMenu, *timePopupMenu;
-    QPopupMenu * yearPopupMenu, *gridPopupMenu;
+    TQPopupMenu * myPopupMenu, *scalePopupMenu, *timePopupMenu;
+    TQPopupMenu * yearPopupMenu, *gridPopupMenu;
     KDGanttView* myGanttView;
     double myZoomFactor;
     int myAutoScaleMinorTickcount;
@@ -244,7 +244,7 @@ private:
     int beginMouseDown;
     int endMouseDown;
     bool autoComputeTimeLine;
-    QPixmap paintPix;
+    TQPixmap paintPix;
 };
 
 /* KDTimeTableWidget */
@@ -255,7 +255,7 @@ class KDTimeTableWidget : public QCanvas
    Q_OBJECT
 
 public:
-   KDTimeTableWidget (QWidget* parent,KDGanttView* my);
+   KDTimeTableWidget (TQWidget* parent,KDGanttView* my);
 
     void setBlockUpdating( bool block = true );
     bool blockUpdating();
@@ -263,25 +263,25 @@ public:
     void dec_blockUpdating();
     void setShowTaskLinks( bool show );
     bool showTaskLinks();
-    QPtrList<KDGanttViewTaskLink>taskLinks();
+    TQPtrList<KDGanttViewTaskLink>taskLinks();
     void clearTaskLinks();
     void updateMyContent();
     void removeItemFromTasklinks( KDGanttViewItem * );
-    void setHorBackgroundLines( int count, QBrush brush );
-    int horBackgroundLines( QBrush& brush );
+    void setHorBackgroundLines( int count, TQBrush brush );
+    int horBackgroundLines( TQBrush& brush );
 
-    void setNoInformationBrush( const QBrush& brush );
-    QBrush noInformationBrush() const;
+    void setNoInformationBrush( const TQBrush& brush );
+    TQBrush noInformationBrush() const;
 
-    int getCoordX( QDateTime dt );
+    int getCoordX( TQDateTime dt );
 
 signals:
    void   heightComputed( int );
 
 public slots:
-  void expandItem(QListViewItem * );
-  void collapseItem(QListViewItem * );
-  void highlightItem(QListViewItem * );
+  void expandItem(TQListViewItem * );
+  void collapseItem(TQListViewItem * );
+  void highlightItem(TQListViewItem * );
   void resetWidth( int );
   void checkHeight( int );
 private:
@@ -293,15 +293,15 @@ private:
 
    bool taskLinksVisible;
 
-   QPtrList<KDGanttViewTaskLink> myTaskLinkList;
+   TQPtrList<KDGanttViewTaskLink> myTaskLinkList;
 
-   QPtrList<KDCanvasLine> verGridList;
-   QPtrList<KDCanvasLine> horGridList;
-   QPtrList<KDCanvasRectangle> horDenseList;
-   QPtrList<KDCanvasRectangle> showNoInfoList;
+   TQPtrList<KDCanvasLine> verGridList;
+   TQPtrList<KDCanvasLine> horGridList;
+   TQPtrList<KDCanvasRectangle> horDenseList;
+   TQPtrList<KDCanvasRectangle> showNoInfoList;
    int denseLineCount;
-   QBrush denseLineBrush, noInfoLineBrush;
-   QPtrList<KDCanvasRectangle> columnColorList;
+   TQBrush denseLineBrush, noInfoLineBrush;
+   TQPtrList<KDCanvasRectangle> columnColorList;
 
   int computeHeight();
   void computeVerticalGrid();
@@ -316,7 +316,7 @@ private:
    void showMinorGrid();
    void hideGrid();
 
-   QPen gridPen;
+   TQPen gridPen;
    int maximumComputedGridHeight;
   int minimumHeight;
   int int_blockUpdating;
@@ -331,23 +331,23 @@ class KDLegendWidget : public KDGanttSemiSizingControl
    Q_OBJECT
 
 public:
-  KDLegendWidget ( QWidget* parent, KDGanttMinimizeSplitter* legendParent );
+  KDLegendWidget ( TQWidget* parent, KDGanttMinimizeSplitter* legendParent );
   void showMe(bool);
   bool isShown();
-  void addLegendItem( KDGanttViewItem::Shape shape, const QColor& shapeColor, const QString& text );
+  void addLegendItem( KDGanttViewItem::Shape shape, const TQColor& shapeColor, const TQString& text );
   void clearLegend();
-  void setFont( QFont );
-  void drawToPainter( QPainter *p );
+  void setFont( TQFont );
+  void drawToPainter( TQPainter *p );
   void setAsDockwindow( bool dockwin );
   bool asDockwindow();
-  QDockWindow* dockwindow();
-  QSize legendSize();
-  QSize legendSizeHint();
+  TQDockWindow* dockwindow();
+  TQSize legendSize();
+  TQSize legendSizeHint();
  private:
-  QGroupBox * myLegend;
-  QLabel* myLabel;
-  QScrollView * scroll;
-  QDockWindow* dock;
+  TQGroupBox * myLegend;
+  TQLabel* myLabel;
+  TQScrollView * scroll;
+  TQDockWindow* dock;
   KDGanttMinimizeSplitter* myLegendParent;
 };
 
@@ -357,38 +357,38 @@ class KDListView : public QListView
    Q_OBJECT
 
 public:
-   KDListView (QWidget* parent,KDGanttView* gv );
+   KDListView (TQWidget* parent,KDGanttView* gv );
    KDGanttView* myGanttView;
-   void drawToPainter( QPainter *p, bool drawHeader=false );
+   void drawToPainter( TQPainter *p, bool drawHeader=false );
    void setCalendarMode( bool mode );
   bool calendarMode() { return _calendarMode; };
-  QString getWhatsThisText(QPoint p);
-  void setOpen ( QListViewItem * item, bool open );
-  void dragEnterEvent ( QDragEnterEvent * );
-  void dragMoveEvent ( QDragMoveEvent * );
-  void dragLeaveEvent ( QDragLeaveEvent * );
-  void dropEvent ( QDropEvent * );
-  QDragObject * dragObject ();
+  TQString getWhatsThisText(TQPoint p);
+  void setOpen ( TQListViewItem * item, bool open );
+  void dragEnterEvent ( TQDragEnterEvent * );
+  void dragMoveEvent ( TQDragMoveEvent * );
+  void dragLeaveEvent ( TQDragLeaveEvent * );
+  void dropEvent ( TQDropEvent * );
+  TQDragObject * dragObject ();
   void startDrag ();
-  void paintemptyarea ( QPainter * p, const QRect & rect ){ QListView::paintEmptyArea( p, rect );};
+  void paintemptyarea ( TQPainter * p, const TQRect & rect ){ TQListView::paintEmptyArea( p, rect );};
 
 public:
     class DrawableItem {
     public:
-        DrawableItem(int level, int ypos, QListViewItem *item ) { y = ypos; l = level; i = item; };
+        DrawableItem(int level, int ypos, TQListViewItem *item ) { y = ypos; l = level; i = item; };
         int y;
         int l;
-        QListViewItem * i;
+        TQListViewItem * i;
     };
 protected:
-    void drawAllContents(QPainter * p, int cx, int cy, int cw, int ch);
-    int buildDrawables(QPtrList<KDListView::DrawableItem> &lst, int level, int ypos, QListViewItem *item, int ymin, int ymax) const;
+    void drawAllContents(TQPainter * p, int cx, int cy, int cw, int ch);
+    int buildDrawables(TQPtrList<KDListView::DrawableItem> &lst, int level, int ypos, TQListViewItem *item, int ymin, int ymax) const;
 
 private slots:
-  void dragItem( QListViewItem * );
+  void dragItem( TQListViewItem * );
  private:
-   void resizeEvent ( QResizeEvent * ) ;
-  void contentsMouseDoubleClickEvent ( QMouseEvent * e );
+   void resizeEvent ( TQResizeEvent * ) ;
+  void contentsMouseDoubleClickEvent ( TQMouseEvent * e );
   bool _calendarMode;
 
 
@@ -457,15 +457,15 @@ class KDIntervalColorRectangle: public KDCanvasRectangle
 public:
   KDIntervalColorRectangle( KDGanttView* view );
 
-  void setDateTimes( const QDateTime& start,
-                     const QDateTime& end );
-  QDateTime start() const { return mStart; }
-  QDateTime end() const { return mEnd; }
+  void setDateTimes( const TQDateTime& start,
+                     const TQDateTime& end );
+  TQDateTime start() const { return mStart; }
+  TQDateTime end() const { return mEnd; }
 
-  void setColor( const QColor& color );
+  void setColor( const TQColor& color );
 
   enum HitTest { Start, Middle, End };
-  HitTest hitTest( KDTimeHeaderWidget* timeHeader, const QPoint& pos ) const;
+  HitTest hitTest( KDTimeHeaderWidget* timeHeader, const TQPoint& pos ) const;
 
   void layout( KDTimeHeaderWidget* timeHeader, int height );
 
@@ -473,9 +473,9 @@ public:
   /*reimp*/ int rtti() const { return RTTI; }
 
 private:
-  QColor mColor;
-  QDateTime mStart;
-  QDateTime mEnd;
+  TQColor mColor;
+  TQDateTime mStart;
+  TQDateTime mEnd;
 };
 
 class KDCanvasToolTip;
@@ -485,11 +485,11 @@ class KDGanttCanvasView : public QCanvasView
     Q_OBJECT
 
 public:
-    KDGanttCanvasView(KDGanttView* sender, QCanvas* canvas = 0, QWidget* parent = 0, const char* name = 0 );
+    KDGanttCanvasView(KDGanttView* sender, TQCanvas* canvas = 0, TQWidget* parent = 0, const char* name = 0 );
     ~KDGanttCanvasView();
-    QString getToolTipText(QPoint p);
-    QString getWhatsThisText(QPoint p);
-    void drawToPainter ( QPainter * p );
+    TQString getToolTipText(TQPoint p);
+    TQString getWhatsThisText(TQPoint p);
+    void drawToPainter ( TQPainter * p );
     void resetCutPaste( KDGanttViewItem* );
     void setShowPopupMenu( bool show );
     bool showPopupMenu();
@@ -500,35 +500,35 @@ public:
 protected:
     friend class KDGanttView;
     friend class KDListView;
-    virtual void contentsMousePressEvent ( QMouseEvent * ) ;
-    virtual void contentsMouseReleaseEvent ( QMouseEvent * );
-    virtual void contentsMouseDoubleClickEvent ( QMouseEvent * );
-    virtual void contentsMouseMoveEvent ( QMouseEvent * ) ;
-    virtual void viewportPaintEvent ( QPaintEvent * pe );
-    void resizeEvent ( QResizeEvent * ) ;
+    virtual void contentsMousePressEvent ( TQMouseEvent * ) ;
+    virtual void contentsMouseReleaseEvent ( TQMouseEvent * );
+    virtual void contentsMouseDoubleClickEvent ( TQMouseEvent * );
+    virtual void contentsMouseMoveEvent ( TQMouseEvent * ) ;
+    virtual void viewportPaintEvent ( TQPaintEvent * pe );
+    void resizeEvent ( TQResizeEvent * ) ;
     void set_MouseTracking(bool on);
-    int getType(QCanvasItem*);
-    KDGanttViewItem* getItem(QCanvasItem*);
-    KDGanttViewTaskLink* getLink(QCanvasItem*);
+    int getType(TQCanvasItem*);
+    KDGanttViewItem* getItem(TQCanvasItem*);
+    KDGanttViewTaskLink* getLink(TQCanvasItem*);
     int getItemArea(KDGanttViewItem *item, int x);
     int getLinkType(int from, int to);
 
     KDGanttView* mySignalSender;
     KDGanttViewItem* currentItem, *lastClickedItem, *cuttedItem;
-    QCanvasRectangle* movingItem;
+    TQCanvasRectangle* movingItem;
     KDGanttViewTaskItem* movingGVItem;
-    QPoint movingStart;
-    QDateTime movingStartDate;
+    TQPoint movingStart;
+    TQDateTime movingStartDate;
     enum MovingOperation { Moving, ResizingLeft, ResizingRight };
     MovingOperation movingOperation;
     KDGanttViewTaskLink* currentLink;
     KDCanvasWhatsThis* myWhatsThis;
-    QPopupMenu* onItem;
+    TQPopupMenu* onItem;
     bool _showItemAddPopupMenu;
     int myMyContentsHeight;
     KDGanttViewItem *fromItem;
     bool linkItemsEnabled;
-    QCanvasLine *linkLine;
+    TQCanvasLine *linkLine;
     int fromArea;
     bool autoScrollEnabled;
     bool mouseDown;
@@ -551,29 +551,29 @@ private slots:
   void myUpdateScrollBars();
 
 private:
-  MovingOperation gvItemHitTest( KDGanttViewItem *item, KDTimeHeaderWidget* timeHeader, const QPoint &pos );
+  MovingOperation gvItemHitTest( KDGanttViewItem *item, KDTimeHeaderWidget* timeHeader, const TQPoint &pos );
 private:
   KDCanvasToolTip* myToolTip;
-  QTimer *myScrollTimer;
-  QPoint mousePos;
-  QTimer scrollBarTimer;
+  TQTimer *myScrollTimer;
+  TQPoint mousePos;
+  TQTimer scrollBarTimer;
 };
 
 class KDTimeHeaderToolTip :public QToolTip
 {
 
 public:
-  KDTimeHeaderToolTip( QWidget *wid, KDTimeHeaderWidget* header ) : QToolTip( wid ), _wid(wid),_header (header) {
+  KDTimeHeaderToolTip( TQWidget *wid, KDTimeHeaderWidget* header ) : TQToolTip( wid ), _wid(wid),_header (header) {
 
 };
 
 protected:
-  virtual void maybeTip( const QPoint& p)
+  virtual void maybeTip( const TQPoint& p)
     {
       static bool ishidden = true;
-      if (QToolTip::isGloballyEnabled () ) {
+      if (TQToolTip::isGloballyEnabled () ) {
 	if (ishidden) {
-	  tip( QRect( p.x(),p.y(),5,5), _header->getToolTipText(p));
+	  tip( TQRect( p.x(),p.y(),5,5), _header->getToolTipText(p));
 	}
 	else
 	  hide();
@@ -581,7 +581,7 @@ protected:
       }
   }
 private:
-  QWidget* _wid;
+  TQWidget* _wid;
   KDTimeHeaderWidget * _header;
 };
 
@@ -589,17 +589,17 @@ class KDCanvasToolTip :public QToolTip
 {
 
 public:
-  KDCanvasToolTip( QWidget *wid, KDGanttCanvasView* canview ) : QToolTip( wid ), _wid(wid),_canview (canview) {
+  KDCanvasToolTip( TQWidget *wid, KDGanttCanvasView* canview ) : TQToolTip( wid ), _wid(wid),_canview (canview) {
 
 };
 
 protected:
-  virtual void maybeTip( const QPoint& p)
+  virtual void maybeTip( const TQPoint& p)
     {
       static bool ishidden = true;
-      if (QToolTip::isGloballyEnabled () ) {
+      if (TQToolTip::isGloballyEnabled () ) {
 	if (ishidden) {
-	  tip( QRect( p.x()-2,p.y()-2,5,5), _canview->getToolTipText(p));
+	  tip( TQRect( p.x()-2,p.y()-2,5,5), _canview->getToolTipText(p));
 	}
 	else
 	  hide();
@@ -607,37 +607,37 @@ protected:
       }
   }
 private:
-  QWidget* _wid;
+  TQWidget* _wid;
   KDGanttCanvasView * _canview;
 };
 
 class KDCanvasWhatsThis :public QWhatsThis
 {
 public:
-  KDCanvasWhatsThis( QWidget *wid, KDGanttCanvasView* canview ) : QWhatsThis( wid ), _wid(wid),_canview (canview) { };
+  KDCanvasWhatsThis( TQWidget *wid, KDGanttCanvasView* canview ) : TQWhatsThis( wid ), _wid(wid),_canview (canview) { };
 
 protected:
-  virtual QString text( const QPoint& p)
+  virtual TQString text( const TQPoint& p)
   {
     return _canview->getWhatsThisText(p) ;
   }
 private:
-  QWidget* _wid;
+  TQWidget* _wid;
   KDGanttCanvasView * _canview;
 };
 
 class KDListViewWhatsThis :public QWhatsThis
 {
 public:
-  KDListViewWhatsThis( QWidget *wid, KDListView* view ) : QWhatsThis( wid ), _wid(wid),_view (view) { };
+  KDListViewWhatsThis( TQWidget *wid, KDListView* view ) : TQWhatsThis( wid ), _wid(wid),_view (view) { };
 
 protected:
-  virtual QString text( const QPoint& p)
+  virtual TQString text( const TQPoint& p)
   {
     return _view->getWhatsThisText(p) ;
   }
 private:
-  QWidget* _wid;
+  TQWidget* _wid;
   KDListView * _view;
 };