Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

8 files changed, 383 insertions, 383 deletions

diff --git a/quanta/src/document.cpp b/quanta/src/document.cpp
index 6ca6e6ab..49b3d195 100644
--- a/quanta/src/document.cpp
+++ b/quanta/src/document.cpp
@@ -200,25 +200,25 @@ Document::Document(KTextEditor::Document *doc,
   //path of the backup copy file of the document
   m_backupPathValue = TQString();
 
-  connect( m_doc,  TQT_SIGNAL(charactersInteractivelyInserted (int ,int ,const TQString&)),
-           this,  TQT_SLOT(slotCharactersInserted(int ,int ,const TQString&)) );
+  connect( m_doc,  TQ_SIGNAL(charactersInteractivelyInserted (int ,int ,const TQString&)),
+           this,  TQ_SLOT(slotCharactersInserted(int ,int ,const TQString&)) );
 
-  connect( m_view, TQT_SIGNAL(completionAborted()),
-           this,  TQT_SLOT(  slotCompletionAborted()) );
+  connect( m_view, TQ_SIGNAL(completionAborted()),
+           this,  TQ_SLOT(  slotCompletionAborted()) );
 
-  connect( m_view, TQT_SIGNAL(completionDone(KTextEditor::CompletionEntry)),
-           this,  TQT_SLOT(  slotCompletionDone(KTextEditor::CompletionEntry)) );
+  connect( m_view, TQ_SIGNAL(completionDone(KTextEditor::CompletionEntry)),
+           this,  TQ_SLOT(  slotCompletionDone(KTextEditor::CompletionEntry)) );
 
-  connect( m_view, TQT_SIGNAL(filterInsertString(KTextEditor::CompletionEntry*,TQString *)),
-           this,  TQT_SLOT(  slotFilterCompletion(KTextEditor::CompletionEntry*,TQString *)) );
-  connect( m_doc, TQT_SIGNAL(textChanged()), TQT_SLOT(slotTextChanged()));
+  connect( m_view, TQ_SIGNAL(filterInsertString(KTextEditor::CompletionEntry*,TQString *)),
+           this,  TQ_SLOT(  slotFilterCompletion(KTextEditor::CompletionEntry*,TQString *)) );
+  connect( m_doc, TQ_SIGNAL(textChanged()), TQ_SLOT(slotTextChanged()));
 
-  connect(m_view, TQT_SIGNAL(gotFocus(Kate::View*)), TQT_SIGNAL(editorGotFocus()));
+  connect(m_view, TQ_SIGNAL(gotFocus(Kate::View*)), TQ_SIGNAL(editorGotFocus()));
 
-  connect(fileWatcher, TQT_SIGNAL(dirty(const TQString&)), TQT_SLOT(slotFileDirty(const TQString&)));
+  connect(fileWatcher, TQ_SIGNAL(dirty(const TQString&)), TQ_SLOT(slotFileDirty(const TQString&)));
 
-//   connect(m_doc, TQT_SIGNAL(marksChanged()), this, TQT_SLOT(slotMarksChanged()));
-  connect(m_doc, TQT_SIGNAL(markChanged(KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction)), this, TQT_SLOT(slotMarkChanged(KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction)));
+//   connect(m_doc, TQ_SIGNAL(marksChanged()), this, TQ_SLOT(slotMarksChanged()));
+  connect(m_doc, TQ_SIGNAL(markChanged(KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction)), this, TQ_SLOT(slotMarkChanged(KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction)));
 
 }
 
@@ -725,7 +725,7 @@ void Document::slotCompletionDone( KTextEditor::CompletionEntry completion )
 /*  if (completion.type == "charCompletion")
   {
     m_lastCompletionList = getCharacterCompletions(completion.userdata);
-    TQTimer::singleShot(0, this, TQT_SLOT(slotDelayedShowCodeCompletion()));
+    TQTimer::singleShot(0, this, TQ_SLOT(slotDelayedShowCodeCompletion()));
   } else*/
   if (completion.type == "attribute")
   {
@@ -736,7 +736,7 @@ void Document::slotCompletionDone( KTextEditor::CompletionEntry completion )
       if (tag)
       {
         m_lastCompletionList = getAttributeValueCompletions(tag->name(), completion.text);
-        TQTimer::singleShot(0, this, TQT_SLOT(slotDelayedShowCodeCompletion()));
+        TQTimer::singleShot(0, this, TQ_SLOT(slotDelayedShowCodeCompletion()));
       }
     }
   } else
@@ -755,7 +755,7 @@ void Document::slotCompletionDone( KTextEditor::CompletionEntry completion )
     {
       m_lastLine = line;
       m_lastCol = col - 1;
-      TQTimer::singleShot(0, this, TQT_SLOT(slotDelayedScriptAutoCompletion()));
+      TQTimer::singleShot(0, this, TQ_SLOT(slotDelayedScriptAutoCompletion()));
     }
   }
 }
@@ -859,7 +859,7 @@ void Document::slotCharactersInserted(int line, int column, const TQString& stri
         m_replaceLine = line;
         m_replaceCol = column;
         m_replaceStr = QuantaCommon::encodedChar(string[0].unicode());
-        TQTimer::singleShot(0, this, TQT_SLOT(slotReplaceChar()));
+        TQTimer::singleShot(0, this, TQ_SLOT(slotReplaceChar()));
         return;
       }
     }
@@ -872,7 +872,7 @@ void Document::slotCharactersInserted(int line, int column, const TQString& stri
       m_replaceLine = line;
       m_replaceCol = column;
       m_replaceStr = QuantaCommon::encodedChar(c);
-      TQTimer::singleShot(0, this, TQT_SLOT(slotReplaceChar()));
+      TQTimer::singleShot(0, this, TQ_SLOT(slotReplaceChar()));
       return;
     }
   }
@@ -2367,7 +2367,7 @@ void Document::slotTextChanged()
   {
     kdDebug(24000) << "Delayed text changed called." << endl;
     //delay the handling, otherwise we may get wrong values for (line,column)
-    TQTimer::singleShot(0, this, TQT_SLOT(slotDelayedTextChanged()));
+    TQTimer::singleShot(0, this, TQ_SLOT(slotDelayedTextChanged()));
     delayedTextChangedEnabled = false;
   }
 }
@@ -2378,7 +2378,7 @@ void Document::slotDelayedTextChanged(bool forced)
    {
      kdDebug(24000) << "Reparsing delayed!" << endl;
      parser->setParsingNeeded(true);
-     TQTimer::singleShot(1000, this, TQT_SLOT(slotDelayedTextChanged()));
+     TQTimer::singleShot(1000, this, TQ_SLOT(slotDelayedTextChanged()));
      reparseEnabled = false;
      delayedTextChangedEnabled = false;
      return;
@@ -2872,8 +2872,8 @@ void Document::open(const KURL &url, const TQString &encoding)
        m_encoding = encoding;
        m_codec = TQTextCodec::codecForName(m_encoding.ascii());
     }
-    connect(m_doc, TQT_SIGNAL(completed()), this, TQT_SLOT(slotOpeningCompleted()));
-    connect(m_doc, TQT_SIGNAL(canceled(const TQString&)), this, TQT_SLOT(slotOpeningFailed(const TQString&)));
+    connect(m_doc, TQ_SIGNAL(completed()), this, TQ_SLOT(slotOpeningCompleted()));
+    connect(m_doc, TQ_SIGNAL(canceled(const TQString&)), this, TQ_SLOT(slotOpeningFailed(const TQString&)));
     if (!openURL(url))
       slotOpeningFailed(TQString());
     if (!url.isLocalFile())
@@ -2897,8 +2897,8 @@ void Document::slotOpeningCompleted()
       m_modifTime = TQFileInfo(u.path()).lastModified();
 //      kdDebug(24000) << "addFile[Document::open]: " << u.path() << endl;
   }
-  disconnect(m_doc, TQT_SIGNAL(completed()), this, TQT_SLOT(slotOpeningCompleted()));
-  disconnect(m_doc, TQT_SIGNAL(canceled(const TQString&)), this, TQT_SLOT(slotOpeningFailed(const TQString&)));
+  disconnect(m_doc, TQ_SIGNAL(completed()), this, TQ_SLOT(slotOpeningCompleted()));
+  disconnect(m_doc, TQ_SIGNAL(canceled(const TQString&)), this, TQ_SLOT(slotOpeningFailed(const TQString&)));
   m_dirty = false;
   m_view->setFocus();
   processDTD();
@@ -2911,8 +2911,8 @@ void Document::slotOpeningFailed(const TQString &errorMessage)
   Q_UNUSED(errorMessage); //TODO: append the error message to our own error message
   if (!url().isLocalFile())
     tqApp->exit_loop();
-  disconnect(m_doc, TQT_SIGNAL(completed()), this, TQT_SLOT(slotOpeningCompleted()));
-  disconnect(m_doc, TQT_SIGNAL(canceled(const TQString&)), this, TQT_SLOT(slotOpeningFailed(const TQString&)));
+  disconnect(m_doc, TQ_SIGNAL(completed()), this, TQ_SLOT(slotOpeningCompleted()));
+  disconnect(m_doc, TQ_SIGNAL(canceled(const TQString&)), this, TQ_SLOT(slotOpeningFailed(const TQString&)));
   emit openingFailed(url());
 }
 
diff --git a/quanta/src/dtds.cpp b/quanta/src/dtds.cpp
index 737a3a00..bf257a0c 100644
--- a/quanta/src/dtds.cpp
+++ b/quanta/src/dtds.cpp
@@ -59,9 +59,9 @@ const TQString m_rcFilename("description.rc");
 DTDs::DTDs(TQObject *parent)
   :TQObject(parent)
 {
-  connect(this, TQT_SIGNAL(hideSplash()), parent, TQT_SLOT(slotHideSplash()));
-  connect(this, TQT_SIGNAL(enableIdleTimer(bool)), parent, TQT_SLOT(slotEnableIdleTimer(bool)));
-  connect(this, TQT_SIGNAL(loadToolbarForDTD(const TQString&)), parent, TQT_SLOT(slotLoadToolbarForDTD(const TQString&)));
+  connect(this, TQ_SIGNAL(hideSplash()), parent, TQ_SLOT(slotHideSplash()));
+  connect(this, TQ_SIGNAL(enableIdleTimer(bool)), parent, TQ_SLOT(slotEnableIdleTimer(bool)));
+  connect(this, TQ_SIGNAL(loadToolbarForDTD(const TQString&)), parent, TQ_SLOT(slotLoadToolbarForDTD(const TQString&)));
 //  kdDebug(24000) << "dtds::dtds" << endl;
   m_dict = new TQDict<DTDStruct>(119, false); //optimized for max 119 DTD. This should be enough.
   m_dict->setAutoDelete(true);
diff --git a/quanta/src/kqapp.cpp b/quanta/src/kqapp.cpp
index fc826178..8bd35024 100644
--- a/quanta/src/kqapp.cpp
+++ b/quanta/src/kqapp.cpp
@@ -93,8 +93,8 @@ KQApplication::KQApplication()
      {
       sp = new KSplashScreen(UserIcon(SPLASH_PICTURE));
       sp->show();
-      connect(quantaApp, TQT_SIGNAL(showSplash(bool)), sp, TQT_SLOT(setShown(bool)));
-      TQTimer::singleShot(10*1000, this, TQT_SLOT(slotSplashTimeout()));
+      connect(quantaApp, TQ_SIGNAL(showSplash(bool)), sp, TQ_SLOT(setShown(bool)));
+      TQTimer::singleShot(10*1000, this, TQ_SLOT(slotSplashTimeout()));
      }
      setMainWidget(quantaApp);
      slotInit();
@@ -164,8 +164,8 @@ int KQUniqueApplication::newInstance()
     {
       sp = new KSplashScreen(UserIcon(SPLASH_PICTURE));
       sp->show();
-      connect(quantaApp, TQT_SIGNAL(showSplash(bool)), sp, TQT_SLOT(setShown(bool)));
-      TQTimer::singleShot(10*1000, this, TQT_SLOT(slotSplashTimeout()));
+      connect(quantaApp, TQ_SIGNAL(showSplash(bool)), sp, TQ_SLOT(setShown(bool)));
+      TQTimer::singleShot(10*1000, this, TQ_SLOT(slotSplashTimeout()));
     }
     setMainWidget(quantaApp);
     slotInit();
diff --git a/quanta/src/quanta.cpp b/quanta/src/quanta.cpp
index 11b8efeb..46a098df 100644
--- a/quanta/src/quanta.cpp
+++ b/quanta/src/quanta.cpp
@@ -219,7 +219,7 @@ QuantaApp::QuantaApp(int mdiMode) : DCOPObject("WindowManagerIf"), KMdiMainFrm(
   currentToolbarDTD = TQString();
   m_config=kapp->config();
   idleTimer = new TQTimer(this);
-  connect(idleTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotIdleTimerExpired()));
+  connect(idleTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotIdleTimerExpired()));
   m_idleTimerEnabled = true;
 
   qConfig.globalDataDir = TDEGlobal::dirs()->findResourceDir("data",resourceDir + "toolbar/quantalogo.png");
@@ -230,7 +230,7 @@ QuantaApp::QuantaApp(int mdiMode) : DCOPObject("WindowManagerIf"), KMdiMainFrm(
     kdWarning() << i18n("Quanta data files were not found.") << endl;
     kdWarning() << i18n("You may have forgotten to run \"make install\", or your TDEDIR, TDEDIRS or PATH are not set correctly.") << endl;
     kdWarning() << "***************************************************************************" << endl;
-    TQTimer::singleShot(20, kapp, TQT_SLOT(quit()));
+    TQTimer::singleShot(20, kapp, TQ_SLOT(quit()));
     return;
   }
   qConfig.enableDTDToolbar = true;
