Replace TRUE/FALSE with boolean values true/falser14.1.4

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit cf85b9c285a2b9baa87c9d0cb9d683b48e82a475)

1 files changed, 329 insertions, 329 deletions

diff --git a/kspread/plugins/calculator/kcalc.cpp b/kspread/plugins/calculator/kcalc.cpp
index 92f665e71..a41418cdb 100644
--- a/kspread/plugins/calculator/kcalc.cpp
+++ b/kspread/plugins/calculator/kcalc.cpp
@@ -72,7 +72,7 @@ TQtCalculator :: TQtCalculator( Calculator *_corba, TQWidget *parent, const char
 
     pb = new TQPushButton( this, "helpbutton" );
     pb->setText( "kCalc" );
-    pb->setFont( TQFont("times",12,TQFont::Bold,FALSE) );
+    pb->setFont( TQFont("times",12,TQFont::Bold,false) );
     TQToolTip::add( pb, i18n("KCalc Setup/Help") );
 
     connect( pb, TQ_SIGNAL(clicked()), TQ_SLOT(configclicked()) );
@@ -111,7 +111,7 @@ TQtCalculator :: TQtCalculator( Calculator *_corba, TQWidget *parent, const char
 
     anglebutton[0] = new TQRadioButton( angle_group );
     anglebutton[0]->setText( "&Deg" )   ;
-    anglebutton[0]->setChecked(   TRUE);
+    anglebutton[0]->setChecked(   true);
     accel->connectItem( accel->insertItem(Key_D + ALT), this ,
                         TQ_SLOT(Deg_Selected()) );
 
@@ -145,7 +145,7 @@ TQtCalculator :: TQtCalculator( Calculator *_corba, TQWidget *parent, const char
 
     basebutton[1] = new TQRadioButton( base_group );
     basebutton[1]->setText( "D&ec" );
-    basebutton[1]->setChecked(TRUE);
+    basebutton[1]->setChecked(true);
     accel->connectItem( accel->insertItem(Key_E + ALT), this ,
                         TQ_SLOT(Dec_Selected()) );
 
@@ -173,203 +173,203 @@ TQtCalculator :: TQtCalculator( Calculator *_corba, TQWidget *parent, const char
 
     pbhyp = new TQPushButton("Hyp", mSmallPage, "hypbutton" );
     connect( pbhyp, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbhyptoggled(bool)));
-    pbhyp->setToggleButton(TRUE);
+    pbhyp->setToggleButton(true);
 
     pbinv = new TQPushButton( "Inv", mSmallPage, "InverseButton" );
     connect( pbinv, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbinvtoggled(bool)));
-    pbinv->setToggleButton(TRUE);
+    pbinv->setToggleButton(true);
 
     pbA = new TQPushButton("A",mSmallPage, "Abutton" );
     connect( pbA, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbAtoggled(bool)));
-    pbA->setToggleButton(TRUE);
+    pbA->setToggleButton(true);
 
     pbSin = new TQPushButton("Sin",mSmallPage, "Sinbutton" );
     connect( pbSin, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbSintoggled(bool)));
-    pbSin->setToggleButton(TRUE);
+    pbSin->setToggleButton(true);
 
     pbplusminus = new TQPushButton( "+/-", mSmallPage, "plusminusbutton" );
     connect( pbplusminus, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbplusminustoggled(bool)));
-    pbplusminus->setToggleButton(TRUE);
+    pbplusminus->setToggleButton(true);
     pbplusminus->setFont(buttonfont);
 
     pbB = new TQPushButton("B", mSmallPage, "Bbutton" );
     connect( pbB, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbBtoggled(bool)));
-    pbB->setToggleButton(TRUE);
+    pbB->setToggleButton(true);
 
     pbCos = new TQPushButton("Cos",mSmallPage, "Cosbutton" );
     pbCos->setText( "Cos" );
     connect( pbCos, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbCostoggled(bool)));
-    pbCos->setToggleButton(TRUE);
+    pbCos->setToggleButton(true);
 
 
     pbreci = new TQPushButton("1/x",mSmallPage, "recibutton" );
     connect( pbreci, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbrecitoggled(bool)));
-    pbreci->setToggleButton(TRUE);
+    pbreci->setToggleButton(true);
 
     pbC = new TQPushButton( "C", mSmallPage, "Cbutton" );
     connect( pbC, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbCtoggled(bool)));
-    pbC->setToggleButton(TRUE);
+    pbC->setToggleButton(true);
 
     pbTan = new TQPushButton("Tan" ,mSmallPage,  "Tanbutton" );
     connect( pbTan, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbTantoggled(bool)));
-    pbTan->setToggleButton(TRUE);
+    pbTan->setToggleButton(true);
 
     pbfactorial = new TQPushButton("x!",mSmallPage, "factorialbutton" );
     connect( pbfactorial, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbfactorialtoggled(bool)));
-    pbfactorial->setToggleButton(TRUE);
+    pbfactorial->setToggleButton(true);
 
     pbD = new TQPushButton("D",mSmallPage,  "Dbutton" );
     connect( pbD, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbDtoggled(bool)));
-    pbD->setToggleButton(TRUE);
+    pbD->setToggleButton(true);
 
     pblog = new TQPushButton("Log",mSmallPage, "logbutton" );
     connect( pblog, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pblogtoggled(bool)));
-    pblog->setToggleButton(TRUE);
+    pblog->setToggleButton(true);
 
     pbsquare = new TQPushButton( "x^2", mSmallPage,  "squarebutton" );
     connect( pbsquare, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbsquaretoggled(bool)));
-    pbsquare->setToggleButton(TRUE);
+    pbsquare->setToggleButton(true);
 
     pbE = new TQPushButton("E",mSmallPage, "Ebutton" );
     connect( pbE, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbEtoggled(bool)));
-    pbE->setToggleButton(TRUE);
+    pbE->setToggleButton(true);
 
 
     pbln = new TQPushButton( "Ln", mSmallPage, "lnbutton" );
     connect( pbln, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pblntoggled(bool)));
