Initial TQt conversion

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

1 files changed, 777 insertions, 777 deletions

diff --git a/src/gui/application/RosegardenGUIApp.cpp.orig b/src/gui/application/RosegardenGUIApp.cpp.orig
index fa98530..889f4f7 100644
--- a/src/gui/application/RosegardenGUIApp.cpp.orig
+++ b/src/gui/application/RosegardenGUIApp.cpp.orig
@@ -199,31 +199,31 @@
 #include <ktoolbar.h>
 #include <kurl.h>
 #include <kxmlguiclient.h>
-#include <qaccel.h>
-#include <qcanvas.h>
-#include <qcstring.h>
-#include <qcursor.h>
-#include <qdatastream.h>
-#include <qdialog.h>
-#include <qdir.h>
-#include <qfile.h>
-#include <qfileinfo.h>
-#include <qiconset.h>
-#include <qinputdialog.h>
-#include <qlabel.h>
-#include <qobject.h>
-#include <qobjectlist.h>
-#include <qpixmap.h>
-#include <qpopupmenu.h>
-#include <qpushbutton.h>
-#include <qregexp.h>
-#include <qslider.h>
-#include <qstring.h>
-#include <qstringlist.h>
-#include <qtextcodec.h>
-#include <qtimer.h>
-#include <qvaluevector.h>
-#include <qwidget.h>
+#include <tqaccel.h>
+#include <tqcanvas.h>
+#include <tqcstring.h>
+#include <tqcursor.h>
+#include <tqdatastream.h>
+#include <tqdialog.h>
+#include <tqdir.h>
+#include <tqfile.h>
+#include <tqfileinfo.h>
+#include <tqiconset.h>
+#include <tqinputdialog.h>
+#include <tqlabel.h>
+#include <tqobject.h>
+#include <tqobjectlist.h>
+#include <tqpixmap.h>
+#include <tqpopupmenu.h>
+#include <tqpushbutton.h>
+#include <tqregexp.h>
+#include <tqslider.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
+#include <tqtextcodec.h>
+#include <tqtimer.h>
+#include <tqvaluevector.h>
+#include <tqwidget.h>
 
 #ifdef HAVE_LIBJACK
 #include <jack/jack.h>
@@ -235,7 +235,7 @@ namespace Rosegarden
 
 RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
                                    bool useExistingSequencer,
-                                   QObject *startupStatusMessageReceiver)
+                                   TQObject *startupStatusMessageReceiver)
         : DCOPObject("RosegardenIface"), RosegardenIface(this), KDockMainWindow(0),
         m_actionsSetup(false),
         m_fileRecent(0),
@@ -258,7 +258,7 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
         m_storedLoopEnd(0),
         m_useSequencer(useSequencer),
         m_dockVisible(true),
-        m_autoSaveTimer(new QTimer(this)),
+        m_autoSaveTimer(new TQTimer(this)),
         m_clipboard(new Clipboard),
         m_playList(0),
         m_deviceManager(0),
@@ -272,8 +272,8 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
 #ifdef HAVE_LIBLO
         m_pluginGUIManager(new AudioPluginOSCGUIManager(this)),
 #endif
-        m_playTimer(new QTimer(this)),
-        m_stopTimer(new QTimer(this)),
+        m_playTimer(new TQTimer(this)),
+        m_stopTimer(new TQTimer(this)),
         m_startupTester(0),
 #ifdef HAVE_LIRC
         m_lircClient(0),
@@ -287,9 +287,9 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
 
 
     if (startupStatusMessageReceiver) {
-        QObject::connect(this, SIGNAL(startupStatusMessage(QString)),
+        TQObject::connect(this, TQT_SIGNAL(startupStatusMessage(TQString)),
                          startupStatusMessageReceiver,
-                         SLOT(slotShowStatusMessage(QString)));
+                         TQT_SLOT(slotShowStatusMessage(TQString)));
     }
 
     // Try to start the sequencer
@@ -341,7 +341,7 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
     iFaceDelayedInit(this);
     initZoomToolbar();
 
-    QPixmap dummyPixmap; // any icon will do
+    TQPixmap dummyPixmap; // any icon will do
     m_mainDockWidget = createDockWidget("Rosegarden MainDockWidget", dummyPixmap, 0L, "main_dock_widget");
     // allow others to dock to the left and right sides only
     m_mainDockWidget->setDockSite(KDockWidget::DockLeft | KDockWidget::DockRight);
@@ -356,14 +356,14 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
                            KDockWidget::DockLeft,  // dock site
                            20);                   // relation target/this (in percent)
 
-    connect(m_dockLeft, SIGNAL(iMBeingClosed()),
-            this, SLOT(slotParametersClosed()));
-    connect(m_dockLeft, SIGNAL(hasUndocked()),
-            this, SLOT(slotParametersClosed()));
+    connect(m_dockLeft, TQT_SIGNAL(iMBeingClosed()),
+            this, TQT_SLOT(slotParametersClosed()));
+    connect(m_dockLeft, TQT_SIGNAL(hasUndocked()),
+            this, TQT_SLOT(slotParametersClosed()));
     // Apparently, hasUndocked() is emitted when the dock widget's
     // 'close' button on the dock handle is clicked.
-    connect(m_mainDockWidget, SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
-            this, SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
+    connect(m_mainDockWidget, TQT_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
+            this, TQT_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
 
     stateChanged("parametersbox_closed", KXMLGUIClient::StateReverse);
 
@@ -393,35 +393,35 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
     m_dockLeft->update();
 
     connect(m_instrumentParameterBox,
-            SIGNAL(selectPlugin(QWidget *, InstrumentId, int)),
+            TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
             this,
-            SLOT(slotShowPluginDialog(QWidget *, InstrumentId, int)));
+            TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
 
     connect(m_instrumentParameterBox,
-            SIGNAL(showPluginGUI(InstrumentId, int)),
+            TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
             this,
-            SLOT(slotShowPluginGUI(InstrumentId, int)));
+            TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
 
     // relay this through our own signal so that others can use it too
     connect(m_instrumentParameterBox,
-            SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
             this,
-            SIGNAL(instrumentParametersChanged(InstrumentId)));
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
             m_instrumentParameterBox,
-            SLOT(slotInstrumentParametersChanged(InstrumentId)));
+            TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
             m_instrumentParameterBox,
-            SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(this,
-            SIGNAL(pluginBypassed(InstrumentId, int, bool)),
+            TQT_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
             m_instrumentParameterBox,
-            SLOT(slotPluginBypassed(InstrumentId, int, bool)));
+            TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
 
     // Load the initial document (this includes doc's own autoload)
     //
@@ -441,8 +441,8 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
     }
 
     if (m_view) {
-        connect(m_seqManager, SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
-                m_view, SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
+        connect(m_seqManager, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
+                m_view, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
     }
 
     if (m_seqManager->getSoundDriverStatus() & AUDIO_OK) {
@@ -496,7 +496,7 @@ RosegardenGUIApp::RosegardenGUIApp(bool useSequencer,
 
     stateChanged("have_project_packager", KXMLGUIClient::StateReverse);
     stateChanged("have_lilypondview", KXMLGUIClient::StateReverse);
-    QTimer::singleShot(1000, this, SLOT(slotTestStartupTester()));
+    TQTimer::singleShot(1000, this, TQT_SLOT(slotTestStartupTester()));
 }
 
 RosegardenGUIApp::~RosegardenGUIApp()
@@ -541,101 +541,101 @@ void RosegardenGUIApp::setupActions()
 {
     // setup File menu
     // New Window ?
-    KStdAction::openNew (this, SLOT(slotFileNew()), actionCollection());
-    KStdAction::open (this, SLOT(slotFileOpen()), actionCollection());
+    KStdAction::openNew (this, TQT_SLOT(slotFileNew()), actionCollection());
+    KStdAction::open (this, TQT_SLOT(slotFileOpen()), actionCollection());
     m_fileRecent = KStdAction::openRecent(this,
-                                          SLOT(slotFileOpenRecent(const KURL&)),
+                                          TQT_SLOT(slotFileOpenRecent(const KURL&)),
                                           actionCollection());
-    KStdAction::save (this, SLOT(slotFileSave()), actionCollection());
-    KStdAction::saveAs(this, SLOT(slotFileSaveAs()), actionCollection());
-    KStdAction::revert(this, SLOT(slotRevertToSaved()), actionCollection());
-    KStdAction::close (this, SLOT(slotFileClose()), actionCollection());
-    KStdAction::print (this, SLOT(slotFilePrint()), actionCollection());
-    KStdAction::printPreview (this, SLOT(slotFilePrintPreview()), 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());
 
     new KAction(i18n("Import Rosegarden &Project file..."), 0, 0, this,
-                SLOT(slotImportProject()), actionCollection(),
+                TQT_SLOT(slotImportProject()), actionCollection(),
                 "file_import_project");
 
     new KAction(i18n("Import &MIDI file..."), 0, 0, this,
-                SLOT(slotImportMIDI()), actionCollection(),
+                TQT_SLOT(slotImportMIDI()), actionCollection(),
                 "file_import_midi");
 
     new KAction(i18n("Import &Rosegarden 2.1 file..."), 0, 0, this,
-                SLOT(slotImportRG21()), actionCollection(),
+                TQT_SLOT(slotImportRG21()), actionCollection(),
                 "file_import_rg21");
 
     new KAction(i18n("Import &Hydrogen file..."), 0, 0, this,
-                SLOT(slotImportHydrogen()), actionCollection(),
+                TQT_SLOT(slotImportHydrogen()), actionCollection(),
                 "file_import_hydrogen");
 
     new KAction(i18n("Merge &File..."), 0, 0, this,
-                SLOT(slotMerge()), actionCollection(),
+                TQT_SLOT(slotMerge()), actionCollection(),
                 "file_merge");
 
     new KAction(i18n("Merge &MIDI file..."), 0, 0, this,
-                SLOT(slotMergeMIDI()), actionCollection(),
+                TQT_SLOT(slotMergeMIDI()), actionCollection(),
                 "file_merge_midi");
 
     new KAction(i18n("Merge &Rosegarden 2.1 file..."), 0, 0, this,
-                SLOT(slotMergeRG21()), actionCollection(),
+                TQT_SLOT(slotMergeRG21()), actionCollection(),
                 "file_merge_rg21");
 
     new KAction(i18n("Merge &Hydrogen file..."), 0, 0, this,
-                SLOT(slotMergeHydrogen()), actionCollection(),
+                TQT_SLOT(slotMergeHydrogen()), actionCollection(),
                 "file_merge_hydrogen");
 
     new KAction(i18n("Export Rosegarden &Project file..."), 0, 0, this,
-                SLOT(slotExportProject()), actionCollection(),
+                TQT_SLOT(slotExportProject()), actionCollection(),
                 "file_export_project");
 
     new KAction(i18n("Export &MIDI file..."), 0, 0, this,
-                SLOT(slotExportMIDI()), actionCollection(),
+                TQT_SLOT(slotExportMIDI()), actionCollection(),
                 "file_export_midi");
 
     new KAction(i18n("Export &LilyPond file..."), 0, 0, this,
-                SLOT(slotExportLilyPond()), actionCollection(),
+                TQT_SLOT(slotExportLilyPond()), actionCollection(),
                 "file_export_lilypond");
 
     new KAction(i18n("Export Music&XML file..."), 0, 0, this,
-                SLOT(slotExportMusicXml()), actionCollection(),
+                TQT_SLOT(slotExportMusicXml()), actionCollection(),
                 "file_export_musicxml");
 
     new KAction(i18n("Export &Csound score file..."), 0, 0, this,
-                SLOT(slotExportCsound()), actionCollection(),
+                TQT_SLOT(slotExportCsound()), actionCollection(),
                 "file_export_csound");
 
     new KAction(i18n("Export M&up file..."), 0, 0, this,
-                SLOT(slotExportMup()), actionCollection(),
+                TQT_SLOT(slotExportMup()), actionCollection(),
                 "file_export_mup");
 
     new KAction(i18n("Print &with LilyPond..."), 0, 0, this,
-                SLOT(slotPrintLilyPond()), actionCollection(),
+                TQT_SLOT(slotPrintLilyPond()), actionCollection(),
                 "file_print_lilypond");
 
     new KAction(i18n("Preview with Lil&yPond..."), 0, 0, this,
-                SLOT(slotPreviewLilyPond()), actionCollection(),
+                TQT_SLOT(slotPreviewLilyPond()), actionCollection(),
                 "file_preview_lilypond");
 
     new KAction(i18n("Play&list"), 0, 0, this,
-                SLOT(slotPlayList()), actionCollection(),
+                TQT_SLOT(slotPlayList()), actionCollection(),
                 "file_show_playlist");
 
-    KStdAction::quit (this, SLOT(slotQuit()), actionCollection());
+    KStdAction::quit (this, TQT_SLOT(slotQuit()), actionCollection());
 
     // help menu
     new KAction(i18n("Rosegarden &Tutorial"), 0, 0, this,
-                SLOT(slotTutorial()), actionCollection(),
+                TQT_SLOT(slotTutorial()), actionCollection(),
                 "tutorial");
 
     new KAction(i18n("&Bug Reporting Guidelines"), 0, 0, this,
-                SLOT(slotBugGuidelines()), actionCollection(),
+                TQT_SLOT(slotBugGuidelines()), actionCollection(),
                 "guidelines");
 
     // setup edit menu
-    KStdAction::cut (this, SLOT(slotEditCut()), actionCollection());
-    KStdAction::copy (this, SLOT(slotEditCopy()), actionCollection());
-    KStdAction::paste (this, SLOT(slotEditPaste()), actionCollection());
+    KStdAction::cut (this, TQT_SLOT(slotEditCut()), actionCollection());
+    KStdAction::copy (this, TQT_SLOT(slotEditCopy()), actionCollection());
+    KStdAction::paste (this, TQT_SLOT(slotEditPaste()), actionCollection());
 
     //
     // undo/redo actions are special in that they are connected to
@@ -659,202 +659,202 @@ void RosegardenGUIApp::setupActions()
 
     // setup Settings menu
     //
-    m_viewToolBar = KStdAction::showToolbar (this, SLOT(slotToggleToolBar()), actionCollection(),
+    m_viewToolBar = KStdAction::showToolbar (this, TQT_SLOT(slotToggleToolBar()), actionCollection(),
                     "show_stock_toolbar");
 
     m_viewToolsToolBar = new KToggleAction(i18n("Show T&ools Toolbar"), 0, this,
-                                           SLOT(slotToggleToolsToolBar()), actionCollection(),
+                                           TQT_SLOT(slotToggleToolsToolBar()), actionCollection(),
                                            "show_tools_toolbar");
 
     m_viewTracksToolBar = new KToggleAction(i18n("Show Trac&ks Toolbar"), 0, this,
-                                            SLOT(slotToggleTracksToolBar()), actionCollection(),
+                                            TQT_SLOT(slotToggleTracksToolBar()), actionCollection(),
                                             "show_tracks_toolbar");
 
     m_viewEditorsToolBar = new KToggleAction(i18n("Show &Editors Toolbar"), 0, this,
-                           SLOT(slotToggleEditorsToolBar()), actionCollection(),
+                           TQT_SLOT(slotToggleEditorsToolBar()), actionCollection(),
                            "show_editors_toolbar");
 
     m_viewTransportToolBar = new KToggleAction(i18n("Show Trans&port Toolbar"), 0, this,
-                             SLOT(slotToggleTransportToolBar()), actionCollection(),
+                             TQT_SLOT(slotToggleTransportToolBar()), actionCollection(),
                              "show_transport_toolbar");
 
     m_viewZoomToolBar = new KToggleAction(i18n("Show &Zoom Toolbar"), 0, this,
-                                          SLOT(slotToggleZoomToolBar()), actionCollection(),
+                                          TQT_SLOT(slotToggleZoomToolBar()), actionCollection(),
                                           "show_zoom_toolbar");
 
-    m_viewStatusBar = KStdAction::showStatusbar(this, SLOT(slotToggleStatusBar()),
+    m_viewStatusBar = KStdAction::showStatusbar(this, TQT_SLOT(slotToggleStatusBar()),
                       actionCollection(), "show_status_bar");
 
     m_viewTransport = new KToggleAction(i18n("Show Tra&nsport"), Key_T, this,
-                                        SLOT(slotToggleTransport()),
+                                        TQT_SLOT(slotToggleTransport()),
                                         actionCollection(),
                                         "show_transport");
 
     m_viewTrackLabels = new KToggleAction(i18n("Show Track &Labels"), 0, this,
-                                          SLOT(slotToggleTrackLabels()),
+                                          TQT_SLOT(slotToggleTrackLabels()),
                                           actionCollection(),
                                           "show_tracklabels");
 
     m_viewRulers = new KToggleAction(i18n("Show Playback Position R&uler"), 0, this,
-                                     SLOT(slotToggleRulers()),
+                                     TQT_SLOT(slotToggleRulers()),
                                      actionCollection(),
                                      "show_rulers");
 
     m_viewTempoRuler = new KToggleAction(i18n("Show Te&mpo Ruler"), 0, this,
-                                         SLOT(slotToggleTempoRuler()),
+                                         TQT_SLOT(slotToggleTempoRuler()),
                                          actionCollection(),
                                          "show_tempo_ruler");
 
     m_viewChordNameRuler = new KToggleAction(i18n("Show Cho&rd Name Ruler"), 0, this,
-                           SLOT(slotToggleChordNameRuler()),
+                           TQT_SLOT(slotToggleChordNameRuler()),
                            actionCollection(),
                            "show_chord_name_ruler");
 
 
     m_viewPreviews = new KToggleAction(i18n("Show Segment Pre&views"), 0, this,
-                                       SLOT(slotTogglePreviews()),
+                                       TQT_SLOT(slotTogglePreviews()),
                                        actionCollection(),
                                        "show_previews");
 
     new KAction(i18n("Show Special &Parameters"), Key_P, this,
-                SLOT(slotDockParametersBack()),
+                TQT_SLOT(slotDockParametersBack()),
                 actionCollection(),
                 "show_inst_segment_parameters");
 
-    KStdAction::tipOfDay( this, SLOT( slotShowTip() ), actionCollection() );
+    KStdAction::tipOfDay( this, TQT_SLOT( slotShowTip() ), actionCollection() );
 
     // Standard Actions
     //
     KStdAction::saveOptions(this,
-                            SLOT(slotSaveOptions()),
+                            TQT_SLOT(slotSaveOptions()),
                             actionCollection());
 
     KStdAction::preferences(this,
-                            SLOT(slotConfigure()),
+                            TQT_SLOT(slotConfigure()),
                             actionCollection());
 
     KStdAction::keyBindings(this,
-                            SLOT(slotEditKeys()),
+                            TQT_SLOT(slotEditKeys()),
                             actionCollection());
 
     KStdAction::configureToolbars(this,
-                                  SLOT(slotEditToolbars()),
+                                  TQT_SLOT(slotEditToolbars()),
                                   actionCollection());
 
     KRadioAction *action = 0;
 
     // Create the select icon
     //
-    QString pixmapDir = KGlobal::dirs()->findResource("appdata", "pixmaps/");
-    QCanvasPixmap pixmap(pixmapDir + "/toolbar/select.xpm");
-    QIconSet icon = QIconSet(pixmap);
+    TQString pixmapDir = KGlobal::dirs()->findResource("appdata", "pixmaps/");
+    TQCanvasPixmap pixmap(pixmapDir + "/toolbar/select.xpm");
+    TQIconSet icon = TQIconSet(pixmap);
 
     // TODO : add some shortcuts here
     action = new KRadioAction(i18n("&Select and Edit"), icon, Key_F2,
-                              this, SLOT(slotPointerSelected()),
+                              this, TQT_SLOT(slotPointerSelected()),
                               actionCollection(), "select");
     action->setExclusiveGroup("segmenttools");
 
     action = new KRadioAction(i18n("&Draw"), "pencil", Key_F3,
-                              this, SLOT(slotDrawSelected()),
+                              this, TQT_SLOT(slotDrawSelected()),
                               actionCollection(), "draw");
     action->setExclusiveGroup("segmenttools");
 
     action = new KRadioAction(i18n("&Erase"), "eraser", Key_F4,
-                              this, SLOT(slotEraseSelected()),
+                              this, TQT_SLOT(slotEraseSelected()),
                               actionCollection(), "erase");
     action->setExclusiveGroup("segmenttools");
 
     action = new KRadioAction(i18n("&Move"), "move", Key_F5,
-                              this, SLOT(slotMoveSelected()),
+                              this, TQT_SLOT(slotMoveSelected()),
                               actionCollection(), "move");
     action->setExclusiveGroup("segmenttools");
 
     pixmap.load(pixmapDir + "/toolbar/resize.xpm");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     action = new KRadioAction(i18n("&Resize"), icon, Key_F6,
-                              this, SLOT(slotResizeSelected()),
+                              this, TQT_SLOT(slotResizeSelected()),
                               actionCollection(), "resize");
     action->setExclusiveGroup("segmenttools");
 
     pixmap.load(pixmapDir + "/toolbar/split.xpm");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     action = new KRadioAction(i18n("&Split"), icon, Key_F7,
-                              this, SLOT(slotSplitSelected()),
+                              this, TQT_SLOT(slotSplitSelected()),
                               actionCollection(), "split");
     action->setExclusiveGroup("segmenttools");
 
     pixmap.load(pixmapDir + "/toolbar/join.xpm");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     action = new KRadioAction(i18n("&Join"), icon, 0,
-                              this, SLOT(slotJoinSelected()),
+                              this, TQT_SLOT(slotJoinSelected()),
                               actionCollection(), "join");
     action->setExclusiveGroup("segmenttools");
 
 
     new KAction(i18n("&Harmonize"), 0, this,
-                SLOT(slotHarmonizeSelection()), actionCollection(),
+                TQT_SLOT(slotHarmonizeSelection()), actionCollection(),
                 "harmonize_selection");
 
     pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(AddTimeSignatureCommand::getGlobalName(),
                 icon, 0,
-                this, SLOT(slotEditTimeSignature()),
+                this, TQT_SLOT(slotEditTimeSignature()),
                 actionCollection(), "add_time_signature");
 
     new KAction(i18n("Open Tempo and Time Signature Editor"), 0, this,
-                SLOT(slotEditTempos()), actionCollection(), "edit_tempos");
+                TQT_SLOT(slotEditTempos()), actionCollection(), "edit_tempos");
 
     //
     // Edit menu
     //
     new KAction(i18n("Cut Range"), Key_X + CTRL + SHIFT, this,
-                SLOT(slotCutRange()), actionCollection(),
+                TQT_SLOT(slotCutRange()), actionCollection(),
                 "cut_range");
 
     new KAction(i18n("Copy Range"), Key_C + CTRL + SHIFT, this,
-                SLOT(slotCopyRange()), actionCollection(),
+                TQT_SLOT(slotCopyRange()), actionCollection(),
                 "copy_range");
 
     new KAction(i18n("Paste Range"), Key_V + CTRL + SHIFT, this,
-                SLOT(slotPasteRange()), actionCollection(),
+                TQT_SLOT(slotPasteRange()), actionCollection(),
                 "paste_range");
 /*
     new KAction(i18n("Delete Range"), Key_Delete + SHIFT, this,
-                SLOT(slotDeleteRange()), actionCollection(),
+                TQT_SLOT(slotDeleteRange()), actionCollection(),
                 "delete_range");
 */
     new KAction(i18n("Insert Range..."), Key_Insert + SHIFT, this,
-                SLOT(slotInsertRange()), actionCollection(),
+                TQT_SLOT(slotInsertRange()), actionCollection(),
                 "insert_range");
 
     new KAction(i18n("De&lete"), Key_Delete, this,
-                SLOT(slotDeleteSelectedSegments()), actionCollection(),
+                TQT_SLOT(slotDeleteSelectedSegments()), actionCollection(),
                 "delete");
 
     new KAction(i18n("Select &All Segments"), Key_A + CTRL, this,
-                SLOT(slotSelectAll()), actionCollection(),
+                TQT_SLOT(slotSelectAll()), actionCollection(),
                 "select_all");
 
     pixmap.load(pixmapDir + "/toolbar/event-insert-tempo.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(AddTempoChangeCommand::getGlobalName(),
                 icon, 0,
-                this, SLOT(slotEditTempo()),
+                this, TQT_SLOT(slotEditTempo()),
                 actionCollection(), "add_tempo");
 
     new KAction(ChangeCompositionLengthCommand::getGlobalName(),
                 0,
-                this, SLOT(slotChangeCompositionLength()),
+                this, TQT_SLOT(slotChangeCompositionLength()),
                 actionCollection(), "change_composition_length");
 
     new KAction(i18n("Edit Mar&kers..."), Key_K + CTRL, this,
-                SLOT(slotEditMarkers()),
+                TQT_SLOT(slotEditMarkers()),
                 actionCollection(), "edit_markers");
 
     new KAction(i18n("Edit Document P&roperties..."), 0, this,
-                SLOT(slotEditDocumentProperties()),
+                TQT_SLOT(slotEditDocumentProperties()),
                 actionCollection(), "edit_doc_properties");
 
 
@@ -862,267 +862,267 @@ void RosegardenGUIApp::setupActions()
     // Segments menu
     //
     new KAction(i18n("Open in &Default Editor"), Key_Return, this,
-                SLOT(slotEdit()), actionCollection(),
+                TQT_SLOT(slotEdit()), actionCollection(),
                 "edit_default");
 
     pixmap.load(pixmapDir + "/toolbar/matrix.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Open in Matri&x Editor"), icon, Key_M, this,
-                SLOT(slotEditInMatrix()), actionCollection(),
+                TQT_SLOT(slotEditInMatrix()), actionCollection(),
                 "edit_matrix");
 
     pixmap.load(pixmapDir + "/toolbar/matrix-percussion.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Open in &Percussion Matrix Editor"), icon, Key_D, this,
-                SLOT(slotEditInPercussionMatrix()), actionCollection(),
+                TQT_SLOT(slotEditInPercussionMatrix()), actionCollection(),
                 "edit_percussion_matrix");
 
     pixmap.load(pixmapDir + "/toolbar/notation.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Open in &Notation Editor"), icon, Key_N, this,
-                SLOT(slotEditAsNotation()), actionCollection(),
+                TQT_SLOT(slotEditAsNotation()), actionCollection(),
                 "edit_notation");
 
     pixmap.load(pixmapDir + "/toolbar/eventlist.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Open in &Event List Editor"), icon, Key_E, this,
-                SLOT(slotEditInEventList()), actionCollection(),
+                TQT_SLOT(slotEditInEventList()), actionCollection(),
                 "edit_event_list");
 
     pixmap.load(pixmapDir + "/toolbar/quantize.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("&Quantize..."), icon, Key_Equal, this,
-                SLOT(slotQuantizeSelection()), actionCollection(),
+                TQT_SLOT(slotQuantizeSelection()), actionCollection(),
                 "quantize_selection");
 
     new KAction(SegmentLabelCommand::getGlobalName(),
                 0,
-                this, SLOT(slotRelabelSegments()),
+                this, TQT_SLOT(slotRelabelSegments()),
                 actionCollection(), "relabel_segment");
 
     new KAction(SegmentTransposeCommand::getGlobalName(),
                 0,
-                this, SLOT(slotTransposeSegments()),
+                this, TQT_SLOT(slotTransposeSegments()),
                 actionCollection(), "transpose");
 
     new KAction(i18n("Repeat Last Quantize"), Key_Plus, this,
-                SLOT(slotRepeatQuantizeSelection()), actionCollection(),
+                TQT_SLOT(slotRepeatQuantizeSelection()), actionCollection(),
                 "repeat_quantize");
 
     new KAction(SegmentRescaleCommand::getGlobalName(), 0, this,
-                SLOT(slotRescaleSelection()), actionCollection(),
+                TQT_SLOT(slotRescaleSelection()), actionCollection(),
                 "rescale");
 
     new KAction(SegmentAutoSplitCommand::getGlobalName(), 0, this,
-                SLOT(slotAutoSplitSelection()), actionCollection(),
+                TQT_SLOT(slotAutoSplitSelection()), actionCollection(),
                 "auto_split");
 
     new KAction(SegmentSplitByPitchCommand::getGlobalName(), 0, this,
-                SLOT(slotSplitSelectionByPitch()), actionCollection(),
+                TQT_SLOT(slotSplitSelectionByPitch()), actionCollection(),
                 "split_by_pitch");
 
     new KAction(SegmentSplitByRecordingSrcCommand::getGlobalName(), 0, this,
-                SLOT(slotSplitSelectionByRecordedSrc()), actionCollection(),
+                TQT_SLOT(slotSplitSelectionByRecordedSrc()), actionCollection(),
                 "split_by_recording");
 
     new KAction(i18n("Split at Time..."), 0, this,
-                SLOT(slotSplitSelectionAtTime()), actionCollection(),
+                TQT_SLOT(slotSplitSelectionAtTime()), actionCollection(),
                 "split_at_time");
 
     new KAction(i18n("Jog &Left"), Key_Left + ALT, this,
-                SLOT(slotJogLeft()), actionCollection(),
+                TQT_SLOT(slotJogLeft()), actionCollection(),
                 "jog_left");
 
     new KAction(i18n("Jog &Right"), Key_Right + ALT, this,
-                SLOT(slotJogRight()), actionCollection(),
+                TQT_SLOT(slotJogRight()), actionCollection(),
                 "jog_right");
 
     new KAction(i18n("Set Start Time..."), 0, this,
-                SLOT(slotSetSegmentStartTimes()), actionCollection(),
+                TQT_SLOT(slotSetSegmentStartTimes()), actionCollection(),
                 "set_segment_start");
 
     new KAction(i18n("Set Duration..."), 0, this,
-                SLOT(slotSetSegmentDurations()), actionCollection(),
+                TQT_SLOT(slotSetSegmentDurations()), actionCollection(),
                 "set_segment_duration");
 
     new KAction(SegmentJoinCommand::getGlobalName(),
                 Key_J + CTRL,
-                this, SLOT(slotJoinSegments()),
+                this, TQT_SLOT(slotJoinSegments()),
                 actionCollection(), "join_segments");
 
     new KAction(i18n("Turn Re&peats into Copies"),
                 0,
-                this, SLOT(slotRepeatingSegments()),
+                this, TQT_SLOT(slotRepeatingSegments()),
                 actionCollection(), "repeats_to_real_copies");
 
     new KAction(i18n("Manage Tri&ggered Segments"), 0,
-                this, SLOT(slotManageTriggerSegments()),
+                this, TQT_SLOT(slotManageTriggerSegments()),
                 actionCollection(), "manage_trigger_segments");
 
     new KAction(i18n("Set Tempos from &Beat Segment"), 0, this,
-                SLOT(slotGrooveQuantize()), actionCollection(),
+                TQT_SLOT(slotGrooveQuantize()), actionCollection(),
                 "groove_quantize");
 
     new KAction(i18n("Set &Tempo to Audio Segment Duration"), 0, this,
-                SLOT(slotTempoToSegmentLength()), actionCollection(),
+                TQT_SLOT(slotTempoToSegmentLength()), actionCollection(),
                 "set_tempo_to_segment_length");
 
     pixmap.load(pixmapDir + "/toolbar/manage-audio-segments.xpm");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Manage A&udio Files"), icon,
                 Key_U + CTRL,
-                this, SLOT(slotAudioManager()),
+                this, TQT_SLOT(slotAudioManager()),
                 actionCollection(), "audio_manager");
 
     m_viewSegmentLabels = new KToggleAction(i18n("Show Segment Labels"), 0, this,
-                                            SLOT(slotToggleSegmentLabels()), actionCollection(),
+                                            TQT_SLOT(slotToggleSegmentLabels()), actionCollection(),
                                             "show_segment_labels");
 
     //
     // Tracks menu
     //
     pixmap.load(pixmapDir + "/toolbar/add_tracks.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Add &Track"), icon, CTRL + Key_T,