@@ -243,10 +243,10 @@ QuantaApp::QuantaApp(int mdiMode) : DCOPObject("WindowManagerIf"), KMdiMainFrm(
   m_partManager = new KParts::PartManager(this);
   // When the manager says the active part changes,
   // the builder updates (recreates) the GUI
-  connect(m_partManager, TQT_SIGNAL(activePartChanged(KParts::Part * )),
-          this, TQT_SLOT(slotActivePartChanged(KParts::Part * )));
-  connect(this, TQT_SIGNAL(dockWidgetHasUndocked(KDockWidget *)), this, TQT_SLOT(slotDockWidgetHasUndocked(KDockWidget *)));
-  connect(tabWidget(), TQT_SIGNAL(initiateDrag(TQWidget *)), this, TQT_SLOT(slotTabDragged(TQWidget*)));
+  connect(m_partManager, TQ_SIGNAL(activePartChanged(KParts::Part * )),
+          this, TQ_SLOT(slotActivePartChanged(KParts::Part * )));
+  connect(this, TQ_SIGNAL(dockWidgetHasUndocked(KDockWidget *)), this, TQ_SLOT(slotDockWidgetHasUndocked(KDockWidget *)));
+  connect(tabWidget(), TQ_SIGNAL(initiateDrag(TQWidget *)), this, TQ_SLOT(slotTabDragged(TQWidget*)));
 
   m_oldKTextEditor = 0L;
   m_previewToolView = 0L;
@@ -280,9 +280,9 @@ QuantaApp::~QuantaApp()
   m_newScriptStuff = 0L;
   delete m_newDTEPStuff;
   m_newDocStuff = 0L;
- // disconnect(m_htmlPart, TQT_SIGNAL(destroyed(TQObject *)));
- // disconnect(m_htmlPartDoc, TQT_SIGNAL(destroyed(TQObject *)));
-  disconnect(this, TQT_SIGNAL(lastChildViewClosed()), ViewManager::ref(), TQT_SLOT(slotLastViewClosed()));
+ // disconnect(m_htmlPart, TQ_SIGNAL(destroyed(TQObject *)));
+ // disconnect(m_htmlPartDoc, TQ_SIGNAL(destroyed(TQObject *)));
+  disconnect(this, TQ_SIGNAL(lastChildViewClosed()), ViewManager::ref(), TQ_SLOT(slotLastViewClosed()));
   //kdDebug(24000) << "QuantaApp::~QuantaApp" << endl;
 #ifdef ENABLE_CVSSERVICE
  delete CVSService::ref();
@@ -1081,7 +1081,7 @@ void QuantaApp::slotConfigureToolbars(const TQString& defaultToolbar)
    }
  }
 
- connect(dlg, TQT_SIGNAL(newToolbarConfig()), TQT_SLOT(slotNewToolbarConfig()));
+ connect(dlg, TQ_SIGNAL(newToolbarConfig()), TQ_SLOT(slotNewToolbarConfig()));
  dlg->exec();
  delete dlg;
  TQPopupMenu *menu = 0L;
@@ -1389,8 +1389,8 @@ void QuantaApp::slotShowPreviewWidget(bool show)
       if (!m_previewToolView)
       {
         m_previewToolView= addToolWindow(m_htmlPart->view(), prevDockPosition(m_htmlPart->view(), KDockWidget::DockBottom), getMainDockWidget());
-        connect(m_previewToolView->wrapperWidget(), TQT_SIGNAL(iMBeingClosed
-()), this, TQT_SLOT(slotPreviewBeingClosed()));
+        connect(m_previewToolView->wrapperWidget(), TQ_SIGNAL(iMBeingClosed
+()), this, TQ_SLOT(slotPreviewBeingClosed()));
       }
       m_htmlPart->view()->show();
       m_previewToolView->show();
@@ -1819,10 +1819,10 @@ TQWidget* QuantaApp::createContainer( TQWidget *parent, int index, const TQDomEl
     toolbarTab->insertTab(tb, tabname, idStr);
     qInstallMsgHandler( oldHandler );
 
-    connect(tb, TQT_SIGNAL(removeAction(const TQString&, const TQString&)),
-                TQT_SLOT(slotRemoveAction(const TQString&, const TQString&)));
-    connect(tb, TQT_SIGNAL(editAction(const TQString&)),
-                TQT_SLOT(slotEditAction(const TQString&)));
+    connect(tb, TQ_SIGNAL(removeAction(const TQString&, const TQString&)),
+                TQ_SLOT(slotRemoveAction(const TQString&, const TQString&)));
+    connect(tb, TQ_SIGNAL(editAction(const TQString&)),
+                TQ_SLOT(slotEditAction(const TQString&)));
     return tb;
   }
 
@@ -3694,7 +3694,7 @@ void QuantaApp::slotDownloadDoc()
   if (!m_newDocStuff)
   {
     m_newDocStuff = new QNewDocStuff("quanta documentation", this);
-    connect(m_newDocStuff, TQT_SIGNAL(installFinished()), dTab, TQT_SLOT(slotRefreshTree()));
+    connect(m_newDocStuff, TQ_SIGNAL(installFinished()), dTab, TQ_SLOT(slotRefreshTree()));
   }
   m_newDocStuff->downloadResource();
 }
@@ -5092,8 +5092,8 @@ void QuantaApp::initTabWidget(bool closeButtonsOnly)
         {
             tab->setTabReorderingEnabled(true);
             tab->setTabPosition(TQTabWidget::Bottom);
-            connect(tab, TQT_SIGNAL( contextMenu( TQWidget *, const TQPoint & ) ), ViewManager::ref(), TQT_SLOT(slotTabContextMenu( TQWidget *, const TQPoint & ) ) );
-            connect(tab, TQT_SIGNAL(initiateTabMove(int, int)), this, TQT_SLOT(slotTabAboutToMove(int, int)));                        connect(tab, TQT_SIGNAL(movedTab(int, int)), this, TQT_SLOT(slotTabMoved(int, int)));            setTabWidgetVisibility(KMdi::AlwaysShowTabs);
+            connect(tab, TQ_SIGNAL( contextMenu( TQWidget *, const TQPoint & ) ), ViewManager::ref(), TQ_SLOT(slotTabContextMenu( TQWidget *, const TQPoint & ) ) );
+            connect(tab, TQ_SIGNAL(initiateTabMove(int, int)), this, TQ_SLOT(slotTabAboutToMove(int, int)));                        connect(tab, TQ_SIGNAL(movedTab(int, int)), this, TQ_SLOT(slotTabMoved(int, int)));            setTabWidgetVisibility(KMdi::AlwaysShowTabs);
         }
     }
     if (!closeButtonsOnly)
@@ -5267,10 +5267,10 @@ void QuantaApp::createPreviewPart()
   m_htmlPart->view()->setIcon(UserIcon("preview"));
   m_htmlPart->view()->setCaption(i18n("Preview"));
   slotNewPart(m_htmlPart, false);
-  connect(m_htmlPart, TQT_SIGNAL(previewHasFocus(bool)), this, TQT_SLOT(slotPreviewHasFocus(bool)));
-  connect(m_htmlPart, TQT_SIGNAL(destroyed(TQObject *)), this, TQT_SLOT(slotHTMLPartDeleted(TQObject *)));
-  connect(m_htmlPart, TQT_SIGNAL(openFile(const KURL&, const TQString&, bool)), this, TQT_SLOT(slotFileOpen(const KURL&, const TQString&, bool)));
-  connect(m_htmlPart, TQT_SIGNAL(showPreview(bool)), this, TQT_SLOT(slotShowPreviewWidget(bool)));
+  connect(m_htmlPart, TQ_SIGNAL(previewHasFocus(bool)), this, TQ_SLOT(slotPreviewHasFocus(bool)));
+  connect(m_htmlPart, TQ_SIGNAL(destroyed(TQObject *)), this, TQ_SLOT(slotHTMLPartDeleted(TQObject *)));
+  connect(m_htmlPart, TQ_SIGNAL(openFile(const KURL&, const TQString&, bool)), this, TQ_SLOT(slotFileOpen(const KURL&, const TQString&, bool)));
+  connect(m_htmlPart, TQ_SIGNAL(showPreview(bool)), this, TQ_SLOT(slotShowPreviewWidget(bool)));
 
 }
 
@@ -5281,7 +5281,7 @@ void QuantaApp::createDocPart()
   m_htmlPartDoc->view()->setIcon(SmallIcon("contents"));
   m_htmlPartDoc->view()->setCaption(i18n("Documentation"));
   slotNewPart(m_htmlPartDoc, false);
-  connect(m_htmlPartDoc, TQT_SIGNAL(destroyed(TQObject *)), this, TQT_SLOT(slotHTMLPartDeleted(TQObject *)));
+  connect(m_htmlPartDoc, TQ_SIGNAL(destroyed(TQObject *)), this, TQ_SLOT(slotHTMLPartDeleted(TQObject *)));
 }
 
 void QuantaApp::insertTagActionPoolItem(TQString const& action_item)
@@ -5320,14 +5320,14 @@ void QuantaApp::slotTabMoved(int from, int to)
   KMdiChildView *view = m_pDocumentViews->at(from);
   m_pDocumentViews->remove(from);
   m_pDocumentViews->insert(to, view);
-  connect(this, TQT_SIGNAL(viewActivated (KMdiChildView *)), ViewManager::ref(), TQT_SLOT(slotViewActivated(KMdiChildView*)));
+  connect(this, TQ_SIGNAL(viewActivated (KMdiChildView *)), ViewManager::ref(), TQ_SLOT(slotViewActivated(KMdiChildView*)));
 }
 
 void QuantaApp::slotTabAboutToMove(int from, int to)
 {
   Q_UNUSED(from);
   Q_UNUSED(to);
-  disconnect(this, TQT_SIGNAL(viewActivated (KMdiChildView *)), ViewManager::ref(), TQT_SLOT(slotViewActivated(KMdiChildView*)));
+  disconnect(this, TQ_SIGNAL(viewActivated (KMdiChildView *)), ViewManager::ref(), TQ_SLOT(slotViewActivated(KMdiChildView*)));
 }
 
 TQString QuantaApp::currentURL() const
diff --git a/quanta/src/quanta_init.cpp b/quanta/src/quanta_init.cpp
index 134e34a4..42e72e38 100644
--- a/quanta/src/quanta_init.cpp
+++ b/quanta/src/quanta_init.cpp
@@ -123,7 +123,7 @@ QuantaInit::QuantaInit(QuantaApp * quantaApp)
         : TQObject()
 {
   m_quanta = quantaApp;
-  connect(this, TQT_SIGNAL(hideSplash()), m_quanta, TQT_SLOT(slotHideSplash()));
+  connect(this, TQ_SIGNAL(hideSplash()), m_quanta, TQ_SLOT(slotHideSplash()));
 }
 
 QuantaInit::~QuantaInit()
@@ -175,11 +175,11 @@ void QuantaInit::initQuanta()
 
   // Initialize debugger
   m_quanta->m_debugger = new DebuggerManager(m_quanta);
