Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

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

16 files changed, 269 insertions, 269 deletions

diff --git a/kdesktop/bgmanager.cpp b/kdesktop/bgmanager.cpp
index 7f524ae26..a7078f12e 100644
--- a/kdesktop/bgmanager.cpp
+++ b/kdesktop/bgmanager.cpp
@@ -97,40 +97,40 @@ KBackgroundManager::KBackgroundManager(TQWidget *desktop, KWinModule* twinModule
         m_Cache[i]->hash = 0;
         m_Cache[i]->exp_from = -1;
         m_Renderer.insert (i, new KVirtualBGRenderer(i,m_pConfig));
-        connect(m_Renderer[i], TQT_SIGNAL(imageDone(int)), TQT_SLOT(slotImageDone(int)));
+        connect(m_Renderer[i], TQ_SIGNAL(imageDone(int)), TQ_SLOT(slotImageDone(int)));
         m_Renderer[i]->enableTiling( true ); // optimize
     }
 
 #ifdef COMPOSITE
     m_tPixmap = new KPixmap(kapp->desktop()->size());
     m_tPixmap->fill(TQColor(0, 0x0));
-    connect(myApp, TQT_SIGNAL(cmBackgroundChanged( bool )),
-            TQT_SLOT(slotCmBackgroundChanged( bool )));
+    connect(myApp, TQ_SIGNAL(cmBackgroundChanged( bool )),
+            TQ_SLOT(slotCmBackgroundChanged( bool )));
 #endif
 
     configure();
 
     m_pTimer = new TQTimer(this);
-    connect(m_pTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotTimeout()));
+    connect(m_pTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotTimeout()));
     m_pTimer->start( 60000 );
 
     /*CrossFade's config*/
     m_crossTimer = new TQTimer(this);
-    connect(m_crossTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotCrossFadeTimeout()));
+    connect(m_crossTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotCrossFadeTimeout()));
     resizingDesktop = true;
     /*Ends here*/
 
 
-    connect(m_pKwinmodule, TQT_SIGNAL(currentDesktopChanged(int)),
-	    TQT_SLOT(slotChangeDesktop(int)));
-    connect(m_pKwinmodule, TQT_SIGNAL(numberOfDesktopsChanged(int)),
-	    TQT_SLOT(slotChangeNumberOfDesktops(int)));
-    connect(m_pKwinmodule, TQT_SIGNAL(currentDesktopViewportChanged(int, const TQPoint&)),
-            TQT_SLOT(slotChangeViewport(int, const TQPoint&)));
+    connect(m_pKwinmodule, TQ_SIGNAL(currentDesktopChanged(int)),
+	    TQ_SLOT(slotChangeDesktop(int)));
+    connect(m_pKwinmodule, TQ_SIGNAL(numberOfDesktopsChanged(int)),
+	    TQ_SLOT(slotChangeNumberOfDesktops(int)));
+    connect(m_pKwinmodule, TQ_SIGNAL(currentDesktopViewportChanged(int, const TQPoint&)),
+            TQ_SLOT(slotChangeViewport(int, const TQPoint&)));
 
 
 #if (TQT_VERSION-0 >= 0x030200)
-    connect( kapp->desktop(), TQT_SIGNAL( resized( int )), TQT_SLOT( desktopResized())); // RANDR support
+    connect( kapp->desktop(), TQ_SIGNAL( resized( int )), TQ_SLOT( desktopResized())); // RANDR support
 #endif
 
     TQSize s(m_pKwinmodule->numberOfViewports(m_pKwinmodule->currentDesktop()));
@@ -338,7 +338,7 @@ void KBackgroundManager::slotChangeNumberOfDesktops(int num)
 	    m_Cache[i]->hash = 0;
 	    m_Cache[i]->exp_from = -1;
             m_Renderer.insert(i, new KVirtualBGRenderer(i,m_pConfig));
-	    connect(m_Renderer[i], TQT_SIGNAL(imageDone(int)), TQT_SLOT(slotImageDone(int)));
+	    connect(m_Renderer[i], TQ_SIGNAL(imageDone(int)), TQ_SLOT(slotImageDone(int)));
             m_Renderer[i]->enableTiling( true ); // optimize
 	}
     }
@@ -542,7 +542,7 @@ void KBackgroundManager::setPixmap(KPixmap *pm, int hash, int desk)
        if( !root_cleared )
        { // clear the root window pixmap set by tdm
           root_cleared = true;
-	  TQTimer::singleShot( 0, this, TQT_SLOT( clearRoot()));
+	  TQTimer::singleShot( 0, this, TQ_SLOT( clearRoot()));
           // but make the pixmap visible until m_pDesktop is visible
           TDEApplication::desktop()->screen()->setErasePixmap(*ep);
           TDEApplication::desktop()->screen()->erase();
@@ -681,7 +681,7 @@ void KBackgroundManager::slotImageDone(int desk)
         {
             m_bBgInitDone = true;
             emit initDone();
-            TQTimer::singleShot( 30000, this, TQT_SLOT( saveImages()));
+            TQTimer::singleShot( 30000, this, TQ_SLOT( saveImages()));
             do_cleanup = false;
         }
     }
diff --git a/kdesktop/desktop.cpp b/kdesktop/desktop.cpp
index fef324797..e7681b1f2 100644
--- a/kdesktop/desktop.cpp
+++ b/kdesktop/desktop.cpp
@@ -184,28 +184,28 @@ KDesktop::KDesktop( SaverEngine* saver, bool x_root_hack, bool wait_for_kded ) :
   setGeometry( TQApplication::desktop()->geometry() );
   lower();
 
-  connect( kapp, TQT_SIGNAL( shutDown() ),
-           this, TQT_SLOT( slotShutdown() ) );
+  connect( kapp, TQ_SIGNAL( shutDown() ),
+           this, TQ_SLOT( slotShutdown() ) );
 
-  connect(kapp, TQT_SIGNAL(settingsChanged(int)),
-          this, TQT_SLOT(slotSettingsChanged(int)));
+  connect(kapp, TQ_SIGNAL(settingsChanged(int)),
+          this, TQ_SLOT(slotSettingsChanged(int)));
   kapp->addKipcEventMask(KIPC::SettingsChanged);
 
   kapp->addKipcEventMask(KIPC::IconChanged);
-  connect(kapp, TQT_SIGNAL(iconChanged(int)), this, TQT_SLOT(slotIconChanged(int)));
+  connect(kapp, TQ_SIGNAL(iconChanged(int)), this, TQ_SLOT(slotIconChanged(int)));
 
-  connect(KSycoca::self(), TQT_SIGNAL(databaseChanged()),
-          this, TQT_SLOT(slotDatabaseChanged()));
+  connect(KSycoca::self(), TQ_SIGNAL(databaseChanged()),
+          this, TQ_SLOT(slotDatabaseChanged()));
 
   m_pIconView = 0;
   m_pRootWidget = 0;
   bgMgr = 0;
   initRoot();
 
-  TQTimer::singleShot(0, this, TQT_SLOT( slotStart() ));
+  TQTimer::singleShot(0, this, TQ_SLOT( slotStart() ));
 
 #if (TQT_VERSION-0 >= 0x030200) // XRANDR support
-  connect( kapp->desktop(), TQT_SIGNAL( resized( int )), TQT_SLOT( desktopResized()));
+  connect( kapp->desktop(), TQ_SIGNAL( resized( int )), TQ_SLOT( desktopResized()));
 #endif
 }
 
@@ -238,21 +238,21 @@ KDesktop::initRoot()
      XSelectInput(dpy, root, attrs.your_event_mask | ButtonPressMask);
 
      m_pRootWidget = new KRootWidget;
-     connect(m_pRootWidget, TQT_SIGNAL(wheelRolled(int)), this, TQT_SLOT(slotSwitchDesktops(int)));
-     connect(m_pRootWidget, TQT_SIGNAL(colorDropEvent(TQDropEvent*)), this, TQT_SLOT(handleColorDropEvent(TQDropEvent*)) );
-     connect(m_pRootWidget, TQT_SIGNAL(imageDropEvent(TQDropEvent*)), this, TQT_SLOT(handleImageDropEvent(TQDropEvent*)) );
-     connect(m_pRootWidget, TQT_SIGNAL(newWallpaper(const KURL&)), this, TQT_SLOT(slotNewWallpaper(const KURL&)) );
+     connect(m_pRootWidget, TQ_SIGNAL(wheelRolled(int)), this, TQ_SLOT(slotSwitchDesktops(int)));
+     connect(m_pRootWidget, TQ_SIGNAL(colorDropEvent(TQDropEvent*)), this, TQ_SLOT(handleColorDropEvent(TQDropEvent*)) );
+     connect(m_pRootWidget, TQ_SIGNAL(imageDropEvent(TQDropEvent*)), this, TQ_SLOT(handleImageDropEvent(TQDropEvent*)) );
+     connect(m_pRootWidget, TQ_SIGNAL(newWallpaper(const KURL&)), this, TQ_SLOT(slotNewWallpaper(const KURL&)) );
 
      // Geert Jansen: backgroundmanager belongs here
      // TODO tell KBackgroundManager if we change widget()
      bgMgr = new KBackgroundManager( m_pIconView, m_pKwinmodule );
      bgMgr->setExport(1);
-     connect( bgMgr, TQT_SIGNAL( initDone()), TQT_SLOT( backgroundInitDone()));
+     connect( bgMgr, TQ_SIGNAL( initDone()), TQ_SLOT( backgroundInitDone()));
      if (!m_bInit)
      {
         delete KRootWm::self();
         KRootWm* krootwm = new KRootWm( m_pSaver, this ); // handler for root menu (used by kdesktop on RMB click)
-        keys->setSlot("Lock Session", krootwm, TQT_SLOT(slotLock()));
+        keys->setSlot("Lock Session", krootwm, TQ_SLOT(slotLock()));
         keys->updateConnections();
      }
   }
@@ -263,14 +263,14 @@ KDesktop::initRoot()
      delete m_pRootWidget;
      m_pRootWidget = 0;
      m_pIconView = new KDIconView( this, 0 );
-     connect( m_pIconView, TQT_SIGNAL( imageDropEvent( TQDropEvent * ) ),
-              this, TQT_SLOT( handleImageDropEvent( TQDropEvent * ) ) );
-     connect( m_pIconView, TQT_SIGNAL( colorDropEvent( TQDropEvent * ) ),
-              this, TQT_SLOT( handleColorDropEvent( TQDropEvent * ) ) );
-     connect( m_pIconView, TQT_SIGNAL( newWallpaper( const KURL & ) ),
-              this, TQT_SLOT( slotNewWallpaper( const KURL & ) ) );
-     connect( m_pIconView, TQT_SIGNAL( wheelRolled( int ) ),
-              this, TQT_SLOT( slotSwitchDesktops( int ) ) );
+     connect( m_pIconView, TQ_SIGNAL( imageDropEvent( TQDropEvent * ) ),
+              this, TQ_SLOT( handleImageDropEvent( TQDropEvent * ) ) );
+     connect( m_pIconView, TQ_SIGNAL( colorDropEvent( TQDropEvent * ) ),
+              this, TQ_SLOT( handleColorDropEvent( TQDropEvent * ) ) );
+     connect( m_pIconView, TQ_SIGNAL( newWallpaper( const KURL & ) ),
+              this, TQ_SLOT( slotNewWallpaper( const KURL & ) ) );
+     connect( m_pIconView, TQ_SIGNAL( wheelRolled( int ) ),
+              this, TQ_SLOT( slotSwitchDesktops( int ) ) );
 
      // All the QScrollView/TQWidget-specific stuff should go here, so that we can use
      // another qscrollview/widget instead of the iconview and use the same code
