Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

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

6 files changed, 712 insertions, 712 deletions

diff --git a/src/gui/application/LircClient.cpp b/src/gui/application/LircClient.cpp
index 34fb57e..64163fc 100644
--- a/src/gui/application/LircClient.cpp
+++ b/src/gui/application/LircClient.cpp
@@ -61,7 +61,7 @@ LircClient::LircClient(void)
     }
 
     m_socketNotifier = new TQSocketNotifier(m_socket, TQSocketNotifier::Read, 0);
-    connect(m_socketNotifier, TQT_SIGNAL(activated(int)), this, TQT_SLOT(readButton()) );
+    connect(m_socketNotifier, TQ_SIGNAL(activated(int)), this, TQ_SLOT(readButton()) );
 
     RG_DEBUG << "LircClient::LircClient: connected to socket: " << m_socket << endl;
 }
diff --git a/src/gui/application/LircCommander.cpp b/src/gui/application/LircCommander.cpp
index 2224048..cc919fe 100644
--- a/src/gui/application/LircCommander.cpp
+++ b/src/gui/application/LircCommander.cpp
@@ -45,33 +45,33 @@ LircCommander::LircCommander(LircClient *lirc, RosegardenGUIApp *rgGUIApp)
 {
     m_lirc = lirc;
     m_rgGUIApp = rgGUIApp;
-    connect(m_lirc, TQT_SIGNAL(buttonPressed(char *)),
-            this, TQT_SLOT(slotExecute(char *)) );
-
-    connect(this, TQT_SIGNAL(play()),
-            m_rgGUIApp, TQT_SLOT(slotPlay()) );
-    connect(this, TQT_SIGNAL(stop()),
-            m_rgGUIApp, TQT_SLOT(slotStop()) );
-    connect(this, TQT_SIGNAL(record()),
-            m_rgGUIApp, TQT_SLOT(slotRecord()) );
-    connect(this, TQT_SIGNAL(rewind()),
-            m_rgGUIApp, TQT_SLOT(slotRewind()) );
-    connect(this, TQT_SIGNAL(rewindToBeginning()),
-            m_rgGUIApp, TQT_SLOT(slotRewindToBeginning()) );
-    connect(this, TQT_SIGNAL(fastForward()),
-            m_rgGUIApp, TQT_SLOT(slotFastforward()) );
-    connect(this, TQT_SIGNAL(fastForwardToEnd()),
-            m_rgGUIApp, TQT_SLOT(slotFastForwardToEnd()) );
-    connect(this, TQT_SIGNAL(toggleRecord()),
-            m_rgGUIApp, TQT_SLOT(slotToggleRecord()) );
-    connect(this, TQT_SIGNAL(trackDown()),
-            m_rgGUIApp, TQT_SLOT(slotTrackDown()) );
-    connect(this, TQT_SIGNAL(trackUp()),
-            m_rgGUIApp, TQT_SLOT(slotTrackUp()) );
-    connect(this, TQT_SIGNAL(trackMute()),
-            m_rgGUIApp, TQT_SLOT(slotToggleMutedCurrentTrack()) );
-    connect(this, TQT_SIGNAL(trackRecord()),
-            m_rgGUIApp, TQT_SLOT(slotToggleRecordCurrentTrack()) );
+    connect(m_lirc, TQ_SIGNAL(buttonPressed(char *)),
+            this, TQ_SLOT(slotExecute(char *)) );
+
+    connect(this, TQ_SIGNAL(play()),
+            m_rgGUIApp, TQ_SLOT(slotPlay()) );
+    connect(this, TQ_SIGNAL(stop()),
+            m_rgGUIApp, TQ_SLOT(slotStop()) );
+    connect(this, TQ_SIGNAL(record()),
+            m_rgGUIApp, TQ_SLOT(slotRecord()) );
+    connect(this, TQ_SIGNAL(rewind()),
+            m_rgGUIApp, TQ_SLOT(slotRewind()) );
+    connect(this, TQ_SIGNAL(rewindToBeginning()),
+            m_rgGUIApp, TQ_SLOT(slotRewindToBeginning()) );
+    connect(this, TQ_SIGNAL(fastForward()),
+            m_rgGUIApp, TQ_SLOT(slotFastforward()) );
+    connect(this, TQ_SIGNAL(fastForwardToEnd()),
+            m_rgGUIApp, TQ_SLOT(slotFastForwardToEnd()) );
+    connect(this, TQ_SIGNAL(toggleRecord()),
+            m_rgGUIApp, TQ_SLOT(slotToggleRecord()) );
+    connect(this, TQ_SIGNAL(trackDown()),
+            m_rgGUIApp, TQ_SLOT(slotTrackDown()) );
+    connect(this, TQ_SIGNAL(trackUp()),
+            m_rgGUIApp, TQ_SLOT(slotTrackUp()) );
+    connect(this, TQ_SIGNAL(trackMute()),
+            m_rgGUIApp, TQ_SLOT(slotToggleMutedCurrentTrack()) );
+    connect(this, TQ_SIGNAL(trackRecord()),
+            m_rgGUIApp, TQ_SLOT(slotToggleRecordCurrentTrack()) );
 }
 
 LircCommander::command LircCommander::commands[] =
diff --git a/src/gui/application/RosegardenGUIApp.cpp b/src/gui/application/RosegardenGUIApp.cpp
index e1de78a..b747edb 100644
--- a/src/gui/application/RosegardenGUIApp.cpp
+++ b/src/gui/application/RosegardenGUIApp.cpp
@@ -285,9 +285,9 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
 
 
     if (startupStatusMessageReceiver) {
-        TQObject::connect(this, TQT_SIGNAL(startupStatusMessage(TQString)),
+        TQObject::connect(this, TQ_SIGNAL(startupStatusMessage(TQString)),
                          startupStatusMessageReceiver,
-                         TQT_SLOT(slotShowStatusMessage(TQString)));
+                         TQ_SLOT(slotShowStatusMessage(TQString)));
     }
 
     // Try to start the sequencer
@@ -354,14 +354,14 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
                            KDockWidget::DockLeft,  // dock site
                            20);                   // relation target/this (in percent)
 
-    connect(m_dockLeft, TQT_SIGNAL(iMBeingClosed()),
-            this, TQT_SLOT(slotParametersClosed()));
-    connect(m_dockLeft, TQT_SIGNAL(hasUndocked()),
-            this, TQT_SLOT(slotParametersClosed()));
+    connect(m_dockLeft, TQ_SIGNAL(iMBeingClosed()),
+            this, TQ_SLOT(slotParametersClosed()));
+    connect(m_dockLeft, TQ_SIGNAL(hasUndocked()),
+            this, TQ_SLOT(slotParametersClosed()));
     // Apparently, hasUndocked() is emitted when the dock widget's
     // 'close' button on the dock handle is clicked.
