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, 225 insertions, 225 deletions

diff --git a/src/gui/application/RosegardenGUIView.cpp b/src/gui/application/RosegardenGUIView.cpp
index c61b51e..9eb7969 100644
--- a/src/gui/application/RosegardenGUIView.cpp
+++ b/src/gui/application/RosegardenGUIView.cpp
@@ -83,20 +83,20 @@
 #include <kconfig.h>
 #include <kmessagebox.h>
 #include <kprocess.h>
-#include <qapplication.h>
-#include <qcursor.h>
-#include <qdialog.h>
-#include <qfileinfo.h>
-#include <qobject.h>
-#include <qstring.h>
-#include <qvbox.h>
-#include <qwidget.h>
+#include <tqapplication.h>
+#include <tqcursor.h>
+#include <tqdialog.h>
+#include <tqfileinfo.h>
+#include <tqobject.h>
+#include <tqstring.h>
+#include <tqvbox.h>
+#include <tqwidget.h>
 
 
 namespace Rosegarden
 {
 
-// Use this to define the basic unit of the main QCanvas size.
+// Use this to define the basic unit of the main TQCanvas size.
 //
 // This apparently arbitrary figure is what we think is an
 // appropriate width in pixels for a 4/4 bar.  Beware of making it
@@ -106,7 +106,7 @@ namespace Rosegarden
 //
 static double barWidth44 = 100.0;
 
-const QWidget *RosegardenGUIView::m_lastActiveMainWindow = 0;
+const TQWidget *RosegardenGUIView::m_lastActiveMainWindow = 0;
 
 // This is the maximum number of matrix, event view or percussion
 // matrix editors to open in a single operation (not the maximum that
@@ -118,9 +118,9 @@ RosegardenGUIView::RosegardenGUIView(bool showTrackLabels,
                                      SegmentParameterBox* segmentParameterBox,
                                      InstrumentParameterBox* instrumentParameterBox,
                                      TrackParameterBox* trackParameterBox,
-                                     QWidget *parent,
+                                     TQWidget *parent,
                                      const char* /*name*/)
-        : QVBox(parent),
+        : TQVBox(parent),
         m_rulerScale(0),
         m_trackEditor(0),
         m_segmentParameterBox(segmentParameterBox),
@@ -141,91 +141,91 @@ RosegardenGUIView::RosegardenGUIView(bool showTrackLabels,
                                     m_rulerScale, showTrackLabels, unitsPerPixel, this /*hbox*/);
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(editSegment(Segment*)),
-            SLOT(slotEditSegment(Segment*)));
+            TQT_SIGNAL(editSegment(Segment*)),
+            TQT_SLOT(slotEditSegment(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(editSegmentNotation(Segment*)),
-            SLOT(slotEditSegmentNotation(Segment*)));
+            TQT_SIGNAL(editSegmentNotation(Segment*)),
+            TQT_SLOT(slotEditSegmentNotation(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(editSegmentMatrix(Segment*)),
-            SLOT(slotEditSegmentMatrix(Segment*)));
+            TQT_SIGNAL(editSegmentMatrix(Segment*)),
+            TQT_SLOT(slotEditSegmentMatrix(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(editSegmentAudio(Segment*)),
-            SLOT(slotEditSegmentAudio(Segment*)));
+            TQT_SIGNAL(editSegmentAudio(Segment*)),
+            TQT_SLOT(slotEditSegmentAudio(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(audioSegmentAutoSplit(Segment*)),
-            SLOT(slotSegmentAutoSplit(Segment*)));
+            TQT_SIGNAL(audioSegmentAutoSplit(Segment*)),
+            TQT_SLOT(slotSegmentAutoSplit(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(editSegmentEventList(Segment*)),
-            SLOT(slotEditSegmentEventList(Segment*)));
+            TQT_SIGNAL(editSegmentEventList(Segment*)),
+            TQT_SLOT(slotEditSegmentEventList(Segment*)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(editRepeat(Segment*, timeT)),
-            SLOT(slotEditRepeat(Segment*, timeT)));
+            TQT_SIGNAL(editRepeat(Segment*, timeT)),
+            TQT_SLOT(slotEditRepeat(Segment*, timeT)));
 
     connect(m_trackEditor->getSegmentCanvas(),
-            SIGNAL(setPointerPosition(timeT)),
-            doc, SLOT(slotSetPointerPosition(timeT)));
+            TQT_SIGNAL(setPointerPosition(timeT)),
+            doc, TQT_SLOT(slotSetPointerPosition(timeT)));
 
     connect(m_trackEditor,
-            SIGNAL(droppedDocument(QString)),
+            TQT_SIGNAL(droppedDocument(TQString)),
             parent,
-            SLOT(slotOpenDroppedURL(QString)));
+            TQT_SLOT(slotOpenDroppedURL(TQString)));
 
     connect(m_trackEditor,
-            SIGNAL(droppedAudio(QString)),
+            TQT_SIGNAL(droppedAudio(TQString)),
             this,
-            SLOT(slotDroppedAudio(QString)));
+            TQT_SLOT(slotDroppedAudio(TQString)));
 
     connect(m_trackEditor,
-            SIGNAL(droppedNewAudio(QString)),
+            TQT_SIGNAL(droppedNewAudio(TQString)),
             this,
-            SLOT(slotDroppedNewAudio(QString)));
+            TQT_SLOT(slotDroppedNewAudio(TQString)));
 
     connect(m_instrumentParameterBox,
-            SIGNAL(changeInstrumentLabel(InstrumentId, QString)),
+            TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
             this,
-            SLOT(slotChangeInstrumentLabel(InstrumentId, QString)));
+            TQT_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
 
     connect(m_instrumentParameterBox,
-            SIGNAL(changeInstrumentLabel(InstrumentId, QString)),
+            TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
             m_trackParameterBox,
-            SLOT(slotInstrumentLabelChanged(InstrumentId, QString)));
+            TQT_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
 
     connect(m_trackEditor->getTrackButtons(),
-            SIGNAL(nameChanged()),
+            TQT_SIGNAL(nameChanged()),
             m_trackParameterBox,
-            SLOT(slotSelectedTrackNameChanged()));
+            TQT_SLOT(slotSelectedTrackNameChanged()));
 
     connect(m_trackEditor->getTrackButtons(),
-            SIGNAL(instrumentSelected(int)),
+            TQT_SIGNAL(instrumentSelected(int)),
             m_trackParameterBox,
-            SLOT(slotUpdateControls(int)));
+            TQT_SLOT(slotUpdateControls(int)));
 
     connect(m_trackParameterBox,
-            SIGNAL(instrumentSelected(TrackId, int)),
+            TQT_SIGNAL(instrumentSelected(TrackId, int)),
             m_trackEditor->getTrackButtons(),
-            SLOT(slotTrackInstrumentSelection(TrackId, int)));
+            TQT_SLOT(slotTrackInstrumentSelection(TrackId, int)));
 