@@ -288,7 +288,7 @@ KDesktop::initRoot()
      // TODO tell KBackgroundManager if we change widget()
      bgMgr = new KBackgroundManager( m_pIconView, m_pKwinmodule );
      bgMgr->setExport(1);
-     connect( bgMgr, TQT_SIGNAL( initDone()), TQT_SLOT( backgroundInitDone()));
+     connect( bgMgr, TQ_SIGNAL( initDone()), TQ_SLOT( backgroundInitDone()));
 
      // make sure it is initialized before we first call updateWorkArea()
      m_pIconView->initConfig( m_bInit );
@@ -315,7 +315,7 @@ KDesktop::initRoot()
             // if we failed to get the information from kicker wait a little - probably
             // this is the KDE startup and kicker is simply not running yet
             m_waitForKicker = new TQTimer(this);
-            connect(m_waitForKicker, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotNoKicker()));
+            connect(m_waitForKicker, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotNoKicker()));
             m_waitForKicker->start(15000, true);
           }
           else  // we are not called from the ctor, so kicker should already run
@@ -330,7 +330,7 @@ KDesktop::initRoot()
         m_pIconView->start();
         delete KRootWm::self();
         KRootWm* krootwm = new KRootWm( m_pSaver, this ); // handler for root menu (used by kdesktop on RMB click)
-        keys->setSlot("Lock Session", krootwm, TQT_SLOT(slotLock()));
+        keys->setSlot("Lock Session", krootwm, TQ_SLOT(slotLock()));
         keys->updateConnections();
      }
    } else {
@@ -404,9 +404,9 @@ KDesktop::slotStart()
   keys->readSettings();
   keys->updateConnections();
 
-  connect(kapp, TQT_SIGNAL(appearanceChanged()), TQT_SLOT(slotConfigure()));
+  connect(kapp, TQ_SIGNAL(appearanceChanged()), TQ_SLOT(slotConfigure()));
 
-  TQTimer::singleShot(300, this, TQT_SLOT( slotUpAndRunning() ));
+  TQTimer::singleShot(300, this, TQ_SLOT( slotUpAndRunning() ));
 }
 
 void
@@ -648,21 +648,21 @@ void KDesktop::setShowDesktop( bool b )
         }
 
         // on desktop changes or when a window is deiconified, we abort the show desktop mode
-        connect(twinModule(), TQT_SIGNAL(currentDesktopChanged(int)),
-                TQT_SLOT(slotCurrentDesktopChanged(int)));
-        connect(twinModule(), TQT_SIGNAL(windowChanged(WId,unsigned int)),
-                TQT_SLOT(slotWindowChanged(WId,unsigned int)));
-        connect(twinModule(), TQT_SIGNAL(windowAdded(WId)),
-                TQT_SLOT(slotWindowAdded(WId)));
+        connect(twinModule(), TQ_SIGNAL(currentDesktopChanged(int)),
+                TQ_SLOT(slotCurrentDesktopChanged(int)));
+        connect(twinModule(), TQ_SIGNAL(windowChanged(WId,unsigned int)),
+                TQ_SLOT(slotWindowChanged(WId,unsigned int)));
+        connect(twinModule(), TQ_SIGNAL(windowAdded(WId)),
+                TQ_SLOT(slotWindowAdded(WId)));
     }
     else
     {
-        disconnect(twinModule(), TQT_SIGNAL(currentDesktopChanged(int)),
-                   this, TQT_SLOT(slotCurrentDesktopChanged(int)));
-        disconnect(twinModule(), TQT_SIGNAL(windowChanged(WId,unsigned int)),
-                   this, TQT_SLOT(slotWindowChanged(WId,unsigned int)));
-        disconnect(twinModule(), TQT_SIGNAL(windowAdded(WId)),
-                   this, TQT_SLOT(slotWindowAdded(WId)));
+        disconnect(twinModule(), TQ_SIGNAL(currentDesktopChanged(int)),
+                   this, TQ_SLOT(slotCurrentDesktopChanged(int)));
+        disconnect(twinModule(), TQ_SIGNAL(windowChanged(WId,unsigned int)),
+                   this, TQ_SLOT(slotWindowChanged(WId,unsigned int)));
+        disconnect(twinModule(), TQ_SIGNAL(windowAdded(WId)),
+                   this, TQ_SLOT(slotWindowAdded(WId)));
 
         for (TQValueVector<WId>::ConstIterator it = m_iconifiedList.begin();
              it != m_iconifiedList.end();
@@ -851,7 +851,7 @@ void KDesktop::slotSetVRoot()
         return;
 
     if (KWin::windowInfo(winId()).mappingState() == NET::Withdrawn) {
-        TQTimer::singleShot(100, this, TQT_SLOT(slotSetVRoot()));
+        TQTimer::singleShot(100, this, TQ_SLOT(slotSetVRoot()));
         return;
     }
 
diff --git a/kdesktop/kcustommenu.cpp b/kdesktop/kcustommenu.cpp
index 2e825c0d9..cd1287d3d 100644
--- a/kdesktop/kcustommenu.cpp
+++ b/kdesktop/kcustommenu.cpp
@@ -57,7 +57,7 @@ KCustomMenu::KCustomMenu(const TQString &configfile, TQWidget *parent)
  
      insertMenuItem( menuItem, -1 );
   }
-  connect(this, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)));
+  connect(this, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)));
 }
 
 KCustomMenu::~KCustomMenu()
diff --git a/kdesktop/kdesktopbindings.cpp b/kdesktop/kdesktopbindings.cpp
index 71f01abc4..17b27fc65 100644
--- a/kdesktop/kdesktopbindings.cpp
+++ b/kdesktop/kdesktopbindings.cpp
@@ -1,6 +1,6 @@
 #ifndef NOSLOTS
 # define DEF( name, key3, key4, fnSlot ) \
-   keys->insert( name, i18n(name), TQString(), key3, key4, this, TQT_SLOT(fnSlot) )
+   keys->insert( name, i18n(name), TQString(), key3, key4, this, TQ_SLOT(fnSlot) )
 # define DEF2( name, key3, key4, receiver, slot ) \
    keys->insert( name, i18n(name), TQString(), key3, key4, receiver, slot );
 #else
@@ -28,14 +28,14 @@
 	if (kapp->authorize("lock_screen"))
 	{
 #endif
-		DEF2( I18N_NOOP("Lock Session"), ALT+CTRL+TQt::Key_L, WIN+TQt::Key_ScrollLock, KRootWm::self(), TQT_SLOT(slotLock()) );
-		DEF2( I18N_NOOP("Lock Session (Hotkey)"), TDEShortcut(TQString("XF86ScreenSaver")), TDEShortcut(TQString("XF86ScreenSaver")), KRootWm::self(), TQT_SLOT(slotLock()) );
+		DEF2( I18N_NOOP("Lock Session"), ALT+CTRL+TQt::Key_L, WIN+TQt::Key_ScrollLock, KRootWm::self(), TQ_SLOT(slotLock()) );
+		DEF2( I18N_NOOP("Lock Session (Hotkey)"), TDEShortcut(TQString("XF86ScreenSaver")), TDEShortcut(TQString("XF86ScreenSaver")), KRootWm::self(), TQ_SLOT(slotLock()) );
 #ifndef NOSLOTS
 	}
 	if (kapp->authorize("start_screensaver"))
 	{
 #endif
-		DEF2( I18N_NOOP("Start Screen Saver"), ALT+CTRL+TQt::Key_S, WIN+TQt::Key_S, KRootWm::self(), TQT_SLOT(slotSave()) );
+		DEF2( I18N_NOOP("Start Screen Saver"), ALT+CTRL+TQt::Key_S, WIN+TQt::Key_S, KRootWm::self(), TQ_SLOT(slotSave()) );
 #ifndef NOSLOTS
 	}
 	if (kapp->authorize("logout"))
diff --git a/kdesktop/kdiconview.cpp b/kdesktop/kdiconview.cpp
index 2c2d0fe0f..7d79d12cf 100644
--- a/kdesktop/kdiconview.cpp
+++ b/kdesktop/kdiconview.cpp
@@ -162,32 +162,32 @@ KDIconView::KDIconView( TQWidget *parent, const char* name )
     // Initialize media handler
     mMediaListView = new TQListView();
 
-    connect( TQApplication::clipboard(), TQT_SIGNAL(dataChanged()), this, TQT_SLOT(slotClipboardDataChanged()) );
+    connect( TQApplication::clipboard(), TQ_SIGNAL(dataChanged()), this, TQ_SLOT(slotClipboardDataChanged()) );
 
     setURL( desktopURL() ); // sets m_url
 
     m_desktopDirs = TDEGlobal::dirs()->findDirs( "appdata", "Desktop" );
     initDotDirectories();
 
-    connect( this, TQT_SIGNAL( executed( TQIconViewItem * ) ),
-             TQT_SLOT( slotExecuted( TQIconViewItem * ) ) );
-    connect( this, TQT_SIGNAL( returnPressed( TQIconViewItem * ) ),
-             TQT_SLOT( slotReturnPressed( TQIconViewItem * ) ) );
-    connect( this, TQT_SIGNAL( mouseButtonPressed(int, TQIconViewItem*, const TQPoint&)),
-             TQT_SLOT( slotMouseButtonPressed(int, TQIconViewItem*, const TQPoint&)) );
-    connect( this, TQT_SIGNAL( mouseButtonClicked(int, TQIconViewItem*, const TQPoint&)),
-             TQT_SLOT( slotMouseButtonClickedKDesktop(int, TQIconViewItem*, const TQPoint&)) );
-    connect( this, TQT_SIGNAL( contextMenuRequested(TQIconViewItem*, const TQPoint&)),
-             TQT_SLOT( slotContextMenuRequested(TQIconViewItem*, const TQPoint&)) );
+    connect( this, TQ_SIGNAL( executed( TQIconViewItem * ) ),
+             TQ_SLOT( slotExecuted( TQIconViewItem * ) ) );
+    connect( this, TQ_SIGNAL( returnPressed( TQIconViewItem * ) ),
+             TQ_SLOT( slotReturnPressed( TQIconViewItem * ) ) );
+    connect( this, TQ_SIGNAL( mouseButtonPressed(int, TQIconViewItem*, const TQPoint&)),
+             TQ_SLOT( slotMouseButtonPressed(int, TQIconViewItem*, const TQPoint&)) );
+    connect( this, TQ_SIGNAL( mouseButtonClicked(int, TQIconViewItem*, const TQPoint&)),
+             TQ_SLOT( slotMouseButtonClickedKDesktop(int, TQIconViewItem*, const TQPoint&)) );
+    connect( this, TQ_SIGNAL( contextMenuRequested(TQIconViewItem*, const TQPoint&)),
+             TQ_SLOT( slotContextMenuRequested(TQIconViewItem*, const TQPoint&)) );
 
-    connect( this, TQT_SIGNAL( enableAction( const char * , bool ) ),
-             TQT_SLOT( slotEnableAction( const char * , bool ) ) );
+    connect( this, TQ_SIGNAL( enableAction( const char * , bool ) ),
+             TQ_SLOT( slotEnableAction( const char * , bool ) ) );
 
     // Hack: KonqIconViewWidget::slotItemRenamed is not virtual :-(