-    pbln->setToggleButton(TRUE);
+    pbln->setToggleButton(true);
 
     pbpower = new TQPushButton("x^y",mSmallPage,  "powerbutton" );
     connect( pbpower, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbpowertoggled(bool)));
-    pbpower->setToggleButton(TRUE);
+    pbpower->setToggleButton(true);
 
     pbF = new TQPushButton("F",mSmallPage, "Fbutton" );
     connect( pbF, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbFtoggled(bool)));
-    pbF->setToggleButton(TRUE);
+    pbF->setToggleButton(true);
 
     pbEE = new TQPushButton("EE",mLargePage,  "EEbutton" );
-    pbEE->setToggleButton(TRUE);
+    pbEE->setToggleButton(true);
     connect( pbEE, TQ_SIGNAL(toggled(bool)), TQ_SLOT(EEtoggled(bool)));
 
     pbMR = new TQPushButton("MR",mLargePage,  "MRbutton" );
     connect( pbMR, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbMRtoggled(bool)));
-    pbMR->setToggleButton(TRUE);
+    pbMR->setToggleButton(true);
     pbMR->setFont(buttonfont);
 
     pbMplusminus = new TQPushButton("M+-",mLargePage,  "Mplusminusbutton" );
     connect( pbMplusminus, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbMplusminustoggled(bool)));
-    pbMplusminus->setToggleButton(TRUE);
+    pbMplusminus->setToggleButton(true);
 
     pbMC = new TQPushButton("MC",mLargePage,  "MCbutton" );
     connect( pbMC, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbMCtoggled(bool)));
-    pbMC->setToggleButton(TRUE);
+    pbMC->setToggleButton(true);
 
     pbClear = new TQPushButton("C",mLargePage,  "Clearbutton" );
     connect( pbClear, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbCleartoggled(bool)));
-    pbClear->setToggleButton(TRUE);
+    pbClear->setToggleButton(true);
 
     pbAC = new TQPushButton("AC", mLargePage,  "ACbutton" );
     connect( pbAC, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbACtoggled(bool)));
-    pbAC->setToggleButton(TRUE);
+    pbAC->setToggleButton(true);
 
     pb7 = new TQPushButton("7",mLargePage, "7button" );
     connect( pb7, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb7toggled(bool)));
-    pb7->setToggleButton(TRUE);
+    pb7->setToggleButton(true);
 
     pb8 = new TQPushButton("8",mLargePage, "8button" );
     connect( pb8, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb8toggled(bool)));
-    pb8->setToggleButton(TRUE);
+    pb8->setToggleButton(true);
 
     pb9 = new TQPushButton("9",mLargePage,"9button" );
     connect( pb9, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb9toggled(bool)));
-    pb9->setToggleButton(TRUE);
+    pb9->setToggleButton(true);
 
     pbparenopen = new TQPushButton("(",mLargePage,  "parenopenbutton" );
     connect( pbparenopen, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbparenopentoggled(bool)));
-    pbparenopen->setToggleButton(TRUE);
+    pbparenopen->setToggleButton(true);
 
     pbparenclose = new TQPushButton(")",mLargePage, "parenclosebutton" );
     connect( pbparenclose, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbparenclosetoggled(bool)));
-    pbparenclose->setToggleButton(TRUE);
+    pbparenclose->setToggleButton(true);
 
     pband = new TQPushButton("And",mLargePage, "andbutton" );
     connect( pband, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbandtoggled(bool)));
-    pband->setToggleButton(TRUE);
+    pband->setToggleButton(true);
     pband->setFont(buttonfont);
 
     pb4 = new TQPushButton("4",mLargePage,  "4button" );
     connect( pb4, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb4toggled(bool)));
-    pb4->setToggleButton(TRUE);
+    pb4->setToggleButton(true);
 
     pb5 = new TQPushButton("5",mLargePage,  "5button" );
     connect( pb5, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb5toggled(bool)));
-    pb5->setToggleButton(TRUE);
+    pb5->setToggleButton(true);
 
     pb6 = new TQPushButton("6",mLargePage,  "6button" );
     connect( pb6, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb6toggled(bool)));
-    pb6->setToggleButton(TRUE);
+    pb6->setToggleButton(true);
 
     pbX = new TQPushButton("X",mLargePage, "Multiplybutton" );
     connect( pbX, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbXtoggled(bool)));
-    pbX->setToggleButton(TRUE);
+    pbX->setToggleButton(true);
 
     pbdivision = new TQPushButton("/",mLargePage,  "divisionbutton" );
     connect( pbdivision, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbdivisiontoggled(bool)));
-    pbdivision->setToggleButton(TRUE);
+    pbdivision->setToggleButton(true);
 
     pbor = new TQPushButton("Or",mLargePage,  "orbutton" );
     connect( pbor, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbortoggled(bool)));
-    pbor->setToggleButton(TRUE);
+    pbor->setToggleButton(true);
 
     pb1 = new TQPushButton("1",mLargePage,  "1button" );
     connect( pb1, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb1toggled(bool)));
-    pb1->setToggleButton(TRUE);
+    pb1->setToggleButton(true);
 
     pb2 = new TQPushButton("2",mLargePage,  "2button" );
 
     connect( pb2, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb2toggled(bool)));
-    pb2->setToggleButton(TRUE);
+    pb2->setToggleButton(true);
 
     pb3 = new TQPushButton("3",mLargePage,  "3button" );
     connect( pb3, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb3toggled(bool)));
-    pb3->setToggleButton(TRUE);
+    pb3->setToggleButton(true);
 
     pbplus = new TQPushButton("+",mLargePage, "plusbutton" );
     connect( pbplus, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbplustoggled(bool)));
-    pbplus->setToggleButton(TRUE);
+    pbplus->setToggleButton(true);
 
 
     pbminus = new TQPushButton("-",mLargePage,  "minusbutton" );
     connect( pbminus, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbminustoggled(bool)));