-                this, SLOT(slotAddTrack()),
+                this, TQT_SLOT(slotAddTrack()),
                 actionCollection(), "add_track");
 
     new KAction(i18n("&Add Tracks..."), 0,
-                this, SLOT(slotAddTracks()),
+                this, TQT_SLOT(slotAddTracks()),
                 actionCollection(), "add_tracks");
 
     pixmap.load(pixmapDir + "/toolbar/delete_track.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("D&elete Track"), icon, CTRL + Key_D,
-                this, SLOT(slotDeleteTrack()),
+                this, TQT_SLOT(slotDeleteTrack()),
                 actionCollection(), "delete_track");
 
     pixmap.load(pixmapDir + "/toolbar/move_track_down.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Move Track &Down"), icon, SHIFT + Key_Down,
-                this, SLOT(slotMoveTrackDown()),
+                this, TQT_SLOT(slotMoveTrackDown()),
                 actionCollection(), "move_track_down");
 
     pixmap.load(pixmapDir + "/toolbar/move_track_up.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Move Track &Up"), icon, SHIFT + Key_Up,
-                this, SLOT(slotMoveTrackUp()),
+                this, TQT_SLOT(slotMoveTrackUp()),
                 actionCollection(), "move_track_up");
 
     new KAction(i18n("Select &Next Track"),
                 Key_Down,
-                this, SLOT(slotTrackDown()),
+                this, TQT_SLOT(slotTrackDown()),
                 actionCollection(), "select_next_track");
 
     new KAction(i18n("Select &Previous Track"),
                 Key_Up,
-                this, SLOT(slotTrackUp()),
+                this, TQT_SLOT(slotTrackUp()),
                 actionCollection(), "select_previous_track");
 
     new KAction(i18n("Mute or Unmute Track"),
                 Key_U,
-                this, SLOT(slotToggleMutedCurrentTrack()),
+                this, TQT_SLOT(slotToggleMutedCurrentTrack()),
                 actionCollection(), "toggle_mute_track");
 
     new KAction(i18n("Arm or Un-arm Track for Record"),
                 Key_R,
-                this, SLOT(slotToggleRecordCurrentTrack()),
+                this, TQT_SLOT(slotToggleRecordCurrentTrack()),
                 actionCollection(), "toggle_arm_track");
 
     pixmap.load(pixmapDir + "/toolbar/mute-all.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("&Mute all Tracks"), icon, 0,
-                this, SLOT(slotMuteAllTracks()),
+                this, TQT_SLOT(slotMuteAllTracks()),
                 actionCollection(), "mute_all_tracks");
 
     pixmap.load(pixmapDir + "/toolbar/un-mute-all.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("&Unmute all Tracks"), icon, 0,
-                this, SLOT(slotUnmuteAllTracks()),
+                this, TQT_SLOT(slotUnmuteAllTracks()),
                 actionCollection(), "unmute_all_tracks");
 
     new KAction(i18n("&Remap Instruments..."), 0, this,
-                SLOT(slotRemapInstruments()),
+                TQT_SLOT(slotRemapInstruments()),
                 actionCollection(), "remap_instruments");
 
     //
     // Studio menu
     //
     pixmap.load(pixmapDir + "/toolbar/mixer.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("&Audio Mixer"), icon, 0, this,
-                SLOT(slotOpenAudioMixer()),
+                TQT_SLOT(slotOpenAudioMixer()),
                 actionCollection(), "audio_mixer");
 
     pixmap.load(pixmapDir + "/toolbar/midimixer.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Midi Mi&xer"), icon, 0, this,
-                SLOT(slotOpenMidiMixer()),
+                TQT_SLOT(slotOpenMidiMixer()),
                 actionCollection(), "midi_mixer");
 
     pixmap.load(pixmapDir + "/toolbar/manage-midi-devices.xpm");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Manage MIDI &Devices"), icon, 0, this,
-                SLOT(slotManageMIDIDevices()),
+                TQT_SLOT(slotManageMIDIDevices()),
                 actionCollection(), "manage_devices");
 
     pixmap.load(pixmapDir + "/toolbar/manage-synth-plugins.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Manage S&ynth Plugins"), icon, 0, this,
-                SLOT(slotManageSynths()),
+                TQT_SLOT(slotManageSynths()),
                 actionCollection(), "manage_synths");
 
     new KAction(i18n("Modify MIDI &Filters"), "filter", 0, this,
-                SLOT(slotModifyMIDIFilters()),
+                TQT_SLOT(slotModifyMIDIFilters()),
                 actionCollection(), "modify_midi_filters");
 
     m_enableMIDIrouting = new KToggleAction(i18n("MIDI Thru Routing"), 0, this,
-                                            SLOT(slotEnableMIDIThruRouting()),
+                                            TQT_SLOT(slotEnableMIDIThruRouting()),
                                             actionCollection(), "enable_midi_routing");
 
     pixmap.load(pixmapDir + "/toolbar/time-musical.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     new KAction(i18n("Manage &Metronome"), 0, this,
-                SLOT(slotManageMetronome()),
+                TQT_SLOT(slotManageMetronome()),
                 actionCollection(), "manage_metronome");
 
     new KAction(i18n("&Save Current Document as Default Studio"), 0, this,
-                SLOT(slotSaveDefaultStudio()),
+                TQT_SLOT(slotSaveDefaultStudio()),
                 actionCollection(), "save_default_studio");
 
     new KAction(i18n("&Import Default Studio"), 0, this,
-                SLOT(slotImportDefaultStudio()),
+                TQT_SLOT(slotImportDefaultStudio()),
                 actionCollection(), "load_default_studio");
 
     new KAction(i18n("Im&port Studio from File..."), 0, this,
-                SLOT(slotImportStudio()),
+                TQT_SLOT(slotImportStudio()),
                 actionCollection(), "load_studio");
 
     new KAction(i18n("&Reset MIDI Network"), 0, this,
-                SLOT(slotResetMidiNetwork()),
+                TQT_SLOT(slotResetMidiNetwork()),
                 actionCollection(), "reset_midi_network");
 
     m_setQuickMarkerAction = new KAction(i18n("Set Quick Marker at Playback Position"), 0, CTRL + Key_1, this,
-                SLOT(slotSetQuickMarker()), actionCollection(),
+                TQT_SLOT(slotSetQuickMarker()), actionCollection(),
                 "set_quick_marker");
 
     m_jumpToQuickMarkerAction = new KAction(i18n("Jump to Quick Marker"), 0, Key_1, this,
-                SLOT(slotJumpToQuickMarker()), actionCollection(),
+                TQT_SLOT(slotJumpToQuickMarker()), actionCollection(),
                 "jump_to_quick_marker");
 
     //
     // Marker Ruler popup menu
     //
 //    new KAction(i18n("Insert Marker"), 0, 0, this,
-//             SLOT(slotInsertMarkerHere()), actionCollection(),
+//             TQT_SLOT(slotInsertMarkerHere()), actionCollection(),
 //             "insert_marker_here");
 //    
 //    new KAction(i18n("Insert Marker at Playback Position"), 0, 0, this,