-    disconnect( this, TQT_SIGNAL(itemRenamed(TQIconViewItem *, const TQString &)),
-             this, TQT_SLOT(slotItemRenamed(TQIconViewItem *, const TQString &)) );
-    connect( this, TQT_SIGNAL(itemRenamed(TQIconViewItem *, const TQString &)),
-             this, TQT_SLOT(slotItemRenamed(TQIconViewItem *, const TQString &)) );
+    disconnect( this, TQ_SIGNAL(itemRenamed(TQIconViewItem *, const TQString &)),
+             this, TQ_SLOT(slotItemRenamed(TQIconViewItem *, const TQString &)) );
+    connect( this, TQ_SIGNAL(itemRenamed(TQIconViewItem *, const TQString &)),
+             this, TQ_SLOT(slotItemRenamed(TQIconViewItem *, const TQString &)) );
 
     if (!m_bEditableDesktopIcons)
     {
@@ -370,12 +370,12 @@ void KDIconView::start()
 
     m_bNeedSave = false;
 
-    connect( m_dirLister, TQT_SIGNAL( clear() ),                               this, TQT_SLOT( slotClear() ) );
-    connect( m_dirLister, TQT_SIGNAL( started(const KURL&) ),                  this, TQT_SLOT( slotStarted(const KURL&) ) );
-    connect( m_dirLister, TQT_SIGNAL( completed() ),                           this, TQT_SLOT( slotCompleted() ) );
-    connect( m_dirLister, TQT_SIGNAL( newItems( const KFileItemList & ) ),     this, TQT_SLOT( slotNewItems( const KFileItemList & ) ) );
-    connect( m_dirLister, TQT_SIGNAL( deleteItem( KFileItem * ) ),             this, TQT_SLOT( slotDeleteItem( KFileItem * ) ) );
-    connect( m_dirLister, TQT_SIGNAL( refreshItems( const KFileItemList & ) ), this, TQT_SLOT( slotRefreshItems( const KFileItemList & ) ) );
+    connect( m_dirLister, TQ_SIGNAL( clear() ),                               this, TQ_SLOT( slotClear() ) );
+    connect( m_dirLister, TQ_SIGNAL( started(const KURL&) ),                  this, TQ_SLOT( slotStarted(const KURL&) ) );
+    connect( m_dirLister, TQ_SIGNAL( completed() ),                           this, TQ_SLOT( slotCompleted() ) );
+    connect( m_dirLister, TQ_SIGNAL( newItems( const KFileItemList & ) ),     this, TQ_SLOT( slotNewItems( const KFileItemList & ) ) );
+    connect( m_dirLister, TQ_SIGNAL( deleteItem( KFileItem * ) ),             this, TQ_SLOT( slotDeleteItem( KFileItem * ) ) );
+    connect( m_dirLister, TQ_SIGNAL( refreshItems( const KFileItemList & ) ), this, TQ_SLOT( slotRefreshItems( const KFileItemList & ) ) );
 
     // Start the directory lister !
     m_dirLister->setShowingDotFiles( m_bShowDot );
@@ -420,35 +420,35 @@ void KDIconView::createActions()
 {
     if (m_bEditableDesktopIcons)
     {
-        TDEAction *undo = KStdAction::undo( KonqUndoManager::self(), TQT_SLOT( undo() ), &m_actionCollection, "undo" );
-        connect( KonqUndoManager::self(), TQT_SIGNAL( undoAvailable( bool ) ),
-             undo, TQT_SLOT( setEnabled( bool ) ) );
-        connect( KonqUndoManager::self(), TQT_SIGNAL( undoTextChanged( const TQString & ) ),
-             undo, TQT_SLOT( setText( const TQString & ) ) );
+        TDEAction *undo = KStdAction::undo( KonqUndoManager::self(), TQ_SLOT( undo() ), &m_actionCollection, "undo" );
+        connect( KonqUndoManager::self(), TQ_SIGNAL( undoAvailable( bool ) ),
+             undo, TQ_SLOT( setEnabled( bool ) ) );
+        connect( KonqUndoManager::self(), TQ_SIGNAL( undoTextChanged( const TQString & ) ),
+             undo, TQ_SLOT( setText( const TQString & ) ) );
         undo->setEnabled( KonqUndoManager::self()->undoAvailable() );
 
-        TDEAction* paCut = KStdAction::cut( this, TQT_SLOT( slotCut() ), &m_actionCollection, "cut" );
+        TDEAction* paCut = KStdAction::cut( this, TQ_SLOT( slotCut() ), &m_actionCollection, "cut" );
         TDEShortcut cutShortCut = paCut->shortcut();
         cutShortCut.remove( KKey( SHIFT + Key_Delete ) ); // used for deleting files
         paCut->setShortcut( cutShortCut );
 
-        KStdAction::copy( this, TQT_SLOT( slotCopy() ), &m_actionCollection, "copy" );
-        KStdAction::paste( this, TQT_SLOT( slotPaste() ), &m_actionCollection, "paste" );
-        TDEAction *pasteTo = KStdAction::paste( this, TQT_SLOT( slotPopupPasteTo() ), &m_actionCollection, "pasteto" );
+        KStdAction::copy( this, TQ_SLOT( slotCopy() ), &m_actionCollection, "copy" );
+        KStdAction::paste( this, TQ_SLOT( slotPaste() ), &m_actionCollection, "paste" );
+        TDEAction *pasteTo = KStdAction::paste( this, TQ_SLOT( slotPopupPasteTo() ), &m_actionCollection, "pasteto" );
         pasteTo->setEnabled( false ); // only enabled during popupMenu()
 
         TDEShortcut reloadShortcut = TDEStdAccel::shortcut(TDEStdAccel::Reload);
-        new TDEAction( i18n( "&Reload" ), "reload", reloadShortcut, this, TQT_SLOT( refreshIcons() ), &m_actionCollection, "reload" );
+        new TDEAction( i18n( "&Reload" ), "reload", reloadShortcut, this, TQ_SLOT( refreshIcons() ), &m_actionCollection, "reload" );
 
-        (void) new TDEAction( i18n( "&Rename" ), /*"editrename",*/ Key_F2, this, TQT_SLOT( renameSelectedItem() ), &m_actionCollection, "rename" );
-        (void) new TDEAction( i18n( "&Properties" ), ALT+Key_Return, this, TQT_SLOT( slotProperties() ), &m_actionCollection, "properties" );
+        (void) new TDEAction( i18n( "&Rename" ), /*"editrename",*/ Key_F2, this, TQ_SLOT( renameSelectedItem() ), &m_actionCollection, "rename" );
+        (void) new TDEAction( i18n( "&Properties" ), ALT+Key_Return, this, TQ_SLOT( slotProperties() ), &m_actionCollection, "properties" );
         TDEAction* trash = new TDEAction( i18n( "&Move to Trash" ), "edittrash", Key_Delete, &m_actionCollection, "trash" );
-        connect( trash, TQT_SIGNAL( activated( TDEAction::ActivationReason, TQt::ButtonState ) ),
-                 this, TQT_SLOT( slotTrashActivated( TDEAction::ActivationReason, TQt::ButtonState ) ) );
+        connect( trash, TQ_SIGNAL( activated( TDEAction::ActivationReason, TQt::ButtonState ) ),
+                 this, TQ_SLOT( slotTrashActivated( TDEAction::ActivationReason, TQt::ButtonState ) ) );
 
         TDEConfig config("kdeglobals", true, false);
         config.setGroup( "KDE" );
-        (void) new TDEAction( i18n( "&Delete" ), "edit-delete", SHIFT+Key_Delete, this, TQT_SLOT( slotDelete() ), &m_actionCollection, "del" );
+        (void) new TDEAction( i18n( "&Delete" ), "edit-delete", SHIFT+Key_Delete, this, TQ_SLOT( slotDelete() ), &m_actionCollection, "del" );
 
         // Initial state of the actions (cut/copy/paste/...)
         slotSelectionChanged();
@@ -526,8 +526,8 @@ void KDIconView::setAutoAlign( bool b )
         else {
             KRootWm::self()->startup = false;
         }
-        connect( this, TQT_SIGNAL( iconMoved() ),
-                 this, TQT_SLOT( lineupIcons() ) );
+        connect( this, TQ_SIGNAL( iconMoved() ),
+                 this, TQ_SLOT( lineupIcons() ) );
     }
     else {
         // change maxItemWidth, because when grid-align was active, it changed this for the grid
@@ -535,8 +535,8 @@ void KDIconView::setAutoAlign( bool b )
         setMaxItemWidth( TQMAX( TQMAX( sz, previewIconSize( iconSize() ) ), KonqFMSettings::settings()->iconTextWidth() ) );
         setFont( font() );  // Force calcRect()
 
-        disconnect( this, TQT_SIGNAL( iconMoved() ),
-                    this, TQT_SLOT( lineupIcons() ) );
+        disconnect( this, TQ_SIGNAL( iconMoved() ),
+                    this, TQ_SLOT( lineupIcons() ) );
     }
 }
 
@@ -1446,7 +1446,7 @@ void KDIconView::showFreeSpaceOverlay(KFileIVI* item)
            if (!m_paOutstandingFreeSpaceOverlaysTimer)
            {
               m_paOutstandingFreeSpaceOverlaysTimer = new TQTimer(this);
-              connect(m_paOutstandingFreeSpaceOverlaysTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotFreeSpaceOverlayStart()));
+              connect(m_paOutstandingFreeSpaceOverlaysTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotFreeSpaceOverlayStart()));
            }
            m_paOutstandingFreeSpaceOverlaysTimer->start(20, true);
         }
@@ -1466,7 +1466,7 @@ void KDIconView::slotFreeSpaceOverlayStart()
 
        if (overlay)
        {
-          connect( overlay, TQT_SIGNAL( finished() ), this, TQT_SLOT( slotFreeSpaceOverlayFinished() ) );
+          connect( overlay, TQ_SIGNAL( finished() ), this, TQ_SLOT( slotFreeSpaceOverlayFinished() ) );
           overlay->start(); // Watch out, may emit finished() immediately!!
           return; // Let it run....
        }
diff --git a/kdesktop/krootwm.cpp b/kdesktop/krootwm.cpp
index 1d7894a93..b33ef60d4 100644
--- a/kdesktop/krootwm.cpp
+++ b/kdesktop/krootwm.cpp
@@ -89,10 +89,10 @@ KRootWm::KRootWm(SaverEngine* _saver, KDesktop* _desktop) : TQObject(_desktop),
   if (m_bDesktopEnabled && kapp->authorize("editable_desktop_icons"))
   {
      menuNew = new KNewMenu( m_actionCollection, "new_menu" );
-     connect(menuNew->popupMenu(), TQT_SIGNAL( aboutToShow() ),
-             this, TQT_SLOT( slotFileNewAboutToShow() ) );
-     connect( menuNew, TQT_SIGNAL( activated() ),
-              m_pDesktop->iconView(), TQT_SLOT( slotNewMenuActivated() ) );
+     connect(menuNew->popupMenu(), TQ_SIGNAL( aboutToShow() ),
+             this, TQ_SLOT( slotFileNewAboutToShow() ) );
+     connect( menuNew, TQ_SIGNAL( activated() ),
+              m_pDesktop->iconView(), TQ_SLOT( slotNewMenuActivated() ) );
   }
 
   if (kapp->authorizeTDEAction("bookmarks"))
@@ -114,8 +114,8 @@ KRootWm::KRootWm(SaverEngine* _saver, KDesktop* _desktop) : TQObject(_desktop),
   // so we create them here
   desktopMenu = new TQPopupMenu;
   windowListMenu = new KWindowListMenu;
-  connect( windowListMenu, TQT_SIGNAL( aboutToShow() ),
-           this, TQT_SLOT( slotWindowListAboutToShow() ) );
+  connect( windowListMenu, TQ_SIGNAL( aboutToShow() ),
+           this, TQ_SLOT( slotWindowListAboutToShow() ) );
 
   // Create the actions
 #if 0