-    connect(m_mainDockWidget, TQT_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
-            this, TQT_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
+    connect(m_mainDockWidget, TQ_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
+            this, TQ_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
 
     stateChanged("parametersbox_closed", KXMLGUIClient::StateReverse);
 
@@ -391,35 +391,35 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
     m_dockLeft->update();
 
     connect(m_instrumentParameterBox,
-            TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
+            TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
             this,
-            TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
+            TQ_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
 
     connect(m_instrumentParameterBox,
-            TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
+            TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
             this,
-            TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
+            TQ_SLOT(slotShowPluginGUI(InstrumentId, int)));
 
     // relay this through our own signal so that others can use it too
     connect(m_instrumentParameterBox,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
             this,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
             m_instrumentParameterBox,
-            TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
+            TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
             m_instrumentParameterBox,
-            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(this,
-            TQT_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
+            TQ_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
             m_instrumentParameterBox,
-            TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
+            TQ_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
 
     // Load the initial document (this includes doc's own autoload)
     //
@@ -439,8 +439,8 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
     }
 
     if (m_view) {
-        connect(m_seqManager, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
-                m_view, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
+        connect(m_seqManager, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
+                m_view, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
     }
 
     if (m_seqManager->getSoundDriverStatus() & AUDIO_OK) {
@@ -494,7 +494,7 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
 
     stateChanged("have_project_packager", KXMLGUIClient::StateReverse);
     stateChanged("have_lilypondview", KXMLGUIClient::StateReverse);
-    TQTimer::singleShot(1000, this, TQT_SLOT(slotTestStartupTester()));
+    TQTimer::singleShot(1000, this, TQ_SLOT(slotTestStartupTester()));
 }
 
 RosegardenGUIApp::~RosegardenGUIApp()
@@ -539,101 +539,101 @@ void RosegardenGUIApp::setupActions()
 {
     // setup File menu
     // New Window ?
-    KStdAction::openNew (this, TQT_SLOT(slotFileNew()), actionCollection());
-    KStdAction::open (this, TQT_SLOT(slotFileOpen()), actionCollection());
+    KStdAction::openNew (this, TQ_SLOT(slotFileNew()), actionCollection());
+    KStdAction::open (this, TQ_SLOT(slotFileOpen()), actionCollection());
     m_fileRecent = KStdAction::openRecent(this,
-                                          TQT_SLOT(slotFileOpenRecent(const KURL&)),
+                                          TQ_SLOT(slotFileOpenRecent(const KURL&)),
                                           actionCollection());
-    KStdAction::save (this, TQT_SLOT(slotFileSave()), actionCollection());
-    KStdAction::saveAs(this, TQT_SLOT(slotFileSaveAs()), actionCollection());
-    KStdAction::revert(this, TQT_SLOT(slotRevertToSaved()), actionCollection());
-    KStdAction::close (this, TQT_SLOT(slotFileClose()), actionCollection());
-    KStdAction::print (this, TQT_SLOT(slotFilePrint()), actionCollection());
-    KStdAction::printPreview (this, TQT_SLOT(slotFilePrintPreview()), actionCollection());
+    KStdAction::save (this, TQ_SLOT(slotFileSave()), actionCollection());
+    KStdAction::saveAs(this, TQ_SLOT(slotFileSaveAs()), actionCollection());
+    KStdAction::revert(this, TQ_SLOT(slotRevertToSaved()), actionCollection());
+    KStdAction::close (this, TQ_SLOT(slotFileClose()), actionCollection());
+    KStdAction::print (this, TQ_SLOT(slotFilePrint()), actionCollection());
+    KStdAction::printPreview (this, TQ_SLOT(slotFilePrintPreview()), actionCollection());
 
     new TDEAction(i18n("Import Rosegarden &Project file..."), 0, 0, this,
-                TQT_SLOT(slotImportProject()), actionCollection(),
+                TQ_SLOT(slotImportProject()), actionCollection(),
                 "file_import_project");
 
     new TDEAction(i18n("Import &MIDI file..."), 0, 0, this,
-                TQT_SLOT(slotImportMIDI()), actionCollection(),
+                TQ_SLOT(slotImportMIDI()), actionCollection(),
                 "file_import_midi");
 
     new TDEAction(i18n("Import &Rosegarden 2.1 file..."), 0, 0, this,
-                TQT_SLOT(slotImportRG21()), actionCollection(),
+                TQ_SLOT(slotImportRG21()), actionCollection(),
                 "file_import_rg21");
 
     new TDEAction(i18n("Import &Hydrogen file..."), 0, 0, this,
-                TQT_SLOT(slotImportHydrogen()), actionCollection(),
+                TQ_SLOT(slotImportHydrogen()), actionCollection(),
                 "file_import_hydrogen");
 
     new TDEAction(i18n("Merge &File..."), 0, 0, this,
-                TQT_SLOT(slotMerge()), actionCollection(),
+                TQ_SLOT(slotMerge()), actionCollection(),
                 "file_merge");
 
     new TDEAction(i18n("Merge &MIDI file..."), 0, 0, this,
-                TQT_SLOT(slotMergeMIDI()), actionCollection(),
+                TQ_SLOT(slotMergeMIDI()), actionCollection(),
                 "file_merge_midi");
 
     new TDEAction(i18n("Merge &Rosegarden 2.1 file..."), 0, 0, this,
-                TQT_SLOT(slotMergeRG21()), actionCollection(),
+                TQ_SLOT(slotMergeRG21()), actionCollection(),
                 "file_merge_rg21");
 
     new TDEAction(i18n("Merge &Hydrogen file..."), 0, 0, this,
-                TQT_SLOT(slotMergeHydrogen()), actionCollection(),
+                TQ_SLOT(slotMergeHydrogen()), actionCollection(),
                 "file_merge_hydrogen");
 
     new TDEAction(i18n("Export Rosegarden &Project file..."), 0, 0, this,
-                TQT_SLOT(slotExportProject()), actionCollection(),
+                TQ_SLOT(slotExportProject()), actionCollection(),
                 "file_export_project");
 
     new TDEAction(i18n("Export &MIDI file..."), 0, 0, this,
-                TQT_SLOT(slotExportMIDI()), actionCollection(),
+                TQ_SLOT(slotExportMIDI()), actionCollection(),
                 "file_export_midi");
 
     new TDEAction(i18n("Export &LilyPond file..."), 0, 0, this,
-                TQT_SLOT(slotExportLilyPond()), actionCollection(),
+                TQ_SLOT(slotExportLilyPond()), actionCollection(),
                 "file_export_lilypond");
 
     new TDEAction(i18n("Export Music&XML file..."), 0, 0, this,
-                TQT_SLOT(slotExportMusicXml()), actionCollection(),
+                TQ_SLOT(slotExportMusicXml()), actionCollection(),
                 "file_export_musicxml");
 
     new TDEAction(i18n("Export &Csound score file..."), 0, 0, this,
-                TQT_SLOT(slotExportCsound()), actionCollection(),
+                TQ_SLOT(slotExportCsound()), actionCollection(),
                 "file_export_csound");
 
     new TDEAction(i18n("Export M&up file..."), 0, 0, this,
-                TQT_SLOT(slotExportMup()), actionCollection(),
+                TQ_SLOT(slotExportMup()), actionCollection(),
                 "file_export_mup");
 
     new TDEAction(i18n("Print &with LilyPond..."), 0, 0, this,
-                TQT_SLOT(slotPrintLilyPond()), actionCollection(),
+                TQ_SLOT(slotPrintLilyPond()), actionCollection(),
                 "file_print_lilypond");
 
     new TDEAction(i18n("Preview with Lil&yPond..."), 0, 0, this,
-                TQT_SLOT(slotPreviewLilyPond()), actionCollection(),
+                TQ_SLOT(slotPreviewLilyPond()), actionCollection(),
                 "file_preview_lilypond");
 
     new TDEAction(i18n("Play&list"), 0, 0, this,
-                TQT_SLOT(slotPlayList()), actionCollection(),
+                TQ_SLOT(slotPlayList()), actionCollection(),
                 "file_show_playlist");
 
-    KStdAction::quit (this, TQT_SLOT(slotQuit()), actionCollection());
+    KStdAction::quit (this, TQ_SLOT(slotQuit()), actionCollection());
 
     // help menu
     new TDEAction(i18n("Rosegarden &Tutorial"), 0, 0, this,
-                TQT_SLOT(slotTutorial()), actionCollection(),
+                TQ_SLOT(slotTutorial()), actionCollection(),
                 "tutorial");
 
     new TDEAction(i18n("&Bug Reporting Guidelines"), 0, 0, this,
-                TQT_SLOT(slotBugGuidelines()), actionCollection(),
+                TQ_SLOT(slotBugGuidelines()), actionCollection(),
                 "guidelines");
 
     // setup edit menu
-    KStdAction::cut (this, TQT_SLOT(slotEditCut()), actionCollection());
-    KStdAction::copy (this, TQT_SLOT(slotEditCopy()), actionCollection());
-    KStdAction::paste (this, TQT_SLOT(slotEditPaste()), actionCollection());
+    KStdAction::cut (this, TQ_SLOT(slotEditCut()), actionCollection());
+    KStdAction::copy (this, TQ_SLOT(slotEditCopy()), actionCollection());
+    KStdAction::paste (this, TQ_SLOT(slotEditPaste()), actionCollection());
 
     //
     // undo/redo actions are special in that they are connected to
@@ -657,86 +657,86 @@ void RosegardenGUIApp::setupActions()
 
     // setup Settings menu
     //
-    m_viewToolBar = KStdAction::showToolbar (this, TQT_SLOT(slotToggleToolBar()), actionCollection(),
+    m_viewToolBar = KStdAction::showToolbar (this, TQ_SLOT(slotToggleToolBar()), actionCollection(),
                     "show_stock_toolbar");
 
     m_viewToolsToolBar = new TDEToggleAction(i18n("Show T&ools Toolbar"), 0, this,
-                                           TQT_SLOT(slotToggleToolsToolBar()), actionCollection(),
+                                           TQ_SLOT(slotToggleToolsToolBar()), actionCollection(),
                                            "show_tools_toolbar");
 
     m_viewTracksToolBar = new TDEToggleAction(i18n("Show Trac&ks Toolbar"), 0, this,
-                                            TQT_SLOT(slotToggleTracksToolBar()), actionCollection(),
+                                            TQ_SLOT(slotToggleTracksToolBar()), actionCollection(),
                                             "show_tracks_toolbar");
 
     m_viewEditorsToolBar = new TDEToggleAction(i18n("Show &Editors Toolbar"), 0, this,
-                           TQT_SLOT(slotToggleEditorsToolBar()), actionCollection(),
+                           TQ_SLOT(slotToggleEditorsToolBar()), actionCollection(),
                            "show_editors_toolbar");
 
     m_viewTransportToolBar = new TDEToggleAction(i18n("Show Trans&port Toolbar"), 0, this,
-                             TQT_SLOT(slotToggleTransportToolBar()), actionCollection(),
+                             TQ_SLOT(slotToggleTransportToolBar()), actionCollection(),
                              "show_transport_toolbar");
 
     m_viewZoomToolBar = new TDEToggleAction(i18n("Show &Zoom Toolbar"), 0, this,
-                                          TQT_SLOT(slotToggleZoomToolBar()), actionCollection(),
+                                          TQ_SLOT(slotToggleZoomToolBar()), actionCollection(),
                                           "show_zoom_toolbar");
 
-    m_viewStatusBar = KStdAction::showStatusbar(this, TQT_SLOT(slotToggleStatusBar()),
+    m_viewStatusBar = KStdAction::showStatusbar(this, TQ_SLOT(slotToggleStatusBar()),
                       actionCollection(), "show_status_bar");
 
     m_viewTransport = new TDEToggleAction(i18n("Show Tra&nsport"), Key_T, this,
-                                        TQT_SLOT(slotToggleTransport()),
+                                        TQ_SLOT(slotToggleTransport()),
                                         actionCollection(),
                                         "show_transport");
 
     m_viewTrackLabels = new TDEToggleAction(i18n("Show Track &Labels"), 0, this,
-                                          TQT_SLOT(slotToggleTrackLabels()),
+                                          TQ_SLOT(slotToggleTrackLabels()),
                                           actionCollection(),
                                           "show_tracklabels");
 
     m_viewRulers = new TDEToggleAction(i18n("Show Playback Position R&uler"), 0, this,
-                                     TQT_SLOT(slotToggleRulers()),
+                                     TQ_SLOT(slotToggleRulers()),
                                      actionCollection(),
                                      "show_rulers");
 
     m_viewTempoRuler = new TDEToggleAction(i18n("Show Te&mpo Ruler"), 0, this,
-                                         TQT_SLOT(slotToggleTempoRuler()),
+                                         TQ_SLOT(slotToggleTempoRuler()),
                                          actionCollection(),
                                          "show_tempo_ruler");
 
     m_viewChordNameRuler = new TDEToggleAction(i18n("Show Cho&rd Name Ruler"), 0, this,
-                           TQT_SLOT(slotToggleChordNameRuler()),
+                           TQ_SLOT(slotToggleChordNameRuler()),
                            actionCollection(),
                            "show_chord_name_ruler");
 
 
     m_viewPreviews = new TDEToggleAction(i18n("Show Segment Pre&views"), 0, this,
-                                       TQT_SLOT(slotTogglePreviews()),
+                                       TQ_SLOT(slotTogglePreviews()),
                                        actionCollection(),
                                        "show_previews");
 
     new TDEAction(i18n("Show Special &Parameters"), Key_P, this,
-                TQT_SLOT(slotDockParametersBack()),
+                TQ_SLOT(slotDockParametersBack()),
                 actionCollection(),
                 "show_inst_segment_parameters");
 
-    KStdAction::tipOfDay( this, TQT_SLOT( slotShowTip() ), actionCollection() );
+    KStdAction::tipOfDay( this, TQ_SLOT( slotShowTip() ), actionCollection() );
 
     // Standard Actions
     //
     KStdAction::saveOptions(this,
-                            TQT_SLOT(slotSaveOptions()),
+                            TQ_SLOT(slotSaveOptions()),
                             actionCollection());
 
     KStdAction::preferences(this,
-                            TQT_SLOT(slotConfigure()),
+                            TQ_SLOT(slotConfigure()),
                             actionCollection());
 
     KStdAction::keyBindings(this,
-                            TQT_SLOT(slotEditKeys()),
+                            TQ_SLOT(slotEditKeys()),
                             actionCollection());
 
     KStdAction::configureToolbars(this,
-                                  TQT_SLOT(slotEditToolbars()),
+                                  TQ_SLOT(slotEditToolbars()),
                                   actionCollection());
 
     TDERadioAction *action = 0;
@@ -749,110 +749,110 @@ void RosegardenGUIApp::setupActions()
 
     // TODO : add some shortcuts here
     action = new TDERadioAction(i18n("&Select and Edit"), icon, Key_F2,
-                              this, TQT_SLOT(slotPointerSelected()),
+                              this, TQ_SLOT(slotPointerSelected()),
                               actionCollection(), "select");
     action->setExclusiveGroup("segmenttools");
 
     action = new TDERadioAction(i18n("&Draw"), "pencil", Key_F3,
-                              this, TQT_SLOT(slotDrawSelected()),
+                              this, TQ_SLOT(slotDrawSelected()),
                               actionCollection(), "draw");
     action->setExclusiveGroup("segmenttools");
 
     action = new TDERadioAction(i18n("&Erase"), "eraser", Key_F4,
-                              this, TQT_SLOT(slotEraseSelected()),
+                              this, TQ_SLOT(slotEraseSelected()),
                               actionCollection(), "erase");
     action->setExclusiveGroup("segmenttools");
 
     action = new TDERadioAction(i18n("&Move"), "move", Key_F5,
-                              this, TQT_SLOT(slotMoveSelected()),
+                              this, TQ_SLOT(slotMoveSelected()),
                               actionCollection(), "move");
     action->setExclusiveGroup("segmenttools");
 
     pixmap.load(pixmapDir + "/toolbar/resize.xpm");
     icon = TQIconSet(pixmap);
     action = new TDERadioAction(i18n("&Resize"), icon, Key_F6,
-                              this, TQT_SLOT(slotResizeSelected()),
+                              this, TQ_SLOT(slotResizeSelected()),
                               actionCollection(), "resize");
     action->setExclusiveGroup("segmenttools");
 
     pixmap.load(pixmapDir + "/toolbar/split.xpm");
     icon = TQIconSet(pixmap);
     action = new TDERadioAction(i18n("&Split"), icon, Key_F7,
-                              this, TQT_SLOT(slotSplitSelected()),
+                              this, TQ_SLOT(slotSplitSelected()),
                               actionCollection(), "split");
     action->setExclusiveGroup("segmenttools");
 
     pixmap.load(pixmapDir + "/toolbar/join.xpm");
     icon = TQIconSet(pixmap);
     action = new TDERadioAction(i18n("&Join"), icon, 0,
-                              this, TQT_SLOT(slotJoinSelected()),
+                              this, TQ_SLOT(slotJoinSelected()),
                               actionCollection(), "join");
     action->setExclusiveGroup("segmenttools");
 
 
     new TDEAction(i18n("&Harmonize"), 0, this,
-                TQT_SLOT(slotHarmonizeSelection()), actionCollection(),
+                TQ_SLOT(slotHarmonizeSelection()), actionCollection(),
                 "harmonize_selection");
 
     pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png");
     icon = TQIconSet(pixmap);
     new TDEAction(AddTimeSignatureCommand::getGlobalName(),
                 icon, 0,
-                this, TQT_SLOT(slotEditTimeSignature()),
+                this, TQ_SLOT(slotEditTimeSignature()),
                 actionCollection(), "add_time_signature");
 
     new TDEAction(i18n("Open Tempo and Time Signature Editor"), 0, this,
-                TQT_SLOT(slotEditTempos()), actionCollection(), "edit_tempos");
+                TQ_SLOT(slotEditTempos()), actionCollection(), "edit_tempos");
 
     //
     // Edit menu
     //
     new TDEAction(i18n("Cut Range"), Key_X + CTRL + SHIFT, this,
-                TQT_SLOT(slotCutRange()), actionCollection(),
+                TQ_SLOT(slotCutRange()), actionCollection(),
                 "cut_range");
 
     new TDEAction(i18n("Copy Range"), Key_C + CTRL + SHIFT, this,
-                TQT_SLOT(slotCopyRange()), actionCollection(),
+                TQ_SLOT(slotCopyRange()), actionCollection(),
                 "copy_range");
 
     new TDEAction(i18n("Paste Range"), Key_V + CTRL + SHIFT, this,
-                TQT_SLOT(slotPasteRange()), actionCollection(),
+                TQ_SLOT(slotPasteRange()), actionCollection(),
                 "paste_range");
 /*
     new TDEAction(i18n("Delete Range"), Key_Delete + SHIFT, this,
-                TQT_SLOT(slotDeleteRange()), actionCollection(),
+                TQ_SLOT(slotDeleteRange()), actionCollection(),
                 "delete_range");
 */
     new TDEAction(i18n("Insert Range..."), Key_Insert + SHIFT, this,
-                TQT_SLOT(slotInsertRange()), actionCollection(),
+                TQ_SLOT(slotInsertRange()), actionCollection(),
                 "insert_range");
 
     new TDEAction(i18n("De&lete"), Key_Delete, this,
-                TQT_SLOT(slotDeleteSelectedSegments()), actionCollection(),
+                TQ_SLOT(slotDeleteSelectedSegments()), actionCollection(),
                 "delete");
 
     new TDEAction(i18n("Select &All Segments"), Key_A + CTRL, this,
-                TQT_SLOT(slotSelectAll()), actionCollection(),
+                TQ_SLOT(slotSelectAll()), actionCollection(),
                 "select_all");
 
     pixmap.load(pixmapDir + "/toolbar/event-insert-tempo.png");
     icon = TQIconSet(pixmap);
     new TDEAction(AddTempoChangeCommand::getGlobalName(),
                 icon, 0,
-                this, TQT_SLOT(slotEditTempo()),
+                this, TQ_SLOT(slotEditTempo()),
                 actionCollection(), "add_tempo");
 
     new TDEAction(ChangeCompositionLengthCommand::getGlobalName(),
                 0,
-                this, TQT_SLOT(slotChangeCompositionLength()),
+                this, TQ_SLOT(slotChangeCompositionLength()),
                 actionCollection(), "change_composition_length");
 
     new TDEAction(i18n("Edit Mar&kers..."), Key_K + CTRL, this,
-                TQT_SLOT(slotEditMarkers()),
+                TQ_SLOT(slotEditMarkers()),
                 actionCollection(), "edit_markers");
 
     new TDEAction(i18n("Edit Document P&roperties..."), 0, this,
-                TQT_SLOT(slotEditDocumentProperties()),
+                TQ_SLOT(slotEditDocumentProperties()),
                 actionCollection(), "edit_doc_properties");
 
 
@@ -860,120 +860,120 @@ void RosegardenGUIApp::setupActions()
     // Segments menu
     //
     new TDEAction(i18n("Open in &Default Editor"), Key_Return, this,
-                TQT_SLOT(slotEdit()), actionCollection(),
+                TQ_SLOT(slotEdit()), actionCollection(),
                 "edit_default");
 
     pixmap.load(pixmapDir + "/toolbar/matrix.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Open in Matri&x Editor"), icon, Key_M, this,
-                TQT_SLOT(slotEditInMatrix()), actionCollection(),
+                TQ_SLOT(slotEditInMatrix()), actionCollection(),
                 "edit_matrix");
 
     pixmap.load(pixmapDir + "/toolbar/matrix-percussion.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Open in &Percussion Matrix Editor"), icon, Key_D, this,
-                TQT_SLOT(slotEditInPercussionMatrix()), actionCollection(),
+                TQ_SLOT(slotEditInPercussionMatrix()), actionCollection(),
                 "edit_percussion_matrix");
 
     pixmap.load(pixmapDir + "/toolbar/notation.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Open in &Notation Editor"), icon, Key_N, this,
-                TQT_SLOT(slotEditAsNotation()), actionCollection(),
+                TQ_SLOT(slotEditAsNotation()), actionCollection(),
                 "edit_notation");
 
     pixmap.load(pixmapDir + "/toolbar/eventlist.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Open in &Event List Editor"), icon, Key_E, this,
-                TQT_SLOT(slotEditInEventList()), actionCollection(),
+                TQ_SLOT(slotEditInEventList()), actionCollection(),
                 "edit_event_list");
 
     pixmap.load(pixmapDir + "/toolbar/quantize.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("&Quantize..."), icon, Key_Equal, this,
-                TQT_SLOT(slotQuantizeSelection()), actionCollection(),
+                TQ_SLOT(slotQuantizeSelection()), actionCollection(),
                 "quantize_selection");
 
     new TDEAction(SegmentLabelCommand::getGlobalName(),
                 0,
-                this, TQT_SLOT(slotRelabelSegments()),
+                this, TQ_SLOT(slotRelabelSegments()),
                 actionCollection(), "relabel_segment");
 
     new TDEAction(SegmentTransposeCommand::getGlobalName(),
                 0,
-                this, TQT_SLOT(slotTransposeSegments()),
+                this, TQ_SLOT(slotTransposeSegments()),
                 actionCollection(), "transpose");
 
     new TDEAction(i18n("Repeat Last Quantize"), Key_Plus, this,
-                TQT_SLOT(slotRepeatQuantizeSelection()), actionCollection(),
+                TQ_SLOT(slotRepeatQuantizeSelection()), actionCollection(),
                 "repeat_quantize");
 
     new TDEAction(SegmentRescaleCommand::getGlobalName(), 0, this,
-                TQT_SLOT(slotRescaleSelection()), actionCollection(),
+                TQ_SLOT(slotRescaleSelection()), actionCollection(),
                 "rescale");
 
     new TDEAction(SegmentAutoSplitCommand::getGlobalName(), 0, this,
-                TQT_SLOT(slotAutoSplitSelection()), actionCollection(),
+                TQ_SLOT(slotAutoSplitSelection()), actionCollection(),
                 "auto_split");
 
     new TDEAction(SegmentSplitByPitchCommand::getGlobalName(), 0, this,
-                TQT_SLOT(slotSplitSelectionByPitch()), actionCollection(),
+                TQ_SLOT(slotSplitSelectionByPitch()), actionCollection(),
                 "split_by_pitch");
 
     new TDEAction(SegmentSplitByRecordingSrcCommand::getGlobalName(), 0, this,
-                TQT_SLOT(slotSplitSelectionByRecordedSrc()), actionCollection(),
+                TQ_SLOT(slotSplitSelectionByRecordedSrc()), actionCollection(),
                 "split_by_recording");
 
     new TDEAction(i18n("Split at Time..."), 0, this,
-                TQT_SLOT(slotSplitSelectionAtTime()), actionCollection(),
+                TQ_SLOT(slotSplitSelectionAtTime()), actionCollection(),
                 "split_at_time");
 
     new TDEAction(i18n("Jog &Left"), Key_Left + ALT, this,
-                TQT_SLOT(slotJogLeft()), actionCollection(),
+                TQ_SLOT(slotJogLeft()), actionCollection(),
                 "jog_left");
 
     new TDEAction(i18n("Jog &Right"), Key_Right + ALT, this,
-                TQT_SLOT(slotJogRight()), actionCollection(),
+                TQ_SLOT(slotJogRight()), actionCollection(),
                 "jog_right");
 
     new TDEAction(i18n("Set Start Time..."), 0, this,
-                TQT_SLOT(slotSetSegmentStartTimes()), actionCollection(),
+                TQ_SLOT(slotSetSegmentStartTimes()), actionCollection(),
                 "set_segment_start");
 
     new TDEAction(i18n("Set Duration..."), 0, this,
-                TQT_SLOT(slotSetSegmentDurations()), actionCollection(),
+                TQ_SLOT(slotSetSegmentDurations()), actionCollection(),
                 "set_segment_duration");
 
     new TDEAction(SegmentJoinCommand::getGlobalName(),
                 Key_J + CTRL,
-                this, TQT_SLOT(slotJoinSegments()),
+                this, TQ_SLOT(slotJoinSegments()),
                 actionCollection(), "join_segments");
 
     new TDEAction(i18n("Turn Re&peats into Copies"),
                 0,
-                this, TQT_SLOT(slotRepeatingSegments()),
+                this, TQ_SLOT(slotRepeatingSegments()),
                 actionCollection(), "repeats_to_real_copies");
 
     new TDEAction(i18n("Manage Tri&ggered Segments"), 0,
-                this, TQT_SLOT(slotManageTriggerSegments()),
+                this, TQ_SLOT(slotManageTriggerSegments()),
                 actionCollection(), "manage_trigger_segments");
 
     new TDEAction(i18n("Set Tempos from &Beat Segment"), 0, this,
-                TQT_SLOT(slotGrooveQuantize()), actionCollection(),
+                TQ_SLOT(slotGrooveQuantize()), actionCollection(),
                 "groove_quantize");
 
     new TDEAction(i18n("Set &Tempo to Audio Segment Duration"), 0, this,
-                TQT_SLOT(slotTempoToSegmentLength()), actionCollection(),
+                TQ_SLOT(slotTempoToSegmentLength()), actionCollection(),
                 "set_tempo_to_segment_length");
 
     pixmap.load(pixmapDir + "/toolbar/manage-audio-segments.xpm");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Manage A&udio Files"), icon,
                 Key_U + CTRL,
-                this, TQT_SLOT(slotAudioManager()),
+                this, TQ_SLOT(slotAudioManager()),
                 actionCollection(), "audio_manager");
 
     m_viewSegmentLabels = new TDEToggleAction(i18n("Show Segment Labels"), 0, this,
-                                            TQT_SLOT(slotToggleSegmentLabels()), actionCollection(),
+                                            TQ_SLOT(slotToggleSegmentLabels()), actionCollection(),
                                             "show_segment_labels");
 
     //
@@ -982,65 +982,65 @@ void RosegardenGUIApp::setupActions()
     pixmap.load(pixmapDir + "/toolbar/add_tracks.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Add &Track"), icon, CTRL + Key_T,
-                this, TQT_SLOT(slotAddTrack()),
+                this, TQ_SLOT(slotAddTrack()),
                 actionCollection(), "add_track");
 
     new TDEAction(i18n("&Add Tracks..."), 0,
-                this, TQT_SLOT(slotAddTracks()),
+                this, TQ_SLOT(slotAddTracks()),
                 actionCollection(), "add_tracks");
 
     pixmap.load(pixmapDir + "/toolbar/delete_track.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("D&elete Track"), icon, CTRL + Key_D,
-                this, TQT_SLOT(slotDeleteTrack()),
+                this, TQ_SLOT(slotDeleteTrack()),
                 actionCollection(), "delete_track");
 
     pixmap.load(pixmapDir + "/toolbar/move_track_down.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Move Track &Down"), icon, SHIFT + Key_Down,
-                this, TQT_SLOT(slotMoveTrackDown()),
+                this, TQ_SLOT(slotMoveTrackDown()),
                 actionCollection(), "move_track_down");
 
     pixmap.load(pixmapDir + "/toolbar/move_track_up.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Move Track &Up"), icon, SHIFT + Key_Up,
-                this, TQT_SLOT(slotMoveTrackUp()),
+                this, TQ_SLOT(slotMoveTrackUp()),
                 actionCollection(), "move_track_up");
 
     new TDEAction(i18n("Select &Next Track"),
                 Key_Down,
-                this, TQT_SLOT(slotTrackDown()),
+                this, TQ_SLOT(slotTrackDown()),
                 actionCollection(), "select_next_track");
 
     new TDEAction(i18n("Select &Previous Track"),
                 Key_Up,
-                this, TQT_SLOT(slotTrackUp()),
+                this, TQ_SLOT(slotTrackUp()),
                 actionCollection(), "select_previous_track");
 
     new TDEAction(i18n("Mute or Unmute Track"),
                 Key_U,
-                this, TQT_SLOT(slotToggleMutedCurrentTrack()),
+                this, TQ_SLOT(slotToggleMutedCurrentTrack()),
                 actionCollection(), "toggle_mute_track");
 
     new TDEAction(i18n("Arm or Un-arm Track for Record"),
                 Key_R,
-                this, TQT_SLOT(slotToggleRecordCurrentTrack()),
+                this, TQ_SLOT(slotToggleRecordCurrentTrack()),
                 actionCollection(), "toggle_arm_track");
 
     pixmap.load(pixmapDir + "/toolbar/mute-all.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("&Mute all Tracks"), icon, 0,
-                this, TQT_SLOT(slotMuteAllTracks()),
+                this, TQ_SLOT(slotMuteAllTracks()),
                 actionCollection(), "mute_all_tracks");
 
     pixmap.load(pixmapDir + "/toolbar/un-mute-all.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("&Unmute all Tracks"), icon, 0,
-                this, TQT_SLOT(slotUnmuteAllTracks()),
+                this, TQ_SLOT(slotUnmuteAllTracks()),
                 actionCollection(), "unmute_all_tracks");
 
     new TDEAction(i18n("&Remap Instruments..."), 0, this,
-                TQT_SLOT(slotRemapInstruments()),
+                TQ_SLOT(slotRemapInstruments()),
                 actionCollection(), "remap_instruments");
 
     //