-    connect(this, SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
-            this, SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
+    connect(this, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
+            this, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
 
     if (doc) {
         /* signal no longer exists
-        	connect(doc, SIGNAL(recordingSegmentUpdated(Segment *,
+        	connect(doc, TQT_SIGNAL(recordingSegmentUpdated(Segment *,
         						    timeT)),
-        		this, SLOT(slotUpdateRecordingSegment(Segment *,
+        		this, TQT_SLOT(slotUpdateRecordingSegment(Segment *,
         						      timeT)));
         */
 
-        QObject::connect
-        (getCommandHistory(), SIGNAL(commandExecuted()),
-         m_trackEditor->getSegmentCanvas(), SLOT(slotUpdateSegmentsDrawBuffer()));
+        TQObject::connect
+        (getCommandHistory(), TQT_SIGNAL(commandExecuted()),
+         m_trackEditor->getSegmentCanvas(), TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
     }
 }
 
@@ -274,7 +274,7 @@ void RosegardenGUIView::print(Composition* p, bool previewOnly)
     delete notationView;
 }
 
-void RosegardenGUIView::selectTool(const QString toolName)
+void RosegardenGUIView::selectTool(const TQString toolName)
 {
     m_trackEditor->getSegmentCanvas()->slotSetTool(toolName);
 }
@@ -298,10 +298,10 @@ void RosegardenGUIView::updateSelectionContents()
 
 /* hjj: WHAT DO DO WITH THIS ?
 void
-RosegardenGUIView::slotEditMetadata(QString name)
+RosegardenGUIView::slotEditMetadata(TQString name)
 {
-    const QWidget *ww = dynamic_cast<const QWidget *>(sender());
-    QWidget *w = const_cast<QWidget *>(ww);
+    const TQWidget *ww = dynamic_cast<const TQWidget *>(sender());
+    TQWidget *w = const_cast<TQWidget *>(ww);
 
     DocumentConfigureDialog *configDlg =
         new DocumentConfigureDialog(getDocument(), w ? w : this);
@@ -457,77 +457,77 @@ RosegardenGUIView::createNotationView(std::vector<Segment *> segmentsToEdit)
     // For tempo changes (ugh -- it'd be nicer to make a tempo change
     // command that could interpret all this stuff from the dialog)
     //
-    connect(notationView, SIGNAL(changeTempo(timeT,
+    connect(notationView, TQT_SIGNAL(changeTempo(timeT,
                                  tempoT,
                                  tempoT,
                                  TempoDialog::TempoDialogAction)),
-            RosegardenGUIApp::self(), SLOT(slotChangeTempo(timeT,
+            RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
                                            tempoT,
                                            tempoT,
                                            TempoDialog::TempoDialogAction)));
 
 
-    connect(notationView, SIGNAL(windowActivated()),
-            this, SLOT(slotActiveMainWindowChanged()));
-
-    connect(notationView, SIGNAL(selectTrack(int)),
-            this, SLOT(slotSelectTrackSegments(int)));
-
-    connect(notationView, SIGNAL(play()),
-            RosegardenGUIApp::self(), SLOT(slotPlay()));
-    connect(notationView, SIGNAL(stop()),
-            RosegardenGUIApp::self(), SLOT(slotStop()));
-    connect(notationView, SIGNAL(fastForwardPlayback()),
-            RosegardenGUIApp::self(), SLOT(slotFastforward()));
-    connect(notationView, SIGNAL(rewindPlayback()),
-            RosegardenGUIApp::self(), SLOT(slotRewind()));
-    connect(notationView, SIGNAL(fastForwardPlaybackToEnd()),
-            RosegardenGUIApp::self(), SLOT(slotFastForwardToEnd()));
-    connect(notationView, SIGNAL(rewindPlaybackToBeginning()),
-            RosegardenGUIApp::self(), SLOT(slotRewindToBeginning()));
-    connect(notationView, SIGNAL(panic()),
-            RosegardenGUIApp::self(), SLOT(slotPanic()));
-
-    connect(notationView, SIGNAL(saveFile()),
-            RosegardenGUIApp::self(), SLOT(slotFileSave()));
-    connect(notationView, SIGNAL(jumpPlaybackTo(timeT)),
-            getDocument(), SLOT(slotSetPointerPosition(timeT)));
-    connect(notationView, SIGNAL(openInNotation(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
-    connect(notationView, SIGNAL(openInMatrix(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
-    connect(notationView, SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
-    connect(notationView, SIGNAL(openInEventList(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
+    connect(notationView, TQT_SIGNAL(windowActivated()),
+            this, TQT_SLOT(slotActiveMainWindowChanged()));
+
+    connect(notationView, TQT_SIGNAL(selectTrack(int)),
+            this, TQT_SLOT(slotSelectTrackSegments(int)));
+
+    connect(notationView, TQT_SIGNAL(play()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
+    connect(notationView, TQT_SIGNAL(stop()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
+    connect(notationView, TQT_SIGNAL(fastForwardPlayback()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
+    connect(notationView, TQT_SIGNAL(rewindPlayback()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
+    connect(notationView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
+    connect(notationView, TQT_SIGNAL(rewindPlaybackToBeginning()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
+    connect(notationView, TQT_SIGNAL(panic()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
+
+    connect(notationView, TQT_SIGNAL(saveFile()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
+    connect(notationView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
+            getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
+    connect(notationView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
+    connect(notationView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
+    connect(notationView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
+    connect(notationView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
 /* hjj: WHAT DO DO WITH THIS ?
-    connect(notationView, SIGNAL(editMetadata(QString)),
-            this, SLOT(slotEditMetadata(QString)));
+    connect(notationView, TQT_SIGNAL(editMetadata(TQString)),
+            this, TQT_SLOT(slotEditMetadata(TQString)));
 */
-    connect(notationView, SIGNAL(editTriggerSegment(int)),
-            this, SLOT(slotEditTriggerSegment(int)));
-    connect(notationView, SIGNAL(staffLabelChanged(TrackId, QString)),
-            this, SLOT(slotChangeTrackLabel(TrackId, QString)));
-    connect(notationView, SIGNAL(toggleSolo(bool)),
-            RosegardenGUIApp::self(), SLOT(slotToggleSolo(bool)));
-    connect(notationView, SIGNAL(editTimeSignature(timeT)),
-            RosegardenGUIApp::self(), SLOT(slotEditTempos(timeT)));
+    connect(notationView, TQT_SIGNAL(editTriggerSegment(int)),
+            this, TQT_SLOT(slotEditTriggerSegment(int)));
+    connect(notationView, TQT_SIGNAL(staffLabelChanged(TrackId, TQString)),
+            this, TQT_SLOT(slotChangeTrackLabel(TrackId, TQString)));
+    connect(notationView, TQT_SIGNAL(toggleSolo(bool)),
+            RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
+    connect(notationView, TQT_SIGNAL(editTimeSignature(timeT)),
+            RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
 
     SequenceManager *sM = getDocument()->getSequenceManager();
 
-    connect(sM, SIGNAL(insertableNoteOnReceived(int, int)),
-            notationView, SLOT(slotInsertableNoteOnReceived(int, int)));
-    connect(sM, SIGNAL(insertableNoteOffReceived(int, int)),
-            notationView, SLOT(slotInsertableNoteOffReceived(int, int)));
+    connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
+            notationView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
+    connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
+            notationView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
 
-    connect(notationView, SIGNAL(stepByStepTargetRequested(QObject *)),
-            this, SIGNAL(stepByStepTargetRequested(QObject *)));
-    connect(this, SIGNAL(stepByStepTargetRequested(QObject *)),
-            notationView, SLOT(slotStepByStepTargetRequested(QObject *)));
-    connect(RosegardenGUIApp::self(), SIGNAL(compositionStateUpdate()),
-            notationView, SLOT(slotCompositionStateUpdate()));
-    connect(this, SIGNAL(compositionStateUpdate()),
-            notationView, SLOT(slotCompositionStateUpdate()));
+    connect(notationView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
+    connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            notationView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
+    connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
+            notationView, TQT_SLOT(slotCompositionStateUpdate()));
+    connect(this, TQT_SIGNAL(compositionStateUpdate()),
+            notationView, TQT_SLOT(slotCompositionStateUpdate()));
 
     // Encourage the notation view window to open to the same
     // interval as the current segment view
@@ -659,73 +659,73 @@ RosegardenGUIView::createMatrixView(std::vector<Segment *> segmentsToEdit, bool
     // For tempo changes (ugh -- it'd be nicer to make a tempo change
     // command that could interpret all this stuff from the dialog)
     //
-    connect(matrixView, SIGNAL(changeTempo(timeT,
+    connect(matrixView, TQT_SIGNAL(changeTempo(timeT,
                                            tempoT,
                                            tempoT,
                                            TempoDialog::TempoDialogAction)),
-            RosegardenGUIApp::self(), SLOT(slotChangeTempo(timeT,
+            RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
                                            tempoT,
                                            tempoT,
                                            TempoDialog::TempoDialogAction)));
 
-    connect(matrixView, SIGNAL(windowActivated()),
-            this, SLOT(slotActiveMainWindowChanged()));
-
-    connect(matrixView, SIGNAL(selectTrack(int)),
-            this, SLOT(slotSelectTrackSegments(int)));
-
-    connect(matrixView, SIGNAL(play()),
-            RosegardenGUIApp::self(), SLOT(slotPlay()));
-    connect(matrixView, SIGNAL(stop()),
-            RosegardenGUIApp::self(), SLOT(slotStop()));
-    connect(matrixView, SIGNAL(fastForwardPlayback()),
-            RosegardenGUIApp::self(), SLOT(slotFastforward()));
-    connect(matrixView, SIGNAL(rewindPlayback()),
-            RosegardenGUIApp::self(), SLOT(slotRewind()));
-    connect(matrixView, SIGNAL(fastForwardPlaybackToEnd()),
-            RosegardenGUIApp::self(), SLOT(slotFastForwardToEnd()));
-    connect(matrixView, SIGNAL(rewindPlaybackToBeginning()),
-            RosegardenGUIApp::self(), SLOT(slotRewindToBeginning()));
-    connect(matrixView, SIGNAL(panic()),
-            RosegardenGUIApp::self(), SLOT(slotPanic()));
-
-    connect(matrixView, SIGNAL(saveFile()),
-            RosegardenGUIApp::self(), SLOT(slotFileSave()));
-    connect(matrixView, SIGNAL(jumpPlaybackTo(timeT)),
-            getDocument(), SLOT(slotSetPointerPosition(timeT)));
-    connect(matrixView, SIGNAL(openInNotation(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
-    connect(matrixView, SIGNAL(openInMatrix(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
-    connect(matrixView, SIGNAL(openInEventList(std::vector<Segment *>)),
-            this, SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
-    connect(matrixView, SIGNAL(editTriggerSegment(int)),
-            this, SLOT(slotEditTriggerSegment(int)));
-    connect(matrixView, SIGNAL(toggleSolo(bool)),
-            RosegardenGUIApp::self(), SLOT(slotToggleSolo(bool)));
-    connect(matrixView, SIGNAL(editTimeSignature(timeT)),
-            RosegardenGUIApp::self(), SLOT(slotEditTempos(timeT)));
+    connect(matrixView, TQT_SIGNAL(windowActivated()),
+            this, TQT_SLOT(slotActiveMainWindowChanged()));
+
+    connect(matrixView, TQT_SIGNAL(selectTrack(int)),
+            this, TQT_SLOT(slotSelectTrackSegments(int)));
+
+    connect(matrixView, TQT_SIGNAL(play()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
+    connect(matrixView, TQT_SIGNAL(stop()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
+    connect(matrixView, TQT_SIGNAL(fastForwardPlayback()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
+    connect(matrixView, TQT_SIGNAL(rewindPlayback()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
+    connect(matrixView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
+    connect(matrixView, TQT_SIGNAL(rewindPlaybackToBeginning()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
+    connect(matrixView, TQT_SIGNAL(panic()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
+
+    connect(matrixView, TQT_SIGNAL(saveFile()),
+            RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
+    connect(matrixView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
+            getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
+    connect(matrixView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
+    connect(matrixView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
+    connect(matrixView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
+            this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
+    connect(matrixView, TQT_SIGNAL(editTriggerSegment(int)),
+            this, TQT_SLOT(slotEditTriggerSegment(int)));
+    connect(matrixView, TQT_SIGNAL(toggleSolo(bool)),
+            RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
+    connect(matrixView, TQT_SIGNAL(editTimeSignature(timeT)),
+            RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
 
     SequenceManager *sM = getDocument()->getSequenceManager();
 
-    connect(sM, SIGNAL(insertableNoteOnReceived(int, int)),
-            matrixView, SLOT(slotInsertableNoteOnReceived(int, int)));
-    connect(sM, SIGNAL(insertableNoteOffReceived(int, int)),
-            matrixView, SLOT(slotInsertableNoteOffReceived(int, int)));
-
-    connect(matrixView, SIGNAL(stepByStepTargetRequested(QObject *)),
-            this, SIGNAL(stepByStepTargetRequested(QObject *)));
-    connect(this, SIGNAL(stepByStepTargetRequested(QObject *)),
-            matrixView, SLOT(slotStepByStepTargetRequested(QObject *)));
-    connect(RosegardenGUIApp::self(), SIGNAL(compositionStateUpdate()),
-            matrixView, SLOT(slotCompositionStateUpdate()));
-    connect(this, SIGNAL(compositionStateUpdate()),
-            matrixView, SLOT(slotCompositionStateUpdate()));
+    connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
+            matrixView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
+    connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
+            matrixView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
+
+    connect(matrixView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
+    connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
+            matrixView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
+    connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
+            matrixView, TQT_SLOT(slotCompositionStateUpdate()));
+    connect(this, TQT_SIGNAL(compositionStateUpdate()),
+            matrixView, TQT_SLOT(slotCompositionStateUpdate()));
     connect(this,
-            SIGNAL(instrumentLevelsChanged(InstrumentId,
+            TQT_SIGNAL(instrumentLevelsChanged(InstrumentId,
                                            const LevelInfo &)),
             matrixView,
-            SLOT(slotInstrumentLevelsChanged(InstrumentId,
+            TQT_SLOT(slotInstrumentLevelsChanged(InstrumentId,
                                              const LevelInfo &)));
 
     // Encourage the matrix view window to open to the same
@@ -817,7 +817,7 @@ void RosegardenGUIView::slotSegmentAutoSplit(Segment *segment)
 {
     AudioSplitDialog aSD(this, segment, getDocument());
 
-    if (aSD.exec() == QDialog::Accepted) {
+    if (aSD.exec() == TQDialog::Accepted) {
         KCommand *command =
             new AudioSegmentAutoSplitCommand(getDocument(),
                                              segment, aSD.getThreshold());
@@ -833,13 +833,13 @@ void RosegardenGUIView::slotEditSegmentAudio(Segment *segment)
     KConfig* config = kapp->config();
     config->setGroup(GeneralOptionsConfigGroup);
 
-    QString application = config->readEntry("externalaudioeditor", "");
+    TQString application = config->readEntry("externalaudioeditor", "");
 
     if (application == "") {
         application = AudioConfigurationPage::getBestAvailableAudioEditor();
     }
 
-    QStringList splitCommand = QStringList::split(" ", application);
+    TQStringList splitCommand = TQStringList::split(" ", application);
 
     if (splitCommand.size() == 0) {
 
@@ -853,7 +853,7 @@ void RosegardenGUIView::slotEditSegmentAudio(Segment *segment)
         return ;
     }
 
-    QFileInfo *appInfo = new QFileInfo(splitCommand[0]);
+    TQFileInfo *appInfo = new TQFileInfo(splitCommand[0]);
     if (appInfo->exists() == false || appInfo->isExecutable() == false) {
         std::cerr << "RosegardenGUIView::slotEditSegmentAudio() - "
                   << "can't execute \"" << splitCommand[0] << "\""
@@ -870,13 +870,13 @@ void RosegardenGUIView::slotEditSegmentAudio(Segment *segment)
     }
 
     // wait cursor
-    QApplication::setOverrideCursor(QCursor(Qt::waitCursor));
+    TQApplication::setOverrideCursor(TQCursor(Qt::waitCursor));
 
     // Prepare the process
     //
     KProcess *process = new KProcess();
     (*process) << splitCommand;
-    (*process) << QString(aF->getFilename().c_str());
+    (*process) << TQString(aF->getFilename().c_str());
 
     // Start it
     //
@@ -886,7 +886,7 @@ void RosegardenGUIView::slotEditSegmentAudio(Segment *segment)
     }
 
     // restore cursor
-    QApplication::restoreOverrideCursor();
+    TQApplication::restoreOverrideCursor();
 
 }
 
@@ -1371,14 +1371,14 @@ RosegardenGUIView::slotAddCommandToHistory(KCommand *command)
 
 void
 RosegardenGUIView::slotChangeInstrumentLabel(InstrumentId id,
-        QString label)
+        TQString label)
 {
     m_trackEditor->getTrackButtons()->changeInstrumentLabel(id, label);
 }
 
 void
 RosegardenGUIView::slotChangeTrackLabel(TrackId id,
-                                        QString label)
+                                        TQString label)
 {
     m_trackEditor->getTrackButtons()->changeTrackLabel(id, label);
 }
@@ -1505,11 +1505,11 @@ RosegardenGUIView::slotAddAudioSegmentDefaultPosition(AudioFileId audioFileId,
 }
 
 void
-RosegardenGUIView::slotDroppedNewAudio(QString audioDesc)
+RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
 {
-    QTextIStream s(&audioDesc);
+    TQTextIStream s(&audioDesc);
 
-    QString url;
+    TQString url;
     int trackId;
     timeT time;
     url = s.readLine();
@@ -1545,31 +1545,31 @@ RosegardenGUIView::slotDroppedNewAudio(QString audioDesc)
 
     // Connect the progress dialog
     //
-    connect(&aFM, SIGNAL(setProgress(int)),
-            progressDlg.progressBar(), SLOT(setValue(int)));
-    connect(&aFM, SIGNAL(setOperationName(QString)),
-            &progressDlg, SLOT(slotSetOperationName(QString)));
-    connect(&progressDlg, SIGNAL(cancelClicked()),
-            &aFM, SLOT(slotStopImport()));
+    connect(&aFM, TQT_SIGNAL(setProgress(int)),
+            progressDlg.progressBar(), TQT_SLOT(setValue(int)));
+    connect(&aFM, TQT_SIGNAL(setOperationName(TQString)),
+            &progressDlg, TQT_SLOT(slotSetOperationName(TQString)));
+    connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
+            &aFM, TQT_SLOT(slotStopImport()));
 
     try {
         audioFileId = aFM.importURL(kurl, sampleRate);
     } catch (AudioFileManager::BadAudioPathException e) {
         CurrentProgressDialog::freeze();
-        QString errorString = i18n("Can't add dropped file. ") + strtoqstr(e.getMessage());
+        TQString errorString = i18n("Can't add dropped file. ") + strtoqstr(e.getMessage());
         KMessageBox::sorry(this, errorString);
         return ;
     } catch (SoundFile::BadSoundFileException e) {
         CurrentProgressDialog::freeze();
-        QString errorString = i18n("Can't add dropped file. ") + strtoqstr(e.getMessage());
+        TQString errorString = i18n("Can't add dropped file. ") + strtoqstr(e.getMessage());
         KMessageBox::sorry(this, errorString);
         return ;
     }
              
-    disconnect(&progressDlg, SIGNAL(cancelClicked()),
-               &aFM, SLOT(slotStopImport()));
-    connect(&progressDlg, SIGNAL(cancelClicked()),
-            &aFM, SLOT(slotStopPreview()));
+    disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
+               &aFM, TQT_SLOT(slotStopImport()));
+    connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
+            &aFM, TQT_SLOT(slotStopPreview()));
     progressDlg.progressBar()->show();
     progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
 
@@ -1577,14 +1577,14 @@ RosegardenGUIView::slotDroppedNewAudio(QString audioDesc)
         aFM.generatePreview(audioFileId);
     } catch (Exception e) {
         CurrentProgressDialog::freeze();
-        QString message = strtoqstr(e.getMessage()) + "\n\n" +
+        TQString message = strtoqstr(e.getMessage()) + "\n\n" +
                           i18n("Try copying this file to a directory where you have write permission and re-add it");
         KMessageBox::information(this, message);
         //return false;
     }
 
-    disconnect(&progressDlg, SIGNAL(cancelClicked()),
-               &aFM, SLOT(slotStopPreview()));
+    disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
+               &aFM, TQT_SLOT(slotStopPreview()));
 
     // add the file at the sequencer
     emit addAudioFile(audioFileId);
@@ -1605,9 +1605,9 @@ RosegardenGUIView::slotDroppedNewAudio(QString audioDesc)
 }
 
 void
-RosegardenGUIView::slotDroppedAudio(QString audioDesc)
+RosegardenGUIView::slotDroppedAudio(TQString audioDesc)
 {
-    QTextIStream s(&audioDesc);
+    TQTextIStream s(&audioDesc);
 
     AudioFileId audioFileId;
     TrackId trackId;
@@ -1748,9 +1748,9 @@ RosegardenGUIView::slotUpdateRecordingSegment(Segment *segment,
         return ;
 
     /* signal no longer exists
-        QObject::connect
-    	(getDocument(), SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
-    	 view, SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
+        TQObject::connect
+    	(getDocument(), TQT_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
+    	 view, TQT_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
     */
 
     view->show();
@@ -1781,7 +1781,7 @@ RosegardenGUIView::windowActivationChange(bool)
 }
 
 void
-RosegardenGUIView::slotActiveMainWindowChanged(const QWidget *w)
+RosegardenGUIView::slotActiveMainWindowChanged(const TQWidget *w)
 {
     m_lastActiveMainWindow = w;
 }
@@ -1789,7 +1789,7 @@ RosegardenGUIView::slotActiveMainWindowChanged(const QWidget *w)
 void
 RosegardenGUIView::slotActiveMainWindowChanged()
 {
-    const QWidget *w = dynamic_cast<const QWidget *>(sender());
+    const TQWidget *w = dynamic_cast<const TQWidget *>(sender());
     if (w)
         slotActiveMainWindowChanged(w);
 }
@@ -2000,31 +2000,31 @@ RosegardenGUIView::createEventView(std::vector<Segment *> segmentsToEdit)
                                          segmentsToEdit,
                                          this);
 
-    connect(eventView, SIGNAL(windowActivated()),
-        this, SLOT(slotActiveMainWindowChanged()));
-
-    connect(eventView, SIGNAL(selectTrack(int)),
-            this, SLOT(slotSelectTrackSegments(int)));
-
-    connect(eventView, SIGNAL(saveFile()),
-        RosegardenGUIApp::self(), SLOT(slotFileSave()));
-
-    connect(eventView, SIGNAL(openInNotation(std::vector<Segment *>)),
-        this, SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
-    connect(eventView, SIGNAL(openInMatrix(std::vector<Segment *>)),
-        this, SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
-    connect(eventView, SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
-        this, SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
-    connect(eventView, SIGNAL(openInEventList(std::vector<Segment *>)),
-        this, SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
-    connect(eventView, SIGNAL(editTriggerSegment(int)),
-        this, SLOT(slotEditTriggerSegment(int)));
-    connect(this, SIGNAL(compositionStateUpdate()),
-        eventView, SLOT(slotCompositionStateUpdate()));
-    connect(RosegardenGUIApp::self(), SIGNAL(compositionStateUpdate()),
-        eventView, SLOT(slotCompositionStateUpdate()));
-    connect(eventView, SIGNAL(toggleSolo(bool)),
-            RosegardenGUIApp::self(), SLOT(slotToggleSolo(bool)));
+    connect(eventView, TQT_SIGNAL(windowActivated()),
+        this, TQT_SLOT(slotActiveMainWindowChanged()));
+
+    connect(eventView, TQT_SIGNAL(selectTrack(int)),
+            this, TQT_SLOT(slotSelectTrackSegments(int)));
+
+    connect(eventView, TQT_SIGNAL(saveFile()),
+        RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
+
+    connect(eventView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
+        this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
+    connect(eventView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
+        this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
+    connect(eventView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
+        this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
+    connect(eventView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
+        this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
+    connect(eventView, TQT_SIGNAL(editTriggerSegment(int)),
+        this, TQT_SLOT(slotEditTriggerSegment(int)));
+    connect(this, TQT_SIGNAL(compositionStateUpdate()),
+        eventView, TQT_SLOT(slotCompositionStateUpdate()));
+    connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
+        eventView, TQT_SLOT(slotCompositionStateUpdate()));
+    connect(eventView, TQT_SIGNAL(toggleSolo(bool)),
+            RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
 
     // create keyboard accelerators on view
     //