-    pbminus->setToggleButton(TRUE);
+    pbminus->setToggleButton(true);
 
     pbshift = new TQPushButton("Lsh",mLargePage, "shiftbutton" );
     connect( pbshift, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbshifttoggled(bool)));
-    pbshift->setToggleButton(TRUE);
+    pbshift->setToggleButton(true);
 
     pbperiod = new TQPushButton(".",mLargePage,  "periodbutton" );
     connect( pbperiod, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbperiodtoggled(bool)));
-    pbperiod->setToggleButton(TRUE);
+    pbperiod->setToggleButton(true);
 
     pb0 = new TQPushButton("0",mLargePage,  "0button" );
     connect( pb0, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pb0toggled(bool)));
-    pb0->setToggleButton(TRUE);
+    pb0->setToggleButton(true);
 
     pbequal = new TQPushButton("=",mLargePage,  "equalbutton" );
     connect( pbequal, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbequaltoggled(bool)));
-    pbequal->setToggleButton(TRUE);
+    pbequal->setToggleButton(true);
 
     pbpercent = new TQPushButton("%",mLargePage, "percentbutton" );
     connect( pbpercent, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbpercenttoggled(bool)));
-    pbpercent->setToggleButton(TRUE);
+    pbpercent->setToggleButton(true);
 
     pbnegate = new TQPushButton("Cmp",mLargePage,  "OneComplementbutton" );
     connect( pbnegate, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbnegatetoggled(bool)));
-    pbnegate->setToggleButton(TRUE);
+    pbnegate->setToggleButton(true);
 
     pbmod = new TQPushButton("Mod",mLargePage,  "modbutton" );
     connect( pbmod, TQ_SIGNAL(toggled(bool)), TQ_SLOT(pbmodtoggled(bool)));
-    pbmod->setToggleButton(TRUE);
+    pbmod->setToggleButton(true);
 
     TQGridLayout *smallBtnLayout = new TQGridLayout(mSmallPage, 6, 3, 0,
                                                   mInternalSpacing);
@@ -631,30 +631,30 @@ void TQtCalculator::exit()
 
 void TQtCalculator::Hex_Selected()
 {
-  basebutton[0]->setChecked(TRUE);
-  basebutton[1]->setChecked(FALSE);
-  basebutton[2]->setChecked(FALSE);
-  basebutton[3]->setChecked(FALSE);
+  basebutton[0]->setChecked(true);
+  basebutton[1]->setChecked(false);
+  basebutton[2]->setChecked(false);
+  basebutton[3]->setChecked(false);
   SetHex();
 }
 
 
 void TQtCalculator::Dec_Selected()
 {
-  basebutton[0]->setChecked(FALSE);
-  basebutton[1]->setChecked(TRUE);
-  basebutton[2]->setChecked(FALSE);
-  basebutton[3]->setChecked(FALSE);
+  basebutton[0]->setChecked(false);
+  basebutton[1]->setChecked(true);
+  basebutton[2]->setChecked(false);
+  basebutton[3]->setChecked(false);
   SetDec();
 }
 
 
 void TQtCalculator::Oct_Selected()
 {
-  basebutton[0]->setChecked(FALSE);
-  basebutton[1]->setChecked(FALSE);
-  basebutton[2]->setChecked(TRUE);
-  basebutton[3]->setChecked(FALSE);
+  basebutton[0]->setChecked(false);
+  basebutton[1]->setChecked(false);
+  basebutton[2]->setChecked(true);
+  basebutton[3]->setChecked(false);
   SetOct();
 }
 
@@ -662,27 +662,27 @@ void TQtCalculator::Oct_Selected()
 
 void TQtCalculator::Bin_Selected()
 {
-  basebutton[0]->setChecked(FALSE);
-  basebutton[1]->setChecked(FALSE);
-  basebutton[2]->setChecked(FALSE);
-  basebutton[3]->setChecked(TRUE);
+  basebutton[0]->setChecked(false);
+  basebutton[1]->setChecked(false);
+  basebutton[2]->setChecked(false);
+  basebutton[3]->setChecked(true);
   SetBin();
 }
 
 void TQtCalculator::Deg_Selected()
 {
-  anglebutton[0]->setChecked(TRUE);
-  anglebutton[1]->setChecked(FALSE);
-  anglebutton[2]->setChecked(FALSE);
+  anglebutton[0]->setChecked(true);
+  anglebutton[1]->setChecked(false);
+  anglebutton[2]->setChecked(false);
   SetDeg();
 }
 
 
 void TQtCalculator::Rad_Selected()
 {
-  anglebutton[0]->setChecked(FALSE);
-  anglebutton[1]->setChecked(TRUE);
-  anglebutton[2]->setChecked(FALSE);
+  anglebutton[0]->setChecked(false);
+  anglebutton[1]->setChecked(true);
+  anglebutton[2]->setChecked(false);
   SetRad();
 
 }
@@ -690,9 +690,9 @@ void TQtCalculator::Rad_Selected()
 
 void TQtCalculator::Gra_Selected()
 {
-  anglebutton[0]->setChecked(FALSE);
-  anglebutton[1]->setChecked(FALSE);
-  anglebutton[2]->setChecked(TRUE);
+  anglebutton[0]->setChecked(false);
+  anglebutton[1]->setChecked(false);
+  anglebutton[2]->setChecked(true);
   SetGra();
 }
 
