TQt4 port knutclient

This enables compilation under both Qt3 and Qt4


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

1 files changed, 114 insertions, 114 deletions

diff --git a/src/knutanalog.cpp b/src/knutanalog.cpp
index c240523..8469738 100644
--- a/src/knutanalog.cpp
+++ b/src/knutanalog.cpp
@@ -26,20 +26,20 @@
 #include <stdio.h>
 #include <math.h>
 
-#include <qpainter.h>
-#include <qframe.h>
-#include <qfontmetrics.h>
-#include <qfont.h>
-#include <qbitmap.h>
-#include <qpaintdevice.h>
-#include <qcolor.h>
+#include <tqpainter.h>
+#include <tqframe.h>
+#include <tqfontmetrics.h>
+#include <tqfont.h>
+#include <tqbitmap.h>
+#include <tqpaintdevice.h>
+#include <tqcolor.h>
 
 #include <kapp.h>
 
 
 
-KNutAnalog::KNutAnalog( QWidget *parent, const char *name, int bottomLimit, int topLimit, int typeOfView, int countOfParts, int countOfSubParts, QColor pointerColor, QColor scaleColor, QColor textColor, QFont *analogFonts, int qualityOfPointer, bool makeBG )
-    : QFrame( parent, name ), m_bottomLimit(bottomLimit), m_topLimit(topLimit), m_typeOfView(typeOfView), m_countOfParts(countOfParts), m_countOfSubParts(countOfSubParts), m_pointerColor(pointerColor), m_scaleColor(scaleColor) ,m_textColor(textColor) {
+KNutAnalog::KNutAnalog( TQWidget *tqparent, const char *name, int bottomLimit, int topLimit, int typeOfView, int countOfParts, int countOfSubParts, TQColor pointerColor, TQColor scaleColor, TQColor textColor, TQFont *analogFonts, int qualityOfPointer, bool makeBG )
+    : TQFrame( tqparent, name ), m_bottomLimit(bottomLimit), m_topLimit(topLimit), m_typeOfView(typeOfView), m_countOfParts(countOfParts), m_countOfSubParts(countOfSubParts), m_pointerColor(pointerColor), m_scaleColor(scaleColor) ,m_textColor(textColor) {
 
 
   if ( qualityOfPointer==0) {
@@ -112,18 +112,18 @@ KNutAnalog::KNutAnalog( QWidget *parent, const char *name, int bottomLimit, int
   m_countOfColorParts = 0;
   setMinimumSize( AnalogWidth, AnalogWidth );
   setMaximumSize( AnalogWidth, AnalogWidth );
-  setFrameStyle( QFrame::Box | QFrame::Raised );
+  setFrameStyle( TQFrame::Box | TQFrame::Raised );
   setLineWidth( 2 );
 
-  m_backgroudLayerBig = new QPixmap( (AnalogWidth-8) * 3,(AnalogWidth-8)*3 );
+  m_backgroudLayerBig = new TQPixmap( (AnalogWidth-8) * 3,(AnalogWidth-8)*3 );
 
-  m_scaleLayerBig = new QPixmap ( (AnalogWidth-8)*3, (AnalogWidth-8)*3 ); //
-  m_scaleLayerSmall = new QPixmap ( (AnalogWidth-8), (AnalogWidth-8)); //
+  m_scaleLayerBig = new TQPixmap ( (AnalogWidth-8)*3, (AnalogWidth-8)*3 ); //
+  m_scaleLayerSmall = new TQPixmap ( (AnalogWidth-8), (AnalogWidth-8)); //
 
-  m_wholeLayer = new QPixmap ( AnalogWidth-8, AnalogWidth-8 ); //
+  m_wholeLayer = new TQPixmap ( AnalogWidth-8, AnalogWidth-8 ); //
 
-  m_pointerLayerBig = new QPixmap ( (AnalogWidth-8)*3, (AnalogWidth-8)*3 ); //
-  m_pointerLayerSmall = new QPixmap ( (AnalogWidth-8), (AnalogWidth-8)); //
+  m_pointerLayerBig = new TQPixmap ( (AnalogWidth-8)*3, (AnalogWidth-8)*3 ); //
+  m_pointerLayerSmall = new TQPixmap ( (AnalogWidth-8), (AnalogWidth-8)); //
 
   setDefaultArcColor(false); // sets standard registers // nastavime standartni registry
 
@@ -153,42 +153,42 @@ void KNutAnalog::makeBackground (bool run) {
   paintBackGround();
   m_showBackGround = true;
   if (run) {
-    repaint();
+    tqrepaint();
     }
   }
 
 
-void KNutAnalog::setText (QString inscription, QString text_up, bool run) {
+void KNutAnalog::setText (TQString inscription, TQString text_up, bool run) {
 
   m_inscription=inscription;
   AnMJ=text_up;
   if (run) {
     paintBackGround();
     m_showBackGround = true;
-    repaint();
+    tqrepaint();
     }
   }
 
 void KNutAnalog::setDefaultArcColor(bool run) {
 
-   m_arcColors[0] = Qt::white;
-   m_arcColors[1] = Qt::green;
-   m_arcColors[2] = Qt::yellow;
-   m_arcColors[3] = Qt::red;
-   m_arcColors[4] = Qt::blue;
-   m_arcColors[5] = Qt::cyan;
-   m_arcColors[6] = Qt::magenta;
-   m_arcColors[7] = Qt::gray;
-   m_arcColors[8] = Qt::black;
+   m_arcColors[0] = TQt::white;
+   m_arcColors[1] = TQt::green;
+   m_arcColors[2] = TQt::yellow;
+   m_arcColors[3] = TQt::red;
+   m_arcColors[4] = TQt::blue;
+   m_arcColors[5] = TQt::cyan;
+   m_arcColors[6] = TQt::magenta;
+   m_arcColors[7] = TQt::gray;
+   m_arcColors[8] = TQt::black;
   if (run) {
     paintBackGround();
     m_showBackGround=true;
-    repaint();
+    tqrepaint();
     }
   }
 
 
-void KNutAnalog::setArcColor(int reg, QColor color ) {
+void KNutAnalog::setArcColor(int reg, TQColor color ) {
   if ((reg > -1) && (reg < 9)) m_arcColors[reg] = color;
   }
 
@@ -204,7 +204,7 @@ void KNutAnalog::addArc (double startOfCircle, double endOfCircle, int regColor,
   if (run) {
     paintBackGround();
     m_showBackGround = true;
-    repaint ();
+    tqrepaint ();
     }
   }
 
@@ -215,7 +215,7 @@ void KNutAnalog::delArc (bool run) {
   if (run) {
     paintBackGround();
     m_showBackGround = true;
-    repaint ();
+    tqrepaint ();
     }
   }
 
@@ -230,7 +230,7 @@ void KNutAnalog::setRange (int Astart, int Aend , bool run) {
   if (run) {
      paintBackGround();
      m_showBackGround = true;
-     repaint ();
+     tqrepaint ();
      }
   }
 
@@ -242,34 +242,34 @@ void KNutAnalog::setMember (int Count, bool run) {
   if (run) {
     paintBackGround();
     m_showBackGround = true;
-    repaint ();
+    tqrepaint ();
     }
   }
 
 
 
-void KNutAnalog::setPointerColor (QColor pointerColor,  bool run ) {
+void KNutAnalog::setPointerColor (TQColor pointerColor,  bool run ) {
 
   m_pointerColor = pointerColor;
   paintPointer();
   m_showPointer = true;
   if (run) {
-     repaint ();
+     tqrepaint ();
     }
   }
 
 
-void KNutAnalog::repaintPointer ( bool run ) {
+void KNutAnalog::tqrepaintPointer ( bool run ) {
 
   paintPointer();
   m_showPointer = true;
   if (run) {
-     repaint ();
+     tqrepaint ();
     }
   }
 
 
-void KNutAnalog::setFontColor (QColor fontColor,  bool run ) {
+void KNutAnalog::setFontColor (TQColor fontColor,  bool run ) {
 
   m_textColor = fontColor;
 //  paintBackGround();
@@ -277,18 +277,18 @@ void KNutAnalog::setFontColor (QColor fontColor,  bool run ) {
   if (run) {
      paintBackGround();
   m_showBackGround = true;
-     repaint ();
+     tqrepaint ();
     }
   }
 
 
-void KNutAnalog::setScaleColor (QColor scaleColor,  bool run) {
+void KNutAnalog::setScaleColor (TQColor scaleColor,  bool run) {
 
   m_scaleColor = scaleColor;
   if (run) {
     paintBackGround();
     m_showBackGround = true;
-    repaint ();
+    tqrepaint ();
     }
   }
 
@@ -307,7 +307,7 @@ void KNutAnalog::setDigitalProcesing (int qualityOfPointer, bool run ) {
     }
   paintPointer();
   m_showPointer = true; // pri jakemkoliv prekresleni prekreslime rucicku
-  if (run) repaint ();
+  if (run) tqrepaint ();
 }
 
 
@@ -320,7 +320,7 @@ void KNutAnalog::setPointer (double pointerValue, bool run ) {
     if (run) {
 //      paintPointer();
       m_showPointer = true; // pri jakemkoliv prekresleni prekreslime rucicku
-      repaint ();
+      tqrepaint ();
     }
   }
 }
@@ -329,51 +329,51 @@ void KNutAnalog::setPointer (double pointerValue, bool run ) {
 
 //************** PUBLIC SLOTS  **********************************
 
-void KNutAnalog::slotSetScaleFont(QFont newScaleFont){
+void KNutAnalog::slotSetScaleFont(TQFont newScaleFont){
   m_scaleFont = newScaleFont;
   paintBackGround();
   m_showBackGround=true;
-  repaint();
+  tqrepaint();
   }
 
-void KNutAnalog::slotSetTextFont(QFont newTextFont){
+void KNutAnalog::slotSetTextFont(TQFont newTextFont){
   m_textFont = newTextFont;
   paintBackGround();
-  paintPointer(); // repaint values if pointer
+  paintPointer(); // tqrepaint values if pointer
   m_showBackGround=true;
   m_showPointer=true;
-  repaint();
+  tqrepaint();
   }
 
-void KNutAnalog::slotSetAllFont(QFont newAllFont){
+void KNutAnalog::slotSetAllFont(TQFont newAllFont){
   m_scaleFont = newAllFont;
   m_textFont = newAllFont;
   paintBackGround();
-  paintPointer(); // repaint values if pointer
+  paintPointer(); // tqrepaint values if pointer
   m_showBackGround=true;
   m_showPointer=true;
-  repaint();
+  tqrepaint();
   }
 
 
-void KNutAnalog::repaintAll (void) {
+void KNutAnalog::tqrepaintAll (void) {
   paintBackGround();
   m_showBackGround = true;
   m_showPointer = true;
-  repaint ();
+  tqrepaint ();
   }
 
 
 //************** protected ****************************
 
-void KNutAnalog::resizeEvent( QResizeEvent * ) {
+void KNutAnalog::resizeEvent( TQResizeEvent * ) {
 }
 
 
-void KNutAnalog::paintEvent( QPaintEvent *e ) {
+void KNutAnalog::paintEvent( TQPaintEvent *e ) {
 
   if (isVisible()) {
-    QFrame::paintEvent(e);
+    TQFrame::paintEvent(e);
     if ((m_showBackGround) || (m_showPointer)) { // novou kompletni vrstvu sestavime jen pokud doslo ke zmene
       bitBlt( m_wholeLayer, 0, 0, m_scaleLayerSmall, 0, 0, m_widthOfBackGround, m_widthOfBackGround, CopyROP); //nakopirujeme vrstvu
       bitBlt( m_wholeLayer, 0, 0, m_pointerLayerSmall, 0, 0, m_widthOfBackGround, m_widthOfBackGround, AndROP ); //nakopirujeme rucicku
@@ -388,8 +388,8 @@ void KNutAnalog::paintEvent( QPaintEvent *e ) {
 //***************private ************************
 
 void KNutAnalog::paintBackGround ( void ) {
-  QPainter paint;
-  QImage myImage; //big image
+  TQPainter paint;
+  TQImage myImage; //big image
 
 //qDebug ("KNutAnalog::paintBackGround");
 
@@ -427,9 +427,9 @@ void KNutAnalog::paintPointer ( void ) {
 
 
 void KNutAnalog::paintPointerSlowly ( double position, int centerX , int centerY, int widthOfCircle) {
-  QPainter paint;
+  TQPainter paint;
 
-  QImage myImage; //big image
+  TQImage myImage; //big image
   double angle;
   int lengthOfPointer = widthOfCircle / 2 - 12;
 
@@ -440,13 +440,13 @@ void KNutAnalog::paintPointerSlowly ( double position, int centerX , int centerY
   // painting of pointer
   angle = ((m_angleOfViewer/(m_topLimit-m_bottomLimit))*(position-m_bottomLimit))*((-1)*m_direction)+m_startAngle;
 
-  m_pointerLayerBig->fill( Qt::white );  //color if beckground
+  m_pointerLayerBig->fill( TQt::white );  //color if beckground
   paint.begin( m_pointerLayerBig ); // paints of pointer
   paint.setBackgroundMode(Qt::TransparentMode);
 
   paint.setBrush( m_pointerColor ); // sets color
   paint.setPen ( m_pointerColor );
-  QPointArray pts;
+  TQPointArray pts;
   // k posuvu a k otoceni pouziva funkce paintu
   // for rotate and translate uses functions of paint
   paint.translate (centerX, centerY);
@@ -471,13 +471,13 @@ void KNutAnalog::paintPointerSlowly ( double position, int centerX , int centerY
 
 
 void KNutAnalog::paintPointerFastly (double position) {
-  QPainter paint;
+  TQPainter paint;
   double uhel;
 
   int delka = m_widthOfScale / 2 - 4;
 
   //m_pointerMutex.lock();
-  m_pointerLayerSmall->fill( Qt::white );  //background color
+  m_pointerLayerSmall->fill( TQt::white );  //background color
   paint.begin( m_pointerLayerSmall ); // kreslime na plochu rucicky
   paint.setBackgroundMode(Qt::TransparentMode);
   paintValueOfPointer ( &paint, m_valueOfPointer);
@@ -492,7 +492,7 @@ void KNutAnalog::paintPointerFastly (double position) {
 
   paint.setBrush( m_pointerColor ); // nastavime barvu
   paint.setPen ( m_pointerColor );
-  QPointArray pts;
+  TQPointArray pts;
   // for translate a rotate uses functions of paint // k posuvu a k otoceni pouziva funkce paintu
   paint.translate (m_centerX, m_centerY);
   paint.rotate(-uhel);
@@ -505,7 +505,7 @@ void KNutAnalog::paintPointerFastly (double position) {
 
 
 
-void KNutAnalog::paintPartOfCircle ( QPainter *paint, int centerX , int centerY, int widthOfCircle ) {
+void KNutAnalog::paintPartOfCircle ( TQPainter *paint, int centerX , int centerY, int widthOfCircle ) {
   double Astart, Aend;
 
   // pocitani uhlu
@@ -540,7 +540,7 @@ void KNutAnalog::paintPartOfCircle ( QPainter *paint, int centerX , int centerY,
 
 
 
-void KNutAnalog::paintScale ( QPainter *paint , int centerX , int centerY, int widthOfCircle) {
+void KNutAnalog::paintScale ( TQPainter *paint , int centerX , int centerY, int widthOfCircle) {
 
   int bottomMax = widthOfCircle/2 - 29;
   int bottom = widthOfCircle/2 -17 ;
@@ -571,28 +571,28 @@ void KNutAnalog::paintScale ( QPainter *paint , int centerX , int centerY, int w
 
 
 
-void KNutAnalog::makeAntialiasing (QImage* bigImage, QPixmap* smallPixmap, const QRgb colorOfBG, speedOfAAlias speed, int typeOfView) {
+void KNutAnalog::makeAntialiasing (TQImage* bigImage, TQPixmap* smallPixmap, const TQRgb colorOfBG, speedOfAAlias speed, int typeOfView) {
   ulong imageRed, imageGreen, imageBlue;
-  QRgb imageRgb;
-  QImage* smallImage;
+  TQRgb imageRgb;
+  TQImage* smallImage;
   bool computeAverage;
   ulong sumOfRed, sumOfGreen, sumOfBlue;
 
   if (speed == slow) {
-    sumOfRed =  (qRed ( colorOfBG ))*9;
-    sumOfGreen = (qGreen ( colorOfBG ))*9;
-    sumOfBlue = (qBlue ( colorOfBG ))*9;
+    sumOfRed =  (tqRed ( colorOfBG ))*9;
+    sumOfGreen = (tqGreen ( colorOfBG ))*9;
+    sumOfBlue = (tqBlue ( colorOfBG ))*9;
     }
   else {
-    sumOfRed =  (qRed ( colorOfBG ))*16;
-    sumOfGreen = (qGreen ( colorOfBG ))*16;
-    sumOfBlue = (qBlue ( colorOfBG ))*16;
+    sumOfRed =  (tqRed ( colorOfBG ))*16;
+    sumOfGreen = (tqGreen ( colorOfBG ))*16;
+    sumOfBlue = (tqBlue ( colorOfBG ))*16;
     }
   int smallImageWidth=bigImage->width()/3;
   int smallImageHeight=bigImage->height()/3;
 
 
-  smallImage = new QImage(smallImageWidth,smallImageHeight, bigImage->depth());
+  smallImage = new TQImage(smallImageWidth,smallImageHeight, bigImage->depth());
 
 //  imageRgb = bigImage->pixel(1,1);
 
@@ -630,9 +630,9 @@ void KNutAnalog::makeAntialiasing (QImage* bigImage, QPixmap* smallPixmap, const
           for (int xi = 0 ; xi < 3; xi ++) {
             for (int yi = 0 ; yi < 3; yi ++) {
             imageRgb = bigImage->pixel(x*3+xi,y*3+yi);
-            imageRed +=  qRed ( imageRgb );
-            imageGreen += qGreen ( imageRgb );
-            imageBlue += qBlue ( imageRgb );
+            imageRed +=  tqRed ( imageRgb );
+            imageGreen += tqGreen ( imageRgb );
+            imageBlue += tqBlue ( imageRgb );
             }
           }
           if (((imageRed == sumOfRed) && (imageGreen == sumOfGreen) && (imageBlue == sumOfBlue))) {
@@ -642,7 +642,7 @@ void KNutAnalog::makeAntialiasing (QImage* bigImage, QPixmap* smallPixmap, const
             imageRed = imageRed / 9;
             imageGreen = imageGreen/9;
             imageBlue = imageBlue/9;
-            smallImage->setPixel (x,y,qRgb(imageRed,imageGreen,imageBlue));
+            smallImage->setPixel (x,y,tqRgb(imageRed,imageGreen,imageBlue));
             }
           }
         else {
@@ -656,22 +656,22 @@ void KNutAnalog::makeAntialiasing (QImage* bigImage, QPixmap* smallPixmap, const
             for (int yi = 0 ; yi < 3; yi ++) {
               if ((xi == 1) && (yi == 1)) { // center of 3x3 area
                 imageRgb = bigImage->pixel(x*3+xi,y*3+yi);
-                imageRed +=  qRed ( imageRgb )*4;
-                imageGreen += qGreen ( imageRgb )*4;
-                imageBlue += qBlue ( imageRgb )*4;
+                imageRed +=  tqRed ( imageRgb )*4;
+                imageGreen += tqGreen ( imageRgb )*4;
+                imageBlue += tqBlue ( imageRgb )*4;
                 }
               else {
                 if ((xi == 1) || (yi == 1))    {
                   imageRgb = bigImage->pixel(x*3+xi,y*3+yi);
-                  imageRed +=  qRed ( imageRgb )*2;
-                  imageGreen += qGreen ( imageRgb )*2;
-                  imageBlue += qBlue ( imageRgb )*2;
+                  imageRed +=  tqRed ( imageRgb )*2;
+                  imageGreen += tqGreen ( imageRgb )*2;
+                  imageBlue += tqBlue ( imageRgb )*2;
                   }
                 else {
                   imageRgb = bigImage->pixel(x*3+xi,y*3+yi);
-                  imageRed +=  qRed ( imageRgb );
-                  imageGreen += qGreen ( imageRgb );
-                  imageBlue += qBlue ( imageRgb );
+                  imageRed +=  tqRed ( imageRgb );
+                  imageGreen += tqGreen ( imageRgb );
+                  imageBlue += tqBlue ( imageRgb );
                   }
                 }
               }
@@ -683,7 +683,7 @@ void KNutAnalog::makeAntialiasing (QImage* bigImage, QPixmap* smallPixmap, const
             imageRed = imageRed >> 4;
             imageGreen = imageGreen >> 4;
             imageBlue = imageBlue >> 4;
-            smallImage->setPixel (x,y,qRgb(imageRed,imageGreen,imageBlue));
+            smallImage->setPixel (x,y,tqRgb(imageRed,imageGreen,imageBlue));
             }
           }
         else {
@@ -697,23 +697,23 @@ void KNutAnalog::makeAntialiasing (QImage* bigImage, QPixmap* smallPixmap, const
 }
 
 
-void KNutAnalog::makeMotionBlur (QImage* image, const QRgb colorOfBG, int typeOfView) {
+void KNutAnalog::makeMotionBlur (TQImage* image, const TQRgb colorOfBG, int typeOfView) {
 
   ulong imageRed, imageGreen, imageBlue;
-  QRgb imageRgb;
-  QImage *layerImageBlur;
+  TQRgb imageRgb;
+  TQImage *layerImageBlur;
   bool computeAverage;
   int startHeight, stopHeight;
   ulong sumOfRed, sumOfGreen, sumOfBlue;
 
-  sumOfRed =  (qRed ( colorOfBG ))*9;
-  sumOfGreen = (qGreen ( colorOfBG ))*9;
-  sumOfBlue = (qBlue ( colorOfBG ))*9;
+  sumOfRed =  (tqRed ( colorOfBG ))*9;
+  sumOfGreen = (tqGreen ( colorOfBG ))*9;
+  sumOfBlue = (tqBlue ( colorOfBG ))*9;
 
   int imageWidth=image->width();
   int imageHeight=image->height();
 
-  layerImageBlur = new QImage(*image);
+  layerImageBlur = new TQImage(*image);
   layerImageBlur->detach(); //costructor makes swallow copy, have to use detach
 
 
@@ -770,9 +770,9 @@ void KNutAnalog::makeMotionBlur (QImage* image, const QRgb colorOfBG, int typeOf
         for (int xi = -1 ; xi < 2; xi ++) {
           for (int yi = -1 ; yi < 2; yi ++) {
             imageRgb = layerImageBlur->pixel(x+xi,y+yi);
-            imageRed +=  qRed ( imageRgb );
-            imageGreen += qGreen ( imageRgb );
-            imageBlue += qBlue ( imageRgb );
+            imageRed +=  tqRed ( imageRgb );
+            imageGreen += tqGreen ( imageRgb );
+            imageBlue += tqBlue ( imageRgb );
             }
           }
 
@@ -780,7 +780,7 @@ void KNutAnalog::makeMotionBlur (QImage* image, const QRgb colorOfBG, int typeOf
           imageRed = (int)(imageRed / 9);
           imageGreen = (int)(imageGreen/9);
           imageBlue = (int)(imageBlue/9);
-          image->setPixel (x,y,qRgb(imageRed,imageGreen,imageBlue));
+          image->setPixel (x,y,tqRgb(imageRed,imageGreen,imageBlue));
           }
         }
       }
@@ -793,7 +793,7 @@ void KNutAnalog::makeMotionBlur (QImage* image, const QRgb colorOfBG, int typeOf
 
 
 
-void KNutAnalog::paintScaleNumbers ( QPainter *paint ) {
+void KNutAnalog::paintScaleNumbers ( TQPainter *paint ) {
   //paintig of scaleNumbers
 
   int poz_x, poz_y, r_vyska, r_sirka;
@@ -803,11 +803,11 @@ void KNutAnalog::paintScaleNumbers ( QPainter *paint ) {
   int smer_st = -m_direction;
 
   paint->save();  // ulozime
-  QString cislo;
+  TQString cislo;
   paint->setPen(m_textColor);
   paint->setFont(m_scaleFont);
 
-  QFontMetrics fm = paint->fontMetrics();
+  TQFontMetrics fm = paint->fontMetrics();
   r_vyska = ((fm.ascent()) / 2);
   posun = ((double)(m_topLimit-m_bottomLimit))/m_countOfParts;
   for (int i=0; i<=(m_countOfParts);i++) {
@@ -823,13 +823,13 @@ void KNutAnalog::paintScaleNumbers ( QPainter *paint ) {
   }
 
 
-void KNutAnalog::paintText ( QPainter *paint ) {
-  QString nadpis1;
-  QString nadpis2;
+void KNutAnalog::paintText ( TQPainter *paint ) {
+  TQString nadpis1;
+  TQString nadpis2;
   int index;
 
   if (m_inscription.length() >1) {
-    if ((index = m_inscription.find(" ")) != -1) {
+    if ((index = m_inscription.tqfind(" ")) != -1) {
     // mezera nalezena space found
       nadpis1 = m_inscription.left(index);
       nadpis2 = m_inscription.mid(index+1,(uint)(m_inscription.length() - index - 1));
@@ -838,7 +838,7 @@ void KNutAnalog::paintText ( QPainter *paint ) {
 
   paint->setPen(m_textColor);
   paint->setFont(m_textFont);
-  QFontMetrics fm = paint->fontMetrics();
+  TQFontMetrics fm = paint->fontMetrics();
   int r_vyska = fm.height()/ 2;
   switch (m_typeOfView)	{
     // kruznice - kreslime dve radky nad sebou cemtrovane
@@ -871,9 +871,9 @@ void KNutAnalog::paintText ( QPainter *paint ) {
 
 
 
-void KNutAnalog::paintValueOfPointer ( QPainter *p, double value) {
+void KNutAnalog::paintValueOfPointer ( TQPainter *p, double value) {
 
-  QString cislo;
+  TQString cislo;
   cislo.sprintf( "%5.1f",value);
   cislo=cislo.stripWhiteSpace();
 
@@ -886,7 +886,7 @@ void KNutAnalog::paintValueOfPointer ( QPainter *p, double value) {
 
   p->setPen(m_textColor);
   p->setFont(m_textFont);
-  QFontMetrics fm = p->fontMetrics();
+  TQFontMetrics fm = p->fontMetrics();
   int r_vyska = fm.height()/ 2;