-//             SLOT(slotInsertMarkerAtPointer()), actionCollection(),
+//             TQT_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
 //             "insert_marker_at_pointer");
 //
 //    new KAction(i18n("Delete Marker"), 0, 0, this,
-//             SLOT(slotDeleteMarker()), actionCollection(),
+//             TQT_SLOT(slotDeleteMarker()), actionCollection(),
 //             "delete_marker");
 
 
@@ -1138,9 +1138,9 @@ void RosegardenGUIApp::setupActions()
     // 0 (insert) and keypad Enter for Play and Stop
     //
     pixmap.load(pixmapDir + "/toolbar/transport-play.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_playTransport = new KAction(i18n("&Play"), icon, Key_Enter, this,
-                                  SLOT(slotPlay()), actionCollection(),
+                                  TQT_SLOT(slotPlay()), actionCollection(),
                                   "play");
     // Alternative shortcut for Play
     KShortcut playShortcut = m_playTransport->shortcut();
@@ -1149,69 +1149,69 @@ void RosegardenGUIApp::setupActions()
     m_playTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-stop.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_stopTransport = new KAction(i18n("&Stop"), icon, Key_Insert, this,
-                                  SLOT(slotStop()), actionCollection(),
+                                  TQT_SLOT(slotStop()), actionCollection(),
                                   "stop");
     m_stopTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-ffwd.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_ffwdTransport = new KAction(i18n("&Fast Forward"), icon, Key_PageDown,
                                   this,
-                                  SLOT(slotFastforward()), actionCollection(),
+                                  TQT_SLOT(slotFastforward()), actionCollection(),
                                   "fast_forward");
     m_ffwdTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-rewind.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_rewindTransport = new KAction(i18n("Re&wind"), icon, Key_End, this,
-                                    SLOT(slotRewind()), actionCollection(),
+                                    TQT_SLOT(slotRewind()), actionCollection(),
                                     "rewind");
     m_rewindTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-record.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_recordTransport = new KAction(i18n("P&unch in Record"), icon, Key_Space, this,
-                                    SLOT(slotToggleRecord()), actionCollection(),
+                                    TQT_SLOT(slotToggleRecord()), actionCollection(),
                                     "recordtoggle");
     m_recordTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-record.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_recordTransport = new KAction(i18n("&Record"), icon, 0, this,
-                                    SLOT(slotRecord()), actionCollection(),
+                                    TQT_SLOT(slotRecord()), actionCollection(),
                                     "record");
     m_recordTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-rewind-end.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_rewindEndTransport = new KAction(i18n("Rewind to &Beginning"), icon, 0, this,
-                                       SLOT(slotRewindToBeginning()), actionCollection(),
+                                       TQT_SLOT(slotRewindToBeginning()), actionCollection(),
                                        "rewindtobeginning");
     m_rewindEndTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-ffwd-end.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     m_ffwdEndTransport = new KAction(i18n("Fast Forward to &End"), icon, 0, this,
-                                     SLOT(slotFastForwardToEnd()), actionCollection(),
+                                     TQT_SLOT(slotFastForwardToEnd()), actionCollection(),
                                      "fastforwardtoend");
     m_ffwdEndTransport->setGroup(TransportDialogConfigGroup);
 
     pixmap.load(pixmapDir + "/toolbar/transport-tracking.png");
-    icon = QIconSet(pixmap);
+    icon = TQIconSet(pixmap);
     (new KToggleAction(i18n("Scro&ll to Follow Playback"), icon, Key_Pause, this,
-                       SLOT(slotToggleTracking()), actionCollection(),
+                       TQT_SLOT(slotToggleTracking()), actionCollection(),
                        "toggle_tracking"))->setChecked(true);
 
     pixmap.load(pixmapDir + "/toolbar/transport-panic.png");
-    icon = QIconSet(pixmap);
-    new KAction( i18n("Panic"), icon, Key_P + CTRL + ALT, this, SLOT(slotPanic()),
+    icon = TQIconSet(pixmap);
+    new KAction( i18n("Panic"), icon, Key_P + CTRL + ALT, this, TQT_SLOT(slotPanic()),
                  actionCollection(), "panic");
 
     // DEBUG FACILITY
     new KAction(i18n("Segment Debug Dump "), 0, this,
-                SLOT(slotDebugDump()), actionCollection(),
+                TQT_SLOT(slotDebugDump()), actionCollection(),
                 "debug_dump_segments");
 
     // create main gui
@@ -1224,11 +1224,11 @@ void RosegardenGUIApp::setupActions()
     //
     //toolBar("Transport Toolbar")->hide();
 
-    QPopupMenu* setTrackInstrumentMenu = dynamic_cast<QPopupMenu*>(factory()->container("set_track_instrument", this));
+    TQPopupMenu* setTrackInstrumentMenu = dynamic_cast<TQPopupMenu*>(factory()->container("set_track_instrument", this));
 
     if (setTrackInstrumentMenu) {
-        connect(setTrackInstrumentMenu, SIGNAL(aboutToShow()),
-                this, SLOT(slotPopulateTrackInstrumentPopup()));
+        connect(setTrackInstrumentMenu, TQT_SIGNAL(aboutToShow()),
+                this, TQT_SLOT(slotPopulateTrackInstrumentPopup()));
     } else {
         RG_DEBUG << "RosegardenGUIApp::setupActions() : couldn't find set_track_instrument menu - check rosegardenui.rcn\n";
     }
@@ -1238,21 +1238,21 @@ void RosegardenGUIApp::setupActions()
 
 void RosegardenGUIApp::setRewFFwdToAutoRepeat()
 {
-    QWidget* transportToolbar = factory()->container("Transport Toolbar", this);
+    TQWidget* transportToolbar = factory()->container("Transport Toolbar", this);
 
     if (transportToolbar) {
-        QObjectList *l = transportToolbar->queryList();
-        QObjectListIt it(*l); // iterate over the buttons
-        QObject *obj;
+        TQObjectList *l = transportToolbar->queryList();
+        TQObjectListIt it(*l); // iterate over the buttons
+        TQObject *obj;
 
         while ( (obj = it.current()) != 0 ) {
             // for each found object...
             ++it;
             // RG_DEBUG << "obj name : " << obj->name() << endl;
-            QString objName = obj->name();
+            TQString objName = obj->name();
 
             if (objName.endsWith("rewind") || objName.endsWith("fast_forward")) {
-                QButton* btn = dynamic_cast<QButton*>(obj);
+                TQButton* btn = dynamic_cast<TQButton*>(obj);
                 if (!btn) {
                     RG_DEBUG << "Very strange - found widgets in transport_toolbar which aren't buttons\n";
 
@@ -1280,7 +1280,7 @@ void RosegardenGUIApp::initZoomToolbar()
         return ;
     }
 
-    new QLabel(i18n("  Zoom:  "), zoomToolbar, "kde toolbar widget");
+    new TQLabel(i18n("  Zoom:  "), zoomToolbar, "kde toolbar widget");
 
     std::vector<double> zoomSizes; // in units-per-pixel
     double defaultBarWidth44 = 100.0;
@@ -1293,18 +1293,18 @@ void RosegardenGUIApp::initZoomToolbar()
     }
 
     // zoom labels
-    QString minZoom = QString("%1%").arg(factors[0] * 100.0);
-    QString maxZoom = QString("%1%").arg(factors[(sizeof(factors) / sizeof(factors[0])) - 1] * 100.0);
+    TQString minZoom = TQString("%1%").arg(factors[0] * 100.0);
+    TQString maxZoom = TQString("%1%").arg(factors[(sizeof(factors) / sizeof(factors[0])) - 1] * 100.0);
 
     m_zoomSlider = new ZoomSlider<double>
-                   (zoomSizes, -1, QSlider::Horizontal, zoomToolbar, "kde toolbar widget");
+                   (zoomSizes, -1, TQSlider::Horizontal, zoomToolbar, "kde toolbar widget");
     m_zoomSlider->setTracking(true);
-    m_zoomSlider->setFocusPolicy(QWidget::NoFocus);
-    m_zoomLabel = new QLabel(minZoom, zoomToolbar, "kde toolbar widget");
+    m_zoomSlider->setFocusPolicy(TQWidget::NoFocus);
+    m_zoomLabel = new TQLabel(minZoom, zoomToolbar, "kde toolbar widget");
     m_zoomLabel->setIndent(10);
 
-    connect(m_zoomSlider, SIGNAL(valueChanged(int)),
-            this, SLOT(slotChangeZoom(int)));
+    connect(m_zoomSlider, TQT_SIGNAL(valueChanged(int)),
+            this, TQT_SLOT(slotChangeZoom(int)));
 
     // set initial zoom - we might want to make this a config option
     //    m_zoomSlider->setToDefault();
@@ -1353,18 +1353,18 @@ void RosegardenGUIApp::initView()
 
     // Connect up this signal so that we can force tool mode
     // changes from the view
-    connect(m_swapView, SIGNAL(activateTool(QString)),
-            this, SLOT(slotActivateTool(QString)));
+    connect(m_swapView, TQT_SIGNAL(activateTool(TQString)),
+            this, TQT_SLOT(slotActivateTool(TQString)));
 
     connect(m_swapView,
-            SIGNAL(segmentsSelected(const SegmentSelection &)),
-            SIGNAL(segmentsSelected(const SegmentSelection &)));
+            TQT_SIGNAL(segmentsSelected(const SegmentSelection &)),
+            TQT_SIGNAL(segmentsSelected(const SegmentSelection &)));
 
     connect(m_swapView,
-            SIGNAL(addAudioFile(AudioFileId)),
-            SLOT(slotAddAudioFile(AudioFileId)));
+            TQT_SIGNAL(addAudioFile(AudioFileId)),
+            TQT_SLOT(slotAddAudioFile(AudioFileId)));
 
-    connect(m_swapView, SIGNAL(toggleSolo(bool)), SLOT(slotToggleSolo(bool)));
+    connect(m_swapView, TQT_SIGNAL(toggleSolo(bool)), TQT_SLOT(slotToggleSolo(bool)));
 
     m_doc->attachView(m_swapView);
 
@@ -1414,11 +1414,11 @@ void RosegardenGUIApp::initView()
     RosegardenGUIView *oldView = m_view;
     m_view = m_swapView;
 
-    connect(m_view, SIGNAL(stateChange(QString, bool)),
-            this, SLOT (slotStateChanged(QString, bool)));
+    connect(m_view, TQT_SIGNAL(stateChange(TQString, bool)),
+            this, TQT_SLOT (slotStateChanged(TQString, bool)));
 
-    connect(m_view, SIGNAL(instrumentParametersChanged(InstrumentId)),
-            this, SIGNAL(instrumentParametersChanged(InstrumentId)));
+    connect(m_view, TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
+            this, TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     // We only check for the SequenceManager to make sure
     // we're not on the first pass though - we don't want
@@ -1440,15 +1440,15 @@ void RosegardenGUIApp::initView()
             if (isUsingSequencer())
                 m_seqManager->setLoop(0, 0);
             stateChanged("have_range", KXMLGUIClient::StateReverse);
-        } catch (QString s) {
+        } catch (TQString s) {
             KStartupLogo::hideIfStillThere();
             CurrentProgressDialog::freeze();
             KMessageBox::error(this, s);
             CurrentProgressDialog::thaw();
         }
 
-        connect(m_seqManager, SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
-                m_view, SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
+        connect(m_seqManager, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *)),
+                m_view, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *)));
     }
 
     //    delete m_playList;
@@ -1490,9 +1490,9 @@ void RosegardenGUIApp::initView()
     m_view->show();
 
     connect(m_view->getTrackEditor()->getSegmentCanvas(),
-            SIGNAL(showContextHelp(const QString &)),
+            TQT_SIGNAL(showContextHelp(const TQString &)),
             this,
-            SLOT(slotShowToolHelp(const QString &)));
+            TQT_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
@@ -1542,7 +1542,7 @@ void RosegardenGUIApp::setDocument(RosegardenGUIDoc* newDocument)
 
     // Caption
     //
-    QString caption = kapp->caption();
+    TQString caption = kapp->caption();
     setCaption(caption + ": " + newDocument->getTitle());
 
     //     // reset AudioManagerDialog
@@ -1590,45 +1590,45 @@ void RosegardenGUIApp::setDocument(RosegardenGUIDoc* newDocument)
 
     // connect needed signals
     //
-    connect(m_segmentParameterBox, SIGNAL(documentModified()),
-            m_doc, SLOT(slotDocumentModified()));
+    connect(m_segmentParameterBox, TQT_SIGNAL(documentModified()),
+            m_doc, TQT_SLOT(slotDocumentModified()));
 
-    connect(m_doc, SIGNAL(pointerPositionChanged(timeT)),
-            this, SLOT(slotSetPointerPosition(timeT)));
+    connect(m_doc, TQT_SIGNAL(pointerPositionChanged(timeT)),
+            this, TQT_SLOT(slotSetPointerPosition(timeT)));
 
-    connect(m_doc, SIGNAL(documentModified(bool)),
-            this, SLOT(slotDocumentModified(bool)));
+    connect(m_doc, TQT_SIGNAL(documentModified(bool)),
+            this, TQT_SLOT(slotDocumentModified(bool)));
 
-    connect(m_doc, SIGNAL(loopChanged(timeT, timeT)),
-            this, SLOT(slotSetLoop(timeT, timeT)));
+    connect(m_doc, TQT_SIGNAL(loopChanged(timeT, timeT)),
+            this, TQT_SLOT(slotSetLoop(timeT, timeT)));
 
     m_doc->getCommandHistory()->attachView(actionCollection());
 
-    connect(m_doc->getCommandHistory(), SIGNAL(commandExecuted()),
-            SLOT(update()));
-    connect(m_doc->getCommandHistory(), SIGNAL(commandExecuted()),
-            SLOT(slotTestClipboard()));
+    connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
+            TQT_SLOT(update()));
+    connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
+            TQT_SLOT(slotTestClipboard()));
 
     // connect and start the autosave timer
-    connect(m_autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
+    connect(m_autoSaveTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotAutoSave()));
     m_autoSaveTimer->start(m_doc->getAutoSavePeriod() * 1000);
 
     // Connect the playback timer
     //
-    connect(m_playTimer, SIGNAL(timeout()), this, SLOT(slotUpdatePlaybackPosition()));
-    connect(m_stopTimer, SIGNAL(timeout()), this, SLOT(slotUpdateMonitoring()));
+    connect(m_playTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotUpdatePlaybackPosition()));
+    connect(m_stopTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotUpdateMonitoring()));
 
     // finally recreate the main view
     //
     initView();
 
     if (getView() && getView()->getTrackEditor()) {
-        connect(m_doc, SIGNAL(makeTrackVisible(int)),
-                getView()->getTrackEditor(), SLOT(slotScrollToTrack(int)));
+        connect(m_doc, TQT_SIGNAL(makeTrackVisible(int)),
+                getView()->getTrackEditor(), TQT_SLOT(slotScrollToTrack(int)));
     }
 
-    connect(m_doc, SIGNAL(devicesResyncd()),
-            this, SLOT(slotDocumentDevicesResyncd()));
+    connect(m_doc, TQT_SIGNAL(devicesResyncd()),
+            this, TQT_SLOT(slotDocumentDevicesResyncd()));
 
     m_doc->syncDevices();
     m_doc->clearModifiedStatus();
@@ -1670,7 +1670,7 @@ void RosegardenGUIApp::setDocument(RosegardenGUIDoc* newDocument)
 }
 
 void
-RosegardenGUIApp::openFile(QString filePath, ImportType type)
+RosegardenGUIApp::openFile(TQString filePath, ImportType type)
 {
     RG_DEBUG << "RosegardenGUIApp::openFile " << filePath << endl;
 
@@ -1690,10 +1690,10 @@ RosegardenGUIApp::openFile(QString filePath, ImportType type)
         kapp->config()->setGroup(GeneralOptionsConfigGroup);
         if (kapp->config()->readBoolEntry("alwaysusedefaultstudio", false)) {
 
-            QString autoloadFile =
+            TQString autoloadFile =
                 KGlobal::dirs()->findResource("appdata", "autoload.rg");
 
-            QFileInfo autoloadFileInfo(autoloadFile);
+            TQFileInfo autoloadFileInfo(autoloadFile);
             if (autoloadFileInfo.isReadable()) {
 
                 RG_DEBUG << "Importing default studio from " << autoloadFile << endl;
@@ -1702,15 +1702,15 @@ RosegardenGUIApp::openFile(QString filePath, ImportType type)
             }
         }
 
-        QFileInfo fInfo(filePath);
+        TQFileInfo fInfo(filePath);
         m_fileRecent->addURL(fInfo.absFilePath());
     }
 }
 
 RosegardenGUIDoc*