@@ -727,211 +727,211 @@ void TQtCalculator::keyPressEvent( TQKeyEvent *e ){
      break;
 
   case Key_Next:
-     key_pressed = TRUE;
-     pbAC->setOn(TRUE);
+     key_pressed = true;
+     pbAC->setOn(true);
      break;
   case Key_Prior:
-     key_pressed = TRUE;
-     pbClear->setOn(TRUE);
+     key_pressed = true;
+     pbClear->setOn(true);
      break;
 
   case Key_H:
-     key_pressed = TRUE;
-     pbhyp->setOn(TRUE);
+     key_pressed = true;
+     pbhyp->setOn(true);
      break;
   case Key_I:
-     key_pressed = TRUE;
-     pbinv->setOn(TRUE);
+     key_pressed = true;
+     pbinv->setOn(true);
      break;
   case Key_A:
-     key_pressed = TRUE;
-     pbA->setOn(TRUE);
+     key_pressed = true;
+     pbA->setOn(true);
 
      break;
   case Key_E:
-     key_pressed = TRUE;
+     key_pressed = true;
     if (current_base == NB_HEX)
-     pbE->setOn(TRUE);
+     pbE->setOn(true);
     else
-     pbEE->setOn(TRUE);
+     pbEE->setOn(true);
      break;
   case Key_Escape:
-     key_pressed = TRUE;
-     pbClear->setOn(TRUE);
+     key_pressed = true;
+     pbClear->setOn(true);
      break;
   case Key_Delete:
-     key_pressed = TRUE;
-     pbAC->setOn(TRUE);
+     key_pressed = true;
+     pbAC->setOn(true);
      break;
   case Key_S:
-     key_pressed = TRUE;
-     pbSin->setOn(TRUE);
+     key_pressed = true;
+     pbSin->setOn(true);
      break;
   case Key_Backslash:
-     key_pressed = TRUE;
-     pbplusminus->setOn(TRUE);
+     key_pressed = true;
+     pbplusminus->setOn(true);
      break;
   case Key_B:
-     key_pressed = TRUE;
-     pbB->setOn(TRUE);
+     key_pressed = true;
+     pbB->setOn(true);
      break;
   case Key_7:
-     key_pressed = TRUE;
-     pb7->setOn(TRUE);
+     key_pressed = true;
+     pb7->setOn(true);
      break;
   case Key_8:
-     key_pressed = TRUE;
-     pb8->setOn(TRUE);
+     key_pressed = true;
+     pb8->setOn(true);
      break;
   case Key_9:
-     key_pressed = TRUE;
-     pb9->setOn(TRUE);
+     key_pressed = true;
+     pb9->setOn(true);
      break;
   case Key_ParenLeft:
-     key_pressed = TRUE;
-     pbparenopen->setOn(TRUE);
+     key_pressed = true;
+     pbparenopen->setOn(true);
      break;
   case Key_ParenRight:
-     key_pressed = TRUE;
-     pbparenclose->setOn(TRUE);
+     key_pressed = true;
+     pbparenclose->setOn(true);
      break;
   case Key_Ampersand:
-     key_pressed = TRUE;
-     pband->setOn(TRUE);
+     key_pressed = true;
+     pband->setOn(true);
      break;
   case Key_C:
-     key_pressed = TRUE;
+     key_pressed = true;
     if (current_base == NB_HEX)
-     pbC->setOn(TRUE);
+     pbC->setOn(true);
     else
-     pbCos->setOn(TRUE);
+     pbCos->setOn(true);
      break;
   case Key_4:
-     key_pressed = TRUE;
-     pb4->setOn(TRUE);
+     key_pressed = true;
+     pb4->setOn(true);
      break;
   case Key_5:
-     key_pressed = TRUE;
-     pb5->setOn(TRUE);
+     key_pressed = true;
+     pb5->setOn(true);
      break;
   case Key_6:
-     key_pressed = TRUE;
-     pb6->setOn(TRUE);
+     key_pressed = true;
+     pb6->setOn(true);
      break;
   case Key_Asterisk:
-     key_pressed = TRUE;
-     pbX->setOn(TRUE);
+     key_pressed = true;
+     pbX->setOn(true);
      break;
   case Key_Slash:
-     key_pressed = TRUE;
-     pbdivision->setOn(TRUE);
+     key_pressed = true;
+     pbdivision->setOn(true);
      break;
   case Key_O:
-     key_pressed = TRUE;
-     pbor->setOn(TRUE);
+     key_pressed = true;
+     pbor->setOn(true);
      break;
   case Key_T:
-     key_pressed = TRUE;
-     pbTan->setOn(TRUE);
+     key_pressed = true;
+     pbTan->setOn(true);
      break;
   case Key_Exclam:
-     key_pressed = TRUE;
-     pbfactorial->setOn(TRUE);
+     key_pressed = true;
+     pbfactorial->setOn(true);
      break;
   case Key_D:
-     key_pressed = TRUE;
+     key_pressed = true;
      if(kcalcdefaults.style == 0)
-       pbD->setOn(TRUE); // trig mode
+       pbD->setOn(true); // trig mode
      else
-       pblog->setOn(TRUE); // stat mode
+       pblog->setOn(true); // stat mode
     break;
   case Key_1:
-     key_pressed = TRUE;
-     pb1->setOn(TRUE);
+     key_pressed = true;
+     pb1->setOn(true);
      break;
   case Key_2:
-     key_pressed = TRUE;
-     pb2->setOn(TRUE);
+     key_pressed = true;
+     pb2->setOn(true);
      break;
   case Key_3:
-     key_pressed = TRUE;
-     pb3->setOn(TRUE);
+     key_pressed = true;
+     pb3->setOn(true);
      break;
   case Key_Plus:
-     key_pressed = TRUE;
-     pbplus->setOn(TRUE);
+     key_pressed = true;
+     pbplus->setOn(true);
      break;
   case Key_Minus:
-     key_pressed = TRUE;
-     pbminus->setOn(TRUE);
+     key_pressed = true;
+     pbminus->setOn(true);
      break;
   case Key_Less:
-     key_pressed = TRUE;
-     pbshift->setOn(TRUE);
+     key_pressed = true;
+     pbshift->setOn(true);
      break;
   case Key_N:
-     key_pressed = TRUE;
-     pbln->setOn(TRUE);
+     key_pressed = true;
+     pbln->setOn(true);
      break;
   case Key_L:
-     key_pressed = TRUE;
-     pblog->setOn(TRUE);
+     key_pressed = true;
+     pblog->setOn(true);
      break;
   case Key_AsciiCircum:
-     key_pressed = TRUE;
-     pbpower->setOn(TRUE);
+     key_pressed = true;
+     pbpower->setOn(true);
      break;
   case Key_F:
-     key_pressed = TRUE;
-     pbF->setOn(TRUE);
+     key_pressed = true;
+     pbF->setOn(true);
      break;
   case Key_Period:
-     key_pressed = TRUE;
-     pbperiod->setOn(TRUE);
+     key_pressed = true;
+     pbperiod->setOn(true);
      break;
   case Key_Comma:
-     key_pressed = TRUE;
-     pbperiod->setOn(TRUE);
+     key_pressed = true;
+     pbperiod->setOn(true);
      break;
   case Key_0:
-     key_pressed = TRUE;
-     pb0->setOn(TRUE);
+     key_pressed = true;
+     pb0->setOn(true);
      break;
      case Key_Equal:
-     key_pressed = TRUE;
-     pbequal->setOn(TRUE);
+     key_pressed = true;
+     pbequal->setOn(true);
      break;
   case Key_Return:
-     key_pressed = TRUE;
-     pbequal->setOn(TRUE);
+     key_pressed = true;
+     pbequal->setOn(true);
      break;
   case Key_Enter:
-     key_pressed = TRUE;
-     pbequal->setOn(TRUE);
+     key_pressed = true;
+     pbequal->setOn(true);
      break;
   case Key_Percent:
-     key_pressed = TRUE;
-     pbpercent->setOn(TRUE);
+     key_pressed = true;
+     pbpercent->setOn(true);
      break;
   case Key_AsciiTilde:
-     key_pressed = TRUE;
-     pbnegate->setOn(TRUE);
+     key_pressed = true;
+     pbnegate->setOn(true);
      break;
   case Key_Colon:
-     key_pressed = TRUE;
-     pbmod->setOn(TRUE);
+     key_pressed = true;
+     pbmod->setOn(true);
      break;
   case Key_BracketLeft:
-     key_pressed = TRUE;
-     pbsquare->setOn(TRUE);
+     key_pressed = true;
+     pbsquare->setOn(true);
      break;
  case Key_Backspace:
-     key_pressed = TRUE;
-     pbAC->setOn(TRUE);
+     key_pressed = true;
+     pbAC->setOn(true);
      break;
   case Key_R:
-     key_pressed = TRUE;
-     pbreci->setOn(TRUE);
+     key_pressed = true;
+     pbreci->setOn(true);
      break;
   }
 }