@@ -1049,78 +1049,78 @@ void RosegardenGUIApp::setupActions()
     pixmap.load(pixmapDir + "/toolbar/mixer.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("&Audio Mixer"), icon, 0, this,
-                TQT_SLOT(slotOpenAudioMixer()),
+                TQ_SLOT(slotOpenAudioMixer()),
                 actionCollection(), "audio_mixer");
 
     pixmap.load(pixmapDir + "/toolbar/midimixer.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Midi Mi&xer"), icon, 0, this,
-                TQT_SLOT(slotOpenMidiMixer()),
+                TQ_SLOT(slotOpenMidiMixer()),
                 actionCollection(), "midi_mixer");
 
     pixmap.load(pixmapDir + "/toolbar/manage-midi-devices.xpm");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Manage MIDI &Devices"), icon, 0, this,
-                TQT_SLOT(slotManageMIDIDevices()),
+                TQ_SLOT(slotManageMIDIDevices()),
                 actionCollection(), "manage_devices");
 
     pixmap.load(pixmapDir + "/toolbar/manage-synth-plugins.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Manage S&ynth Plugins"), icon, 0, this,
-                TQT_SLOT(slotManageSynths()),
+                TQ_SLOT(slotManageSynths()),
                 actionCollection(), "manage_synths");
 
     new TDEAction(i18n("Modify MIDI &Filters"), "filter", 0, this,
-                TQT_SLOT(slotModifyMIDIFilters()),
+                TQ_SLOT(slotModifyMIDIFilters()),
                 actionCollection(), "modify_midi_filters");
 
     m_enableMIDIrouting = new TDEToggleAction(i18n("MIDI Thru Routing"), 0, this,
-                                            TQT_SLOT(slotEnableMIDIThruRouting()),
+                                            TQ_SLOT(slotEnableMIDIThruRouting()),
                                             actionCollection(), "enable_midi_routing");
 
     pixmap.load(pixmapDir + "/toolbar/time-musical.png");
     icon = TQIconSet(pixmap);
     new TDEAction(i18n("Manage &Metronome"), 0, this,
-                TQT_SLOT(slotManageMetronome()),
+                TQ_SLOT(slotManageMetronome()),
                 actionCollection(), "manage_metronome");
 
     new TDEAction(i18n("&Save Current Document as Default Studio"), 0, this,
-                TQT_SLOT(slotSaveDefaultStudio()),
+                TQ_SLOT(slotSaveDefaultStudio()),
                 actionCollection(), "save_default_studio");
 
     new TDEAction(i18n("&Import Default Studio"), 0, this,
-                TQT_SLOT(slotImportDefaultStudio()),
+                TQ_SLOT(slotImportDefaultStudio()),
                 actionCollection(), "load_default_studio");
 
     new TDEAction(i18n("Im&port Studio from File..."), 0, this,
-                TQT_SLOT(slotImportStudio()),
+                TQ_SLOT(slotImportStudio()),
                 actionCollection(), "load_studio");
 
     new TDEAction(i18n("&Reset MIDI Network"), 0, this,
-                TQT_SLOT(slotResetMidiNetwork()),
+                TQ_SLOT(slotResetMidiNetwork()),
                 actionCollection(), "reset_midi_network");
 
     m_setQuickMarkerAction = new TDEAction(i18n("Set Quick Marker at Playback Position"), 0, CTRL + Key_1, this,
-                TQT_SLOT(slotSetQuickMarker()), actionCollection(),
+                TQ_SLOT(slotSetQuickMarker()), actionCollection(),
                 "set_quick_marker");
 
     m_jumpToQuickMarkerAction = new TDEAction(i18n("Jump to Quick Marker"), 0, Key_1, this,
-                TQT_SLOT(slotJumpToQuickMarker()), actionCollection(),
+                TQ_SLOT(slotJumpToQuickMarker()), actionCollection(),
                 "jump_to_quick_marker");
 
     //
     // Marker Ruler popup menu
     //
 //    new TDEAction(i18n("Insert Marker"), 0, 0, this,
-//             TQT_SLOT(slotInsertMarkerHere()), actionCollection(),
+//             TQ_SLOT(slotInsertMarkerHere()), actionCollection(),
 //             "insert_marker_here");
 //    
 //    new TDEAction(i18n("Insert Marker at Playback Position"), 0, 0, this,
-//             TQT_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
+//             TQ_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
 //             "insert_marker_at_pointer");
 //
 //    new TDEAction(i18n("Delete Marker"), 0, 0, this,
-//             TQT_SLOT(slotDeleteMarker()), actionCollection(),
+//             TQ_SLOT(slotDeleteMarker()), actionCollection(),
 //             "delete_marker");
 
 
@@ -1138,7 +1138,7 @@ void RosegardenGUIApp::setupActions()
     pixmap.load(pixmapDir + "/toolbar/transport-play.png");
     icon = TQIconSet(pixmap);
     m_playTransport = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
-                                  TQT_SLOT(slotPlay()), actionCollection(),
+                                  TQ_SLOT(slotPlay()), actionCollection(),
                                   "play");
     // Alternative shortcut for Play
     TDEShortcut playShortcut = m_playTransport->shortcut();
@@ -1149,7 +1149,7 @@ void RosegardenGUIApp::setupActions()
     pixmap.load(pixmapDir + "/toolbar/transport-stop.png");
     icon = TQIconSet(pixmap);
     m_stopTransport = new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
-                                  TQT_SLOT(slotStop()), actionCollection(),
+                                  TQ_SLOT(slotStop()), actionCollection(),
                                   "stop");
     m_stopTransport->setGroup(TransportDialogConfigGroup);
 
@@ -1157,59 +1157,59 @@ void RosegardenGUIApp::setupActions()
     icon = TQIconSet(pixmap);
     m_ffwdTransport = new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown,
                                   this,
-                                  TQT_SLOT(slotFastforward()), actionCollection(),
+                                  TQ_SLOT(slotFastforward()), actionCollection(),
                                   "fast_forward");
     m_ffwdTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-rewind.png");
     icon = TQIconSet(pixmap);
     m_rewindTransport = new TDEAction(i18n("Re&wind"), icon, Key_End, this,
-                                    TQT_SLOT(slotRewind()), actionCollection(),
+                                    TQ_SLOT(slotRewind()), actionCollection(),
                                     "rewind");
     m_rewindTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-record.png");
     icon = TQIconSet(pixmap);
     m_recordTransport = new TDEAction(i18n("P&unch in Record"), icon, Key_Space, this,
-                                    TQT_SLOT(slotToggleRecord()), actionCollection(),
+                                    TQ_SLOT(slotToggleRecord()), actionCollection(),
                                     "recordtoggle");
     m_recordTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-record.png");
     icon = TQIconSet(pixmap);
     m_recordTransport = new TDEAction(i18n("&Record"), icon, 0, this,
-                                    TQT_SLOT(slotRecord()), actionCollection(),
+                                    TQ_SLOT(slotRecord()), actionCollection(),
                                     "record");
     m_recordTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-rewind-end.png");
     icon = TQIconSet(pixmap);
     m_rewindEndTransport = new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
-                                       TQT_SLOT(slotRewindToBeginning()), actionCollection(),
+                                       TQ_SLOT(slotRewindToBeginning()), actionCollection(),
                                        "rewindtobeginning");
     m_rewindEndTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-ffwd-end.png");
     icon = TQIconSet(pixmap);
     m_ffwdEndTransport = new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