@@ -134,80 +134,80 @@ KRootWm::KRootWm(SaverEngine* _saver, KDesktop* _desktop) : TQObject(_desktop),
 
   if (kapp->authorize("run_command"))
   {
-     new TDEAction(i18n("Run Command..."), "system-run", 0, m_pDesktop, TQT_SLOT( slotExecuteCommand() ), m_actionCollection, "exec" );
-     new TDEAction(i18n("Open Terminal Here..." ), "terminal", CTRL+Key_T, this, TQT_SLOT( slotOpenTerminal() ),
+     new TDEAction(i18n("Run Command..."), "system-run", 0, m_pDesktop, TQ_SLOT( slotExecuteCommand() ), m_actionCollection, "exec" );
+     new TDEAction(i18n("Open Terminal Here..." ), "terminal", CTRL+Key_T, this, TQ_SLOT( slotOpenTerminal() ),
 	m_actionCollection, "open_terminal" );
   }
 
   if (!TDEGlobal::config()->isImmutable())
   {
-     new TDEAction(i18n("Configure Desktop..."), "configure", 0, this, TQT_SLOT( slotConfigureDesktop() ),
+     new TDEAction(i18n("Configure Desktop..."), "configure", 0, this, TQ_SLOT( slotConfigureDesktop() ),
                  m_actionCollection, "configdesktop" );
-     new TDEAction(i18n("Disable Desktop Menu"), 0, this, TQT_SLOT( slotToggleDesktopMenu() ),
+     new TDEAction(i18n("Disable Desktop Menu"), 0, this, TQ_SLOT( slotToggleDesktopMenu() ),
                  m_actionCollection, "togglemenubar" );
   }
 
-  new TDEAction(i18n("Unclutter Windows"), 0, this, TQT_SLOT( slotUnclutterWindows() ),
+  new TDEAction(i18n("Unclutter Windows"), 0, this, TQ_SLOT( slotUnclutterWindows() ),
               m_actionCollection, "unclutter" );
-  new TDEAction(i18n("Cascade Windows"), 0, this, TQT_SLOT( slotCascadeWindows() ),
+  new TDEAction(i18n("Cascade Windows"), 0, this, TQ_SLOT( slotCascadeWindows() ),
               m_actionCollection, "cascade" );
 
   // arrange menu actions
   if (m_bDesktopEnabled && kapp->authorize("editable_desktop_icons"))
   {
-     new TDEAction(i18n("By Name (Case Sensitive)"), 0, this, TQT_SLOT( slotArrangeByNameCS() ),
+     new TDEAction(i18n("By Name (Case Sensitive)"), 0, this, TQ_SLOT( slotArrangeByNameCS() ),
                  m_actionCollection, "sort_ncs");
-     new TDEAction(i18n("By Name (Case Insensitive)"), 0, this, TQT_SLOT( slotArrangeByNameCI() ),
+     new TDEAction(i18n("By Name (Case Insensitive)"), 0, this, TQ_SLOT( slotArrangeByNameCI() ),
                  m_actionCollection, "sort_nci");
-     new TDEAction(i18n("By Size"), 0, this, TQT_SLOT( slotArrangeBySize() ),
+     new TDEAction(i18n("By Size"), 0, this, TQ_SLOT( slotArrangeBySize() ),
                  m_actionCollection, "sort_size");
-     new TDEAction(i18n("By Type"), 0, this, TQT_SLOT( slotArrangeByType() ),
+     new TDEAction(i18n("By Type"), 0, this, TQ_SLOT( slotArrangeByType() ),
                  m_actionCollection, "sort_type");
-     new TDEAction(i18n("By Date"), 0, this, TQT_SLOT( slotArrangeByDate() ),
+     new TDEAction(i18n("By Date"), 0, this, TQ_SLOT( slotArrangeByDate() ),
                  m_actionCollection, "sort_date");
 
      TDEToggleAction *aSortDirsFirst = new TDEToggleAction( i18n("Directories First"), 0, m_actionCollection, "sort_directoriesfirst" );
-     connect( aSortDirsFirst, TQT_SIGNAL( toggled( bool ) ),
-              this, TQT_SLOT( slotToggleDirFirst( bool ) ) );
+     connect( aSortDirsFirst, TQ_SIGNAL( toggled( bool ) ),
+              this, TQ_SLOT( slotToggleDirFirst( bool ) ) );
      new TDEAction(i18n("Line Up Horizontally"), 0,
-                 this, TQT_SLOT( slotLineupIconsHoriz() ),
+                 this, TQ_SLOT( slotLineupIconsHoriz() ),
                  m_actionCollection, "lineupHoriz" );
      new TDEAction(i18n("Line Up Vertically"), 0,
-                 this, TQT_SLOT( slotLineupIconsVert() ),
+                 this, TQ_SLOT( slotLineupIconsVert() ),
                  m_actionCollection, "lineupVert" );
      TDEToggleAction *aAutoAlign = new TDEToggleAction(i18n("Align to Grid"), 0,
                  m_actionCollection, "realign" );
-     connect( aAutoAlign, TQT_SIGNAL( toggled( bool ) ),
-              this, TQT_SLOT( slotToggleAutoAlign( bool ) ) );
+     connect( aAutoAlign, TQ_SIGNAL( toggled( bool ) ),
+              this, TQ_SLOT( slotToggleAutoAlign( bool ) ) );
      TDEToggleAction *aLockIcons = new TDEToggleAction(i18n("Lock in Place"), 0, m_actionCollection, "lock_icons");
-     connect( aLockIcons, TQT_SIGNAL( toggled( bool ) ),
-              this, TQT_SLOT( slotToggleLockIcons( bool ) ) );
+     connect( aLockIcons, TQ_SIGNAL( toggled( bool ) ),
+              this, TQ_SLOT( slotToggleLockIcons( bool ) ) );
   }
   if (m_bDesktopEnabled)
   {
-     new TDEAction(i18n("Refresh Desktop"), "desktop", 0, this, TQT_SLOT( slotRefreshDesktop() ),
+     new TDEAction(i18n("Refresh Desktop"), "desktop", 0, this, TQ_SLOT( slotRefreshDesktop() ),
                  m_actionCollection, "refresh" );
   }
   // Icons in sync with kicker
   if (kapp->authorize("lock_screen"))
   {
-      new TDEAction(i18n("Lock Session"), "system-lock-screen", 0, this, TQT_SLOT( slotLock() ),
+      new TDEAction(i18n("Lock Session"), "system-lock-screen", 0, this, TQ_SLOT( slotLock() ),
                   m_actionCollection, "lock" );
   }
   if (kapp->authorize("logout"))
   {
       new TDEAction(i18n("Log Out \"%1\"...").arg(KUser().loginName()), "system-log-out", 0,
-                  this, TQT_SLOT( slotLogout() ), m_actionCollection, "logout" );
+                  this, TQ_SLOT( slotLogout() ), m_actionCollection, "logout" );
   }
 
   if (kapp->authorize("start_new_session") && DM().isSwitchable())
   {
       new TDEAction(i18n("Start New Session"), "fork", 0, this,
-                  TQT_SLOT( slotNewSession() ), m_actionCollection, "newsession" );
+                  TQ_SLOT( slotNewSession() ), m_actionCollection, "newsession" );
       if (kapp->authorize("lock_screen"))
       {
           new TDEAction(i18n("Lock Current && Start New Session"), "system-lock-screen", 0, this,
-                      TQT_SLOT( slotLockNNewSession() ), m_actionCollection, "lockNnewsession" );
+                      TQ_SLOT( slotLockNNewSession() ), m_actionCollection, "lockNnewsession" );
       }
   }
 
@@ -314,8 +314,8 @@ void KRootWm::buildMenus()
     if (m_actionCollection->action("newsession"))
     {
         sessionsMenu = new TQPopupMenu;
-        connect( sessionsMenu, TQT_SIGNAL(aboutToShow()), TQT_SLOT(slotPopulateSessions()) );
-        connect( sessionsMenu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSessionActivated(int)) );
+        connect( sessionsMenu, TQ_SIGNAL(aboutToShow()), TQ_SLOT(slotPopulateSessions()) );
+        connect( sessionsMenu, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSessionActivated(int)) );
     }
 
     if (menuBar) {
@@ -489,7 +489,7 @@ void KRootWm::buildMenus()
         desktopMenu->removeItem(lastSep);
     }
 
-    connect( desktopMenu, TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT( slotFileNewAboutToShow() ) );
+    connect( desktopMenu, TQ_SIGNAL( aboutToShow() ), this, TQ_SLOT( slotFileNewAboutToShow() ) );
 
     if (menuBar) {
         menuBar->insertItem(i18n("File"), file);
@@ -637,13 +637,13 @@ void KRootWm::slotWindowList() {
   else
       r = desktop->screenGeometry( desktop->screenNumber(TQCursor::pos()));
   windowListMenu->init();
-  disconnect( windowListMenu, TQT_SIGNAL( aboutToShow() ),
-           this, TQT_SLOT( slotWindowListAboutToShow() ) ); // avoid calling init() twice
+  disconnect( windowListMenu, TQ_SIGNAL( aboutToShow() ),
+           this, TQ_SLOT( slotWindowListAboutToShow() ) ); // avoid calling init() twice
   // windowListMenu->rect() is not valid before showing, use sizeHint()
   windowListMenu->popup(r.center() - TQRect( TQPoint( 0, 0 ), windowListMenu->sizeHint()).center());
   windowListMenu->selectActiveWindow(); // make the popup more useful
-  connect( windowListMenu, TQT_SIGNAL( aboutToShow() ),
-           this, TQT_SLOT( slotWindowListAboutToShow() ) );
+  connect( windowListMenu, TQ_SIGNAL( aboutToShow() ),
+           this, TQ_SLOT( slotWindowListAboutToShow() ) );
 }
 
 void KRootWm::slotSwitchUser() {
@@ -657,11 +657,11 @@ void KRootWm::slotSwitchUser() {
   else
       r = desktop->screenGeometry( desktop->screenNumber(TQCursor::pos()));
   slotPopulateSessions();
-  disconnect( sessionsMenu, TQT_SIGNAL( aboutToShow() ),
-           this, TQT_SLOT( slotPopulateSessions() ) ); // avoid calling init() twice
+  disconnect( sessionsMenu, TQ_SIGNAL( aboutToShow() ),
+           this, TQ_SLOT( slotPopulateSessions() ) ); // avoid calling init() twice
   sessionsMenu->popup(r.center() - TQRect( TQPoint( 0, 0 ), sessionsMenu->sizeHint()).center());
-  connect( sessionsMenu, TQT_SIGNAL( aboutToShow() ),
-           TQT_SLOT( slotPopulateSessions() ) );
+  connect( sessionsMenu, TQ_SIGNAL( aboutToShow() ),
+           TQ_SLOT( slotPopulateSessions() ) );
 }
 
 void KRootWm::slotArrangeByNameCS()
@@ -786,7 +786,7 @@ void KRootWm::slotConfigureDesktop() {
   if (!m_configDialog)
   {
     m_configDialog = new KCMultiDialog( (TQWidget*)0, "configureDialog" );
-    connect(m_configDialog, TQT_SIGNAL(finished()), this, TQT_SLOT(slotConfigClosed()));
+    connect(m_configDialog, TQ_SIGNAL(finished()), this, TQ_SLOT(slotConfigClosed()));
 
     TQStringList modules = configModules();
     for (TQStringList::const_iterator it = modules.constBegin(); it != modules.constEnd(); ++it)
diff --git a/kdesktop/kwebdesktop/kwebdesktop.cpp b/kdesktop/kwebdesktop/kwebdesktop.cpp
index 1e2499ea2..67a55192f 100644
--- a/kdesktop/kwebdesktop/kwebdesktop.cpp
+++ b/kdesktop/kwebdesktop/kwebdesktop.cpp
@@ -52,10 +52,10 @@ KWebDesktopRun::KWebDesktopRun( KWebDesktop* webDesktop, const KURL & url )
 {
     kdDebug() << "KWebDesktopRun::KWebDesktopRun starting get" << endl;
     TDEIO::Job * job = TDEIO::get(m_url, false, false);
-    connect( job, TQT_SIGNAL( result( TDEIO::Job *)),
-             this, TQT_SLOT( slotFinished(TDEIO::Job *)));
-    connect( job, TQT_SIGNAL( mimetype( TDEIO::Job *, const TQString &)),
-             this, TQT_SLOT( slotMimetype(TDEIO::Job *, const TQString &)));
+    connect( job, TQ_SIGNAL( result( TDEIO::Job *)),
+             this, TQ_SLOT( slotFinished(TDEIO::Job *)));
+    connect( job, TQ_SIGNAL( mimetype( TDEIO::Job *, const TQString &)),
+             this, TQ_SLOT( slotMimetype(TDEIO::Job *, const TQString &)));
 }
 
 void KWebDesktopRun::slotMimetype( TDEIO::Job *job, const TQString &_type )
@@ -166,7 +166,7 @@ KParts::ReadOnlyPart* KWebDesktop::createPart( const TQString& mimeType )
         ((TQScrollView *)htmlPart->widget())->setHScrollBarMode( TQScrollView::AlwaysOff );
         ((TQScrollView *)htmlPart->widget())->setVScrollBarMode( TQScrollView::AlwaysOff );
 
-        connect( htmlPart, TQT_SIGNAL( completed() ), this, TQT_SLOT( slotCompleted() ) );
+        connect( htmlPart, TQ_SIGNAL( completed() ), this, TQ_SLOT( slotCompleted() ) );
         m_part = htmlPart;
     } else {
         // Try to find an appropriate viewer component
@@ -176,13 +176,13 @@ KParts::ReadOnlyPart* KWebDesktop::createPart( const TQString& mimeType )
             kdWarning() << "No handler found for " << mimeType << endl;
         else {
             kdDebug() << "Loaded " << m_part->className() << endl;
-            connect( m_part, TQT_SIGNAL( completed() ),
-                     this, TQT_SLOT( slotCompleted() ) );
+            connect( m_part, TQ_SIGNAL( completed() ),
+                     this, TQ_SLOT( slotCompleted() ) );
         }
     }
     if ( m_part ) {
-        connect( m_part, TQT_SIGNAL( canceled(const TQString &) ),
-                 this, TQT_SLOT( slotCompleted() ) );
+        connect( m_part, TQ_SIGNAL( canceled(const TQString &) ),
+                 this, TQ_SLOT( slotCompleted() ) );
     }
     return m_part;
 }
diff --git a/kdesktop/lock/autologout.cpp b/kdesktop/lock/autologout.cpp
index 19c6d1e28..ee1d8e1db 100644
--- a/kdesktop/lock/autologout.cpp
+++ b/kdesktop/lock/autologout.cpp
@@ -83,7 +83,7 @@ AutoLogout::AutoLogout(LockProcess *parent) : TQDialog(parent, "password dialog"
 	
 	mCountdownTimerId = startTimer(1000/25);
 	
-	connect(tqApp, TQT_SIGNAL(activity()), TQT_SLOT(slotActivity()));
+	connect(tqApp, TQ_SIGNAL(activity()), TQ_SLOT(slotActivity()));
 	
 	setFixedSize( sizeHint() );
 }
diff --git a/kdesktop/lock/lockdlg.cpp b/kdesktop/lock/lockdlg.cpp
index 969dcb77a..c8d82e8d9 100644
--- a/kdesktop/lock/lockdlg.cpp
+++ b/kdesktop/lock/lockdlg.cpp
@@ -237,12 +237,12 @@ void PasswordDlg::init(GreeterPluginHandle *plugin)
 	}
 	setTabOrder( mNewSessButton, mLayoutButton );
 
-	connect(mLayoutButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(layoutClicked()));
+	connect(mLayoutButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(layoutClicked()));
 	if (show_cancel_button) {
-		connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));
+		connect(cancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
 	}
-	connect(ok, TQT_SIGNAL(clicked()), TQT_SLOT(slotOK()));
-	connect(mNewSessButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSwitchUser()));
+	connect(ok, TQ_SIGNAL(clicked()), TQ_SLOT(slotOK()));
+	connect(mNewSessButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSwitchUser()));
 
 	if (!DM().isSwitchable() || !kapp->authorize("switch_user")) {
 		mNewSessButton->hide();
@@ -253,7 +253,7 @@ void PasswordDlg::init(GreeterPluginHandle *plugin)
 
 	mFailedTimerId = 0;
 	mTimeoutTimerId = startTimer(PASSDLG_HIDE_TIMEOUT);
-	connect(tqApp, TQT_SIGNAL(activity()), TQT_SLOT(slotActivity()) );
+	connect(tqApp, TQ_SIGNAL(activity()), TQ_SLOT(slotActivity()) );
 
 	greet->setInfoMessageDisplay(showInfoMessages);
 	greet->start();
@@ -568,7 +568,7 @@ void PasswordDlg::handleVerify()
 						TQString autoPIN = cdevice->autoPIN();
 						if (autoPIN != TQString::null) {
 							greet->setPassword(autoPIN);
-							TQTimer::singleShot(0, this, SLOT(slotOK()));
+							TQTimer::singleShot(0, this, TQ_SLOT(slotOK()));
 						}
 					}
 					mCardLoginInProgress = false;
@@ -712,7 +712,7 @@ void PasswordDlg::gplugMsgBox( TQMessageBox::Icon type, const TQString &text )
 	KPushButton *button = new KPushButton( KStdGuiItem::ok(), winFrame );
 	button->setDefault( true );
 	button->setSizePolicy( TQSizePolicy( TQSizePolicy::Preferred, TQSizePolicy::Preferred ) );
-	connect( button, TQT_SIGNAL( clicked() ), TQT_SLOT( accept() ) );
+	connect( button, TQ_SIGNAL( clicked() ), TQ_SLOT( accept() ) );
 
 	TQGridLayout *grid = new TQGridLayout( winFrame, 2, 2, 10 );
 	grid->addWidget( label1, 0, 0, TQt::AlignCenter );
@@ -783,9 +783,9 @@ void PasswordDlg::slotStartNewSession()
 	TQLabel *label2 = new TQLabel( qt_text, winFrame );
 	KPushButton *okbutton = new KPushButton( KGuiItem(i18n("&Start New Session"), "fork"), winFrame );
 	okbutton->setDefault( true );
-	connect( okbutton, TQT_SIGNAL( clicked() ), dialog, TQT_SLOT( accept() ) );
+	connect( okbutton, TQ_SIGNAL( clicked() ), dialog, TQ_SLOT( accept() ) );
 	KPushButton *cbutton = new KPushButton( KStdGuiItem::cancel(), winFrame );
-	connect( cbutton, TQT_SIGNAL( clicked() ), dialog, TQT_SLOT( reject() ) );
+	connect( cbutton, TQ_SIGNAL( clicked() ), dialog, TQ_SLOT( reject() ) );
 
 	TQBoxLayout *mbox = new TQVBoxLayout( winFrame, KDialog::marginHint(), KDialog::spacingHint() );
 
@@ -901,8 +901,8 @@ void PasswordDlg::slotSwitchUser()
 	SessList sess;
 	if (dm.localSessions( sess )) {
 		lv = new TQListView( winFrame );
-		connect( lv, TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint&, int)), TQT_SLOT(slotSessionActivated()) );
-		connect( lv, TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint&, int)), &dialog, TQT_SLOT(accept()) );
+		connect( lv, TQ_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint&, int)), TQ_SLOT(slotSessionActivated()) );
+		connect( lv, TQ_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint&, int)), &dialog, TQ_SLOT(accept()) );
 		lv->setAllColumnsShowFocus( true );
 		lv->addColumn( i18n("Session") );
 		lv->addColumn( i18n("Location") );