@@ -940,210 +940,210 @@ void TQtCalculator::keyReleaseEvent( TQKeyEvent *e ){
   switch (e->key() ){
 
   case Key_Next:
-     key_pressed = FALSE;
-     pbAC->setOn(FALSE);
+     key_pressed = false;
+     pbAC->setOn(false);
      break;
   case Key_Prior:
-     key_pressed = FALSE;
-     pbClear->setOn(FALSE);
+     key_pressed = false;
+     pbClear->setOn(false);
      break;
 
   case Key_H:
-    key_pressed = FALSE;
-     pbhyp->setOn(FALSE);
+    key_pressed = false;
+     pbhyp->setOn(false);
      break;
   case Key_I:
-    key_pressed = FALSE;
-     pbinv->setOn(FALSE);
+    key_pressed = false;
+     pbinv->setOn(false);
      break;
   case Key_A:
-    key_pressed = FALSE;
-     pbA->setOn(FALSE);
+    key_pressed = false;
+     pbA->setOn(false);
      break;
   case Key_E:
-    key_pressed = FALSE;
+    key_pressed = false;
     if (current_base == NB_HEX)
-     pbE->setOn(FALSE);
+     pbE->setOn(false);
     else
-     pbEE->setOn(FALSE);
+     pbEE->setOn(false);
      break;
   case Key_Escape:
-    key_pressed = FALSE;
-     pbClear->setOn(FALSE);
+    key_pressed = false;
+     pbClear->setOn(false);
      break;
   case Key_Delete:
-    key_pressed = FALSE;
-     pbAC->setOn(FALSE);
+    key_pressed = false;
+     pbAC->setOn(false);
      break;
   case Key_S:
-    key_pressed = FALSE;
-     pbSin->setOn(FALSE);
+    key_pressed = false;
+     pbSin->setOn(false);
      break;
   case Key_Backslash:
-    key_pressed = FALSE;
-     pbplusminus->setOn(FALSE);
+    key_pressed = false;
+     pbplusminus->setOn(false);
      break;
   case Key_B:
-    key_pressed = FALSE;
-     pbB->setOn(FALSE);
+    key_pressed = false;
+     pbB->setOn(false);
      break;
   case Key_7:
-    key_pressed = FALSE;
-     pb7->setOn(FALSE);
+    key_pressed = false;
+     pb7->setOn(false);
      break;
   case Key_8:
-    key_pressed = FALSE;
-     pb8->setOn(FALSE);
+    key_pressed = false;
+     pb8->setOn(false);
      break;
   case Key_9:
-    key_pressed = FALSE;
-     pb9->setOn(FALSE);
+    key_pressed = false;
+     pb9->setOn(false);
      break;
   case Key_ParenLeft:
-    key_pressed = FALSE;
-     pbparenopen->setOn(FALSE);
+    key_pressed = false;
+     pbparenopen->setOn(false);
      break;
   case Key_ParenRight:
-    key_pressed = FALSE;
-     pbparenclose->setOn(FALSE);
+    key_pressed = false;
+     pbparenclose->setOn(false);
      break;
   case Key_Ampersand:
-    key_pressed = FALSE;
-     pband->setOn(FALSE);
+    key_pressed = false;
+     pband->setOn(false);
      break;
   case Key_C:
-    key_pressed = FALSE;
+    key_pressed = false;
     if (current_base == NB_HEX)
-     pbC->setOn(FALSE);
+     pbC->setOn(false);
     else
-     pbCos->setOn(FALSE);
+     pbCos->setOn(false);
      break;
   case Key_4:
-    key_pressed = FALSE;
-     pb4->setOn(FALSE);
+    key_pressed = false;
+     pb4->setOn(false);
      break;
   case Key_5:
-    key_pressed = FALSE;
-     pb5->setOn(FALSE);
+    key_pressed = false;
+     pb5->setOn(false);
      break;
   case Key_6:
-    key_pressed = FALSE;
-     pb6->setOn(FALSE);
+    key_pressed = false;
+     pb6->setOn(false);
      break;
   case Key_Asterisk:
-    key_pressed = FALSE;
-     pbX->setOn(FALSE);
+    key_pressed = false;
+     pbX->setOn(false);
      break;
   case Key_Slash:
-    key_pressed = FALSE;
-     pbdivision->setOn(FALSE);
+    key_pressed = false;
+     pbdivision->setOn(false);
      break;
   case Key_O:
-    key_pressed = FALSE;
-     pbor->setOn(FALSE);
+    key_pressed = false;
+     pbor->setOn(false);
      break;
   case Key_T:
-    key_pressed = FALSE;
-     pbTan->setOn(FALSE);
+    key_pressed = false;
+     pbTan->setOn(false);
      break;
   case Key_Exclam:
-    key_pressed = FALSE;
-     pbfactorial->setOn(FALSE);
+    key_pressed = false;
+     pbfactorial->setOn(false);
      break;
   case Key_D:
-    key_pressed = FALSE;
+    key_pressed = false;
     if(kcalcdefaults.style == 0)
-      pbD->setOn(FALSE); // trig mode
+      pbD->setOn(false); // trig mode
     else
-      pblog->setOn(FALSE);// stat mode
+      pblog->setOn(false);// stat mode
      break;
   case Key_1:
-    key_pressed = FALSE;
-     pb1->setOn(FALSE);
+    key_pressed = false;
+     pb1->setOn(false);
      break;
   case Key_2:
-    key_pressed = FALSE;
-     pb2->setOn(FALSE);
+    key_pressed = false;
+     pb2->setOn(false);
      break;
   case Key_3:
-    key_pressed = FALSE;
-     pb3->setOn(FALSE);
+    key_pressed = false;
+     pb3->setOn(false);
      break;
   case Key_Plus:
-    key_pressed = FALSE;
-     pbplus->setOn(FALSE);
+    key_pressed = false;
+     pbplus->setOn(false);
      break;
   case Key_Minus:
-    key_pressed = FALSE;
-     pbminus->setOn(FALSE);
+    key_pressed = false;
+     pbminus->setOn(false);
      break;
   case Key_Less:
-    key_pressed = FALSE;
-     pbshift->setOn(FALSE);
+    key_pressed = false;
+     pbshift->setOn(false);
      break;
   case Key_N:
-    key_pressed = FALSE;
-     pbln->setOn(FALSE);
+    key_pressed = false;
+     pbln->setOn(false);
      break;
   case Key_L:
-    key_pressed = FALSE;
-     pblog->setOn(FALSE);
+    key_pressed = false;
+     pblog->setOn(false);
      break;
   case Key_AsciiCircum:
-    key_pressed = FALSE;
-     pbpower->setOn(FALSE);
+    key_pressed = false;
+     pbpower->setOn(false);
      break;
   case Key_F:
-    key_pressed = FALSE;
-     pbF->setOn(FALSE);
+    key_pressed = false;
+     pbF->setOn(false);
      break;
   case Key_Period:
-    key_pressed = FALSE;
-     pbperiod->setOn(FALSE);
+    key_pressed = false;
+     pbperiod->setOn(false);
      break;
   case Key_Comma:
-    key_pressed = FALSE;
-     pbperiod->setOn(FALSE);
+    key_pressed = false;
+     pbperiod->setOn(false);
      break;
   case Key_0:
-    key_pressed = FALSE;
-     pb0->setOn(FALSE);
+    key_pressed = false;
+     pb0->setOn(false);
      break;
   case Key_Equal:
-    key_pressed = FALSE;
-     pbequal->setOn(FALSE);
+    key_pressed = false;
+     pbequal->setOn(false);
      break;
   case Key_Return:
-    key_pressed = FALSE;
-     pbequal->setOn(FALSE);
+    key_pressed = false;
+     pbequal->setOn(false);
      break;
   case Key_Enter:
-     key_pressed = FALSE;
-     pbequal->setOn(FALSE);
+     key_pressed = false;
+     pbequal->setOn(false);
      break;
   case Key_Percent:
-    key_pressed = FALSE;
-     pbpercent->setOn(FALSE);
+    key_pressed = false;
+     pbpercent->setOn(false);
      break;
   case Key_AsciiTilde:
-    key_pressed = FALSE;
-     pbnegate->setOn(FALSE);
+    key_pressed = false;
+     pbnegate->setOn(false);
      break;
   case Key_Colon:
-    key_pressed = FALSE;
-     pbmod->setOn(FALSE);
+    key_pressed = false;
+     pbmod->setOn(false);
      break;
   case Key_BracketLeft:
-     key_pressed = FALSE;
-     pbsquare->setOn(FALSE);
+     key_pressed = false;
+     pbsquare->setOn(false);
      break;
   case Key_Backspace:
-     key_pressed = FALSE;
-     pbAC->setOn(FALSE);
+     key_pressed = false;
+     pbAC->setOn(false);
      break;
   case Key_R:
-     key_pressed = FALSE;
-     pbreci->setOn(FALSE);
+     key_pressed = false;
+     pbreci->setOn(false);
      break;
   }
 
@@ -1159,300 +1159,300 @@ void TQtCalculator::EEtoggled(bool myboolean){
   if(myboolean)
     EE();
   if(pbEE->isOn() && (!key_pressed))
-    pbEE->setOn(FALSE);
+    pbEE->setOn(false);
 }
 
 void TQtCalculator::pbinvtoggled(bool myboolean){
   if(myboolean)
     SetInverse();
   if(pbinv->isOn() && (!key_pressed))
-    pbinv->setOn(FALSE);
+    pbinv->setOn(false);
 }
 
 void TQtCalculator::pbhyptoggled(bool myboolean){
   if(myboolean)
     EnterHyp();
   if(pbhyp->isOn() && (!key_pressed))
-    pbhyp->setOn(FALSE);
+    pbhyp->setOn(false);
 }
 void TQtCalculator::pbMRtoggled(bool myboolean){
   if(myboolean)
     MR();
   if(pbMR->isOn() && (!key_pressed))
-    pbMR->setOn(FALSE);
+    pbMR->setOn(false);
 }
 
 void TQtCalculator::pbAtoggled(bool myboolean){
   if(myboolean)
     buttonA();
     if(pbA->isOn() && (!key_pressed))
-   pbA->setOn(FALSE);
+   pbA->setOn(false);
 }
 
 void TQtCalculator::pbSintoggled(bool myboolean){
   if(myboolean)
     ExecSin();
   if(pbSin->isOn() && (!key_pressed))
-    pbSin->setOn(FALSE);
+    pbSin->setOn(false);
 }
 void TQtCalculator::pbplusminustoggled(bool myboolean){
   if(myboolean)
     EnterNegate();
   if(pbplusminus->isOn() && (!key_pressed))
-    pbplusminus->setOn(FALSE);
+    pbplusminus->setOn(false);
 }
 void TQtCalculator::pbMplusminustoggled(bool myboolean){
   if(myboolean)
     Mplusminus();
   if(pbMplusminus->isOn() && (!key_pressed))
-    pbMplusminus->setOn(FALSE);
+    pbMplusminus->setOn(false);
 }
 void TQtCalculator::pbBtoggled(bool myboolean){
   if(myboolean)
     buttonB();
   if(pbB->isOn() && (!key_pressed))
-    pbB->setOn(FALSE);
+    pbB->setOn(false);
 }
 void TQtCalculator::pbCostoggled(bool myboolean){
   if(myboolean)
     ExecCos();
   if(pbCos->isOn() && (!key_pressed))
-    pbCos->setOn(FALSE);
+    pbCos->setOn(false);
 }
 void TQtCalculator::pbrecitoggled(bool myboolean){
   if(myboolean)
     EnterRecip();
   if(pbreci->isOn() && (!key_pressed))
-    pbreci->setOn(FALSE);
+    pbreci->setOn(false);
 }
 void TQtCalculator::pbCtoggled(bool myboolean){
   if(myboolean)
     buttonC();
   if(pbC->isOn() && (!key_pressed))
-    pbC->setOn(FALSE);
+    pbC->setOn(false);
 }
 void TQtCalculator::pbTantoggled(bool myboolean){
   if(myboolean)
     ExecTan();
   if(pbTan->isOn() && (!key_pressed))
-    pbTan->setOn(FALSE);
+    pbTan->setOn(false);
 }
 void TQtCalculator::pbfactorialtoggled(bool myboolean){
   if(myboolean)
     EnterFactorial();
   if(pbfactorial->isOn() && (!key_pressed))
-    pbfactorial->setOn(FALSE);
+    pbfactorial->setOn(false);
 }
 void TQtCalculator::pbDtoggled(bool myboolean){
   if(myboolean)
     buttonD();
   if(pbD->isOn() && (!key_pressed))
-    pbD->setOn(FALSE);
+    pbD->setOn(false);
 }
 void TQtCalculator::pblogtoggled(bool myboolean){
   if(myboolean)
    EnterLogr();
   if(pblog->isOn() && (!key_pressed))
-    pblog->setOn(FALSE);
+    pblog->setOn(false);
 }
 void TQtCalculator::pbsquaretoggled(bool myboolean){
   if(myboolean)
     EnterSquare();
   if(pbsquare->isOn() && (!key_pressed))
-    pbsquare->setOn(FALSE);
+    pbsquare->setOn(false);
 }
 void TQtCalculator::pbEtoggled(bool myboolean){
   if(myboolean)
     buttonE();
   if(pbE->isOn() && (!key_pressed))
-    pbE->setOn(FALSE);
+    pbE->setOn(false);
 }
 void TQtCalculator::pblntoggled(bool myboolean){
   if(myboolean)
     EnterLogn();
   if(pbln->isOn() && (!key_pressed))
-    pbln->setOn(FALSE);
+    pbln->setOn(false);
 }
 void TQtCalculator::pbpowertoggled(bool myboolean){
   if(myboolean)
     Power();
   if(pbpower->isOn() && (!key_pressed))
-    pbpower->setOn(FALSE);
+    pbpower->setOn(false);
 }
 void TQtCalculator::pbFtoggled(bool myboolean){
   if(myboolean)
     buttonF();
   if(pbF->isOn() && (!key_pressed))
-    pbF->setOn(FALSE);
+    pbF->setOn(false);
 }
 void TQtCalculator::pbMCtoggled(bool myboolean){
   if(myboolean)
     MC();
   if(pbMC->isOn() && (!key_pressed))
-    pbMC->setOn(FALSE);
+    pbMC->setOn(false);
 }
 void TQtCalculator::pbCleartoggled(bool myboolean){
   if(myboolean)
     Clear();
   if(pbClear->isOn() && (!key_pressed))
-    pbClear->setOn(FALSE);
+    pbClear->setOn(false);
 }
 void TQtCalculator::pbACtoggled(bool myboolean){
   if(myboolean)
     ClearAll();
   if(pbAC->isOn() && (!key_pressed))
-    pbAC->setOn(FALSE);
+    pbAC->setOn(false);
 }
 void TQtCalculator::pb7toggled(bool myboolean){
   if(myboolean)
     button7();
   if(pb7->isOn() && (!key_pressed))
-    pb7->setOn(FALSE);
+    pb7->setOn(false);
 }
 void TQtCalculator::pb8toggled(bool myboolean){
   if(myboolean)
     button8();
   if(pb8->isOn() && (!key_pressed))
-    pb8->setOn(FALSE);
+    pb8->setOn(false);
 }
 void TQtCalculator::pb9toggled(bool myboolean){
   if(myboolean)
     button9();
   if(pb9->isOn() && (!key_pressed))
-    pb9->setOn(FALSE);
+    pb9->setOn(false);
 }
 void TQtCalculator::pbparenopentoggled(bool myboolean){
   if(myboolean)
     EnterOpenParen();
   if(pbparenopen->isOn() && (!key_pressed))
-    pbparenopen->setOn(FALSE);
+    pbparenopen->setOn(false);
 }
 void TQtCalculator::pbparenclosetoggled(bool myboolean){
   if(myboolean)
     EnterCloseParen();
   if(pbparenclose->isOn() && (!key_pressed))
-    pbparenclose->setOn(FALSE);
+    pbparenclose->setOn(false);
 }
 void TQtCalculator::pbandtoggled(bool myboolean){
   if(myboolean)
     And();
   if(pband->isOn() && (!key_pressed))
-    pband->setOn(FALSE);
+    pband->setOn(false);
 }
 void TQtCalculator::pb4toggled(bool myboolean){
   if(myboolean)
     button4();
   if(pb4->isOn() && (!key_pressed))
-    pb4->setOn(FALSE);
+    pb4->setOn(false);
 }
 void TQtCalculator::pb5toggled(bool myboolean){
   if(myboolean)
     button5();
   if(pb5->isOn() && (!key_pressed))
-    pb5->setOn(FALSE);
+    pb5->setOn(false);
 }
 void TQtCalculator::pb6toggled(bool myboolean){
   if(myboolean)
     button6();
   if(pb6->isOn() && (!key_pressed))
-    pb6->setOn(FALSE);
+    pb6->setOn(false);
 }
 void TQtCalculator::pbXtoggled(bool myboolean){
   if(myboolean)
     Multiply();
   if(pbX->isOn() && (!key_pressed))
-    pbX->setOn(FALSE);
+    pbX->setOn(false);
 }
 void TQtCalculator::pbdivisiontoggled(bool myboolean){
   if(myboolean)
     Divide();
   if(pbdivision->isOn() && (!key_pressed))
-    pbdivision->setOn(FALSE);
+    pbdivision->setOn(false);
 }
 void TQtCalculator::pbortoggled(bool myboolean){
   if(myboolean)
     Or();
   if(pbor->isOn() && (!key_pressed))
-    pbor->setOn(FALSE);
+    pbor->setOn(false);
 }
 void TQtCalculator::pb1toggled(bool myboolean){
   if(myboolean)
     button1();
   if(pb1->isOn() && (!key_pressed))
-    pb1->setOn(FALSE);
+    pb1->setOn(false);
 }
 void TQtCalculator::pb2toggled(bool myboolean){
   if(myboolean)
     button2();
   if(pb2->isOn() && (!key_pressed))
-    pb2->setOn(FALSE);
+    pb2->setOn(false);
 }
 void TQtCalculator::pb3toggled(bool myboolean){
   if(myboolean)
     button3();
   if(pb3->isOn() && (!key_pressed))
-    pb3->setOn(FALSE);
+    pb3->setOn(false);
 }
 void TQtCalculator::pbplustoggled(bool myboolean){
   if(myboolean)
     Plus();
   if(pbplus->isOn() && (!key_pressed))
-    pbplus->setOn(FALSE);
+    pbplus->setOn(false);
 }
 void TQtCalculator::pbminustoggled(bool myboolean){
   if(myboolean)
     Minus();
   if(pbminus->isOn() && (!key_pressed))
-    pbminus->setOn(FALSE);
+    pbminus->setOn(false);
 }
 void TQtCalculator::pbshifttoggled(bool myboolean){
   if(myboolean)
     Shift();
   if(pbshift->isOn() && (!key_pressed))
-    pbshift->setOn(FALSE);
+    pbshift->setOn(false);
 }
 void TQtCalculator::pbperiodtoggled(bool myboolean){
   if(myboolean)
     EnterDecimal();
   if(pbperiod->isOn() && (!key_pressed))
-    pbperiod->setOn(FALSE);
+    pbperiod->setOn(false);
 }
 void TQtCalculator::pb0toggled(bool myboolean){
   if(myboolean)
     button0();
   if(pb0->isOn() && (!key_pressed))
-    pb0->setOn(FALSE);
+    pb0->setOn(false);
 }
 void TQtCalculator::pbequaltoggled(bool myboolean){
   if(myboolean)
     EnterEqual();
   if(pbequal->isOn() && (!key_pressed))
-    pbequal->setOn(FALSE);
+    pbequal->setOn(false);
 }
 void TQtCalculator::pbpercenttoggled(bool myboolean){
   if(myboolean)
     EnterPercent();
   if(pbpercent->isOn() && (!key_pressed))
-    pbpercent->setOn(FALSE);
+    pbpercent->setOn(false);
 }
 void TQtCalculator::pbnegatetoggled(bool myboolean){
   if(myboolean)
     EnterNotCmp();
   if(pbnegate->isOn() && (!key_pressed))
-    pbnegate->setOn(FALSE);
+    pbnegate->setOn(false);
 }
 void TQtCalculator::pbmodtoggled(bool myboolean)  {
   if(myboolean)
     Mod();
   if(pbmod->isOn() && (!key_pressed))
-    pbmod->setOn(FALSE);
+    pbmod->setOn(false);
 }
 
 void TQtCalculator::configclicked(){
 
 
   TQTabDialog * tabdialog;
-  tabdialog = new TQTabDialog(0,"tabdialog",TRUE);
+  tabdialog = new TQTabDialog(0,"tabdialog",true);
 
   tabdialog->setCaption( i18n("KCalc Configuration") );
   tabdialog->resize( 360, 390 );
@@ -1659,7 +1659,7 @@ void TQtCalculator::selection_timed_out(){
 
   //  printf("selection timed out\n");
   selection_timer->stop();
-  calc_display->setLit(FALSE);
+  calc_display->setLit(false);
   invertColors();
 
 
@@ -1675,7 +1675,7 @@ void TQtCalculator::clear_status_label(){
 void TQtCalculator::setStatusLabel(const TQString& string){
 
   statusERRORLabel->setText(string);
-  status_timer->start(3000,TRUE);
+  status_timer->start(3000,true);
 
 }