-                                     TQT_SLOT(slotFastForwardToEnd()), actionCollection(),
+                                     TQ_SLOT(slotFastForwardToEnd()), actionCollection(),
                                      "fastforwardtoend");
     m_ffwdEndTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-tracking.png");
     icon = TQIconSet(pixmap);
     (new TDEToggleAction(i18n("Scro&ll to Follow Playback"), icon, Key_Pause, this,
-                       TQT_SLOT(slotToggleTracking()), actionCollection(),
+                       TQ_SLOT(slotToggleTracking()), actionCollection(),
                        "toggle_tracking"))->setChecked(true);
 
     pixmap.load(pixmapDir + "/toolbar/transport-panic.png");
     icon = TQIconSet(pixmap);
-    new TDEAction( i18n("Panic"), icon, Key_P + CTRL + ALT, this, TQT_SLOT(slotPanic()),
+    new TDEAction( i18n("Panic"), icon, Key_P + CTRL + ALT, this, TQ_SLOT(slotPanic()),
                  actionCollection(), "panic");
 
     // DEBUG FACILITY
     new TDEAction(i18n("Segment Debug Dump "), 0, this,
-                TQT_SLOT(slotDebugDump()), actionCollection(),
+                TQ_SLOT(slotDebugDump()), actionCollection(),
                 "debug_dump_segments");
 
     // create main gui
@@ -1225,8 +1225,8 @@ void RosegardenGUIApp::setupActions()
     TQPopupMenu* setTrackInstrumentMenu = dynamic_cast<TQPopupMenu*>(factory()->container("set_track_instrument", this));
 
     if (setTrackInstrumentMenu) {
-        connect(setTrackInstrumentMenu, TQT_SIGNAL(aboutToShow()),
-                this, TQT_SLOT(slotPopulateTrackInstrumentPopup()));
+        connect(setTrackInstrumentMenu, TQ_SIGNAL(aboutToShow()),
+                this, TQ_SLOT(slotPopulateTrackInstrumentPopup()));
     } else {
         RG_DEBUG << "RosegardenGUIApp::setupActions() : couldn't find set_track_instrument menu - check rosegardenui.rcn\n";
     }
@@ -1301,8 +1301,8 @@ void RosegardenGUIApp::initZoomToolbar()
     m_zoomLabel = new TQLabel(minZoom, zoomToolbar, "tde toolbar widget");
     m_zoomLabel->setIndent(10);
 
-    connect(m_zoomSlider, TQT_SIGNAL(valueChanged(int)),
-            this, TQT_SLOT(slotChangeZoom(int)));
+    connect(m_zoomSlider, TQ_SIGNAL(valueChanged(int)),
+            this, TQ_SLOT(slotChangeZoom(int)));
 
     // set initial zoom - we might want to make this a config option
     //    m_zoomSlider->setToDefault();
@@ -1351,18 +1351,18 @@ void RosegardenGUIApp::initView()
 
     // Connect up this signal so that we can force tool mode
     // changes from the view
-    connect(m_swapView, TQT_SIGNAL(activateTool(TQString)),
-            this, TQT_SLOT(slotActivateTool(TQString)));
+    connect(m_swapView, TQ_SIGNAL(activateTool(TQString)),
+            this, TQ_SLOT(slotActivateTool(TQString)));
 
     connect(m_swapView,
-            TQT_SIGNAL(segmentsSelected(const SegmentSelection &)),
-            TQT_SIGNAL(segmentsSelected(const SegmentSelection &)));
+            TQ_SIGNAL(segmentsSelected(const SegmentSelection &)),
+            TQ_SIGNAL(segmentsSelected(const SegmentSelection &)));
 
     connect(m_swapView,
-            TQT_SIGNAL(addAudioFile(AudioFileId)),
-            TQT_SLOT(slotAddAudioFile(AudioFileId)));
+            TQ_SIGNAL(addAudioFile(AudioFileId)),
+            TQ_SLOT(slotAddAudioFile(AudioFileId)));
 
-    connect(m_swapView, TQT_SIGNAL(toggleSolo(bool)), TQT_SLOT(slotToggleSolo(bool)));
+    connect(m_swapView, TQ_SIGNAL(toggleSolo(bool)), TQ_SLOT(slotToggleSolo(bool)));
 
     m_doc->attachView(m_swapView);
 
@@ -1412,11 +1412,11 @@ void RosegardenGUIApp::initView()
     RosegardenGUIView *oldView = m_view;
     m_view = m_swapView;
 
-    connect(m_view, TQT_SIGNAL(stateChange(TQString, bool)),
-            this, TQT_SLOT (slotStateChanged(TQString, bool)));
+    connect(m_view, TQ_SIGNAL(stateChange(TQString, bool)),
+            this, TQ_SLOT (slotStateChanged(TQString, bool)));
 
-    connect(m_view, TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
-            this, TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
+    connect(m_view, TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            this, TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     // We only check for the SequenceManager to make sure
     // we're not on the first pass though - we don't want
@@ -1445,8 +1445,8 @@ void RosegardenGUIApp::initView()
             CurrentProgressDialog::thaw();
         }
 
-        connect(m_seqManager, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
-                m_view, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
+        connect(m_seqManager, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
+                m_view, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
     }
 
     //    delete m_playList;
@@ -1488,9 +1488,9 @@ void RosegardenGUIApp::initView()
     m_view->show();
 
     connect(m_view->getTrackEditor()->getSegmentCanvas(),
-            TQT_SIGNAL(showContextHelp(const TQString &)),
+            TQ_SIGNAL(showContextHelp(const TQString &)),
             this,
-            TQT_SLOT(slotShowToolHelp(const TQString &)));
+            TQ_SLOT(slotShowToolHelp(const TQString &)));
 
     // We have to do this to make sure that the 2nd call ("select")
     // actually has any effect. Activating the same radio action
@@ -1588,45 +1588,45 @@ void RosegardenGUIApp::setDocument(RosegardenGUIDoc* newDocument)
 
     // connect needed signals
     //
-    connect(m_segmentParameterBox, TQT_SIGNAL(documentModified()),
-            m_doc, TQT_SLOT(slotDocumentModified()));
+    connect(m_segmentParameterBox, TQ_SIGNAL(documentModified()),
+            m_doc, TQ_SLOT(slotDocumentModified()));
 
-    connect(m_doc, TQT_SIGNAL(pointerPositionChanged(timeT)),
-            this, TQT_SLOT(slotSetPointerPosition(timeT)));
+    connect(m_doc, TQ_SIGNAL(pointerPositionChanged(timeT)),
+            this, TQ_SLOT(slotSetPointerPosition(timeT)));
 
-    connect(m_doc, TQT_SIGNAL(documentModified(bool)),
-            this, TQT_SLOT(slotDocumentModified(bool)));
+    connect(m_doc, TQ_SIGNAL(documentModified(bool)),
+            this, TQ_SLOT(slotDocumentModified(bool)));
 
-    connect(m_doc, TQT_SIGNAL(loopChanged(timeT, timeT)),
-            this, TQT_SLOT(slotSetLoop(timeT, timeT)));
+    connect(m_doc, TQ_SIGNAL(loopChanged(timeT, timeT)),
+            this, TQ_SLOT(slotSetLoop(timeT, timeT)));
 
     m_doc->getCommandHistory()->attachView(actionCollection());
 
-    connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
-            TQT_SLOT(update()));
-    connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
-            TQT_SLOT(slotTestClipboard()));
+    connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
+            TQ_SLOT(update()));
+    connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
+            TQ_SLOT(slotTestClipboard()));
 
     // connect and start the autosave timer
-    connect(m_autoSaveTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotAutoSave()));
+    connect(m_autoSaveTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotAutoSave()));
     m_autoSaveTimer->start(m_doc->getAutoSavePeriod() * 1000);
 
     // Connect the playback timer
     //
-    connect(m_playTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotUpdatePlaybackPosition()));
-    connect(m_stopTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotUpdateMonitoring()));
+    connect(m_playTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotUpdatePlaybackPosition()));
+    connect(m_stopTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotUpdateMonitoring()));
 
     // finally recreate the main view
     //
     initView();
 
     if (getView() && getView()->getTrackEditor()) {
-        connect(m_doc, TQT_SIGNAL(makeTrackVisible(int)),
-                getView()->getTrackEditor(), TQT_SLOT(slotScrollToTrack(int)));
+        connect(m_doc, TQ_SIGNAL(makeTrackVisible(int)),
+                getView()->getTrackEditor(), TQ_SLOT(slotScrollToTrack(int)));
     }
 
-    connect(m_doc, TQT_SIGNAL(devicesResyncd()),
-            this, TQT_SLOT(slotDocumentDevicesResyncd()));
+    connect(m_doc, TQ_SIGNAL(devicesResyncd()),
+            this, TQ_SLOT(slotDocumentDevicesResyncd()));
 
     m_doc->syncDevices();
     m_doc->clearModifiedStatus();
@@ -2075,8 +2075,8 @@ bool RosegardenGUIApp::queryClose()
         // 'off'
         //
 
-        disconnect(m_transport, TQT_SIGNAL(closed()),
-                   this, TQT_SLOT(slotCloseTransport()));
+        disconnect(m_transport, TQ_SIGNAL(closed()),
+                   this, TQ_SLOT(slotCloseTransport()));
     }
     */
 
@@ -2737,10 +2737,10 @@ void RosegardenGUIApp::slotRescaleSelection()
             asrcs[i]->disconnectProgressDialog(progressDlg);
         }
 
-        connect(&m_doc->getAudioFileManager(), TQT_SIGNAL(setProgress(int)),
-                progressDlg->progressBar(), TQT_SLOT(setValue(int)));
-        connect(progressDlg, TQT_SIGNAL(cancelClicked()),
-                &m_doc->getAudioFileManager(), TQT_SLOT(slotStopPreview()));
+        connect(&m_doc->getAudioFileManager(), TQ_SIGNAL(setProgress(int)),
+                progressDlg->progressBar(), TQ_SLOT(setValue(int)));
+        connect(progressDlg, TQ_SIGNAL(cancelClicked()),
+                &m_doc->getAudioFileManager(), TQ_SLOT(slotStopPreview()));
 
         for (size_t i = 0; i < asrcs.size(); ++i) {
             int fid = asrcs[i]->getNewAudioFileId();
@@ -2854,33 +2854,33 @@ void RosegardenGUIApp::createAndSetupTransport()
     m_transport->getAccelerators()->connectItem
         (m_transport->getAccelerators()->insertItem(Key_T),
          this,
-         TQT_SLOT(slotHideTransport()));
+         TQ_SLOT(slotHideTransport()));
 
     // Ensure that the checkbox is unchecked if the dialog
     // is closed
-    connect(m_transport, TQT_SIGNAL(closed()),
-            TQT_SLOT(slotCloseTransport()));
+    connect(m_transport, TQ_SIGNAL(closed()),
+            TQ_SLOT(slotCloseTransport()));
 
     // Handle loop setting and unsetting from the transport loop button
     //
 
-    connect(m_transport, TQT_SIGNAL(setLoop()), TQT_SLOT(slotSetLoop()));
-    connect(m_transport, TQT_SIGNAL(unsetLoop()), TQT_SLOT(slotUnsetLoop()));
-    connect(m_transport, TQT_SIGNAL(panic()), TQT_SLOT(slotPanic()));
+    connect(m_transport, TQ_SIGNAL(setLoop()), TQ_SLOT(slotSetLoop()));
+    connect(m_transport, TQ_SIGNAL(unsetLoop()), TQ_SLOT(slotUnsetLoop()));
+    connect(m_transport, TQ_SIGNAL(panic()), TQ_SLOT(slotPanic()));
 
-    connect(m_transport, TQT_SIGNAL(editTempo(TQWidget*)),
-            TQT_SLOT(slotEditTempo(TQWidget*)));
+    connect(m_transport, TQ_SIGNAL(editTempo(TQWidget*)),
+            TQ_SLOT(slotEditTempo(TQWidget*)));
 
-    connect(m_transport, TQT_SIGNAL(editTimeSignature(TQWidget*)),
-            TQT_SLOT(slotEditTimeSignature(TQWidget*)));
+    connect(m_transport, TQ_SIGNAL(editTimeSignature(TQWidget*)),
+            TQ_SLOT(slotEditTimeSignature(TQWidget*)));
 
-    connect(m_transport, TQT_SIGNAL(editTransportTime(TQWidget*)),
-            TQT_SLOT(slotEditTransportTime(TQWidget*)));
+    connect(m_transport, TQ_SIGNAL(editTransportTime(TQWidget*)),
+            TQ_SLOT(slotEditTransportTime(TQWidget*)));
 
     // Handle set loop start/stop time buttons.
     //
-    connect(m_transport, TQT_SIGNAL(setLoopStartTime()), TQT_SLOT(slotSetLoopStart()));
-    connect(m_transport, TQT_SIGNAL(setLoopStopTime()), TQT_SLOT(slotSetLoopStop()));
+    connect(m_transport, TQ_SIGNAL(setLoopStartTime()), TQ_SLOT(slotSetLoopStart()));
+    connect(m_transport, TQ_SIGNAL(setLoopStopTime()), TQ_SLOT(slotSetLoopStop()));
 
     if (m_seqManager != 0)
         m_seqManager->setTransport(m_transport);
@@ -3868,11 +3868,11 @@ RosegardenGUIApp::createDocumentFromMIDIFile(TQString file)
     CurrentProgressDialog::set
         (&progressDlg);
 