-  connect(Project::ref(), TQT_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
-          m_quanta->m_debugger, TQT_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
-  connect(Project::ref(), TQT_SIGNAL(eventHappened(const TQString &, const TQString &, const TQString &)),
-          m_quanta->m_debugger, TQT_SLOT(slotHandleEvent(const TQString &, const TQString &, const TQString &)));
-  connect(m_quanta->m_debugger, TQT_SIGNAL(hideSplash()), m_quanta, TQT_SLOT(slotHideSplash()));
+  connect(Project::ref(), TQ_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
+          m_quanta->m_debugger, TQ_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
+  connect(Project::ref(), TQ_SIGNAL(eventHappened(const TQString &, const TQString &, const TQString &)),
+          m_quanta->m_debugger, TQ_SLOT(slotHandleEvent(const TQString &, const TQString &, const TQString &)));
+  connect(m_quanta->m_debugger, TQ_SIGNAL(hideSplash()), m_quanta, TQ_SLOT(slotHideSplash()));
 
   //m_quanta->KDockMainWindow::createGUI( TQString(), false /* conserveMemory */ );
   m_quanta->createShellGUI(true);
@@ -213,7 +213,7 @@ void QuantaInit::initQuanta()
   if (mdiMode == KMdi::ToplevelMode)
   {
       m_quanta->switchToChildframeMode();
-      TQTimer::singleShot(0, m_quanta, TQT_SLOT(switchToToplevelMode()));
+      TQTimer::singleShot(0, m_quanta, TQ_SLOT(switchToToplevelMode()));
   }
 
   // Always hide debugger toolbar at this point
@@ -257,19 +257,19 @@ void QuantaInit::initQuanta()
      toolviewMenu->plug(m_quanta->windowMenu());
 
   TQPopupMenu *toolbarsMenu  = (TQPopupMenu*)(m_quanta->guiFactory())->container("toolbars_load", m_quanta);
-  connect(toolbarsMenu, TQT_SIGNAL(aboutToShow()), m_quanta, TQT_SLOT(slotBuildPrjToolbarsMenu()));
+  connect(toolbarsMenu, TQ_SIGNAL(aboutToShow()), m_quanta, TQ_SLOT(slotBuildPrjToolbarsMenu()));
 
   TQPopupMenu *contextMenu = (TQPopupMenu*)(m_quanta->guiFactory())->container("popup_editor", m_quanta);
-  connect(contextMenu, TQT_SIGNAL(aboutToShow()), m_quanta, TQT_SLOT(slotContextMenuAboutToShow()));
+  connect(contextMenu, TQ_SIGNAL(aboutToShow()), m_quanta, TQ_SLOT(slotContextMenuAboutToShow()));
 
-  connect(m_quanta->m_messageOutput, TQT_SIGNAL(clicked(const TQString&, int, int)),
-          m_quanta, TQT_SLOT(gotoFileAndLine(const TQString&, int, int)));
-  connect(m_quanta->m_problemOutput, TQT_SIGNAL(clicked(const TQString&, int, int)),
-          m_quanta, TQT_SLOT(gotoFileAndLine(const TQString&, int, int)));
-  connect(m_quanta->m_annotationOutput->currentFileAnnotations(), TQT_SIGNAL(clicked(const TQString&, int, int)),
-          m_quanta, TQT_SLOT(gotoFileAndLine(const TQString&, int, int)));
-  connect(m_quanta->m_annotationOutput, TQT_SIGNAL(clicked(const TQString&, int, int)),
-          m_quanta, TQT_SLOT(gotoFileAndLine(const TQString&, int, int)));
+  connect(m_quanta->m_messageOutput, TQ_SIGNAL(clicked(const TQString&, int, int)),
+          m_quanta, TQ_SLOT(gotoFileAndLine(const TQString&, int, int)));
+  connect(m_quanta->m_problemOutput, TQ_SIGNAL(clicked(const TQString&, int, int)),
+          m_quanta, TQ_SLOT(gotoFileAndLine(const TQString&, int, int)));
+  connect(m_quanta->m_annotationOutput->currentFileAnnotations(), TQ_SIGNAL(clicked(const TQString&, int, int)),
+          m_quanta, TQ_SLOT(gotoFileAndLine(const TQString&, int, int)));
+  connect(m_quanta->m_annotationOutput, TQ_SIGNAL(clicked(const TQString&, int, int)),
+          m_quanta, TQ_SLOT(gotoFileAndLine(const TQString&, int, int)));
 
   m_quanta->slotFileNew();
   m_quanta->slotNewStatus();
@@ -283,12 +283,12 @@ void QuantaInit::initQuanta()
   qConfig.backupDirPath = TDEGlobal::instance()->dirs()->saveLocation("data", resourceDir + "backups/");
 
   m_quanta->autosaveTimer = new TQTimer(m_quanta);
-  connect(m_quanta->autosaveTimer, TQT_SIGNAL(timeout()), m_quanta, TQT_SLOT(slotAutosaveTimer()));
+  connect(m_quanta->autosaveTimer, TQ_SIGNAL(timeout()), m_quanta, TQ_SLOT(slotAutosaveTimer()));
   m_quanta->autosaveTimer->start(qConfig.autosaveInterval * 60000, false);
 
-  connect(m_quanta->m_doc, TQT_SIGNAL(hideSplash()), m_quanta, TQT_SLOT(slotHideSplash()));
-  connect(parser, TQT_SIGNAL(rebuildStructureTree(bool)),
-          m_quanta, TQT_SLOT(slotReloadStructTreeView(bool)));
+  connect(m_quanta->m_doc, TQ_SIGNAL(hideSplash()), m_quanta, TQ_SLOT(slotHideSplash()));
+  connect(parser, TQ_SIGNAL(rebuildStructureTree(bool)),
+          m_quanta, TQ_SLOT(slotReloadStructTreeView(bool)));
 
   // Read list of characters
   TQFile file(locate("appdata","chars"));
@@ -319,7 +319,7 @@ void QuantaInit::initQuanta()
   ViewManager::ref()->activeDocument()->view()->setFocus();
 
   m_quanta->refreshTimer = new TQTimer(m_quanta);
-  connect(m_quanta->refreshTimer, TQT_SIGNAL(timeout()), m_quanta, TQT_SLOT(slotReparse()));
+  connect(m_quanta->refreshTimer, TQ_SIGNAL(timeout()), m_quanta, TQ_SLOT(slotReparse()));
   m_quanta->refreshTimer->start( qConfig.refreshFrequency*1000, false ); //update the structure tree every 5 seconds
   if (qConfig.instantUpdate || qConfig.refreshFrequency == 0)
   {
@@ -337,8 +337,8 @@ void QuantaInit::initToolBars()
 void QuantaInit::initStatusBar()
 {
   m_quanta->statusbarTimer = new TQTimer(m_quanta);
-  connect(m_quanta->statusbarTimer,TQT_SIGNAL(timeout()),
-          m_quanta, TQT_SLOT(statusBarTimeout()));
+  connect(m_quanta->statusbarTimer,TQ_SIGNAL(timeout()),
+          m_quanta, TQ_SLOT(statusBarTimeout()));
 
   progressBar = new KProgress(m_quanta->statusBar());
   progressBar->setTextEnabled(false);
@@ -360,111 +360,111 @@ void QuantaInit::initStatusBar()
 void QuantaInit::initDocument()
 {
   m_quanta->m_doc = new QuantaDoc(0L);
-  connect(m_quanta->m_doc, TQT_SIGNAL(newStatus()),
-          m_quanta, TQT_SLOT(slotNewStatus()));
+  connect(m_quanta->m_doc, TQ_SIGNAL(newStatus()),
+          m_quanta, TQ_SLOT(slotNewStatus()));
 }
 
 void QuantaInit::initProject()
 {
   Project *m_project = Project::ref(m_quanta);
 
-  connect(m_project, TQT_SIGNAL(getTreeStatus(TQStringList *)),
-          pTab, TQT_SLOT(slotGetTreeStatus(TQStringList *)));
-  connect(m_project, TQT_SIGNAL(loadToolbarFile(const KURL &)),
-          m_quanta, TQT_SLOT(slotLoadToolbarFile(const KURL &)));
-  connect(m_project, TQT_SIGNAL(getUserToolbarFiles(KURL::List *)),
-          m_quanta, TQT_SLOT(slotGetUserToolbarFiles(KURL::List *)));
-  connect(m_project, TQT_SIGNAL(openFiles(const KURL::List &, const TQString&)),
-          m_quanta, TQT_SLOT(slotFileOpen(const KURL::List &, const TQString&)));
-  connect(m_project, TQT_SIGNAL(openFile(const KURL &, const TQString&)),
-          m_quanta, TQT_SLOT(slotFileOpen(const KURL &, const TQString&)));
-  connect(m_project, TQT_SIGNAL(closeFile(const KURL &)),
-          m_quanta, TQT_SLOT(slotFileClose(const KURL &)));
-  connect(m_project, TQT_SIGNAL(reloadTree(ProjectList *, bool, const TQStringList &)),
-          pTab, TQT_SLOT(slotReloadTree(ProjectList *, bool, const TQStringList &)));
-  connect(m_project, TQT_SIGNAL(closeFiles()), ViewManager::ref(), TQT_SLOT(closeAll()));
-  connect(m_project, TQT_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQT_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
-
-  connect(m_quanta->fTab, TQT_SIGNAL(insertDirInProject(const KURL&)),
-          m_project, TQT_SLOT(slotAddDirectory(const KURL&)));
-
-  connect(m_quanta->fTab, TQT_SIGNAL(insertFileInProject(const KURL&)),
-          m_project, TQT_SLOT(slotInsertFile(const KURL&)));
-
-  connect(TemplatesTreeView::ref(), TQT_SIGNAL(insertDirInProject(const KURL&)),
-          m_project, TQT_SLOT(slotAddDirectory(const KURL&)));
-
-  connect(TemplatesTreeView::ref(), TQT_SIGNAL(insertFileInProject(const KURL&)),
-          m_project, TQT_SLOT(slotInsertFile(const KURL&)));
-  connect(TemplatesTreeView::ref(), TQT_SIGNAL(downloadTemplate()),
-          m_quanta, TQT_SLOT(slotDownloadTemplate()));
-  connect(TemplatesTreeView::ref(), TQT_SIGNAL(uploadTemplate(const TQString&)), m_quanta, TQT_SLOT(slotUploadTemplate(const TQString&)));
+  connect(m_project, TQ_SIGNAL(getTreeStatus(TQStringList *)),
+          pTab, TQ_SLOT(slotGetTreeStatus(TQStringList *)));
+  connect(m_project, TQ_SIGNAL(loadToolbarFile(const KURL &)),
+          m_quanta, TQ_SLOT(slotLoadToolbarFile(const KURL &)));
+  connect(m_project, TQ_SIGNAL(getUserToolbarFiles(KURL::List *)),
+          m_quanta, TQ_SLOT(slotGetUserToolbarFiles(KURL::List *)));
+  connect(m_project, TQ_SIGNAL(openFiles(const KURL::List &, const TQString&)),
+          m_quanta, TQ_SLOT(slotFileOpen(const KURL::List &, const TQString&)));
+  connect(m_project, TQ_SIGNAL(openFile(const KURL &, const TQString&)),
+          m_quanta, TQ_SLOT(slotFileOpen(const KURL &, const TQString&)));
+  connect(m_project, TQ_SIGNAL(closeFile(const KURL &)),
+          m_quanta, TQ_SLOT(slotFileClose(const KURL &)));
+  connect(m_project, TQ_SIGNAL(reloadTree(ProjectList *, bool, const TQStringList &)),
+          pTab, TQ_SLOT(slotReloadTree(ProjectList *, bool, const TQStringList &)));
+  connect(m_project, TQ_SIGNAL(closeFiles()), ViewManager::ref(), TQ_SLOT(closeAll()));
+  connect(m_project, TQ_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQ_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
+
+  connect(m_quanta->fTab, TQ_SIGNAL(insertDirInProject(const KURL&)),
+          m_project, TQ_SLOT(slotAddDirectory(const KURL&)));
+
+  connect(m_quanta->fTab, TQ_SIGNAL(insertFileInProject(const KURL&)),
+          m_project, TQ_SLOT(slotInsertFile(const KURL&)));
+
+  connect(TemplatesTreeView::ref(), TQ_SIGNAL(insertDirInProject(const KURL&)),
+          m_project, TQ_SLOT(slotAddDirectory(const KURL&)));
+
+  connect(TemplatesTreeView::ref(), TQ_SIGNAL(insertFileInProject(const KURL&)),
+          m_project, TQ_SLOT(slotInsertFile(const KURL&)));
+  connect(TemplatesTreeView::ref(), TQ_SIGNAL(downloadTemplate()),
+          m_quanta, TQ_SLOT(slotDownloadTemplate()));
+  connect(TemplatesTreeView::ref(), TQ_SIGNAL(uploadTemplate(const TQString&)), m_quanta, TQ_SLOT(slotUploadTemplate(const TQString&)));
 
   // inform project if something was renamed
-  connect(pTab, TQT_SIGNAL(renamed(const KURL&, const KURL&)),
-          m_project, TQT_SLOT(slotRenamed(const KURL&, const KURL&)));
-  connect(m_quanta->fTab, TQT_SIGNAL(renamed(const KURL&, const KURL&)),
-          m_project, TQT_SLOT(slotRenamed(const KURL&, const KURL&)));
-  connect(tTab, TQT_SIGNAL(renamed(const KURL&, const KURL&)),
-          m_project, TQT_SLOT(slotRenamed(const KURL&, const KURL&)));
-
-  connect(pTab, TQT_SIGNAL(insertToProject(const KURL&)),
-          m_project, TQT_SLOT(slotInsertFile(const KURL&)));
-  connect(pTab, TQT_SIGNAL(removeFromProject(const KURL&)),
-          m_project, TQT_SLOT(slotRemove(const KURL&)));
-  connect(pTab, TQT_SIGNAL(uploadSingleURL(const KURL&, const TQString&, bool, bool)),
-          m_project, TQT_SLOT(slotUploadURL(const KURL&, const TQString&, bool, bool)));
-  connect(pTab, TQT_SIGNAL(rescanProjectDir()), m_project, TQT_SLOT(slotRescanPrjDir()));
-  connect(pTab, TQT_SIGNAL(showProjectOptions()), m_project, TQT_SLOT(slotOptions()));
-  connect(pTab, TQT_SIGNAL(uploadProject()), m_project, TQT_SLOT(slotUpload()));
-
-  connect(m_quanta->dTab, TQT_SIGNAL(reloadProjectDocs()), m_project, TQT_SLOT(slotReloadProjectDocs()));
-  connect(m_project, TQT_SIGNAL(reloadProjectDocs()), m_quanta->dTab, TQT_SLOT(slotReloadProjectDocs()));
-  connect(m_project, TQT_SIGNAL(addProjectDoc(const KURL&)), m_quanta->dTab, TQT_SLOT(slotAddProjectDoc(const KURL&)));
-
-  connect(m_project, TQT_SIGNAL(enableMessageWidget()),
-          m_quanta, TQT_SLOT(slotShowMessagesView()));
-
-  connect(m_project, TQT_SIGNAL(messages(const TQString&)),
-          m_quanta->m_messageOutput, TQT_SLOT(showMessage(const TQString&)));
-
-  connect(m_project, TQT_SIGNAL(newStatus()),
-          m_quanta, TQT_SLOT(slotNewStatus()));
-
-  connect(m_project, TQT_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
-          TemplatesTreeView::ref(), TQT_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
-  connect(m_project, TQT_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
-          pTab, TQT_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
-  connect(m_project, TQT_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
-          m_quanta->fTab, TQT_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
-  connect(m_project, TQT_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
-          m_quanta->annotationOutput(), TQT_SLOT(updateAnnotations()));
-
-  connect(pTab, TQT_SIGNAL(changeFileDescription(const KURL&, const TQString&)),
-          m_project, TQT_SLOT(slotFileDescChanged(const KURL&, const TQString&)));
-  connect(pTab, TQT_SIGNAL(changeUploadStatus(const KURL&, int)),
-          m_project, TQT_SLOT(slotUploadStatusChanged(const KURL&, int)));
-  connect(pTab, TQT_SIGNAL(changeDocumentFolderStatus(const KURL&, bool)),
-          m_project, TQT_SLOT(slotChangeDocumentFolderStatus(const KURL&, bool)));
-
-  connect(m_project, TQT_SIGNAL(hideSplash()), m_quanta, TQT_SLOT(slotHideSplash()));
-
-  connect(m_project, TQT_SIGNAL(statusMsg(const TQString &)),
-          m_quanta, TQT_SLOT(slotStatusMsg(const TQString & )));
+  connect(pTab, TQ_SIGNAL(renamed(const KURL&, const KURL&)),
+          m_project, TQ_SLOT(slotRenamed(const KURL&, const KURL&)));
+  connect(m_quanta->fTab, TQ_SIGNAL(renamed(const KURL&, const KURL&)),
+          m_project, TQ_SLOT(slotRenamed(const KURL&, const KURL&)));
+  connect(tTab, TQ_SIGNAL(renamed(const KURL&, const KURL&)),
+          m_project, TQ_SLOT(slotRenamed(const KURL&, const KURL&)));
+
+  connect(pTab, TQ_SIGNAL(insertToProject(const KURL&)),
+          m_project, TQ_SLOT(slotInsertFile(const KURL&)));
+  connect(pTab, TQ_SIGNAL(removeFromProject(const KURL&)),
+          m_project, TQ_SLOT(slotRemove(const KURL&)));
+  connect(pTab, TQ_SIGNAL(uploadSingleURL(const KURL&, const TQString&, bool, bool)),
+          m_project, TQ_SLOT(slotUploadURL(const KURL&, const TQString&, bool, bool)));
+  connect(pTab, TQ_SIGNAL(rescanProjectDir()), m_project, TQ_SLOT(slotRescanPrjDir()));
+  connect(pTab, TQ_SIGNAL(showProjectOptions()), m_project, TQ_SLOT(slotOptions()));
+  connect(pTab, TQ_SIGNAL(uploadProject()), m_project, TQ_SLOT(slotUpload()));
+
+  connect(m_quanta->dTab, TQ_SIGNAL(reloadProjectDocs()), m_project, TQ_SLOT(slotReloadProjectDocs()));
+  connect(m_project, TQ_SIGNAL(reloadProjectDocs()), m_quanta->dTab, TQ_SLOT(slotReloadProjectDocs()));
+  connect(m_project, TQ_SIGNAL(addProjectDoc(const KURL&)), m_quanta->dTab, TQ_SLOT(slotAddProjectDoc(const KURL&)));
+
+  connect(m_project, TQ_SIGNAL(enableMessageWidget()),
+          m_quanta, TQ_SLOT(slotShowMessagesView()));
+
+  connect(m_project, TQ_SIGNAL(messages(const TQString&)),
+          m_quanta->m_messageOutput, TQ_SLOT(showMessage(const TQString&)));
+
+  connect(m_project, TQ_SIGNAL(newStatus()),
+          m_quanta, TQ_SLOT(slotNewStatus()));
+
+  connect(m_project, TQ_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
+          TemplatesTreeView::ref(), TQ_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
+  connect(m_project, TQ_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
+          pTab, TQ_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
+  connect(m_project, TQ_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
+          m_quanta->fTab, TQ_SLOT(slotNewProjectLoaded(const TQString &, const KURL &, const KURL &)));
+  connect(m_project, TQ_SIGNAL(newProjectLoaded(const TQString &, const KURL &, const KURL &)),
+          m_quanta->annotationOutput(), TQ_SLOT(updateAnnotations()));
+
+  connect(pTab, TQ_SIGNAL(changeFileDescription(const KURL&, const TQString&)),
+          m_project, TQ_SLOT(slotFileDescChanged(const KURL&, const TQString&)));
+  connect(pTab, TQ_SIGNAL(changeUploadStatus(const KURL&, int)),
+          m_project, TQ_SLOT(slotUploadStatusChanged(const KURL&, int)));
+  connect(pTab, TQ_SIGNAL(changeDocumentFolderStatus(const KURL&, bool)),
+          m_project, TQ_SLOT(slotChangeDocumentFolderStatus(const KURL&, bool)));
+
+  connect(m_project, TQ_SIGNAL(hideSplash()), m_quanta, TQ_SLOT(slotHideSplash()));
+
+  connect(m_project, TQ_SIGNAL(statusMsg(const TQString &)),
+          m_quanta, TQ_SLOT(slotStatusMsg(const TQString & )));
 }
 
 void QuantaInit::initView()
 {
   ViewManager *m_viewManager = ViewManager::ref(m_quanta);
-  connect(m_quanta, TQT_SIGNAL(viewActivated (KMdiChildView *)), m_viewManager, TQT_SLOT(slotViewActivated(KMdiChildView*)));
-  connect(m_quanta, TQT_SIGNAL(lastChildViewClosed()), m_viewManager, TQT_SLOT(slotLastViewClosed()));
-//   connect(m_quanta, TQT_SIGNAL(viewDeactivated(KMdiChildView *)), m_viewManager, TQT_SLOT(slotViewDeactivated(KMdiChildView*)));
+  connect(m_quanta, TQ_SIGNAL(viewActivated (KMdiChildView *)), m_viewManager, TQ_SLOT(slotViewActivated(KMdiChildView*)));
+  connect(m_quanta, TQ_SIGNAL(lastChildViewClosed()), m_viewManager, TQ_SLOT(slotLastViewClosed()));
+//   connect(m_quanta, TQ_SIGNAL(viewDeactivated(KMdiChildView *)), m_viewManager, TQ_SLOT(slotViewDeactivated(KMdiChildView*)));
   KafkaDocument *m_kafkaDocument = KafkaDocument::ref(0, 0, "KafkaPart");
   m_kafkaDocument->getKafkaWidget()->view()->setMinimumHeight(50);
   m_kafkaDocument->readConfig(quantaApp->config());
   loadVPLConfig();
   ToolbarTabWidget *toolBarTab = ToolbarTabWidget::ref(quantaApp);
-  connect(toolBarTab, TQT_SIGNAL(iconTextModeChanged()), quantaApp, TQT_SLOT(slotRefreshActiveWindow()));
+  connect(toolBarTab, TQ_SIGNAL(iconTextModeChanged()), quantaApp, TQ_SLOT(slotRefreshActiveWindow()));
 
   //set the toolview and close button style before the GUI is created
   m_config->setGroup("General Options");
@@ -487,8 +487,8 @@ void QuantaInit::initView()
   m_quanta->m_messageOutput = new MessageOutput(m_quanta, "Messages");
   m_quanta->m_messageOutput->setFocusPolicy(TQWidget::NoFocus);
   m_quanta->m_messageOutput->showMessage(i18n("Message Window..."));
-  connect(m_quanta, TQT_SIGNAL(showMessage(const TQString&, bool)), m_quanta->m_messageOutput, TQT_SLOT(showMessage(const TQString&, bool)));
-  connect(m_quanta, TQT_SIGNAL(clearMessages()), m_quanta->m_messageOutput, TQT_SLOT(clear()));
+  connect(m_quanta, TQ_SIGNAL(showMessage(const TQString&, bool)), m_quanta->m_messageOutput, TQ_SLOT(showMessage(const TQString&, bool)));
+  connect(m_quanta, TQ_SIGNAL(clearMessages()), m_quanta->m_messageOutput, TQ_SLOT(clear()));
 
   m_quanta->m_problemOutput = new MessageOutput(m_quanta, "Problems");
   m_quanta->m_problemOutput->setFocusPolicy(TQWidget::NoFocus);
@@ -498,59 +498,59 @@ void QuantaInit::initView()
   m_quanta->createPreviewPart();
   m_quanta->createDocPart();
 
-  connect(m_quanta, TQT_SIGNAL(reloadAllTrees()),
-          m_quanta->fTab, TQT_SLOT(slotReloadAllTrees()));
-
-  connect(pTab, TQT_SIGNAL(loadToolbarFile  (const KURL&)),
-          m_quanta, TQT_SLOT(slotLoadToolbarFile(const KURL&)));
-  connect(m_viewManager, TQT_SIGNAL(viewActivated(const KURL&)),
-          pTab, TQT_SLOT(slotViewActivated(const KURL&)));
-
-  connect(m_viewManager, TQT_SIGNAL(documentClosed(const KURL&)),
-          pTab, TQT_SLOT(slotDocumentClosed(const KURL&)));
-  connect(m_viewManager, TQT_SIGNAL(documentClosed(const KURL&)),
-          tTab, TQT_SLOT(slotDocumentClosed(const KURL&)));
-  connect(m_viewManager, TQT_SIGNAL(documentClosed(const KURL&)),
-          m_quanta->scriptTab, TQT_SLOT(slotDocumentClosed(const KURL&)));
-  connect(m_viewManager, TQT_SIGNAL(documentClosed(const KURL&)),
-          m_quanta->fTab, TQT_SLOT(slotDocumentClosed(const KURL&)));
-
-  connect(tTab, TQT_SIGNAL(insertFile  (const KURL &)),
-          m_quanta, TQT_SLOT(slotInsertFile(const KURL &)));
-
-  connect(m_quanta->scriptTab, TQT_SIGNAL(openFileInPreview(const KURL &)),
-          m_quanta, TQT_SLOT(slotOpenFileInPreview(const KURL &)));
-  connect(m_quanta->scriptTab, TQT_SIGNAL(showPreviewWidget(bool)),
-          m_quanta, TQT_SLOT(slotShowPreviewWidget(bool)));
-  connect(m_quanta->scriptTab, TQT_SIGNAL(assignActionToScript(const KURL &, const TQString&)),
-          m_quanta, TQT_SLOT(slotAssignActionToScript(const KURL &, const TQString&)));
-  connect(m_quanta->scriptTab, TQT_SIGNAL(downloadScript()), m_quanta, TQT_SLOT(slotDownloadScript()));
-  connect(m_quanta->scriptTab, TQT_SIGNAL(uploadScript(const TQString&)), m_quanta, TQT_SLOT(slotUploadScript(const TQString&)));
-  connect(m_quanta->dTab, TQT_SIGNAL(downloadDoc()), m_quanta, TQT_SLOT(slotDownloadDoc()));
-
-  connect(m_quanta->m_htmlPart, TQT_SIGNAL(onURL(const TQString&)),
-              m_quanta, TQT_SLOT(slotStatusMsg(const TQString&)));
-  connect(m_quanta->m_htmlPartDoc, TQT_SIGNAL(onURL(const TQString&)),
-                 m_quanta, TQT_SLOT(slotStatusMsg(const TQString&)));
-
-  connect(sTab, TQT_SIGNAL(newCursorPosition(int,int)), m_quanta, TQT_SLOT(setCursorPosition(int,int)));
-  connect(sTab, TQT_SIGNAL(selectArea(int,int,int,int)), m_quanta, TQT_SLOT( selectArea(int,int,int,int)));
-  connect(sTab, TQT_SIGNAL(selectTagArea(Node*)), m_quanta, TQT_SLOT(slotSelectTagArea(Node*)));
-  connect(sTab, TQT_SIGNAL(needReparse()), m_quanta, TQT_SLOT(slotForceReparse()));
-  connect(sTab, TQT_SIGNAL(showGroupsForDTEP(const TQString&, bool)), m_quanta, TQT_SLOT(slotShowGroupsForDTEP(const TQString&, bool)));
-  connect(sTab, TQT_SIGNAL(openFile(const KURL &)),
-          m_quanta, TQT_SLOT  (slotFileOpen(const KURL &)));
-  connect(sTab, TQT_SIGNAL(openImage  (const KURL&)),
-          m_quanta, TQT_SLOT(slotImageOpen(const KURL&)));
-  connect(sTab, TQT_SIGNAL(showProblemMessage(const TQString&)),
-          m_quanta->m_problemOutput, TQT_SLOT(showMessage(const TQString&)));
-  connect(sTab, TQT_SIGNAL(clearProblemOutput()),
-          m_quanta->m_problemOutput, TQT_SLOT(clear()));
-  connect(parser, TQT_SIGNAL(nodeTreeChanged()), sTab, TQT_SLOT(slotNodeTreeChanged()));
-
-  connect(m_quanta->dTab, TQT_SIGNAL(openURL(const TQString&)), m_quanta, TQT_SLOT(openDoc(const TQString&)));
-
-  connect(m_viewManager, TQT_SIGNAL(dragInsert(TQDropEvent *)), tTab, TQT_SLOT(slotDragInsert(TQDropEvent *)));
+  connect(m_quanta, TQ_SIGNAL(reloadAllTrees()),
+          m_quanta->fTab, TQ_SLOT(slotReloadAllTrees()));
+
+  connect(pTab, TQ_SIGNAL(loadToolbarFile  (const KURL&)),
+          m_quanta, TQ_SLOT(slotLoadToolbarFile(const KURL&)));
+  connect(m_viewManager, TQ_SIGNAL(viewActivated(const KURL&)),
+          pTab, TQ_SLOT(slotViewActivated(const KURL&)));
+
+  connect(m_viewManager, TQ_SIGNAL(documentClosed(const KURL&)),
+          pTab, TQ_SLOT(slotDocumentClosed(const KURL&)));
+  connect(m_viewManager, TQ_SIGNAL(documentClosed(const KURL&)),
+          tTab, TQ_SLOT(slotDocumentClosed(const KURL&)));
+  connect(m_viewManager, TQ_SIGNAL(documentClosed(const KURL&)),
+          m_quanta->scriptTab, TQ_SLOT(slotDocumentClosed(const KURL&)));
+  connect(m_viewManager, TQ_SIGNAL(documentClosed(const KURL&)),
+          m_quanta->fTab, TQ_SLOT(slotDocumentClosed(const KURL&)));
+
+  connect(tTab, TQ_SIGNAL(insertFile  (const KURL &)),
+          m_quanta, TQ_SLOT(slotInsertFile(const KURL &)));
+
+  connect(m_quanta->scriptTab, TQ_SIGNAL(openFileInPreview(const KURL &)),
+          m_quanta, TQ_SLOT(slotOpenFileInPreview(const KURL &)));
+  connect(m_quanta->scriptTab, TQ_SIGNAL(showPreviewWidget(bool)),
+          m_quanta, TQ_SLOT(slotShowPreviewWidget(bool)));
+  connect(m_quanta->scriptTab, TQ_SIGNAL(assignActionToScript(const KURL &, const TQString&)),
+          m_quanta, TQ_SLOT(slotAssignActionToScript(const KURL &, const TQString&)));
+  connect(m_quanta->scriptTab, TQ_SIGNAL(downloadScript()), m_quanta, TQ_SLOT(slotDownloadScript()));
+  connect(m_quanta->scriptTab, TQ_SIGNAL(uploadScript(const TQString&)), m_quanta, TQ_SLOT(slotUploadScript(const TQString&)));
+  connect(m_quanta->dTab, TQ_SIGNAL(downloadDoc()), m_quanta, TQ_SLOT(slotDownloadDoc()));
+
+  connect(m_quanta->m_htmlPart, TQ_SIGNAL(onURL(const TQString&)),
+              m_quanta, TQ_SLOT(slotStatusMsg(const TQString&)));
+  connect(m_quanta->m_htmlPartDoc, TQ_SIGNAL(onURL(const TQString&)),
+                 m_quanta, TQ_SLOT(slotStatusMsg(const TQString&)));
+
+  connect(sTab, TQ_SIGNAL(newCursorPosition(int,int)), m_quanta, TQ_SLOT(setCursorPosition(int,int)));
+  connect(sTab, TQ_SIGNAL(selectArea(int,int,int,int)), m_quanta, TQ_SLOT( selectArea(int,int,int,int)));
+  connect(sTab, TQ_SIGNAL(selectTagArea(Node*)), m_quanta, TQ_SLOT(slotSelectTagArea(Node*)));
+  connect(sTab, TQ_SIGNAL(needReparse()), m_quanta, TQ_SLOT(slotForceReparse()));
+  connect(sTab, TQ_SIGNAL(showGroupsForDTEP(const TQString&, bool)), m_quanta, TQ_SLOT(slotShowGroupsForDTEP(const TQString&, bool)));
+  connect(sTab, TQ_SIGNAL(openFile(const KURL &)),
+          m_quanta, TQ_SLOT  (slotFileOpen(const KURL &)));
+  connect(sTab, TQ_SIGNAL(openImage  (const KURL&)),
+          m_quanta, TQ_SLOT(slotImageOpen(const KURL&)));
+  connect(sTab, TQ_SIGNAL(showProblemMessage(const TQString&)),
+          m_quanta->m_problemOutput, TQ_SLOT(showMessage(const TQString&)));
+  connect(sTab, TQ_SIGNAL(clearProblemOutput()),
+          m_quanta->m_problemOutput, TQ_SLOT(clear()));
+  connect(parser, TQ_SIGNAL(nodeTreeChanged()), sTab, TQ_SLOT(slotNodeTreeChanged()));
+
+  connect(m_quanta->dTab, TQ_SIGNAL(openURL(const TQString&)), m_quanta, TQ_SLOT(openDoc(const TQString&)));
+
+  connect(m_viewManager, TQ_SIGNAL(dragInsert(TQDropEvent *)), tTab, TQ_SLOT(slotDragInsert(TQDropEvent *)));
 
   qConfig.windowLayout = "Default";
 }
@@ -710,74 +710,74 @@ void QuantaInit::loadInitialProject(const TQString& url)
 void QuantaInit::initActions()
 {
     TDEActionCollection *ac = m_quanta->actionCollection();
-    new TDEAction(i18n("Annotate..."), 0, m_quanta, TQT_SLOT(slotAnnotate()),ac, "annotate");
+    new TDEAction(i18n("Annotate..."), 0, m_quanta, TQ_SLOT(slotAnnotate()),ac, "annotate");
     m_quanta->editTagAction = new TDEAction( i18n( "&Edit Current Tag..." ), CTRL+Key_E,
-                        m_quanta, TQT_SLOT( slotEditCurrentTag() ),
+                        m_quanta, TQ_SLOT( slotEditCurrentTag() ),
                         ac, "edit_current_tag" );
     m_quanta->selectTagAreaAction = new TDEAction( i18n( "&Select Current Tag Area" ), 0,
-                        m_quanta, TQT_SLOT( slotSelectTagArea() ),
+                        m_quanta, TQ_SLOT( slotSelectTagArea() ),
                         ac, "select_tag_area" );
     new TDEAction( i18n( "E&xpand Abbreviation" ), CTRL+SHIFT+Key_J,
-                        m_quanta, TQT_SLOT( slotExpandAbbreviation() ),
+                        m_quanta, TQ_SLOT( slotExpandAbbreviation() ),
                         ac, "expand_abbreviation" );
 
-    new TDEAction(i18n("&Report Bug..."), 0, m_quanta, TQT_SLOT(slotReportBug()), ac, "help_reportbug"); //needed, because quanta_be bugs should be reported for quanta
+    new TDEAction(i18n("&Report Bug..."), 0, m_quanta, TQ_SLOT(slotReportBug()), ac, "help_reportbug"); //needed, because quanta_be bugs should be reported for quanta
 
     //Kate actions
 
 //Edit menu
-    KStdAction::undo(m_quanta, TQT_SLOT(slotUndo()), ac);
-    KStdAction::redo(m_quanta, TQT_SLOT(slotRedo()), ac);
-    KStdAction::cut(m_quanta, TQT_SLOT(slotCut()), ac);
-    KStdAction::copy(m_quanta, TQT_SLOT(slotCopy()), ac) ;
-    KStdAction::pasteText(m_quanta, TQT_SLOT(slotPaste()), ac);
+    KStdAction::undo(m_quanta, TQ_SLOT(slotUndo()), ac);
+    KStdAction::redo(m_quanta, TQ_SLOT(slotRedo()), ac);
+    KStdAction::cut(m_quanta, TQ_SLOT(slotCut()), ac);
+    KStdAction::copy(m_quanta, TQ_SLOT(slotCopy()), ac) ;
+    KStdAction::pasteText(m_quanta, TQ_SLOT(slotPaste()), ac);
 
 //help
    (void) new TDEAction(i18n("Ti&p of the Day"), "idea", "", m_quanta,
-      TQT_SLOT(slotHelpTip()), ac, "help_tip");
+      TQ_SLOT(slotHelpTip()), ac, "help_tip");
 
     // File actions
     //
-    KStdAction::openNew( m_quanta, TQT_SLOT( slotFileNew()  ), ac);
-    KStdAction::open   ( m_quanta, TQT_SLOT( slotFileOpen() ), ac, "file_open");
-    (void) new TDEAction(i18n("Close Other Tabs"), 0, ViewManager::ref(), TQT_SLOT(slotCloseOtherTabs()), ac, "close_other_tabs");
+    KStdAction::openNew( m_quanta, TQ_SLOT( slotFileNew()  ), ac);
+    KStdAction::open   ( m_quanta, TQ_SLOT( slotFileOpen() ), ac, "file_open");
+    (void) new TDEAction(i18n("Close Other Tabs"), 0, ViewManager::ref(), TQ_SLOT(slotCloseOtherTabs()), ac, "close_other_tabs");
 
-    m_quanta->fileRecent =  KStdAction::openRecent(m_quanta, TQT_SLOT(slotFileOpenRecent(const KURL&)),
+    m_quanta->fileRecent =  KStdAction::openRecent(m_quanta, TQ_SLOT(slotFileOpenRecent(const KURL&)),
                                          ac, "file_open_recent");
     m_quanta->fileRecent->setToolTip(i18n("Open / Open Recent"));
-    connect(m_quanta->fileRecent, TQT_SIGNAL(activated()), m_quanta, TQT_SLOT(slotFileOpen()));
+    connect(m_quanta->fileRecent, TQ_SIGNAL(activated()), m_quanta, TQ_SLOT(slotFileOpen()));
 
     (void) new TDEAction( i18n( "Close All" ), 0, m_quanta,
-                        TQT_SLOT( slotFileCloseAll() ),
+                        TQ_SLOT( slotFileCloseAll() ),
                         ac, "file_close_all" );
 
-    m_quanta->saveAction = KStdAction::save(m_quanta, TQT_SLOT( slotFileSave() ), ac);
+    m_quanta->saveAction = KStdAction::save(m_quanta, TQ_SLOT( slotFileSave() ), ac);
 
-    KStdAction::saveAs( m_quanta, TQT_SLOT( slotFileSaveAs() ), ac );
+    KStdAction::saveAs( m_quanta, TQ_SLOT( slotFileSaveAs() ), ac );
 
     m_quanta->saveAllAction = new TDEAction( i18n( "Save All..." ), "save_all", SHIFT+TDEStdAccel::shortcut(TDEStdAccel::Save).keyCodeQt(),
-                        m_quanta, TQT_SLOT( slotFileSaveAll() ),
+                        m_quanta, TQ_SLOT( slotFileSaveAll() ),
                         ac, "file_save_all" );
     (void)  new TDEAction(i18n("Reloa&d"), "document-revert", SHIFT+Key_F5, m_quanta,
-                        TQT_SLOT(slotFileReload()), ac, "file_reload");
+                        TQ_SLOT(slotFileReload()), ac, "file_reload");
 //    (void)  new TDEAction(i18n("Reload All "), 0, 0, m_quanta,
-//                        TQT_SLOT(slotFileReloadAll()), ac, "file_reload_all");
+//                        TQ_SLOT(slotFileReloadAll()), ac, "file_reload_all");
 
     (void) new TDEAction( i18n( "Save as Local Template..." ), 0,
-                        m_quanta, TQT_SLOT( slotFileSaveAsLocalTemplate() ),
+                        m_quanta, TQ_SLOT( slotFileSaveAsLocalTemplate() ),
                         ac, "save_local_template" );
 
     (void) new TDEAction( i18n( "Save Selection to Local Template File..." ), 0,
-                        m_quanta, TQT_SLOT( slotFileSaveSelectionAsLocalTemplate() ),
+                        m_quanta, TQ_SLOT( slotFileSaveSelectionAsLocalTemplate() ),
                         ac, "save_selection_local_template" );
 
-    KStdAction::quit( m_quanta, TQT_SLOT( slotFileQuit() ), ac );
+    KStdAction::quit( m_quanta, TQ_SLOT( slotFileQuit() ), ac );
 
     // Edit actions
 
     (void) new TDEAction( i18n( "Find in Files..." ),
                         SmallIcon("filefind"), CTRL+ALT+Key_F,
-                        m_quanta, TQT_SLOT( slotEditFindInFiles() ),
+                        m_quanta, TQ_SLOT( slotEditFindInFiles() ),
                         ac, "find_in_files" );
 
     TDEAction* aux = TagActionManager::self()->actionCollection()->action("apply_source_indentation");
@@ -787,57 +787,57 @@ void QuantaInit::initActions()
     // Tool actions
 
     (void) new TDEAction( i18n( "&Context Help..." ), CTRL+Key_H,
-                        m_quanta, TQT_SLOT( slotContextHelp() ),
+                        m_quanta, TQ_SLOT( slotContextHelp() ),
                         ac, "context_help" );
 
     (void) new TDEAction( i18n( "Tag &Attributes..." ), ALT+Key_Down,
-                        m_quanta->m_doc, TQT_SLOT( slotAttribPopup() ),
+                        m_quanta->m_doc, TQ_SLOT( slotAttribPopup() ),
                         ac, "tag_attributes" );
 
     (void) new TDEAction( i18n( "&Change the DTD..." ), 0,
-                        m_quanta, TQT_SLOT( slotChangeDTD() ),
+                        m_quanta, TQ_SLOT( slotChangeDTD() ),
                         ac, "change_dtd" );
 
     (void) new TDEAction( i18n( "&Edit DTD Settings..." ), 0,
-    m_quanta, TQT_SLOT( slotEditDTD() ),
+    m_quanta, TQ_SLOT( slotEditDTD() ),
     ac, "edit_dtd" );
 
     (void) new TDEAction( i18n( "&Load && Convert DTD..." ), 0,
-                        DTDs::ref(), TQT_SLOT( slotLoadDTD() ),
+                        DTDs::ref(), TQ_SLOT( slotLoadDTD() ),
                         ac, "load_dtd" );
     (void) new TDEAction( i18n( "Load DTD E&ntities..." ), 0,
-                        DTDs::ref(), TQT_SLOT( slotLoadEntities() ),
+                        DTDs::ref(), TQ_SLOT( slotLoadEntities() ),
                         ac, "load_entities" );
 
     (void) new TDEAction( i18n( "Load DTD &Package (DTEP)..." ), 0,
-                        m_quanta, TQT_SLOT( slotLoadDTEP() ),
+                        m_quanta, TQ_SLOT( slotLoadDTEP() ),
                         ac, "load_dtep" );
 
     (void) new TDEAction( i18n( "Send DTD Package (DTEP) in E&mail..." ), "mail-send", 0,
-                        m_quanta, TQT_SLOT( slotEmailDTEP() ),
+                        m_quanta, TQ_SLOT( slotEmailDTEP() ),
                         ac, "send_dtep" );
 
     (void) new TDEAction( i18n( "&Download DTD Package (DTEP)..." ), "network", 0,
-                        m_quanta, TQT_SLOT( slotDownloadDTEP() ),
+                        m_quanta, TQ_SLOT( slotDownloadDTEP() ),
                         ac, "download_dtep" );
     (void) new TDEAction( i18n( "&Upload DTD Package (DTEP)..." ), "network", 0,
-                        m_quanta, TQT_SLOT( slotUploadDTEP() ),
+                        m_quanta, TQ_SLOT( slotUploadDTEP() ),
                         ac, "upload_dtep" );
 /*
     (void) new TDEAction( i18n( "&Upload DTD Package (DTEP)..." ), 0,
-                        m_quanta, TQT_SLOT( slotUploadDTEP() ),
+                        m_quanta, TQ_SLOT( slotUploadDTEP() ),
                         ac, "send_dtep" );
 */
     (void) new TDEAction( i18n( "&Document Properties" ), 0,
-                        m_quanta, TQT_SLOT( slotDocumentProperties() ),
+                        m_quanta, TQ_SLOT( slotDocumentProperties() ),
                         ac, "tools_document_properties" );
 
     (void) new TDEAction ( i18n ("F&ormat XML Code"), 0,
-                        m_quanta, TQT_SLOT( slotCodeFormatting() ),
+                        m_quanta, TQ_SLOT( slotCodeFormatting() ),
                         ac, "tools_code_formatting");
 
     (void) new TDEAction( i18n( "&Convert Tag && Attribute Case..."), 0,
-                        m_quanta, TQT_SLOT(slotConvertCase()),
+                        m_quanta, TQ_SLOT(slotConvertCase()),
                         ac, "tools_change_case");
 
     // View actions
@@ -845,19 +845,19 @@ void QuantaInit::initActions()
 
     m_quanta->showSourceAction =
       new TDEToggleAction( i18n( "&Source Editor"), UserIcon ("view_text"), ALT+Key_F9,
-                         m_quanta, TQT_SLOT( slotShowSourceEditor()),
+                         m_quanta, TQ_SLOT( slotShowSourceEditor()),
                          ac, "show_quanta_editor");
     m_quanta->showSourceAction->setExclusiveGroup("view");
 
     m_quanta->showVPLAction =
       new TDEToggleAction( i18n( "&VPL Editor"), UserIcon ("vpl"), CTRL+SHIFT+Key_F9,
-      m_quanta, TQT_SLOT( slotShowVPLOnly() ),
+      m_quanta, TQ_SLOT( slotShowVPLOnly() ),
                           ac, "show_kafka_view");
     m_quanta->showVPLAction->setExclusiveGroup("view");
 
     m_quanta->showVPLSourceAction =
       new TDEToggleAction( i18n("VPL && So&urce Editors"), UserIcon ("vpl_text"), Key_F9,
-                         m_quanta, TQT_SLOT( slotShowVPLAndSourceEditor() ),
+                         m_quanta, TQ_SLOT( slotShowVPLAndSourceEditor() ),
                           ac, "show_kafka_and_quanta");
     m_quanta->showVPLSourceAction->setExclusiveGroup("view");
     /**kafkaSelectAction = new TDESelectAction(i18n("Main &View"), 0, ac,"show_kafka");
@@ -866,73 +866,73 @@ void QuantaInit::initActions()
     list2.append(i18n("&VPL Editor (experimental)"));
     list2.append(i18n("&Both Editors"));
     kafkaSelectAction->setItems(list2);
-    connect(kafkaSelectAction, TQT_SIGNAL(activated(int)), m_quanta, TQT_SLOT(slotShowKafkaPartl(int)));*/
+    connect(kafkaSelectAction, TQ_SIGNAL(activated(int)), m_quanta, TQ_SLOT(slotShowKafkaPartl(int)));*/
 
 
     (void) new TDEAction( i18n( "&Reload Preview" ), "reload",
                         TDEStdAccel::shortcut(TDEStdAccel::Reload).keyCodeQt(),
-                        m_quanta, TQT_SLOT(slotRepaintPreview()),
+                        m_quanta, TQ_SLOT(slotRepaintPreview()),
                         ac, "reload" );
 
     (void) new TDEAction( i18n( "&Previous File" ), "1leftarrow", TDEStdAccel::back(),
-                        m_quanta, TQT_SLOT( slotBack() ),
+                        m_quanta, TQ_SLOT( slotBack() ),
                         ac, "previous_file" );
 
     (void) new TDEAction( i18n( "&Next File" ), "1rightarrow", TDEStdAccel::forward(),
-                        m_quanta, TQT_SLOT( slotForward() ),
+                        m_quanta, TQ_SLOT( slotForward() ),
                         ac, "next_file" );
 
     // Options actions
     //
 
     (void) new TDEAction( i18n( "Configure &Actions..." ), UserIcon("ball"),0,
-                        m_quanta, TQT_SLOT( slotOptionsConfigureActions() ),
+                        m_quanta, TQ_SLOT( slotOptionsConfigureActions() ),
                         ac, "configure_actions" );
 
-    KStdAction::showMenubar(m_quanta, TQT_SLOT(slotShowMenuBar()), ac, "options_show_menubar");
-    KStdAction::keyBindings(m_quanta, TQT_SLOT( slotOptionsConfigureKeys() ), ac, "configure_shortcuts");
-    KStdAction::configureToolbars(m_quanta, TQT_SLOT( slotOptionsConfigureToolbars() ), ac, "options_configure_toolbars");
-    KStdAction::preferences(m_quanta, TQT_SLOT( slotOptions() ), ac, "general_options");
-    new TDEAction(i18n("Configure Pre&view..."), SmallIcon("konqueror"), 0, m_quanta, TQT_SLOT(slotPreviewOptions()), ac, "preview_options");
+    KStdAction::showMenubar(m_quanta, TQ_SLOT(slotShowMenuBar()), ac, "options_show_menubar");
+    KStdAction::keyBindings(m_quanta, TQ_SLOT( slotOptionsConfigureKeys() ), ac, "configure_shortcuts");
+    KStdAction::configureToolbars(m_quanta, TQ_SLOT( slotOptionsConfigureToolbars() ), ac, "options_configure_toolbars");
+    KStdAction::preferences(m_quanta, TQ_SLOT( slotOptions() ), ac, "general_options");
+    new TDEAction(i18n("Configure Pre&view..."), SmallIcon("konqueror"), 0, m_quanta, TQ_SLOT(slotPreviewOptions()), ac, "preview_options");
 
     // Toolbars actions
     m_quanta->projectToolbarFiles = new TDERecentFilesAction(i18n("Load &Project Toolbar"),0,
-                                                           m_quanta, TQT_SLOT(slotLoadToolbarFile(const KURL&)),
+                                                           m_quanta, TQ_SLOT(slotLoadToolbarFile(const KURL&)),
                                                            ac, "toolbars_load_project");
 
-    new TDEAction(i18n("Load &Global Toolbar..."), 0, m_quanta, TQT_SLOT(slotLoadGlobalToolbar()), ac, "toolbars_load_global");
-    new TDEAction(i18n("Load &Local Toolbar..."), 0, m_quanta, TQT_SLOT(slotLoadToolbar()), ac, "toolbars_load_user");
-    new TDEAction(i18n("Save as &Local Toolbar..."), 0, m_quanta, TQT_SLOT(slotSaveLocalToolbar()), ac, "toolbars_save_local");
-    new TDEAction(i18n("Save as &Project Toolbar..."), 0, m_quanta, TQT_SLOT(slotSaveProjectToolbar()), ac, "toolbars_save_project");
-    new TDEAction(i18n("&New User Toolbar..."),  0, m_quanta, TQT_SLOT(slotAddToolbar()), ac, "toolbars_add");
-    new TDEAction(i18n("&Remove User Toolbar..."), 0, m_quanta, TQT_SLOT(slotRemoveToolbar()), ac, "toolbars_remove");
-    new TDEAction(i18n("Re&name User Toolbar..."), 0, m_quanta, TQT_SLOT(slotRenameToolbar()), ac, "toolbars_rename");
-    new TDEAction(i18n("Send Toolbar in E&mail..."), "mail-send", 0, m_quanta, TQT_SLOT(slotSendToolbar()), ac, "toolbars_send");
-    new TDEAction(i18n("&Upload Toolbar..." ), "network", 0, m_quanta, TQT_SLOT(slotUploadToolbar()), ac, "toolbars_upload" );
-    new TDEAction(i18n("&Download Toolbar..." ), "network", 0, m_quanta, TQT_SLOT(slotDownloadToolbar()), ac, "toolbars_download" );
+    new TDEAction(i18n("Load &Global Toolbar..."), 0, m_quanta, TQ_SLOT(slotLoadGlobalToolbar()), ac, "toolbars_load_global");
+    new TDEAction(i18n("Load &Local Toolbar..."), 0, m_quanta, TQ_SLOT(slotLoadToolbar()), ac, "toolbars_load_user");
+    new TDEAction(i18n("Save as &Local Toolbar..."), 0, m_quanta, TQ_SLOT(slotSaveLocalToolbar()), ac, "toolbars_save_local");
+    new TDEAction(i18n("Save as &Project Toolbar..."), 0, m_quanta, TQ_SLOT(slotSaveProjectToolbar()), ac, "toolbars_save_project");
+    new TDEAction(i18n("&New User Toolbar..."),  0, m_quanta, TQ_SLOT(slotAddToolbar()), ac, "toolbars_add");
+    new TDEAction(i18n("&Remove User Toolbar..."), 0, m_quanta, TQ_SLOT(slotRemoveToolbar()), ac, "toolbars_remove");
+    new TDEAction(i18n("Re&name User Toolbar..."), 0, m_quanta, TQ_SLOT(slotRenameToolbar()), ac, "toolbars_rename");
+    new TDEAction(i18n("Send Toolbar in E&mail..."), "mail-send", 0, m_quanta, TQ_SLOT(slotSendToolbar()), ac, "toolbars_send");
+    new TDEAction(i18n("&Upload Toolbar..." ), "network", 0, m_quanta, TQ_SLOT(slotUploadToolbar()), ac, "toolbars_upload" );
+    new TDEAction(i18n("&Download Toolbar..." ), "network", 0, m_quanta, TQ_SLOT(slotDownloadToolbar()), ac, "toolbars_download" );
 
     TDEToggleAction *toggle = new TDEToggleAction( i18n("Smart Tag Insertion"), 0, ac, "smart_tag_insertion");
-    connect(toggle, TQT_SIGNAL(toggled(bool)), m_quanta, TQT_SLOT(slotSmartTagInsertion()));
+    connect(toggle, TQ_SIGNAL(toggled(bool)), m_quanta, TQ_SLOT(slotSmartTagInsertion()));
 
     m_quanta->showDTDToolbar=new TDEToggleAction(i18n("Show DTD Toolbar"), 0, ac, "view_dtd_toolbar");
 
-    connect(m_quanta->showDTDToolbar, TQT_SIGNAL(toggled(bool)), m_quanta, TQT_SLOT(slotToggleDTDToolbar(bool)));
+    connect(m_quanta->showDTDToolbar, TQ_SIGNAL(toggled(bool)), m_quanta, TQ_SLOT(slotToggleDTDToolbar(bool)));
     m_quanta->showDTDToolbar->setCheckedState(i18n("Hide DTD Toolbar"));
 
     new TDEAction(i18n("Complete Text"), CTRL+Key_Space,
-                m_quanta, TQT_SLOT(slotShowCompletion()), ac,"show_completion");
+                m_quanta, TQ_SLOT(slotShowCompletion()), ac,"show_completion");
     new TDEAction(i18n("Completion Hints"), CTRL+SHIFT+Key_Space,
-                m_quanta, TQT_SLOT(slotShowCompletionHint()), ac,"show_completion_hint");
+                m_quanta, TQ_SLOT(slotShowCompletionHint()), ac,"show_completion_hint");
 
-    KStdAction::back(m_quanta, TQT_SLOT( slotBack() ), ac, "w_back");
-    KStdAction::forward(m_quanta, TQT_SLOT( slotForward() ), ac, "w_forward");
+    KStdAction::back(m_quanta, TQ_SLOT( slotBack() ), ac, "w_back");
+    KStdAction::forward(m_quanta, TQ_SLOT( slotForward() ), ac, "w_forward");
 
-    new TDEAction(i18n("Open File: none"), 0, m_quanta, TQT_SLOT(slotOpenFileUnderCursor()), ac, "open_file_under_cursor");
-    new TDEAction(i18n("Upload..."), 0, m_quanta, TQT_SLOT(slotUploadFile()), ac, "upload_file");
-    new TDEAction(i18n("Delete File"), 0, m_quanta, TQT_SLOT(slotDeleteFile()), ac, "delete_file");
+    new TDEAction(i18n("Open File: none"), 0, m_quanta, TQ_SLOT(slotOpenFileUnderCursor()), ac, "open_file_under_cursor");
+    new TDEAction(i18n("Upload..."), 0, m_quanta, TQ_SLOT(slotUploadFile()), ac, "upload_file");
+    new TDEAction(i18n("Delete File"), 0, m_quanta, TQ_SLOT(slotDeleteFile()), ac, "delete_file");
 
     TQString ss = i18n("Upload Opened Project Files...");
-/*    new TDEAction(i18n("Upload Opened Project Files"), 0, m_quanta, TQT_SLOT(slotUploadOpenedFiles()), ac, "upload_opened_files"); */
+/*    new TDEAction(i18n("Upload Opened Project Files"), 0, m_quanta, TQ_SLOT(slotUploadOpenedFiles()), ac, "upload_opened_files"); */
 
     TQString error;
     int el, ec;
@@ -993,16 +993,16 @@ void QuantaInit::initActions()
     // create the preview action
     m_quanta->showPreviewAction =
       new TDEToolBarPopupAction( i18n( "&Preview" ), "preview", Key_F6,
-                         m_quanta, TQT_SLOT( slotToggleShowPreview() ),
+                         m_quanta, TQ_SLOT( slotToggleShowPreview() ),
                          ac, "show_preview" );
 
     TDEAction *act = new TDEAction( i18n( "Preview Without Frames" ), "", 0,
-                                  m_quanta, TQT_SLOT(slotShowNoFramesPreview()),
+                                  m_quanta, TQ_SLOT(slotShowNoFramesPreview()),
                                   ac, "show_preview_no_frames" );
     act->plug(m_quanta->showPreviewAction->popupMenu());
 
     act = new TDEAction( i18n( "View with &Konqueror" ), "konqueror", Key_F12,
-                        m_quanta, TQT_SLOT( slotViewInKFM() ),
+                        m_quanta, TQ_SLOT( slotViewInKFM() ),
                         ac, "view_with_konqueror" );
     act->plug(m_quanta->showPreviewAction->popupMenu());
 
@@ -1024,62 +1024,62 @@ void QuantaInit::initActions()
       act->plug(m_quanta->showPreviewAction->popupMenu());
 
     act = new TDEAction( i18n( "View with L&ynx" ), "terminal", 0,
-                        m_quanta, TQT_SLOT( slotViewInLynx() ),
+                        m_quanta, TQ_SLOT( slotViewInLynx() ),
                         ac, "view_with_lynx" );
     act->plug(m_quanta->showPreviewAction->popupMenu());
 
 
     (void) new TDEAction( i18n( "Table Editor..." ), "quick_table", 0,
-                        m_quanta, TQT_SLOT( slotTagEditTable() ),
+                        m_quanta, TQ_SLOT( slotTagEditTable() ),
                         ac, "tag_edit_table" );
 
     (void) new TDEAction( i18n( "Quick List..." ), "quick_list", 0,
-                        m_quanta, TQT_SLOT( slotTagQuickList() ),
+                        m_quanta, TQ_SLOT( slotTagQuickList() ),
                         ac, "tag_quick_list" );
 
     (void) new TDEAction( i18n( "Color..." ), "colorize", CTRL+SHIFT+Key_C,
-                        m_quanta, TQT_SLOT( slotTagColor() ),
+                        m_quanta, TQ_SLOT( slotTagColor() ),
                         ac, "tag_color" );
 
 
     (void) new TDEAction( i18n( "Email..." ), "tag_mail", 0,
-                        m_quanta, TQT_SLOT( slotTagMail() ),
+                        m_quanta, TQ_SLOT( slotTagMail() ),
                         ac, "tag_mail" );
 
     (void) new TDEAction( i18n( "Misc. Tag..." ), "tag_misc", CTRL+SHIFT+Key_T,
-                        m_quanta, TQT_SLOT( slotTagMisc() ),
+                        m_quanta, TQ_SLOT( slotTagMisc() ),
                         ac, "tag_misc" );
 
     (void) new TDEAction( i18n( "Frame Wizard..." ), "frame", 0,
-                        m_quanta, TQT_SLOT( slotFrameWizard() ),
+                        m_quanta, TQ_SLOT( slotFrameWizard() ),
                         ac, "tag_frame_wizard" );
 
     (void) new TDEAction( i18n( "Paste &HTML Quoted" ), "edit-paste", 0,
-                        m_quanta, TQT_SLOT( slotPasteHTMLQuoted() ),
+                        m_quanta, TQ_SLOT( slotPasteHTMLQuoted() ),
                         ac, "edit_paste_html_quoted" );
 
     (void) new TDEAction( i18n( "Paste &URL Encoded" ), "edit-paste", 0,
-                        m_quanta, TQT_SLOT( slotPasteURLEncoded() ),
+                        m_quanta, TQ_SLOT( slotPasteURLEncoded() ),
                         ac, "edit_paste_url_encoded" );
 
     (void) new TDEAction( i18n( "Insert CSS..." ),"css", 0,
-                        m_quanta, TQT_SLOT( slotInsertCSS() ),
+                        m_quanta, TQ_SLOT( slotInsertCSS() ),
                         ac, "insert_css" );
 
     // special-character combo
     TDEAction* char_action = new TDEAction(
                         i18n( "Insert Special Character" ), "charset", 0,
                         ac, "insert_char" );
-    connect( char_action, TQT_SIGNAL(activated()),
-             m_quanta, TQT_SLOT(slotInsertChar()) );
+    connect( char_action, TQ_SIGNAL(activated()),
+             m_quanta, TQ_SLOT(slotInsertChar()) );
 
-    connect(m_quanta, TQT_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQT_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
-    connect(m_quanta->doc(), TQT_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQT_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
-    connect(ViewManager::ref(), TQT_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQT_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
+    connect(m_quanta, TQ_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQ_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
+    connect(m_quanta->doc(), TQ_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQ_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
+    connect(ViewManager::ref(), TQ_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(m_quanta), TQ_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
 
     QuantaBookmarks *m_bookmarks = new QuantaBookmarks(ViewManager::ref(m_quanta));
     m_bookmarks->createActions(ac);
-    connect(m_bookmarks, TQT_SIGNAL(gotoFileAndLine(const TQString&, int, int)), m_quanta, TQT_SLOT(gotoFileAndLine(const TQString&, int, int)));
+    connect(m_bookmarks, TQ_SIGNAL(gotoFileAndLine(const TQString&, int, int)), m_quanta, TQ_SLOT(gotoFileAndLine(const TQString&, int, int)));
 }
 
 /** Initialize the plugin architecture. */
@@ -1089,10 +1089,10 @@ void QuantaInit::initPlugins()
 
   m_quanta->m_pluginInterface = QuantaPluginInterface::ref(m_quanta);
 
-  connect(m_quanta->m_pluginInterface, TQT_SIGNAL(hideSplash()),
-          m_quanta, TQT_SLOT(slotHideSplash()));
-  connect(m_quanta->m_pluginInterface, TQT_SIGNAL(statusMsg(const TQString &)),
-          m_quanta, TQT_SLOT(slotStatusMsg(const TQString & )));
+  connect(m_quanta->m_pluginInterface, TQ_SIGNAL(hideSplash()),
+          m_quanta, TQ_SLOT(slotHideSplash()));
+  connect(m_quanta->m_pluginInterface, TQ_SIGNAL(statusMsg(const TQString &)),
+          m_quanta, TQ_SLOT(slotStatusMsg(const TQString & )));
 
   m_quanta->m_pluginInterface->readConfig();
   if (!m_quanta->m_pluginInterface->pluginAvailable("TDEFileReplace"))
@@ -1276,12 +1276,12 @@ void QuantaInit::recoverCrashed(TQStringList& recoveredFileNameList)
   TDEProcess *execCommand = new TDEProcess();
   *(execCommand) << TQStringList::split(" ",cmd);
 
-  connect(execCommand, TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
-          m_quanta, TQT_SLOT(slotGetScriptOutput(TDEProcess*,char*,int)));
-  connect(execCommand, TQT_SIGNAL(receivedStderr(TDEProcess*,char*,int)),
-          m_quanta, TQT_SLOT(slotGetScriptError(TDEProcess*,char*,int)));
-  connect(execCommand, TQT_SIGNAL(processExited(TDEProcess*)),
-          m_quanta, TQT_SLOT(slotProcessExited(TDEProcess*)));
+  connect(execCommand, TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
+          m_quanta, TQ_SLOT(slotGetScriptOutput(TDEProcess*,char*,int)));
+  connect(execCommand, TQ_SIGNAL(receivedStderr(TDEProcess*,char*,int)),
+          m_quanta, TQ_SLOT(slotGetScriptError(TDEProcess*,char*,int)));
+  connect(execCommand, TQ_SIGNAL(processExited(TDEProcess*)),
+          m_quanta, TQ_SLOT(slotProcessExited(TDEProcess*)));
 
   if (!execCommand->start(TDEProcess::NotifyOnExit,TDEProcess::All))
   {
@@ -1291,8 +1291,8 @@ void QuantaInit::recoverCrashed(TQStringList& recoveredFileNameList)
   {
     //To avoid lock-ups, start a timer.
     TQTimer *timer = new TQTimer(m_quanta);
-    connect(timer, TQT_SIGNAL(timeout()),
-            m_quanta, TQT_SLOT(slotProcessTimeout()));
+    connect(timer, TQ_SIGNAL(timeout()),
+            m_quanta, TQ_SLOT(slotProcessTimeout()));
     timer->start(180*1000, true);
     QExtFileInfo internalFileInfo;
     m_quanta->m_loopStarted = true;
@@ -1487,10 +1487,10 @@ void QuantaInit::checkRuntimeDependencies()
   } else
   {
      CVSService::ref(m_quanta->actionCollection())->setAppId(appId);
-     connect(CVSService::ref(), TQT_SIGNAL(clearMessages()), m_quanta->m_messageOutput, TQT_SLOT(clear()));
-     connect(CVSService::ref(), TQT_SIGNAL(showMessage(const TQString&, bool)), m_quanta->m_messageOutput, TQT_SLOT(showMessage(const TQString&, bool)));
-     connect(CVSService::ref(), TQT_SIGNAL(commandExecuted(const TQString&, const TQStringList&)), m_quanta, TQT_SLOT(slotCVSCommandExecuted(const TQString&, const TQStringList&)));
-     //connect(CVSService::ref(), TQT_SIGNAL(statusMsg(const TQString &)),  m_quanta, TQT_SLOT(slotStatusMsg(const TQString & )));
+     connect(CVSService::ref(), TQ_SIGNAL(clearMessages()), m_quanta->m_messageOutput, TQ_SLOT(clear()));
+     connect(CVSService::ref(), TQ_SIGNAL(showMessage(const TQString&, bool)), m_quanta->m_messageOutput, TQ_SLOT(showMessage(const TQString&, bool)));
+     connect(CVSService::ref(), TQ_SIGNAL(commandExecuted(const TQString&, const TQStringList&)), m_quanta, TQ_SLOT(slotCVSCommandExecuted(const TQString&, const TQStringList&)));
+     //connect(CVSService::ref(), TQ_SIGNAL(statusMsg(const TQString &)),  m_quanta, TQ_SLOT(slotStatusMsg(const TQString & )));
      m_quanta->fTab->plugCVSMenu();
      pTab->plugCVSMenu();
   }
diff --git a/quanta/src/quantadoc.cpp b/quanta/src/quantadoc.cpp
index 354cb464..b77e2341 100644
--- a/quanta/src/quantadoc.cpp
+++ b/quanta/src/quantadoc.cpp
@@ -82,7 +82,7 @@ QuantaDoc::QuantaDoc(TQWidget *parent, const char *name) : TQObject(parent, name
 
   attribMenu = new TDEPopupMenu();
   attribMenu->insertTitle(i18n("Tag"));
-  connect( attribMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotInsertAttrib(int)));
+  connect( attribMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotInsertAttrib(int)));
 }
 
 QuantaDoc::~QuantaDoc()
@@ -175,10 +175,10 @@ void QuantaDoc::openDocument(const KURL& urlToOpen, const TQString &a_encoding,
     {
        if (encoding.isEmpty())
           encoding = quantaApp->defaultEncoding();
-       w->disconnect(TQT_SIGNAL(openingFailed(const KURL&)));
-       connect(w, TQT_SIGNAL(openingFailed(const KURL&)), this, TQT_SLOT(slotOpeningFailed(const KURL&)));
-       w->disconnect(TQT_SIGNAL(openingCompleted(const KURL&)));
-       connect(w, TQT_SIGNAL(openingCompleted(const KURL&)), this, TQT_SLOT(slotOpeningCompleted(const KURL&)));
+       w->disconnect(TQ_SIGNAL(openingFailed(const KURL&)));
+       connect(w, TQ_SIGNAL(openingFailed(const KURL&)), this, TQ_SLOT(slotOpeningFailed(const KURL&)));
+       w->disconnect(TQ_SIGNAL(openingCompleted(const KURL&)));
+       connect(w, TQ_SIGNAL(openingCompleted(const KURL&)), this, TQ_SLOT(slotOpeningCompleted(const KURL&)));
        w->open(url, encoding);
        quantaApp->setTitle(url.prettyURL(0, KURL::StripFileProtocol));
     }
@@ -302,7 +302,7 @@ void QuantaDoc::slotAttribPopup()
           popUpMenu->setItemEnabled( menuId , false );
         }
        }
-       connect( popUpMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotInsertAttrib(int)));
+       connect( popUpMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotInsertAttrib(int)));
        attribMenu->insertItem(*it, popUpMenu);
       }
 
@@ -367,7 +367,7 @@ void QuantaDoc::slotInsertAttrib( int id )
     delete attribMenu;
     attribMenu = new TDEPopupMenu();
     attribMenu->insertTitle(i18n("Tag"));
-    connect( attribMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotInsertAttrib(int)));
+    connect( attribMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotInsertAttrib(int)));
   }
 }
 
diff --git a/quanta/src/quantaview.cpp b/quanta/src/quantaview.cpp
index 8003ce62..8e867d9a 100644
--- a/quanta/src/quantaview.cpp
+++ b/quanta/src/quantaview.cpp
@@ -86,8 +86,8 @@ QuantaView::QuantaView(TQWidget *parent, const char *name, const TQString &capti
 {
   setMDICaption(caption);
 //Connect the VPL update timers
-  connect(&m_sourceUpdateTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(sourceUpdateTimerTimeout()));
-  connect(&m_VPLUpdateTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(VPLUpdateTimerTimeout()));
+  connect(&m_sourceUpdateTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(sourceUpdateTimerTimeout()));
+  connect(&m_VPLUpdateTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(VPLUpdateTimerTimeout()));
 
 //create the source and VPL holding widgets
   m_documentArea = new TQWidget(this);
@@ -186,18 +186,18 @@ void QuantaView::addDocument(Document *document)
    if (!document)
      return;
    m_document = document;
-   connect(m_document, TQT_SIGNAL(editorGotFocus()), this, TQT_SLOT(slotSourceGetFocus()));
-   connect(m_document->view(), TQT_SIGNAL(cursorPositionChanged()), this, TQT_SIGNAL(cursorPositionChanged()));
+   connect(m_document, TQ_SIGNAL(editorGotFocus()), this, TQ_SLOT(slotSourceGetFocus()));
+   connect(m_document->view(), TQ_SIGNAL(cursorPositionChanged()), this, TQ_SIGNAL(cursorPositionChanged()));
 
 
    m_kafkaDocument = KafkaDocument::ref();
 
-  connect(m_kafkaDocument->getKafkaWidget(), TQT_SIGNAL(hasFocus(bool)),
-    this, TQT_SLOT(slotVPLGetFocus(bool)));
-  connect(m_kafkaDocument, TQT_SIGNAL(newCursorPosition(int,int)),
-    this, TQT_SLOT(slotSetCursorPositionInSource(int, int)));
-  connect(m_kafkaDocument, TQT_SIGNAL(loadingError(Node *)),
-    this, TQT_SLOT(slotVPLLoadingError(Node *)));
+  connect(m_kafkaDocument->getKafkaWidget(), TQ_SIGNAL(hasFocus(bool)),
+    this, TQ_SLOT(slotVPLGetFocus(bool)));
+  connect(m_kafkaDocument, TQ_SIGNAL(newCursorPosition(int,int)),
+    this, TQ_SLOT(slotSetCursorPositionInSource(int, int)));
+  connect(m_kafkaDocument, TQ_SIGNAL(loadingError(Node *)),
+    this, TQ_SLOT(slotVPLLoadingError(Node *)));
 
    m_kafkaReloadingEnabled = true;
    m_quantaReloadingEnabled = true;
@@ -1134,8 +1134,8 @@ bool QuantaView::saveDocument(const KURL& url)
   {
     KTextEditor::Document *doc = m_document->doc();
     m_eventLoopStarted = false;
-    connect(doc, TQT_SIGNAL(canceled(const TQString &)), this, TQT_SLOT(slotSavingFailed(const TQString &)));
-    connect(doc, TQT_SIGNAL(completed()), this, TQT_SLOT(slotSavingCompleted()));
+    connect(doc, TQ_SIGNAL(canceled(const TQString &)), this, TQ_SLOT(slotSavingFailed(const TQString &)));
+    connect(doc, TQ_SIGNAL(completed()), this, TQ_SLOT(slotSavingCompleted()));
     m_saveResult = m_document->saveAs(url);
     if (m_saveResult)
     {
@@ -1144,8 +1144,8 @@ bool QuantaView::saveDocument(const KURL& url)
       m_eventLoopStarted = true;
       internalFileInfo.enter_loop();
     }
-    disconnect(doc, TQT_SIGNAL(canceled(const TQString &)), this, TQT_SLOT(slotSavingFailed(const TQString &)));
-    disconnect(doc, TQT_SIGNAL(completed()), this, TQT_SLOT(slotSavingCompleted()));
+    disconnect(doc, TQ_SIGNAL(canceled(const TQString &)), this, TQ_SLOT(slotSavingFailed(const TQString &)));
+    disconnect(doc, TQ_SIGNAL(completed()), this, TQ_SLOT(slotSavingCompleted()));
     if (!m_saveResult) //there was an error while saving
     {
       if (oldURL.isLocalFile())
diff --git a/quanta/src/viewmanager.cpp b/quanta/src/viewmanager.cpp
index c2717de4..2e70966b 100644
--- a/quanta/src/viewmanager.cpp
+++ b/quanta/src/viewmanager.cpp
@@ -71,20 +71,20 @@ ViewManager::ViewManager(TQObject *parent, const char *name) : TQObject(parent,
     m_lastActiveEditorView = 0L;
     m_documentationView = 0L;
     m_tabPopup = new TDEPopupMenu(quantaApp);
-    m_tabPopup->insertItem(SmallIcon("window-close"), i18n("&Close"), this, TQT_SLOT(slotCloseView()));
-    m_tabPopup->insertItem(i18n("Close &Other Tabs"), this, TQT_SLOT(slotCloseOtherTabs()));
-    m_tabPopup->insertItem(i18n("Close &All"), this, TQT_SLOT(closeAll()));
-    m_tabPopup->insertItem(SmallIcon("document-revert"), i18n("&Reload"), this, TQT_SLOT(slotReloadFile()), 0, RELOAD_ID);
-    m_tabPopup->insertItem(SmallIcon("go-up"), i18n("&Upload File"), this, TQT_SLOT(slotUploadFile()), 0, UPLOAD_ID);
-    m_tabPopup->insertItem(SmallIcon("edit-delete"), i18n("&Delete File"), this, TQT_SLOT(slotDeleteFile()), 0, DELETE_ID);
+    m_tabPopup->insertItem(SmallIcon("window-close"), i18n("&Close"), this, TQ_SLOT(slotCloseView()));
+    m_tabPopup->insertItem(i18n("Close &Other Tabs"), this, TQ_SLOT(slotCloseOtherTabs()));
+    m_tabPopup->insertItem(i18n("Close &All"), this, TQ_SLOT(closeAll()));
+    m_tabPopup->insertItem(SmallIcon("document-revert"), i18n("&Reload"), this, TQ_SLOT(slotReloadFile()), 0, RELOAD_ID);
+    m_tabPopup->insertItem(SmallIcon("go-up"), i18n("&Upload File"), this, TQ_SLOT(slotUploadFile()), 0, UPLOAD_ID);
+    m_tabPopup->insertItem(SmallIcon("edit-delete"), i18n("&Delete File"), this, TQ_SLOT(slotDeleteFile()), 0, DELETE_ID);
     m_tabPopup->insertSeparator();
     m_fileListPopup = new TDEPopupMenu(quantaApp);
-    connect(m_fileListPopup, TQT_SIGNAL(aboutToShow()), this, TQT_SLOT(slotFileListPopupAboutToShow()));
-    connect(m_fileListPopup, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotFileListPopupItemActivated(int)));
+    connect(m_fileListPopup, TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(slotFileListPopupAboutToShow()));
+    connect(m_fileListPopup, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotFileListPopupItemActivated(int)));
     m_bookmarks = new QuantaBookmarks(this, QuantaBookmarks::Position, true);
     m_bookmarksMenu = new TDEPopupMenu(quantaApp);
     m_bookmarks->setBookmarksMenu(m_bookmarksMenu);
-    connect(m_bookmarks, TQT_SIGNAL(gotoFileAndLine(const TQString&, int, int)), quantaApp, TQT_SLOT(gotoFileAndLine(const TQString&, int, int)));
+    connect(m_bookmarks, TQ_SIGNAL(gotoFileAndLine(const TQString&, int, int)), quantaApp, TQ_SLOT(gotoFileAndLine(const TQString&, int, int)));
     m_bookmarksMenuId = m_tabPopup->insertItem(SmallIconSet("bookmark"), i18n("&Bookmarks"), m_bookmarksMenu);
     m_tabPopup->insertItem(i18n("&Switch To"), m_fileListPopup);
     m_contextView = 0L;
@@ -96,14 +96,14 @@ QuantaView* ViewManager::createView(const TQString &caption)
 {
     QuantaView *view = new QuantaView(quantaApp, "", caption);
     quantaApp->addWindow(view);
-    connect(view, TQT_SIGNAL(cursorPositionChanged()), quantaApp, TQT_SLOT(slotNewLineColumn()));
-    connect(view, TQT_SIGNAL(title(const TQString &)), quantaApp, TQT_SLOT(slotNewLineColumn()));
-    connect(view, TQT_SIGNAL(dragInsert(TQDropEvent*)), this, TQT_SIGNAL(dragInsert(TQDropEvent *)));
-    connect(view, TQT_SIGNAL(hidePreview()), quantaApp, TQT_SLOT(slotChangePreviewStatus()));
-    disconnect(view, TQT_SIGNAL(childWindowCloseRequest( KMdiChildView *)), 0, 0 );
-    connect(view, TQT_SIGNAL(childWindowCloseRequest( KMdiChildView*)), this, TQT_SLOT(slotCloseRequest(KMdiChildView*)));
-    connect(view, TQT_SIGNAL(documentClosed(const KURL&)), this, TQT_SLOT(slotDocumentClosed(const KURL&)));
-    connect(view, TQT_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(), TQT_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
+    connect(view, TQ_SIGNAL(cursorPositionChanged()), quantaApp, TQ_SLOT(slotNewLineColumn()));
+    connect(view, TQ_SIGNAL(title(const TQString &)), quantaApp, TQ_SLOT(slotNewLineColumn()));
+    connect(view, TQ_SIGNAL(dragInsert(TQDropEvent*)), this, TQ_SIGNAL(dragInsert(TQDropEvent *)));
+    connect(view, TQ_SIGNAL(hidePreview()), quantaApp, TQ_SLOT(slotChangePreviewStatus()));
+    disconnect(view, TQ_SIGNAL(childWindowCloseRequest( KMdiChildView *)), 0, 0 );
+    connect(view, TQ_SIGNAL(childWindowCloseRequest( KMdiChildView*)), this, TQ_SLOT(slotCloseRequest(KMdiChildView*)));
+    connect(view, TQ_SIGNAL(documentClosed(const KURL&)), this, TQ_SLOT(slotDocumentClosed(const KURL&)));
+    connect(view, TQ_SIGNAL(eventHappened(const TQString&, const TQString&, const TQString& )), QPEvents::ref(), TQ_SLOT(slotEventHappened(const TQString&, const TQString&, const TQString& )));
 
     return view;
 }
@@ -125,7 +125,7 @@ void ViewManager::createNewDocument()
   KTextEditor::Document *doc = KTextEditor::createDocument ("libkatepart", view, "KTextEditor::Document");
 #endif
   Document *w = new Document(doc, 0L);
-  connect(w, TQT_SIGNAL(showAnnotation(uint, const TQString&, const TQPair<TQString, TQString>&)), quantaApp->annotationOutput(), TQT_SLOT(insertAnnotation(uint, const TQString&, const TQPair<TQString, TQString>&)));
+  connect(w, TQ_SIGNAL(showAnnotation(uint, const TQString&, const TQPair<TQString, TQString>&)), quantaApp->annotationOutput(), TQ_SLOT(insertAnnotation(uint, const TQString&, const TQPair<TQString, TQString>&)));
   TQString encoding = quantaApp->defaultEncoding();
   KTextEditor::EncodingInterface* encodingIf = dynamic_cast<KTextEditor::EncodingInterface*>(doc);
   if (encodingIf)
@@ -134,7 +134,7 @@ void ViewManager::createNewDocument()
   KTextEditor::View * v = w->view();
 
   //[MB02] connect all kate views for drag and drop
-  connect(w->view(), TQT_SIGNAL(dropEventPass(TQDropEvent *)), this, TQT_SIGNAL(dragInsert(TQDropEvent *)));
+  connect(w->view(), TQ_SIGNAL(dropEventPass(TQDropEvent *)), this, TQ_SIGNAL(dragInsert(TQDropEvent *)));
 
   w->setUntitledUrl( fname );
   KTextEditor::PopupMenuInterface* popupIf = dynamic_cast<KTextEditor::PopupMenuInterface*>(w->view());
@@ -143,7 +143,7 @@ void ViewManager::createNewDocument()
 
   quantaApp->setFocusProxy(w->view());
   w->view()->setFocusPolicy(TQWidget::WheelFocus);
-  connect( v, TQT_SIGNAL(newStatus()), quantaApp, TQT_SLOT(slotNewStatus()));
+  connect( v, TQ_SIGNAL(newStatus()), quantaApp, TQ_SLOT(slotNewStatus()));
 
   quantaApp->slotNewPart(doc, true);  // register new part in partmanager and make active
   view->addDocument(w);
@@ -186,7 +186,7 @@ bool ViewManager::removeView(QuantaView *view, bool force, bool createNew)
         if (view == activeView())
             ToolbarTabWidget::ref()->reparent(0L, 0, TQPoint(), false);
         if (!createNew)
-          disconnect(quantaApp, TQT_SIGNAL(lastChildViewClosed()), this, TQT_SLOT(slotLastViewClosed()));
+          disconnect(quantaApp, TQ_SIGNAL(lastChildViewClosed()), this, TQ_SLOT(slotLastViewClosed()));
         quantaApp->closeWindow(view);
         if (createNew)
         {
@@ -195,7 +195,7 @@ bool ViewManager::removeView(QuantaView *view, bool force, bool createNew)
             quantaApp->slotFileNew();
           }
         } else
-          connect(quantaApp, TQT_SIGNAL(lastChildViewClosed()), this, TQT_SLOT(slotLastViewClosed()));
+          connect(quantaApp, TQ_SIGNAL(lastChildViewClosed()), this, TQ_SLOT(slotLastViewClosed()));
         return true;
        }
     }
@@ -484,8 +484,8 @@ bool ViewManager::closeAll(bool createNew)
       return false;  //save aborted
     }
   }
-  disconnect(quantaApp, TQT_SIGNAL(viewActivated (KMdiChildView *)), this, TQT_SLOT(slotViewActivated(KMdiChildView*)));
-  disconnect(quantaApp, TQT_SIGNAL(lastChildViewClosed()), this, TQT_SLOT(slotLastViewClosed()));
+  disconnect(quantaApp, TQ_SIGNAL(viewActivated (KMdiChildView *)), this, TQ_SLOT(slotViewActivated(KMdiChildView*)));
+  disconnect(quantaApp, TQ_SIGNAL(lastChildViewClosed()), this, TQ_SLOT(slotLastViewClosed()));
   ToolbarTabWidget::ref()->reparent(0L, 0, TQPoint(), false);
 
   for (childIt = children.begin(); childIt != children.end(); ++childIt)
@@ -512,8 +512,8 @@ bool ViewManager::closeAll(bool createNew)
               } else
               {
                 //actually this code should be never executed
-               connect(quantaApp, TQT_SIGNAL(viewActivated (KMdiChildView *)), this, TQT_SLOT(slotViewActivated(KMdiChildView*)));
-               connect(quantaApp, TQT_SIGNAL(lastChildViewClosed()), this, TQT_SLOT(slotLastViewClosed()));
+               connect(quantaApp, TQ_SIGNAL(viewActivated (KMdiChildView *)), this, TQ_SLOT(slotViewActivated(KMdiChildView*)));
+               connect(quantaApp, TQ_SIGNAL(lastChildViewClosed()), this, TQ_SLOT(slotLastViewClosed()));
                view->activated();
                emit filesClosed(false);
                 return false;
@@ -527,8 +527,8 @@ bool ViewManager::closeAll(bool createNew)
           }
       }
   }
-  connect(quantaApp, TQT_SIGNAL(viewActivated (KMdiChildView *)), this, TQT_SLOT(slotViewActivated(KMdiChildView*)));
-  connect(quantaApp, TQT_SIGNAL(lastChildViewClosed()), this, TQT_SLOT(slotLastViewClosed()));
+  connect(quantaApp, TQ_SIGNAL(viewActivated (KMdiChildView *)), this, TQ_SLOT(slotViewActivated(KMdiChildView*)));
+  connect(quantaApp, TQ_SIGNAL(lastChildViewClosed()), this, TQ_SLOT(slotLastViewClosed()));
   if (createNew)
   {
       createNewDocument();