@@ -933,16 +933,16 @@ void PasswordDlg::slotSwitchUser()
 		vbox1->addWidget( lv );
 
 		btn = new KPushButton( KGuiItem(i18n("session", "&Activate"), "fork"), winFrame );
-		connect( btn, TQT_SIGNAL(clicked()), TQT_SLOT(slotSessionActivated()) );
-		connect( btn, TQT_SIGNAL(clicked()), &dialog, TQT_SLOT(accept()) );
+		connect( btn, TQ_SIGNAL(clicked()), TQ_SLOT(slotSessionActivated()) );
+		connect( btn, TQ_SIGNAL(clicked()), &dialog, TQ_SLOT(accept()) );
 		vbox2->addWidget( btn );
 		vbox2->addStretch( 2 );
 	}
 
 	if (kapp->authorize("start_new_session") && (p = dm.numReserve()) >= 0) {
 		btn = new KPushButton( KGuiItem(i18n("Start &New Session"), "fork"), winFrame );
-		connect( btn, TQT_SIGNAL(clicked()), TQT_SLOT(slotStartNewSession()) );
-		connect( btn, TQT_SIGNAL(clicked()), &dialog, TQT_SLOT(accept()) );
+		connect( btn, TQ_SIGNAL(clicked()), TQ_SLOT(slotStartNewSession()) );
+		connect( btn, TQ_SIGNAL(clicked()), &dialog, TQ_SLOT(accept()) );
 		if (!p)
 		btn->setEnabled( false );
 		vbox2->addWidget( btn );
@@ -950,7 +950,7 @@ void PasswordDlg::slotSwitchUser()
 	}
 
 	btn = new KPushButton( KStdGuiItem::cancel(), winFrame );
-	connect( btn, TQT_SIGNAL(clicked()), &dialog, TQT_SLOT(reject()) );
+	connect( btn, TQ_SIGNAL(clicked()), &dialog, TQ_SLOT(reject()) );
 	vbox2->addWidget( btn );
 
 	dialog.setFixedSize( dialog.sizeHint() );
@@ -1015,7 +1015,7 @@ void PasswordDlg::attemptCardLogin() {
 	// Bypass initial password prompt
 	greet->start();
 	greet->setPassword("");
-	TQTimer::singleShot(0, this, SLOT(slotOK()));
+	TQTimer::singleShot(0, this, TQ_SLOT(slotOK()));
 #endif
 }
 
diff --git a/kdesktop/lock/lockprocess.cpp b/kdesktop/lock/lockprocess.cpp
index f493649f1..0a343d88e 100644
--- a/kdesktop/lock/lockprocess.cpp
+++ b/kdesktop/lock/lockprocess.cpp
@@ -256,7 +256,7 @@ LockProcess::LockProcess()
 	if (!argb_visual) {
 		// Try to get the root pixmap
 		if (!m_rootPixmap) m_rootPixmap = new KRootPixmap(this);
-		connect(m_rootPixmap, TQT_SIGNAL(backgroundUpdated(const TQPixmap &)), this, TQT_SLOT(slotPaintBackground(const TQPixmap &)));
+		connect(m_rootPixmap, TQ_SIGNAL(backgroundUpdated(const TQPixmap &)), this, TQ_SLOT(slotPaintBackground(const TQPixmap &)));
 		m_rootPixmap->setCustomPainting(true);
 		m_rootPixmap->start();
 	}