-    connect(&midiFile, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&midiFile, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&midiFile, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&midiFile, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     if (!midiFile.open()) {
         CurrentProgressDialog::freeze();
@@ -3960,8 +3960,8 @@ RosegardenGUIApp::createDocumentFromMIDIFile(TQString file)
                                            (segment, startTime, endTime, "Notation Options", true);
 
         subCommand->setProgressTotal(progressPer + 1);
-        TQObject::connect(subCommand, TQT_SIGNAL(incrementProgress(int)),
-                         progressDlg.progressBar(), TQT_SLOT(advance(int)));
+        TQObject::connect(subCommand, TQ_SIGNAL(incrementProgress(int)),
+                         progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
         command->addCommand(subCommand);
     }
@@ -4034,11 +4034,11 @@ RosegardenGUIApp::createDocumentFromRG21File(TQString file)
 
     // TODO: make RG21Loader to actually emit these signals
     //
-    connect(&rg21Loader, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&rg21Loader, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&rg21Loader, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&rg21Loader, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     // "your starter for 40%" - helps the "freeze" work
     //
@@ -4121,11 +4121,11 @@ RosegardenGUIApp::createDocumentFromHydrogenFile(TQString file)
 
     // TODO: make RG21Loader to actually emit these signals
     //
-    connect(&hydrogenLoader, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&hydrogenLoader, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&hydrogenLoader, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&hydrogenLoader, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     // "your starter for 40%" - helps the "freeze" work
     //
@@ -4499,15 +4499,15 @@ void RosegardenGUIApp::slotTestStartupTester()
 
     if (!m_startupTester) {
         m_startupTester = new StartupTester();
-        connect(m_startupTester, TQT_SIGNAL(newerVersionAvailable(TQString)),
-                this, TQT_SLOT(slotNewerVersionAvailable(TQString)));
+        connect(m_startupTester, TQ_SIGNAL(newerVersionAvailable(TQString)),
+                this, TQ_SLOT(slotNewerVersionAvailable(TQString)));
         m_startupTester->start();
-        TQTimer::singleShot(100, this, TQT_SLOT(slotTestStartupTester()));
+        TQTimer::singleShot(100, this, TQ_SLOT(slotTestStartupTester()));
         return ;
     }
 
     if (!m_startupTester->isReady()) {
-        TQTimer::singleShot(100, this, TQT_SLOT(slotTestStartupTester()));
+        TQTimer::singleShot(100, this, TQ_SLOT(slotTestStartupTester()));
         return ;
     }
 
@@ -4737,8 +4737,8 @@ bool RosegardenGUIApp::launchSequencer(bool useExisting)
                 stateChanged("sequencer_running");
                 slotEnableTransport(true);
 
-                connect(m_sequencerProcess, TQT_SIGNAL(processExited(TDEProcess*)),
-                        this, TQT_SLOT(slotSequencerExited(TDEProcess*)));
+                connect(m_sequencerProcess, TQ_SIGNAL(processExited(TDEProcess*)),
+                        this, TQ_SLOT(slotSequencerExited(TDEProcess*)));
 
             } catch (Exception e) {
                 m_sequencerProcess = 0;
@@ -4919,11 +4919,11 @@ void RosegardenGUIApp::exportMIDIFile(TQString file)
     MidiFile midiFile(fname,
                       &m_doc->getStudio());
 
-    connect(&midiFile, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&midiFile, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&midiFile, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&midiFile, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     midiFile.convertToMidi(m_doc->getComposition());
 
@@ -4953,11 +4953,11 @@ void RosegardenGUIApp::exportCsoundFile(TQString file)
 
     CsoundExporter e(this, &m_doc->getComposition(), std::string(TQFile::encodeName(file)));
 
-    connect(&e, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&e, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&e, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&e, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -4986,11 +4986,11 @@ void RosegardenGUIApp::exportMupFile(TQString file)
 
     MupExporter e(this, &m_doc->getComposition(), std::string(TQFile::encodeName(file)));
 
-    connect(&e, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&e, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&e, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&e, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -5034,8 +5034,8 @@ void RosegardenGUIApp::slotPrintLilyPond()
     *proc << "--graphical";
     *proc << "--print";
     *proc << file->name();
-    connect(proc, TQT_SIGNAL(processExited(TDEProcess *)),
-            this, TQT_SLOT(slotLilyPondViewProcessExited(TDEProcess *)));
+    connect(proc, TQ_SIGNAL(processExited(TDEProcess *)),
+            this, TQ_SLOT(slotLilyPondViewProcessExited(TDEProcess *)));
     m_lilyTempFileMap[proc] = file;
     proc->start(TDEProcess::NotifyOnExit);
 }
@@ -5058,8 +5058,8 @@ void RosegardenGUIApp::slotPreviewLilyPond()
     *proc << "--graphical";
     *proc << "--pdf";
     *proc << file->name();
-    connect(proc, TQT_SIGNAL(processExited(TDEProcess *)),
-            this, TQT_SLOT(slotLilyPondViewProcessExited(TDEProcess *)));
+    connect(proc, TQ_SIGNAL(processExited(TDEProcess *)),
+            this, TQ_SLOT(slotLilyPondViewProcessExited(TDEProcess *)));
     m_lilyTempFileMap[proc] = file;
     proc->start(TDEProcess::NotifyOnExit);
 }
@@ -5090,11 +5090,11 @@ bool RosegardenGUIApp::exportLilyPondFile(TQString file, bool forPreview)
 
     LilyPondExporter e(this, m_doc, std::string(TQFile::encodeName(file)));
 
-    connect(&e, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&e, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&e, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&e, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -5127,11 +5127,11 @@ void RosegardenGUIApp::exportMusicXmlFile(TQString file)
 
     MusicXmlExporter e(this, m_doc, std::string(TQFile::encodeName(file)));
 
-    connect(&e, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&e, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
 
-    connect(&e, TQT_SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(advance(int)));
+    connect(&e, TQ_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -5306,8 +5306,8 @@ RosegardenGUIApp::slotRecord()
     plugAccelerators(m_seqManager->getCountdownDialog(),
                      m_seqManager->getCountdownDialog()->getAccelerators());
 
-    connect(m_seqManager->getCountdownDialog(), TQT_SIGNAL(stopped()),
-            this, TQT_SLOT(slotStop()));
+    connect(m_seqManager->getCountdownDialog(), TQ_SIGNAL(stopped()),
+            this, TQ_SLOT(slotStop()));
 
     // Start the playback timer - this fetches the current sequencer position &c
     //
@@ -5457,10 +5457,10 @@ void RosegardenGUIApp::slotStop()
 {
     if (m_seqManager &&
         m_seqManager->getCountdownDialog()) {
-        disconnect(m_seqManager->getCountdownDialog(), TQT_SIGNAL(stopped()),
-                   this, TQT_SLOT(slotStop()));
-        disconnect(m_seqManager->getCountdownDialog(), TQT_SIGNAL(completed()),
-                   this, TQT_SLOT(slotStop()));
+        disconnect(m_seqManager->getCountdownDialog(), TQ_SIGNAL(stopped()),
+                   this, TQ_SLOT(slotStop()));
+        disconnect(m_seqManager->getCountdownDialog(), TQ_SIGNAL(completed()),
+                   this, TQ_SLOT(slotStop()));
     }
 
     try {
@@ -5643,10 +5643,10 @@ void RosegardenGUIApp::slotConfigure()
     ConfigureDialog *configDlg =
         new ConfigureDialog(m_doc, kapp->config(), this);
 
-    connect(configDlg, TQT_SIGNAL(updateAutoSaveInterval(unsigned int)),
-            this, TQT_SLOT(slotUpdateAutoSaveInterval(unsigned int)));
-    connect(configDlg, TQT_SIGNAL(updateSidebarStyle(unsigned int)),
-            this, TQT_SLOT(slotUpdateSidebarStyle(unsigned int)));
+    connect(configDlg, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)),
+            this, TQ_SLOT(slotUpdateAutoSaveInterval(unsigned int)));
+    connect(configDlg, TQ_SIGNAL(updateSidebarStyle(unsigned int)),
+            this, TQ_SLOT(slotUpdateSidebarStyle(unsigned int)));
 
     configDlg->show();
 }
@@ -5681,8 +5681,8 @@ void RosegardenGUIApp::slotEditToolbars()
 {
     KEditToolbar dlg(actionCollection(), "rosegardenui.rc");
 
-    connect(&dlg, TQT_SIGNAL(newToolbarConfig()),
-            TQT_SLOT(slotUpdateToolbars()));
+    connect(&dlg, TQ_SIGNAL(newToolbarConfig()),
+            TQ_SLOT(slotUpdateToolbars()));
 
     dlg.exec();
 }
@@ -5715,11 +5715,11 @@ void RosegardenGUIApp::slotEditTempo(TQWidget *parent, timeT atTime)
     TempoDialog tempoDialog(parent, m_doc);
 
     connect(&tempoDialog,
-            TQT_SIGNAL(changeTempo(timeT,
+            TQ_SIGNAL(changeTempo(timeT,
                                tempoT,
                                tempoT,
                                TempoDialog::TempoDialogAction)),
-            TQT_SLOT(slotChangeTempo(timeT,
+            TQ_SLOT(slotChangeTempo(timeT,
                                  tempoT,
                                  tempoT,
                                  TempoDialog::TempoDialogAction)));
@@ -6008,27 +6008,27 @@ RosegardenGUIApp::plugAccelerators(TQWidget *widget, TQAccel *acc)
 
     acc->connectItem(acc->insertItem(Key_Enter),
                      this,
-                     TQT_SLOT(slotPlay()));
+                     TQ_SLOT(slotPlay()));
     // Alternative shortcut for Play
     acc->connectItem(acc->insertItem(Key_Return + CTRL),
                      this,
-                     TQT_SLOT(slotPlay()));
+                     TQ_SLOT(slotPlay()));
 
     acc->connectItem(acc->insertItem(Key_Insert),
                      this,
-                     TQT_SLOT(slotStop()));
+                     TQ_SLOT(slotStop()));
 
     acc->connectItem(acc->insertItem(Key_PageDown),
                      this,
-                     TQT_SLOT(slotFastforward()));
+                     TQ_SLOT(slotFastforward()));
 
     acc->connectItem(acc->insertItem(Key_End),
                      this,
-                     TQT_SLOT(slotRewind()));
+                     TQ_SLOT(slotRewind()));
 
     acc->connectItem(acc->insertItem(Key_Space),
                      this,
-                     TQT_SLOT(slotToggleRecord()));
+                     TQ_SLOT(slotToggleRecord()));
 
     TransportDialog *transport =
         dynamic_cast<TransportDialog*>(widget);
@@ -6036,64 +6036,64 @@ RosegardenGUIApp::plugAccelerators(TQWidget *widget, TQAccel *acc)
     if (transport) {
         acc->connectItem(acc->insertItem(m_jumpToQuickMarkerAction->shortcut()),
                          this,
-                         TQT_SLOT(slotJumpToQuickMarker()));
+                         TQ_SLOT(slotJumpToQuickMarker()));
 
         acc->connectItem(acc->insertItem(m_setQuickMarkerAction->shortcut()),
                          this,
-                         TQT_SLOT(slotSetQuickMarker()));
+                         TQ_SLOT(slotSetQuickMarker()));
 
         connect(transport->PlayButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotPlay()));
+                TQ_SLOT(slotPlay()));
 
         connect(transport->StopButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotStop()));
+                TQ_SLOT(slotStop()));
 
         connect(transport->FfwdButton(),
-                TQT_SIGNAL(clicked()),
-                TQT_SLOT(slotFastforward()));
+                TQ_SIGNAL(clicked()),
+                TQ_SLOT(slotFastforward()));
 
         connect(transport->RewindButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotRewind()));
+                TQ_SLOT(slotRewind()));
 
         connect(transport->RecordButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotRecord()));
+                TQ_SLOT(slotRecord()));
 
         connect(transport->RewindEndButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotRewindToBeginning()));
+                TQ_SLOT(slotRewindToBeginning()));
 
         connect(transport->FfwdEndButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotFastForwardToEnd()));
+                TQ_SLOT(slotFastForwardToEnd()));
 
         connect(transport->MetronomeButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotToggleMetronome()));
+                TQ_SLOT(slotToggleMetronome()));
 
         connect(transport->SoloButton(),
-                TQT_SIGNAL(toggled(bool)),
+                TQ_SIGNAL(toggled(bool)),
                 this,
-                TQT_SLOT(slotToggleSolo(bool)));
+                TQ_SLOT(slotToggleSolo(bool)));
 
         connect(transport->TimeDisplayButton(),
-                TQT_SIGNAL(clicked()),
+                TQ_SIGNAL(clicked()),
                 this,
-                TQT_SLOT(slotRefreshTimeDisplay()));
+                TQ_SLOT(slotRefreshTimeDisplay()));
 
         connect(transport->ToEndButton(),
-                TQT_SIGNAL(clicked()),
-                TQT_SLOT(slotRefreshTimeDisplay()));
+                TQ_SIGNAL(clicked()),
+                TQ_SLOT(slotRefreshTimeDisplay()));
     }
 }
 
@@ -6243,20 +6243,20 @@ RosegardenGUIApp::slotAudioManager()
         new AudioManagerDialog(this, m_doc);
 
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(playAudioFile(AudioFileId,
+            TQ_SIGNAL(playAudioFile(AudioFileId,
                                  const RealTime &,
                                  const RealTime&)),
-            TQT_SLOT(slotPlayAudioFile(AudioFileId,
+            TQ_SLOT(slotPlayAudioFile(AudioFileId,
                                    const RealTime &,
                                    const RealTime &)));
 
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(addAudioFile(AudioFileId)),
-            TQT_SLOT(slotAddAudioFile(AudioFileId)));
+            TQ_SIGNAL(addAudioFile(AudioFileId)),
+            TQ_SLOT(slotAddAudioFile(AudioFileId)));
 
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(deleteAudioFile(AudioFileId)),
-            TQT_SLOT(slotDeleteAudioFile(AudioFileId)));
+            TQ_SIGNAL(deleteAudioFile(AudioFileId)),
+            TQ_SLOT(slotDeleteAudioFile(AudioFileId)));
 
     //
     // Sync segment selection between audio man. dialog and main window
@@ -6264,46 +6264,46 @@ RosegardenGUIApp::slotAudioManager()
 
     // from dialog to us...
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(segmentsSelected(const SegmentSelection&)),
+            TQ_SIGNAL(segmentsSelected(const SegmentSelection&)),
             m_view,
-            TQT_SLOT(slotPropagateSegmentSelection(const SegmentSelection&)));
+            TQ_SLOT(slotPropagateSegmentSelection(const SegmentSelection&)));
 
     // and from us to dialog
-    connect(this, TQT_SIGNAL(segmentsSelected(const SegmentSelection&)),
+    connect(this, TQ_SIGNAL(segmentsSelected(const SegmentSelection&)),
             m_audioManagerDialog,
-            TQT_SLOT(slotSegmentSelection(const SegmentSelection&)));
+            TQ_SLOT(slotSegmentSelection(const SegmentSelection&)));
 
 
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(deleteSegments(const SegmentSelection&)),
-            TQT_SLOT(slotDeleteSegments(const SegmentSelection&)));
+            TQ_SIGNAL(deleteSegments(const SegmentSelection&)),
+            TQ_SLOT(slotDeleteSegments(const SegmentSelection&)));
 
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(insertAudioSegment(AudioFileId,
+            TQ_SIGNAL(insertAudioSegment(AudioFileId,
                                       const RealTime&,
                                       const RealTime&)),
             m_view,
-            TQT_SLOT(slotAddAudioSegmentDefaultPosition(AudioFileId,
+            TQ_SLOT(slotAddAudioSegmentDefaultPosition(AudioFileId,
                                                     const RealTime&,
                                                     const RealTime&)));
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(cancelPlayingAudioFile(AudioFileId)),
-            TQT_SLOT(slotCancelAudioPlayingFile(AudioFileId)));
+            TQ_SIGNAL(cancelPlayingAudioFile(AudioFileId)),
+            TQ_SLOT(slotCancelAudioPlayingFile(AudioFileId)));
 
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(deleteAllAudioFiles()),
-            TQT_SLOT(slotDeleteAllAudioFiles()));
+            TQ_SIGNAL(deleteAllAudioFiles()),
+            TQ_SLOT(slotDeleteAllAudioFiles()));
 
     // Make sure we know when the audio man. dialog is closing
     //
     connect(m_audioManagerDialog,
-            TQT_SIGNAL(closing()),
-            TQT_SLOT(slotAudioManagerClosed()));
+            TQ_SIGNAL(closing()),
+            TQ_SLOT(slotAudioManagerClosed()));
 
     // And that it goes away when the current document is changing
     //
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            m_audioManagerDialog, TQT_SLOT(close()));
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            m_audioManagerDialog, TQ_SLOT(close()));
 
     m_audioManagerDialog->setAudioSubsystemStatus(
         m_seqManager->getSoundDriverStatus() & AUDIO_OK);