-RosegardenGUIApp::createDocument(QString filePath, ImportType importType)
+RosegardenGUIApp::createDocument(TQString filePath, ImportType importType)
 {
-    QFileInfo info(filePath);
+    TQFileInfo info(filePath);
     RosegardenGUIDoc *doc = 0;
 
     if (!info.exists()) {
@@ -1726,11 +1726,11 @@ RosegardenGUIApp::createDocument(QString filePath, ImportType importType)
         return 0;
     }
 
-    QFile file(filePath);
+    TQFile file(filePath);
 
     if (!file.open(IO_ReadOnly)) {
         KStartupLogo::hideIfStillThere();
-        QString errStr =
+        TQString errStr =
             i18n("You do not have read permission for \"%1\"").arg(filePath);
 
         KMessageBox::sorry(this, errStr);
@@ -1777,16 +1777,16 @@ RosegardenGUIApp::createDocument(QString filePath, ImportType importType)
 }
 
 RosegardenGUIDoc*
-RosegardenGUIApp::createDocumentFromRGFile(QString filePath)
+RosegardenGUIApp::createDocumentFromRGFile(TQString filePath)
 {
     // Check for an autosaved file to recover
-    QString effectiveFilePath = filePath;
+    TQString effectiveFilePath = filePath;
     bool canRecover = false;
-    QString autoSaveFileName = kapp->checkRecoverFile(filePath, canRecover);
+    TQString autoSaveFileName = kapp->checkRecoverFile(filePath, canRecover);
 
     if (canRecover) {
         // First check if the auto-save file is more recent than the doc
-        QFileInfo docFileInfo(filePath), autoSaveFileInfo(autoSaveFileName);
+        TQFileInfo docFileInfo(filePath), autoSaveFileInfo(autoSaveFileName);
 
         if (docFileInfo.lastModified() < autoSaveFileInfo.lastModified()) {
 
@@ -1808,7 +1808,7 @@ RosegardenGUIApp::createDocumentFromRGFile(QString filePath)
                 // user doesn't want the autosave, so delete it
                 // so it won't bother us again if we reload
                 canRecover = false;
-                QFile::remove
+                TQFile::remove
                     (autoSaveFileName);
             }
 
@@ -1830,7 +1830,7 @@ RosegardenGUIApp::createDocumentFromRGFile(QString filePath)
             // the autosaved doc)
             //
             newDoc->slotDocumentModified();
-            QFileInfo info(filePath);
+            TQFileInfo info(filePath);
             newDoc->setAbsFilePath(info.absFilePath());
             newDoc->setTitle(info.fileName());
         } else {
@@ -1850,8 +1850,8 @@ void RosegardenGUIApp::slotSaveOptions()
 
 #ifdef SETTING_LOG_DEBUG
 
-    _settingLog(QString("SETTING 2 : transport flap extended = %1").arg(getTransport()->isExpanded()));
-    _settingLog(QString("SETTING 2 : show track labels = %1").arg(m_viewTrackLabels->isChecked()));
+    _settingLog(TQString("SETTING 2 : transport flap extended = %1").arg(getTransport()->isExpanded()));
+    _settingLog(TQString("SETTING 2 : show track labels = %1").arg(m_viewTrackLabels->isChecked()));
 #endif
 
     kapp->config()->setGroup(GeneralOptionsConfigGroup);
@@ -1893,13 +1893,13 @@ void RosegardenGUIApp::setupFileDialogSpeedbar()
 
         unsigned int n = config->readUnsignedNumEntry("Number of Entries", 0);
 
-        config->writeEntry(QString("Description_%1").arg(n), i18n("Example Files"));
-        config->writeEntry(QString("IconGroup_%1").arg(n), 4);
-        config->writeEntry(QString("Icon_%1").arg(n), "folder");
-        config->writeEntry(QString("URL_%1").arg(n),
+        config->writeEntry(TQString("Description_%1").arg(n), i18n("Example Files"));
+        config->writeEntry(TQString("IconGroup_%1").arg(n), 4);
+        config->writeEntry(TQString("Icon_%1").arg(n), "folder");
+        config->writeEntry(TQString("URL_%1").arg(n),
                            KGlobal::dirs()->findResource("appdata", "examples/"));
 
-        RG_DEBUG << "wrote url " << config->readEntry(QString("URL_%1").arg(n)) << endl;
+        RG_DEBUG << "wrote url " << config->readEntry(TQString("URL_%1").arg(n)) << endl;
 
         config->writeEntry("Examples Set", true);
         config->writeEntry("Number of Entries", n + 1);
@@ -1936,7 +1936,7 @@ void RosegardenGUIApp::readOptions()
 
 #ifdef SETTING_LOG_DEBUG
 
-    _settingLog(QString("SETTING 3 : transport flap extended = %1").arg(opt));
+    _settingLog(TQString("SETTING 3 : transport flap extended = %1").arg(opt));
 #endif
 
     if (opt)
@@ -1948,7 +1948,7 @@ void RosegardenGUIApp::readOptions()
 
 #ifdef SETTING_LOG_DEBUG
 
-    _settingLog(QString("SETTING 3 : show track labels = %1").arg(opt));
+    _settingLog(TQString("SETTING 3 : show track labels = %1").arg(opt));
 #endif
 
     m_viewTrackLabels->setChecked(opt);
@@ -2000,19 +2000,19 @@ void RosegardenGUIApp::saveGlobalProperties(KConfig *cfg)
     if (m_doc->getTitle() != i18n("Untitled") && !m_doc->isModified()) {
         // saving to tempfile not necessary
     } else {
-        QString filename = m_doc->getAbsFilePath();
+        TQString filename = m_doc->getAbsFilePath();
         cfg->writeEntry("filename", filename);
         cfg->writeEntry("modified", m_doc->isModified());
 
-        QString tempname = kapp->tempSaveName(filename);
-        QString errMsg;
+        TQString tempname = kapp->tempSaveName(filename);
+        TQString errMsg;
         bool res = m_doc->saveDocument(tempname, errMsg);
         if (!res) {
             if (errMsg)
-                KMessageBox::error(this, i18n(QString("Could not save document at %1\nError was : %2")
+                KMessageBox::error(this, i18n(TQString("Could not save document at %1\nError was : %2")
                                               .arg(tempname).arg(errMsg)));
             else
-                KMessageBox::error(this, i18n(QString("Could not save document at %1")
+                KMessageBox::error(this, i18n(TQString("Could not save document at %1")
                                               .arg(tempname)));
         }
     }
@@ -2020,19 +2020,19 @@ void RosegardenGUIApp::saveGlobalProperties(KConfig *cfg)
 
 void RosegardenGUIApp::readGlobalProperties(KConfig* _cfg)
 {
-    QString filename = _cfg->readEntry("filename", "");
+    TQString filename = _cfg->readEntry("filename", "");
     bool modified = _cfg->readBoolEntry("modified", false);
 
     if (modified) {
         bool canRecover;
-        QString tempname = kapp->checkRecoverFile(filename, canRecover);
+        TQString tempname = kapp->checkRecoverFile(filename, canRecover);
 
         if (canRecover) {
             slotEnableTransport(false);
             m_doc->openDocument(tempname);
             slotEnableTransport(true);
             m_doc->slotDocumentModified();
-            QFileInfo info(filename);
+            TQFileInfo info(filename);
             m_doc->setAbsFilePath(info.absFilePath());
             m_doc->setTitle(info.fileName());
         }
@@ -2044,11 +2044,11 @@ void RosegardenGUIApp::readGlobalProperties(KConfig* _cfg)
         }
     }
 
-    QString caption = kapp->caption();
+    TQString caption = kapp->caption();
     setCaption(caption + ": " + m_doc->getTitle());
 }
 
-void RosegardenGUIApp::showEvent(QShowEvent* e)
+void RosegardenGUIApp::showEvent(TQShowEvent* e)
 {
     RG_DEBUG << "RosegardenGUIApp::showEvent()\n";
 
@@ -2061,11 +2061,11 @@ bool RosegardenGUIApp::queryClose()
     RG_DEBUG << "RosegardenGUIApp::queryClose" << endl;
 #ifdef SETTING_LOG_DEBUG
 
-    _settingLog(QString("SETTING 1 : transport flap extended = %1").arg(getTransport()->isExpanded()));
-    _settingLog(QString("SETTING 1 : show track labels = %1").arg(m_viewTrackLabels->isChecked()));
+    _settingLog(TQString("SETTING 1 : transport flap extended = %1").arg(getTransport()->isExpanded()));
+    _settingLog(TQString("SETTING 1 : show track labels = %1").arg(m_viewTrackLabels->isChecked()));
 #endif
 
-    QString errMsg;
+    TQString errMsg;
 
     bool canClose = m_doc->saveIfModified();
 
@@ -2077,8 +2077,8 @@ bool RosegardenGUIApp::queryClose()
         // 'off'
         //
 
-        disconnect(m_transport, SIGNAL(closed()),
-                   this, SLOT(slotCloseTransport()));
+        disconnect(m_transport, TQT_SIGNAL(closed()),
+                   this, TQT_SLOT(slotCloseTransport()));
     }
     */
 
@@ -2124,7 +2124,7 @@ void RosegardenGUIApp::slotFileNew()
     }
 }
 
-void RosegardenGUIApp::slotOpenDroppedURL(QString url)
+void RosegardenGUIApp::slotOpenDroppedURL(TQString url)
 {
     ProgressDialog::processEvents(); // or else we get a crash because the
     // track editor is erased too soon - it is the originator of the signal
@@ -2136,9 +2136,9 @@ void RosegardenGUIApp::slotOpenDroppedURL(QString url)
     openURL(KURL(url));
 }
 
-void RosegardenGUIApp::openURL(QString url)
+void RosegardenGUIApp::openURL(TQString url)
 {
-    RG_DEBUG << "RosegardenGUIApp::openURL: QString " << url << endl;
+    RG_DEBUG << "RosegardenGUIApp::openURL: TQString " << url << endl;
     openURL(KURL(url));
 }
 
@@ -2146,18 +2146,18 @@ void RosegardenGUIApp::openURL(const KURL& url)
 {
     SetWaitCursor waitCursor;
 
-    QString netFile = url.prettyURL();
+    TQString netFile = url.prettyURL();
     RG_DEBUG << "RosegardenGUIApp::openURL: KURL " << netFile << endl;
 
     if (!url.isValid()) {
-        QString string;
+        TQString string;
         string = i18n( "Malformed URL\n%1").arg(netFile);
 
         KMessageBox::sorry(this, string);
         return ;
     }
 
-    QString target, caption(url.path());
+    TQString target, caption(url.path());
 
     if (KIO::NetAccess::download(url, target, this) == false) {
         KMessageBox::error(this, i18n("Cannot download file %1").arg(url.prettyURL()));
@@ -2180,7 +2180,7 @@ void RosegardenGUIApp::slotFileOpen()
 
     kapp->config()->setGroup(GeneralOptionsConfigGroup);
 
-    QString lastOpenedVersion =
+    TQString lastOpenedVersion =
         kapp->config()->readEntry("Last File Opened Version", "none");
 
     if (lastOpenedVersion != VERSION) {
@@ -2188,11 +2188,11 @@ void RosegardenGUIApp::slotFileOpen()
         // We haven't opened any files with this version of the
         // program before.  Default to the examples directory.
 
-        QString examplesDir = KGlobal::dirs()->findResource("appdata", "examples/");
+        TQString examplesDir = KGlobal::dirs()->findResource("appdata", "examples/");
         kapp->config()->setGroup("Recent Dirs");
-        QString recentString = kapp->config()->readEntry("ROSEGARDEN", "");
+        TQString recentString = kapp->config()->readEntry("ROSEGARDEN", "");
         kapp->config()->writeEntry
-        ("ROSEGARDEN", QString("file:%1,%2").arg(examplesDir).arg(recentString));
+        ("ROSEGARDEN", TQString("file:%1,%2").arg(examplesDir).arg(recentString));
     }
 
     KURL url = KFileDialog::getOpenURL
@@ -2223,7 +2223,7 @@ void RosegardenGUIApp::slotMerge()
     }
 
 
-    QString target;
+    TQString target;
 
     if (KIO::NetAccess::download(url, target, this) == false) {
         KMessageBox::error(this, i18n("Cannot download file %1").arg(url.prettyURL()));
@@ -2267,28 +2267,28 @@ void RosegardenGUIApp::slotFileSave()
     } else {
 
         SetWaitCursor waitCursor;
-        QString errMsg, docFilePath = m_doc->getAbsFilePath();
+        TQString errMsg, docFilePath = m_doc->getAbsFilePath();
 
         bool res = m_doc->saveDocument(docFilePath, errMsg);
         if (!res) {
             if (errMsg)
-                KMessageBox::error(this, i18n(QString("Could not save document at %1\nError was : %2")
+                KMessageBox::error(this, i18n(TQString("Could not save document at %1\nError was : %2")
                                               .arg(docFilePath).arg(errMsg)));
             else
-                KMessageBox::error(this, i18n(QString("Could not save document at %1")
+                KMessageBox::error(this, i18n(TQString("Could not save document at %1")
                                               .arg(docFilePath)));
         }
     }
 }
 
 QString
-RosegardenGUIApp::getValidWriteFile(QString descriptiveExtension,
-                                    QString label)
+RosegardenGUIApp::getValidWriteFile(TQString descriptiveExtension,
+                                    TQString label)
 {
     // extract first extension listed in descriptiveExtension, for instance,
     // ".rg" from "*.rg|Rosegarden files", or ".mid" from "*.mid *.midi|MIDI Files"
     //
-    QString extension = descriptiveExtension.left(descriptiveExtension.find('|')).mid(1).section(' ', 0, 0);
+    TQString extension = descriptiveExtension.left(descriptiveExtension.find('|')).mid(1).section(' ', 0, 0);
 
     RG_DEBUG << "RosegardenGUIApp::getValidWriteFile() : extension = " << extension << endl;
 
@@ -2297,7 +2297,7 @@ RosegardenGUIApp::getValidWriteFile(QString descriptiveExtension,
     KFileDialog saveFileDialog(":ROSEGARDEN", descriptiveExtension, this, label, true);
     saveFileDialog.setOperationMode(KFileDialog::Saving);
     if (m_doc) {
-        QString saveFileName = m_doc->getAbsFilePath();
+        TQString saveFileName = m_doc->getAbsFilePath();
         // Show filename without the old extension
         int dotLoc = saveFileName.findRev('.');
         if (dotLoc >= int(saveFileName.length() - 4)) {
@@ -2306,7 +2306,7 @@ RosegardenGUIApp::getValidWriteFile(QString descriptiveExtension,
         saveFileDialog.setSelection(saveFileName);
     }
     saveFileDialog.exec();
-    QString name = saveFileDialog.selectedFile();
+    TQString name = saveFileDialog.selectedFile();
 
     //     RG_DEBUG << "RosegardenGUIApp::getValidWriteFile() : KFileDialog::getSaveFileName returned "
     //              << name << endl;
@@ -2318,7 +2318,7 @@ RosegardenGUIApp::getValidWriteFile(QString descriptiveExtension,
     // Append extension if we don't have one
     //
     if (!extension.isEmpty()) {
-        static QRegExp rgFile("\\..{1,4}$");
+        static TQRegExp rgFile("\\..{1,4}$");
         if (rgFile.match(name) == -1) {
             name += extension;
         }
@@ -2336,7 +2336,7 @@ RosegardenGUIApp::getValidWriteFile(QString descriptiveExtension,
         return "";
     }
 
-    QFileInfo info(name);
+    TQFileInfo info(name);
 
     if (info.isDir()) {
         KMessageBox::sorry(this, i18n("You have specified a directory"));
@@ -2361,31 +2361,31 @@ bool RosegardenGUIApp::slotFileSaveAs()
 
     KTmpStatusMsg msg(i18n("Saving file with a new filename..."), this);
 
-    QString newName = getValidWriteFile("*.rg|" + i18n("Rosegarden files") +
+    TQString newName = getValidWriteFile("*.rg|" + i18n("Rosegarden files") +
                                         "\n*|" + i18n("All files"),
                                         i18n("Save as..."));
     if (newName.isEmpty())
         return false;
 
     SetWaitCursor waitCursor;
-    QFileInfo saveAsInfo(newName);
+    TQFileInfo saveAsInfo(newName);
     m_doc->setTitle(saveAsInfo.fileName());
     m_doc->setAbsFilePath(saveAsInfo.absFilePath());
-    QString errMsg;
+    TQString errMsg;
     bool res = m_doc->saveDocument(newName, errMsg);
     if (!res) {
         if (errMsg)
-            KMessageBox::error(this, i18n(QString("Could not save document at %1\nError was : %2")
+            KMessageBox::error(this, i18n(TQString("Could not save document at %1\nError was : %2")
                                           .arg(newName).arg(errMsg)));
         else
-            KMessageBox::error(this, i18n(QString("Could not save document at %1")
+            KMessageBox::error(this, i18n(TQString("Could not save document at %1")
                                           .arg(newName)));
 
     } else {
 
         m_fileRecent->addURL(newName);
 
-        QString caption = kapp->caption();
+        TQString caption = kapp->caption();
         setCaption(caption + ": " + m_doc->getTitle());
         // update the edit view's captions too
         emit compositionStateUpdate();
@@ -2555,7 +2555,7 @@ void RosegardenGUIApp::slotInsertRange()
     std::pair<timeT, timeT> r = m_doc->getComposition().getBarRangeForTime(t0);
     TimeDialog dialog(m_view, i18n("Duration of empty range to insert"),
                       &m_doc->getComposition(), t0, r.second - r.first, false);
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         m_doc->getCommandHistory()->addCommand
             (new InsertRangeCommand(&m_doc->getComposition(), t0, dialog.getTime()));
         m_doc->setLoop(0, 0);
@@ -2580,7 +2580,7 @@ void RosegardenGUIApp::slotQuantizeSelection()
     //!!! this should all be in rosegardenguiview
 
     QuantizeDialog dialog(m_view);
-    if (dialog.exec() != QDialog::Accepted)
+    if (dialog.exec() != TQDialog::Accepted)
         return ;
 
     SegmentSelection selection = m_view->getSelection();
@@ -2684,7 +2684,7 @@ void RosegardenGUIApp::slotRescaleSelection()
     RescaleDialog dialog(m_view, &m_doc->getComposition(),
                          startTime, endTime - startTime,
                          false, false);
-    if (dialog.exec() != QDialog::Accepted)
+    if (dialog.exec() != TQDialog::Accepted)
         return ;
 
     std::vector<AudioSegmentRescaleCommand *> asrcs;
@@ -2739,10 +2739,10 @@ void RosegardenGUIApp::slotRescaleSelection()
             asrcs[i]->disconnectProgressDialog(progressDlg);
         }
 
-        connect(&m_doc->getAudioFileManager(), SIGNAL(setProgress(int)),
-                progressDlg->progressBar(), SLOT(setValue(int)));
-        connect(progressDlg, SIGNAL(cancelClicked()),
-                &m_doc->getAudioFileManager(), SLOT(slotStopPreview()));
+        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()));
 
         for (size_t i = 0; i < asrcs.size(); ++i) {
             int fid = asrcs[i]->getNewAudioFileId();
@@ -2757,7 +2757,7 @@ void RosegardenGUIApp::slotRescaleSelection()
 }
 
 bool
-RosegardenGUIApp::testAudioPath(QString op)
+RosegardenGUIApp::testAudioPath(TQString op)
 {
     try {
         m_doc->getAudioFileManager().testAudioPath();
@@ -2793,7 +2793,7 @@ void RosegardenGUIApp::slotAutoSplitSelection()
         if ((*i)->getType() == Segment::Audio) {
             AudioSplitDialog aSD(this, (*i), m_doc);
 
-            if (aSD.exec() == QDialog::Accepted) {
+            if (aSD.exec() == TQDialog::Accepted) {
                 // split to threshold
                 //
                 command->addCommand(
@@ -2856,33 +2856,33 @@ void RosegardenGUIApp::createAndSetupTransport()
     m_transport->getAccelerators()->connectItem
         (m_transport->getAccelerators()->insertItem(Key_T),
          this,
-         SLOT(slotHideTransport()));
+         TQT_SLOT(slotHideTransport()));
 
     // Ensure that the checkbox is unchecked if the dialog
     // is closed
-    connect(m_transport, SIGNAL(closed()),
-            SLOT(slotCloseTransport()));
+    connect(m_transport, TQT_SIGNAL(closed()),
+            TQT_SLOT(slotCloseTransport()));
 
     // Handle loop setting and unsetting from the transport loop button
     //
 
-    connect(m_transport, SIGNAL(setLoop()), SLOT(slotSetLoop()));
-    connect(m_transport, SIGNAL(unsetLoop()), SLOT(slotUnsetLoop()));
-    connect(m_transport, SIGNAL(panic()), SLOT(slotPanic()));
+    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, SIGNAL(editTempo(QWidget*)),
-            SLOT(slotEditTempo(QWidget*)));
+    connect(m_transport, TQT_SIGNAL(editTempo(TQWidget*)),
+            TQT_SLOT(slotEditTempo(TQWidget*)));
 
-    connect(m_transport, SIGNAL(editTimeSignature(QWidget*)),
-            SLOT(slotEditTimeSignature(QWidget*)));
+    connect(m_transport, TQT_SIGNAL(editTimeSignature(TQWidget*)),
+            TQT_SLOT(slotEditTimeSignature(TQWidget*)));
 
-    connect(m_transport, SIGNAL(editTransportTime(QWidget*)),
-            SLOT(slotEditTransportTime(QWidget*)));
+    connect(m_transport, TQT_SIGNAL(editTransportTime(TQWidget*)),
+            TQT_SLOT(slotEditTransportTime(TQWidget*)));
 
     // Handle set loop start/stop time buttons.
     //
-    connect(m_transport, SIGNAL(setLoopStartTime()), SLOT(slotSetLoopStart()));
-    connect(m_transport, SIGNAL(setLoopStopTime()), SLOT(slotSetLoopStop()));
+    connect(m_transport, TQT_SIGNAL(setLoopStartTime()), TQT_SLOT(slotSetLoopStart()));
+    connect(m_transport, TQT_SIGNAL(setLoopStopTime()), TQT_SLOT(slotSetLoopStop()));
 
     if (m_seqManager != 0)
         m_seqManager->setTransport(m_transport);
@@ -2895,7 +2895,7 @@ void RosegardenGUIApp::slotSplitSelectionByPitch()
         return ;
 
     SplitByPitchDialog dialog(m_view);
-    if (dialog.exec() != QDialog::Accepted)
+    if (dialog.exec() != TQDialog::Accepted)
         return ;
 
     SegmentSelection selection = m_view->getSelection();
@@ -2935,7 +2935,7 @@ RosegardenGUIApp::slotSplitSelectionByRecordedSrc()
         return ;
 
     SplitByRecordingSrcDialog dialog(m_view, m_doc);
-    if (dialog.exec() != QDialog::Accepted)
+    if (dialog.exec() != TQDialog::Accepted)
         return ;
 
     SegmentSelection selection = m_view->getSelection();
@@ -2974,7 +2974,7 @@ RosegardenGUIApp::slotSplitSelectionAtTime()
 
     timeT now = m_doc->getComposition().getPosition();
 
-    QString title = i18n("Split Segment at Time",
+    TQString title = i18n("Split Segment at Time",
                          "Split %n Segments at Time",
                          selection.size());
 
@@ -2984,7 +2984,7 @@ RosegardenGUIApp::slotSplitSelectionAtTime()
 
     KMacroCommand *command = new KMacroCommand( title );
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         for (SegmentSelection::iterator i = selection.begin();
                 i != selection.end(); ++i) {
 
@@ -3014,7 +3014,7 @@ RosegardenGUIApp::slotSetSegmentStartTimes()
                       &m_doc->getComposition(),
                       someTime, false);
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
 
         bool plural = (selection.size() > 1);
 
@@ -3059,7 +3059,7 @@ RosegardenGUIApp::slotSetSegmentDurations()
                       someDuration,
                       false);
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
 
         bool plural = (selection.size() > 1);
 
@@ -3105,7 +3105,7 @@ void RosegardenGUIApp::slotTempoToSegmentLength()
     slotTempoToSegmentLength(this);
 }
 
-void RosegardenGUIApp::slotTempoToSegmentLength(QWidget* parent)
+void RosegardenGUIApp::slotTempoToSegmentLength(TQWidget* parent)
 {
     RG_DEBUG << "RosegardenGUIApp::slotTempoToSegmentLength" << endl;
 
@@ -3136,7 +3136,7 @@ void RosegardenGUIApp::slotTempoToSegmentLength(QWidget* parent)
 
         // Get user to tell us how many beats or bars the segment contains
         BeatsBarsDialog dialog(parent);
-        if (dialog.exec() == QDialog::Accepted) {
+        if (dialog.exec() == TQDialog::Accepted) {
             beats = dialog.getQuantity(); // beats (or bars)
             if (dialog.getMode() == 1)    // bars  (multiply by time sig)
                 beats *= timeSig.getBeatsPerBar();
@@ -3382,7 +3382,7 @@ void RosegardenGUIApp::slotToggleStatusBar()
         statusBar()->show();
 }
 
-void RosegardenGUIApp::slotStatusMsg(QString text)
+void RosegardenGUIApp::slotStatusMsg(TQString text)
 {
     ///////////////////////////////////////////////////////////////////
     // change status message permanently
@@ -3390,7 +3390,7 @@ void RosegardenGUIApp::slotStatusMsg(QString text)
     statusBar()->changeItem(text, EditViewBase::ID_STATUS_MSG);
 }
 
-void RosegardenGUIApp::slotStatusHelpMsg(QString text)
+void RosegardenGUIApp::slotStatusHelpMsg(TQString text)
 {
     ///////////////////////////////////////////////////////////////////
     // change status message of whole statusbar temporary (text, msec)
@@ -3529,7 +3529,7 @@ void RosegardenGUIApp::slotAddTracks()
 
     AddTracksDialog dialog(this, pos);
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         m_view->slotAddTracks(dialog.getTracks(), id, 
                               dialog.getInsertPosition());
     }
@@ -3694,7 +3694,7 @@ void RosegardenGUIApp::slotImportProject()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
 
     importProject(tmpfile);
@@ -3702,7 +3702,7 @@ void RosegardenGUIApp::slotImportProject()
     KIO::NetAccess::removeTempFile(tmpfile);
 }
 
-void RosegardenGUIApp::importProject(QString filePath)
+void RosegardenGUIApp::importProject(TQString filePath)
 {
     KProcess *proc = new KProcess;
     *proc << "rosegarden-project-package";
@@ -3722,9 +3722,9 @@ void RosegardenGUIApp::importProject(QString filePath)
 
     delete proc;
 
-    QString rgFile = filePath;
-    rgFile.replace(QRegExp(".rg.rgp$"), ".rg");
-    rgFile.replace(QRegExp(".rgp$"), ".rg");
+    TQString rgFile = filePath;
+    rgFile.replace(TQRegExp(".rg.rgp$"), ".rg");
+    rgFile.replace(TQRegExp(".rgp$"), ".rg");
     openURL(rgFile);
 }
 
@@ -3741,7 +3741,7 @@ void RosegardenGUIApp::slotImportMIDI()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
     openFile(tmpfile, ImportMIDI); // does everything including setting the document
 
@@ -3758,17 +3758,17 @@ void RosegardenGUIApp::slotMergeMIDI()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
     mergeFile(tmpfile, ImportMIDI);
 
     KIO::NetAccess::removeTempFile( tmpfile );
 }
 
-QTextCodec *
+TQTextCodec *
 RosegardenGUIApp::guessTextCodec(std::string text)
 {
-    QTextCodec *codec = 0;
+    TQTextCodec *codec = 0;
 
     for (int c = 0; c < text.length(); ++c) {
         if (text[c] & 0x80) {
@@ -3784,7 +3784,7 @@ RosegardenGUIApp::guessTextCodec(std::string text)
             CurrentProgressDialog::thaw();
 
             if (codecName != "") {
-                codec = QTextCodec::codecForName(codecName.c_str());
+                codec = TQTextCodec::codecForName(codecName.c_str());
             }
             break;
         }
@@ -3797,7 +3797,7 @@ void
 RosegardenGUIApp::fixTextEncodings(Composition *c)
 
 {
-    QTextCodec *codec = 0;
+    TQTextCodec *codec = 0;
 
     for (Composition::iterator i = c->begin();
             i != c->end(); ++i) {
@@ -3849,7 +3849,7 @@ RosegardenGUIApp::fixTextEncodings(Composition *c)
 }
 
 RosegardenGUIDoc*
-RosegardenGUIApp::createDocumentFromMIDIFile(QString file)
+RosegardenGUIApp::createDocumentFromMIDIFile(TQString file)
 {
     //if (!merge && !m_doc->saveIfModified()) return;
 
@@ -3857,7 +3857,7 @@ RosegardenGUIApp::createDocumentFromMIDIFile(QString file)
     //
     RosegardenGUIDoc *newDoc = new RosegardenGUIDoc(this, m_pluginManager);
 
-    std::string fname(QFile::encodeName(file));
+    std::string fname(TQFile::encodeName(file));
 
     MidiFile midiFile(fname,
                       &newDoc->getStudio());
@@ -3870,11 +3870,11 @@ RosegardenGUIApp::createDocumentFromMIDIFile(QString file)
     CurrentProgressDialog::set
         (&progressDlg);
 
-    connect(&midiFile, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&midiFile, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&midiFile, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&midiFile, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     if (!midiFile.open()) {
         CurrentProgressDialog::freeze();
@@ -3894,8 +3894,8 @@ RosegardenGUIApp::createDocumentFromMIDIFile(QString file)
 
     // Set the caption
     //
-    newDoc->setTitle(QFileInfo(file).fileName());
-    newDoc->setAbsFilePath(QFileInfo(file).absFilePath());
+    newDoc->setTitle(TQFileInfo(file).fileName());
+    newDoc->setAbsFilePath(TQFileInfo(file).absFilePath());
 
     // Clean up for notation purposes (after reinitialise, because that
     // sets the composition's end marker time which is needed here)
@@ -3962,8 +3962,8 @@ RosegardenGUIApp::createDocumentFromMIDIFile(QString file)
                                            (segment, startTime, endTime, "Notation Options", true);
 
         subCommand->setProgressTotal(progressPer + 1);
-        QObject::connect(subCommand, SIGNAL(incrementProgress(int)),
-                         progressDlg.progressBar(), SLOT(advance(int)));
+        TQObject::connect(subCommand, TQT_SIGNAL(incrementProgress(int)),
+                         progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
         command->addCommand(subCommand);
     }
@@ -3994,7 +3994,7 @@ void RosegardenGUIApp::slotImportRG21()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
     openFile(tmpfile, ImportRG21);
 
@@ -4011,7 +4011,7 @@ void RosegardenGUIApp::slotMergeRG21()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
     mergeFile(tmpfile, ImportRG21);
 
@@ -4019,7 +4019,7 @@ void RosegardenGUIApp::slotMergeRG21()
 }
 
 RosegardenGUIDoc*
-RosegardenGUIApp::createDocumentFromRG21File(QString file)
+RosegardenGUIApp::createDocumentFromRG21File(TQString file)
 {
     KStartupLogo::hideIfStillThere();
     ProgressDialog progressDlg(
@@ -4036,11 +4036,11 @@ RosegardenGUIApp::createDocumentFromRG21File(QString file)
 
     // TODO: make RG21Loader to actually emit these signals
     //
-    connect(&rg21Loader, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&rg21Loader, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&rg21Loader, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&rg21Loader, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     // "your starter for 40%" - helps the "freeze" work
     //
@@ -4060,8 +4060,8 @@ RosegardenGUIApp::createDocumentFromRG21File(QString file)
 
     // Set the caption and add recent
     //
-    newDoc->setTitle(QFileInfo(file).fileName());
-    newDoc->setAbsFilePath(QFileInfo(file).absFilePath());
+    newDoc->setTitle(TQFileInfo(file).fileName());
+    newDoc->setAbsFilePath(TQFileInfo(file).absFilePath());
 
     return newDoc;
 
@@ -4081,7 +4081,7 @@ RosegardenGUIApp::slotImportHydrogen()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
     openFile(tmpfile, ImportHydrogen);
 
@@ -4098,7 +4098,7 @@ void RosegardenGUIApp::slotMergeHydrogen()
         return ;
     }
 
-    QString tmpfile;
+    TQString tmpfile;
     KIO::NetAccess::download(url, tmpfile, this);
     mergeFile(tmpfile, ImportHydrogen);
 
@@ -4106,7 +4106,7 @@ void RosegardenGUIApp::slotMergeHydrogen()
 }
 
 RosegardenGUIDoc*
-RosegardenGUIApp::createDocumentFromHydrogenFile(QString file)
+RosegardenGUIApp::createDocumentFromHydrogenFile(TQString file)
 {
     KStartupLogo::hideIfStillThere();
     ProgressDialog progressDlg(
@@ -4123,11 +4123,11 @@ RosegardenGUIApp::createDocumentFromHydrogenFile(QString file)
 
     // TODO: make RG21Loader to actually emit these signals
     //
-    connect(&hydrogenLoader, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&hydrogenLoader, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&hydrogenLoader, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&hydrogenLoader, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     // "your starter for 40%" - helps the "freeze" work
     //
@@ -4147,15 +4147,15 @@ RosegardenGUIApp::createDocumentFromHydrogenFile(QString file)
 
     // Set the caption and add recent
     //
-    newDoc->setTitle(QFileInfo(file).fileName());
-    newDoc->setAbsFilePath(QFileInfo(file).absFilePath());
+    newDoc->setTitle(TQFileInfo(file).fileName());
+    newDoc->setAbsFilePath(TQFileInfo(file).absFilePath());
 
     return newDoc;
 
 }
 
 void
-RosegardenGUIApp::mergeFile(QString filePath, ImportType type)
+RosegardenGUIApp::mergeFile(TQString filePath, ImportType type)
 {
     RosegardenGUIDoc *doc = createDocument(filePath, type);
 
@@ -4197,7 +4197,7 @@ RosegardenGUIApp::mergeFile(QString filePath, ImportType type)
             }
 
             FileMergeDialog dialog(this, filePath, timingsDiffer);
-            if (dialog.exec() == QDialog::Accepted) {
+            if (dialog.exec() == TQDialog::Accepted) {
                 m_doc->mergeDocument(doc, dialog.getMergeOptions());
             }
 
@@ -4385,7 +4385,7 @@ void RosegardenGUIApp::slotSetPointerPosition(timeT t)
 	        if (!m_originatingJump) {
 	            m_seqManager->sendSequencerJump(comp.getElapsedRealTime(t));
 	        }
-	    } catch (QString s) {
+	    } catch (TQString s) {
 	        KMessageBox::error(this, s);
 	    }
     }
@@ -4501,22 +4501,22 @@ void RosegardenGUIApp::slotTestStartupTester()
 
     if (!m_startupTester) {
         m_startupTester = new StartupTester();
-        connect(m_startupTester, SIGNAL(newerVersionAvailable(QString)),
-                this, SLOT(slotNewerVersionAvailable(QString)));
+        connect(m_startupTester, TQT_SIGNAL(newerVersionAvailable(TQString)),
+                this, TQT_SLOT(slotNewerVersionAvailable(TQString)));
         m_startupTester->start();
-        QTimer::singleShot(100, this, SLOT(slotTestStartupTester()));
+        TQTimer::singleShot(100, this, TQT_SLOT(slotTestStartupTester()));
         return ;
     }
 
     if (!m_startupTester->isReady()) {
-        QTimer::singleShot(100, this, SLOT(slotTestStartupTester()));
+        TQTimer::singleShot(100, this, TQT_SLOT(slotTestStartupTester()));
         return ;
     }
 
-    QStringList missingFeatures;
-    QStringList allMissing;
+    TQStringList missingFeatures;
+    TQStringList allMissing;
 
-    QStringList missing;
+    TQStringList missing;
     bool have = m_startupTester->haveProjectPackager(&missing);
 
     stateChanged("have_project_packager",
@@ -4582,7 +4582,7 @@ void RosegardenGUIApp::slotTestStartupTester()
 #endif
 
     if (missingFeatures.count() > 0) {
-        QString message = i18n("<h3>Helper programs not found</h3><p>Rosegarden could not find one or more helper programs which it needs to provide some features.  The following features will not be available:</p>");
+        TQString message = i18n("<h3>Helper programs not found</h3><p>Rosegarden could not find one or more helper programs which it needs to provide some features.  The following features will not be available:</p>");
         message += i18n("<ul>");
         for (int i = 0; i < missingFeatures.count(); ++i) {
             message += i18n("<li>%1</li>").arg(missingFeatures[i]);
@@ -4634,7 +4634,7 @@ bool RosegardenGUIApp::launchSequencer(bool useExisting)
     // User mode should clear down sequencer processes.
     //
     if (kapp->dcopClient()->isApplicationRegistered(
-                QCString(ROSEGARDEN_SEQUENCER_APP_NAME))) {
+                TQCString(ROSEGARDEN_SEQUENCER_APP_NAME))) {
         RG_DEBUG << "RosegardenGUIApp::launchSequencer() - "
         << "existing DCOP registered sequencer found\n";
 
@@ -4659,7 +4659,7 @@ bool RosegardenGUIApp::launchSequencer(bool useExisting)
         sleep(1);
 
         if (kapp->dcopClient()->isApplicationRegistered(
-                    QCString(ROSEGARDEN_SEQUENCER_APP_NAME))) {
+                    TQCString(ROSEGARDEN_SEQUENCER_APP_NAME))) {
             RG_DEBUG << "RosegardenGUIApp::launchSequencer() - "
             << "failed to kill existing sequencer\n";
 
@@ -4694,7 +4694,7 @@ bool RosegardenGUIApp::launchSequencer(bool useExisting)
         //
         KConfig *config = kapp->config();
         config->setGroup(SequencerOptionsConfigGroup);
-        QString options = config->readEntry("commandlineoptions");
+        TQString options = config->readEntry("commandlineoptions");
         if (!options.isEmpty()) {
             (*m_sequencerProcess) << options;
             RG_DEBUG << "sequencer options \"" << options << "\"" << endl;
@@ -4739,8 +4739,8 @@ bool RosegardenGUIApp::launchSequencer(bool useExisting)
                 stateChanged("sequencer_running");
                 slotEnableTransport(true);
 
-                connect(m_sequencerProcess, SIGNAL(processExited(KProcess*)),
-                        this, SLOT(slotSequencerExited(KProcess*)));
+                connect(m_sequencerProcess, TQT_SIGNAL(processExited(KProcess*)),
+                        this, TQT_SLOT(slotSequencerExited(KProcess*)));
 
             } catch (Exception e) {
                 m_sequencerProcess = 0;
@@ -4784,7 +4784,7 @@ bool RosegardenGUIApp::launchJack()
     if (!startJack)
         return true; // we don't do anything
 
-    QString jackPath = config->readEntry("jackcommand", "");
+    TQString jackPath = config->readEntry("jackcommand", "");
 
     emit startupStatusMessage(i18n("Clearing down jackd..."));
 
@@ -4806,8 +4806,8 @@ bool RosegardenGUIApp::launchJack()
 
         RG_DEBUG << "starting jack \"" << jackPath << "\"" << endl;
 
-        QStringList splitCommand;
-        splitCommand = QStringList::split(" ", jackPath);
+        TQStringList splitCommand;
+        splitCommand = TQStringList::split(" ", jackPath);
 
         RG_DEBUG << "RosegardenGUIApp::launchJack() : splitCommand length : "
         << splitCommand.size() << endl;
@@ -4855,7 +4855,7 @@ void RosegardenGUIApp::slotExportProject()
 {
     KTmpStatusMsg msg(i18n("Exporting Rosegarden Project file..."), this);
 
-    QString fileName = getValidWriteFile
+    TQString fileName = getValidWriteFile
                        ("*.rgp|" + i18n("Rosegarden Project files\n") +
                         "\n*|" + i18n("All files"),
                         i18n("Export as..."));
@@ -4863,13 +4863,13 @@ void RosegardenGUIApp::slotExportProject()
     if (fileName.isEmpty())
         return ;
 
-    QString rgFile = fileName;
-    rgFile.replace(QRegExp(".rg.rgp$"), ".rg");
-    rgFile.replace(QRegExp(".rgp$"), ".rg");
+    TQString rgFile = fileName;
+    rgFile.replace(TQRegExp(".rg.rgp$"), ".rg");
+    rgFile.replace(TQRegExp(".rgp$"), ".rg");
 
     CurrentProgressDialog::freeze();
 
-    QString errMsg;
+    TQString errMsg;
     if (!m_doc->saveDocument(rgFile, errMsg,
                              true)) { // pretend it's autosave
         KMessageBox::sorry(this, i18n("Saving Rosegarden file to package failed: %1").arg(errMsg));
@@ -4899,7 +4899,7 @@ void RosegardenGUIApp::slotExportMIDI()
 {
     KTmpStatusMsg msg(i18n("Exporting MIDI file..."), this);
 
-    QString fileName = getValidWriteFile
+    TQString fileName = getValidWriteFile
                        ("*.mid *.midi|" + i18n("Standard MIDI files\n") +
                         "\n*|" + i18n("All files"),
                         i18n("Export as..."));
@@ -4910,22 +4910,22 @@ void RosegardenGUIApp::slotExportMIDI()
     exportMIDIFile(fileName);
 }
 
-void RosegardenGUIApp::exportMIDIFile(QString file)
+void RosegardenGUIApp::exportMIDIFile(TQString file)
 {
     ProgressDialog progressDlg(i18n("Exporting MIDI file..."),
                                100,
                                this);
 
-    std::string fname(QFile::encodeName(file));
+    std::string fname(TQFile::encodeName(file));
 
     MidiFile midiFile(fname,
                       &m_doc->getStudio());
 
-    connect(&midiFile, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&midiFile, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&midiFile, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&midiFile, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     midiFile.convertToMidi(m_doc->getComposition());
 
@@ -4939,7 +4939,7 @@ void RosegardenGUIApp::slotExportCsound()
 {
     KTmpStatusMsg msg(i18n("Exporting Csound score file..."), this);
 
-    QString fileName = getValidWriteFile(QString("*|") + i18n("All files"),
+    TQString fileName = getValidWriteFile(TQString("*|") + i18n("All files"),
                                          i18n("Export as..."));
     if (fileName.isEmpty())
         return ;
@@ -4947,19 +4947,19 @@ void RosegardenGUIApp::slotExportCsound()
     exportCsoundFile(fileName);
 }
 
-void RosegardenGUIApp::exportCsoundFile(QString file)
+void RosegardenGUIApp::exportCsoundFile(TQString file)
 {
     ProgressDialog progressDlg(i18n("Exporting Csound score file..."),
                                100,
                                this);
 
-    CsoundExporter e(this, &m_doc->getComposition(), std::string(QFile::encodeName(file)));
+    CsoundExporter e(this, &m_doc->getComposition(), std::string(TQFile::encodeName(file)));
 
-    connect(&e, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&e, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&e, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&e, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -4971,7 +4971,7 @@ void RosegardenGUIApp::slotExportMup()
 {
     KTmpStatusMsg msg(i18n("Exporting Mup file..."), this);
 
-    QString fileName = getValidWriteFile
+    TQString fileName = getValidWriteFile
                        ("*.mup|" + i18n("Mup files\n") + "\n*|" + i18n("All files"),
                         i18n("Export as..."));
     if (fileName.isEmpty())
@@ -4980,19 +4980,19 @@ void RosegardenGUIApp::slotExportMup()
     exportMupFile(fileName);
 }
 
-void RosegardenGUIApp::exportMupFile(QString file)
+void RosegardenGUIApp::exportMupFile(TQString file)
 {
     ProgressDialog progressDlg(i18n("Exporting Mup file..."),
                                100,
                                this);
 
-    MupExporter e(this, &m_doc->getComposition(), std::string(QFile::encodeName(file)));
+    MupExporter e(this, &m_doc->getComposition(), std::string(TQFile::encodeName(file)));
 
-    connect(&e, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&e, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&e, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&e, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -5004,8 +5004,8 @@ void RosegardenGUIApp::slotExportLilyPond()
 {
     KTmpStatusMsg msg(i18n("Exporting LilyPond file..."), this);
 
-    QString fileName = getValidWriteFile
-                       (QString("*.ly|") + i18n("LilyPond files") +
+    TQString fileName = getValidWriteFile
+                       (TQString("*.ly|") + i18n("LilyPond files") +
                         "\n*|" + i18n("All files"),
                         i18n("Export as..."));
 
@@ -5021,7 +5021,7 @@ std::map<KProcess *, KTempFile *> RosegardenGUIApp::m_lilyTempFileMap;
 void RosegardenGUIApp::slotPrintLilyPond()
 {
     KTmpStatusMsg msg(i18n("Printing LilyPond file..."), this);
-    KTempFile *file = new KTempFile(QString::null, ".ly");
+    KTempFile *file = new KTempFile(TQString::null, ".ly");
     file->setAutoDelete(true);
     if (!file->name()) {
         CurrentProgressDialog::freeze();
@@ -5036,8 +5036,8 @@ void RosegardenGUIApp::slotPrintLilyPond()
     *proc << "--graphical";
     *proc << "--print";
     *proc << file->name();
-    connect(proc, SIGNAL(processExited(KProcess *)),
-            this, SLOT(slotLilyPondViewProcessExited(KProcess *)));
+    connect(proc, TQT_SIGNAL(processExited(KProcess *)),
+            this, TQT_SLOT(slotLilyPondViewProcessExited(KProcess *)));
     m_lilyTempFileMap[proc] = file;
     proc->start(KProcess::NotifyOnExit);
 }
@@ -5045,7 +5045,7 @@ void RosegardenGUIApp::slotPrintLilyPond()
 void RosegardenGUIApp::slotPreviewLilyPond()
 {
     KTmpStatusMsg msg(i18n("Previewing LilyPond file..."), this);
-    KTempFile *file = new KTempFile(QString::null, ".ly");
+    KTempFile *file = new KTempFile(TQString::null, ".ly");
     file->setAutoDelete(true);
     if (!file->name()) {
         CurrentProgressDialog::freeze();
@@ -5060,8 +5060,8 @@ void RosegardenGUIApp::slotPreviewLilyPond()
     *proc << "--graphical";
     *proc << "--pdf";
     *proc << file->name();
-    connect(proc, SIGNAL(processExited(KProcess *)),
-            this, SLOT(slotLilyPondViewProcessExited(KProcess *)));
+    connect(proc, TQT_SIGNAL(processExited(KProcess *)),
+            this, TQT_SLOT(slotLilyPondViewProcessExited(KProcess *)));
     m_lilyTempFileMap[proc] = file;
     proc->start(KProcess::NotifyOnExit);
 }
@@ -5073,16 +5073,16 @@ void RosegardenGUIApp::slotLilyPondViewProcessExited(KProcess *p)
     delete p;
 }
 
-bool RosegardenGUIApp::exportLilyPondFile(QString file, bool forPreview)
+bool RosegardenGUIApp::exportLilyPondFile(TQString file, bool forPreview)
 {
-    QString caption = "", heading = "";
+    TQString caption = "", heading = "";
     if (forPreview) {
         caption = i18n("LilyPond Preview Options");
         heading = i18n("LilyPond preview options");
     }
 
     LilyPondOptionsDialog dialog(this, m_doc, caption, heading);
-    if (dialog.exec() != QDialog::Accepted) {
+    if (dialog.exec() != TQDialog::Accepted) {
         return false;
     }
 
@@ -5090,13 +5090,13 @@ bool RosegardenGUIApp::exportLilyPondFile(QString file, bool forPreview)
                                100,
                                this);
 
-    LilyPondExporter e(this, m_doc, std::string(QFile::encodeName(file)));
+    LilyPondExporter e(this, m_doc, std::string(TQFile::encodeName(file)));
 
-    connect(&e, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&e, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&e, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&e, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -5111,8 +5111,8 @@ void RosegardenGUIApp::slotExportMusicXml()
 {
     KTmpStatusMsg msg(i18n("Exporting MusicXML file..."), this);
 
-    QString fileName = getValidWriteFile
-                       (QString("*.xml|") + i18n("XML files") +
+    TQString fileName = getValidWriteFile
+                       (TQString("*.xml|") + i18n("XML files") +
                         "\n*|" + i18n("All files"), i18n("Export as..."));
 
     if (fileName.isEmpty())
@@ -5121,19 +5121,19 @@ void RosegardenGUIApp::slotExportMusicXml()
     exportMusicXmlFile(fileName);
 }
 
-void RosegardenGUIApp::exportMusicXmlFile(QString file)
+void RosegardenGUIApp::exportMusicXmlFile(TQString file)
 {
     ProgressDialog progressDlg(i18n("Exporting MusicXML file..."),
                                100,
                                this);
 
-    MusicXmlExporter e(this, m_doc, std::string(QFile::encodeName(file)));
+    MusicXmlExporter e(this, m_doc, std::string(TQFile::encodeName(file)));
 
-    connect(&e, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
+    connect(&e, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
 
-    connect(&e, SIGNAL(incrementProgress(int)),
-            progressDlg.progressBar(), SLOT(advance(int)));
+    connect(&e, TQT_SIGNAL(incrementProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(advance(int)));
 
     if (!e.write()) {
         CurrentProgressDialog::freeze();
@@ -5156,7 +5156,7 @@ RosegardenGUIApp::slotDeleteTransport()
 }
 
 void
-RosegardenGUIApp::slotActivateTool(QString toolName)
+RosegardenGUIApp::slotActivateTool(TQString toolName)
 {
     if (toolName == SegmentSelector::ToolName) {
         actionCollection()->action("select")->activate();
@@ -5273,7 +5273,7 @@ RosegardenGUIApp::slotRecord()
     //
     try {
         m_seqManager->record(false);
-    } catch (QString s) {
+    } catch (TQString s) {
         // We should already be stopped by this point so just unset
         // the buttons after clicking the dialog.
         //
@@ -5308,8 +5308,8 @@ RosegardenGUIApp::slotRecord()
     plugAccelerators(m_seqManager->getCountdownDialog(),
                      m_seqManager->getCountdownDialog()->getAccelerators());
 
-    connect(m_seqManager->getCountdownDialog(), SIGNAL(stopped()),
-            this, SLOT(slotStop()));
+    connect(m_seqManager->getCountdownDialog(), TQT_SIGNAL(stopped()),
+            this, TQT_SLOT(slotStop()));
 
     // Start the playback timer - this fetches the current sequencer position &c
     //
@@ -5329,7 +5329,7 @@ RosegardenGUIApp::slotToggleRecord()
 
     try {
         m_seqManager->record(true);
-    } catch (QString s) {
+    } catch (TQString s) {
         KMessageBox::error(this, s);
     } catch (AudioFileManager::BadAudioPathException e) {
         if (KMessageBox::warningContinueCancel
@@ -5361,7 +5361,7 @@ RosegardenGUIApp::slotSetLoop(timeT lhs, timeT rhs)
             getTransport()->LoopButton()->setOn(false);
             stateChanged("have_range", KXMLGUIClient::StateReverse);
         }
-    } catch (QString s) {
+    } catch (TQString s) {
         KMessageBox::error(this, s);
     }
 }
@@ -5429,7 +5429,7 @@ void RosegardenGUIApp::slotPlay()
             m_playTimer->stop();
             m_stopTimer->start(100);
         }
-    } catch (QString s) {
+    } catch (TQString s) {
         KMessageBox::error(this, s);
         m_playTimer->stop();
         m_stopTimer->start(100);
@@ -5459,10 +5459,10 @@ void RosegardenGUIApp::slotStop()
 {
     if (m_seqManager &&
         m_seqManager->getCountdownDialog()) {
-        disconnect(m_seqManager->getCountdownDialog(), SIGNAL(stopped()),
-                   this, SLOT(slotStop()));
-        disconnect(m_seqManager->getCountdownDialog(), SIGNAL(completed()),
-                   this, SLOT(slotStop()));
+        disconnect(m_seqManager->getCountdownDialog(), TQT_SIGNAL(stopped()),
+                   this, TQT_SLOT(slotStop()));
+        disconnect(m_seqManager->getCountdownDialog(), TQT_SIGNAL(completed()),
+                   this, TQT_SLOT(slotStop()));
     }
 
     try {
@@ -5645,10 +5645,10 @@ void RosegardenGUIApp::slotConfigure()
     ConfigureDialog *configDlg =
         new ConfigureDialog(m_doc, kapp->config(), this);
 
-    connect(configDlg, SIGNAL(updateAutoSaveInterval(unsigned int)),
-            this, SLOT(slotUpdateAutoSaveInterval(unsigned int)));
-    connect(configDlg, SIGNAL(updateSidebarStyle(unsigned int)),
-            this, SLOT(slotUpdateSidebarStyle(unsigned int)));
+    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)));
 
     configDlg->show();
 }
@@ -5683,8 +5683,8 @@ void RosegardenGUIApp::slotEditToolbars()
 {
     KEditToolbar dlg(actionCollection(), "rosegardenui.rc");
 
-    connect(&dlg, SIGNAL(newToolbarConfig()),
-            SLOT(slotUpdateToolbars()));
+    connect(&dlg, TQT_SIGNAL(newToolbarConfig()),
+            TQT_SLOT(slotUpdateToolbars()));
 
     dlg.exec();
 }
@@ -5705,23 +5705,23 @@ void RosegardenGUIApp::slotEditTempo(timeT atTime)
     slotEditTempo(this, atTime);
 }
 
-void RosegardenGUIApp::slotEditTempo(QWidget *parent)
+void RosegardenGUIApp::slotEditTempo(TQWidget *parent)
 {
     slotEditTempo(parent, m_doc->getComposition().getPosition());
 }
 
-void RosegardenGUIApp::slotEditTempo(QWidget *parent, timeT atTime)
+void RosegardenGUIApp::slotEditTempo(TQWidget *parent, timeT atTime)
 {
     RG_DEBUG << "RosegardenGUIApp::slotEditTempo\n";
 
     TempoDialog tempoDialog(parent, m_doc);
 
     connect(&tempoDialog,
-            SIGNAL(changeTempo(timeT,
+            TQT_SIGNAL(changeTempo(timeT,
                                tempoT,
                                tempoT,
                                TempoDialog::TempoDialogAction)),
-            SLOT(slotChangeTempo(timeT,
+            TQT_SLOT(slotChangeTempo(timeT,
                                  tempoT,
                                  tempoT,
                                  TempoDialog::TempoDialogAction)));
@@ -5740,12 +5740,12 @@ void RosegardenGUIApp::slotEditTimeSignature(timeT atTime)
     slotEditTimeSignature(this, atTime);
 }
 
-void RosegardenGUIApp::slotEditTimeSignature(QWidget *parent)
+void RosegardenGUIApp::slotEditTimeSignature(TQWidget *parent)
 {
     slotEditTimeSignature(parent, m_doc->getComposition().getPosition());
 }
 
-void RosegardenGUIApp::slotEditTimeSignature(QWidget *parent,
+void RosegardenGUIApp::slotEditTimeSignature(TQWidget *parent,
         timeT time)
 {
     Composition &composition(m_doc->getComposition());
@@ -5754,7 +5754,7 @@ void RosegardenGUIApp::slotEditTimeSignature(QWidget *parent,
 
     TimeSignatureDialog dialog(parent, &composition, time, sig);
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
 
         time = dialog.getTime();
 
@@ -5775,13 +5775,13 @@ void RosegardenGUIApp::slotEditTransportTime()
     slotEditTransportTime(this);
 }
 
-void RosegardenGUIApp::slotEditTransportTime(QWidget *parent)
+void RosegardenGUIApp::slotEditTransportTime(TQWidget *parent)
 {
     TimeDialog dialog(parent, i18n("Move playback pointer to time"),
                       &m_doc->getComposition(),
                       m_doc->getComposition().getPosition(),
                       true);
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         m_doc->slotSetPointerPosition(dialog.getTime());
     }
 }
@@ -5953,7 +5953,7 @@ RosegardenGUIApp::slotAddMarker(timeT time)
 }
 
 void
-RosegardenGUIApp::slotDeleteMarker(int id, timeT time, QString name, QString description)
+RosegardenGUIApp::slotDeleteMarker(int id, timeT time, TQString name, TQString description)
 {
     RemoveMarkerCommand *command =
         new RemoveMarkerCommand(&m_doc->getComposition(),
@@ -5980,7 +5980,7 @@ RosegardenGUIApp::slotDocumentModified(bool m)
 }
 
 void
-RosegardenGUIApp::slotStateChanged(QString s,
+RosegardenGUIApp::slotStateChanged(TQString s,
                                    bool noReverse)
 {
     //     RG_DEBUG << "RosegardenGUIApp::slotStateChanged " << s << "," << noReverse << endl;
@@ -6005,32 +6005,32 @@ RosegardenGUIApp::slotTestClipboard()
 }
 
 void
-RosegardenGUIApp::plugAccelerators(QWidget *widget, QAccel *acc)
+RosegardenGUIApp::plugAccelerators(TQWidget *widget, TQAccel *acc)
 {
 
     acc->connectItem(acc->insertItem(Key_Enter),
                      this,
-                     SLOT(slotPlay()));
+                     TQT_SLOT(slotPlay()));
     // Alternative shortcut for Play
     acc->connectItem(acc->insertItem(Key_Return + CTRL),
                      this,
-                     SLOT(slotPlay()));
+                     TQT_SLOT(slotPlay()));
 
     acc->connectItem(acc->insertItem(Key_Insert),
                      this,
-                     SLOT(slotStop()));
+                     TQT_SLOT(slotStop()));
 
     acc->connectItem(acc->insertItem(Key_PageDown),
                      this,
-                     SLOT(slotFastforward()));
+                     TQT_SLOT(slotFastforward()));
 
     acc->connectItem(acc->insertItem(Key_End),
                      this,
-                     SLOT(slotRewind()));
+                     TQT_SLOT(slotRewind()));
 
     acc->connectItem(acc->insertItem(Key_Space),
                      this,
-                     SLOT(slotToggleRecord()));
+                     TQT_SLOT(slotToggleRecord()));
 
     TransportDialog *transport =
         dynamic_cast<TransportDialog*>(widget);
@@ -6038,69 +6038,69 @@ RosegardenGUIApp::plugAccelerators(QWidget *widget, QAccel *acc)
     if (transport) {
         acc->connectItem(acc->insertItem(m_jumpToQuickMarkerAction->shortcut()),
                          this,
-                         SLOT(slotJumpToQuickMarker()));
+                         TQT_SLOT(slotJumpToQuickMarker()));
 
         acc->connectItem(acc->insertItem(m_setQuickMarkerAction->shortcut()),
                          this,
-                         SLOT(slotSetQuickMarker()));
+                         TQT_SLOT(slotSetQuickMarker()));
 
         connect(transport->PlayButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotPlay()));
+                TQT_SLOT(slotPlay()));
 
         connect(transport->StopButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotStop()));
+                TQT_SLOT(slotStop()));
 
         connect(transport->FfwdButton(),
-                SIGNAL(clicked()),
-                SLOT(slotFastforward()));
+                TQT_SIGNAL(clicked()),
+                TQT_SLOT(slotFastforward()));
 
         connect(transport->RewindButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotRewind()));
+                TQT_SLOT(slotRewind()));
 
         connect(transport->RecordButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotRecord()));
+                TQT_SLOT(slotRecord()));
 
         connect(transport->RewindEndButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotRewindToBeginning()));
+                TQT_SLOT(slotRewindToBeginning()));
 
         connect(transport->FfwdEndButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotFastForwardToEnd()));
+                TQT_SLOT(slotFastForwardToEnd()));
 
         connect(transport->MetronomeButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotToggleMetronome()));
+                TQT_SLOT(slotToggleMetronome()));
 
         connect(transport->SoloButton(),
-                SIGNAL(toggled(bool)),
+                TQT_SIGNAL(toggled(bool)),
                 this,
-                SLOT(slotToggleSolo(bool)));
+                TQT_SLOT(slotToggleSolo(bool)));
 
         connect(transport->TimeDisplayButton(),
-                SIGNAL(clicked()),
+                TQT_SIGNAL(clicked()),
                 this,
-                SLOT(slotRefreshTimeDisplay()));
+                TQT_SLOT(slotRefreshTimeDisplay()));
 
         connect(transport->ToEndButton(),
-                SIGNAL(clicked()),
-                SLOT(slotRefreshTimeDisplay()));
+                TQT_SIGNAL(clicked()),
+                TQT_SLOT(slotRefreshTimeDisplay()));
     }
 }
 
 void
-RosegardenGUIApp::setCursor(const QCursor& cursor)
+RosegardenGUIApp::setCursor(const TQCursor& cursor)
 {
     KDockMainWindow::setCursor(cursor);
 
@@ -6119,7 +6119,7 @@ RosegardenGUIApp::setCursor(const QCursor& cursor)
 
     // toolbars...
     //
-    QPtrListIterator<KToolBar> tbIter = toolBarIterator();
+    TQPtrListIterator<KToolBar> tbIter = toolBarIterator();
     KToolBar* tb = 0;
     while ((tb = tbIter.current()) != 0) {
         tb->setCursor(cursor);
@@ -6150,10 +6150,10 @@ RosegardenGUIApp::createNewAudioFile()
     }
 }
 
-QValueVector<QString>
-RosegardenGUIApp::createRecordAudioFiles(const QValueVector<InstrumentId> &recordInstruments)
+TQValueVector<TQString>
+RosegardenGUIApp::createRecordAudioFiles(const TQValueVector<InstrumentId> &recordInstruments)
 {
-    QValueVector<QString> qv;
+    TQValueVector<TQString> qv;
     for (unsigned int i = 0; i < recordInstruments.size(); ++i) {
         AudioFile *aF = 0;
         try {
@@ -6180,10 +6180,10 @@ RosegardenGUIApp::createRecordAudioFiles(const QValueVector<InstrumentId> &recor
 QString
 RosegardenGUIApp::getAudioFilePath()
 {
-    return QString(m_doc->getAudioFileManager().getAudioPath().c_str());
+    return TQString(m_doc->getAudioFileManager().getAudioPath().c_str());
 }
 
-QValueVector<InstrumentId>
+TQValueVector<InstrumentId>
 RosegardenGUIApp::getArmedInstruments()
 {
     std::set
@@ -6203,7 +6203,7 @@ RosegardenGUIApp::getArmedInstruments()
         }
     }
 
-    QValueVector<InstrumentId> iv;
+    TQValueVector<InstrumentId> iv;
     for (std::set
                 <InstrumentId>::iterator ii = iid.begin();
                 ii != iid.end(); ++ii) {
@@ -6213,7 +6213,7 @@ RosegardenGUIApp::getArmedInstruments()
 }
 
 void
-RosegardenGUIApp::showError(QString error)
+RosegardenGUIApp::showError(TQString error)
 {
     KStartupLogo::hideIfStillThere();
     CurrentProgressDialog::freeze();
@@ -6245,20 +6245,20 @@ RosegardenGUIApp::slotAudioManager()
         new AudioManagerDialog(this, m_doc);
 
     connect(m_audioManagerDialog,
-            SIGNAL(playAudioFile(AudioFileId,
+            TQT_SIGNAL(playAudioFile(AudioFileId,
                                  const RealTime &,
                                  const RealTime&)),
-            SLOT(slotPlayAudioFile(AudioFileId,
+            TQT_SLOT(slotPlayAudioFile(AudioFileId,
                                    const RealTime &,
                                    const RealTime &)));
 
     connect(m_audioManagerDialog,
-            SIGNAL(addAudioFile(AudioFileId)),
-            SLOT(slotAddAudioFile(AudioFileId)));
+            TQT_SIGNAL(addAudioFile(AudioFileId)),
+            TQT_SLOT(slotAddAudioFile(AudioFileId)));
 
     connect(m_audioManagerDialog,
-            SIGNAL(deleteAudioFile(AudioFileId)),
-            SLOT(slotDeleteAudioFile(AudioFileId)));
+            TQT_SIGNAL(deleteAudioFile(AudioFileId)),
+            TQT_SLOT(slotDeleteAudioFile(AudioFileId)));
 
     //
     // Sync segment selection between audio man. dialog and main window
@@ -6266,46 +6266,46 @@ RosegardenGUIApp::slotAudioManager()
 
     // from dialog to us...
     connect(m_audioManagerDialog,
-            SIGNAL(segmentsSelected(const SegmentSelection&)),
+            TQT_SIGNAL(segmentsSelected(const SegmentSelection&)),
             m_view,
-            SLOT(slotPropagateSegmentSelection(const SegmentSelection&)));
+            TQT_SLOT(slotPropagateSegmentSelection(const SegmentSelection&)));
 
     // and from us to dialog
-    connect(this, SIGNAL(segmentsSelected(const SegmentSelection&)),
+    connect(this, TQT_SIGNAL(segmentsSelected(const SegmentSelection&)),
             m_audioManagerDialog,
-            SLOT(slotSegmentSelection(const SegmentSelection&)));
+            TQT_SLOT(slotSegmentSelection(const SegmentSelection&)));
 
 
     connect(m_audioManagerDialog,
-            SIGNAL(deleteSegments(const SegmentSelection&)),
-            SLOT(slotDeleteSegments(const SegmentSelection&)));
+            TQT_SIGNAL(deleteSegments(const SegmentSelection&)),
+            TQT_SLOT(slotDeleteSegments(const SegmentSelection&)));
 
     connect(m_audioManagerDialog,
-            SIGNAL(insertAudioSegment(AudioFileId,
+            TQT_SIGNAL(insertAudioSegment(AudioFileId,
                                       const RealTime&,
                                       const RealTime&)),
             m_view,
-            SLOT(slotAddAudioSegmentDefaultPosition(AudioFileId,
+            TQT_SLOT(slotAddAudioSegmentDefaultPosition(AudioFileId,
                                                     const RealTime&,
                                                     const RealTime&)));
     connect(m_audioManagerDialog,
-            SIGNAL(cancelPlayingAudioFile(AudioFileId)),
-            SLOT(slotCancelAudioPlayingFile(AudioFileId)));
+            TQT_SIGNAL(cancelPlayingAudioFile(AudioFileId)),
+            TQT_SLOT(slotCancelAudioPlayingFile(AudioFileId)));
 
     connect(m_audioManagerDialog,
-            SIGNAL(deleteAllAudioFiles()),
-            SLOT(slotDeleteAllAudioFiles()));
+            TQT_SIGNAL(deleteAllAudioFiles()),
+            TQT_SLOT(slotDeleteAllAudioFiles()));
 
     // Make sure we know when the audio man. dialog is closing
     //
     connect(m_audioManagerDialog,
-            SIGNAL(closing()),
-            SLOT(slotAudioManagerClosed()));
+            TQT_SIGNAL(closing()),
+            TQT_SLOT(slotAudioManagerClosed()));
 
     // And that it goes away when the current document is changing
     //
-    connect(this, SIGNAL(documentAboutToChange()),
-            m_audioManagerDialog, SLOT(close()));
+    connect(this, TQT_SIGNAL(documentAboutToChange()),
+            m_audioManagerDialog, TQT_SLOT(close()));
 
     m_audioManagerDialog->setAudioSubsystemStatus(
         m_seqManager->getSoundDriverStatus() & AUDIO_OK);
@@ -6345,18 +6345,18 @@ RosegardenGUIApp::slotAddAudioFile(unsigned int id)
     if (aF == 0)
         return ;
 
-    QCString replyType;
-    QByteArray replyData;
-    QByteArray data;
-    QDataStream streamOut(data, IO_WriteOnly);
+    TQCString replyType;
+    TQByteArray replyData;
+    TQByteArray data;
+    TQDataStream streamOut(data, IO_WriteOnly);
 
     // We have to pass the filename as a QString
     //
-    streamOut << QString(strtoqstr(aF->getFilename()));
+    streamOut << TQString(strtoqstr(aF->getFilename()));
     streamOut << (int)aF->getId();
 
-    if (rgapp->sequencerCall("addAudioFile(QString, int)", replyType, replyData, data)) {
-        QDataStream streamIn(replyData, IO_ReadOnly);
+    if (rgapp->sequencerCall("addAudioFile(TQString, int)", replyType, replyData, data)) {
+        TQDataStream streamIn(replyData, IO_ReadOnly);
         int result;
         streamIn >> result;
         if (!result) {
@@ -6371,17 +6371,17 @@ RosegardenGUIApp::slotDeleteAudioFile(unsigned int id)
     if (m_doc->getAudioFileManager().removeFile(id) == false)
         return ;
 
-    QCString replyType;
-    QByteArray replyData;
-    QByteArray data;
-    QDataStream streamOut(data, IO_WriteOnly);
+    TQCString replyType;
+    TQByteArray replyData;
+    TQByteArray data;
+    TQDataStream streamOut(data, IO_WriteOnly);
 
     // file id
     //
     streamOut << (int)id;
 
     if (rgapp->sequencerCall("removeAudioFile(int)", replyType, replyData, data)) {
-        QDataStream streamIn(replyData, IO_ReadOnly);
+        TQDataStream streamIn(replyData, IO_ReadOnly);
         int result;
         streamIn >> result;
         if (!result) {
@@ -6420,9 +6420,9 @@ RosegardenGUIApp::slotDeleteAllAudioFiles()
 
     // Clear at the sequencer
     //
-    QCString replyType;
-    QByteArray replyData;
-    QByteArray data;
+    TQCString replyType;
+    TQByteArray replyData;
+    TQByteArray data;
 
     rgapp->sequencerCall("clearAllAudioFiles()", replyType, replyData, data);
 }
@@ -6440,7 +6440,7 @@ RosegardenGUIApp::slotRelabelSegments()
         return ;
 
     SegmentSelection selection(m_view->getSelection());
-    QString editLabel;
+    TQString editLabel;
 
     if (selection.size() == 0)
         return ;
@@ -6452,7 +6452,7 @@ RosegardenGUIApp::slotRelabelSegments()
     KTmpStatusMsg msg(i18n("Relabelling selection..."), this);
 
     // Generate label
-    QString label = strtoqstr((*selection.begin())->getLabel());
+    TQString label = strtoqstr((*selection.begin())->getLabel());
 
     for (SegmentSelection::iterator i = selection.begin();
             i != selection.end(); ++i) {
@@ -6462,7 +6462,7 @@ RosegardenGUIApp::slotRelabelSegments()
 
     bool ok = false;
 
-    QString newLabel = KInputDialog::getText(editLabel,
+    TQString newLabel = KInputDialog::getText(editLabel,
                        i18n("Enter new label"),
                        label,
                        &ok,
@@ -6498,7 +6498,7 @@ RosegardenGUIApp::slotChangeCompositionLength()
 {
     CompositionLengthDialog dialog(this, &m_doc->getComposition());
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         ChangeCompositionLengthCommand *command
         = new ChangeCompositionLengthCommand(
               &m_doc->getComposition(),
@@ -6522,26 +6522,26 @@ RosegardenGUIApp::slotManageMIDIDevices()
 
     m_deviceManager = new DeviceManagerDialog(this, m_doc);
 
-    connect(m_deviceManager, SIGNAL(closing()),
-            this, SLOT(slotDeviceManagerClosed()));
+    connect(m_deviceManager, TQT_SIGNAL(closing()),
+            this, TQT_SLOT(slotDeviceManagerClosed()));
 
-    connect(this, SIGNAL(documentAboutToChange()),
-            m_deviceManager, SLOT(close()));
+    connect(this, TQT_SIGNAL(documentAboutToChange()),
+            m_deviceManager, TQT_SLOT(close()));
 
     // Cheating way of updating the track/instrument list
     //
-    connect(m_deviceManager, SIGNAL(deviceNamesChanged()),
-            m_view, SLOT(slotSynchroniseWithComposition()));
+    connect(m_deviceManager, TQT_SIGNAL(deviceNamesChanged()),
+            m_view, TQT_SLOT(slotSynchroniseWithComposition()));
 
-    connect(m_deviceManager, SIGNAL(editBanks(DeviceId)),
-            this, SLOT(slotEditBanks(DeviceId)));
+    connect(m_deviceManager, TQT_SIGNAL(editBanks(DeviceId)),
+            this, TQT_SLOT(slotEditBanks(DeviceId)));
 
-    connect(m_deviceManager, SIGNAL(editControllers(DeviceId)),
-            this, SLOT(slotEditControlParameters(DeviceId)));
+    connect(m_deviceManager, TQT_SIGNAL(editControllers(DeviceId)),
+            this, TQT_SLOT(slotEditControlParameters(DeviceId)));
 
     if (m_midiMixer) {
-        connect(m_deviceManager, SIGNAL(deviceNamesChanged()),
-                m_midiMixer, SLOT(slotSynchronise()));
+        connect(m_deviceManager, TQT_SIGNAL(deviceNamesChanged()),
+                m_midiMixer, TQT_SLOT(slotSynchronise()));
 
     }
 
@@ -6565,26 +6565,26 @@ RosegardenGUIApp::slotManageSynths()
 #endif
                                                  );
 
-    connect(m_synthManager, SIGNAL(closing()),
-            this, SLOT(slotSynthPluginManagerClosed()));
+    connect(m_synthManager, TQT_SIGNAL(closing()),
+            this, TQT_SLOT(slotSynthPluginManagerClosed()));
 
-    connect(this, SIGNAL(documentAboutToChange()),
-            m_synthManager, SLOT(close()));
+    connect(this, TQT_SIGNAL(documentAboutToChange()),
+            m_synthManager, TQT_SLOT(close()));
 
     connect(m_synthManager,
-            SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
             this,
-            SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(m_synthManager,
-            SIGNAL(showPluginDialog(QWidget *, InstrumentId, int)),
+            TQT_SIGNAL(showPluginDialog(TQWidget *, InstrumentId, int)),
             this,
-            SLOT(slotShowPluginDialog(QWidget *, InstrumentId, int)));
+            TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
 
     connect(m_synthManager,
-            SIGNAL(showPluginGUI(InstrumentId, int)),
+            TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
             this,
-            SLOT(slotShowPluginGUI(InstrumentId, int)));
+            TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
 
     m_synthManager->show();
 }
@@ -6601,66 +6601,66 @@ RosegardenGUIApp::slotOpenAudioMixer()
 
     m_audioMixer = new AudioMixerWindow(this, m_doc);
 
-    connect(m_audioMixer, SIGNAL(windowActivated()),
-            m_view, SLOT(slotActiveMainWindowChanged()));
+    connect(m_audioMixer, TQT_SIGNAL(windowActivated()),
+            m_view, TQT_SLOT(slotActiveMainWindowChanged()));
 
-    connect(m_view, SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            m_audioMixer, SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+    connect(m_view, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            m_audioMixer, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
 
-    connect(m_audioMixer, SIGNAL(closing()),
-            this, SLOT(slotAudioMixerClosed()));
+    connect(m_audioMixer, TQT_SIGNAL(closing()),
+            this, TQT_SLOT(slotAudioMixerClosed()));
 
-    connect(m_audioMixer, SIGNAL(selectPlugin(QWidget *, InstrumentId, int)),
-            this, SLOT(slotShowPluginDialog(QWidget *, InstrumentId, int)));
+    connect(m_audioMixer, TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
+            this, TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
 
     connect(this,
-            SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
             m_audioMixer,
-            SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(this,
-            SIGNAL(pluginBypassed(InstrumentId, int, bool)),
+            TQT_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
             m_audioMixer,
-            SLOT(slotPluginBypassed(InstrumentId, int, bool)));
-
-    connect(this, SIGNAL(documentAboutToChange()),
-            m_audioMixer, SLOT(close()));
-
-    connect(m_view, SIGNAL(checkTrackAssignments()),
-            m_audioMixer, SLOT(slotTrackAssignmentsChanged()));
-
-    connect(m_audioMixer, SIGNAL(play()),
-            this, SLOT(slotPlay()));
-    connect(m_audioMixer, SIGNAL(stop()),
-            this, SLOT(slotStop()));
-    connect(m_audioMixer, SIGNAL(fastForwardPlayback()),
-            this, SLOT(slotFastforward()));
-    connect(m_audioMixer, SIGNAL(rewindPlayback()),
-            this, SLOT(slotRewind()));
-    connect(m_audioMixer, SIGNAL(fastForwardPlaybackToEnd()),
-            this, SLOT(slotFastForwardToEnd()));
-    connect(m_audioMixer, SIGNAL(rewindPlaybackToBeginning()),
-            this, SLOT(slotRewindToBeginning()));
-    connect(m_audioMixer, SIGNAL(record()),
-            this, SLOT(slotRecord()));
-    connect(m_audioMixer, SIGNAL(panic()),
-            this, SLOT(slotPanic()));
+            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()));
 
     connect(m_audioMixer,
-            SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
             this,
-            SIGNAL(instrumentParametersChanged(InstrumentId)));
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
             m_audioMixer,
-            SLOT(slotUpdateInstrument(InstrumentId)));
+            TQT_SLOT(slotUpdateInstrument(InstrumentId)));
 
     if (m_synthManager) {
         connect(m_synthManager,
-                SIGNAL(pluginSelected(InstrumentId, int, int)),
+                TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
                 m_audioMixer,
-                SLOT(slotPluginSelected(InstrumentId, int, int)));
+                TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
     }
 
     plugAccelerators(m_audioMixer, m_audioMixer->getAccelerators());
@@ -6680,44 +6680,44 @@ RosegardenGUIApp::slotOpenMidiMixer()
 
     m_midiMixer = new MidiMixerWindow(this, m_doc);
 
-    connect(m_midiMixer, SIGNAL(windowActivated()),
-            m_view, SLOT(slotActiveMainWindowChanged()));
-
-    connect(m_view, SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            m_midiMixer, SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
-
-    connect(m_midiMixer, SIGNAL(closing()),
-            this, SLOT(slotMidiMixerClosed()));
-
-    connect(this, SIGNAL(documentAboutToChange()),
-            m_midiMixer, SLOT(close()));
-
-    connect(m_midiMixer, SIGNAL(play()),
-            this, SLOT(slotPlay()));
-    connect(m_midiMixer, SIGNAL(stop()),
-            this, SLOT(slotStop()));
-    connect(m_midiMixer, SIGNAL(fastForwardPlayback()),
-            this, SLOT(slotFastforward()));
-    connect(m_midiMixer, SIGNAL(rewindPlayback()),
-            this, SLOT(slotRewind()));
-    connect(m_midiMixer, SIGNAL(fastForwardPlaybackToEnd()),
-            this, SLOT(slotFastForwardToEnd()));
-    connect(m_midiMixer, SIGNAL(rewindPlaybackToBeginning()),
-            this, SLOT(slotRewindToBeginning()));
-    connect(m_midiMixer, SIGNAL(record()),
-            this, SLOT(slotRecord()));
-    connect(m_midiMixer, SIGNAL(panic()),
-            this, SLOT(slotPanic()));
+    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,
-            SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
             this,
-            SIGNAL(instrumentParametersChanged(InstrumentId)));
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
 
     connect(this,
-            SIGNAL(instrumentParametersChanged(InstrumentId)),
+            TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
             m_midiMixer,
-            SLOT(slotUpdateInstrument(InstrumentId)));
+            TQT_SLOT(slotUpdateInstrument(InstrumentId)));
 
     plugAccelerators(m_midiMixer, m_midiMixer->getAccelerators());
 
@@ -6744,14 +6744,14 @@ RosegardenGUIApp::slotEditControlParameters(DeviceId device)
 
     RG_DEBUG << "inserting control editor dialog, have " << m_controlEditors.size() << " now" << endl;
 
-    connect(controlEditor, SIGNAL(closing()),
-            SLOT(slotControlEditorClosed()));
+    connect(controlEditor, TQT_SIGNAL(closing()),
+            TQT_SLOT(slotControlEditorClosed()));
 
-    connect(this, SIGNAL(documentAboutToChange()),
-            controlEditor, SLOT(close()));
+    connect(this, TQT_SIGNAL(documentAboutToChange()),
+            controlEditor, TQT_SLOT(close()));
 
-    connect(m_doc, SIGNAL(devicesResyncd()),
-            controlEditor, SLOT(slotUpdate()));
+    connect(m_doc, TQT_SIGNAL(devicesResyncd()),
+            controlEditor, TQT_SLOT(slotUpdate()));
 
     controlEditor->show();
 }
@@ -6776,16 +6776,16 @@ RosegardenGUIApp::slotEditBanks(DeviceId device)
 
     m_bankEditor = new BankEditorDialog(this, m_doc, device);
 
-    connect(m_bankEditor, SIGNAL(closing()),
-            this, SLOT(slotBankEditorClosed()));
+    connect(m_bankEditor, TQT_SIGNAL(closing()),
+            this, TQT_SLOT(slotBankEditorClosed()));
 
-    connect(this, SIGNAL(documentAboutToChange()),
-            m_bankEditor, SLOT(slotFileClose()));
+    connect(this, TQT_SIGNAL(documentAboutToChange()),
+            m_bankEditor, TQT_SLOT(slotFileClose()));
 
     // Cheating way of updating the track/instrument list
     //
-    connect(m_bankEditor, SIGNAL(deviceNamesChanged()),
-            m_view, SLOT(slotSynchroniseWithComposition()));
+    connect(m_bankEditor, TQT_SIGNAL(deviceNamesChanged()),
+            m_view, TQT_SLOT(slotSynchroniseWithComposition()));
 
     m_bankEditor->show();
 }
@@ -6802,11 +6802,11 @@ RosegardenGUIApp::slotManageTriggerSegments()
 
     m_triggerSegmentManager = new TriggerSegmentManager(this, m_doc);
 
-    connect(m_triggerSegmentManager, SIGNAL(closing()),
-            SLOT(slotTriggerManagerClosed()));
+    connect(m_triggerSegmentManager, TQT_SIGNAL(closing()),
+            TQT_SLOT(slotTriggerManagerClosed()));
 
-    connect(m_triggerSegmentManager, SIGNAL(editTriggerSegment(int)),
-            m_view, SLOT(slotEditTriggerSegment(int)));
+    connect(m_triggerSegmentManager, TQT_SIGNAL(editTriggerSegment(int)),
+            m_view, TQT_SLOT(slotEditTriggerSegment(int)));
 
     m_triggerSegmentManager->show();
 }
@@ -6831,11 +6831,11 @@ RosegardenGUIApp::slotEditMarkers()
 
     m_markerEditor = new MarkerEditor(this, m_doc);
 
-    connect(m_markerEditor, SIGNAL(closing()),
-            SLOT(slotMarkerEditorClosed()));
+    connect(m_markerEditor, TQT_SIGNAL(closing()),
+            TQT_SLOT(slotMarkerEditorClosed()));
 
-    connect(m_markerEditor, SIGNAL(jumpToMarker(timeT)),
-            m_doc, SLOT(slotSetPointerPosition(timeT)));
+    connect(m_markerEditor, TQT_SIGNAL(jumpToMarker(timeT)),
+            m_doc, TQT_SLOT(slotSetPointerPosition(timeT)));
 
     plugAccelerators(m_markerEditor, m_markerEditor->getAccelerators());
 
@@ -6862,24 +6862,24 @@ RosegardenGUIApp::slotEditTempos(timeT t)
 
     m_tempoView = new TempoView(m_doc, getView(), t);
 
-    connect(m_tempoView, SIGNAL(closing()),
-            SLOT(slotTempoViewClosed()));
+    connect(m_tempoView, TQT_SIGNAL(closing()),
+            TQT_SLOT(slotTempoViewClosed()));
 
-    connect(m_tempoView, SIGNAL(windowActivated()),
-            getView(), SLOT(slotActiveMainWindowChanged()));
+    connect(m_tempoView, TQT_SIGNAL(windowActivated()),
+            getView(), TQT_SLOT(slotActiveMainWindowChanged()));
 
     connect(m_tempoView,
-            SIGNAL(changeTempo(timeT,
+            TQT_SIGNAL(changeTempo(timeT,
                                tempoT,
                                tempoT,
                                TempoDialog::TempoDialogAction)),
             this,
-            SLOT(slotChangeTempo(timeT,
+            TQT_SLOT(slotChangeTempo(timeT,
                                  tempoT,
                                  tempoT,
                                  TempoDialog::TempoDialogAction)));
 
-    connect(m_tempoView, SIGNAL(saveFile()), this, SLOT(slotFileSave()));
+    connect(m_tempoView, TQT_SIGNAL(saveFile()), this, TQT_SLOT(slotFileSave()));
 
     plugAccelerators(m_tempoView, m_tempoView->getAccelerators());
 
@@ -6897,7 +6897,7 @@ RosegardenGUIApp::slotTempoViewClosed()
 void
 RosegardenGUIApp::slotControlEditorClosed()
 {
-    const QObject *s = sender();
+    const TQObject *s = sender();
 
     RG_DEBUG << "RosegardenGUIApp::slotControlEditorClosed" << endl;
 
@@ -6915,7 +6915,7 @@ RosegardenGUIApp::slotControlEditorClosed()
 }
 
 void
-RosegardenGUIApp::slotShowPluginDialog(QWidget *parent,
+RosegardenGUIApp::slotShowPluginDialog(TQWidget *parent,
                                        InstrumentId instrumentId,
                                        int index)
 {
@@ -6962,12 +6962,12 @@ RosegardenGUIApp::slotShowPluginDialog(QWidget *parent,
                               container,
                               index);
 
-    connect(dialog, SIGNAL(windowActivated()),
-            m_view, SLOT(slotActiveMainWindowChanged()));
+    connect(dialog, TQT_SIGNAL(windowActivated()),
+            m_view, TQT_SLOT(slotActiveMainWindowChanged()));
 
 /* This feature isn't provided by the plugin dialog
-    connect(m_view, SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            dialog, SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+    connect(m_view, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            dialog, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
 */
 
     // Plug the new dialog into the standard keyboard accelerators so
@@ -6976,46 +6976,46 @@ RosegardenGUIApp::slotShowPluginDialog(QWidget *parent,
     plugAccelerators(dialog, dialog->getAccelerators());
 
     connect(dialog,
-            SIGNAL(pluginSelected(InstrumentId, int, int)),
+            TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
             this,
-            SLOT(slotPluginSelected(InstrumentId, int, int)));
+            TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
 
     connect(dialog,
-            SIGNAL(pluginPortChanged(InstrumentId, int, int)),
+            TQT_SIGNAL(pluginPortChanged(InstrumentId, int, int)),
             this,
-            SLOT(slotPluginPortChanged(InstrumentId, int, int)));
+            TQT_SLOT(slotPluginPortChanged(InstrumentId, int, int)));
 
     connect(dialog,
-            SIGNAL(pluginProgramChanged(InstrumentId, int)),
+            TQT_SIGNAL(pluginProgramChanged(InstrumentId, int)),
             this,
-            SLOT(slotPluginProgramChanged(InstrumentId, int)));
+            TQT_SLOT(slotPluginProgramChanged(InstrumentId, int)));
 
     connect(dialog,
-            SIGNAL(changePluginConfiguration(InstrumentId, int, bool, QString, QString)),
+            TQT_SIGNAL(changePluginConfiguration(InstrumentId, int, bool, TQString, TQString)),
             this,
-            SLOT(slotChangePluginConfiguration(InstrumentId, int, bool, QString, QString)));
+            TQT_SLOT(slotChangePluginConfiguration(InstrumentId, int, bool, TQString, TQString)));
 
     connect(dialog,
-            SIGNAL(showPluginGUI(InstrumentId, int)),
+            TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
             this,
-            SLOT(slotShowPluginGUI(InstrumentId, int)));
+            TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
 
     connect(dialog,
-            SIGNAL(stopPluginGUI(InstrumentId, int)),
+            TQT_SIGNAL(stopPluginGUI(InstrumentId, int)),
             this,
-            SLOT(slotStopPluginGUI(InstrumentId, int)));
+            TQT_SLOT(slotStopPluginGUI(InstrumentId, int)));
 
     connect(dialog,
-            SIGNAL(bypassed(InstrumentId, int, bool)),
+            TQT_SIGNAL(bypassed(InstrumentId, int, bool)),
             this,
-            SLOT(slotPluginBypassed(InstrumentId, int, bool)));
+            TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
 
     connect(dialog,
-            SIGNAL(destroyed(InstrumentId, int)),
+            TQT_SIGNAL(destroyed(InstrumentId, int)),
             this,
-            SLOT(slotPluginDialogDestroyed(InstrumentId, int)));
+            TQT_SLOT(slotPluginDialogDestroyed(InstrumentId, int)));
 
-    connect(this, SIGNAL(documentAboutToChange()), dialog, SLOT(close()));
+    connect(this, TQT_SIGNAL(documentAboutToChange()), dialog, TQT_SLOT(close()));
 
     m_pluginDialogs[key] = dialog;
     m_pluginDialogs[key]->show();
@@ -7028,7 +7028,7 @@ void
 RosegardenGUIApp::slotPluginSelected(InstrumentId instrumentId,
                                      int index, int plugin)
 {
-    const QObject *s = sender();
+    const TQObject *s = sender();
 
     bool fromSynthMgr = (s == m_synthManager);
 
@@ -7276,7 +7276,7 @@ RosegardenGUIApp::slotPluginPortChanged(InstrumentId instrumentId,
 void
 RosegardenGUIApp::slotChangePluginProgram(InstrumentId instrumentId,
         int pluginIndex,
-        QString program)
+        TQString program)
 {
     PluginContainer *container = 0;
 
@@ -7345,7 +7345,7 @@ RosegardenGUIApp::slotPluginProgramChanged(InstrumentId instrumentId,
         return ;
     }
 
-    QString program = strtoqstr(inst->getProgram());
+    TQString program = strtoqstr(inst->getProgram());
 
     RG_DEBUG << "RosegardenGUIApp::slotPluginProgramChanged - "
     << "setting plugin program ("
@@ -7381,8 +7381,8 @@ void
 RosegardenGUIApp::slotChangePluginConfiguration(InstrumentId instrumentId,
         int index,
         bool global,
-        QString key,
-        QString value)
+        TQString key,
+        TQString value)
 {
     PluginContainer *container = 0;
 
@@ -7537,17 +7537,17 @@ RosegardenGUIApp::slotPlayList()
 {
     if (!m_playList) {
         m_playList = new PlayListDialog(i18n("Play List"), this);
-        connect(m_playList, SIGNAL(closing()),
-                SLOT(slotPlayListClosed()));
-        connect(m_playList->getPlayList(), SIGNAL(play(QString)),
-                SLOT(slotPlayListPlay(QString)));
+        connect(m_playList, TQT_SIGNAL(closing()),
+                TQT_SLOT(slotPlayListClosed()));
+        connect(m_playList->getPlayList(), TQT_SIGNAL(play(TQString)),
+                TQT_SLOT(slotPlayListPlay(TQString)));
     }
 
     m_playList->show();
 }
 
 void
-RosegardenGUIApp::slotPlayListPlay(QString url)
+RosegardenGUIApp::slotPlayListPlay(TQString url)
 {
     slotStop();
     openURL(url);
@@ -7564,14 +7564,14 @@ RosegardenGUIApp::slotPlayListClosed()
 void
 RosegardenGUIApp::slotTutorial()
 {
-    QString tutorialURL = i18n("http://rosegarden.sourceforge.net/tutorial/en/chapter-0.html");
+    TQString tutorialURL = i18n("http://rosegarden.sourceforge.net/tutorial/en/chapter-0.html");
     kapp->invokeBrowser(tutorialURL);
 }
 
 void
 RosegardenGUIApp::slotBugGuidelines()
 {
-    QString glURL = i18n("http://rosegarden.sourceforge.net/tutorial/bug-guidelines.html");
+    TQString glURL = i18n("http://rosegarden.sourceforge.net/tutorial/bug-guidelines.html");
     kapp->invokeBrowser(glURL);
 }
 
@@ -7654,10 +7654,10 @@ RosegardenGUIApp::slotPanic()
             (&progressDlg);
         ProgressDialog::processEvents();
 
-        connect(m_seqManager, SIGNAL(setProgress(int)),
-                progressDlg.progressBar(), SLOT(setValue(int)));
-        connect(m_seqManager, SIGNAL(incrementProgress(int)),
-                progressDlg.progressBar(), SLOT(advance(int)));
+        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)));
 
         m_seqManager->panic();
 
@@ -7678,7 +7678,7 @@ RosegardenGUIApp::slotPopulateTrackInstrumentPopup()
 
     Instrument* instrument = m_doc->getStudio().getInstrumentById(track->getInstrument());
 
-    QPopupMenu* popup = dynamic_cast<QPopupMenu*>(factory()->container("set_track_instrument", this));
+    TQPopupMenu* popup = dynamic_cast<TQPopupMenu*>(factory()->container("set_track_instrument", this));
 
     m_view->getTrackEditor()->getTrackButtons()->populateInstrumentPopup(instrument, popup);
 }
@@ -7689,11 +7689,11 @@ RosegardenGUIApp::slotRemapInstruments()
     RG_DEBUG << "RosegardenGUIApp::slotRemapInstruments\n";
     RemapInstrumentDialog dialog(this, m_doc);
 
-    connect(&dialog, SIGNAL(applyClicked()),
+    connect(&dialog, TQT_SIGNAL(applyClicked()),
             m_view->getTrackEditor()->getTrackButtons(),
-            SLOT(slotSynchroniseWithComposition()));
+            TQT_SLOT(slotSynchroniseWithComposition()));
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         RG_DEBUG << "slotRemapInstruments - accepted\n";
     }
 
@@ -7712,20 +7712,20 @@ RosegardenGUIApp::slotSaveDefaultStudio()
 
     KTmpStatusMsg msg(i18n("Saving current document as default studio..."), this);
 
-    QString autoloadFile = ::locateLocal("appdata", "autoload.rg");
+    TQString autoloadFile = ::locateLocal("appdata", "autoload.rg");
 
     RG_DEBUG << "RosegardenGUIApp::slotSaveDefaultStudio : saving studio in "
     << autoloadFile << endl;
 
     SetWaitCursor waitCursor;
-    QString errMsg;
+    TQString errMsg;
     bool res = m_doc->saveDocument(autoloadFile, errMsg);
     if (!res) {
         if (errMsg)
-            KMessageBox::error(this, i18n(QString("Could not auto-save document at %1\nError was : %2")
+            KMessageBox::error(this, i18n(TQString("Could not auto-save document at %1\nError was : %2")
                                           .arg(autoloadFile).arg(errMsg)));
         else
-            KMessageBox::error(this, i18n(QString("Could not auto-save document at %1")
+            KMessageBox::error(this, i18n(TQString("Could not auto-save document at %1")
                                           .arg(autoloadFile)));
 
     }
@@ -7740,10 +7740,10 @@ RosegardenGUIApp::slotImportDefaultStudio()
     if (reply != KMessageBox::Yes)
         return ;
 
-    QString autoloadFile =
+    TQString autoloadFile =
         KGlobal::dirs()->findResource("appdata", "autoload.rg");
 
-    QFileInfo autoloadFileInfo(autoloadFile);
+    TQFileInfo autoloadFileInfo(autoloadFile);
 
     if (!autoloadFileInfo.isReadable()) {
         RG_DEBUG << "RosegardenGUIDoc::slotImportDefaultStudio - "
@@ -7759,8 +7759,8 @@ RosegardenGUIApp::slotImportStudio()
 {
     RG_DEBUG << "RosegardenGUIApp::slotImportStudio()\n";
 
-    QString studioDir = KGlobal::dirs()->findResource("appdata", "library/");
-    QDir dir(studioDir);
+    TQString studioDir = KGlobal::dirs()->findResource("appdata", "library/");
+    TQDir dir(studioDir);
     if (!dir.exists()) {
         studioDir = ":ROSEGARDENDEVICE";
     } else {
@@ -7775,7 +7775,7 @@ RosegardenGUIApp::slotImportStudio()
     if (url.isEmpty())
         return ;
 
-    QString target;
+    TQString target;
     if (KIO::NetAccess::download(url, target, this) == false) {
         KMessageBox::error(this, i18n("Cannot download file %1")
                            .arg(url.prettyURL()));
@@ -7786,7 +7786,7 @@ RosegardenGUIApp::slotImportStudio()
 }
 
 void
-RosegardenGUIApp::slotImportStudioFromFile(const QString &file)
+RosegardenGUIApp::slotImportStudioFromFile(const TQString &file)
 {
     RosegardenGUIDoc *doc = new RosegardenGUIDoc(this, 0, true); // skipAutoload
 
@@ -7891,7 +7891,7 @@ RosegardenGUIApp::slotModifyMIDIFilters()
 
     MidiFilterDialog dialog(this, m_doc);
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         RG_DEBUG << "slotModifyMIDIFilters - accepted" << endl;
     }
 }
@@ -7903,7 +7903,7 @@ RosegardenGUIApp::slotManageMetronome()
 
     ManageMetronomeDialog dialog(this, m_doc);
 
-    if (dialog.exec() == QDialog::Accepted) {
+    if (dialog.exec() == TQDialog::Accepted) {
         RG_DEBUG << "slotManageMetronome - accepted" << endl;
     }
 }
@@ -7947,9 +7947,9 @@ RosegardenGUIApp::slotShowTip()
     KTipDialog::showTip(this, locate("data", "rosegarden/tips"), true);
 }
 
-void RosegardenGUIApp::slotShowToolHelp(const QString &s)
+void RosegardenGUIApp::slotShowToolHelp(const TQString &s)
 {
-    QString msg = s;
+    TQString msg = s;
     if (msg != "") msg = " " + msg;
     slotStatusMsg(msg);
 }
@@ -7982,12 +7982,12 @@ RosegardenGUIApp::awaitDialogClearance()
     
     while (haveDialog) {
 
-        const QObjectList *c = children();
+        const TQObjectList *c = children();
         if (!c) return;
 
         haveDialog = false;
-        for (QObjectList::const_iterator i = c->begin(); i != c->end(); ++i) {
-            QDialog *dialog = dynamic_cast<QDialog *>(*i);
+        for (TQObjectList::const_iterator i = c->begin(); i != c->end(); ++i) {
+            TQDialog *dialog = dynamic_cast<TQDialog *>(*i);
             if (dialog && dialog->isVisible()) {
                 haveDialog = true;
                 break;
@@ -8004,7 +8004,7 @@ RosegardenGUIApp::awaitDialogClearance()
 }
 
 void
-RosegardenGUIApp::slotNewerVersionAvailable(QString v)
+RosegardenGUIApp::slotNewerVersionAvailable(TQString v)
 {
     if (m_firstRun) return;
     KStartupLogo::hideIfStillThere();
@@ -8014,7 +8014,7 @@ RosegardenGUIApp::slotNewerVersionAvailable(QString v)
         (this,
          i18n("<h3>Newer version available</h3><p>A newer version of Rosegarden may be available.<br>Please consult the <a href=\"http://www.rosegardenmusic.com/getting/\">Rosegarden website</a> for more information.</p>"),
          i18n("Newer version available"),
-         QString("version-%1-available-show").arg(v),
+         TQString("version-%1-available-show").arg(v),
          KMessageBox::AllowLink);
     CurrentProgressDialog::thaw();
 }