@@ -305,9 +305,9 @@ LockProcess::LockProcess()
 	TDEGenericHardwareList cardReaderList = hwdevices->listByDeviceClass(TDEGenericDeviceType::CryptographicCard);
 	for (hwdevice = cardReaderList.first(); hwdevice; hwdevice = cardReaderList.next()) {
 		TDECryptographicCardDevice* cdevice = static_cast<TDECryptographicCardDevice*>(hwdevice);
-		// connect(cdevice, SIGNAL(pinRequested(TQString,TDECryptographicCardDevice*)), this, SLOT(cryptographicCardPinRequested(TQString,TDECryptographicCardDevice*)));
-		connect(cdevice, TQT_SIGNAL(certificateListAvailable(TDECryptographicCardDevice*)), this, TQT_SLOT(cryptographicCardInserted(TDECryptographicCardDevice*)));
-		connect(cdevice, TQT_SIGNAL(cardRemoved(TDECryptographicCardDevice*)), this, TQT_SLOT(cryptographicCardRemoved(TDECryptographicCardDevice*)));
+		// connect(cdevice, TQ_SIGNAL(pinRequested(TQString,TDECryptographicCardDevice*)), this, TQ_SLOT(cryptographicCardPinRequested(TQString,TDECryptographicCardDevice*)));
+		connect(cdevice, TQ_SIGNAL(certificateListAvailable(TDECryptographicCardDevice*)), this, TQ_SLOT(cryptographicCardInserted(TDECryptographicCardDevice*)));
+		connect(cdevice, TQ_SIGNAL(cardRemoved(TDECryptographicCardDevice*)), this, TQ_SLOT(cryptographicCardRemoved(TDECryptographicCardDevice*)));
 		cdevice->enableCardMonitoring(true);
 		// cdevice->enablePINEntryCallbacks(true);
 	}
@@ -388,12 +388,12 @@ void LockProcess::init(bool child, bool useBlankOnly)
 	generateBackingImages();
 
 	// Connect all signals
-	connect( mForceContinualLockDisplayTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(displayLockDialogIfNeeded()) );
-	connect( mHackDelayStartupTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(closeDialogAndStartHack()) );
-	connect( mEnsureVRootWindowSecurityTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(repaintRootWindowIfNeeded()) );
-	connect(tqApp, TQT_SIGNAL(mouseInteraction(XEvent *)), TQT_SLOT(slotMouseActivity(XEvent *)));
-	connect(&mHackProc, TQT_SIGNAL(processExited(TDEProcess *)), TQT_SLOT(hackExited(TDEProcess *)));
-	connect(&mSuspendTimer, TQT_SIGNAL(timeout()), TQT_SLOT(suspend()));
+	connect( mForceContinualLockDisplayTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(displayLockDialogIfNeeded()) );
+	connect( mHackDelayStartupTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(closeDialogAndStartHack()) );
+	connect( mEnsureVRootWindowSecurityTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(repaintRootWindowIfNeeded()) );
+	connect(tqApp, TQ_SIGNAL(mouseInteraction(XEvent *)), TQ_SLOT(slotMouseActivity(XEvent *)));
+	connect(&mHackProc, TQ_SIGNAL(processExited(TDEProcess *)), TQ_SLOT(hackExited(TDEProcess *)));
+	connect(&mSuspendTimer, TQ_SIGNAL(timeout()), TQ_SLOT(suspend()));
 
 #ifdef HAVE_DPMS
 	//if the user decided that the screensaver should run independent from
@@ -403,7 +403,7 @@ void LockProcess::init(bool child, bool useBlankOnly)
 		CARD16 state;
 		if (DPMSInfo(tqt_xdisplay(), &state, &on)) {
 			if (on) {
-				connect(&mCheckDPMS, TQT_SIGNAL(timeout()), TQT_SLOT(checkDPMSActive()));
+				connect(&mCheckDPMS, TQ_SIGNAL(timeout()), TQ_SLOT(checkDPMSActive()));
 				// we can save CPU if we stop it as quickly as possible
 				// but we waste CPU if we check too often -> so take 10s
 				mCheckDPMS.start(10000);
@@ -413,7 +413,7 @@ void LockProcess::init(bool child, bool useBlankOnly)
 #endif
 
 #if (TQT_VERSION-0 >= 0x030200) // XRANDR support
-	connect( kapp->desktop(), TQT_SIGNAL( resized( int )), TQT_SLOT( desktopResized()));
+	connect( kapp->desktop(), TQ_SIGNAL( resized( int )), TQ_SLOT( desktopResized()));
 #endif
 
 	if (!trinity_desktop_lock_use_system_modal_dialogs) {
@@ -435,8 +435,8 @@ void LockProcess::init(bool child, bool useBlankOnly)
 	mControlPipeHandler = new ControlPipeHandlerObject();
 	mControlPipeHandler->mParent = this;
 	mControlPipeHandler->moveToThread(mControlPipeHandlerThread);
-	TQObject::connect(mControlPipeHandler, SIGNAL(processCommand(TQString)), this, SLOT(processInputPipeCommand(TQString)));
-	TQTimer::singleShot(0, mControlPipeHandler, SLOT(run()));
+	TQObject::connect(mControlPipeHandler, TQ_SIGNAL(processCommand(TQString)), this, TQ_SLOT(processInputPipeCommand(TQString)));
+	TQTimer::singleShot(0, mControlPipeHandler, TQ_SLOT(run()));
 	mControlPipeHandlerThread->start();
 }
 
@@ -534,7 +534,7 @@ void LockProcess::setupSignals()
 		// Error handler to shut up gcc warnings
 	}
 	TQSocketNotifier* notif = new TQSocketNotifier(signal_pipe[0], TQSocketNotifier::Read, this );
-	connect( notif, TQT_SIGNAL(activated(int)), TQT_SLOT(signalPipeSignal()));
+	connect( notif, TQ_SIGNAL(activated(int)), TQ_SLOT(signalPipeSignal()));
 }
 
 
@@ -577,7 +577,7 @@ bool LockProcess::lock()
 		// selecting "lock screen", that looks really untidy.
 		mBusy = true;
 		if (startLock()) {
-			TQTimer::singleShot(1000, this, TQT_SLOT(slotDeadTimePassed()));
+			TQTimer::singleShot(1000, this, TQ_SLOT(slotDeadTimePassed()));
 			return true;
 		}
 		stopSaver();
@@ -598,7 +598,7 @@ bool LockProcess::defaultSave()
 	mOverrideHackStartupEnabled = true;
 	if (startSaver()) {
 		if (mLockGrace >= 0) {
-			TQTimer::singleShot(mLockGrace, this, TQT_SLOT(startLock()));
+			TQTimer::singleShot(mLockGrace, this, TQ_SLOT(startLock()));
 		}
 		return true;
 	}
@@ -618,7 +618,7 @@ void LockProcess::quitSaver()
 {
 	DISABLE_CONTINUOUS_LOCKDLG_DISPLAY
 	if (closeCurrentWindow()) {
-		TQTimer::singleShot( 0, this, SLOT(quitSaver()) );
+		TQTimer::singleShot( 0, this, TQ_SLOT(quitSaver()) );
 		return;
 	}
 	stopSaver();
@@ -629,7 +629,7 @@ void LockProcess::quitSaver()
 void LockProcess::startSecureDialog()
 {
 	if ((backingPixmap.isNull()) && (mBackingStartupDelayTimer < 100)) {
-		TQTimer::singleShot(10, this, TQT_SLOT(startSecureDialog()));
+		TQTimer::singleShot(10, this, TQ_SLOT(startSecureDialog()));
 		mBackingStartupDelayTimer++;
 		return;
 	}
@@ -668,7 +668,7 @@ void LockProcess::startSecureDialog()
 				mBusy = false;
 			}
 			else {
-				TQTimer::singleShot(1000, this, TQT_SLOT(slotDeadTimePassed()));
+				TQTimer::singleShot(1000, this, TQ_SLOT(slotDeadTimePassed()));
 			}
 			if (trinity_desktop_lock_delay_screensaver_start && trinity_desktop_lock_forced && trinity_desktop_lock_use_system_modal_dialogs) {
 				ENABLE_CONTINUOUS_LOCKDLG_DISPLAY
@@ -728,7 +728,7 @@ bool LockProcess::runSecureDialog()
 	mInSecureDialog = true;
 	if (startSaver()) {
 		mBackingStartupDelayTimer = 0;
-		TQTimer::singleShot(0, this, TQT_SLOT(startSecureDialog()));
+		TQTimer::singleShot(0, this, TQ_SLOT(startSecureDialog()));
 		return true;
 	}
 	else {
@@ -1040,7 +1040,7 @@ void LockProcess::desktopResized()
 		}
 		else {
 			mEnsureScreenHiddenTimer = new TQTimer( this );
-			connect( mEnsureScreenHiddenTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotForcePaintBackground()) );
+			connect( mEnsureScreenHiddenTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotForcePaintBackground()) );
 		}
 		mEnsureScreenHiddenTimer->start(DESKTOP_WALLPAPER_OBTAIN_TIMEOUT_MS, true);
 	}
@@ -1063,7 +1063,7 @@ void LockProcess::desktopResized()
 	// being displayed, so we finish the hack restarting/display prettying operations in a separate timed slot
 	if (resizeTimer == NULL) {
 		resizeTimer = new TQTimer( this );
-		connect( resizeTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(doDesktopResizeFinish()) );
+		connect( resizeTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(doDesktopResizeFinish()) );
 	}
 	resizeTimer->start( 100, TRUE ); // 100 millisecond single shot timer; should allow display switching operations to finish before hack is started
 }
@@ -1075,7 +1075,7 @@ void LockProcess::doDesktopResizeFinish()
 	}
 	mDialogControlLock = true;
 	if (closeCurrentWindow()) {
-		TQTimer::singleShot( 0, this, SLOT(doDesktopResizeFinish()) );
+		TQTimer::singleShot( 0, this, TQ_SLOT(doDesktopResizeFinish()) );
 		mDialogControlLock = false;
 		return;
 	}
@@ -1354,7 +1354,7 @@ bool LockProcess::startSaver(bool notify_ready)
 
 	if (mParent) {
 		TQSocketNotifier *notifier = new TQSocketNotifier(mParent, TQSocketNotifier::Read, this, "notifier");
-		connect(notifier, TQT_SIGNAL( activated (int)), TQT_SLOT( quitSaver()));
+		connect(notifier, TQ_SIGNAL( activated (int)), TQ_SLOT( quitSaver()));
 	}
 	createSaverWindow();
 	move(0, 0);
@@ -1542,7 +1542,7 @@ void LockProcess::closeDialogAndStartHack()
 	DISABLE_CONTINUOUS_LOCKDLG_DISPLAY
 	mSuspended = true;
 	if (closeCurrentWindow()) {
-		TQTimer::singleShot( 0, this, SLOT(closeDialogAndStartHack()) );
+		TQTimer::singleShot( 0, this, TQ_SLOT(closeDialogAndStartHack()) );
 	}
 	else {
 		resume(true);
@@ -1669,7 +1669,7 @@ bool LockProcess::startHack()
 				if (trinity_desktop_lock_delay_screensaver_start && trinity_desktop_lock_forced) {
 					// Close any active dialogs
 					if (closeCurrentWindow()) {
-						TQTimer::singleShot( 0, this, SLOT(closeCurrentWindow()) );
+						TQTimer::singleShot( 0, this, TQ_SLOT(closeCurrentWindow()) );
 					}
 				}
 				if (m_startupStatusDialog) { m_startupStatusDialog->closeSMDialog(); m_startupStatusDialog=NULL; }
@@ -2026,7 +2026,7 @@ int LockProcess::execDialog( TQDialog *dlg )
 			// Slight delay before screensaver resume to allow the dialog window to fully disappear
 			if (hackResumeTimer == NULL) {
 				hackResumeTimer = new TQTimer( this );
-				connect( hackResumeTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(resumeUnforced()) );
+				connect( hackResumeTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(resumeUnforced()) );
 			}
 			if (mResizingDesktopLock == false) {
 				hackResumeTimer->start( 10, TRUE );
@@ -2065,7 +2065,7 @@ void LockProcess::slotPaintBackground(const TQPixmap &rpm)
 	}
 	else {
 		mEnsureScreenHiddenTimer = new TQTimer( this );
-		connect( mEnsureScreenHiddenTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotForcePaintBackground()) );
+		connect( mEnsureScreenHiddenTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotForcePaintBackground()) );
 	}
 
 	// Only remove the mask widget once the resize is 100% complete!