@@ -6520,26 +6520,26 @@ RosegardenGUIApp::slotManageMIDIDevices()
 
     m_deviceManager = new DeviceManagerDialog(this, m_doc);
 
-    connect(m_deviceManager, TQT_SIGNAL(closing()),
-            this, TQT_SLOT(slotDeviceManagerClosed()));
+    connect(m_deviceManager, TQ_SIGNAL(closing()),
+            this, TQ_SLOT(slotDeviceManagerClosed()));
 
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            m_deviceManager, TQT_SLOT(close()));
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            m_deviceManager, TQ_SLOT(close()));
 
     // Cheating way of updating the track/instrument list
     //
-    connect(m_deviceManager, TQT_SIGNAL(deviceNamesChanged()),
-            m_view, TQT_SLOT(slotSynchroniseWithComposition()));
+    connect(m_deviceManager, TQ_SIGNAL(deviceNamesChanged()),
+            m_view, TQ_SLOT(slotSynchroniseWithComposition()));
 
-    connect(m_deviceManager, TQT_SIGNAL(editBanks(DeviceId)),
-            this, TQT_SLOT(slotEditBanks(DeviceId)));
+    connect(m_deviceManager, TQ_SIGNAL(editBanks(DeviceId)),
+            this, TQ_SLOT(slotEditBanks(DeviceId)));
 
-    connect(m_deviceManager, TQT_SIGNAL(editControllers(DeviceId)),
-            this, TQT_SLOT(slotEditControlParameters(DeviceId)));
+    connect(m_deviceManager, TQ_SIGNAL(editControllers(DeviceId)),
+            this, TQ_SLOT(slotEditControlParameters(DeviceId)));
 
     if (m_midiMixer) {
-        connect(m_deviceManager, TQT_SIGNAL(deviceNamesChanged()),
-                m_midiMixer, TQT_SLOT(slotSynchronise()));
+        connect(m_deviceManager, TQ_SIGNAL(deviceNamesChanged()),
+                m_midiMixer, TQ_SLOT(slotSynchronise()));
 
     }
 
@@ -6563,26 +6563,26 @@ RosegardenGUIApp::slotManageSynths()
 #endif
                                                  );
 
-    connect(m_synthManager, TQT_SIGNAL(closing()),
-            this, TQT_SLOT(slotSynthPluginManagerClosed()));
+    connect(m_synthManager, TQ_SIGNAL(closing()),
+            this, TQ_SLOT(slotSynthPluginManagerClosed()));
 
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            m_synthManager, TQT_SLOT(close()));
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            m_synthManager, TQ_SLOT(close()));
 
     connect(m_synthManager,
-            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
             this,
-            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(m_synthManager,
-            TQT_SIGNAL(showPluginDialog(TQWidget *, InstrumentId, int)),
+            TQ_SIGNAL(showPluginDialog(TQWidget *, InstrumentId, int)),
             this,
-            TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
+            TQ_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
 
     connect(m_synthManager,
-            TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
+            TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
             this,
-            TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
+            TQ_SLOT(slotShowPluginGUI(InstrumentId, int)));
 
     m_synthManager->show();
 }
@@ -6599,66 +6599,66 @@ RosegardenGUIApp::slotOpenAudioMixer()
 
     m_audioMixer = new AudioMixerWindow(this, m_doc);
 
-    connect(m_audioMixer, TQT_SIGNAL(windowActivated()),
-            m_view, TQT_SLOT(slotActiveMainWindowChanged()));
+    connect(m_audioMixer, TQ_SIGNAL(windowActivated()),
+            m_view, TQ_SLOT(slotActiveMainWindowChanged()));
 
-    connect(m_view, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            m_audioMixer, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+    connect(m_view, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            m_audioMixer, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
 
-    connect(m_audioMixer, TQT_SIGNAL(closing()),
-            this, TQT_SLOT(slotAudioMixerClosed()));
+    connect(m_audioMixer, TQ_SIGNAL(closing()),
+            this, TQ_SLOT(slotAudioMixerClosed()));
 
-    connect(m_audioMixer, TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
-            this, TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
+    connect(m_audioMixer, TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
+            this, TQ_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
 
     connect(this,
-            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
             m_audioMixer,
-            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(this,
-            TQT_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
+            TQ_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
             m_audioMixer,
-            TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
-
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            m_audioMixer, TQT_SLOT(close()));
-
-    connect(m_view, TQT_SIGNAL(checkTrackAssignments()),
-            m_audioMixer, TQT_SLOT(slotTrackAssignmentsChanged()));
-
-    connect(m_audioMixer, TQT_SIGNAL(play()),
-            this, TQT_SLOT(slotPlay()));
-    connect(m_audioMixer, TQT_SIGNAL(stop()),
-            this, TQT_SLOT(slotStop()));
-    connect(m_audioMixer, TQT_SIGNAL(fastForwardPlayback()),
-            this, TQT_SLOT(slotFastforward()));
-    connect(m_audioMixer, TQT_SIGNAL(rewindPlayback()),
-            this, TQT_SLOT(slotRewind()));
-    connect(m_audioMixer, TQT_SIGNAL(fastForwardPlaybackToEnd()),
-            this, TQT_SLOT(slotFastForwardToEnd()));
-    connect(m_audioMixer, TQT_SIGNAL(rewindPlaybackToBeginning()),
-            this, TQT_SLOT(slotRewindToBeginning()));
-    connect(m_audioMixer, TQT_SIGNAL(record()),
-            this, TQT_SLOT(slotRecord()));
-    connect(m_audioMixer, TQT_SIGNAL(panic()),
-            this, TQT_SLOT(slotPanic()));
+            TQ_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
+
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            m_audioMixer, TQ_SLOT(close()));
+
+    connect(m_view, TQ_SIGNAL(checkTrackAssignments()),
+            m_audioMixer, TQ_SLOT(slotTrackAssignmentsChanged()));
+
+    connect(m_audioMixer, TQ_SIGNAL(play()),
+            this, TQ_SLOT(slotPlay()));
+    connect(m_audioMixer, TQ_SIGNAL(stop()),
+            this, TQ_SLOT(slotStop()));
+    connect(m_audioMixer, TQ_SIGNAL(fastForwardPlayback()),
+            this, TQ_SLOT(slotFastforward()));
+    connect(m_audioMixer, TQ_SIGNAL(rewindPlayback()),
+            this, TQ_SLOT(slotRewind()));
+    connect(m_audioMixer, TQ_SIGNAL(fastForwardPlaybackToEnd()),
+            this, TQ_SLOT(slotFastForwardToEnd()));
+    connect(m_audioMixer, TQ_SIGNAL(rewindPlaybackToBeginning()),
+            this, TQ_SLOT(slotRewindToBeginning()));
+    connect(m_audioMixer, TQ_SIGNAL(record()),
+            this, TQ_SLOT(slotRecord()));
+    connect(m_audioMixer, TQ_SIGNAL(panic()),
+            this, TQ_SLOT(slotPanic()));
 
     connect(m_audioMixer,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
             this,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
             m_audioMixer,
-            TQT_SLOT(slotUpdateInstrument(InstrumentId)));
+            TQ_SLOT(slotUpdateInstrument(InstrumentId)));
 
     if (m_synthManager) {
         connect(m_synthManager,
-                TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
+                TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
                 m_audioMixer,
-                TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
+                TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
     }
 
     plugAccelerators(m_audioMixer, m_audioMixer->getAccelerators());
@@ -6678,44 +6678,44 @@ RosegardenGUIApp::slotOpenMidiMixer()
 
     m_midiMixer = new MidiMixerWindow(this, m_doc);
 
-    connect(m_midiMixer, TQT_SIGNAL(windowActivated()),
-            m_view, TQT_SLOT(slotActiveMainWindowChanged()));
-
-    connect(m_view, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            m_midiMixer, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
-
-    connect(m_midiMixer, TQT_SIGNAL(closing()),
-            this, TQT_SLOT(slotMidiMixerClosed()));
-
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            m_midiMixer, TQT_SLOT(close()));
-
-    connect(m_midiMixer, TQT_SIGNAL(play()),
-            this, TQT_SLOT(slotPlay()));
-    connect(m_midiMixer, TQT_SIGNAL(stop()),
-            this, TQT_SLOT(slotStop()));
-    connect(m_midiMixer, TQT_SIGNAL(fastForwardPlayback()),
-            this, TQT_SLOT(slotFastforward()));
-    connect(m_midiMixer, TQT_SIGNAL(rewindPlayback()),
-            this, TQT_SLOT(slotRewind()));
-    connect(m_midiMixer, TQT_SIGNAL(fastForwardPlaybackToEnd()),
-            this, TQT_SLOT(slotFastForwardToEnd()));
-    connect(m_midiMixer, TQT_SIGNAL(rewindPlaybackToBeginning()),
-            this, TQT_SLOT(slotRewindToBeginning()));
-    connect(m_midiMixer, TQT_SIGNAL(record()),
-            this, TQT_SLOT(slotRecord()));
-    connect(m_midiMixer, TQT_SIGNAL(panic()),
-            this, TQT_SLOT(slotPanic()));
+    connect(m_midiMixer, TQ_SIGNAL(windowActivated()),
+            m_view, TQ_SLOT(slotActiveMainWindowChanged()));
+
+    connect(m_view, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            m_midiMixer, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+
+    connect(m_midiMixer, TQ_SIGNAL(closing()),
+            this, TQ_SLOT(slotMidiMixerClosed()));
+
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            m_midiMixer, TQ_SLOT(close()));
+
+    connect(m_midiMixer, TQ_SIGNAL(play()),
+            this, TQ_SLOT(slotPlay()));
+    connect(m_midiMixer, TQ_SIGNAL(stop()),
+            this, TQ_SLOT(slotStop()));
+    connect(m_midiMixer, TQ_SIGNAL(fastForwardPlayback()),
+            this, TQ_SLOT(slotFastforward()));
+    connect(m_midiMixer, TQ_SIGNAL(rewindPlayback()),
+            this, TQ_SLOT(slotRewind()));
+    connect(m_midiMixer, TQ_SIGNAL(fastForwardPlaybackToEnd()),
+            this, TQ_SLOT(slotFastForwardToEnd()));
+    connect(m_midiMixer, TQ_SIGNAL(rewindPlaybackToBeginning()),
+            this, TQ_SLOT(slotRewindToBeginning()));
+    connect(m_midiMixer, TQ_SIGNAL(record()),
+            this, TQ_SLOT(slotRecord()));
+    connect(m_midiMixer, TQ_SIGNAL(panic()),
+            this, TQ_SLOT(slotPanic()));
 
     connect(m_midiMixer,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
             this,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
             m_midiMixer,
-            TQT_SLOT(slotUpdateInstrument(InstrumentId)));
+            TQ_SLOT(slotUpdateInstrument(InstrumentId)));
 
     plugAccelerators(m_midiMixer, m_midiMixer->getAccelerators());
 
@@ -6742,14 +6742,14 @@ RosegardenGUIApp::slotEditControlParameters(DeviceId device)
 
     RG_DEBUG << "inserting control editor dialog, have " << m_controlEditors.size() << " now" << endl;
 
-    connect(controlEditor, TQT_SIGNAL(closing()),
-            TQT_SLOT(slotControlEditorClosed()));
+    connect(controlEditor, TQ_SIGNAL(closing()),
+            TQ_SLOT(slotControlEditorClosed()));
 
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            controlEditor, TQT_SLOT(close()));
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            controlEditor, TQ_SLOT(close()));
 
-    connect(m_doc, TQT_SIGNAL(devicesResyncd()),
-            controlEditor, TQT_SLOT(slotUpdate()));
+    connect(m_doc, TQ_SIGNAL(devicesResyncd()),
+            controlEditor, TQ_SLOT(slotUpdate()));
 
     controlEditor->show();
 }
@@ -6774,16 +6774,16 @@ RosegardenGUIApp::slotEditBanks(DeviceId device)
 
     m_bankEditor = new BankEditorDialog(this, m_doc, device);
 
-    connect(m_bankEditor, TQT_SIGNAL(closing()),
-            this, TQT_SLOT(slotBankEditorClosed()));
+    connect(m_bankEditor, TQ_SIGNAL(closing()),
+            this, TQ_SLOT(slotBankEditorClosed()));
 
-    connect(this, TQT_SIGNAL(documentAboutToChange()),
-            m_bankEditor, TQT_SLOT(slotFileClose()));
+    connect(this, TQ_SIGNAL(documentAboutToChange()),
+            m_bankEditor, TQ_SLOT(slotFileClose()));
 
     // Cheating way of updating the track/instrument list
     //
-    connect(m_bankEditor, TQT_SIGNAL(deviceNamesChanged()),
-            m_view, TQT_SLOT(slotSynchroniseWithComposition()));
+    connect(m_bankEditor, TQ_SIGNAL(deviceNamesChanged()),
+            m_view, TQ_SLOT(slotSynchroniseWithComposition()));
 
     m_bankEditor->show();
 }
@@ -6800,11 +6800,11 @@ RosegardenGUIApp::slotManageTriggerSegments()
 
     m_triggerSegmentManager = new TriggerSegmentManager(this, m_doc);
 
-    connect(m_triggerSegmentManager, TQT_SIGNAL(closing()),
-            TQT_SLOT(slotTriggerManagerClosed()));
+    connect(m_triggerSegmentManager, TQ_SIGNAL(closing()),
+            TQ_SLOT(slotTriggerManagerClosed()));
 
-    connect(m_triggerSegmentManager, TQT_SIGNAL(editTriggerSegment(int)),
-            m_view, TQT_SLOT(slotEditTriggerSegment(int)));
+    connect(m_triggerSegmentManager, TQ_SIGNAL(editTriggerSegment(int)),
+            m_view, TQ_SLOT(slotEditTriggerSegment(int)));
 
     m_triggerSegmentManager->show();
 }
@@ -6829,11 +6829,11 @@ RosegardenGUIApp::slotEditMarkers()
 
     m_markerEditor = new MarkerEditor(this, m_doc);
 
-    connect(m_markerEditor, TQT_SIGNAL(closing()),
-            TQT_SLOT(slotMarkerEditorClosed()));
+    connect(m_markerEditor, TQ_SIGNAL(closing()),
+            TQ_SLOT(slotMarkerEditorClosed()));
 
-    connect(m_markerEditor, TQT_SIGNAL(jumpToMarker(timeT)),
-            m_doc, TQT_SLOT(slotSetPointerPosition(timeT)));
+    connect(m_markerEditor, TQ_SIGNAL(jumpToMarker(timeT)),
+            m_doc, TQ_SLOT(slotSetPointerPosition(timeT)));
 
     plugAccelerators(m_markerEditor, m_markerEditor->getAccelerators());
 
@@ -6860,24 +6860,24 @@ RosegardenGUIApp::slotEditTempos(timeT t)
 
     m_tempoView = new TempoView(m_doc, getView(), t);
 