@@ -2127,7 +2127,7 @@ void LockProcess::doFunctionKeyBroadcast() {
 	// This does NOT work with the SAK or system modal dialogs!
 	if ((!trinity_desktop_lock_use_system_modal_dialogs) && (!trinity_desktop_lock_use_sak)) {
 		mBusy=true;
-		TQTimer::singleShot(1000, this, TQT_SLOT(slotDeadTimePassed()));
+		TQTimer::singleShot(1000, this, TQ_SLOT(slotDeadTimePassed()));
 		if (mkeyCode == XKeysymToKeycode(tqt_xdisplay(), XF86XK_Display)) {
 			while (mDialogControlLock == true) {
 				usleep(100000);
@@ -2167,7 +2167,7 @@ bool LockProcess::x11Event(XEvent *event)
 			(event->xkey.keycode == XKeysymToKeycode(event->xkey.display, XF86XK_AudioRaiseVolume)) || \
 			(event->xkey.keycode == XKeysymToKeycode(event->xkey.display, XF86XK_AudioLowerVolume))) {
 			mkeyCode = event->xkey.keycode;
-			TQTimer::singleShot( 100, this, TQT_SLOT(doFunctionKeyBroadcast()) );
+			TQTimer::singleShot( 100, this, TQ_SLOT(doFunctionKeyBroadcast()) );
 			return true;
 		}
 		// ACPI power keys
@@ -2176,7 +2176,7 @@ bool LockProcess::x11Event(XEvent *event)
 			(event->xkey.keycode == XKeysymToKeycode(event->xkey.display, XF86XK_Suspend)) || \
 			(event->xkey.keycode == XKeysymToKeycode(event->xkey.display, XF86XK_Hibernate))) {
 			mkeyCode = event->xkey.keycode;
-			TQTimer::singleShot( 100, this, TQT_SLOT(doFunctionKeyBroadcast()) );
+			TQTimer::singleShot( 100, this, TQ_SLOT(doFunctionKeyBroadcast()) );
 			return true;
 		}
 	}
@@ -2442,7 +2442,7 @@ void LockProcess::msgBox( TQMessageBox::Icon type, const TQString &txt )
 	KPushButton *button = new KPushButton( KStdGuiItem::ok(), winFrame );
 	button->setDefault( true );
 	button->setSizePolicy( TQSizePolicy( TQSizePolicy::Preferred, TQSizePolicy::Preferred ) );
-	connect( button, TQT_SIGNAL( clicked() ), &box, TQT_SLOT( accept() ) );
+	connect( button, TQ_SIGNAL( clicked() ), &box, TQ_SLOT( accept() ) );
 
 	TQVBoxLayout *vbox = new TQVBoxLayout( &box );
 	vbox->addWidget( winFrame );
@@ -2464,7 +2464,7 @@ void LockProcess::showVkbd()
 		mVkbdWindows.clear();
 		mVkbdLastEventWindow = None;
 		mKWinModule = new KWinModule( NULL, KWinModule::INFO_WINDOWS );
-		connect( mKWinModule, TQT_SIGNAL( windowAdded( WId )), TQT_SLOT( windowAdded( WId )));
+		connect( mKWinModule, TQ_SIGNAL( windowAdded( WId )), TQ_SLOT( windowAdded( WId )));
 		mVkbdProcess = new TDEProcess;
 		*mVkbdProcess << "xvkbd" << "-compact" << "-geometry" << "-0-0" << "-xdm";
 		mVkbdProcess->start();
@@ -2849,11 +2849,11 @@ void LockProcess::cryptographicCardInserted(TDECryptographicCardDevice* cdevice)
 			m_loginCardDevice = cdevice;
 			if (dynamic_cast<SAKDlg*>(currentDialog)) {
 				dynamic_cast<SAKDlg*>(currentDialog)->closeDialogForced();
-				TQTimer::singleShot(0, this, SLOT(signalPassDlgToAttemptCardLogin()));
+				TQTimer::singleShot(0, this, TQ_SLOT(signalPassDlgToAttemptCardLogin()));
 			}
 			else if (dynamic_cast<SecureDlg*>(currentDialog)) {
 				dynamic_cast<SecureDlg*>(currentDialog)->closeDialogForced();
-				TQTimer::singleShot(0, this, SLOT(signalPassDlgToAttemptCardLogin()));
+				TQTimer::singleShot(0, this, TQ_SLOT(signalPassDlgToAttemptCardLogin()));
 			}
 			else if (dynamic_cast<PasswordDlg*>(currentDialog)) {
 				signalPassDlgToAttemptCardLogin();
@@ -2871,7 +2871,7 @@ void LockProcess::cryptographicCardRemoved(TDECryptographicCardDevice* cdevice)
 	}
 	else {
 		m_loginCardDevice = NULL;
-		TQTimer::singleShot(0, this, SLOT(signalPassDlgToAttemptCardAbort()));
+		TQTimer::singleShot(0, this, TQ_SLOT(signalPassDlgToAttemptCardAbort()));
 	}
 #endif
 }
@@ -2886,7 +2886,7 @@ void LockProcess::signalPassDlgToAttemptCardLogin()
 	else {
 		if (currentDialog && m_loginCardDevice) {
 			// Try again later
-			TQTimer::singleShot(0, this, SLOT(signalPassDlgToAttemptCardLogin()));
+			TQTimer::singleShot(0, this, TQ_SLOT(signalPassDlgToAttemptCardLogin()));
 		}
 	}
 #endif
@@ -2902,7 +2902,7 @@ void LockProcess::signalPassDlgToAttemptCardAbort()
 	else {
 		if (currentDialog) {
 			// Try again later
-			TQTimer::singleShot(0, this, SLOT(signalPassDlgToAttemptCardAbort()));
+			TQTimer::singleShot(0, this, TQ_SLOT(signalPassDlgToAttemptCardAbort()));
 		}
 	}
 #endif
diff --git a/kdesktop/lock/querydlg.cpp b/kdesktop/lock/querydlg.cpp
index 9d594ecba..edab1fd97 100644
--- a/kdesktop/lock/querydlg.cpp
+++ b/kdesktop/lock/querydlg.cpp
@@ -117,7 +117,7 @@ QueryDlg::QueryDlg(LockProcess *parent)
 	frameLayout->addMultiCellWidget( sep, 3, 3, 0, 1 );
 	frameLayout->addMultiCellLayout( layButtons, 4, 4, 0, 1 );
 
-	connect(ok, TQT_SIGNAL(clicked()), TQT_SLOT(slotOK()));
+	connect(ok, TQ_SIGNAL(clicked()), TQ_SLOT(slotOK()));
 
 	installEventFilter(this);
 	setFixedSize( sizeHint() );
diff --git a/kdesktop/lock/sakdlg.cpp b/kdesktop/lock/sakdlg.cpp
index 274826e69..a9bb25f40 100644
--- a/kdesktop/lock/sakdlg.cpp
+++ b/kdesktop/lock/sakdlg.cpp
@@ -108,7 +108,7 @@ SAKDlg::SAKDlg(LockProcess *parent)
 
 	mSAKProcess = new TDEProcess;
 	*mSAKProcess << "tdmtsak";
-	connect(mSAKProcess, TQT_SIGNAL(processExited(TDEProcess*)), this, TQT_SLOT(slotSAKProcessExited()));
+	connect(mSAKProcess, TQ_SIGNAL(processExited(TDEProcess*)), this, TQ_SLOT(slotSAKProcessExited()));
 	mSAKProcess->start();
 }
 
diff --git a/kdesktop/lock/securedlg.cpp b/kdesktop/lock/securedlg.cpp
index fca79a707..5be274660 100644
--- a/kdesktop/lock/securedlg.cpp
+++ b/kdesktop/lock/securedlg.cpp
@@ -137,11 +137,11 @@ SecureDlg::SecureDlg(LockProcess *parent)
 	frameLayout->addMultiCellWidget( sep, 2, 2, 0, 1 );
 	frameLayout->addMultiCellLayout( layPBGrid, 3, 3, 0, 1, AlignLeft | AlignVCenter);
 
-	connect(mCancelButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotBtnCancel()));
-	connect(mLockButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotBtnLock()));
-	connect(mTaskButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotBtnTask()));
-	connect(mShutdownButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotBtnShutdown()));
-	connect(mSwitchButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotBtnSwitchUser()));
+	connect(mCancelButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotBtnCancel()));
+	connect(mLockButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotBtnLock()));
+	connect(mTaskButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotBtnTask()));
+	connect(mShutdownButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotBtnShutdown()));
+	connect(mSwitchButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotBtnSwitchUser()));
 
 	TQSize dlgSz = sizeHint();
 	int btnSize = dlgSz.width();
diff --git a/kdesktop/lockeng.cpp b/kdesktop/lockeng.cpp
index 5e32fd0f6..e22fc4c7a 100644
--- a/kdesktop/lockeng.cpp
+++ b/kdesktop/lockeng.cpp
@@ -134,12 +134,12 @@ SaverEngine::SaverEngine()
 	m_helperThread->start();
 	m_threadHelperObject = new SaverEngineThreadHelperObject;
 	m_threadHelperObject->moveToThread(m_helperThread);
-	connect(this, TQT_SIGNAL(terminateHelperThread()), m_threadHelperObject, TQT_SLOT(terminateThread()));
-	connect(m_threadHelperObject, TQT_SIGNAL(lockProcessWaiting()), this, TQT_SLOT(lockProcessWaiting()));
-	connect(m_threadHelperObject, TQT_SIGNAL(lockProcessFullyActivated()), this, TQT_SLOT(lockProcessFullyActivated()));
+	connect(this, TQ_SIGNAL(terminateHelperThread()), m_threadHelperObject, TQ_SLOT(terminateThread()));
+	connect(m_threadHelperObject, TQ_SIGNAL(lockProcessWaiting()), this, TQ_SLOT(lockProcessWaiting()));
+	connect(m_threadHelperObject, TQ_SIGNAL(lockProcessFullyActivated()), this, TQ_SLOT(lockProcessFullyActivated()));
 
-	connect(&mLockProcess, TQT_SIGNAL(processExited(TDEProcess *)),
-						TQT_SLOT(lockProcessExited()));
+	connect(&mLockProcess, TQ_SIGNAL(processExited(TDEProcess *)),
+						TQ_SLOT(lockProcessExited()));
 
 	configure();
 
@@ -160,8 +160,8 @@ SaverEngine::SaverEngine()
 	if (useSAKProcess) {
 		mSAKProcess = new TDEProcess;
 		*mSAKProcess << "tdmtsak";
-		connect(mSAKProcess, TQT_SIGNAL(processExited(TDEProcess*)), this, TQT_SLOT(slotSAKProcessExited()));
-		TQTimer::singleShot( 0, this, TQT_SLOT(handleSecureDialog()) );
+		connect(mSAKProcess, TQ_SIGNAL(processExited(TDEProcess*)), this, TQ_SLOT(slotSAKProcessExited()));
+		TQTimer::singleShot( 0, this, TQ_SLOT(handleSecureDialog()) );
 	}
 
 	mLockProcess.clearArguments();
@@ -207,8 +207,8 @@ SaverEngine::SaverEngine()
 	TDEGenericHardwareList cardReaderList = hwdevices->listByDeviceClass(TDEGenericDeviceType::CryptographicCard);
 	for (hwdevice = cardReaderList.first(); hwdevice; hwdevice = cardReaderList.next()) {
 		TDECryptographicCardDevice* cdevice = static_cast<TDECryptographicCardDevice*>(hwdevice);
-		connect(cdevice, TQT_SIGNAL(certificateListAvailable(TDECryptographicCardDevice*)), this, TQT_SLOT(cryptographicCardInserted(TDECryptographicCardDevice*)));
-		connect(cdevice, TQT_SIGNAL(cardRemoved(TDECryptographicCardDevice*)), this, TQT_SLOT(cryptographicCardRemoved(TDECryptographicCardDevice*)));
+		connect(cdevice, TQ_SIGNAL(certificateListAvailable(TDECryptographicCardDevice*)), this, TQ_SLOT(cryptographicCardInserted(TDECryptographicCardDevice*)));
+		connect(cdevice, TQ_SIGNAL(cardRemoved(TDECryptographicCardDevice*)), this, TQ_SLOT(cryptographicCardRemoved(TDECryptographicCardDevice*)));
 		cdevice->enableCardMonitoring(true);
 	}
 
@@ -220,7 +220,7 @@ SaverEngine::SaverEngine()
 		TQTextStream stream(&flagFile);
 		if (stream.readLine().startsWith("1")) {
 			// Card was likely used to log in
-			TQTimer::singleShot(5000, this, SLOT(cardStartupTimeout()));
+			TQTimer::singleShot(5000, this, TQ_SLOT(cardStartupTimeout()));
 		}
 		flagFile.close();
 	}
@@ -409,7 +409,7 @@ bool SaverEngine::enable( bool e )
 	if (mEnabled) {
 		if ( !mXAutoLock ) {
 			mXAutoLock = new XAutoLock();
-			connect(mXAutoLock, TQT_SIGNAL(timeout()), TQT_SLOT(idleTimeout()));
+			connect(mXAutoLock, TQ_SIGNAL(timeout()), TQ_SLOT(idleTimeout()));
 		}
 		mXAutoLock->setTimeout(mTimeout);
 		mXAutoLock->setDPMS(true);
@@ -702,7 +702,7 @@ void SaverEngine::lockProcessExited()
 		// PROBABLE HACKING ATTEMPT DETECTED
 		restartDesktopLockProcess();
 		mState = Waiting;
-		TQTimer::singleShot( 100, this, SLOT(recoverFromHackingAttempt()) );
+		TQTimer::singleShot( 100, this, TQ_SLOT(recoverFromHackingAttempt()) );
 	}
 	else {
 		// Restart the lock process
@@ -849,19 +849,19 @@ bool SaverEngine::dBusConnect() {
 	dBusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus, DBUS_CONN_NAME);
 	if( !dBusConn.isConnected() ) {
 		kdError() << "Failed to open connection to system message bus: " << dBusConn.lastError().message() << endl;
-		TQTimer::singleShot(4000, this, TQT_SLOT(dBusReconnect()));
+		TQTimer::singleShot(4000, this, TQ_SLOT(dBusReconnect()));
 		return false;
 	}
 
 	// watcher for Disconnect signal
 	dBusLocal = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_LOCAL, DBUS_INTERFACE_LOCAL, dBusConn);
-	TQObject::connect(dBusLocal, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
-			  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
+	TQObject::connect(dBusLocal, TQ_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
+			  this, TQ_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
 
 	// watcher for NameOwnerChanged signals
 	dBusWatch = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
-	TQObject::connect(dBusWatch, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
-			  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
+	TQObject::connect(dBusWatch, TQ_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
+			  this, TQ_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
 
 	// find already running SystemD
 	TQT_DBusProxy checkSystemD(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
@@ -895,8 +895,8 @@ void SaverEngine::onDBusServiceRegistered(const TQString& service) {
 		// wather for systemd session signals
 		if( systemdSessionPath.isValid() ) {
 			systemdSession = new TQT_DBusProxy(SYSTEMD_LOGIN1_SERVICE, systemdSessionPath, SYSTEMD_LOGIN1_SESSION_IFACE, dBusConn);
-			TQObject::connect(systemdSession, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
-					  this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
+			TQObject::connect(systemdSession, TQ_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
+					  this, TQ_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
 		}
 		return;
 	}
@@ -924,7 +924,7 @@ void SaverEngine::handleDBusSignal(const TQT_DBusMessage& msg) {
 	 && msg.interface() == DBUS_INTERFACE_LOCAL
 	 && msg.member() == "Disconnected" ) {
 		dBusClose();
-		TQTimer::singleShot(1000, this, TQT_SLOT(dBusReconnect()));
+		TQTimer::singleShot(1000, this, TQ_SLOT(dBusReconnect()));
 		return;
 	}
 
diff --git a/kdesktop/minicli.cpp b/kdesktop/minicli.cpp
index da4d18d30..1192a0292 100644
--- a/kdesktop/minicli.cpp
+++ b/kdesktop/minicli.cpp
@@ -131,34 +131,34 @@ Minicli::Minicli( TQWidget *parent, const char *name)
   m_pURLCompletion = new KURLCompletion(KURLCompletion::FileCompletion);
   m_pEXECompletion = new KURLCompletion(KURLCompletion::SystemExeCompletion);
   //m_pURLCompletion->setCompletionMode( TDEGlobalSettings::completionMode() );
-  connect( m_pURLCompletion, TQT_SIGNAL( match(const TQString&) ), TQT_SLOT( slotMatch(const TQString&) ));
-  connect( m_pEXECompletion, TQT_SIGNAL( match(const TQString&) ), TQT_SLOT( slotEXEMatch(const TQString&) ));
+  connect( m_pURLCompletion, TQ_SIGNAL( match(const TQString&) ), TQ_SLOT( slotMatch(const TQString&) ));
+  connect( m_pEXECompletion, TQ_SIGNAL( match(const TQString&) ), TQ_SLOT( slotEXEMatch(const TQString&) ));
 
   // Main widget buttons...
-  connect( m_dlg->pbRun, TQT_SIGNAL(clicked()), this, TQT_SLOT(accept()) );
-  connect( m_dlg->pbCancel, TQT_SIGNAL(clicked()), this, TQT_SLOT(reject()) );
-  connect( m_dlg->pbOptions, TQT_SIGNAL(clicked()), TQT_SLOT(slotAdvanced()) );
-  connect( m_parseTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotParseTimer()) );
+  connect( m_dlg->pbRun, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()) );
+  connect( m_dlg->pbCancel, TQ_SIGNAL(clicked()), this, TQ_SLOT(reject()) );
+  connect( m_dlg->pbOptions, TQ_SIGNAL(clicked()), TQ_SLOT(slotAdvanced()) );
+  connect( m_parseTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotParseTimer()) );
 
-  connect( m_dlg->cbCommand, TQT_SIGNAL( textChanged( const TQString& ) ),
-           TQT_SLOT( slotCmdChanged(const TQString&) ) );
+  connect( m_dlg->cbCommand, TQ_SIGNAL( textChanged( const TQString& ) ),
+           TQ_SLOT( slotCmdChanged(const TQString&) ) );
 
-  connect( m_dlg->cbCommand, TQT_SIGNAL( returnPressed() ),
-           m_dlg->pbRun, TQT_SLOT( animateClick() ) );
+  connect( m_dlg->cbCommand, TQ_SIGNAL( returnPressed() ),
+           m_dlg->pbRun, TQ_SLOT( animateClick() ) );
 
   m_dlg->cbCommand->setHistoryEditorEnabled( true );
-  connect( m_dlg->cbCommand, TQT_SIGNAL(removed( const TQString&) ), TQT_SLOT(saveConfig()) );
+  connect( m_dlg->cbCommand, TQ_SIGNAL(removed( const TQString&) ), TQ_SLOT(saveConfig()) );
 
   // Advanced group box...
-  connect(m_dlg->cbPriority, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotChangeScheduler(bool)));
-  connect(m_dlg->slPriority, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotPriority(int)));
-  connect(m_dlg->cbRealtime, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotRealtime(bool)));
-  connect(m_dlg->cbAppcomplete, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAppcompleteToggled(bool)));
-  connect(m_dlg->cbAutocomplete, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAutocompleteToggled(bool)));
-  connect(m_dlg->cbAutohistory, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAutohistoryToggled(bool)));
-  connect(m_dlg->cbRunAsOther, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotChangeUid(bool)));
-  connect(m_dlg->leUsername, TQT_SIGNAL(lostFocus()), TQT_SLOT(updateAuthLabel()));
-  connect(m_dlg->cbRunInTerminal, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotTerminal(bool)));
+  connect(m_dlg->cbPriority, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotChangeScheduler(bool)));
+  connect(m_dlg->slPriority, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotPriority(int)));
+  connect(m_dlg->cbRealtime, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotRealtime(bool)));
+  connect(m_dlg->cbAppcomplete, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAppcompleteToggled(bool)));
+  connect(m_dlg->cbAutocomplete, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAutocompleteToggled(bool)));
+  connect(m_dlg->cbAutohistory, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAutohistoryToggled(bool)));
+  connect(m_dlg->cbRunAsOther, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotChangeUid(bool)));
+  connect(m_dlg->leUsername, TQ_SIGNAL(lostFocus()), TQ_SLOT(updateAuthLabel()));
+  connect(m_dlg->cbRunInTerminal, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotTerminal(bool)));
 
   m_dlg->slPriority->setValue(50);
 
diff --git a/kdesktop/startupid.cpp b/kdesktop/startupid.cpp
index d7b1cf75a..7d448c089 100644
--- a/kdesktop/startupid.cpp
+++ b/kdesktop/startupid.cpp
@@ -56,16 +56,16 @@ StartupId::StartupId( TQWidget* parent, const char* name )
         XSelectInput( tqt_xdisplay(), tqt_xrootwin(), attrs.your_event_mask | SubstructureNotifyMask);
         kapp->installX11EventFilter( this );
         }
-    connect( &update_timer, TQT_SIGNAL( timeout()), TQT_SLOT( update_startupid()));
+    connect( &update_timer, TQ_SIGNAL( timeout()), TQ_SLOT( update_startupid()));
     connect( &startup_info,
-        TQT_SIGNAL( gotNewStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )),
-        TQT_SLOT( gotNewStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )));
+        TQ_SIGNAL( gotNewStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )),
+        TQ_SLOT( gotNewStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )));
     connect( &startup_info,
-        TQT_SIGNAL( gotStartupChange( const TDEStartupInfoId&, const TDEStartupInfoData& )),
-        TQT_SLOT( gotStartupChange( const TDEStartupInfoId&, const TDEStartupInfoData& )));
+        TQ_SIGNAL( gotStartupChange( const TDEStartupInfoId&, const TDEStartupInfoData& )),
+        TQ_SLOT( gotStartupChange( const TDEStartupInfoId&, const TDEStartupInfoData& )));
     connect( &startup_info,
-        TQT_SIGNAL( gotRemoveStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )),
-        TQT_SLOT( gotRemoveStartup( const TDEStartupInfoId& )));
+        TQ_SIGNAL( gotRemoveStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )),
+        TQ_SLOT( gotRemoveStartup( const TDEStartupInfoId& )));
     }
 
 StartupId::~StartupId()
@@ -129,10 +129,10 @@ bool StartupId::x11Event( XEvent* e )
             if( startups.count() == 0 )
                 start_startupid( KDE_STARTUP_ICON );
             // 60(?) sec timeout - shouldn't be hopefully needed anyway, ksmserver should have it too
-            TQTimer::singleShot( 60000, this, TQT_SLOT( finishKDEStartup()));
+            TQTimer::singleShot( 60000, this, TQ_SLOT( finishKDEStartup()));
             }
         else if( strcmp( s, "session ready" ) == 0 && kde_startup_status < StartupDone )
-            TQTimer::singleShot( 2000, this, TQT_SLOT( finishKDEStartup()));
+            TQTimer::singleShot( 2000, this, TQ_SLOT( finishKDEStartup()));
         }
     return false;
     }