-    connect(m_tempoView, TQT_SIGNAL(closing()),
-            TQT_SLOT(slotTempoViewClosed()));
+    connect(m_tempoView, TQ_SIGNAL(closing()),
+            TQ_SLOT(slotTempoViewClosed()));
 
-    connect(m_tempoView, TQT_SIGNAL(windowActivated()),
-            getView(), TQT_SLOT(slotActiveMainWindowChanged()));
+    connect(m_tempoView, TQ_SIGNAL(windowActivated()),
+            getView(), TQ_SLOT(slotActiveMainWindowChanged()));
 
     connect(m_tempoView,
-            TQT_SIGNAL(changeTempo(timeT,
+            TQ_SIGNAL(changeTempo(timeT,
                                tempoT,
                                tempoT,
                                TempoDialog::TempoDialogAction)),
             this,
-            TQT_SLOT(slotChangeTempo(timeT,
+            TQ_SLOT(slotChangeTempo(timeT,
                                  tempoT,
                                  tempoT,
                                  TempoDialog::TempoDialogAction)));
 
-    connect(m_tempoView, TQT_SIGNAL(saveFile()), this, TQT_SLOT(slotFileSave()));
+    connect(m_tempoView, TQ_SIGNAL(saveFile()), this, TQ_SLOT(slotFileSave()));
 
     plugAccelerators(m_tempoView, m_tempoView->getAccelerators());
 
@@ -6960,12 +6960,12 @@ RosegardenGUIApp::slotShowPluginDialog(TQWidget *parent,
                               container,
                               index);
 
-    connect(dialog, TQT_SIGNAL(windowActivated()),
-            m_view, TQT_SLOT(slotActiveMainWindowChanged()));
+    connect(dialog, TQ_SIGNAL(windowActivated()),
+            m_view, TQ_SLOT(slotActiveMainWindowChanged()));
 
 /* This feature isn't provided by the plugin dialog
-    connect(m_view, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            dialog, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+    connect(m_view, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            dialog, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
 */
 
     // Plug the new dialog into the standard keyboard accelerators so
@@ -6974,46 +6974,46 @@ RosegardenGUIApp::slotShowPluginDialog(TQWidget *parent,
     plugAccelerators(dialog, dialog->getAccelerators());
 
     connect(dialog,
-            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
             this,
-            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(dialog,
-            TQT_SIGNAL(pluginPortChanged(InstrumentId, int, int)),
+            TQ_SIGNAL(pluginPortChanged(InstrumentId, int, int)),
             this,
-            TQT_SLOT(slotPluginPortChanged(InstrumentId, int, int)));
+            TQ_SLOT(slotPluginPortChanged(InstrumentId, int, int)));
 
     connect(dialog,
-            TQT_SIGNAL(pluginProgramChanged(InstrumentId, int)),
+            TQ_SIGNAL(pluginProgramChanged(InstrumentId, int)),
             this,
-            TQT_SLOT(slotPluginProgramChanged(InstrumentId, int)));
+            TQ_SLOT(slotPluginProgramChanged(InstrumentId, int)));
 
     connect(dialog,
-            TQT_SIGNAL(changePluginConfiguration(InstrumentId, int, bool, TQString, TQString)),
+            TQ_SIGNAL(changePluginConfiguration(InstrumentId, int, bool, TQString, TQString)),
             this,
-            TQT_SLOT(slotChangePluginConfiguration(InstrumentId, int, bool, TQString, TQString)));
+            TQ_SLOT(slotChangePluginConfiguration(InstrumentId, int, bool, TQString, TQString)));
 
     connect(dialog,
-            TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
+            TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
             this,
-            TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
+            TQ_SLOT(slotShowPluginGUI(InstrumentId, int)));
 
     connect(dialog,
-            TQT_SIGNAL(stopPluginGUI(InstrumentId, int)),
+            TQ_SIGNAL(stopPluginGUI(InstrumentId, int)),
             this,
-            TQT_SLOT(slotStopPluginGUI(InstrumentId, int)));
+            TQ_SLOT(slotStopPluginGUI(InstrumentId, int)));
 
     connect(dialog,
-            TQT_SIGNAL(bypassed(InstrumentId, int, bool)),
+            TQ_SIGNAL(bypassed(InstrumentId, int, bool)),
             this,
-            TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
+            TQ_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
 
     connect(dialog,
-            TQT_SIGNAL(destroyed(InstrumentId, int)),
+            TQ_SIGNAL(destroyed(InstrumentId, int)),
             this,
-            TQT_SLOT(slotPluginDialogDestroyed(InstrumentId, int)));
+            TQ_SLOT(slotPluginDialogDestroyed(InstrumentId, int)));
 
-    connect(this, TQT_SIGNAL(documentAboutToChange()), dialog, TQT_SLOT(close()));
+    connect(this, TQ_SIGNAL(documentAboutToChange()), dialog, TQ_SLOT(close()));
 
     m_pluginDialogs[key] = dialog;
     m_pluginDialogs[key]->show();
@@ -7535,10 +7535,10 @@ RosegardenGUIApp::slotPlayList()
 {
     if (!m_playList) {
         m_playList = new PlayListDialog(i18n("Play List"), this);
-        connect(m_playList, TQT_SIGNAL(closing()),
-                TQT_SLOT(slotPlayListClosed()));
-        connect(m_playList->getPlayList(), TQT_SIGNAL(play(TQString)),
-                TQT_SLOT(slotPlayListPlay(TQString)));
+        connect(m_playList, TQ_SIGNAL(closing()),
+                TQ_SLOT(slotPlayListClosed()));
+        connect(m_playList->getPlayList(), TQ_SIGNAL(play(TQString)),
+                TQ_SLOT(slotPlayListPlay(TQString)));
     }
 
     m_playList->show();
@@ -7682,10 +7682,10 @@ RosegardenGUIApp::slotPanic()
             (&progressDlg);
         ProgressDialog::processEvents();
 
-        connect(m_seqManager, TQT_SIGNAL(setProgress(int)),
-                progressDlg.progressBar(), TQT_SLOT(setValue(int)));
-        connect(m_seqManager, TQT_SIGNAL(incrementProgress(int)),
-                progressDlg.progressBar(), TQT_SLOT(advance(int)));
+        connect(m_seqManager, TQ_SIGNAL(setProgress(int)),
+                progressDlg.progressBar(), TQ_SLOT(setValue(int)));
+        connect(m_seqManager, TQ_SIGNAL(incrementProgress(int)),
+                progressDlg.progressBar(), TQ_SLOT(advance(int)));
 
         m_seqManager->panic();
 
@@ -7717,9 +7717,9 @@ RosegardenGUIApp::slotRemapInstruments()
     RG_DEBUG << "RosegardenGUIApp::slotRemapInstruments\n";
     RemapInstrumentDialog dialog(this, m_doc);
 
-    connect(&dialog, TQT_SIGNAL(applyClicked()),
+    connect(&dialog, TQ_SIGNAL(applyClicked()),
             m_view->getTrackEditor()->getTrackButtons(),
-            TQT_SLOT(slotSynchroniseWithComposition()));
+            TQ_SLOT(slotSynchroniseWithComposition()));
 
     if (dialog.exec() == TQDialog::Accepted) {
         RG_DEBUG << "slotRemapInstruments - accepted\n";
diff --git a/src/gui/application/RosegardenGUIView.cpp b/src/gui/application/RosegardenGUIView.cpp
index b8ba4ef..03e437e 100644
--- a/src/gui/application/RosegardenGUIView.cpp
+++ b/src/gui/application/RosegardenGUIView.cpp
@@ -139,91 +139,91 @@ RosegardenGUIView::RosegardenGUIView(bool showTrackLabels,
                                     m_rulerScale, showTrackLabels, unitsPerPixel, this /*hbox*/);
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(editSegment(Segment*)),
-            TQT_SLOT(slotEditSegment(Segment*)));
+            TQ_SIGNAL(editSegment(Segment*)),
+            TQ_SLOT(slotEditSegment(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(editSegmentNotation(Segment*)),
-            TQT_SLOT(slotEditSegmentNotation(Segment*)));
+            TQ_SIGNAL(editSegmentNotation(Segment*)),
+            TQ_SLOT(slotEditSegmentNotation(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(editSegmentMatrix(Segment*)),
-            TQT_SLOT(slotEditSegmentMatrix(Segment*)));
+            TQ_SIGNAL(editSegmentMatrix(Segment*)),
+            TQ_SLOT(slotEditSegmentMatrix(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(editSegmentAudio(Segment*)),
-            TQT_SLOT(slotEditSegmentAudio(Segment*)));
+            TQ_SIGNAL(editSegmentAudio(Segment*)),
+            TQ_SLOT(slotEditSegmentAudio(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(audioSegmentAutoSplit(Segment*)),
-            TQT_SLOT(slotSegmentAutoSplit(Segment*)));
+            TQ_SIGNAL(audioSegmentAutoSplit(Segment*)),
+            TQ_SLOT(slotSegmentAutoSplit(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(editSegmentEventList(Segment*)),
-            TQT_SLOT(slotEditSegmentEventList(Segment*)));
+            TQ_SIGNAL(editSegmentEventList(Segment*)),
+            TQ_SLOT(slotEditSegmentEventList(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(editRepeat(Segment*, timeT)),
-            TQT_SLOT(slotEditRepeat(Segment*, timeT)));
+            TQ_SIGNAL(editRepeat(Segment*, timeT)),
+            TQ_SLOT(slotEditRepeat(Segment*, timeT)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            TQT_SIGNAL(setPointerPosition(timeT)),
-            doc, TQT_SLOT(slotSetPointerPosition(timeT)));
+            TQ_SIGNAL(setPointerPosition(timeT)),
+            doc, TQ_SLOT(slotSetPointerPosition(timeT)));
 
     connect(m_trackEditor,
-            TQT_SIGNAL(droppedDocument(TQString)),
+            TQ_SIGNAL(droppedDocument(TQString)),
             parent,
-            TQT_SLOT(slotOpenDroppedURL(TQString)));
+            TQ_SLOT(slotOpenDroppedURL(TQString)));
 
     connect(m_trackEditor,
-            TQT_SIGNAL(droppedAudio(TQString)),
+            TQ_SIGNAL(droppedAudio(TQString)),
             this,
-            TQT_SLOT(slotDroppedAudio(TQString)));
+            TQ_SLOT(slotDroppedAudio(TQString)));
 
     connect(m_trackEditor,
-            TQT_SIGNAL(droppedNewAudio(TQString)),
+            TQ_SIGNAL(droppedNewAudio(TQString)),
             this,
-            TQT_SLOT(slotDroppedNewAudio(TQString)));
+            TQ_SLOT(slotDroppedNewAudio(TQString)));
 
     connect(m_instrumentParameterBox,
-            TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
+            TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
             this,
-            TQT_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
+            TQ_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
 
     connect(m_instrumentParameterBox,
-            TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
+            TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
             m_trackParameterBox,
-            TQT_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
+            TQ_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
 
     connect(m_trackEditor->getTrackButtons(),
-            TQT_SIGNAL(nameChanged()),
+            TQ_SIGNAL(nameChanged()),
             m_trackParameterBox,
-            TQT_SLOT(slotSelectedTrackNameChanged()));
+            TQ_SLOT(slotSelectedTrackNameChanged()));
 
     connect(m_trackEditor->getTrackButtons(),
-            TQT_SIGNAL(instrumentSelected(int)),
+            TQ_SIGNAL(instrumentSelected(int)),
             m_trackParameterBox,
-            TQT_SLOT(slotUpdateControls(int)));
+            TQ_SLOT(slotUpdateControls(int)));
 
     connect(m_trackParameterBox,
-            TQT_SIGNAL(instrumentSelected(TrackId, int)),
+            TQ_SIGNAL(instrumentSelected(TrackId, int)),
             m_trackEditor->getTrackButtons(),
-            TQT_SLOT(slotTrackInstrumentSelection(TrackId, int)));
+            TQ_SLOT(slotTrackInstrumentSelection(TrackId, int)));
 
-    connect(this, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            this, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+    connect(this, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            this, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
 
     if (doc) {
         /* signal no longer exists
-        	connect(doc, TQT_SIGNAL(recordingSegmentUpdated(Segment *,
+        	connect(doc, TQ_SIGNAL(recordingSegmentUpdated(Segment *,
         						    timeT)),
-        		this, TQT_SLOT(slotUpdateRecordingSegment(Segment *,
+        		this, TQ_SLOT(slotUpdateRecordingSegment(Segment *,
         						      timeT)));
         */
 
         TQObject::connect
-        (getCommandHistory(), TQT_SIGNAL(commandExecuted()),
-         m_trackEditor->getSegmentCanvas(), TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
+        (getCommandHistory(), TQ_SIGNAL(commandExecuted()),
+         m_trackEditor->getSegmentCanvas(), TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
     }
 }
 
@@ -455,77 +455,77 @@ RosegardenGUIView::createNotationView(std::vector<Segment *> segmentsToEdit)
     // For tempo changes (ugh -- it'd be nicer to make a tempo change
     // command that could interpret all this stuff from the dialog)
     //
-    connect(notationView, TQT_SIGNAL(changeTempo(timeT,
+    connect(notationView, TQ_SIGNAL(changeTempo(timeT,
                                  tempoT,
                                  tempoT,
                                  TempoDialog::TempoDialogAction)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
+            RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
                                            tempoT,
                                            tempoT,
                                            TempoDialog::TempoDialogAction)));
 
 
-    connect(notationView, TQT_SIGNAL(windowActivated()),
-            this, TQT_SLOT(slotActiveMainWindowChanged()));
-
-    connect(notationView, TQT_SIGNAL(selectTrack(int)),
-            this, TQT_SLOT(slotSelectTrackSegments(int)));
-
-    connect(notationView, TQT_SIGNAL(play()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
-    connect(notationView, TQT_SIGNAL(stop()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
-    connect(notationView, TQT_SIGNAL(fastForwardPlayback()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
-    connect(notationView, TQT_SIGNAL(rewindPlayback()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
-    connect(notationView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
-    connect(notationView, TQT_SIGNAL(rewindPlaybackToBeginning()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
-    connect(notationView, TQT_SIGNAL(panic()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
-
-    connect(notationView, TQT_SIGNAL(saveFile()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
-    connect(notationView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
-            getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
-    connect(notationView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
-    connect(notationView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
-    connect(notationView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
-    connect(notationView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
+    connect(notationView, TQ_SIGNAL(windowActivated()),
+            this, TQ_SLOT(slotActiveMainWindowChanged()));
+
+    connect(notationView, TQ_SIGNAL(selectTrack(int)),
+            this, TQ_SLOT(slotSelectTrackSegments(int)));
+
+    connect(notationView, TQ_SIGNAL(play()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
+    connect(notationView, TQ_SIGNAL(stop()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
+    connect(notationView, TQ_SIGNAL(fastForwardPlayback()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
+    connect(notationView, TQ_SIGNAL(rewindPlayback()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
+    connect(notationView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
+    connect(notationView, TQ_SIGNAL(rewindPlaybackToBeginning()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
+    connect(notationView, TQ_SIGNAL(panic()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
+
+    connect(notationView, TQ_SIGNAL(saveFile()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
+    connect(notationView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
+            getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
+    connect(notationView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
+    connect(notationView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
+    connect(notationView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
+    connect(notationView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
 /* hjj: WHAT DO DO WITH THIS ?
-    connect(notationView, TQT_SIGNAL(editMetadata(TQString)),
-            this, TQT_SLOT(slotEditMetadata(TQString)));
+    connect(notationView, TQ_SIGNAL(editMetadata(TQString)),
+            this, TQ_SLOT(slotEditMetadata(TQString)));
 */
-    connect(notationView, TQT_SIGNAL(editTriggerSegment(int)),
-            this, TQT_SLOT(slotEditTriggerSegment(int)));
-    connect(notationView, TQT_SIGNAL(staffLabelChanged(TrackId, TQString)),
-            this, TQT_SLOT(slotChangeTrackLabel(TrackId, TQString)));
-    connect(notationView, TQT_SIGNAL(toggleSolo(bool)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
-    connect(notationView, TQT_SIGNAL(editTimeSignature(timeT)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
+    connect(notationView, TQ_SIGNAL(editTriggerSegment(int)),
+            this, TQ_SLOT(slotEditTriggerSegment(int)));
+    connect(notationView, TQ_SIGNAL(staffLabelChanged(TrackId, TQString)),
+            this, TQ_SLOT(slotChangeTrackLabel(TrackId, TQString)));
+    connect(notationView, TQ_SIGNAL(toggleSolo(bool)),
+            RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
+    connect(notationView, TQ_SIGNAL(editTimeSignature(timeT)),
+            RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
 
     SequenceManager *sM = getDocument()->getSequenceManager();
 
-    connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
-            notationView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
-    connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
-            notationView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
+    connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
+            notationView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
+    connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
+            notationView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
 
-    connect(notationView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
-            this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
-    connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
-            notationView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
-    connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
-            notationView, TQT_SLOT(slotCompositionStateUpdate()));
-    connect(this, TQT_SIGNAL(compositionStateUpdate()),
-            notationView, TQT_SLOT(slotCompositionStateUpdate()));
+    connect(notationView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
+    connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            notationView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
+    connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
+            notationView, TQ_SLOT(slotCompositionStateUpdate()));
+    connect(this, TQ_SIGNAL(compositionStateUpdate()),
+            notationView, TQ_SLOT(slotCompositionStateUpdate()));
 
     // Encourage the notation view window to open to the same
     // interval as the current segment view
@@ -657,73 +657,73 @@ RosegardenGUIView::createMatrixView(std::vector<Segment *> segmentsToEdit, bool
     // For tempo changes (ugh -- it'd be nicer to make a tempo change
     // command that could interpret all this stuff from the dialog)
     //
-    connect(matrixView, TQT_SIGNAL(changeTempo(timeT,
+    connect(matrixView, TQ_SIGNAL(changeTempo(timeT,
                                            tempoT,
                                            tempoT,
                                            TempoDialog::TempoDialogAction)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
+            RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
                                            tempoT,
                                            tempoT,
                                            TempoDialog::TempoDialogAction)));
 
-    connect(matrixView, TQT_SIGNAL(windowActivated()),
-            this, TQT_SLOT(slotActiveMainWindowChanged()));
-
-    connect(matrixView, TQT_SIGNAL(selectTrack(int)),
-            this, TQT_SLOT(slotSelectTrackSegments(int)));
-
-    connect(matrixView, TQT_SIGNAL(play()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
-    connect(matrixView, TQT_SIGNAL(stop()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
-    connect(matrixView, TQT_SIGNAL(fastForwardPlayback()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
-    connect(matrixView, TQT_SIGNAL(rewindPlayback()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
-    connect(matrixView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
-    connect(matrixView, TQT_SIGNAL(rewindPlaybackToBeginning()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
-    connect(matrixView, TQT_SIGNAL(panic()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
-
-    connect(matrixView, TQT_SIGNAL(saveFile()),
-            RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
-    connect(matrixView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
-            getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
-    connect(matrixView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
-    connect(matrixView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
-    connect(matrixView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
-            this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
-    connect(matrixView, TQT_SIGNAL(editTriggerSegment(int)),
-            this, TQT_SLOT(slotEditTriggerSegment(int)));
-    connect(matrixView, TQT_SIGNAL(toggleSolo(bool)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
-    connect(matrixView, TQT_SIGNAL(editTimeSignature(timeT)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
+    connect(matrixView, TQ_SIGNAL(windowActivated()),
+            this, TQ_SLOT(slotActiveMainWindowChanged()));
+
+    connect(matrixView, TQ_SIGNAL(selectTrack(int)),
+            this, TQ_SLOT(slotSelectTrackSegments(int)));
+
+    connect(matrixView, TQ_SIGNAL(play()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
+    connect(matrixView, TQ_SIGNAL(stop()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
+    connect(matrixView, TQ_SIGNAL(fastForwardPlayback()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
+    connect(matrixView, TQ_SIGNAL(rewindPlayback()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
+    connect(matrixView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
+    connect(matrixView, TQ_SIGNAL(rewindPlaybackToBeginning()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
+    connect(matrixView, TQ_SIGNAL(panic()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
+
+    connect(matrixView, TQ_SIGNAL(saveFile()),
+            RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
+    connect(matrixView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
+            getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
+    connect(matrixView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
+    connect(matrixView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
+    connect(matrixView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
+            this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
+    connect(matrixView, TQ_SIGNAL(editTriggerSegment(int)),
+            this, TQ_SLOT(slotEditTriggerSegment(int)));
+    connect(matrixView, TQ_SIGNAL(toggleSolo(bool)),
+            RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
+    connect(matrixView, TQ_SIGNAL(editTimeSignature(timeT)),
+            RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
 
     SequenceManager *sM = getDocument()->getSequenceManager();
 
-    connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
-            matrixView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
-    connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
-            matrixView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
-
-    connect(matrixView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
-            this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
-    connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
-            matrixView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
-    connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
-            matrixView, TQT_SLOT(slotCompositionStateUpdate()));
-    connect(this, TQT_SIGNAL(compositionStateUpdate()),
-            matrixView, TQT_SLOT(slotCompositionStateUpdate()));
+    connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
+            matrixView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
+    connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
+            matrixView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
+
+    connect(matrixView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
+    connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            matrixView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
+    connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
+            matrixView, TQ_SLOT(slotCompositionStateUpdate()));
+    connect(this, TQ_SIGNAL(compositionStateUpdate()),
+            matrixView, TQ_SLOT(slotCompositionStateUpdate()));
     connect(this,
-            TQT_SIGNAL(instrumentLevelsChanged(InstrumentId,
+            TQ_SIGNAL(instrumentLevelsChanged(InstrumentId,
                                            const LevelInfo &)),
             matrixView,
-            TQT_SLOT(slotInstrumentLevelsChanged(InstrumentId,
+            TQ_SLOT(slotInstrumentLevelsChanged(InstrumentId,
                                              const LevelInfo &)));
 
     // Encourage the matrix view window to open to the same
@@ -1543,12 +1543,12 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
 
     // Connect the progress dialog
     //
-    connect(&aFM, TQT_SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
-    connect(&aFM, TQT_SIGNAL(setOperationName(TQString)),
-            &progressDlg, TQT_SLOT(slotSetOperationName(TQString)));
-    connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
-            &aFM, TQT_SLOT(slotStopImport()));
+    connect(&aFM, TQ_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQ_SLOT(setValue(int)));
+    connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
+            &progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
+    connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
+            &aFM, TQ_SLOT(slotStopImport()));
 
     try {
         audioFileId = aFM.importURL(kurl, sampleRate);
@@ -1564,10 +1564,10 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
         return ;
     }
              
-    disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
-               &aFM, TQT_SLOT(slotStopImport()));
-    connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
-            &aFM, TQT_SLOT(slotStopPreview()));
+    disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
+               &aFM, TQ_SLOT(slotStopImport()));
+    connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
+            &aFM, TQ_SLOT(slotStopPreview()));
     progressDlg.progressBar()->show();
     progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
 
@@ -1581,8 +1581,8 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
         //return false;
     }
 
-    disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
-               &aFM, TQT_SLOT(slotStopPreview()));
+    disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
+               &aFM, TQ_SLOT(slotStopPreview()));
 
     // add the file at the sequencer
     emit addAudioFile(audioFileId);
@@ -1747,8 +1747,8 @@ RosegardenGUIView::slotUpdateRecordingSegment(Segment *segment,
 
     /* signal no longer exists
         TQObject::connect
-    	(getDocument(), TQT_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
-    	 view, TQT_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
+    	(getDocument(), TQ_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
+    	 view, TQ_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
     */
 
     view->show();
@@ -1998,31 +1998,31 @@ RosegardenGUIView::createEventView(std::vector<Segment *> segmentsToEdit)
                                          segmentsToEdit,
                                          this);
 
-    connect(eventView, TQT_SIGNAL(windowActivated()),
-        this, TQT_SLOT(slotActiveMainWindowChanged()));
-
-    connect(eventView, TQT_SIGNAL(selectTrack(int)),
-            this, TQT_SLOT(slotSelectTrackSegments(int)));
-
-    connect(eventView, TQT_SIGNAL(saveFile()),
-        RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
-
-    connect(eventView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
-        this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
-    connect(eventView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
-        this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
-    connect(eventView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
-        this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
-    connect(eventView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
-        this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
-    connect(eventView, TQT_SIGNAL(editTriggerSegment(int)),
-        this, TQT_SLOT(slotEditTriggerSegment(int)));
-    connect(this, TQT_SIGNAL(compositionStateUpdate()),
-        eventView, TQT_SLOT(slotCompositionStateUpdate()));
-    connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
-        eventView, TQT_SLOT(slotCompositionStateUpdate()));
-    connect(eventView, TQT_SIGNAL(toggleSolo(bool)),
-            RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
+    connect(eventView, TQ_SIGNAL(windowActivated()),
+        this, TQ_SLOT(slotActiveMainWindowChanged()));
+
+    connect(eventView, TQ_SIGNAL(selectTrack(int)),
+            this, TQ_SLOT(slotSelectTrackSegments(int)));
+
+    connect(eventView, TQ_SIGNAL(saveFile()),
+        RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
+
+    connect(eventView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
+        this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
+    connect(eventView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
+        this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
+    connect(eventView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
+        this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
+    connect(eventView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
+        this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
+    connect(eventView, TQ_SIGNAL(editTriggerSegment(int)),
+        this, TQ_SLOT(slotEditTriggerSegment(int)));
+    connect(this, TQ_SIGNAL(compositionStateUpdate()),
+        eventView, TQ_SLOT(slotCompositionStateUpdate()));
+    connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
+        eventView, TQ_SLOT(slotCompositionStateUpdate()));
+    connect(eventView, TQ_SIGNAL(toggleSolo(bool)),
+            RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
 
     // create keyboard accelerators on view
     //
diff --git a/src/gui/application/StartupTester.cpp b/src/gui/application/StartupTester.cpp
index 7bb40a6..84e84aa 100644
--- a/src/gui/application/StartupTester.cpp
+++ b/src/gui/application/StartupTester.cpp
@@ -42,10 +42,10 @@ StartupTester::StartupTester() :
     m_haveAudioFileImporter(false)
 {
     TQHttp *http = new TQHttp();
-    connect(http, TQT_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
-            this, TQT_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
-    connect(http, TQT_SIGNAL(done(bool)),
-            this, TQT_SLOT(slotHttpDone(bool)));
+    connect(http, TQ_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
+            this, TQ_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
+    connect(http, TQ_SIGNAL(done(bool)),
+            this, TQ_SLOT(slotHttpDone(bool)));
     m_versionHttpFailed = false;
     http->setHost("www.rosegardenmusic.com");
     http->get("/latest-version.txt");
@@ -65,8 +65,8 @@ StartupTester::run()
 
     TDEProcess *proc = new TDEProcess();
     m_stdoutBuffer = "";
-    TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
-                     this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
+    TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
+                     this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
     *proc << "rosegarden-audiofile-importer";
     *proc << "--conftest";
     proc->start(TDEProcess::Block, TDEProcess::All);
@@ -83,8 +83,8 @@ StartupTester::run()
 
     proc = new TDEProcess;
     m_stdoutBuffer = "";
-    TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
-                     this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
+    TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
+                     this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
     *proc << "rosegarden-project-package";
     *proc << "--conftest";
     proc->start(TDEProcess::Block, TDEProcess::All);
@@ -103,8 +103,8 @@ StartupTester::run()
 
     proc = new TDEProcess();
     m_stdoutBuffer = "";
-    TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
-                     this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
+    TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
+                     this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
     *proc << "rosegarden-lilypondview";
     *proc << "--conftest";
     proc->start(TDEProcess::Block, TDEProcess::All);
diff --git a/src/gui/application/main.cpp b/src/gui/application/main.cpp
index 011a0c6..ecb8e40 100644
--- a/src/gui/application/main.cpp
+++ b/src/gui/application/main.cpp
@@ -479,7 +479,7 @@ int main(int argc, char *argv[])
     // Ensure quit on last window close
     // Register main DCOP interface
     //
-    TQObject::connect(&app, TQT_SIGNAL(lastWindowClosed()), &app, TQT_SLOT(quit()));
+    TQObject::connect(&app, TQ_SIGNAL(lastWindowClosed()), &app, TQ_SLOT(quit()));
     app.dcopClient()->registerAs(app.name(), false);
     app.dcopClient()->setDefaultObject(ROSEGARDEN_GUI_IFACE_NAME);
 
@@ -624,8 +624,8 @@ int main(int argc, char *argv[])
 
     }
 
-    TQObject::connect(&app, TQT_SIGNAL(aboutToSaveState()),
-                     rosegardengui, TQT_SLOT(slotDeleteTransport()));
+    TQObject::connect(&app, TQ_SIGNAL(aboutToSaveState()),
+                     rosegardengui, TQ_SLOT(slotDeleteTransport()));
 
     // Now that we've started up, raise start logo
     //
@@ -661,8 +661,8 @@ int main(int argc, char *argv[])
             (*sfxLoadProcess) << sfxLoadPath << soundFontPath;
             RG_DEBUG << "Starting sfxload : " << sfxLoadPath << " " << soundFontPath << endl;
 
-            TQObject::connect(sfxLoadProcess, TQT_SIGNAL(processExited(TDEProcess*)),
-                             &app, TQT_SLOT(sfxLoadExited(TDEProcess*)));
+            TQObject::connect(sfxLoadProcess, TQ_SIGNAL(processExited(TDEProcess*)),
+                             &app, TQ_SLOT(sfxLoadExited(TDEProcess*)));
 
             sfxLoadProcess->start();
         } else {
@@ -694,7 +694,7 @@ int main(int argc, char *argv[])
 
         if (visibleFor < RealTime(2, 0)) {
             int waitTime = visibleFor.sec * 1000 + visibleFor.msec();
-            TQTimer::singleShot(2500 - waitTime, startLogo, TQT_SLOT(close()));
+            TQTimer::singleShot(2500 - waitTime, startLogo, TQ_SLOT(close()));
         } else {
             startLogo->close();
         }