TDE
/
rosegarden
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/rosegarden
0
0
Fork 0
Code Issues Releases Wiki Activity

Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit e9f46130c2)
r14.1.x
Michele Calgaro 11 months ago
parent 0d651f25b2
commit a3a855ce18
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
123 changed files with 2386 additions and 2386 deletions
Show Stats Download Patch File Download Diff File

16
src/commands/segment/AudioSegmentRescaleCommand.cpp
Unescape View File

@ -90,19 +90,19 @@ AudioSegmentRescaleCommand::~AudioSegmentRescaleCommand()
void
AudioSegmentRescaleCommand::connectProgressDialog(ProgressDialog *dlg)
{
TQObject::connect(m_stretcher, TQT_SIGNAL(setProgress(int)),
dlg->progressBar(), TQT_SLOT(setValue(int)));
TQObject::connect(dlg, TQT_SIGNAL(cancelClicked()),
m_stretcher, TQT_SLOT(slotStopTimestretch()));
TQObject::connect(m_stretcher, TQ_SIGNAL(setProgress(int)),
dlg->progressBar(), TQ_SLOT(setValue(int)));
TQObject::connect(dlg, TQ_SIGNAL(cancelClicked()),
m_stretcher, TQ_SLOT(slotStopTimestretch()));
}
void
AudioSegmentRescaleCommand::disconnectProgressDialog(ProgressDialog *dlg)
{
TQObject::disconnect(m_stretcher, TQT_SIGNAL(setProgress(int)),
dlg->progressBar(), TQT_SLOT(setValue(int)));
TQObject::disconnect(dlg, TQT_SIGNAL(cancelClicked()),
m_stretcher, TQT_SLOT(slotStopTimestretch()));
TQObject::disconnect(m_stretcher, TQ_SIGNAL(setProgress(int)),
dlg->progressBar(), TQ_SLOT(setValue(int)));
TQObject::disconnect(dlg, TQ_SIGNAL(cancelClicked()),
m_stretcher, TQ_SLOT(slotStopTimestretch()));
}
void

24
src/document/MultiViewCommandHistory.cpp
Unescape View File

@ -73,40 +73,40 @@ MultiViewCommandHistory::attachView(TDEActionCollection *collection)
TDEToolBarPopupAction *undo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Undo)));
if (undo) {
connect(undo, TQT_SIGNAL(activated()),
this, TQT_SLOT(slotUndo()));
connect(undo, TQ_SIGNAL(activated()),
this, TQ_SLOT(slotUndo()));
connect
(undo->popupMenu(),
TQT_SIGNAL(aboutToShow()),
TQ_SIGNAL(aboutToShow()),
this,
TQT_SLOT(slotUndoAboutToShow()));
TQ_SLOT(slotUndoAboutToShow()));
connect
(undo->popupMenu(),
TQT_SIGNAL(activated(int)),
TQ_SIGNAL(activated(int)),
this,
TQT_SLOT(slotUndoActivated(int)));
TQ_SLOT(slotUndoActivated(int)));
}
TDEToolBarPopupAction *redo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Redo)));
if (redo) {
connect(redo, TQT_SIGNAL(activated()),
this, TQT_SLOT(slotRedo()));
connect(redo, TQ_SIGNAL(activated()),
this, TQ_SLOT(slotRedo()));
connect
(redo->popupMenu(),
TQT_SIGNAL(aboutToShow()),
TQ_SIGNAL(aboutToShow()),
this,
TQT_SLOT(slotRedoAboutToShow()));
TQ_SLOT(slotRedoAboutToShow()));
connect
(redo->popupMenu(),
TQT_SIGNAL(activated(int)),
TQ_SIGNAL(activated(int)),
this,
TQT_SLOT(slotRedoActivated(int)));
TQ_SLOT(slotRedoActivated(int)));
}
m_views.insert(collection);

40
src/document/RosegardenGUIDoc.cpp
Unescape View File

@ -135,11 +135,11 @@ RosegardenGUIDoc::RosegardenGUIDoc(TQWidget *parent,
m_viewList.setAutoDelete(false);
m_editViewList.setAutoDelete(false);
connect(m_commandHistory, TQT_SIGNAL(commandExecuted(KCommand *)),
this, TQT_SLOT(slotDocumentModified()));
connect(m_commandHistory, TQ_SIGNAL(commandExecuted(KCommand *)),
this, TQ_SLOT(slotDocumentModified()));
connect(m_commandHistory, TQT_SIGNAL(documentRestored()),
this, TQT_SLOT(slotDocumentRestored()));
connect(m_commandHistory, TQ_SIGNAL(documentRestored()),
this, TQ_SLOT(slotDocumentRestored()));
// autoload a new document
if (!skipAutoload)
@ -584,8 +584,8 @@ bool RosegardenGUIDoc::openDocument(const TQString& filename,
100,
(TQWidget*)parent());
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&m_audioFileManager, TQT_SLOT(slotStopPreview()));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&m_audioFileManager, TQ_SLOT(slotStopPreview()));
progressDlg.setMinimumDuration(500);
progressDlg.setAutoReset(true); // we're re-using it for the preview generation
@ -686,8 +686,8 @@ bool RosegardenGUIDoc::openDocument(const TQString& filename,
// reuse the previous one
progressDlg.setLabel(i18n("Generating audio previews..."));
connect(&m_audioFileManager, TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&m_audioFileManager, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
try {
// generate any audio previews after loading the files
m_audioFileManager.generatePreviews();
@ -1575,14 +1575,14 @@ RosegardenGUIDoc::xmlParse(TQString fileContents, TQString &errMsg,
RoseXmlHandler handler(this, elementCount, permanent);
if (progress) {
connect(&handler, TQT_SIGNAL(setProgress(int)),
progress->progressBar(), TQT_SLOT(setValue(int)));
connect(&handler, TQT_SIGNAL(setOperationName(TQString)),
progress, TQT_SLOT(slotSetOperationName(TQString)));
connect(&handler, TQT_SIGNAL(incrementProgress(int)),
progress->progressBar(), TQT_SLOT(advance(int)));
connect(progress, TQT_SIGNAL(cancelClicked()),
&handler, TQT_SLOT(slotCancel()));
connect(&handler, TQ_SIGNAL(setProgress(int)),
progress->progressBar(), TQ_SLOT(setValue(int)));
connect(&handler, TQ_SIGNAL(setOperationName(TQString)),
progress, TQ_SLOT(slotSetOperationName(TQString)));
connect(&handler, TQ_SIGNAL(incrementProgress(int)),
progress->progressBar(), TQ_SLOT(advance(int)));
connect(progress, TQ_SIGNAL(cancelClicked()),
&handler, TQ_SLOT(slotCancel()));
}
TQXmlInputSource source;
@ -2789,11 +2789,11 @@ RosegardenGUIDoc::finalizeAudioFile(InstrumentId iid)
progressDlg->setAutoReset(false);
progressDlg->show();
connect(progressDlg, TQT_SIGNAL(cancelClicked()),
&m_audioFileManager, TQT_SLOT(slotStopPreview()));
connect(progressDlg, TQ_SIGNAL(cancelClicked()),
&m_audioFileManager, TQ_SLOT(slotStopPreview()));
connect(&m_audioFileManager, TQT_SIGNAL(setProgress(int)),
progressDlg->progressBar(), TQT_SLOT(setValue(int)));
connect(&m_audioFileManager, TQ_SIGNAL(setProgress(int)),
progressDlg->progressBar(), TQ_SLOT(setValue(int)));
try {
m_audioFileManager.generatePreview(newAudioFile->getId());

2
src/gui/application/LircClient.cpp
Unescape View File

@ -61,7 +61,7 @@ LircClient::LircClient(void)
}
m_socketNotifier = new TQSocketNotifier(m_socket, TQSocketNotifier::Read, 0);
connect(m_socketNotifier, TQT_SIGNAL(activated(int)), this, TQT_SLOT(readButton()) );
connect(m_socketNotifier, TQ_SIGNAL(activated(int)), this, TQ_SLOT(readButton()) );
RG_DEBUG << "LircClient::LircClient: connected to socket: " << m_socket << endl;
}

54
src/gui/application/LircCommander.cpp
Unescape View File

@ -45,33 +45,33 @@ LircCommander::LircCommander(LircClient *lirc, RosegardenGUIApp *rgGUIApp)
{
m_lirc = lirc;
m_rgGUIApp = rgGUIApp;
connect(m_lirc, TQT_SIGNAL(buttonPressed(char *)),
this, TQT_SLOT(slotExecute(char *)) );
connect(this, TQT_SIGNAL(play()),
m_rgGUIApp, TQT_SLOT(slotPlay()) );
connect(this, TQT_SIGNAL(stop()),
m_rgGUIApp, TQT_SLOT(slotStop()) );
connect(this, TQT_SIGNAL(record()),
m_rgGUIApp, TQT_SLOT(slotRecord()) );
connect(this, TQT_SIGNAL(rewind()),
m_rgGUIApp, TQT_SLOT(slotRewind()) );
connect(this, TQT_SIGNAL(rewindToBeginning()),
m_rgGUIApp, TQT_SLOT(slotRewindToBeginning()) );
connect(this, TQT_SIGNAL(fastForward()),
m_rgGUIApp, TQT_SLOT(slotFastforward()) );
connect(this, TQT_SIGNAL(fastForwardToEnd()),
m_rgGUIApp, TQT_SLOT(slotFastForwardToEnd()) );
connect(this, TQT_SIGNAL(toggleRecord()),
m_rgGUIApp, TQT_SLOT(slotToggleRecord()) );
connect(this, TQT_SIGNAL(trackDown()),
m_rgGUIApp, TQT_SLOT(slotTrackDown()) );
connect(this, TQT_SIGNAL(trackUp()),
m_rgGUIApp, TQT_SLOT(slotTrackUp()) );
connect(this, TQT_SIGNAL(trackMute()),
m_rgGUIApp, TQT_SLOT(slotToggleMutedCurrentTrack()) );
connect(this, TQT_SIGNAL(trackRecord()),
m_rgGUIApp, TQT_SLOT(slotToggleRecordCurrentTrack()) );
connect(m_lirc, TQ_SIGNAL(buttonPressed(char *)),
this, TQ_SLOT(slotExecute(char *)) );
connect(this, TQ_SIGNAL(play()),
m_rgGUIApp, TQ_SLOT(slotPlay()) );
connect(this, TQ_SIGNAL(stop()),
m_rgGUIApp, TQ_SLOT(slotStop()) );
connect(this, TQ_SIGNAL(record()),
m_rgGUIApp, TQ_SLOT(slotRecord()) );
connect(this, TQ_SIGNAL(rewind()),
m_rgGUIApp, TQ_SLOT(slotRewind()) );
connect(this, TQ_SIGNAL(rewindToBeginning()),
m_rgGUIApp, TQ_SLOT(slotRewindToBeginning()) );
connect(this, TQ_SIGNAL(fastForward()),
m_rgGUIApp, TQ_SLOT(slotFastforward()) );
connect(this, TQ_SIGNAL(fastForwardToEnd()),
m_rgGUIApp, TQ_SLOT(slotFastForwardToEnd()) );
connect(this, TQ_SIGNAL(toggleRecord()),
m_rgGUIApp, TQ_SLOT(slotToggleRecord()) );
connect(this, TQ_SIGNAL(trackDown()),
m_rgGUIApp, TQ_SLOT(slotTrackDown()) );
connect(this, TQ_SIGNAL(trackUp()),
m_rgGUIApp, TQ_SLOT(slotTrackUp()) );
connect(this, TQ_SIGNAL(trackMute()),
m_rgGUIApp, TQ_SLOT(slotToggleMutedCurrentTrack()) );
connect(this, TQ_SIGNAL(trackRecord()),
m_rgGUIApp, TQ_SLOT(slotToggleRecordCurrentTrack()) );
}
LircCommander::command LircCommander::commands[] =

960
src/gui/application/RosegardenGUIApp.cpp
View File

File diff suppressed because it is too large Load Diff

376
src/gui/application/RosegardenGUIView.cpp
Unescape View File

@ -139,91 +139,91 @@ RosegardenGUIView::RosegardenGUIView(bool showTrackLabels,
m_rulerScale, showTrackLabels, unitsPerPixel, this /*hbox*/);
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegment(Segment*)),
TQT_SLOT(slotEditSegment(Segment*)));
TQ_SIGNAL(editSegment(Segment*)),
TQ_SLOT(slotEditSegment(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentNotation(Segment*)),
TQT_SLOT(slotEditSegmentNotation(Segment*)));
TQ_SIGNAL(editSegmentNotation(Segment*)),
TQ_SLOT(slotEditSegmentNotation(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentMatrix(Segment*)),
TQT_SLOT(slotEditSegmentMatrix(Segment*)));
TQ_SIGNAL(editSegmentMatrix(Segment*)),
TQ_SLOT(slotEditSegmentMatrix(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentAudio(Segment*)),
TQT_SLOT(slotEditSegmentAudio(Segment*)));
TQ_SIGNAL(editSegmentAudio(Segment*)),
TQ_SLOT(slotEditSegmentAudio(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(audioSegmentAutoSplit(Segment*)),
TQT_SLOT(slotSegmentAutoSplit(Segment*)));
TQ_SIGNAL(audioSegmentAutoSplit(Segment*)),
TQ_SLOT(slotSegmentAutoSplit(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentEventList(Segment*)),
TQT_SLOT(slotEditSegmentEventList(Segment*)));
TQ_SIGNAL(editSegmentEventList(Segment*)),
TQ_SLOT(slotEditSegmentEventList(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editRepeat(Segment*, timeT)),
TQT_SLOT(slotEditRepeat(Segment*, timeT)));
TQ_SIGNAL(editRepeat(Segment*, timeT)),
TQ_SLOT(slotEditRepeat(Segment*, timeT)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT)));
TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQ_SLOT(slotSetPointerPosition(timeT)));
connect(m_trackEditor,
TQT_SIGNAL(droppedDocument(TQString)),
TQ_SIGNAL(droppedDocument(TQString)),
parent,
TQT_SLOT(slotOpenDroppedURL(TQString)));
TQ_SLOT(slotOpenDroppedURL(TQString)));
connect(m_trackEditor,
TQT_SIGNAL(droppedAudio(TQString)),
TQ_SIGNAL(droppedAudio(TQString)),
this,
TQT_SLOT(slotDroppedAudio(TQString)));
TQ_SLOT(slotDroppedAudio(TQString)));
connect(m_trackEditor,
TQT_SIGNAL(droppedNewAudio(TQString)),
TQ_SIGNAL(droppedNewAudio(TQString)),
this,
TQT_SLOT(slotDroppedNewAudio(TQString)));
TQ_SLOT(slotDroppedNewAudio(TQString)));
connect(m_instrumentParameterBox,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this,
TQT_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
TQ_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
connect(m_instrumentParameterBox,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
m_trackParameterBox,
TQT_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
TQ_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
connect(m_trackEditor->getTrackButtons(),
TQT_SIGNAL(nameChanged()),
TQ_SIGNAL(nameChanged()),
m_trackParameterBox,
TQT_SLOT(slotSelectedTrackNameChanged()));
TQ_SLOT(slotSelectedTrackNameChanged()));
connect(m_trackEditor->getTrackButtons(),
TQT_SIGNAL(instrumentSelected(int)),
TQ_SIGNAL(instrumentSelected(int)),
m_trackParameterBox,
TQT_SLOT(slotUpdateControls(int)));
TQ_SLOT(slotUpdateControls(int)));
connect(m_trackParameterBox,
TQT_SIGNAL(instrumentSelected(TrackId, int)),
TQ_SIGNAL(instrumentSelected(TrackId, int)),
m_trackEditor->getTrackButtons(),
TQT_SLOT(slotTrackInstrumentSelection(TrackId, int)));
TQ_SLOT(slotTrackInstrumentSelection(TrackId, int)));
connect(this, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
this, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
connect(this, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
this, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
if (doc) {
/* signal no longer exists
connect(doc, TQT_SIGNAL(recordingSegmentUpdated(Segment *,
connect(doc, TQ_SIGNAL(recordingSegmentUpdated(Segment *,
timeT)),
this, TQT_SLOT(slotUpdateRecordingSegment(Segment *,
this, TQ_SLOT(slotUpdateRecordingSegment(Segment *,
timeT)));
*/
TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
m_trackEditor->getSegmentCanvas(), TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
m_trackEditor->getSegmentCanvas(), TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
}
}
@ -455,77 +455,77 @@ RosegardenGUIView::createNotationView(std::vector<Segment *> segmentsToEdit)
// For tempo changes (ugh -- it'd be nicer to make a tempo change
// command that could interpret all this stuff from the dialog)
//
connect(notationView, TQT_SIGNAL(changeTempo(timeT,
connect(notationView, TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
connect(notationView, TQT_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged()));
connect(notationView, TQT_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int)));
connect(notationView, TQT_SIGNAL(play()),
RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
connect(notationView, TQT_SIGNAL(stop()),
RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
connect(notationView, TQT_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
connect(notationView, TQT_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
connect(notationView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
connect(notationView, TQT_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
connect(notationView, TQT_SIGNAL(panic()),
RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
connect(notationView, TQT_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
connect(notationView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
connect(notationView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(windowActivated()),
this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(notationView, TQ_SIGNAL(selectTrack(int)),
this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(notationView, TQ_SIGNAL(play()),
RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
connect(notationView, TQ_SIGNAL(stop()),
RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
connect(notationView, TQ_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
connect(notationView, TQ_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
connect(notationView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
connect(notationView, TQ_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
connect(notationView, TQ_SIGNAL(panic()),
RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
connect(notationView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(notationView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
connect(notationView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
/* hjj: WHAT DO DO WITH THIS ?
connect(notationView, TQT_SIGNAL(editMetadata(TQString)),
this, TQT_SLOT(slotEditMetadata(TQString)));
connect(notationView, TQ_SIGNAL(editMetadata(TQString)),
this, TQ_SLOT(slotEditMetadata(TQString)));
*/
connect(notationView, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int)));
connect(notationView, TQT_SIGNAL(staffLabelChanged(TrackId, TQString)),
this, TQT_SLOT(slotChangeTrackLabel(TrackId, TQString)));
connect(notationView, TQT_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
connect(notationView, TQT_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
connect(notationView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(notationView, TQ_SIGNAL(staffLabelChanged(TrackId, TQString)),
this, TQ_SLOT(slotChangeTrackLabel(TrackId, TQString)));
connect(notationView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
connect(notationView, TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
SequenceManager *sM = getDocument()->getSequenceManager();
connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
notationView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
notationView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
notationView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
notationView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(notationView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
notationView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
notationView, TQT_SLOT(slotCompositionStateUpdate()));
connect(this, TQT_SIGNAL(compositionStateUpdate()),
notationView, TQT_SLOT(slotCompositionStateUpdate()));
connect(notationView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
notationView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
notationView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, TQ_SIGNAL(compositionStateUpdate()),
notationView, TQ_SLOT(slotCompositionStateUpdate()));
// Encourage the notation view window to open to the same
// interval as the current segment view
@ -657,73 +657,73 @@ RosegardenGUIView::createMatrixView(std::vector<Segment *> segmentsToEdit, bool
// For tempo changes (ugh -- it'd be nicer to make a tempo change
// command that could interpret all this stuff from the dialog)
//
connect(matrixView, TQT_SIGNAL(changeTempo(timeT,
connect(matrixView, TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
connect(matrixView, TQT_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged()));
connect(matrixView, TQT_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int)));
connect(matrixView, TQT_SIGNAL(play()),
RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
connect(matrixView, TQT_SIGNAL(stop()),
RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
connect(matrixView, TQT_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
connect(matrixView, TQT_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
connect(matrixView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
connect(matrixView, TQT_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
connect(matrixView, TQT_SIGNAL(panic()),
RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
connect(matrixView, TQT_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
connect(matrixView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
connect(matrixView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int)));
connect(matrixView, TQT_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
connect(matrixView, TQT_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
connect(matrixView, TQ_SIGNAL(windowActivated()),
this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(matrixView, TQ_SIGNAL(selectTrack(int)),
this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(matrixView, TQ_SIGNAL(play()),
RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
connect(matrixView, TQ_SIGNAL(stop()),
RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
connect(matrixView, TQ_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
connect(matrixView, TQ_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
connect(matrixView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
connect(matrixView, TQ_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
connect(matrixView, TQ_SIGNAL(panic()),
RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
connect(matrixView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(matrixView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
connect(matrixView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(matrixView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(matrixView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(matrixView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(matrixView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
connect(matrixView, TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
SequenceManager *sM = getDocument()->getSequenceManager();
connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
matrixView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
matrixView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(matrixView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
matrixView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
matrixView, TQT_SLOT(slotCompositionStateUpdate()));
connect(this, TQT_SIGNAL(compositionStateUpdate()),
matrixView, TQT_SLOT(slotCompositionStateUpdate()));
connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
matrixView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
matrixView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(matrixView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
matrixView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
matrixView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, TQ_SIGNAL(compositionStateUpdate()),
matrixView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this,
TQT_SIGNAL(instrumentLevelsChanged(InstrumentId,
TQ_SIGNAL(instrumentLevelsChanged(InstrumentId,
const LevelInfo &)),
matrixView,
TQT_SLOT(slotInstrumentLevelsChanged(InstrumentId,
TQ_SLOT(slotInstrumentLevelsChanged(InstrumentId,
const LevelInfo &)));
// Encourage the matrix view window to open to the same
@ -1543,12 +1543,12 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
// Connect the progress dialog
//
connect(&aFM, TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&aFM, TQT_SIGNAL(setOperationName(TQString)),
&progressDlg, TQT_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&aFM, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
&progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
try {
audioFileId = aFM.importURL(kurl, sampleRate);
@ -1564,10 +1564,10 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
return ;
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
progressDlg.progressBar()->show();
progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
@ -1581,8 +1581,8 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
//return false;
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
// add the file at the sequencer
emit addAudioFile(audioFileId);
@ -1747,8 +1747,8 @@ RosegardenGUIView::slotUpdateRecordingSegment(Segment *segment,
/* signal no longer exists
TQObject::connect
(getDocument(), TQT_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
view, TQT_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
(getDocument(), TQ_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
view, TQ_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
*/
view->show();
@ -1998,31 +1998,31 @@ RosegardenGUIView::createEventView(std::vector<Segment *> segmentsToEdit)
segmentsToEdit,
this);
connect(eventView, TQT_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged()));
connect(eventView, TQT_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int)));
connect(eventView, TQT_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
connect(eventView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int)));
connect(this, TQT_SIGNAL(compositionStateUpdate()),
eventView, TQT_SLOT(slotCompositionStateUpdate()));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
eventView, TQT_SLOT(slotCompositionStateUpdate()));
connect(eventView, TQT_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
connect(eventView, TQ_SIGNAL(windowActivated()),
this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(eventView, TQ_SIGNAL(selectTrack(int)),
this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(eventView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(eventView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(this, TQ_SIGNAL(compositionStateUpdate()),
eventView, TQ_SLOT(slotCompositionStateUpdate()));
connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
eventView, TQ_SLOT(slotCompositionStateUpdate()));
connect(eventView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
// create keyboard accelerators on view
//

20
src/gui/application/StartupTester.cpp
Unescape View File

@ -42,10 +42,10 @@ StartupTester::StartupTester() :
m_haveAudioFileImporter(false)
{
TQHttp *http = new TQHttp();
connect(http, TQT_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
this, TQT_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
connect(http, TQT_SIGNAL(done(bool)),
this, TQT_SLOT(slotHttpDone(bool)));
connect(http, TQ_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
this, TQ_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
connect(http, TQ_SIGNAL(done(bool)),
this, TQ_SLOT(slotHttpDone(bool)));
m_versionHttpFailed = false;
http->setHost("www.rosegardenmusic.com");
http->get("/latest-version.txt");
@ -65,8 +65,8 @@ StartupTester::run()
TDEProcess *proc = new TDEProcess();
m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-audiofile-importer";
*proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All);
@ -83,8 +83,8 @@ StartupTester::run()
proc = new TDEProcess;
m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-project-package";
*proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All);
@ -103,8 +103,8 @@ StartupTester::run()
proc = new TDEProcess();
m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-lilypondview";
*proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All);

12
src/gui/application/main.cpp
Unescape View File

@ -479,7 +479,7 @@ int main(int argc, char *argv[])
// Ensure quit on last window close
// Register main DCOP interface
//
TQObject::connect(&app, TQT_SIGNAL(lastWindowClosed()), &app, TQT_SLOT(quit()));
TQObject::connect(&app, TQ_SIGNAL(lastWindowClosed()), &app, TQ_SLOT(quit()));
app.dcopClient()->registerAs(app.name(), false);
app.dcopClient()->setDefaultObject(ROSEGARDEN_GUI_IFACE_NAME);
@ -624,8 +624,8 @@ int main(int argc, char *argv[])
}
TQObject::connect(&app, TQT_SIGNAL(aboutToSaveState()),
rosegardengui, TQT_SLOT(slotDeleteTransport()));
TQObject::connect(&app, TQ_SIGNAL(aboutToSaveState()),
rosegardengui, TQ_SLOT(slotDeleteTransport()));
// Now that we've started up, raise start logo
//
@ -661,8 +661,8 @@ int main(int argc, char *argv[])
(*sfxLoadProcess) << sfxLoadPath << soundFontPath;
RG_DEBUG << "Starting sfxload : " << sfxLoadPath << " " << soundFontPath << endl;
TQObject::connect(sfxLoadProcess, TQT_SIGNAL(processExited(TDEProcess*)),
&app, TQT_SLOT(sfxLoadExited(TDEProcess*)));
TQObject::connect(sfxLoadProcess, TQ_SIGNAL(processExited(TDEProcess*)),
&app, TQ_SLOT(sfxLoadExited(TDEProcess*)));
sfxLoadProcess->start();
} else {
@ -694,7 +694,7 @@ int main(int argc, char *argv[])
if (visibleFor < RealTime(2, 0)) {
int waitTime = visibleFor.sec * 1000 + visibleFor.msec();
TQTimer::singleShot(2500 - waitTime, startLogo, TQT_SLOT(close()));
TQTimer::singleShot(2500 - waitTime, startLogo, TQ_SLOT(close()));
} else {
startLogo->close();
}

2
src/gui/configuration/AudioConfigurationPage.cpp
Unescape View File

@ -135,7 +135,7 @@ AudioConfigurationPage::AudioConfigurationPage(
new TQPushButton(i18n("Choose..."), frame);
layout->addWidget(changePathButton, row, 2);
connect(changePathButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotFileDialog()));
connect(changePathButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotFileDialog()));
++row;
m_cfg->setGroup(SequencerOptionsConfigGroup);

16
src/gui/configuration/AudioPropertiesPage.cpp
Unescape View File

@ -82,8 +82,8 @@ AudioPropertiesPage::AudioPropertiesPage(RosegardenGUIDoc *doc,
calculateStats();
connect(m_changePathButton, TQT_SIGNAL(released()),
TQT_SLOT(slotFileDialog()));
connect(m_changePathButton, TQ_SIGNAL(released()),
TQ_SLOT(slotFileDialog()));
addTab(frame, i18n("Modify audio path"));
}
@ -95,9 +95,9 @@ AudioPropertiesPage::calculateStats()
//
TQString mountPoint = TDEIO::findPathMountPoint(m_path->text());
KDiskFreeSp * job = new KDiskFreeSp;
connect(job, TQT_SIGNAL(foundMountPoint(const TQString&, unsigned long, unsigned long,
connect(job, TQ_SIGNAL(foundMountPoint(const TQString&, unsigned long, unsigned long,
unsigned long)),
this, TQT_SLOT(slotFoundMountPoint(const TQString&, unsigned long, unsigned long,
this, TQ_SLOT(slotFoundMountPoint(const TQString&, unsigned long, unsigned long,
unsigned long)));
job->readDF(mountPoint);
}
@ -153,11 +153,11 @@ AudioPropertiesPage::slotFileDialog()
this, "file dialog", true);
fileDialog->setMode(KFile::Directory);
connect(fileDialog, TQT_SIGNAL(fileSelected(const TQString&)),
TQT_SLOT(slotFileSelected(const TQString&)));
connect(fileDialog, TQ_SIGNAL(fileSelected(const TQString&)),
TQ_SLOT(slotFileSelected(const TQString&)));
connect(fileDialog, TQT_SIGNAL(destroyed()),
TQT_SLOT(slotDirectoryDialogClosed()));
connect(fileDialog, TQ_SIGNAL(destroyed()),
TQ_SLOT(slotDirectoryDialogClosed()));
if (fileDialog->exec() == TQDialog::Accepted) {
m_path->setText(fileDialog->selectedFile());

20
src/gui/configuration/ColourConfigurationPage.cpp
Unescape View File

@ -73,20 +73,20 @@ ColourConfigurationPage::ColourConfigurationPage(RosegardenGUIDoc *doc,
frame);
layout->addWidget(deleteColourButton, 1, 1, TQt::AlignHCenter);
connect(addColourButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddNew()));
connect(addColourButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddNew()));
connect(deleteColourButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDelete()));
connect(deleteColourButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDelete()));
connect(this, TQT_SIGNAL(docColoursChanged()),
m_doc, TQT_SLOT(slotDocColoursChanged()));
connect(this, TQ_SIGNAL(docColoursChanged()),
m_doc, TQ_SLOT(slotDocColoursChanged()));
connect(m_colourtable, TQT_SIGNAL(entryTextChanged(unsigned int, TQString)),
this, TQT_SLOT(slotTextChanged(unsigned int, TQString)));
connect(m_colourtable, TQ_SIGNAL(entryTextChanged(unsigned int, TQString)),
this, TQ_SLOT(slotTextChanged(unsigned int, TQString)));
connect(m_colourtable, TQT_SIGNAL(entryColourChanged(unsigned int, TQColor)),
this, TQT_SLOT(slotColourChanged(unsigned int, TQColor)));
connect(m_colourtable, TQ_SIGNAL(entryColourChanged(unsigned int, TQColor)),
this, TQ_SLOT(slotColourChanged(unsigned int, TQColor)));
addTab(frame, i18n("Color Map"));

4
src/gui/configuration/GeneralConfigurationPage.cpp
Unescape View File

@ -192,8 +192,8 @@ GeneralConfigurationPage::GeneralConfigurationPage(RosegardenGUIDoc *doc,
TQPushButton *showStatusButton = new TQPushButton(i18n("Details..."),
frame);
TQObject::connect(showStatusButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotShowStatus()));
TQObject::connect(showStatusButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotShowStatus()));
layout->addWidget(showStatusButton, row, 2, TQt::AlignRight);
++row;

8
src/gui/configuration/HeadersConfigurationPage.cpp
Unescape View File

@ -215,11 +215,11 @@ HeadersConfigurationPage::HeadersConfigurationPage(TQWidget *parent,
frameOtherHeaders);
layoutOtherHeaders->addWidget(deletePropButton, 1, 1, TQt::AlignHCenter);
connect(addPropButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddNewProperty()));
connect(addPropButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddNewProperty()));
connect(deletePropButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteProperty()));
connect(deletePropButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteProperty()));
}
void

12
src/gui/configuration/LatencyConfigurationPage.cpp
Unescape View File

@ -68,8 +68,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
layout->addWidget(m_fetchLatencyValues, 1, 3);
connect(m_fetchLatencyValues, TQT_SIGNAL(released()),
TQT_SLOT(slotFetchLatencyValues()));
connect(m_fetchLatencyValues, TQ_SIGNAL(released()),
TQ_SLOT(slotFetchLatencyValues()));
int jackPlaybackValue = (m_cfg->readLongNumEntry(
"jackplaybacklatencyusec", 0) / 1000) +
@ -83,8 +83,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
TQLabel *jackPlaybackLabel = new TQLabel(TQString("%1").arg(jackPlaybackValue),
frame);
layout->addWidget(jackPlaybackLabel, 2, 2, TQt::AlignHCenter);
connect(m_jackPlayback, TQT_SIGNAL(valueChanged(int)),
jackPlaybackLabel, TQT_SLOT(setNum(int)));
connect(m_jackPlayback, TQ_SIGNAL(valueChanged(int)),
jackPlaybackLabel, TQ_SLOT(setNum(int)));
m_jackPlayback->setMinValue(0);
layout->addWidget(new TQLabel("0", frame), 3, 1, TQt::AlignRight);
@ -106,8 +106,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
TQLabel *jackRecordLabel = new TQLabel(TQString("%1").arg(jackRecordValue),
frame);
layout->addWidget(jackRecordLabel, 4, 2, TQt::AlignHCenter);
connect(m_jackRecord, TQT_SIGNAL(valueChanged(int)),
jackRecordLabel, TQT_SLOT(setNum(int)));
connect(m_jackRecord, TQ_SIGNAL(valueChanged(int)),
jackRecordLabel, TQ_SLOT(setNum(int)));
m_jackRecord->setMinValue(0);
layout->addWidget(new TQLabel("0", frame), 5, 1, TQt::AlignRight);

14
src/gui/configuration/MIDIConfigurationPage.cpp
Unescape View File

@ -191,14 +191,14 @@ MIDIConfigurationPage::MIDIConfigurationPage(
m_soundFontChoose->setEnabled(false);
}
connect(m_sfxLoadEnabled, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotSoundFontToggled(bool)));
connect(m_sfxLoadEnabled, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotSoundFontToggled(bool)));
connect(m_sfxLoadChoose, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSfxLoadPathChoose()));
connect(m_sfxLoadChoose, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSfxLoadPathChoose()));
connect(m_soundFontChoose, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSoundFontChoose()));
connect(m_soundFontChoose, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSoundFontChoose()));
layout->setRowStretch(row, 10);
@ -363,7 +363,7 @@ MIDIConfigurationPage::apply()
int midiClock = m_midiSync->currentItem();
m_cfg->writeEntry("midiclock", midiClock);
// Now send it (OLD TQT_METHOD - to be removed)
// Now send it (OLD METHOD - to be removed)
//!!! No, don't remove -- this controls SPP as well doesn't it?
//
MappedEvent mEMIDIClock(MidiInstrumentBase, // InstrumentId

8
src/gui/configuration/NotationConfigurationPage.cpp
Unescape View File

@ -444,14 +444,14 @@ NotationConfigurationPage::NotationConfigurationPage(TDEConfig *cfg,
m_viewButton = new TQPushButton(i18n("View"), frame);
layout->addMultiCellWidget(m_font, row, row, 1, 2);
layout->addWidget(m_viewButton, row, 3);
TQObject::connect(m_viewButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotViewButtonPressed()));
TQObject::connect(m_viewButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotViewButtonPressed()));
#else
layout->addMultiCellWidget(m_font, row, row, 1, 3);
#endif
m_font->setEditable(false);
TQObject::connect(m_font, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotFontComboChanged(int)));
TQObject::connect(m_font, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotFontComboChanged(int)));
++row;
TQFrame *subFrame = new TQFrame(frame);

64
src/gui/dialogs/AudioManagerDialog.cpp
Unescape View File

@ -128,47 +128,47 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm"));
new TDEAction(i18n("&Add Audio File..."), "document-open", 0, this,
TQT_SLOT(slotAdd()), actionCollection(), "add_audio");
TQ_SLOT(slotAdd()), actionCollection(), "add_audio");
new TDEAction(i18n("&Unload Audio File"), "edit-delete", 0, this,
TQT_SLOT(slotRemove()),
TQ_SLOT(slotRemove()),
actionCollection(), "remove_audio");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm"));
new TDEAction(i18n("&Play Preview"), icon, 0, this,
TQT_SLOT(slotPlayPreview()),
TQ_SLOT(slotPlayPreview()),
actionCollection(), "preview_audio");
/*!!! Not actually implemented -- this never worked right!
new TDEAction(i18n("Re&label"), 0, 0, this,
TQT_SLOT(slotRename()),
TQ_SLOT(slotRename()),
actionCollection(), "rename_audio");
*/
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/insert_audio_into_track.xpm"));
new TDEAction(i18n("&Insert into Selected Audio Track"),
icon, 0, this, TQT_SLOT(slotInsert()),
icon, 0, this, TQ_SLOT(slotInsert()),
actionCollection(), "insert_audio");
new TDEAction(i18n("Unload &all Audio Files"), 0, 0, this,
TQT_SLOT(slotRemoveAll()),
TQ_SLOT(slotRemoveAll()),
actionCollection(), "remove_all_audio");
new TDEAction(i18n("Unload all &Unused Audio Files"), 0, 0, this,
TQT_SLOT(slotRemoveAllUnused()),
TQ_SLOT(slotRemoveAllUnused()),
actionCollection(), "remove_all_unused_audio");
new TDEAction(i18n("&Delete Unused Audio Files..."), 0, 0, this,
TQT_SLOT(slotDeleteUnused()),
TQ_SLOT(slotDeleteUnused()),
actionCollection(), "delete_unused_audio");
new TDEAction(i18n("&Export Audio File..."), "fileexport", 0, this,
TQT_SLOT(slotExportAudio()),
TQ_SLOT(slotExportAudio()),
actionCollection(), "export_audio");
/*
new TDEAction(i18n("Distribute Audio on &MIDI"),
0, 0, this,
TQT_SLOT(slotDistributeOnMidiSegment()),
TQ_SLOT(slotDistributeOnMidiSegment()),
actionCollection(),
"distribute_audio");
*/
@ -200,11 +200,11 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
m_fileList->setShowToolTips(true);
// connect selection mechanism
connect(m_fileList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
TQT_SLOT(slotSelectionChanged(TQListViewItem*)));
connect(m_fileList, TQ_SIGNAL(selectionChanged(TQListViewItem*)),
TQ_SLOT(slotSelectionChanged(TQListViewItem*)));
connect(m_fileList, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
connect(m_fileList, TQ_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQ_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
// setup local accelerators
//
@ -214,22 +214,22 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
//
m_accelerators->connectItem(m_accelerators->insertItem(Key_Delete),
this,
TQT_SLOT(slotRemove()));
TQ_SLOT(slotRemove()));
slotPopulateFileList();
// Connect command history for updates
//
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted(KCommand *)),
this, TQT_SLOT(slotCommandExecuted(KCommand *)));
connect(getCommandHistory(), TQ_SIGNAL(commandExecuted(KCommand *)),
this, TQ_SLOT(slotCommandExecuted(KCommand *)));
//setInitialSize(configDialogSize(AudioManagerDialogConfigGroup));
connect(m_playTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCancelPlayingAudio()));
connect(m_playTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCancelPlayingAudio()));
KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
createGUI("audiomanager.rc");
@ -1091,12 +1091,12 @@ AudioManagerDialog::addFile(const KURL& kurl)
// Connect the progress dialog
//
connect(&aFM, TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&aFM, TQT_SIGNAL(setOperationName(TQString)),
&progressDlg, TQT_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&aFM, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
&progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
try {
id = aFM.importURL(kurl, m_sampleRate);
@ -1112,10 +1112,10 @@ AudioManagerDialog::addFile(const KURL& kurl)
return false;
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
progressDlg.progressBar()->show();
progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
@ -1129,8 +1129,8 @@ AudioManagerDialog::addFile(const KURL& kurl)
KMessageBox::information(this, message);
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
slotPopulateFileList();

36
src/gui/dialogs/AudioPluginDialog.cpp
Unescape View File

@ -118,8 +118,8 @@ AudioPluginDialog::AudioPluginDialog(TQWidget *parent,
TQToolTip::add
(m_bypass, i18n("Bypass this plugin."));
connect(m_bypass, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotBypassChanged(bool)));
connect(m_bypass, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotBypassChanged(bool)));
m_insOuts = new TQLabel(i18n("<ports>"), h);
@ -132,29 +132,29 @@ AudioPluginDialog::AudioPluginDialog(TQWidget *parent,
TQToolTip::add
(m_pluginId, i18n("Unique ID of plugin."));
connect(m_pluginList, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPluginSelected(int)));
connect(m_pluginList, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPluginSelected(int)));
connect(m_pluginCategoryList, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotCategorySelected(int)));
connect(m_pluginCategoryList, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotCategorySelected(int)));
// new line
h = new TQHBox(pluginSelectionBox);
m_copyButton = new TQPushButton(i18n("Copy"), h);
connect(m_copyButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotCopy()));
connect(m_copyButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotCopy()));
TQToolTip::add
(m_copyButton, i18n("Copy plugin parameters"));
m_pasteButton = new TQPushButton(i18n("Paste"), h);
connect(m_pasteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPaste()));
connect(m_pasteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPaste()));
TQToolTip::add
(m_pasteButton, i18n("Paste plugin parameters"));
m_defaultButton = new TQPushButton(i18n("Default"), h);
connect(m_defaultButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDefault()));
connect(m_defaultButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDefault()));
TQToolTip::add
(m_defaultButton, i18n("Set to defaults"));
@ -523,8 +523,8 @@ AudioPluginDialog::slotPluginSelected(int i)
m_gridLayout->addMultiCellWidget(m_programCombo,
0, 0, 1, m_gridLayout->numCols() - 1,
TQt::AlignLeft);
connect(m_programCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotPluginProgramChanged(const TQString &)));
connect(m_programCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotPluginProgramChanged(const TQString &)));
m_programCombo->clear();
m_programCombo->insertItem(i18n("<none selected>"));
@ -553,8 +553,8 @@ AudioPluginDialog::slotPluginSelected(int i)
showBounds,
portCount > tooManyPorts);
connect(control, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPluginPortChanged(float)));
connect(control, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotPluginPortChanged(float)));
m_pluginWidgets.push_back(control);
}
@ -720,8 +720,8 @@ AudioPluginDialog::updatePluginProgramList()
m_programCombo->show();
m_programCombo->blockSignals(true);
connect(m_programCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotPluginProgramChanged(const TQString &)));
connect(m_programCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotPluginProgramChanged(const TQString &)));
} else {
return ;

4
src/gui/dialogs/AudioSplitDialog.cpp
Unescape View File

@ -82,8 +82,8 @@ AudioSplitDialog::AudioSplitDialog(TQWidget *parent,
new TQLabel(i18n("Threshold"), hbox);
m_thresholdSpin = new TQSpinBox(hbox);
m_thresholdSpin->setSuffix(" %");
connect(m_thresholdSpin, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotThresholdChanged(int)));
connect(m_thresholdSpin, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotThresholdChanged(int)));
// ensure this is cleared
m_previewBoxes.clear();

8
src/gui/dialogs/ClefDialog.cpp
Unescape View File

@ -109,10 +109,10 @@ ClefDialog::ClefDialog(TQWidget *parent,
conversionFrame->hide();
}
TQObject::connect(clefUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClefUp()));
TQObject::connect(clefDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClefDown()));
TQObject::connect(m_octaveUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotOctaveUp()));
TQObject::connect(m_octaveDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotOctaveDown()));
TQObject::connect(clefUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClefUp()));
TQObject::connect(clefDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClefDown()));
TQObject::connect(m_octaveUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotOctaveUp()));
TQObject::connect(m_octaveDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotOctaveDown()));
redrawClefPixmap();
}

8
src/gui/dialogs/ConfigureDialog.cpp
Unescape View File

@ -78,10 +78,10 @@ ConfigureDialog::ConfigureDialog(RosegardenGUIDoc *doc,
page->setPageIndex(pageIndex(pageWidget));
m_configurationPages.push_back(page);
connect(page, TQT_SIGNAL(updateAutoSaveInterval(unsigned int)),
this, TQT_SIGNAL(updateAutoSaveInterval(unsigned int)));
connect(page, TQT_SIGNAL(updateSidebarStyle(unsigned int)),
this, TQT_SIGNAL(updateSidebarStyle(unsigned int)));
connect(page, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)),
this, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)));
connect(page, TQ_SIGNAL(updateSidebarStyle(unsigned int)),
this, TQ_SIGNAL(updateSidebarStyle(unsigned int)));
pageWidget = addPage(MIDIConfigurationPage::iconLabel(),
MIDIConfigurationPage::title(),

2
src/gui/dialogs/CountdownDialog.cpp
Unescape View File

@ -69,7 +69,7 @@ CountdownDialog::CountdownDialog(TQWidget *parent, int seconds):
layout->addWidget(m_progressBar, 0, AlignCenter);
layout->addWidget(m_stopButton, 0, AlignRight);
connect (m_stopButton, TQT_SIGNAL(released()), this, TQT_SIGNAL(stopped()));
connect (m_stopButton, TQ_SIGNAL(released()), this, TQ_SIGNAL(stopped()));
// Set the total time to show the bar in initial position
//

44
src/gui/dialogs/EventEditDialog.cpp
Unescape View File

@ -92,8 +92,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *absoluteTime = new TQSpinBox
(INT_MIN, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid);
absoluteTime->setValue(event.getAbsoluteTime());
TQObject::connect(absoluteTime, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotAbsoluteTimeChanged(int)));
TQObject::connect(absoluteTime, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotAbsoluteTimeChanged(int)));
slotAbsoluteTimeChanged(event.getAbsoluteTime());
new TQLabel(i18n("Duration: "), intrinsicGrid);
@ -105,8 +105,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *duration = new TQSpinBox
(0, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid);
duration->setValue(event.getDuration());
TQObject::connect(duration, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotDurationChanged(int)));
TQObject::connect(duration, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotDurationChanged(int)));
slotDurationChanged(event.getDuration());
new TQLabel(i18n("Sub-ordering: "), intrinsicGrid);
@ -115,8 +115,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *subOrdering = new TQSpinBox( -100, 100, 1, intrinsicGrid);
subOrdering->setValue(event.getSubOrdering());
TQObject::connect(subOrdering, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSubOrderingChanged(int)));
TQObject::connect(subOrdering, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSubOrderingChanged(int)));
slotSubOrderingChanged(event.getSubOrdering());
TQGroupBox *persistentBox = new TQGroupBox
@ -184,8 +184,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
button->setFixedSize(TQSize(24, 24));
TQToolTip::add
(button, i18n("Make persistent"));
TQObject::connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPropertyMadePersistent()));
TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPropertyMadePersistent()));
}
}
}
@ -213,8 +213,8 @@ EventEditDialog::addPersistentProperty(const PropertyName &name)
TQSpinBox *spinBox = new TQSpinBox
(min, max, 1, m_persistentGrid, strtoqstr(name).ascii());
spinBox->setValue(m_originalEvent.get<Int>(name));
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotIntPropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotIntPropertyChanged(int)));
spinBox->show();
break;
}
@ -228,8 +228,8 @@ case UInt: {
TQSpinBox *spinBox = new TQSpinBox
(min, max, 1, m_persistentGrid, strtoqstr(name).ascii());
spinBox->setValue(m_originalEvent.get<UInt>(name));
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotIntPropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotIntPropertyChanged(int)));
spinBox->show();
break;
}
@ -245,8 +245,8 @@ case UInt: {
hbox, TQString(strtoqstr(name) + "%sec").ascii());
spinBox->setValue(realTime.sec);
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotRealTimePropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotRealTimePropertyChanged(int)));
// nseconds
//
@ -255,8 +255,8 @@ case UInt: {
hbox, TQString(strtoqstr(name) + "%nsec").ascii());
spinBox->setValue(realTime.nsec);
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotRealTimePropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotRealTimePropertyChanged(int)));
spinBox->show();
break;
}
@ -265,8 +265,8 @@ case UInt: {
TQCheckBox *checkBox = new TQCheckBox
("", m_persistentGrid, strtoqstr(name).ascii());
checkBox->setChecked(m_originalEvent.get<Bool>(name));
TQObject::connect(checkBox, TQT_SIGNAL(activated()),
this, TQT_SLOT(slotBoolPropertyChanged()));
TQObject::connect(checkBox, TQ_SIGNAL(activated()),
this, TQ_SLOT(slotBoolPropertyChanged()));
checkBox->show();
break;
}
@ -276,8 +276,8 @@ case UInt: {
(strtoqstr(m_originalEvent.get<String>(name)),
m_persistentGrid,
strtoqstr(name).ascii());
TQObject::connect(lineEdit, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotStringPropertyChanged(const TQString &)));
TQObject::connect(lineEdit, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotStringPropertyChanged(const TQString &)));
lineEdit->show();
break;
}
@ -288,8 +288,8 @@ case UInt: {
button->setFixedSize(TQSize(24, 24));
TQToolTip::add
(button, i18n("Delete this property"));
TQObject::connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPropertyDeleted()));
TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPropertyDeleted()));
button->show();
}

36
src/gui/dialogs/EventFilterDialog.cpp
Unescape View File

@ -128,8 +128,8 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup);
m_pitchFromSpinBox->setValue(cfg->readUnsignedNumEntry("pitchfrom", 0));
noteFrameLayout->addWidget(m_pitchFromSpinBox, 1, 2);
connect(m_pitchFromSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchFromChanged(int)));
connect(m_pitchFromSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotPitchFromChanged(int)));
m_pitchFromChooserButton = new TQPushButton(i18n("edit"), noteFrame);
m_pitchFromChooserButton->setSizePolicy(TQSizePolicy((TQSizePolicy::SizeType)0,
@ -138,8 +138,8 @@ EventFilterDialog::initDialog()
TQToolTip::add
(m_pitchFromChooserButton, i18n("choose a pitch using a staff"));
noteFrameLayout->addWidget(m_pitchFromChooserButton, 1, 3);
connect(m_pitchFromChooserButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPitchFromChooser()));
connect(m_pitchFromChooserButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPitchFromChooser()));
// Pitch To
m_pitchToSpinBox = new TQSpinBox(noteFrame);
@ -147,15 +147,15 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup);
m_pitchToSpinBox->setValue(cfg->readUnsignedNumEntry("pitchto", 127));
noteFrameLayout->addWidget(m_pitchToSpinBox, 1, 4);
connect(m_pitchToSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchToChanged(int)));
connect(m_pitchToSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotPitchToChanged(int)));
m_pitchToChooserButton = new TQPushButton(i18n("edit"), noteFrame);
TQToolTip::add
(m_pitchToChooserButton, i18n("choose a pitch using a staff"));
noteFrameLayout->addWidget(m_pitchToChooserButton, 1, 5);
connect(m_pitchToChooserButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPitchToChooser()));
connect(m_pitchToChooserButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPitchToChooser()));
// Velocity From/To
m_velocityFromSpinBox = new TQSpinBox(noteFrame);
@ -163,30 +163,30 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup);
m_velocityFromSpinBox->setValue(cfg->readUnsignedNumEntry("velocityfrom", 0));
noteFrameLayout->addWidget(m_velocityFromSpinBox, 2, 2);
connect(m_velocityFromSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityFromChanged(int)));
connect(m_velocityFromSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotVelocityFromChanged(int)));
m_velocityToSpinBox = new TQSpinBox(noteFrame);
m_velocityToSpinBox->setMaxValue(127);
cfg->setGroup(EventFilterDialogConfigGroup);
m_velocityToSpinBox->setValue(cfg->readUnsignedNumEntry("velocityto", 127));
noteFrameLayout->addWidget( m_velocityToSpinBox, 2, 4 );
connect(m_velocityToSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityToChanged(int)));
connect(m_velocityToSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotVelocityToChanged(int)));
// Duration From/To
m_noteDurationFromComboBox = new TQComboBox(0, noteFrame);
m_noteDurationFromComboBox->insertItem(i18n("longest"));
noteFrameLayout->addWidget(m_noteDurationFromComboBox, 3, 2);
connect(m_noteDurationFromComboBox, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDurationFromChanged(int)));
connect(m_noteDurationFromComboBox, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDurationFromChanged(int)));
m_noteDurationToComboBox = new TQComboBox(0, noteFrame);
m_noteDurationToComboBox->insertItem(i18n("longest"));
noteFrameLayout->addWidget(m_noteDurationToComboBox, 3, 4);
connect(m_noteDurationToComboBox, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDurationToChanged(int)));
connect(m_noteDurationToComboBox, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDurationToChanged(int)));
populateDurationCombos();
@ -207,8 +207,8 @@ EventFilterDialog::initDialog()
(m_buttonNone, i18n("Exclude entire range of values"));
buttonLayout->addWidget( m_buttonNone, 0, 1 );
connect(m_buttonAll, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotToggleAll()));
connect(m_buttonNone, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotToggleNone()));
connect(m_buttonAll, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotToggleAll()));
connect(m_buttonNone, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotToggleNone()));
}

4
src/gui/dialogs/EventParameterDialog.cpp
Unescape View File

@ -80,8 +80,8 @@ EventParameterDialog::EventParameterDialog(
text = i18n("Ringing - set %1 alternating from max to min with both dying to zero").arg(strtoqstr(property));
m_patternCombo->insertItem(text);
connect(m_patternCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPatternSelected(int)));
connect(m_patternCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPatternSelected(int)));
TQHBox *value1Box = new TQHBox(vBox);
m_value1Label = new TQLabel(i18n("Value"), value1Box);

4
src/gui/dialogs/IdentifyTextCodecDialog.cpp
Unescape View File

@ -134,8 +134,8 @@ IdentifyTextCodecDialog::IdentifyTextCodecDialog(TQWidget *parent,
++i;
}
connect(codecs, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotCodecSelected(int)));
connect(codecs, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotCodecSelected(int)));
new TQLabel(i18n("\nExample text from file:"), vbox);
m_example = new TQLabel("", vbox);

2
src/gui/dialogs/InterpretDialog.cpp
Unescape View File

@ -73,7 +73,7 @@ InterpretDialog::InterpretDialog(TQWidget *parent) :
(config->readBoolEntry("interpretarticulate", true));
connect(m_allInterpretations,
TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAllBoxChanged()));
TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAllBoxChanged()));
slotAllBoxChanged();
}

8
src/gui/dialogs/IntervalDialog.cpp
Unescape View File

@ -93,11 +93,11 @@ IntervalDialog::IntervalDialog(TQWidget *parent, bool askChangeKey, bool askTran
m_transposeSegmentBack = NULL;
}
connect(m_referencenote, TQT_SIGNAL(noteChanged(int,int,int)),
this, TQT_SLOT(slotSetReferenceNote(int,int,int)));
connect(m_referencenote, TQ_SIGNAL(noteChanged(int,int,int)),
this, TQ_SLOT(slotSetReferenceNote(int,int,int)));
connect(m_targetnote, TQT_SIGNAL(noteChanged(int,int,int)),
this, TQT_SLOT(slotSetTargetNote(int,int,int)));
connect(m_targetnote, TQ_SIGNAL(noteChanged(int,int,int)),
this, TQ_SLOT(slotSetTargetNote(int,int,int)));
}
// number of octaves the notes are apart

16
src/gui/dialogs/KeySignatureDialog.cpp
Unescape View File

@ -162,14 +162,14 @@ KeySignatureDialog::KeySignatureDialog(TQWidget *parent,
conversionFrame->hide();
}
TQObject::connect(keyUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotKeyUp()));
TQObject::connect(keyDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotKeyDown()));
TQObject::connect(m_keyCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_keyCombo, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_majorMinorCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotMajorMinorChanged(const TQString &)));
TQObject::connect(keyUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotKeyUp()));
TQObject::connect(keyDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotKeyDown()));
TQObject::connect(m_keyCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_keyCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_majorMinorCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotMajorMinorChanged(const TQString &)));
}
KeySignatureDialog::ConversionType

4
src/gui/dialogs/LyricEditDialog.cpp
Unescape View File

@ -64,9 +64,9 @@ LyricEditDialog::LyricEditDialog(TQWidget *parent,
// new TQLabel(i18n("Verse:"), hbox);
m_verseNumber = new KComboBox(hbox);
m_verseNumber->setEditable(false);
connect(m_verseNumber, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotVerseNumberChanged(int)));
connect(m_verseNumber, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotVerseNumberChanged(int)));
m_verseAddButton = new TQPushButton(i18n("Add Verse"), hbox);
connect(m_verseAddButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddVerse()));
connect(m_verseAddButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddVerse()));
TQFrame *f = new TQFrame(hbox);
hbox->setStretchFactor(f, 10);

30
src/gui/dialogs/ManageMetronomeDialog.cpp
Unescape View File

@ -108,8 +108,8 @@ ManageMetronomeDialog::ManageMetronomeDialog(TQWidget *parent,
layout->addWidget(new TQLabel(i18n("Instrument"), frame), 1, 0);
m_metronomeInstrument = new KComboBox(frame);
connect(m_metronomeInstrument, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeInstrument, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotInstrumentChanged(int)));
connect(m_metronomeInstrument, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotSetModified()));
connect(m_metronomeInstrument, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotInstrumentChanged(int)));
layout->addWidget(m_metronomeInstrument, 1, 1);
TQGroupBox *beatBox = new TQGroupBox
@ -124,58 +124,58 @@ ManageMetronomeDialog::ManageMetronomeDialog(TQWidget *parent,
m_metronomeResolution->insertItem(i18n("Bars only"));
m_metronomeResolution->insertItem(i18n("Bars and beats"));
m_metronomeResolution->insertItem(i18n("Bars, beats, and divisions"));
connect(m_metronomeResolution, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotResolutionChanged(int)));
connect(m_metronomeResolution, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotResolutionChanged(int)));
layout->addWidget(m_metronomeResolution, 0, 1);
layout->addWidget(new TQLabel(i18n("Bar velocity"), frame), 1, 0);
m_metronomeBarVely = new TQSpinBox(frame);
m_metronomeBarVely->setMinValue(0);
m_metronomeBarVely->setMaxValue(127);
connect(m_metronomeBarVely, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeBarVely, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotSetModified()));
layout->addWidget(m_metronomeBarVely, 1, 1);
layout->addWidget(new TQLabel(i18n("Beat velocity"), frame), 2, 0);
m_metronomeBeatVely = new TQSpinBox(frame);
m_metronomeBeatVely->setMinValue(0);
m_metronomeBeatVely->setMaxValue(127);
connect(m_metronomeBeatVely, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeBeatVely, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotSetModified()));
layout->addWidget(m_metronomeBeatVely, 2, 1);
layout->addWidget(new TQLabel(i18n("Sub-beat velocity"), frame), 3, 0);
m_metronomeSubBeatVely = new TQSpinBox(frame);
m_metronomeSubBeatVely->setMinValue(0);
m_metronomeSubBeatVely->setMaxValue(127);
connect(m_metronomeSubBeatVely, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeSubBeatVely, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotSetModified()));
layout->addWidget(m_metronomeSubBeatVely, 3, 1);
vbox = new TQVBox(hbox);
m_metronomePitch = new PitchChooser(i18n("Pitch"), vbox, 60);
connect(m_metronomePitch, TQT_SIGNAL(pitchChanged(int)), this, TQT_SLOT(slotPitchChanged(int)));
connect(m_metronomePitch, TQT_SIGNAL(preview(int)), this, TQT_SLOT(slotPreviewPitch(int)));
connect(m_metronomePitch, TQ_SIGNAL(pitchChanged(int)), this, TQ_SLOT(slotPitchChanged(int)));
connect(m_metronomePitch, TQ_SIGNAL(preview(int)), this, TQ_SLOT(slotPreviewPitch(int)));
m_metronomePitchSelector = new KComboBox(m_metronomePitch);
m_metronomePitchSelector->insertItem(i18n("for Bar"));
m_metronomePitchSelector->insertItem(i18n("for Beat"));
m_metronomePitchSelector->insertItem(i18n("for Sub-beat"));
connect(m_metronomePitchSelector, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotPitchSelectorChanged(int)));
connect(m_metronomePitchSelector, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotPitchSelectorChanged(int)));
TQGroupBox *enableBox = new TQGroupBox
(1, TQt::Horizontal, i18n("Metronome Activated"), vbox);
m_playEnabled = new TQCheckBox(i18n("Playing"), enableBox);
m_recordEnabled = new TQCheckBox(i18n("Recording"), enableBox);
connect(m_playEnabled, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetModified()));
connect(m_recordEnabled, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetModified()));
connect(m_playEnabled, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetModified()));
connect(m_recordEnabled, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetModified()));
// populate the dialog
populate(m_metronomeDevice->currentItem());
// connect up the device list
connect(m_metronomeDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(populate(int)));
connect(m_metronomeDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(populate(int)));
// connect up the device list
connect(m_metronomeDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetModified()));
connect(m_metronomeDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetModified()));
setModified(false);
}

4
src/gui/dialogs/PasteNotationDialog.cpp
Unescape View File

@ -57,8 +57,8 @@ PasteNotationDialog::PasteNotationDialog(TQWidget *parent,
TQRadioButton *button = new TQRadioButton(i->second, pasteTypeGroup);
button->setChecked(m_defaultType == i->first);
TQObject::connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPasteTypeChanged()));
TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPasteTypeChanged()));
m_pasteTypeButtons.push_back(button);
}

4
src/gui/dialogs/PitchDialog.cpp
Unescape View File

@ -41,8 +41,8 @@ PitchDialog::PitchDialog(TQWidget *parent, TQString title, int defaultPitch) :
m_pitchChooser = new PitchChooser(title, vbox, defaultPitch);
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_pitchChooser, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_pitchChooser, TQ_SLOT(slotResetToDefault()));
}
int

4
src/gui/dialogs/RescaleDialog.cpp
Unescape View File

@ -68,8 +68,8 @@ RescaleDialog::RescaleDialog(TQWidget *parent,
}
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_newDuration, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_newDuration, TQ_SLOT(slotResetToDefault()));
}
timeT

64
src/gui/dialogs/SimpleEventEditDialog.cpp
Unescape View File

@ -101,8 +101,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
// Connect up the combos
//
connect(m_typeCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotEventTypeChanged(int)));
connect(m_typeCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotEventTypeChanged(int)));
} else {
@ -119,10 +119,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_timeSpinBox, 1, 1);
layout->addWidget(m_timeEditButton, 1, 2);
connect(m_timeSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotAbsoluteTimeChanged(int)));
connect(m_timeEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditAbsoluteTime()));
connect(m_timeSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotAbsoluteTimeChanged(int)));
connect(m_timeEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditAbsoluteTime()));
m_durationLabel = new TQLabel(i18n("Duration:"), frame);
layout->addWidget(m_durationLabel, 2, 0);
@ -131,10 +131,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_durationSpinBox, 2, 1);
layout->addWidget(m_durationEditButton, 2, 2);
connect(m_durationSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotDurationChanged(int)));
connect(m_durationEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditDuration()));
connect(m_durationSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotDurationChanged(int)));
connect(m_durationEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditDuration()));
m_pitchLabel = new TQLabel(i18n("Pitch:"), frame);
layout->addWidget(m_pitchLabel, 3, 0);
@ -143,10 +143,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_pitchSpinBox, 3, 1);
layout->addWidget(m_pitchEditButton, 3, 2);
connect(m_pitchSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchChanged(int)));
connect(m_pitchEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditPitch()));
connect(m_pitchSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotPitchChanged(int)));
connect(m_pitchEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditPitch()));
m_pitchSpinBox->setMinValue(MidiMinValue);
m_pitchSpinBox->setMaxValue(MidiMaxValue);
@ -163,8 +163,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
m_velocitySpinBox = new TQSpinBox(frame);
layout->addWidget(m_velocitySpinBox, 5, 1);
connect(m_velocitySpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityChanged(int)));
connect(m_velocitySpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotVelocityChanged(int)));
m_velocitySpinBox->setMinValue(MidiMinValue);
m_velocitySpinBox->setMaxValue(MidiMaxValue);
@ -179,12 +179,12 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
m_sysexSaveButton = new TQPushButton(i18n("Save data"), frame);
layout->addWidget(m_sysexSaveButton, 4, 2);
connect(m_metaEdit, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(slotMetaChanged(const TQString &)));
connect(m_sysexLoadButton, TQT_SIGNAL(released()),
TQT_SLOT(slotSysexLoad()));
connect(m_sysexSaveButton, TQT_SIGNAL(released()),
TQT_SLOT(slotSysexSave()));
connect(m_metaEdit, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(slotMetaChanged(const TQString &)));
connect(m_sysexLoadButton, TQ_SIGNAL(released()),
TQ_SLOT(slotSysexLoad()));
connect(m_sysexSaveButton, TQ_SIGNAL(released()),
TQ_SLOT(slotSysexSave()));
m_notationGroupBox = new TQGroupBox
(1, TQt::Horizontal, i18n("Notation Properties"), vbox);
@ -197,8 +197,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addMultiCellWidget(m_lockNotationValues, 0, 0, 0, 2);
m_lockNotationValues->setChecked(true);
connect(m_lockNotationValues, TQT_SIGNAL(released()),
TQT_SLOT(slotLockNotationChanged()));
connect(m_lockNotationValues, TQ_SIGNAL(released()),
TQ_SLOT(slotLockNotationChanged()));
m_notationTimeLabel = new TQLabel(i18n("Notation time:"), frame);
layout->addWidget(m_notationTimeLabel, 1, 0);
@ -207,10 +207,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_notationTimeSpinBox, 1, 1);
layout->addWidget(m_notationTimeEditButton, 1, 2);
connect(m_notationTimeSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotNotationAbsoluteTimeChanged(int)));
connect(m_notationTimeEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditNotationAbsoluteTime()));
connect(m_notationTimeSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotNotationAbsoluteTimeChanged(int)));
connect(m_notationTimeEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditNotationAbsoluteTime()));
m_notationDurationLabel = new TQLabel(i18n("Notation duration:"), frame);
layout->addWidget(m_notationDurationLabel, 2, 0);
@ -219,10 +219,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_notationDurationSpinBox, 2, 1);
layout->addWidget(m_notationDurationEditButton, 2, 2);
connect(m_notationDurationSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotNotationDurationChanged(int)));
connect(m_notationDurationEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditNotationDuration()));
connect(m_notationDurationSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotNotationDurationChanged(int)));
connect(m_notationDurationEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditNotationDuration()));
setupForEvent();
}

42
src/gui/dialogs/TempoDialog.cpp
Unescape View File

@ -68,12 +68,12 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
m_tempoValueSpinBox = new HSpinBox(frame, 0, 100000, 0.0, 1000.0, 5);
layout->addWidget(m_tempoValueSpinBox, 0, 2);
connect(m_tempoValueSpinBox, TQT_SIGNAL(valueChanged(const TQString &)),
TQT_SLOT(slotTempoChanged(const TQString &)));
connect(m_tempoValueSpinBox, TQ_SIGNAL(valueChanged(const TQString &)),
TQ_SLOT(slotTempoChanged(const TQString &)));
m_tempoTap= new TQPushButton(i18n("Tap"), frame);
layout->addWidget(m_tempoTap, 0, 3);
connect(m_tempoTap, TQT_SIGNAL(clicked()), TQT_SLOT(slotTapClicked()));
connect(m_tempoTap, TQ_SIGNAL(clicked()), TQ_SLOT(slotTapClicked()));
m_tempoConstant = new TQRadioButton(i18n("Tempo is fixed until the following tempo change"), frame);
@ -91,16 +91,16 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
layout->addWidget(m_tempoRampToTarget, 3, 1);
layout->addWidget(m_tempoTargetSpinBox, 3, 2);
// connect(m_tempoTargetCheckBox, TQT_SIGNAL(clicked()),
// TQT_SLOT(slotTargetCheckBoxClicked()));
connect(m_tempoConstant, TQT_SIGNAL(clicked()),
TQT_SLOT(slotTempoConstantClicked()));
connect(m_tempoRampToNext, TQT_SIGNAL(clicked()),
TQT_SLOT(slotTempoRampToNextClicked()));
connect(m_tempoRampToTarget, TQT_SIGNAL(clicked()),
TQT_SLOT(slotTempoRampToTargetClicked()));
connect(m_tempoTargetSpinBox, TQT_SIGNAL(valueChanged(const TQString &)),
TQT_SLOT(slotTargetChanged(const TQString &)));
// connect(m_tempoTargetCheckBox, TQ_SIGNAL(clicked()),
// TQ_SLOT(slotTargetCheckBoxClicked()));
connect(m_tempoConstant, TQ_SIGNAL(clicked()),
TQ_SLOT(slotTempoConstantClicked()));
connect(m_tempoRampToNext, TQ_SIGNAL(clicked()),
TQ_SLOT(slotTempoRampToNextClicked()));
connect(m_tempoRampToTarget, TQ_SIGNAL(clicked()),
TQ_SLOT(slotTempoRampToTargetClicked()));
connect(m_tempoTargetSpinBox, TQ_SIGNAL(valueChanged(const TQString &)),
TQ_SLOT(slotTargetChanged(const TQString &)));
m_tempoBeatLabel = new TQLabel(frame);
layout->addWidget(m_tempoBeatLabel, 0, 4);
@ -173,14 +173,14 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
// new TQLabel(scopeBox);
connect(m_tempoChangeHere, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeBefore, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeStartOfBar, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeGlobal, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeHere, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeBefore, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeStartOfBar, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeGlobal, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
m_tempoChangeHere->setChecked(true);

34
src/gui/dialogs/TextEventDialog.cpp
Unescape View File

@ -327,23 +327,23 @@ TextEventDialog::TextEventDialog(TQWidget *parent,
m_prevLyric = config->readEntry("previous_lyric", "");
m_prevAnnotation = config->readEntry("previous_annotation", "");
TQObject::connect(m_text, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotTextChanged(const TQString &)));
TQObject::connect(m_typeCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTypeChanged(const TQString &)));
TQObject::connect(this, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotOK()));
TQObject::connect(m_dynamicShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotDynamicShortcutChanged(const TQString &)));
TQObject::connect(m_directionShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_localDirectionShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLocalDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_tempoShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTempoShortcutChanged(const TQString &)));
TQObject::connect(m_localTempoShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLocalTempoShortcutChanged(const TQString &)));
TQObject::connect(m_lilyPondDirectiveCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLilyPondDirectiveChanged(const TQString &)));
TQObject::connect(m_text, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotTextChanged(const TQString &)));
TQObject::connect(m_typeCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotTypeChanged(const TQString &)));
TQObject::connect(this, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotOK()));
TQObject::connect(m_dynamicShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotDynamicShortcutChanged(const TQString &)));
TQObject::connect(m_directionShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_localDirectionShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotLocalDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_tempoShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotTempoShortcutChanged(const TQString &)));
TQObject::connect(m_localTempoShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotLocalTempoShortcutChanged(const TQString &)));
TQObject::connect(m_lilyPondDirectiveCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotLilyPondDirectiveChanged(const TQString &)));
m_text->setFocus();
slotTypeChanged(strtoqstr(getTextType()));

8
src/gui/dialogs/TimeDialog.cpp
Unescape View File

@ -47,8 +47,8 @@ TimeDialog::TimeDialog(TQWidget *parent, TQString title,
constrainToCompositionDuration);
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_timeWidget, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_timeWidget, TQ_SLOT(slotResetToDefault()));
}
TimeDialog::TimeDialog(TQWidget *parent, TQString title,
@ -64,8 +64,8 @@ TimeDialog::TimeDialog(TQWidget *parent, TQString title,
constrainToCompositionDuration);
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_timeWidget, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_timeWidget, TQ_SLOT(slotResetToDefault()));
}
timeT

12
src/gui/dialogs/TimeSignatureDialog.cpp
Unescape View File

@ -103,10 +103,10 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
BigArrowButton *numUp = new BigArrowButton(numBox, TQt::RightArrow);
BigArrowButton *denomUp = new BigArrowButton(denomBox, TQt::RightArrow);
TQObject::connect(numDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNumDown()));
TQObject::connect(numUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNumUp()));
TQObject::connect(denomDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDenomDown()));
TQObject::connect(denomUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDenomUp()));
TQObject::connect(numDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNumDown()));
TQObject::connect(numUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNumUp()));
TQObject::connect(denomDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDenomDown()));
TQObject::connect(denomUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDenomUp()));
if (timeEditable) {
@ -190,8 +190,8 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
m_normalizeRestsButton->setChecked
(config->readBoolEntry("timesigdialognormalize", true));
TQObject::connect(m_hideSignatureButton, TQT_SIGNAL(clicked()), this,
TQT_SLOT(slotUpdateCommonTimeButton()));
TQObject::connect(m_hideSignatureButton, TQ_SIGNAL(clicked()), this,
TQ_SLOT(slotUpdateCommonTimeButton()));
slotUpdateCommonTimeButton();
m_explanatoryLabel = explanatoryLabel;

110
src/gui/dialogs/TransportDialog.cpp
Unescape View File

@ -140,41 +140,41 @@ TransportDialog::TransportDialog(TQWidget *parent,
m_midiOutTimer = new TQTimer(this);
m_clearMetronomeTimer = new TQTimer(this);
connect(m_midiInTimer, TQT_SIGNAL(timeout()),
TQT_SLOT(slotClearMidiInLabel()));
connect(m_midiInTimer, TQ_SIGNAL(timeout()),
TQ_SLOT(slotClearMidiInLabel()));
connect(m_midiOutTimer, TQT_SIGNAL(timeout()),
TQT_SLOT(slotClearMidiOutLabel()));
connect(m_midiOutTimer, TQ_SIGNAL(timeout()),
TQ_SLOT(slotClearMidiOutLabel()));
connect(m_clearMetronomeTimer, TQT_SIGNAL(timeout()),
TQT_SLOT(slotResetBackground()));
connect(m_clearMetronomeTimer, TQ_SIGNAL(timeout()),
TQ_SLOT(slotResetBackground()));
m_transport->TimeDisplayLabel->hide();
m_transport->ToEndLabel->hide();
connect(m_transport->TimeDisplayButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotChangeTimeDisplay()));
connect(m_transport->TimeDisplayButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotChangeTimeDisplay()));
connect(m_transport->ToEndButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotChangeToEnd()));
connect(m_transport->ToEndButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotChangeToEnd()));
connect(m_transport->LoopButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotLoopButtonClicked()));
connect(m_transport->LoopButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotLoopButtonClicked()));
connect(m_transport->PanelOpenButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPanelOpenButtonClicked()));
connect(m_transport->PanelOpenButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPanelOpenButtonClicked()));
connect(m_transport->PanelCloseButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPanelCloseButtonClicked()));
connect(m_transport->PanelCloseButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPanelCloseButtonClicked()));
connect(m_transport->PanicButton, TQT_SIGNAL(clicked()), TQT_SIGNAL(panic()));
connect(m_transport->PanicButton, TQ_SIGNAL(clicked()), TQ_SIGNAL(panic()));
m_panelOpen = *m_transport->PanelOpenButton->pixmap();
m_panelClosed = *m_transport->PanelCloseButton->pixmap();
connect(m_transport->SetStartLPButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetStartLoopingPointAtMarkerPos()));
connect(m_transport->SetStopLPButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetStopLoopingPointAtMarkerPos()));
connect(m_transport->SetStartLPButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetStartLoopingPointAtMarkerPos()));
connect(m_transport->SetStopLPButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetStopLoopingPointAtMarkerPos()));
// clear labels
//
@ -216,46 +216,46 @@ TransportDialog::TransportDialog(TQWidget *parent,
m_transport->TempoDisplay->setFont( localFont );
m_transport->TimeSigDisplay->setFont( localFont );
connect(m_transport->TempoDisplay, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTempo()));
connect(m_transport->TempoDisplay, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTempo()));
connect(m_transport->TempoDisplay, TQT_SIGNAL(scrollWheel(int)),
this, TQT_SIGNAL(scrollTempo(int)));
connect(m_transport->TempoDisplay, TQ_SIGNAL(scrollWheel(int)),
this, TQ_SIGNAL(scrollTempo(int)));
connect(m_transport->TimeSigDisplay, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTimeSignature()));
connect(m_transport->TimeSigDisplay, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTimeSignature()));
// toil through the individual pixmaps
connect(m_transport->NegativePixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenHoursPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->UnitHoursPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->HourColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenMinutesPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->UnitMinutesPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->MinuteColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenSecondsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->UnitSecondsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->SecondColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->HundredthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->HundredthColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenThousandthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->ThousandthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->NegativePixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenHoursPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitHoursPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->HourColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenMinutesPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitMinutesPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->MinuteColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenSecondsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitSecondsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->SecondColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->HundredthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->HundredthColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenThousandthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->ThousandthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
// accelerator object
//

22
src/gui/dialogs/TupletDialog.cpp
Unescape View File

@ -103,7 +103,7 @@ TupletDialog::TupletDialog(TQWidget *parent, Note::Type defaultUnitType,
m_hasTimingAlready->setChecked(false);
timingLayout->addMultiCellWidget(m_hasTimingAlready, 2, 2, 0, 2);
connect(m_hasTimingAlready, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotHasTimingChanged()));
connect(m_hasTimingAlready, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHasTimingChanged()));
updateUntupledCombo();
updateTupledCombo();
@ -157,18 +157,18 @@ TupletDialog::TupletDialog(TQWidget *parent, Note::Type defaultUnitType,
updateTimingDisplays();
TQObject::connect(m_unitCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotUnitChanged(const TQString &)));
TQObject::connect(m_unitCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotUnitChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotTupledChanged(const TQString &)));
}
void

2
src/gui/dialogs/UseOrnamentDialog.cpp
Unescape View File

@ -91,7 +91,7 @@ UseOrnamentDialog::UseOrnamentDialog(TQWidget *parent,
}
m_mark->insertItem(i18n("Text mark"));
connect(m_mark, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMarkChanged(int)));
connect(m_mark, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotMarkChanged(int)));
m_textLabel = new TQLabel(i18n(" Text: "), frame);
layout->addWidget(m_textLabel, 0, 2);

46
src/gui/editors/eventlist/EventView.cpp
Unescape View File

@ -141,8 +141,8 @@ EventView::EventView(RosegardenGUIDoc *doc,
// Connect up
//
connect(m_filterGroup, TQT_SIGNAL(released(int)),
TQT_SLOT(slotModifyFilter(int)));
connect(m_filterGroup, TQ_SIGNAL(released(int)),
TQ_SLOT(slotModifyFilter(int)));
m_eventList = new TDEListView(getCentralWidget());
m_eventList->setItemsRenameable(true);
@ -169,21 +169,21 @@ EventView::EventView(RosegardenGUIDoc *doc,
layout->addWidget(m_triggerName, 0, 1);
TQPushButton *editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 0, 2);
connect(editButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotEditTriggerName()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditTriggerName()));
layout->addWidget(new TQLabel(i18n("Base pitch: "), frame), 1, 0);
m_triggerPitch = new TQLabel(TQString("%1").arg(rec->getBasePitch()), frame);
layout->addWidget(m_triggerPitch, 1, 1);
editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 1, 2);
connect(editButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotEditTriggerPitch()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditTriggerPitch()));
layout->addWidget(new TQLabel(i18n("Base velocity: "), frame), 2, 0);
m_triggerVelocity = new TQLabel(TQString("%1").arg(rec->getBaseVelocity()), frame);
layout->addWidget(m_triggerVelocity, 2, 1);
editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 2, 2);
connect(editButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotEditTriggerVelocity()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditTriggerVelocity()));
/*!!! Comment out these two options, which are not yet used
anywhere else -- intended for use with library ornaments, not
@ -209,11 +209,11 @@ EventView::EventView(RosegardenGUIDoc *doc,
adjust->setCurrentItem(2);
}
connect(adjust, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotTriggerTimeAdjustChanged(int)));
connect(adjust, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotTriggerTimeAdjustChanged(int)));
TQCheckBox *retune = new TQCheckBox(i18n("Adjust pitch to trigger note by default"), frame);
retune->setChecked(rec->getDefaultRetune());
connect(retune, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotTriggerRetuneChanged()));
connect(retune, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotTriggerRetuneChanged()));
layout->addMultiCellWidget(retune, 4, 4, 1, 2);
*/
@ -230,12 +230,12 @@ EventView::EventView(RosegardenGUIDoc *doc,
// Connect double clicker
//
connect(m_eventList, TQT_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotPopupEventEditor(TQListViewItem*)));
connect(m_eventList, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQ_SLOT(slotPopupEventEditor(TQListViewItem*)));
connect(m_eventList,
TQT_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(slotPopupMenu(TQListViewItem*, const TQPoint&, int)));
TQ_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
TQ_SLOT(slotPopupMenu(TQListViewItem*, const TQPoint&, int)));
m_eventList->setAllColumnsShowFocus(true);
m_eventList->setSelectionMode(TQListView::Extended);
@ -1119,41 +1119,41 @@ EventView::setupActions()
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert.png"));
new TDEAction(i18n("&Insert Event"), icon, Key_I, this,
TQT_SLOT(slotEditInsert()), actionCollection(),
TQ_SLOT(slotEditInsert()), actionCollection(),
"insert");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-delete.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Delete Event"), icon, Key_Delete, this,
TQT_SLOT(slotEditDelete()), actionCollection(),
TQ_SLOT(slotEditDelete()), actionCollection(),
"delete");
pixmap.load(pixmapDir + "/toolbar/event-edit.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Edit Event"), icon, Key_E, this,
TQT_SLOT(slotEditEvent()), actionCollection(),
TQ_SLOT(slotEditEvent()), actionCollection(),
"edit_simple");
pixmap.load(pixmapDir + "/toolbar/event-edit-advanced.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Advanced Event Editor"), icon, Key_A, this,
TQT_SLOT(slotEditEventAdvanced()), actionCollection(),
TQ_SLOT(slotEditEventAdvanced()), actionCollection(),
"edit_advanced");
// icon = TQIconSet(TQCanvasPixmap(pixmapDir + "/toolbar/eventfilter.xpm"));
new TDEAction(i18n("&Filter Selection"), "filter", Key_F, this,
TQT_SLOT(slotFilterSelection()), actionCollection(),
TQ_SLOT(slotFilterSelection()), actionCollection(),
"filter_selection");
new TDEAction(i18n("Select &All"), Key_A + CTRL, this,
TQT_SLOT(slotSelectAll()), actionCollection(),
TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all");
new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQT_SLOT(slotClearSelection()), actionCollection(),
TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection");
m_config->setGroup(EventViewConfigGroup);
@ -1165,7 +1165,7 @@ EventView::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()),
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -1175,7 +1175,7 @@ EventView::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()),
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -1185,7 +1185,7 @@ EventView::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()),
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)
@ -1516,8 +1516,8 @@ EventView::createMenu()
m_menu->insertItem(i18n("Open in Event Editor"), 0);
m_menu->insertItem(i18n("Open in Expert Event Editor"), 1);
connect(m_menu, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotMenuActivated(int)));
connect(m_menu, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotMenuActivated(int)));
}
void

4
src/gui/editors/guitar/GuitarChordEditorDialog.cpp
Unescape View File

@ -50,8 +50,8 @@ GuitarChordEditorDialog::GuitarChordEditorDialog(Guitar::Chord& chord, const Gui
m_startFret = new TQSpinBox(1, 24, 1, page);
topLayout->addWidget(m_startFret, 1, 1);
connect(m_startFret, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotStartFretChanged(int)));
connect(m_startFret, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotStartFretChanged(int)));
topLayout->addWidget(new TQLabel(i18n("Root"), page), 2, 1);
m_rootNotesList = new TQComboBox(page);

28
src/gui/editors/guitar/GuitarChordSelectorDialog.cpp
Unescape View File

@ -63,8 +63,8 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
m_chordComplexityCombo->insertItem(i18n("common"));
m_chordComplexityCombo->insertItem(i18n("all"));
connect(m_chordComplexityCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotComplexityChanged(int)));
connect(m_chordComplexityCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotComplexityChanged(int)));
TQVBoxLayout* vboxLayout = new TQVBoxLayout(page, 5);
topLayout->addMultiCellLayout(vboxLayout, 1, 3, 2, 2);
@ -74,12 +74,12 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
vboxLayout->addWidget(m_deleteFingeringButton);
vboxLayout->addWidget(m_editFingeringButton);
connect(m_newFingeringButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotNewFingering()));
connect(m_deleteFingeringButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteFingering()));
connect(m_editFingeringButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEditFingering()));
connect(m_newFingeringButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotNewFingering()));
connect(m_deleteFingeringButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteFingering()));
connect(m_editFingeringButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEditFingering()));
topLayout->addWidget(new TQLabel(i18n("Fingerings"), page), 0, 3);
m_fingeringsList = new TQListBox(page);
@ -88,12 +88,12 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
m_fingeringBox = new FingeringBox(false, page);
topLayout->addMultiCellWidget(m_fingeringBox, 2, 2, 0, 1);
connect(m_rootNotesList, TQT_SIGNAL(highlighted(int)),
this, TQT_SLOT(slotRootHighlighted(int)));
connect(m_chordExtList, TQT_SIGNAL(highlighted(int)),
this, TQT_SLOT(slotChordExtHighlighted(int)));
connect(m_fingeringsList, TQT_SIGNAL(highlighted(TQListBoxItem*)),
this, TQT_SLOT(slotFingeringHighlighted(TQListBoxItem*)));
connect(m_rootNotesList, TQ_SIGNAL(highlighted(int)),
this, TQ_SLOT(slotRootHighlighted(int)));
connect(m_chordExtList, TQ_SIGNAL(highlighted(int)),
this, TQ_SLOT(slotChordExtHighlighted(int)));
connect(m_fingeringsList, TQ_SIGNAL(highlighted(TQListBoxItem*)),
this, TQ_SLOT(slotFingeringHighlighted(TQListBoxItem*)));
}
void

8
src/gui/editors/matrix/MatrixEraser.cpp
Unescape View File

@ -50,21 +50,21 @@ MatrixEraser::MatrixEraser(MatrixView* parent)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
pixmap.load(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixeraser.rc");

24
src/gui/editors/matrix/MatrixMover.cpp
Unescape View File

@ -63,21 +63,21 @@ MatrixMover::MatrixMover(MatrixView* parent) :
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
pixmap.load(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixmover.rc");
@ -418,20 +418,20 @@ void MatrixMover::handleMouseRelease(timeT newTime,
void MatrixMover::ready()
{
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(this, TQT_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQT_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
connect(this, TQ_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQ_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
m_mParentView->setCanvasCursor(TQt::sizeAllCursor);
setBasicContextHelp();
}
void MatrixMover::stow()
{
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(this, TQT_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQT_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
disconnect(this, TQ_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQ_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
}
void MatrixMover::slotMatrixScrolled(int newX, int newY)

16
src/gui/editors/matrix/MatrixPainter.cpp
Unescape View File

@ -61,21 +61,21 @@ MatrixPainter::MatrixPainter(MatrixView* parent)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
pixmap.load(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixpainter.rc");
@ -318,8 +318,8 @@ void MatrixPainter::handleMouseRelease(timeT endTime,
void MatrixPainter::ready()
{
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
m_mParentView->setCanvasCursor(TQt::crossCursor);
@ -328,8 +328,8 @@ void MatrixPainter::ready()
void MatrixPainter::stow()
{
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
}
void MatrixPainter::slotMatrixScrolled(int newX, int newY)

16
src/gui/editors/matrix/MatrixResizer.cpp
Unescape View File

@ -59,19 +59,19 @@ MatrixResizer::MatrixResizer(MatrixView* parent)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
createMenu("matrixresizer.rc");
@ -287,16 +287,16 @@ void MatrixResizer::handleMouseRelease(timeT newTime,
void MatrixResizer::ready()
{
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
m_mParentView->setCanvasCursor(TQt::sizeHorCursor);
setBasicContextHelp();
}
void MatrixResizer::stow()
{
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
}
void MatrixResizer::slotMatrixScrolled(int newX, int newY)

22
src/gui/editors/matrix/MatrixSelector.cpp
Unescape View File

@ -69,19 +69,19 @@ MatrixSelector::MatrixSelector(MatrixView* view)
m_matrixView(view),
m_selectionToMerge(0)
{
connect(m_parentView, TQT_SIGNAL(usedSelection()),
this, TQT_SLOT(slotHideSelection()));
connect(m_parentView, TQ_SIGNAL(usedSelection()),
this, TQ_SLOT(slotHideSelection()));
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
@ -89,7 +89,7 @@ MatrixSelector::MatrixSelector(MatrixView* view)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixselector.rc");
@ -316,7 +316,7 @@ void MatrixSelector::handleMouseDoubleClick(timeT ,
m_justSelectedBar = true;
TQTimer::singleShot(TQApplication::doubleClickInterval(), this,
TQT_SLOT(slotClickTimeout()));
TQ_SLOT(slotClickTimeout()));
} */
}
@ -445,8 +445,8 @@ void MatrixSelector::ready()
//m_mParentView->setPositionTracking(false);
}
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
setContextHelp(i18n("Click and drag to select; middle-click and drag to draw new note"));
}
@ -459,8 +459,8 @@ void MatrixSelector::stow()
m_mParentView->canvas()->update();
}
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
}

288
src/gui/editors/matrix/MatrixView.cpp
Unescape View File

@ -173,14 +173,14 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
KDockWidget::DockLeft, // dock site
20); // relation target/this (in percent)
connect(m_dockLeft, TQT_SIGNAL(iMBeingClosed()),
this, TQT_SLOT(slotParametersClosed()));
connect(m_dockLeft, TQT_SIGNAL(hasUndocked()),
this, TQT_SLOT(slotParametersClosed()));
connect(m_dockLeft, TQ_SIGNAL(iMBeingClosed()),
this, TQ_SLOT(slotParametersClosed()));
connect(m_dockLeft, TQ_SIGNAL(hasUndocked()),
this, TQ_SLOT(slotParametersClosed()));
// Apparently, hasUndocked() is emitted when the dock widget's
// 'close' button on the dock handle is clicked.
connect(m_mainDockWidget, TQT_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
this, TQT_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
connect(m_mainDockWidget, TQ_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
this, TQ_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
Composition &comp = doc->getComposition();
@ -188,8 +188,8 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
initStatusBar();
connect(m_toolBox, TQT_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SLOT(slotToolHelpChanged(const TQString &)));
connect(m_toolBox, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQ_SLOT(slotToolHelpChanged(const TQString &)));
TQCanvas *tCanvas = new TQCanvas(this);
@ -276,33 +276,33 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
RosegardenGUIApp *app = RosegardenGUIApp::self();
connect(app,
TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
m_parameterBox,
TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
connect(app,
TQT_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
TQ_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
m_parameterBox,
TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
TQ_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
connect(app,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_parameterBox,
TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(m_parameterBox,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
app,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
connect(m_parameterBox,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
app,
TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
TQ_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
connect(m_parameterBox,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
app,
TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
TQ_SLOT(slotShowPluginGUI(InstrumentId, int)));
connect(parent, // RosegardenGUIView
TQT_SIGNAL(checkTrackAssignments()),
TQ_SIGNAL(checkTrackAssignments()),
this,
TQT_SLOT(slotCheckTrackAssignments()));
TQ_SLOT(slotCheckTrackAssignments()));
// Assign the instrument
//
@ -310,9 +310,9 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
if (m_drumMode) {
connect(m_parameterBox,
TQT_SIGNAL(instrumentPercussionSetChanged(Instrument *)),
TQ_SIGNAL(instrumentPercussionSetChanged(Instrument *)),
this,
TQT_SLOT(slotPercussionSetChanged(Instrument *)));
TQ_SLOT(slotPercussionSetChanged(Instrument *)));
}
// Set the snap grid from the stored size in the segment
@ -350,83 +350,83 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
// Connect vertical scrollbars between matrix and piano
//
connect(m_canvasView->verticalScrollBar(), TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView->verticalScrollBar(), TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView->verticalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
this, TQT_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView->verticalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
this, TQ_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView, TQT_SIGNAL(zoomIn()), this, TQT_SLOT(slotZoomIn()));
connect(m_canvasView, TQT_SIGNAL(zoomOut()), this, TQT_SLOT(slotZoomOut()));
connect(m_canvasView, TQ_SIGNAL(zoomIn()), this, TQ_SLOT(slotZoomIn()));
connect(m_canvasView, TQ_SIGNAL(zoomOut()), this, TQ_SLOT(slotZoomOut()));
connect(m_pianoView, TQT_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_canvasView, TQT_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
connect(m_pianoView, TQ_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_canvasView, TQ_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
// ensure the piano keyb keeps the right margins when the user toggles
// the canvas view rulers
//
connect(m_canvasView, TQT_SIGNAL(bottomWidgetHeightChanged(int)),
this, TQT_SLOT(slotCanvasBottomWidgetHeightChanged(int)));
connect(m_canvasView, TQ_SIGNAL(bottomWidgetHeightChanged(int)),
this, TQ_SLOT(slotCanvasBottomWidgetHeightChanged(int)));
connect(m_canvasView, TQT_SIGNAL(mouseEntered()),
this, TQT_SLOT(slotMouseEnteredCanvasView()));
connect(m_canvasView, TQ_SIGNAL(mouseEntered()),
this, TQ_SLOT(slotMouseEnteredCanvasView()));
connect(m_canvasView, TQT_SIGNAL(mouseLeft()),
this, TQT_SLOT(slotMouseLeftCanvasView()));
connect(m_canvasView, TQ_SIGNAL(mouseLeft()),
this, TQ_SLOT(slotMouseLeftCanvasView()));
/*
TQObject::connect
(getCanvasView(), TQT_SIGNAL(activeItemPressed(TQMouseEvent*, TQCanvasItem*)),
this, TQT_SLOT (activeItemPressed(TQMouseEvent*, TQCanvasItem*)));
(getCanvasView(), TQ_SIGNAL(activeItemPressed(TQMouseEvent*, TQCanvasItem*)),
this, TQ_SLOT (activeItemPressed(TQMouseEvent*, TQCanvasItem*)));
*/
TQObject::connect
(getCanvasView(),
TQT_SIGNAL(mousePressed(timeT,
TQ_SIGNAL(mousePressed(timeT,
int, TQMouseEvent*, MatrixElement*)),
this,
TQT_SLOT(slotMousePressed(timeT,
TQ_SLOT(slotMousePressed(timeT,
int, TQMouseEvent*, MatrixElement*)));
TQObject::connect
(getCanvasView(),
TQT_SIGNAL(mouseMoved(timeT, int, TQMouseEvent*)),
TQ_SIGNAL(mouseMoved(timeT, int, TQMouseEvent*)),
this,
TQT_SLOT(slotMouseMoved(timeT, int, TQMouseEvent*)));
TQ_SLOT(slotMouseMoved(timeT, int, TQMouseEvent*)));
TQObject::connect
(getCanvasView(),
TQT_SIGNAL(mouseReleased(timeT, int, TQMouseEvent*)),
TQ_SIGNAL(mouseReleased(timeT, int, TQMouseEvent*)),
this,
TQT_SLOT(slotMouseReleased(timeT, int, TQMouseEvent*)));
TQ_SLOT(slotMouseReleased(timeT, int, TQMouseEvent*)));
TQObject::connect
(getCanvasView(), TQT_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
this, TQT_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
(getCanvasView(), TQ_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
this, TQ_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(hoveredOverKeyChanged(unsigned int)),
this, TQT_SLOT (slotHoveredOverKeyChanged(unsigned int)));
(m_pitchRuler, TQ_SIGNAL(hoveredOverKeyChanged(unsigned int)),
this, TQ_SLOT (slotHoveredOverKeyChanged(unsigned int)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(keyPressed(unsigned int, bool)),
this, TQT_SLOT (slotKeyPressed(unsigned int, bool)));
(m_pitchRuler, TQ_SIGNAL(keyPressed(unsigned int, bool)),
this, TQ_SLOT (slotKeyPressed(unsigned int, bool)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(keySelected(unsigned int, bool)),
this, TQT_SLOT (slotKeySelected(unsigned int, bool)));
(m_pitchRuler, TQ_SIGNAL(keySelected(unsigned int, bool)),
this, TQ_SLOT (slotKeySelected(unsigned int, bool)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(keyReleased(unsigned int, bool)),
this, TQT_SLOT (slotKeyReleased(unsigned int, bool)));
(m_pitchRuler, TQ_SIGNAL(keyReleased(unsigned int, bool)),
this, TQ_SLOT (slotKeyReleased(unsigned int, bool)));
TQObject::connect
(getCanvasView(), TQT_SIGNAL(hoveredOverAbsoluteTimeChanged(unsigned int)),
this, TQT_SLOT (slotHoveredOverAbsoluteTimeChanged(unsigned int)));
(getCanvasView(), TQ_SIGNAL(hoveredOverAbsoluteTimeChanged(unsigned int)),
this, TQ_SLOT (slotHoveredOverAbsoluteTimeChanged(unsigned int)));
TQObject::connect
(doc, TQT_SIGNAL(pointerPositionChanged(timeT)),
this, TQT_SLOT(slotSetPointerPosition(timeT)));
(doc, TQ_SIGNAL(pointerPositionChanged(timeT)),
this, TQ_SLOT(slotSetPointerPosition(timeT)));
MATRIX_DEBUG << "MatrixView : applying layout\n";
@ -463,32 +463,32 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
TQObject::disconnect
(topStandardRuler->getLoopRuler(),
TQT_SIGNAL(setPointerPosition(timeT)), 0, 0);
TQ_SIGNAL(setPointerPosition(timeT)), 0, 0);
TQObject::connect
(topStandardRuler->getLoopRuler(),
TQT_SIGNAL(setPointerPosition(timeT)),
this, TQT_SLOT(slotSetInsertCursorPosition(timeT)));
TQ_SIGNAL(setPointerPosition(timeT)),
this, TQ_SLOT(slotSetInsertCursorPosition(timeT)));
TQObject::connect
(topStandardRuler,
TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SLOT(slotSetInsertCursorPosition(timeT)));
TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotSetInsertCursorPosition(timeT)));
topStandardRuler->getLoopRuler()->setBackgroundColor
(GUIPalette::getColour(GUIPalette::InsertCursorRuler));
connect(topStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_canvasView, TQT_SLOT(startAutoScroll(int)));
connect(topStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_canvasView, TQT_SLOT(stopAutoScroll()));
connect(topStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_canvasView, TQ_SLOT(startAutoScroll(int)));
connect(topStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_canvasView, TQ_SLOT(stopAutoScroll()));
connect(bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_canvasView, TQT_SLOT(startAutoScroll(int)));
connect(bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_canvasView, TQT_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SLOT(slotSetPointerPosition(timeT)));
connect(bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_canvasView, TQ_SLOT(startAutoScroll(int)));
connect(bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_canvasView, TQ_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotSetPointerPosition(timeT)));
// Force height for the moment
//
@ -637,148 +637,148 @@ void MatrixView::setupActions()
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/select.xpm"));
toolAction = new TDERadioAction(i18n("&Select and Edit"), icon, Key_F2,
this, TQT_SLOT(slotSelectSelected()),
this, TQ_SLOT(slotSelectSelected()),
actionCollection(), "select");
toolAction->setExclusiveGroup("tools");
toolAction = new TDERadioAction(i18n("&Draw"), "pencil", Key_F3,
this, TQT_SLOT(slotPaintSelected()),
this, TQ_SLOT(slotPaintSelected()),
actionCollection(), "draw");
toolAction->setExclusiveGroup("tools");
toolAction = new TDERadioAction(i18n("&Erase"), "eraser", Key_F4,
this, TQT_SLOT(slotEraseSelected()),
this, TQ_SLOT(slotEraseSelected()),
actionCollection(), "erase");
toolAction->setExclusiveGroup("tools");
toolAction = new TDERadioAction(i18n("&Move"), "move", Key_F5,
this, TQT_SLOT(slotMoveSelected()),
this, TQ_SLOT(slotMoveSelected()),
actionCollection(), "move");
toolAction->setExclusiveGroup("tools");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
toolAction = new TDERadioAction(i18n("Resi&ze"), icon, Key_F6,
this, TQT_SLOT(slotResizeSelected()),
this, TQ_SLOT(slotResizeSelected()),
actionCollection(), "resize");
toolAction->setExclusiveGroup("tools");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap("chord")));
(new TDEToggleAction(i18n("C&hord Insert Mode"), icon, Key_H,
this, TQT_SLOT(slotUpdateInsertModeStatus()),
this, TQ_SLOT(slotUpdateInsertModeStatus()),
actionCollection(), "chord_mode"))->
setChecked(false);
pixmap.load(pixmapDir + "/toolbar/step_by_step.xpm");
icon = TQIconSet(pixmap);
new TDEToggleAction(i18n("Ste&p Recording"), icon, 0, this,
TQT_SLOT(slotToggleStepByStep()), actionCollection(),
TQ_SLOT(slotToggleStepByStep()), actionCollection(),
"toggle_step_by_step");
pixmap.load(pixmapDir + "/toolbar/quantize.png");
icon = TQIconSet(pixmap);
new TDEAction(EventQuantizeCommand::getGlobalName(), icon, Key_Equal, this,
TQT_SLOT(slotTransformsQuantize()), actionCollection(),
TQ_SLOT(slotTransformsQuantize()), actionCollection(),
"quantize");
new TDEAction(i18n("Repeat Last Quantize"), Key_Plus, this,
TQT_SLOT(slotTransformsRepeatQuantize()), actionCollection(),
TQ_SLOT(slotTransformsRepeatQuantize()), actionCollection(),
"repeat_quantize");
new TDEAction(CollapseNotesCommand::getGlobalName(), Key_Equal + CTRL, this,
TQT_SLOT(slotTransformsCollapseNotes()), actionCollection(),
TQ_SLOT(slotTransformsCollapseNotes()), actionCollection(),
"collapse_notes");
new TDEAction(i18n("&Legato"), Key_Minus, this,
TQT_SLOT(slotTransformsLegato()), actionCollection(),
TQ_SLOT(slotTransformsLegato()), actionCollection(),
"legatoize");
new TDEAction(ChangeVelocityCommand::getGlobalName(10), 0,
Key_Up + SHIFT, this,
TQT_SLOT(slotVelocityUp()), actionCollection(),
TQ_SLOT(slotVelocityUp()), actionCollection(),
"velocity_up");
new TDEAction(ChangeVelocityCommand::getGlobalName( -10), 0,
Key_Down + SHIFT, this,
TQT_SLOT(slotVelocityDown()), actionCollection(),
TQ_SLOT(slotVelocityDown()), actionCollection(),
"velocity_down");
new TDEAction(i18n("Set to Current Velocity"), 0, this,
TQT_SLOT(slotSetVelocitiesToCurrent()), actionCollection(),
TQ_SLOT(slotSetVelocitiesToCurrent()), actionCollection(),
"set_to_current_velocity");
new TDEAction(i18n("Set Event &Velocities..."), 0, this,
TQT_SLOT(slotSetVelocities()), actionCollection(),
TQ_SLOT(slotSetVelocities()), actionCollection(),
"set_velocities");
new TDEAction(i18n("Trigger Se&gment..."), 0, this,
TQT_SLOT(slotTriggerSegment()), actionCollection(),
TQ_SLOT(slotTriggerSegment()), actionCollection(),
"trigger_segment");
new TDEAction(i18n("Remove Triggers..."), 0, this,
TQT_SLOT(slotRemoveTriggers()), actionCollection(),
TQ_SLOT(slotRemoveTriggers()), actionCollection(),
"remove_trigger");
new TDEAction(i18n("Select &All"), Key_A + CTRL, this,
TQT_SLOT(slotSelectAll()), actionCollection(),
TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all");
new TDEAction(i18n("&Delete"), Key_Delete, this,
TQT_SLOT(slotEditDelete()), actionCollection(),
TQ_SLOT(slotEditDelete()), actionCollection(),
"delete");
new TDEAction(i18n("Cursor &Back"), 0, Key_Left, this,
TQT_SLOT(slotStepBackward()), actionCollection(),
TQ_SLOT(slotStepBackward()), actionCollection(),
"cursor_back");
new TDEAction(i18n("Cursor &Forward"), 0, Key_Right, this,
TQT_SLOT(slotStepForward()), actionCollection(),
TQ_SLOT(slotStepForward()), actionCollection(),
"cursor_forward");
new TDEAction(i18n("Cursor Ba&ck Bar"), 0, Key_Left + CTRL, this,
TQT_SLOT(slotJumpBackward()), actionCollection(),
TQ_SLOT(slotJumpBackward()), actionCollection(),
"cursor_back_bar");
new TDEAction(i18n("Cursor For&ward Bar"), 0, Key_Right + CTRL, this,
TQT_SLOT(slotJumpForward()), actionCollection(),
TQ_SLOT(slotJumpForward()), actionCollection(),
"cursor_forward_bar");
new TDEAction(i18n("Cursor Back and Se&lect"), SHIFT + Key_Left, this,
TQT_SLOT(slotExtendSelectionBackward()), actionCollection(),
TQ_SLOT(slotExtendSelectionBackward()), actionCollection(),
"extend_selection_backward");
new TDEAction(i18n("Cursor Forward and &Select"), SHIFT + Key_Right, this,
TQT_SLOT(slotExtendSelectionForward()), actionCollection(),
TQ_SLOT(slotExtendSelectionForward()), actionCollection(),
"extend_selection_forward");
new TDEAction(i18n("Cursor Back Bar and Select"), SHIFT + CTRL + Key_Left, this,
TQT_SLOT(slotExtendSelectionBackwardBar()), actionCollection(),
TQ_SLOT(slotExtendSelectionBackwardBar()), actionCollection(),
"extend_selection_backward_bar");
new TDEAction(i18n("Cursor Forward Bar and Select"), SHIFT + CTRL + Key_Right, this,
TQT_SLOT(slotExtendSelectionForwardBar()), actionCollection(),
TQ_SLOT(slotExtendSelectionForwardBar()), actionCollection(),
"extend_selection_forward_bar");
new TDEAction(i18n("Cursor to St&art"), 0,
/* #1025717: conflicting meanings for ctrl+a - dupe with Select All
Key_A + CTRL, */ this,
TQT_SLOT(slotJumpToStart()), actionCollection(),
TQ_SLOT(slotJumpToStart()), actionCollection(),
"cursor_start");
new TDEAction(i18n("Cursor to &End"), 0, Key_E + CTRL, this,
TQT_SLOT(slotJumpToEnd()), actionCollection(),
TQ_SLOT(slotJumpToEnd()), actionCollection(),
"cursor_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-cursor-to-pointer")));
new TDEAction(i18n("Cursor to &Playback Pointer"), icon, 0, this,
TQT_SLOT(slotJumpCursorToPlayback()), actionCollection(),
TQ_SLOT(slotJumpCursorToPlayback()), actionCollection(),
"cursor_to_playback_pointer");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQT_SIGNAL(play()), actionCollection(), "play");
TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) );
@ -787,70 +787,70 @@ void MatrixView::setupActions()
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQT_SIGNAL(stop()), actionCollection(), "stop");
TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQT_SIGNAL(rewindPlayback()), actionCollection(),
TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQT_SIGNAL(fastForwardPlayback()), actionCollection(),
TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-pointer-to-cursor")));
new TDEAction(i18n("Playback Pointer to &Cursor"), icon, 0, this,
TQT_SLOT(slotJumpPlaybackToCursor()), actionCollection(),
TQ_SLOT(slotJumpPlaybackToCursor()), actionCollection(),
"playback_pointer_to_cursor");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-solo")));
new TDEToggleAction(i18n("&Solo"), icon, 0, this,
TQT_SLOT(slotToggleSolo()), actionCollection(),
TQ_SLOT(slotToggleSolo()), actionCollection(),
"toggle_solo");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-tracking")));
(new TDEToggleAction(i18n("Scro&ll to Follow Playback"), icon, Key_Pause, this,
TQT_SLOT(slotToggleTracking()), actionCollection(),
TQ_SLOT(slotToggleTracking()), actionCollection(),
"toggle_tracking"))->setChecked(m_playTracking);
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQT_SIGNAL(panic()), actionCollection(), "panic");
TQ_SIGNAL(panic()), actionCollection(), "panic");
new TDEAction(i18n("Set Loop to Selection"), Key_Semicolon + CTRL, this,
TQT_SLOT(slotPreviewSelection()), actionCollection(),
TQ_SLOT(slotPreviewSelection()), actionCollection(),
"preview_selection");
new TDEAction(i18n("Clear L&oop"), Key_Colon + CTRL, this,
TQT_SLOT(slotClearLoop()), actionCollection(),
TQ_SLOT(slotClearLoop()), actionCollection(),
"clear_loop");
new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQT_SLOT(slotClearSelection()), actionCollection(),
TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection");
// icon = TQIconSet(TQCanvasPixmap(pixmapDir + "/toolbar/eventfilter.xpm"));
new TDEAction(i18n("&Filter Selection"), "filter", Key_F + CTRL, this,
TQT_SLOT(slotFilterSelection()), actionCollection(),
TQ_SLOT(slotFilterSelection()), actionCollection(),
"filter_selection");
timeT crotchetDuration = Note(Note::Crotchet).getDuration();
@ -875,16 +875,16 @@ void MatrixView::setupActions()
if (d == SnapGrid::NoSnap) {
new TDEAction(i18n("&No Snap"), 0, this,
TQT_SLOT(slotSetSnapFromAction()),
TQ_SLOT(slotSetSnapFromAction()),
actionCollection(), "snap_none");
} else if (d == SnapGrid::SnapToUnit) {
} else if (d == SnapGrid::SnapToBeat) {
new TDEAction(i18n("Snap to Bea&t"), Key_1, this,
TQT_SLOT(slotSetSnapFromAction()),
TQ_SLOT(slotSetSnapFromAction()),
actionCollection(), "snap_beat");
} else if (d == SnapGrid::SnapToBar) {
new TDEAction(i18n("Snap to &Bar"), Key_5, this,
TQT_SLOT(slotSetSnapFromAction()),
TQ_SLOT(slotSetSnapFromAction()),
actionCollection(), "snap_bar");
} else {
@ -904,7 +904,7 @@ void MatrixView::setupActions()
TQString actionName = TQString("snap_%1").arg(int((crotchetDuration * 4) / d));
if (d == (crotchetDuration * 3) / 2) actionName = "snap_3";
new TDEAction(i18n("Snap to %1").arg(label), pixmap, cut, this,
TQT_SLOT(slotSetSnapFromAction()), actionCollection(),
TQ_SLOT(slotSetSnapFromAction()), actionCollection(),
actionName.ascii());
}
}
@ -913,16 +913,16 @@ void MatrixView::setupActions()
// Settings menu
//
new TDEAction(i18n("Show Instrument Parameters"), 0, this,
TQT_SLOT(slotDockParametersBack()),
TQ_SLOT(slotDockParametersBack()),
actionCollection(),
"show_inst_parameters");
new TDEToggleAction(i18n("Show Ch&ord Name Ruler"), 0, this,
TQT_SLOT(slotToggleChordsRuler()),
TQ_SLOT(slotToggleChordsRuler()),
actionCollection(), "show_chords_ruler");
new TDEToggleAction(i18n("Show &Tempo Ruler"), 0, this,
TQT_SLOT(slotToggleTempoRuler()),
TQ_SLOT(slotToggleTempoRuler()),
actionCollection(), "show_tempo_ruler");
createGUI(getRCFileName(), false);
@ -1312,11 +1312,11 @@ void MatrixView::slotSelectSelected()
{
EditTool* selector = m_toolBox->getTool(MatrixSelector::ToolName);
connect(selector, TQT_SIGNAL(gotSelection()),
this, TQT_SLOT(slotNewSelection()));
connect(selector, TQ_SIGNAL(gotSelection()),
this, TQ_SLOT(slotNewSelection()));
connect(selector, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SIGNAL(editTriggerSegment(int)));
connect(selector, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SIGNAL(editTriggerSegment(int)));
setTool(selector);
}
@ -2147,8 +2147,8 @@ MatrixView::initActionsToolbar()
}
}
connect(m_snapGridCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetSnapFromIndex(int)));
connect(m_snapGridCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetSnapFromIndex(int)));
// Velocity combo. Not a spin box, because the spin box is too
// slow to use unless we make it typeable into, and then it takes
@ -2181,8 +2181,8 @@ MatrixView::initActionsToolbar()
m_quantizeCombo->insertItem(noMap, i18n("Off"));
connect(m_quantizeCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotQuantizeSelection(int)));
connect(m_quantizeCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotQuantizeSelection(int)));
}
void
@ -2224,8 +2224,8 @@ MatrixView::initZoomToolbar()
m_zoomLabel->setFixedWidth(80);
connect(m_hZoomSlider,
TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotChangeHorizontalZoom(int)));
TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotChangeHorizontalZoom(int)));
}
@ -3023,20 +3023,20 @@ MatrixView::slotPercussionSetChanged(Instrument * newInstr)
TQObject::connect
(pitchRuler, TQT_SIGNAL(hoveredOverKeyChanged(unsigned int)),
this, TQT_SLOT (slotHoveredOverKeyChanged(unsigned int)));
(pitchRuler, TQ_SIGNAL(hoveredOverKeyChanged(unsigned int)),
this, TQ_SLOT (slotHoveredOverKeyChanged(unsigned int)));
TQObject::connect
(pitchRuler, TQT_SIGNAL(keyPressed(unsigned int, bool)),
this, TQT_SLOT (slotKeyPressed(unsigned int, bool)));
(pitchRuler, TQ_SIGNAL(keyPressed(unsigned int, bool)),
this, TQ_SLOT (slotKeyPressed(unsigned int, bool)));
TQObject::connect
(pitchRuler, TQT_SIGNAL(keySelected(unsigned int, bool)),
this, TQT_SLOT (slotKeySelected(unsigned int, bool)));
(pitchRuler, TQ_SIGNAL(keySelected(unsigned int, bool)),
this, TQ_SLOT (slotKeySelected(unsigned int, bool)));
TQObject::connect
(pitchRuler, TQT_SIGNAL(keyReleased(unsigned int, bool)),
this, TQT_SLOT (slotKeyReleased(unsigned int, bool)));
(pitchRuler, TQ_SIGNAL(keyReleased(unsigned int, bool)),
this, TQ_SLOT (slotKeyReleased(unsigned int, bool)));
// Replace the old pitchruler widget
m_pitchRuler = pitchRuler;

6
src/gui/editors/notation/ClefInserter.cpp
Unescape View File

@ -49,18 +49,18 @@ ClefInserter::ClefInserter(NotationView* view)
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(),
TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes");
createMenu("clefinserter.rc");

6
src/gui/editors/notation/GuitarChordInserter.cpp
Unescape View File

@ -55,11 +55,11 @@ GuitarChordInserter::GuitarChordInserter(NotationView* view)
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
@ -67,7 +67,7 @@ GuitarChordInserter::GuitarChordInserter(NotationView* view)
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNoteSelected()), actionCollection(),
TQ_SLOT(slotNoteSelected()), actionCollection(),
"notes");
m_guitarChordSelector = new GuitarChordSelectorDialog(m_nParentView);

6
src/gui/editors/notation/NotationEraser.cpp
Unescape View File

@ -50,20 +50,20 @@ NotationEraser::NotationEraser(NotationView* view)
m_collapseRest = config->readBoolEntry("collapse", false);
new TDEToggleAction(i18n("Collapse rests after erase"), 0, this,
TQT_SLOT(slotToggleRestCollapse()), actionCollection(),
TQ_SLOT(slotToggleRestCollapse()), actionCollection(),
"toggle_rest_collapse");
TQIconSet icon
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Insert Tool"), icon, 0, this,
TQT_SLOT(slotInsertSelected()), actionCollection(),
TQ_SLOT(slotInsertSelected()), actionCollection(),
"insert");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
createMenu("notationeraser.rc");

36
src/gui/editors/notation/NotationSelector.cpp
Unescape View File

@ -69,68 +69,68 @@ NotationSelector::NotationSelector(NotationView* view)
m_justSelectedBar(false),
m_wholeStaffSelectionComplete(false)
{
connect(m_parentView, TQT_SIGNAL(usedSelection()),
this, TQT_SLOT(slotHideSelection()));
connect(m_parentView, TQ_SIGNAL(usedSelection()),
this, TQ_SLOT(slotHideSelection()));
connect(this, TQT_SIGNAL(editElement(NotationStaff *, NotationElement *, bool)),
m_parentView, TQT_SLOT(slotEditElement(NotationStaff *, NotationElement *, bool)));
connect(this, TQ_SIGNAL(editElement(NotationStaff *, NotationElement *, bool)),
m_parentView, TQ_SLOT(slotEditElement(NotationStaff *, NotationElement *, bool)));
TQIconSet icon
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEToggleAction(i18n("Switch to Insert Tool"), icon, 0, this,
TQT_SLOT(slotInsertSelected()), actionCollection(),
TQ_SLOT(slotInsertSelected()), actionCollection(),
"insert");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
// (this crashed, and it might be superfluous with ^N anyway, so I'm
// commenting it out, but leaving it here in case I change my mind about
// fooling with it.) (DMM)
// new TDEAction(i18n("Normalize Rests"), 0, 0, this,
// TQT_SLOT(slotCollapseRests()), actionCollection(),
// TQ_SLOT(slotCollapseRests()), actionCollection(),
// "collapse_rests");
new TDEAction(i18n("Collapse Rests"), 0, 0, this,
TQT_SLOT(slotCollapseRestsHard()), actionCollection(),
TQ_SLOT(slotCollapseRestsHard()), actionCollection(),
"collapse_rests_aggressively");
new TDEAction(i18n("Respell as Flat"), 0, 0, this,
TQT_SLOT(slotRespellFlat()), actionCollection(),
TQ_SLOT(slotRespellFlat()), actionCollection(),
"respell_flat");
new TDEAction(i18n("Respell as Sharp"), 0, 0, this,
TQT_SLOT(slotRespellSharp()), actionCollection(),
TQ_SLOT(slotRespellSharp()), actionCollection(),
"respell_sharp");
new TDEAction(i18n("Respell as Natural"), 0, 0, this,
TQT_SLOT(slotRespellNatural()), actionCollection(),
TQ_SLOT(slotRespellNatural()), actionCollection(),
"respell_natural");
new TDEAction(i18n("Collapse Notes"), 0, 0, this,
TQT_SLOT(slotCollapseNotes()), actionCollection(),
TQ_SLOT(slotCollapseNotes()), actionCollection(),
"collapse_notes");
new TDEAction(i18n("Interpret"), 0, 0, this,
TQT_SLOT(slotInterpret()), actionCollection(),
TQ_SLOT(slotInterpret()), actionCollection(),
"interpret");
new TDEAction(i18n("Move to Staff Above"), 0, 0, this,
TQT_SLOT(slotStaffAbove()), actionCollection(),
TQ_SLOT(slotStaffAbove()), actionCollection(),
"move_events_up_staff");
new TDEAction(i18n("Move to Staff Below"), 0, 0, this,
TQT_SLOT(slotStaffBelow()), actionCollection(),
TQ_SLOT(slotStaffBelow()), actionCollection(),
"move_events_down_staff");
new TDEAction(i18n("Make Invisible"), 0, 0, this,
TQT_SLOT(slotMakeInvisible()), actionCollection(),
TQ_SLOT(slotMakeInvisible()), actionCollection(),
"make_invisible");
new TDEAction(i18n("Make Visible"), 0, 0, this,
TQT_SLOT(slotMakeVisible()), actionCollection(),
TQ_SLOT(slotMakeVisible()), actionCollection(),
"make_visible");
createMenu("notationselector.rc");
@ -256,7 +256,7 @@ void NotationSelector::handleMouseDoubleClick(timeT,
m_justSelectedBar = true;
TQTimer::singleShot(TQApplication::doubleClickInterval(), this,
TQT_SLOT(slotClickTimeout()));
TQ_SLOT(slotClickTimeout()));
}
return ;

514
src/gui/editors/notation/NotationView.cpp
View File

File diff suppressed because it is too large Load Diff

12
src/gui/editors/notation/NoteFontViewer.cpp
Unescape View File

@ -107,14 +107,14 @@ NoteFontViewer::NoteFontViewer(TQWidget *parent, TQString noteFontName,
m_frame = new FontViewFrame(pixelSize, box);
connect(m_font, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotFontChanged(const TQString &)));
connect(m_font, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotFontChanged(const TQString &)));
connect(m_view, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotViewChanged(int)));
connect(m_view, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotViewChanged(int)));
connect(m_rows, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotRowChanged(const TQString &)));
connect(m_rows, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotRowChanged(const TQString &)));
slotFontChanged(m_font->currentText());
}

18
src/gui/editors/notation/NoteInserter.cpp
Unescape View File

@ -78,7 +78,7 @@ NoteInserter::NoteInserter(NotationView* view)
TDEToggleAction *autoBeamAction =
new TDEToggleAction(i18n("Auto-Beam when appropriate"), 0, this,
TQT_SLOT(slotToggleAutoBeam()), actionCollection(),
TQ_SLOT(slotToggleAutoBeam()), actionCollection(),
"toggle_auto_beam");
autoBeamAction->setChecked(m_autoBeam);
@ -99,30 +99,30 @@ NoteInserter::NoteInserter(NotationView* view)
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("dotted-crotchet")));
new TDEToggleAction(i18n("Dotted note"), icon, 0, this,
TQT_SLOT(slotToggleDot()), actionCollection(),
TQ_SLOT(slotToggleDot()), actionCollection(),
"toggle_dot");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("rest-crotchet")));
new TDEAction(i18n("Switch to Inserting Rests"), icon, 0, this,
TQT_SLOT(slotRestsSelected()), actionCollection(),
TQ_SLOT(slotRestsSelected()), actionCollection(),
"rests");
createMenu("noteinserter.rc");
connect(m_parentView, TQT_SIGNAL(changeAccidental(Accidental, bool)),
this, TQT_SLOT(slotSetAccidental(Accidental, bool)));
connect(m_parentView, TQ_SIGNAL(changeAccidental(Accidental, bool)),
this, TQ_SLOT(slotSetAccidental(Accidental, bool)));
}
NoteInserter::NoteInserter(const TQString& menuName, NotationView* view)
@ -135,8 +135,8 @@ NoteInserter::NoteInserter(const TQString& menuName, NotationView* view)
m_lastAccidental(Accidentals::NoAccidental),
m_followAccidental(false)
{
connect(m_parentView, TQT_SIGNAL(changeAccidental(Accidental, bool)),
this, TQT_SLOT(slotSetAccidental(Accidental, bool)));
connect(m_parentView, TQ_SIGNAL(changeAccidental(Accidental, bool)),
this, TQ_SLOT(slotSetAccidental(Accidental, bool)));
}
NoteInserter::~NoteInserter()

8
src/gui/editors/notation/RestInserter.cpp
Unescape View File

@ -58,24 +58,24 @@ RestInserter::RestInserter(NotationView* view)
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("dotted-rest-crotchet")));
new TDEToggleAction(i18n("Dotted rest"), icon, 0, this,
TQT_SLOT(slotToggleDot()), actionCollection(),
TQ_SLOT(slotToggleDot()), actionCollection(),
"toggle_dot");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(),
TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes");
createMenu("restinserter.rc");

6
src/gui/editors/notation/TextInserter.cpp
Unescape View File

@ -53,18 +53,18 @@ TextInserter::TextInserter(NotationView* view)
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(),
TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes");
createMenu("textinserter.rc");

36
src/gui/editors/parameters/AudioInstrumentParameterPanel.cpp
Unescape View File

@ -254,32 +254,32 @@ AudioInstrumentParameterPanel::AudioInstrumentParameterPanel(RosegardenGUIDoc* d
gridLayout->setRowStretch(2, 1);
connect(m_audioFader, TQT_SIGNAL(audioChannelsChanged(int)),
this, TQT_SLOT(slotAudioChannels(int)));
connect(m_audioFader, TQ_SIGNAL(audioChannelsChanged(int)),
this, TQ_SLOT(slotAudioChannels(int)));
connect(m_audioFader->m_signalMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotSelectPlugin(int)));
connect(m_audioFader->m_signalMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotSelectPlugin(int)));
connect(m_audioFader->m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotSelectAudioLevel(float)));
connect(m_audioFader->m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotSelectAudioLevel(float)));
connect(m_audioFader->m_recordFader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotSelectAudioRecordLevel(float)));
connect(m_audioFader->m_recordFader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotSelectAudioRecordLevel(float)));
connect(m_audioFader->m_pan, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotSetPan(float)));
connect(m_audioFader->m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotSetPan(float)));
connect(m_audioFader->m_audioOutput, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioOutput, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioInput, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioInput, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_synthButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSynthButtonClicked()));
connect(m_audioFader->m_synthButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSynthButtonClicked()));
connect(m_audioFader->m_synthGUIButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSynthGUIButtonClicked()));
connect(m_audioFader->m_synthGUIButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSynthGUIButtonClicked()));
}
void

32
src/gui/editors/parameters/InstrumentParameterBox.cpp
Unescape View File

@ -84,39 +84,39 @@ InstrumentParameterBox::InstrumentParameterBox(RosegardenGUIDoc *doc,
m_audioInstrumentParameters->adjustSize();
m_noInstrumentParameters->adjustSize();
connect(m_audioInstrumentParameters, TQT_SIGNAL(updateAllBoxes()),
this, TQT_SLOT(slotUpdateAllBoxes()));
connect(m_audioInstrumentParameters, TQ_SIGNAL(updateAllBoxes()),
this, TQ_SLOT(slotUpdateAllBoxes()));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
this,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
this,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)));
TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
this,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)));
TQ_SIGNAL(showPluginGUI(InstrumentId, int)));
connect(m_midiInstrumentParameters, TQT_SIGNAL(updateAllBoxes()),
this, TQT_SLOT(slotUpdateAllBoxes()));
connect(m_midiInstrumentParameters, TQ_SIGNAL(updateAllBoxes()),
this, TQ_SLOT(slotUpdateAllBoxes()));
connect(m_midiInstrumentParameters,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
connect(m_midiInstrumentParameters,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
this,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
// Layout the groups left to right.

40
src/gui/editors/parameters/MIDIInstrumentParameterPanel.cpp
Unescape View File

@ -150,32 +150,32 @@ MIDIInstrumentParameterPanel::MIDIInstrumentParameterPanel(RosegardenGUIDoc *doc
// Connect up the toggle boxes
//
connect(m_percussionCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotTogglePercussion(bool)));
connect(m_percussionCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotTogglePercussion(bool)));
connect(m_programCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleProgramChange(bool)));
connect(m_programCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotToggleProgramChange(bool)));
connect(m_bankCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleBank(bool)));
connect(m_bankCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotToggleBank(bool)));
connect(m_variationCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleVariation(bool)));
connect(m_variationCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotToggleVariation(bool)));
// Connect activations
//
connect(m_bankValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectBank(int)));
connect(m_bankValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectBank(int)));
connect(m_variationValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectVariation(int)));
connect(m_variationValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectVariation(int)));
connect(m_programValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectProgram(int)));
connect(m_programValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectProgram(int)));
connect(m_channelValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectChannel(int)));
connect(m_channelValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectChannel(int)));
// don't select any of the options in any dropdown
m_programValue->setCurrentItem( -1);
@ -183,8 +183,8 @@ MIDIInstrumentParameterPanel::MIDIInstrumentParameterPanel(RosegardenGUIDoc *doc
m_channelValue->setCurrentItem( -1);
m_variationValue->setCurrentItem( -1);
connect(m_rotaryMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotControllerChanged(int)));
connect(m_rotaryMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotControllerChanged(int)));
}
void
@ -415,8 +415,8 @@ MIDIInstrumentParameterPanel::setupControllers(MidiDevice *md)
// Connect
//
connect(rotary, TQT_SIGNAL(valueChanged(float)),
m_rotaryMapper, TQT_SLOT(map()));
connect(rotary, TQ_SIGNAL(valueChanged(float)),
m_rotaryMapper, TQ_SLOT(map()));
rmi = m_rotaries.end();
}

66
src/gui/editors/parameters/SegmentParameterBox.cpp
Unescape View File

@ -96,8 +96,8 @@ SegmentParameterBox::SegmentParameterBox(RosegardenGUIDoc* doc,
m_doc->getComposition().addObserver(this);
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
}
SegmentParameterBox::~SegmentParameterBox()
@ -143,15 +143,15 @@ SegmentParameterBox::initBox()
m_labelButton->setFont(font);
// m_labelButton->setFixedWidth(50);
connect(m_labelButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditSegmentLabel()));
connect(m_labelButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditSegmentLabel()));
m_repeatValue = new TristateCheckBox(this);
m_repeatValue->setFont(font);
//m_repeatValue->setFixedHeight(comboHeight);
// handle state changes
connect(m_repeatValue, TQT_SIGNAL(pressed()), TQT_SLOT(slotRepeatPressed()));
connect(m_repeatValue, TQ_SIGNAL(pressed()), TQ_SLOT(slotRepeatPressed()));
// non-reversing motif style read-only combo
m_quantizeValue = new KComboBox(this);
@ -159,8 +159,8 @@ SegmentParameterBox::initBox()
//m_quantizeValue->setFixedHeight(comboHeight);
// handle quantize changes from drop down
connect(m_quantizeValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotQuantizeSelected(int)));
connect(m_quantizeValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotQuantizeSelected(int)));
// reversing motif style read-write combo
m_transposeValue = new KComboBox(this);
@ -168,12 +168,12 @@ SegmentParameterBox::initBox()
//m_transposeValue->setFixedHeight(comboHeight);
// handle transpose combo changes
connect(m_transposeValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotTransposeSelected(int)));
connect(m_transposeValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotTransposeSelected(int)));
// and text changes
connect(m_transposeValue, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotTransposeTextChanged(const TQString&)));
connect(m_transposeValue, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotTransposeTextChanged(const TQString&)));
// reversing motif style read-write combo
m_delayValue = new KComboBox(this);
@ -181,16 +181,16 @@ SegmentParameterBox::initBox()
//m_delayValue->setFixedHeight(comboHeight);
// handle delay combo changes
connect(m_delayValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDelaySelected(int)));
connect(m_delayValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDelaySelected(int)));
// Detect when the document colours are updated
connect(m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
connect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
// handle text changes for delay
connect(m_delayValue, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotDelayTextChanged(const TQString &)));
connect(m_delayValue, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotDelayTextChanged(const TQString &)));
// set up combo box for colours
m_colourValue = new KComboBox(false, this);
@ -200,8 +200,8 @@ SegmentParameterBox::initBox()
m_colourValue->setSizeLimit(20);
// handle colour combo changes
connect(m_colourValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotColourSelected(int)));
connect(m_colourValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotColourSelected(int)));
// pre-set width of buttons so they don't grow later
// width = fontMetrics.width(i18n("used internally for spacing", "High: ----"));
@ -214,8 +214,8 @@ SegmentParameterBox::initBox()
// m_highButton->setFont(font);
// m_highButton->setMinimumWidth(width);
// connect(m_highButton, TQT_SIGNAL(released()),
// TQT_SLOT(slotHighestPressed()));
// connect(m_highButton, TQ_SIGNAL(released()),
// TQ_SLOT(slotHighestPressed()));
// lowest playable note
//
@ -225,14 +225,14 @@ SegmentParameterBox::initBox()
// m_lowButton->setFont(font);
// m_lowButton->setMinimumWidth(width);
// connect(m_lowButton, TQT_SIGNAL(released()),
// TQT_SLOT(slotLowestPressed()));
// connect(m_lowButton, TQ_SIGNAL(released()),
// TQ_SLOT(slotLowestPressed()));
// Audio autofade enabled
//
// m_autoFadeBox = new TQCheckBox(this);
// connect(m_autoFadeBox, TQT_SIGNAL(stateChanged(int)),
// this, TQT_SLOT(slotAudioFadeChanged(int)));
// connect(m_autoFadeBox, TQ_SIGNAL(stateChanged(int)),
// this, TQ_SLOT(slotAudioFadeChanged(int)));
// Fade in and out times
//
@ -240,15 +240,15 @@ SegmentParameterBox::initBox()
// m_fadeInSpin->setMinValue(0);
// m_fadeInSpin->setMaxValue(5000);
// m_fadeInSpin->setSuffix(i18n(" ms"));
// connect(m_fadeInSpin, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SLOT(slotFadeInChanged(int)));
// connect(m_fadeInSpin, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SLOT(slotFadeInChanged(int)));
// m_fadeOutSpin = new TQSpinBox(this);
// m_fadeOutSpin->setMinValue(0);
// m_fadeOutSpin->setMaxValue(5000);
// m_fadeOutSpin->setSuffix(i18n(" ms"));
// connect(m_fadeOutSpin, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SLOT(slotFadeOutChanged(int)));
// connect(m_fadeOutSpin, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SLOT(slotFadeOutChanged(int)));
label->setFont(font);
repeatLabel->setFont(font);
@ -382,14 +382,14 @@ void
SegmentParameterBox::setDocument(RosegardenGUIDoc* doc)
{
if (m_doc != 0)
disconnect(m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
disconnect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
m_doc = doc;
// Detect when the document colours are updated
connect (m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
connect (m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
slotDocColoursChanged(); // repopulate combo
}

52
src/gui/editors/parameters/TrackParameterBox.cpp
Unescape View File

@ -304,8 +304,8 @@ TrackParameterBox::TrackParameterBox( RosegardenGUIDoc *doc,
groupLayout->addMultiCellWidget(m_transpLbl, row, row, 3, 4, AlignRight);
m_defTranspose = new KComboBox(m_defaultsGroup);
connect(m_defTranspose, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotTransposeIndexChanged(int)));
connect(m_defTranspose, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotTransposeIndexChanged(int)));
int transposeRange = 48;
for (int i = -transposeRange; i < transposeRange + 1; i++) {
@ -359,43 +359,43 @@ TrackParameterBox::TrackParameterBox( RosegardenGUIDoc *doc,
mainLayout->setRowStretch(mainLayout->numRows() - 1, 1);
// Connections
connect( m_playDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPlaybackDeviceChanged(int)));
connect( m_playDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPlaybackDeviceChanged(int)));
connect( m_instrument, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotInstrumentChanged(int)));
connect( m_instrument, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotInstrumentChanged(int)));
connect( m_recDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotRecordingDeviceChanged(int)));
connect( m_recDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotRecordingDeviceChanged(int)));
connect( m_recChannel, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotRecordingChannelChanged(int)));
connect( m_recChannel, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotRecordingChannelChanged(int)));
connect( m_defClef, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotClefChanged(int)));
connect( m_defClef, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotClefChanged(int)));
// Detect when the document colours are updated
connect(m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
connect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
// handle colour combo changes
connect(m_defColor, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotColorChanged(int)));
connect(m_defColor, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotColorChanged(int)));
connect(m_highButton, TQT_SIGNAL(released()),
TQT_SLOT(slotHighestPressed()));
connect(m_highButton, TQ_SIGNAL(released()),
TQ_SLOT(slotHighestPressed()));
connect(m_lowButton, TQT_SIGNAL(released()),
TQT_SLOT(slotLowestPressed()));
connect(m_lowButton, TQ_SIGNAL(released()),
TQ_SLOT(slotLowestPressed()));
connect(m_presetButton, TQT_SIGNAL(released()),
TQT_SLOT(slotPresetPressed()));
connect(m_presetButton, TQ_SIGNAL(released()),
TQ_SLOT(slotPresetPressed()));
connect(m_staffSizeCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotStaffSizeChanged(int)));
connect(m_staffSizeCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotStaffSizeChanged(int)));
connect(m_staffBracketCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotStaffBracketChanged(int)));
connect(m_staffBracketCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotStaffBracketChanged(int)));
}
TrackParameterBox::~TrackParameterBox()

20
src/gui/editors/segment/ControlEditorDialog.cpp
Unescape View File

@ -149,20 +149,20 @@ ControlEditorDialog::ControlEditorDialog(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()),
TQT_SLOT(slotAdd()));
connect(m_addButton, TQ_SIGNAL(released()),
TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDelete()));
connect(m_deleteButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDelete()));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQ_SLOT(slotEdit(TQListViewItem *)));
// Highlight all columns - enable extended selection mode
//
@ -336,11 +336,11 @@ void
ControlEditorDialog::setupActions()
{
TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(released()), this, TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()), this, TQ_SLOT(slotClose()));
// some adjustments
new TDEToolBarPopupAction(i18n("Und&o"),

36
src/gui/editors/segment/ControlParameterEditDialog.cpp
Unescape View File

@ -112,32 +112,32 @@ ControlParameterEditDialog::ControlParameterEditDialog(
m_ipbPosition = new KComboBox(frame);
layout->addMultiCellWidget(m_ipbPosition, 8, 8, 1, 2);
connect(m_nameEdit, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotNameChanged(const TQString&)));
connect(m_nameEdit, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotNameChanged(const TQString&)));
connect(m_typeCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotTypeChanged(int)));
connect(m_typeCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotTypeChanged(int)));
connect(m_description, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotDescriptionChanged(const TQString &)));
connect(m_description, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotDescriptionChanged(const TQString &)));
connect(m_controllerBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotControllerChanged(int)));
connect(m_controllerBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotControllerChanged(int)));
connect(m_minBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotMinChanged(int)));
connect(m_minBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotMinChanged(int)));
connect(m_maxBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotMaxChanged(int)));
connect(m_maxBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotMaxChanged(int)));
connect(m_defaultBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotDefaultChanged(int)));
connect(m_defaultBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotDefaultChanged(int)));
connect(m_colourCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotColourChanged(int)));
connect(m_colourCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotColourChanged(int)));
connect(m_ipbPosition, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotIPBPositionChanged(int)));
connect(m_ipbPosition, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotIPBPositionChanged(int)));
//m_nameEdit->selectAll();
//m_description->selectAll();

38
src/gui/editors/segment/MarkerEditor.cpp
Unescape View File

@ -139,29 +139,29 @@ MarkerEditor::MarkerEditor(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()),
TQT_SLOT(slotAdd()));
connect(m_addButton, TQ_SIGNAL(released()),
TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDelete()));
connect(m_deleteButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDelete()));
connect(m_closeButton, TQT_SIGNAL(released()),
TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()),
TQ_SLOT(slotClose()));
connect(m_deleteAllButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDeleteAll()));
connect(m_deleteAllButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDeleteAll()));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQ_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQT_SIGNAL(pressed(TQListViewItem *)),
this, TQT_SLOT(slotItemClicked(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(pressed(TQListViewItem *)),
this, TQ_SLOT(slotItemClicked(TQListViewItem *)));
// Highlight all columns - enable extended selection mode
//
@ -366,11 +366,11 @@ void
MarkerEditor::setupActions()
{
TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(released()), this, TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()), this, TQ_SLOT(slotClose()));
// some adjustments
new TDEToolBarPopupAction(i18n("Und&o"),
@ -395,7 +395,7 @@ MarkerEditor::setupActions()
TQIconSet icon(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()),
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -405,7 +405,7 @@ MarkerEditor::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()),
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -415,7 +415,7 @@ MarkerEditor::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()),
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)

32
src/gui/editors/segment/PlayList.cpp
Unescape View File

@ -78,29 +78,29 @@ PlayList::PlayList(TQWidget *parent, const char *name)
m_deleteButton ->setText(i18n("Delete"));
m_clearButton ->setText(i18n("Clear"));
connect(m_openButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotOpenFiles()));
connect(m_openButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotOpenFiles()));
connect(m_playButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPlay()));
connect(m_playButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPlay()));
connect(m_deleteButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotDeleteCurrent()));
connect(m_deleteButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotDeleteCurrent()));
connect(m_clearButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotClear()));
connect(m_clearButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotClear()));
connect(m_moveUpButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotMoveUp()));
connect(m_moveUpButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotMoveUp()));
connect(m_moveDownButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotMoveDown()));
connect(m_moveDownButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotMoveDown()));
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)),
TQT_SLOT(slotCurrentItemChanged(TQListViewItem*)));
connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)),
TQ_SLOT(slotCurrentItemChanged(TQListViewItem*)));
connect(m_listView, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
connect(m_listView, TQ_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQ_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
restore();

40
src/gui/editors/segment/TrackButtons.cpp
Unescape View File

@ -106,18 +106,18 @@ TrackButtons::TrackButtons(RosegardenGUIDoc* doc,
m_layout->addStretch(20);
connect(m_recordSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotToggleRecordTrack(int)));
connect(m_recordSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotToggleRecordTrack(int)));
connect(m_muteSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotToggleMutedTrack(int)));
connect(m_muteSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotToggleMutedTrack(int)));
// connect signal mappers
connect(m_instListSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotInstrumentSelection(int)));
connect(m_instListSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotInstrumentSelection(int)));
connect(m_clickedSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SIGNAL(trackSelected(int)));
connect(m_clickedSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SIGNAL(trackSelected(int)));
// // Populate instrument popup menu just once at start-up
// //
@ -767,8 +767,8 @@ TrackButtons::populateInstrumentPopup(Instrument *thisTrackInstr, TQPopupMenu* i
// Connect up the submenu
//
connect(subMenu, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotInstrumentPopupActivated(int)));
connect(subMenu, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotInstrumentPopupActivated(int)));
} else if (!instrUsedByMe) {
@ -1066,10 +1066,10 @@ TQFrame* TrackButtons::makeButton(Rosegarden::TrackId trackId)
record->off();
// Connect them to their sigmappers
connect(record, TQT_SIGNAL(stateChanged(bool)),
m_recordSigMapper, TQT_SLOT(map()));
connect(mute, TQT_SIGNAL(stateChanged(bool)),
m_muteSigMapper, TQT_SLOT(map()));
connect(record, TQ_SIGNAL(stateChanged(bool)),
m_recordSigMapper, TQ_SLOT(map()));
connect(mute, TQ_SIGNAL(stateChanged(bool)),
m_muteSigMapper, TQ_SLOT(map()));
m_recordSigMapper->setMapping(record, track->getPosition());
m_muteSigMapper->setMapping(mute, track->getPosition());
@ -1101,8 +1101,8 @@ TQFrame* TrackButtons::makeButton(Rosegarden::TrackId trackId)
trackLabel->setFixedHeight(m_cellSize - buttonGap);
trackLabel->setIndent(7);
connect(trackLabel, TQT_SIGNAL(renameTrack(TQString, TrackId)),
TQT_SLOT(slotRenameTrack(TQString, TrackId)));
connect(trackLabel, TQ_SIGNAL(renameTrack(TQString, TrackId)),
TQ_SLOT(slotRenameTrack(TQString, TrackId)));
// Store the TrackLabel pointer
//
@ -1111,10 +1111,10 @@ TQFrame* TrackButtons::makeButton(Rosegarden::TrackId trackId)
// Connect it
setButtonMapping(trackLabel, trackId);
connect(trackLabel, TQT_SIGNAL(changeToInstrumentList()),
m_instListSigMapper, TQT_SLOT(map()));
connect(trackLabel, TQT_SIGNAL(clicked()),
m_clickedSigMapper, TQT_SLOT(map()));
connect(trackLabel, TQ_SIGNAL(changeToInstrumentList()),
m_instListSigMapper, TQ_SLOT(map()));
connect(trackLabel, TQ_SIGNAL(clicked()),
m_clickedSigMapper, TQ_SLOT(map()));
//
// instrument label

142
src/gui/editors/segment/TrackEditor.cpp
Unescape View File

@ -162,10 +162,10 @@ TrackEditor::init(TQWidget* rosegardenguiview)
m_doc->getStudio(),
m_rulerScale, getTrackCellHeight());
connect(rosegardenguiview, TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(rosegardenguiview->parent(), TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(rosegardenguiview, TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(rosegardenguiview->parent(), TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
m_segmentCanvas = new CompositionView(m_doc, m_compositionModel, this);
@ -221,105 +221,105 @@ TrackEditor::init(TQWidget* rosegardenguiview)
m_trackButtonScroll->setBottomMargin(m_bottomStandardRuler->height() +
m_segmentCanvas->horizontalScrollBar()->height());
connect(m_trackButtons, TQT_SIGNAL(widthChanged()),
this, TQT_SLOT(slotTrackButtonsWidthChanged()));
connect(m_trackButtons, TQ_SIGNAL(widthChanged()),
this, TQ_SLOT(slotTrackButtonsWidthChanged()));
connect(m_trackButtons, TQT_SIGNAL(trackSelected(int)),
rosegardenguiview, TQT_SLOT(slotSelectTrackSegments(int)));
connect(m_trackButtons, TQ_SIGNAL(trackSelected(int)),
rosegardenguiview, TQ_SLOT(slotSelectTrackSegments(int)));
connect(m_trackButtons, TQT_SIGNAL(instrumentSelected(int)),
rosegardenguiview, TQT_SLOT(slotUpdateInstrumentParameterBox(int)));
connect(m_trackButtons, TQ_SIGNAL(instrumentSelected(int)),
rosegardenguiview, TQ_SLOT(slotUpdateInstrumentParameterBox(int)));
connect(this, TQT_SIGNAL(stateChange(TQString, bool)),
rosegardenguiview, TQT_SIGNAL(stateChange(TQString, bool)));
connect(this, TQ_SIGNAL(stateChange(TQString, bool)),
rosegardenguiview, TQ_SIGNAL(stateChange(TQString, bool)));
connect(m_trackButtons, TQT_SIGNAL(modified()),
m_doc, TQT_SLOT(slotDocumentModified()));
connect(m_trackButtons, TQ_SIGNAL(modified()),
m_doc, TQ_SLOT(slotDocumentModified()));
connect(m_trackButtons, TQT_SIGNAL(muteButton(TrackId, bool)),
rosegardenguiview, TQT_SLOT(slotSetMuteButton(TrackId, bool)));
connect(m_trackButtons, TQ_SIGNAL(muteButton(TrackId, bool)),
rosegardenguiview, TQ_SLOT(slotSetMuteButton(TrackId, bool)));
// connect loop rulers' follow-scroll signals
connect(m_topStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQT_SLOT(startAutoScroll(int)));
connect(m_topStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQT_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQT_SLOT(startAutoScroll(int)));
connect(m_bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQT_SLOT(stopAutoScroll()));
connect(m_segmentCanvas, TQT_SIGNAL(contentsMoving(int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_topStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQ_SLOT(startAutoScroll(int)));
connect(m_topStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQ_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQ_SLOT(startAutoScroll(int)));
connect(m_bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQ_SLOT(stopAutoScroll()));
connect(m_segmentCanvas, TQ_SIGNAL(contentsMoving(int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
// Synchronize bar buttons' scrollview with segment canvas' scrollbar
//
connect(m_segmentCanvas->verticalScrollBar(), TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotVerticalScrollTrackButtons(int)));
connect(m_segmentCanvas->verticalScrollBar(), TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotVerticalScrollTrackButtons(int)));
connect(m_segmentCanvas->verticalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
this, TQT_SLOT(slotVerticalScrollTrackButtons(int)));
connect(m_segmentCanvas->verticalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
this, TQ_SLOT(slotVerticalScrollTrackButtons(int)));
// scrolling with mouse wheel
connect(m_trackButtonScroll, TQT_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_segmentCanvas, TQT_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
connect(m_trackButtonScroll, TQ_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_segmentCanvas, TQ_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
// Connect horizontal scrollbar
//
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_tempoRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_tempoRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_tempoRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_tempoRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_chordNameRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_chordNameRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_chordNameRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_chordNameRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(this, TQT_SIGNAL(needUpdate()), m_segmentCanvas, TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(this, TQ_SIGNAL(needUpdate()), m_segmentCanvas, TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(m_segmentCanvas->getModel(),
TQT_SIGNAL(selectedSegments(const SegmentSelection &)),
TQ_SIGNAL(selectedSegments(const SegmentSelection &)),
rosegardenguiview,
TQT_SLOT(slotSelectedSegments(const SegmentSelection &)));
TQ_SLOT(slotSelectedSegments(const SegmentSelection &)));
connect(m_segmentCanvas, TQT_SIGNAL(zoomIn()),
RosegardenGUIApp::self(), TQT_SLOT(slotZoomIn()));
connect(m_segmentCanvas, TQT_SIGNAL(zoomOut()),
RosegardenGUIApp::self(), TQT_SLOT(slotZoomOut()));
connect(m_segmentCanvas, TQ_SIGNAL(zoomIn()),
RosegardenGUIApp::self(), TQ_SLOT(slotZoomIn()));
connect(m_segmentCanvas, TQ_SIGNAL(zoomOut()),
RosegardenGUIApp::self(), TQ_SLOT(slotZoomOut()));
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
connect(m_doc, TQT_SIGNAL(pointerPositionChanged(timeT)),
this, TQT_SLOT(slotSetPointerPosition(timeT)));
connect(m_doc, TQ_SIGNAL(pointerPositionChanged(timeT)),
this, TQ_SLOT(slotSetPointerPosition(timeT)));
//
// pointer and loop drag signals from top and bottom bar buttons (loop rulers actually)
//
connect(m_topStandardRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_topStandardRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_topStandardRuler, TQT_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQT_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_topStandardRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQ_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQ_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_doc, TQT_SIGNAL(loopChanged(timeT,
connect(m_doc, TQ_SIGNAL(loopChanged(timeT,
timeT)),
this, TQT_SLOT(slotSetLoop(timeT, timeT)));
this, TQ_SLOT(slotSetLoop(timeT, timeT)));
}
void TrackEditor::slotReadjustCanvasSize()
@ -756,7 +756,7 @@ void TrackEditor::dropEvent(TQDropEvent* event)
// WARNING
//
// DO NOT PERFORM ANY OPERATIONS AFTER THAT
// EMITTING THIS TQT_SIGNAL TRIGGERS THE LOADING OF A NEW DOCUMENT
// EMITTING THIS TQ_SIGNAL TRIGGERS THE LOADING OF A NEW DOCUMENT
// AND AS A CONSEQUENCE THE DELETION OF THIS TrackEditor OBJECT
//
} else {

4
src/gui/editors/segment/TrackLabel.cpp
Unescape View File

@ -68,8 +68,8 @@ TrackLabel::TrackLabel(TrackId id,
m_pressTimer = new TQTimer(this);
connect(m_pressTimer, TQT_SIGNAL(timeout()),
this, TQT_SIGNAL(changeToInstrumentList()));
connect(m_pressTimer, TQ_SIGNAL(timeout()),
this, TQ_SIGNAL(changeToInstrumentList()));
TQToolTip::add
(this, i18n("Click and hold with left mouse button to assign this Track to an Instrument."));

40
src/gui/editors/segment/TriggerSegmentManager.cpp
Unescape View File

@ -133,29 +133,29 @@ TriggerSegmentManager::TriggerSegmentManager(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()),
TQT_SLOT(slotAdd()));
connect(m_addButton, TQ_SIGNAL(released()),
TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDelete()));
connect(m_deleteButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDelete()));
connect(m_closeButton, TQT_SIGNAL(released()),
TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()),
TQ_SLOT(slotClose()));
connect(m_deleteAllButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDeleteAll()));
connect(m_deleteAllButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDeleteAll()));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQ_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQT_SIGNAL(pressed(TQListViewItem *)),
this, TQT_SLOT(slotItemClicked(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(pressed(TQListViewItem *)),
this, TQ_SLOT(slotItemClicked(TQListViewItem *)));
// Highlight all columns - enable extended selection mode
//
@ -374,11 +374,11 @@ void
TriggerSegmentManager::setupActions()
{
TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(released()), this, TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()), this, TQ_SLOT(slotClose()));
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
@ -396,7 +396,7 @@ TriggerSegmentManager::setupActions()
KStdAction::stdName(KStdAction::Redo));
new TDEAction(i18n("Pa&ste as New Triggered Segment"), CTRL + SHIFT + Key_V, this,
TQT_SLOT(slotPasteAsNew()), actionCollection(),
TQ_SLOT(slotPasteAsNew()), actionCollection(),
"paste_to_trigger_segment");
kapp->config()->setGroup(TriggerManagerConfigGroup);
@ -408,7 +408,7 @@ TriggerSegmentManager::setupActions()
TQIconSet icon(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()),
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -418,7 +418,7 @@ TriggerSegmentManager::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()),
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -428,7 +428,7 @@ TriggerSegmentManager::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()),
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)

4
src/gui/editors/segment/segmentcanvas/CompositionModelImpl.cpp
Unescape View File

@ -449,8 +449,8 @@ void CompositionModelImpl::updatePreviewCacheForAudioSegment(const Segment* segm
AudioPreviewUpdater *updater = new AudioPreviewUpdater
(*m_audioPreviewThread, m_composition, segment, segRect, this);
connect(updater, TQT_SIGNAL(audioPreviewComplete(AudioPreviewUpdater*)),
this, TQT_SLOT(slotAudioPreviewComplete(AudioPreviewUpdater*)));
connect(updater, TQ_SIGNAL(audioPreviewComplete(AudioPreviewUpdater*)),
this, TQ_SLOT(slotAudioPreviewComplete(AudioPreviewUpdater*)));
m_audioPreviewUpdaterMap[segment] = updater;

70
src/gui/editors/segment/segmentcanvas/CompositionView.cpp
Unescape View File

@ -130,8 +130,8 @@ CompositionView::CompositionView(RosegardenGUIDoc* doc,
if (doc) {
m_toolBox = new SegmentToolBox(this, doc);
connect(m_toolBox, TQT_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SLOT(slotToolHelpChanged(const TQString &)));
connect(m_toolBox, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQ_SLOT(slotToolHelpChanged(const TQString &)));
}
setDragAutoScroll(true);
@ -144,43 +144,43 @@ CompositionView::CompositionView(RosegardenGUIDoc* doc,
TQScrollBar* hsb = horizontalScrollBar();
// dynamically adjust content size when scrolling past current composition's end
connect(hsb, TQT_SIGNAL(nextLine()),
this, TQT_SLOT(scrollRight()));
connect(hsb, TQT_SIGNAL(prevLine()),
this, TQT_SLOT(scrollLeft()));
// connect(this, TQT_SIGNAL(contentsMoving(int, int)),
// this, TQT_SLOT(slotAllDrawBuffersNeedRefresh()));
// connect(this, TQT_SIGNAL(contentsMoving(int, int)),
// this, TQT_SLOT(slotContentsMoving(int, int)));
connect(model, TQT_SIGNAL(needContentUpdate()),
this, TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(model, TQT_SIGNAL(needContentUpdate(const TQRect&)),
this, TQT_SLOT(slotUpdateSegmentsDrawBuffer(const TQRect&)));
connect(model, TQT_SIGNAL(needArtifactsUpdate()),
this, TQT_SLOT(slotArtifactsDrawBufferNeedsRefresh()));
connect(model, TQT_SIGNAL(needSizeUpdate()),
this, TQT_SLOT(slotUpdateSize()));
connect(hsb, TQ_SIGNAL(nextLine()),
this, TQ_SLOT(scrollRight()));
connect(hsb, TQ_SIGNAL(prevLine()),
this, TQ_SLOT(scrollLeft()));
// connect(this, TQ_SIGNAL(contentsMoving(int, int)),
// this, TQ_SLOT(slotAllDrawBuffersNeedRefresh()));
// connect(this, TQ_SIGNAL(contentsMoving(int, int)),
// this, TQ_SLOT(slotContentsMoving(int, int)));
connect(model, TQ_SIGNAL(needContentUpdate()),
this, TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(model, TQ_SIGNAL(needContentUpdate(const TQRect&)),
this, TQ_SLOT(slotUpdateSegmentsDrawBuffer(const TQRect&)));
connect(model, TQ_SIGNAL(needArtifactsUpdate()),
this, TQ_SLOT(slotArtifactsDrawBufferNeedsRefresh()));
connect(model, TQ_SIGNAL(needSizeUpdate()),
this, TQ_SLOT(slotUpdateSize()));
if (doc) {
connect(doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotRefreshColourCache()));
connect(doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotRefreshColourCache()));
// recording-related signals
connect(doc, TQT_SIGNAL(newMIDIRecordingSegment(Segment*)),
this, TQT_SLOT(slotNewMIDIRecordingSegment(Segment*)));
connect(doc, TQT_SIGNAL(newAudioRecordingSegment(Segment*)),
this, TQT_SLOT(slotNewAudioRecordingSegment(Segment*)));
// connect(doc, TQT_SIGNAL(recordMIDISegmentUpdated(Segment*, timeT)),
// this, TQT_SLOT(slotRecordMIDISegmentUpdated(Segment*, timeT)));
connect(doc, TQT_SIGNAL(stoppedAudioRecording()),
this, TQT_SLOT(slotStoppedRecording()));
connect(doc, TQT_SIGNAL(stoppedMIDIRecording()),
this, TQT_SLOT(slotStoppedRecording()));
connect(doc, TQT_SIGNAL(audioFileFinalized(Segment*)),
getModel(), TQT_SLOT(slotAudioFileFinalized(Segment*)));
connect(doc, TQ_SIGNAL(newMIDIRecordingSegment(Segment*)),
this, TQ_SLOT(slotNewMIDIRecordingSegment(Segment*)));
connect(doc, TQ_SIGNAL(newAudioRecordingSegment(Segment*)),
this, TQ_SLOT(slotNewAudioRecordingSegment(Segment*)));
// connect(doc, TQ_SIGNAL(recordMIDISegmentUpdated(Segment*, timeT)),
// this, TQ_SLOT(slotRecordMIDISegmentUpdated(Segment*, timeT)));
connect(doc, TQ_SIGNAL(stoppedAudioRecording()),
this, TQ_SLOT(slotStoppedRecording()));
connect(doc, TQ_SIGNAL(stoppedMIDIRecording()),
this, TQ_SLOT(slotStoppedRecording()));
connect(doc, TQ_SIGNAL(audioFileFinalized(Segment*)),
getModel(), TQ_SLOT(slotAudioFileFinalized(Segment*)));
}
CompositionModelImpl* cmi = dynamic_cast<CompositionModelImpl*>(model);

8
src/gui/editors/segment/segmentcanvas/SegmentMover.cpp
Unescape View File

@ -61,15 +61,15 @@ SegmentMover::SegmentMover(CompositionView *c, RosegardenGUIDoc *d)
void SegmentMover::ready()
{
m_canvas->viewport()->setCursor(TQt::sizeAllCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setBasicContextHelp();
}
void SegmentMover::stow()
{
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
}
void SegmentMover::slotCanvasScrolled(int newX, int newY)

8
src/gui/editors/segment/segmentcanvas/SegmentPencil.cpp
Unescape View File

@ -63,15 +63,15 @@ SegmentPencil::SegmentPencil(CompositionView *c, RosegardenGUIDoc *d)
void SegmentPencil::ready()
{
m_canvas->viewport()->setCursor(TQt::ibeamCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setContextHelpFor(TQPoint(0, 0));
}
void SegmentPencil::stow()
{
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
}
void SegmentPencil::slotCanvasScrolled(int newX, int newY)

16
src/gui/editors/segment/segmentcanvas/SegmentResizer.cpp
Unescape View File

@ -68,15 +68,15 @@ SegmentResizer::SegmentResizer(CompositionView *c, RosegardenGUIDoc *d,
void SegmentResizer::ready()
{
m_canvas->viewport()->setCursor(TQt::sizeHorCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setBasicContextHelp(false);
}
void SegmentResizer::stow()
{
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
}
void SegmentResizer::slotCanvasScrolled(int newX, int newY)
@ -177,10 +177,10 @@ void SegmentResizer::handleMouseButtonRelease(TQMouseEvent *e)
progressDlg.setLabel(i18n("Generating audio preview..."));
command->disconnectProgressDialog(&progressDlg);
connect(&m_doc->getAudioFileManager(), TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&m_doc->getAudioFileManager(), TQT_SLOT(slotStopPreview()));
connect(&m_doc->getAudioFileManager(), TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&m_doc->getAudioFileManager(), TQ_SLOT(slotStopPreview()));
int fid = command->getNewAudioFileId();
if (fid >= 0) {

4
src/gui/editors/segment/segmentcanvas/SegmentSelector.cpp
Unescape View File

@ -74,8 +74,8 @@ SegmentSelector::~SegmentSelector()
void SegmentSelector::ready()
{
m_canvas->viewport()->setCursor(TQt::arrowCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setContextHelp(i18n("Click and drag to select segments"));
}

34
src/gui/editors/tempo/TempoView.cpp
Unescape View File

@ -92,8 +92,8 @@ TempoView::TempoView(RosegardenGUIDoc *doc, TQWidget *parent, timeT openTime):
// Connect up
//
connect(m_filterGroup, TQT_SIGNAL(released(int)),
TQT_SLOT(slotModifyFilter(int)));
connect(m_filterGroup, TQ_SIGNAL(released(int)),
TQ_SLOT(slotModifyFilter(int)));
m_list = new TDEListView(getCentralWidget());
m_list->setItemsRenameable(true);
@ -106,8 +106,8 @@ TempoView::TempoView(RosegardenGUIDoc *doc, TQWidget *parent, timeT openTime):
// Connect double clicker
//
connect(m_list, TQT_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotPopupEditor(TQListViewItem*)));
connect(m_list, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQ_SLOT(slotPopupEditor(TQListViewItem*)));
m_list->setAllColumnsShowFocus(true);
m_list->setSelectionMode(TQListView::Extended);
@ -487,12 +487,12 @@ TempoView::slotEditInsertTempo()
dialog.setTempoPosition(insertTime);
connect(&dialog,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
@ -577,36 +577,36 @@ TempoView::setupActions()
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png"));
new TDEAction(AddTempoChangeCommand::getGlobalName(), icon, Key_I, this,
TQT_SLOT(slotEditInsertTempo()), actionCollection(),
TQ_SLOT(slotEditInsertTempo()), actionCollection(),
"insert_tempo");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-insert-timesig.png");
icon = TQIconSet(pixmap);
new TDEAction(AddTimeSignatureCommand::getGlobalName(), icon, Key_G, this,
TQT_SLOT(slotEditInsertTimeSignature()), actionCollection(),
TQ_SLOT(slotEditInsertTimeSignature()), actionCollection(),
"insert_timesig");
pixmap.load(pixmapDir + "/toolbar/event-delete.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Delete"), icon, Key_Delete, this,
TQT_SLOT(slotEditDelete()), actionCollection(),
TQ_SLOT(slotEditDelete()), actionCollection(),
"delete");
pixmap.load(pixmapDir + "/toolbar/event-edit.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Edit Item"), icon, Key_E, this,
TQT_SLOT(slotEdit()), actionCollection(),
TQ_SLOT(slotEdit()), actionCollection(),
"edit");
new TDEAction(i18n("Select &All"), 0, this,
TQT_SLOT(slotSelectAll()), actionCollection(),
TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all");
new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQT_SLOT(slotClearSelection()), actionCollection(),
TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection");
m_config->setGroup(TempoViewConfigGroup);
@ -618,7 +618,7 @@ TempoView::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()),
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -628,7 +628,7 @@ TempoView::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()),
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -638,7 +638,7 @@ TempoView::setupActions()
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()),
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)
@ -784,12 +784,12 @@ TempoView::slotPopupEditor(TQListViewItem *qitem)
dialog.setTempoPosition(time);
connect(&dialog,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));

4
src/gui/general/BaseToolBox.cpp
Unescape View File

@ -46,8 +46,8 @@ BaseTool* BaseToolBox::getTool(const TQString& toolName)
if (!tool) tool = createTool(toolName);
connect(tool, TQT_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SIGNAL(showContextHelp(const TQString &)));
connect(tool, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQ_SIGNAL(showContextHelp(const TQString &)));
return tool;
}

116
src/gui/general/EditView.cpp
Unescape View File

@ -133,8 +133,8 @@ EditView::EditView(RosegardenGUIDoc *doc,
{
m_controlRulers->setHoverCloseButton(true);
m_controlRulers->setHoverCloseButtonDelayed(false);
connect(m_controlRulers, TQT_SIGNAL(closeRequest(TQWidget*)),
this, TQT_SLOT(slotRemoveControlRuler(TQWidget*)));
connect(m_controlRulers, TQ_SIGNAL(closeRequest(TQWidget*)),
this, TQ_SLOT(slotRemoveControlRuler(TQWidget*)));
(dynamic_cast<TQBoxLayout*>(m_bottomBox->layout()))->setDirection(TQBoxLayout::BottomToTop);
@ -281,10 +281,10 @@ void EditView::setTopStandardRuler(StandardRuler* w, TQWidget *leftBox)
m_grid->addLayout(gl, TOPBARBUTTONS_ROW, m_mainCol);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
}
}
@ -296,10 +296,10 @@ void EditView::setBottomStandardRuler(StandardRuler* w)
// m_bottomBox->insertWidget(0, w);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
}
}
@ -343,10 +343,10 @@ void EditView::addRuler(TQWidget* w)
m_rulerBox->addWidget(w);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
w, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
w, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
w, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
w, TQ_SLOT(slotScrollHoriz(int)));
}
}
@ -363,14 +363,14 @@ void EditView::addControlRuler(ControlRuler* ruler)
m_controlRulers->showPage(ruler);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
ruler->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
ruler->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
ruler->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
ruler->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)));
}
connect(ruler, TQT_SIGNAL(stateChange(const TQString&, bool)),
this, TQT_SLOT(slotStateChanged(const TQString&, bool)));
connect(ruler, TQ_SIGNAL(stateChange(const TQString&, bool)),
this, TQ_SLOT(slotStateChanged(const TQString&, bool)));
stateChanged("have_control_ruler", KXMLGUIClient::StateReverse);
}
@ -424,10 +424,10 @@ void EditView::setCanvasView(RosegardenCanvasView *canvasView)
// m_horizontalScrollBar->setSteps(m_canvasView->horizontalScrollBar()->lineStep(),
// m_canvasView->horizontalScrollBar()->pageStep());
// connect(m_horizontalScrollBar, TQT_SIGNAL(valueChanged(int)),
// m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)));
// connect(m_horizontalScrollBar, TQT_SIGNAL(sliderMoved(int)),
// m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)));
// connect(m_horizontalScrollBar, TQ_SIGNAL(valueChanged(int)),
// m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)));
// connect(m_horizontalScrollBar, TQ_SIGNAL(sliderMoved(int)),
// m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)));
}
@ -726,132 +726,132 @@ EditView::setupActions()
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(AddTempoChangeCommand::getGlobalName(),
icon, 0,
this, TQT_SLOT(slotAddTempo()),
this, TQ_SLOT(slotAddTempo()),
actionCollection(), "add_tempo");
pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png");
icon = TQIconSet(pixmap);
new TDEAction(AddTimeSignatureCommand::getGlobalName(),
icon, 0,
this, TQT_SLOT(slotAddTimeSignature()),
this, TQ_SLOT(slotAddTimeSignature()),
actionCollection(), "add_time_signature");
//
// Transforms
//
new TDEAction(i18n("&Halve Durations"), Key_H + CTRL, this,
TQT_SLOT(slotHalveDurations()), actionCollection(),
TQ_SLOT(slotHalveDurations()), actionCollection(),
"halve_durations");
new TDEAction(i18n("&Double Durations"), Key_H + CTRL + SHIFT, this,
TQT_SLOT(slotDoubleDurations()), actionCollection(),
TQ_SLOT(slotDoubleDurations()), actionCollection(),
"double_durations");
new TDEAction(RescaleCommand::getGlobalName(), 0, this,
TQT_SLOT(slotRescale()), actionCollection(),
TQ_SLOT(slotRescale()), actionCollection(),
"rescale");
new TDEAction(TransposeCommand::getGlobalName(1), 0,
Key_Up, this,
TQT_SLOT(slotTransposeUp()), actionCollection(),
TQ_SLOT(slotTransposeUp()), actionCollection(),
"transpose_up");
new TDEAction(TransposeCommand::getGlobalName(12), 0,
Key_Up + CTRL, this,
TQT_SLOT(slotTransposeUpOctave()), actionCollection(),
TQ_SLOT(slotTransposeUpOctave()), actionCollection(),
"transpose_up_octave");
new TDEAction(TransposeCommand::getGlobalName( -1), 0,
Key_Down, this,
TQT_SLOT(slotTransposeDown()), actionCollection(),
TQ_SLOT(slotTransposeDown()), actionCollection(),
"transpose_down");
new TDEAction(TransposeCommand::getGlobalName( -12), 0,
Key_Down + CTRL, this,
TQT_SLOT(slotTransposeDownOctave()), actionCollection(),
TQ_SLOT(slotTransposeDownOctave()), actionCollection(),
"transpose_down_octave");
new TDEAction(TransposeCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotTranspose()), actionCollection(),
TQ_SLOT(slotTranspose()), actionCollection(),
"general_transpose");
new TDEAction(TransposeCommand::getDiatonicGlobalName(0,0), 0, this,
TQT_SLOT(slotDiatonicTranspose()), actionCollection(),
TQ_SLOT(slotDiatonicTranspose()), actionCollection(),
"general_diatonic_transpose");
new TDEAction(InvertCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotInvert()), actionCollection(),
TQ_SLOT(slotInvert()), actionCollection(),
"invert");
new TDEAction(RetrogradeCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotRetrograde()), actionCollection(),
TQ_SLOT(slotRetrograde()), actionCollection(),
"retrograde");
new TDEAction(RetrogradeInvertCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotRetrogradeInvert()), actionCollection(),
TQ_SLOT(slotRetrogradeInvert()), actionCollection(),
"retrograde_invert");
new TDEAction(i18n("Jog &Left"), Key_Left + ALT, this,
TQT_SLOT(slotJogLeft()), actionCollection(),
TQ_SLOT(slotJogLeft()), actionCollection(),
"jog_left");
new TDEAction(i18n("Jog &Right"), Key_Right + ALT, this,
TQT_SLOT(slotJogRight()), actionCollection(),
TQ_SLOT(slotJogRight()), actionCollection(),
"jog_right");
// Control rulers
//
new TDEAction(i18n("Show Velocity Property Ruler"), 0, this,
TQT_SLOT(slotShowVelocityControlRuler()), actionCollection(),
TQ_SLOT(slotShowVelocityControlRuler()), actionCollection(),
"show_velocity_control_ruler");
/*
new TDEAction(i18n("Show Controllers Events Ruler"), 0, this,
TQT_SLOT(slotShowControllerEventsRuler()), actionCollection(),
TQ_SLOT(slotShowControllerEventsRuler()), actionCollection(),
"show_controller_events_ruler");
*/
// Disabled for now
//
// new TDEAction(i18n("Add Control Ruler..."), 0, this,
// TQT_SLOT(slotShowPropertyControlRuler()), actionCollection(),
// TQ_SLOT(slotShowPropertyControlRuler()), actionCollection(),
// "add_control_ruler");
//
// Control Ruler context menu
//
new TDEAction(i18n("Insert item"), 0, this,
TQT_SLOT(slotInsertControlRulerItem()), actionCollection(),
TQ_SLOT(slotInsertControlRulerItem()), actionCollection(),
"insert_control_ruler_item");
// This was on Key_Delete, but that conflicts with existing Delete commands
// on individual edit views
new TDEAction(i18n("Erase selected items"), 0, this,
TQT_SLOT(slotEraseControlRulerItem()), actionCollection(),
TQ_SLOT(slotEraseControlRulerItem()), actionCollection(),
"erase_control_ruler_item");
new TDEAction(i18n("Clear ruler"), 0, this,
TQT_SLOT(slotClearControlRulerItem()), actionCollection(),
TQ_SLOT(slotClearControlRulerItem()), actionCollection(),
"clear_control_ruler_item");
new TDEAction(i18n("Insert line of controllers"), 0, this,
TQT_SLOT(slotStartControlLineItem()), actionCollection(),
TQ_SLOT(slotStartControlLineItem()), actionCollection(),
"start_control_line_item");
new TDEAction(i18n("Flip forward"), Key_BracketRight, this,
TQT_SLOT(slotFlipForwards()), actionCollection(),
TQ_SLOT(slotFlipForwards()), actionCollection(),
"flip_control_events_forward");
new TDEAction(i18n("Flip backwards"), Key_BracketLeft, this,
TQT_SLOT(slotFlipBackwards()), actionCollection(),
TQ_SLOT(slotFlipBackwards()), actionCollection(),
"flip_control_events_back");
new TDEAction(i18n("Draw property line"), 0, this,
TQT_SLOT(slotDrawPropertyLine()), actionCollection(),
TQ_SLOT(slotDrawPropertyLine()), actionCollection(),
"draw_property_line");
new TDEAction(i18n("Select all property values"), 0, this,
TQT_SLOT(slotSelectAllProperties()), actionCollection(),
TQ_SLOT(slotSelectAllProperties()), actionCollection(),
"select_all_properties");
}
@ -901,8 +901,8 @@ EditView::setupAddControlRulerMenu()
addControlRulerMenu->insertItem(itemStr, i++);
}
connect(addControlRulerMenu, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotAddControlRuler(int)));
connect(addControlRulerMenu, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotAddControlRuler(int)));
}
}
@ -1114,7 +1114,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction
(flat.arg(notePitchNames[i]),
CTRL + SHIFT + notePitchKeys[octave][i],
this, TQT_SLOT(slotInsertNoteFromAction()), actionCollection(),
this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1_flat%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction);
@ -1124,7 +1124,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction
(notePitchNames[i],
notePitchKeys[octave][i],
this, TQT_SLOT(slotInsertNoteFromAction()), actionCollection(),
this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction);
@ -1137,7 +1137,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction
(sharp.arg(notePitchNames[i]),
SHIFT + notePitchKeys[octave][i],
this, TQT_SLOT(slotInsertNoteFromAction()), actionCollection(),
this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1_sharp%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction);
@ -1218,12 +1218,12 @@ void EditView::slotAddTempo()
TempoDialog tempoDlg(this, getDocument());
connect(&tempoDlg,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));

44
src/gui/general/EditViewBase.cpp
Unescape View File

@ -118,12 +118,12 @@ EditViewBase::EditViewBase(RosegardenGUIDoc *doc,
m_doc->attachEditView(this);
TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotTestClipboard()));
(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotTestClipboard()));
// create accelerators
//
@ -156,33 +156,33 @@ void EditViewBase::setupActions(TQString rcFileName, bool haveClipboard)
// Actions all edit views will have
KStdAction::showToolbar(this, TQT_SLOT(slotToggleToolBar()),
KStdAction::showToolbar(this, TQ_SLOT(slotToggleToolBar()),
actionCollection(), "options_show_toolbar");
KStdAction::showStatusbar(this, TQT_SLOT(slotToggleStatusBar()),
KStdAction::showStatusbar(this, TQ_SLOT(slotToggleStatusBar()),
actionCollection(), "options_show_statusbar");
KStdAction::preferences(this,
TQT_SLOT(slotConfigure()),
TQ_SLOT(slotConfigure()),
actionCollection());
KStdAction::keyBindings(this,
TQT_SLOT(slotEditKeys()),
TQ_SLOT(slotEditKeys()),
actionCollection());
KStdAction::configureToolbars(this,
TQT_SLOT(slotEditToolbars()),
TQ_SLOT(slotEditToolbars()),
actionCollection());
// File menu
KStdAction::save (this, TQT_SIGNAL(saveFile()), actionCollection());
KStdAction::close(this, TQT_SLOT(slotCloseWindow()), actionCollection());
KStdAction::save (this, TQ_SIGNAL(saveFile()), actionCollection());
KStdAction::close(this, TQ_SLOT(slotCloseWindow()), actionCollection());
if (haveClipboard) {
KStdAction::cut (this, TQT_SLOT(slotEditCut()), actionCollection());
KStdAction::copy (this, TQT_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQT_SLOT(slotEditPaste()), actionCollection());
KStdAction::cut (this, TQ_SLOT(slotEditCut()), actionCollection());
KStdAction::copy (this, TQ_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQ_SLOT(slotEditPaste()), actionCollection());
}
new TDEToolBarPopupAction(i18n("Und&o"),
@ -202,33 +202,33 @@ void EditViewBase::setupActions(TQString rcFileName, bool haveClipboard)
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/matrix.png");
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in Matri&x Editor"), icon, 0, this,
TQT_SLOT(slotOpenInMatrix()), actionCollection(),
TQ_SLOT(slotOpenInMatrix()), actionCollection(),
"open_in_matrix");
pixmap.load(pixmapDir + "/toolbar/matrix-percussion.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in &Percussion Matrix Editor"), icon, 0, this,
TQT_SLOT(slotOpenInPercussionMatrix()), actionCollection(),
TQ_SLOT(slotOpenInPercussionMatrix()), actionCollection(),
"open_in_percussion_matrix");
pixmap.load(pixmapDir + "/toolbar/notation.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in &Notation Editor"), icon, 0, this,
TQT_SLOT(slotOpenInNotation()), actionCollection(),
TQ_SLOT(slotOpenInNotation()), actionCollection(),
"open_in_notation");
pixmap.load(pixmapDir + "/toolbar/eventlist.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in &Event List Editor"), icon, 0, this,
TQT_SLOT(slotOpenInEventList()), actionCollection(),
TQ_SLOT(slotOpenInEventList()), actionCollection(),
"open_in_event_list");
new TDEAction(i18n("Set Segment Start Time..."), 0, this,
TQT_SLOT(slotSetSegmentStartTime()), actionCollection(),
TQ_SLOT(slotSetSegmentStartTime()), actionCollection(),
"set_segment_start");
new TDEAction(i18n("Set Segment Duration..."), 0, this,
TQT_SLOT(slotSetSegmentDuration()), actionCollection(),
TQ_SLOT(slotSetSegmentDuration()), actionCollection(),
"set_segment_duration");
// add undo and redo to edit menu and toolbar
@ -254,8 +254,8 @@ void EditViewBase::slotEditToolbars()
{
KEditToolbar dlg(actionCollection(), getRCFileName());
connect(&dlg, TQT_SIGNAL(newToolbarConfig()),
TQT_SLOT(slotUpdateToolbars()));
connect(&dlg, TQ_SIGNAL(newToolbarConfig()),
TQ_SLOT(slotUpdateToolbars()));
dlg.exec();
}

4
src/gui/general/PresetHandlerDialog.cpp
Unescape View File

@ -145,8 +145,8 @@ PresetHandlerDialog::initDialog()
}
connect(m_categoryCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotCategoryIndexChanged(int)));
connect(m_categoryCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotCategoryIndexChanged(int)));
}
TQString

4
src/gui/general/RosegardenCanvasView.cpp
Unescape View File

@ -58,8 +58,8 @@ RosegardenCanvasView::RosegardenCanvasView(TQCanvas* canvas,
m_autoScrolling(false)
{
setDragAutoScroll(true);
connect( &m_autoScrollTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( doAutoScroll() ) );
connect( &m_autoScrollTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( doAutoScroll() ) );
}
void RosegardenCanvasView::fitWidthToContents()

4
src/gui/general/RosegardenScrollView.cpp
Unescape View File

@ -64,8 +64,8 @@ RosegardenScrollView::RosegardenScrollView(TQWidget* parent,
m_autoScrolling(false)
{
setDragAutoScroll(true);
connect( &m_autoScrollTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( doAutoScroll() ) );
connect( &m_autoScrollTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( doAutoScroll() ) );
}
void RosegardenScrollView::setBottomFixedWidget(TQWidget* w)

8
src/gui/rulers/ChordNameRuler.cpp
Unescape View File

@ -88,8 +88,8 @@ ChordNameRuler::ChordNameRuler(RulerScale *rulerScale,
m_compositionRefreshStatusId = m_composition->getNewRefreshStatusId();
TQObject::connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
TQObject::connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
TQToolTip::add
(this, i18n("Chord name ruler.\nTurn it on and off from the Settings->Rulers menu."));
@ -129,8 +129,8 @@ ChordNameRuler::ChordNameRuler(RulerScale *rulerScale,
m_compositionRefreshStatusId = m_composition->getNewRefreshStatusId();
TQObject::connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
TQObject::connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
for (std::vector<Segment *>::iterator i = segments.begin();
i != segments.end(); ++i) {

4
src/gui/rulers/ControlRuler.cpp
Unescape View File

@ -86,8 +86,8 @@ ControlRuler::ControlRuler(Segment *segment,
setFixedHeight(sizeHint().height());
connect(this, TQT_SIGNAL(stateChange(const TQString&, bool)),
m_parentEditView, TQT_SLOT(slotStateChanged(const TQString&, bool)));
connect(this, TQ_SIGNAL(stateChange(const TQString&, bool)),
m_parentEditView, TQ_SLOT(slotStateChanged(const TQString&, bool)));
m_numberFloat = new TextFloat(this);
m_numberFloat->hide();

8
src/gui/rulers/MarkerRuler.cpp
Unescape View File

@ -96,21 +96,21 @@ MarkerRuler::MarkerRuler(RosegardenGUIDoc *doc,
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert.png"));
new TDEAction(i18n("Insert Marker"), icon, 0, this,
TQT_SLOT(slotInsertMarkerHere()), actionCollection(),
TQ_SLOT(slotInsertMarkerHere()), actionCollection(),
"insert_marker_here");
new TDEAction(i18n("Insert Marker at Playback Position"), 0, this,
TQT_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
TQ_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
"insert_marker_at_pointer");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png"));
new TDEAction(i18n("Delete Marker"), icon, 0, this,
TQT_SLOT(slotDeleteMarker()), actionCollection(),
TQ_SLOT(slotDeleteMarker()), actionCollection(),
"delete_marker");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png"));
new TDEAction(i18n("Edit Marker..."), icon, 0, this,
TQT_SLOT(slotEditMarker()), actionCollection(),
TQ_SLOT(slotEditMarker()), actionCollection(),
"edit_marker");
TQToolTip::add

48
src/gui/rulers/StandardRuler.cpp
Unescape View File

@ -74,8 +74,8 @@ StandardRuler::StandardRuler(RosegardenGUIDoc *doc,
}
TQObject::connect
(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
}
@ -94,49 +94,49 @@ void StandardRuler::connectRulerToDocPointer(RosegardenGUIDoc *doc)
// so they are re-emitted from the loop ruler by this widget
//
TQObject::connect
(m_loopRuler, TQT_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQ_SLOT(slotSetPointerPosition(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT)));
(m_hButtonBar, TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQ_SLOT(slotSetPointerPosition(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(editMarkers()),
RosegardenGUIApp::self(), TQT_SLOT(slotEditMarkers()));
(m_hButtonBar, TQ_SIGNAL(editMarkers()),
RosegardenGUIApp::self(), TQ_SLOT(slotEditMarkers()));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(addMarker(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotAddMarker(timeT)));
(m_hButtonBar, TQ_SIGNAL(addMarker(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotAddMarker(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(deleteMarker(int, timeT, TQString, TQString)),
RosegardenGUIApp::self(), TQT_SLOT(slotDeleteMarker(int, timeT, TQString, TQString)));
(m_hButtonBar, TQ_SIGNAL(deleteMarker(int, timeT, TQString, TQString)),
RosegardenGUIApp::self(), TQ_SLOT(slotDeleteMarker(int, timeT, TQString, TQString)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SIGNAL(dragPointerToPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SIGNAL(dragPointerToPosition(timeT)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SIGNAL(dragLoopToPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQ_SIGNAL(dragLoopToPosition(timeT)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(setPlayPosition(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotSetPlayPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(setPlayPosition(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotSetPlayPosition(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(setLoop(timeT, timeT)),
doc, TQT_SLOT(slotSetLoop(timeT, timeT)));
(m_hButtonBar, TQ_SIGNAL(setLoop(timeT, timeT)),
doc, TQ_SLOT(slotSetLoop(timeT, timeT)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(setLoop(timeT, timeT)),
doc, TQT_SLOT(slotSetLoop(timeT, timeT)));
(m_loopRuler, TQ_SIGNAL(setLoop(timeT, timeT)),
doc, TQ_SLOT(slotSetLoop(timeT, timeT)));
TQObject::connect
(doc, TQT_SIGNAL(loopChanged(timeT, timeT)),
(doc, TQ_SIGNAL(loopChanged(timeT, timeT)),
m_loopRuler,
TQT_SLOT(slotSetLoopMarker(timeT, timeT)));
TQ_SLOT(slotSetLoopMarker(timeT, timeT)));
m_loopRuler->setBackgroundColor(GUIPalette::getColour(GUIPalette::PointerRuler));
}

48
src/gui/rulers/TempoRuler.cpp
Unescape View File

@ -115,45 +115,45 @@ TempoRuler::TempoRuler(RulerScale *rulerScale,
setBackgroundMode(TQt::NoBackground);
TQObject::connect
(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
TQIconSet icon;
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png"));
new TDEAction(i18n("Insert Tempo Change"), icon, 0, this,
TQT_SLOT(slotInsertTempoHere()), actionCollection(),
TQ_SLOT(slotInsertTempoHere()), actionCollection(),
"insert_tempo_here");
new TDEAction(i18n("Insert Tempo Change at Playback Position"), 0, 0, this,
TQT_SLOT(slotInsertTempoAtPointer()), actionCollection(),
TQ_SLOT(slotInsertTempoAtPointer()), actionCollection(),
"insert_tempo_at_pointer");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png"));
new TDEAction(i18n("Delete Tempo Change"), icon, 0, this,
TQT_SLOT(slotDeleteTempoChange()), actionCollection(),
TQ_SLOT(slotDeleteTempoChange()), actionCollection(),
"delete_tempo");
new TDEAction(i18n("Ramp Tempo to Next Tempo"), 0, 0, this,
TQT_SLOT(slotRampToNext()), actionCollection(),
TQ_SLOT(slotRampToNext()), actionCollection(),
"ramp_to_next");
new TDEAction(i18n("Un-Ramp Tempo"), 0, 0, this,
TQT_SLOT(slotUnramp()), actionCollection(),
TQ_SLOT(slotUnramp()), actionCollection(),
"unramp");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png"));
new TDEAction(i18n("Edit Tempo..."), icon, 0, this,
TQT_SLOT(slotEditTempo()), actionCollection(),
TQ_SLOT(slotEditTempo()), actionCollection(),
"edit_tempo");
new TDEAction(i18n("Edit Time Signature..."), 0, 0, this,
TQT_SLOT(slotEditTimeSignature()), actionCollection(),
TQ_SLOT(slotEditTimeSignature()), actionCollection(),
"edit_time_signature");
new TDEAction(i18n("Open Tempo and Time Signature Editor"), 0, 0, this,
TQT_SLOT(slotEditTempos()), actionCollection(),
TQ_SLOT(slotEditTempos()), actionCollection(),
"edit_tempos");
setMouseTracking(false);
@ -172,47 +172,47 @@ void
TempoRuler::connectSignals()
{
connect(this,
TQT_SIGNAL(doubleClicked(timeT)),
TQ_SIGNAL(doubleClicked(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempos(timeT)));
TQ_SLOT(slotEditTempos(timeT)));
connect(this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(),
TQT_SLOT(slotChangeTempo(timeT,
TQ_SLOT(slotChangeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
connect(this,
TQT_SIGNAL(moveTempo(timeT,
TQ_SIGNAL(moveTempo(timeT,
timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotMoveTempo(timeT,
TQ_SLOT(slotMoveTempo(timeT,
timeT)));
connect(this,
TQT_SIGNAL(deleteTempo(timeT)),
TQ_SIGNAL(deleteTempo(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotDeleteTempo(timeT)));
TQ_SLOT(slotDeleteTempo(timeT)));
connect(this,
TQT_SIGNAL(editTempo(timeT)),
TQ_SIGNAL(editTempo(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempo(timeT)));
TQ_SLOT(slotEditTempo(timeT)));
connect(this,
TQT_SIGNAL(editTimeSignature(timeT)),
TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTimeSignature(timeT)));
TQ_SLOT(slotEditTimeSignature(timeT)));
connect(this,
TQT_SIGNAL(editTempos(timeT)),
TQ_SIGNAL(editTempos(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempos(timeT)));
TQ_SLOT(slotEditTempos(timeT)));
}
void

8
src/gui/seqmanager/MidiFilterDialog.cpp
Unescape View File

@ -124,11 +124,11 @@ MidiFilterDialog::MidiFilterDialog(TQWidget *parent,
sysRecord->setChecked(true);
connect(m_thruBox, TQT_SIGNAL(released(int)),
this, TQT_SLOT(slotSetModified()));
connect(m_thruBox, TQ_SIGNAL(released(int)),
this, TQ_SLOT(slotSetModified()));
connect(m_recordBox, TQT_SIGNAL(released(int)),
this, TQT_SLOT(slotSetModified()));
connect(m_recordBox, TQ_SIGNAL(released(int)),
this, TQ_SLOT(slotSetModified()));
setModified(false);
}

30
src/gui/seqmanager/SequenceManager.cpp
Unescape View File

@ -115,18 +115,18 @@ SequenceManager::SequenceManager(RosegardenGUIDoc *doc,
(m_doc->parent())->parentWidget());
// Connect these for use later
//
connect(m_countdownTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCountdownTimerTimeout()));
connect(m_countdownTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCountdownTimerTimeout()));
connect(m_reportTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotAllowReport()));
connect(m_reportTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotAllowReport()));
connect(m_compositionMmapperResetTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotScheduledCompositionMmapperReset()));
connect(m_compositionMmapperResetTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotScheduledCompositionMmapperReset()));
connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
m_doc->getComposition().addObserver(this);
@ -162,7 +162,7 @@ void SequenceManager::setDocument(RosegardenGUIDoc* doc)
DataBlockRepository::clear();
m_doc->getComposition().removeObserver(this);
disconnect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()));
disconnect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()));
m_segments.clear();
m_triggerSegments.clear();
@ -188,14 +188,14 @@ void SequenceManager::setDocument(RosegardenGUIDoc* doc)
// Connect this for use later
//
connect(m_countdownTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCountdownTimerTimeout()));
connect(m_countdownTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCountdownTimerTimeout()));
m_compositionRefreshStatusId = comp.getNewRefreshStatusId();
comp.addObserver(this);
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
for (Composition::iterator i = comp.begin(); i != comp.end(); ++i) {
@ -215,8 +215,8 @@ void SequenceManager::setDocument(RosegardenGUIDoc* doc)
m_compositionMmapperResetTimer = new TQTimer(m_doc);
connect(m_compositionMmapperResetTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotScheduledCompositionMmapperReset()));
connect(m_compositionMmapperResetTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotScheduledCompositionMmapperReset()));
resetCompositionMmapper();

94
src/gui/studio/AudioMixerWindow.cpp
Unescape View File

@ -95,13 +95,13 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
populate();
KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQT_SIGNAL(play()), actionCollection(), "play");
TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) );
@ -110,68 +110,68 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQT_SIGNAL(stop()), actionCollection(), "stop");
TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQT_SIGNAL(rewindPlayback()), actionCollection(),
TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQT_SIGNAL(fastForwardPlayback()), actionCollection(),
TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-record")));
new TDEAction(i18n("&Record"), icon, 0, this,
TQT_SIGNAL(record()), actionCollection(),
TQ_SIGNAL(record()), actionCollection(),
"record");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQT_SIGNAL(panic()), actionCollection(),
TQ_SIGNAL(panic()), actionCollection(),
"panic");
unsigned int mixerOptions = m_studio->getMixerDisplayOptions();
(new TDEToggleAction(i18n("Show Audio &Faders"), 0, this,
TQT_SLOT(slotToggleFaders()), actionCollection(),
TQ_SLOT(slotToggleFaders()), actionCollection(),
"show_audio_faders"))->setChecked
(!(mixerOptions & MIXER_OMIT_FADERS));
(new TDEToggleAction(i18n("Show Synth &Faders"), 0, this,
TQT_SLOT(slotToggleSynthFaders()), actionCollection(),
TQ_SLOT(slotToggleSynthFaders()), actionCollection(),
"show_synth_faders"))->setChecked
(!(mixerOptions & MIXER_OMIT_SYNTH_FADERS));
(new TDEToggleAction(i18n("Show &Submasters"), 0, this,
TQT_SLOT(slotToggleSubmasters()), actionCollection(),
TQ_SLOT(slotToggleSubmasters()), actionCollection(),
"show_audio_submasters"))->setChecked
(!(mixerOptions & MIXER_OMIT_SUBMASTERS));
(new TDEToggleAction(i18n("Show &Plugin Buttons"), 0, this,
TQT_SLOT(slotTogglePluginButtons()), actionCollection(),
TQ_SLOT(slotTogglePluginButtons()), actionCollection(),
"show_plugin_buttons"))->setChecked
(!(mixerOptions & MIXER_OMIT_PLUGINS));
(new TDEToggleAction(i18n("Show &Unassigned Faders"), 0, this,
TQT_SLOT(slotToggleUnassignedFaders()), actionCollection(),
TQ_SLOT(slotToggleUnassignedFaders()), actionCollection(),
"show_unassigned_faders"))->setChecked
(mixerOptions & MIXER_SHOW_UNASSIGNED_FADERS);
@ -181,7 +181,7 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action =
new TDERadioAction(i18n("1 Input", "%n Inputs", i),
0, this,
TQT_SLOT(slotSetInputCountFromAction()), actionCollection(),
TQ_SLOT(slotSetInputCountFromAction()), actionCollection(),
TQString("inputs_%1").arg(i).ascii());
action->setExclusiveGroup("inputs");
if (i == int(m_studio->getRecordIns().size()))
@ -191,7 +191,7 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action = new TDERadioAction
(i18n("No Submasters"),
0, this,
TQT_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQ_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQString("submasters_0").ascii());
action->setExclusiveGroup("submasters");
action->setChecked(true);
@ -200,7 +200,7 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action = new TDERadioAction
(i18n("1 Submaster", "%n Submasters", i),
0, this,
TQT_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQ_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQString("submasters_%1").arg(i).ascii());
action->setExclusiveGroup("submasters");
if (i == int(m_studio->getBusses().size()) - 1)
@ -388,8 +388,8 @@ AudioMixerWindow::populate()
TQToolTip::add
(plugin, i18n("Audio plugin button"));
rec.m_plugins.push_back(plugin);
connect(plugin, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSelectPlugin()));
connect(plugin, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSelectPlugin()));
}
TQLabel *idLabel;
@ -441,30 +441,30 @@ AudioMixerWindow::populate()
updatePluginButtons((*i)->getId());
if (rec.m_input) {
connect(rec.m_input, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotInputChanged()));
connect(rec.m_input, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotInputChanged()));
}
connect(rec.m_output, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotOutputChanged()));
connect(rec.m_output, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotOutputChanged()));
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_pan, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPanChanged(float)));
connect(rec.m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotPanChanged(float)));
connect(rec.m_soloButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSoloChanged()));
connect(rec.m_soloButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSoloChanged()));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged()));
connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotMuteChanged()));
connect(rec.m_stereoButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotChannelsChanged()));
connect(rec.m_stereoButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotChannelsChanged()));
connect(rec.m_recordButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotRecordChanged()));
connect(rec.m_recordButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotRecordChanged()));
++count;
@ -519,8 +519,8 @@ AudioMixerWindow::populate()
TQToolTip::add
(plugin, i18n("Audio plugin button"));
rec.m_plugins.push_back(plugin);
connect(plugin, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSelectPlugin()));
connect(plugin, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSelectPlugin()));
}
TQLabel *idLabel = new TQLabel(i18n("Sub %1").arg(count), m_mainBox, "subMaster");
@ -546,14 +546,14 @@ AudioMixerWindow::populate()
updateFader(count);
updatePluginButtons(count);
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_pan, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPanChanged(float)));
connect(rec.m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotPanChanged(float)));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged()));
connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotMuteChanged()));
++count;
@ -597,11 +597,11 @@ AudioMixerWindow::populate()
m_master = rec;
updateFader(0);
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged()));
connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotMuteChanged()));
}
m_mainBox->show();

70
src/gui/studio/BankEditorDialog.cpp
Unescape View File

@ -113,10 +113,10 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_applyButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotApply()));
connect(m_resetButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotReset()));
connect(m_applyButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotApply()));
connect(m_resetButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotReset()));
//
// Left-side list view
@ -191,8 +191,8 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
(m_pastePrograms,
i18n("Paste Program names from clipboard to current Bank"));
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)),
this, TQT_SLOT(slotPopulateDevice(TQListViewItem*)));
connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)),
this, TQ_SLOT(slotPopulateDevice(TQListViewItem*)));
TQFrame *vbox = new TQFrame(splitter);
TQVBoxLayout *vboxLayout = new TQVBoxLayout(vbox, 8, 6);
@ -217,44 +217,44 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
m_variationCombo->insertItem(i18n("MSB"));
// device/bank modification
connect(m_listView, TQT_SIGNAL(itemRenamed (TQListViewItem*, const TQString&, int)),
this, TQT_SLOT(slotModifyDeviceOrBankName(TQListViewItem*, const TQString&, int)));
connect(m_listView, TQ_SIGNAL(itemRenamed (TQListViewItem*, const TQString&, int)),
this, TQ_SLOT(slotModifyDeviceOrBankName(TQListViewItem*, const TQString&, int)));
connect(m_addBank, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddBank()));
connect(m_addBank, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddBank()));
connect(m_addKeyMapping, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddKeyMapping()));
connect(m_addKeyMapping, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddKeyMapping()));
connect(m_delete, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDelete()));
connect(m_delete, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDelete()));
connect(m_deleteAll, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteAll()));
connect(m_deleteAll, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteAll()));
connect(m_importBanks, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotImport()));
connect(m_importBanks, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotImport()));
connect(m_exportBanks, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotExport()));
connect(m_exportBanks, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotExport()));
connect(m_copyPrograms, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEditCopy()));
connect(m_copyPrograms, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEditCopy()));
connect(m_pastePrograms, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEditPaste()));
connect(m_pastePrograms, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEditPaste()));
connect(m_variationToggle, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotVariationToggled()));
connect(m_variationToggle, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotVariationToggled()));
connect(m_variationCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotVariationChanged(int)));
connect(m_variationCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotVariationChanged(int)));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
// Initialise the dialog
//
@ -301,14 +301,14 @@ BankEditorDialog::~BankEditorDialog()
void
BankEditorDialog::setupActions()
{
TDEAction* close = KStdAction::close (this, TQT_SLOT(slotFileClose()), actionCollection());
TDEAction* close = KStdAction::close (this, TQ_SLOT(slotFileClose()), actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotFileClose()));
connect(m_closeButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotFileClose()));
KStdAction::copy (this, TQT_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQT_SLOT(slotEditPaste()), actionCollection());
KStdAction::copy (this, TQ_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQ_SLOT(slotEditPaste()), actionCollection());
// some adjustments

10
src/gui/studio/DeviceEditorDialog.cpp
Unescape View File

@ -90,11 +90,11 @@ DeviceEditorDialog::DeviceEditorDialog(TQWidget *parent,
TQPushButton *addButton = new TQPushButton(i18n("Add Play Device"), hbox);
TQPushButton *addRButton = new TQPushButton(i18n("Add Record Device"), hbox);
TQPushButton *deleteButton = new TQPushButton(i18n("Delete Device"), hbox);
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddPlayDevice()));
connect(addRButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddRecordDevice()));
connect(deleteButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeleteDevice()));
connect(m_table, TQT_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotValueChanged (int, int)));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayDevice()));
connect(addRButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddRecordDevice()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeleteDevice()));
connect(m_table, TQ_SIGNAL(valueChanged(int, int)),
this, TQ_SLOT(slotValueChanged (int, int)));
setMinimumHeight(250);

44
src/gui/studio/DeviceManagerDialog.cpp
Unescape View File

@ -138,17 +138,17 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
(m_controllersButton,
i18n("View and edit Control Events for the selected device - these are special Event types that you can define against your device and control through Control Rulers or the Instrument Parameter Box "));
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddPlayDevice()));
connect(m_deletePlayButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeletePlayDevice()));
connect(m_importButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotImport()));
connect(m_exportButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotExport()));
connect(m_banksButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetBanks()));
connect(m_controllersButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetControllers()));
connect(m_playTable, TQT_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotPlayValueChanged (int, int)));
connect(m_playTable, TQT_SIGNAL(currentChanged(int, int)),
this, TQT_SLOT(slotPlayDeviceSelected (int, int)));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayDevice()));
connect(m_deletePlayButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeletePlayDevice()));
connect(m_importButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotImport()));
connect(m_exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotExport()));
connect(m_banksButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetBanks()));
connect(m_controllersButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetControllers()));
connect(m_playTable, TQ_SIGNAL(valueChanged(int, int)),
this, TQ_SLOT(slotPlayValueChanged (int, int)));
connect(m_playTable, TQ_SIGNAL(currentChanged(int, int)),
this, TQ_SLOT(slotPlayDeviceSelected (int, int)));
mainLayout->addWidget(groupBox);
groupBox = new TQGroupBox(2, TQt::Horizontal, i18n("Record devices"), mainBox);
@ -181,15 +181,15 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
(m_deleteRecordButton,
i18n("Delete the selected device"));
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddRecordDevice()));
connect(m_deleteRecordButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeleteRecordDevice()));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddRecordDevice()));
connect(m_deleteRecordButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeleteRecordDevice()));
connect(m_recordTable, TQT_SIGNAL(currentChanged(int, int)),
this, TQT_SLOT(slotRecordDeviceSelected (int, int)));
connect(m_recordTable, TQT_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotRecordValueChanged (int, int)));
connect(m_recordTable, TQ_SIGNAL(currentChanged(int, int)),
this, TQ_SLOT(slotRecordDeviceSelected (int, int)));
connect(m_recordTable, TQ_SIGNAL(valueChanged(int, int)),
this, TQ_SLOT(slotRecordValueChanged (int, int)));
connect(document, TQT_SIGNAL(devicesResyncd()), this, TQT_SLOT(slotDevicesResyncd()));
connect(document, TQ_SIGNAL(devicesResyncd()), this, TQ_SLOT(slotDevicesResyncd()));
m_noConnectionString = i18n("No connection");
@ -213,11 +213,11 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
layout->addSpacing(5);
TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
closeButton->setText(close->text());
connect(closeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClose()));
connect(closeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClose()));
mainLayout->addWidget(btnBox);
@ -237,8 +237,8 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
createGUI("devicemanager.rc");
m_document->getCommandHistory()->attachView(actionCollection());
connect(m_document->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(populate()));
connect(m_document->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(populate()));
m_playTable->setCurrentCell( -1, 0);
m_recordTable->setCurrentCell( -1, 0);

30
src/gui/studio/MidiMixerWindow.cpp
Unescape View File

@ -71,13 +71,13 @@ MidiMixerWindow::MidiMixerWindow(TQWidget *parent,
setupTabs();
KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQT_SIGNAL(play()), actionCollection(), "play");
TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) );
@ -86,42 +86,42 @@ MidiMixerWindow::MidiMixerWindow(TQWidget *parent,
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQT_SIGNAL(stop()), actionCollection(), "stop");
TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQT_SIGNAL(rewindPlayback()), actionCollection(),
TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQT_SIGNAL(fastForwardPlayback()), actionCollection(),
TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-record")));
new TDEAction(i18n("&Record"), icon, 0, this,
TQT_SIGNAL(record()), actionCollection(),
TQ_SIGNAL(record()), actionCollection(),
"record");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQT_SIGNAL(panic()), actionCollection(),
TQ_SIGNAL(panic()), actionCollection(),
"panic");
createGUI("midimixer.rc");
@ -144,8 +144,8 @@ MidiMixerWindow::setupTabs()
//
m_tabWidget = new TQTabWidget(this);
setCentralWidget(m_tabWidget);
connect(m_tabWidget, TQT_SIGNAL(currentChanged(TQWidget *)),
this, TQT_SLOT(slotCurrentTabChanged(TQWidget *)));
connect(m_tabWidget, TQ_SIGNAL(currentChanged(TQWidget *)),
this, TQ_SLOT(slotCurrentTabChanged(TQWidget *)));
m_tabWidget->setTabPosition(TQTabWidget::Bottom);
setCaption(i18n("MIDI Mixer"));
@ -246,8 +246,8 @@ MidiMixerWindow::setupTabs()
controller->setKnobColour(knobColour);
connect(controller, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotControllerChanged(float)));
connect(controller, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotControllerChanged(float)));
mainLayout->addWidget(controller, i + 1, posCount,
TQt::AlignCenter);
@ -291,8 +291,8 @@ MidiMixerWindow::setupTabs()
// Connect them up
//
connect(fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
// Update all the faders and controllers
//

16
src/gui/studio/MidiProgramsEditor.cpp
Unescape View File

@ -91,8 +91,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
gridLayout->addWidget(new TQLabel(i18n("Percussion"), frame),
0, 0, AlignLeft);
gridLayout->addWidget(m_percussion, 0, 1, AlignLeft);
connect(m_percussion, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotNewPercussion()));
connect(m_percussion, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotNewPercussion()));
gridLayout->addWidget(new TQLabel(i18n("MSB Value"), frame),
1, 0, AlignLeft);
@ -108,8 +108,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
(m_lsb,
i18n("Selects a LSB controller Bank number (MSB/LSB pairs are always unique for any Device)"));
connect(m_msb, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotNewMSB(int)));
connect(m_msb, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotNewMSB(int)));
gridLayout->addWidget(new TQLabel(i18n("LSB Value"), frame),
2, 0, AlignLeft);
@ -117,8 +117,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
m_lsb->setMaxValue(127);
gridLayout->addWidget(m_lsb, 2, 1, AlignLeft);
connect(m_lsb, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotNewLSB(int)));
connect(m_lsb, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotNewLSB(int)));
return frame;
}
@ -472,12 +472,12 @@ MidiProgramsEditor::slotEntryButtonPressed()
int currentEntry = 0;
menu->insertItem(i18n("<no key mapping>"), this,
TQT_SLOT(slotEntryMenuItemSelected(int)), 0, 0);
TQ_SLOT(slotEntryMenuItemSelected(int)), 0, 0);
menu->setItemParameter(0, 0);
for (int i = 0; i < kml.size(); ++i) {
menu->insertItem(strtoqstr(kml[i].getName()),
this, TQT_SLOT(slotEntryMenuItemSelected(int)),
this, TQ_SLOT(slotEntryMenuItemSelected(int)),
0, i + 1);
menu->setItemParameter(i + 1, i + 1);
if (currentMapping && (kml[i] == *currentMapping))

12
src/gui/studio/NameSetEditor.cpp
Unescape View File

@ -103,9 +103,9 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
// Initial label; button to adjust whether labels start at 0 or 1
m_initialLabel = new TQPushButton(numberText, numBox);
connect(m_initialLabel,
TQT_SIGNAL(clicked()),
TQ_SIGNAL(clicked()),
this,
TQT_SLOT(slotToggleInitialLabel()));
TQ_SLOT(slotToggleInitialLabel()));
} else {
TQLabel *label = new TQLabel(numberText, numBox);
label->setFixedWidth(40);
@ -120,8 +120,8 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
button->setMaximumWidth(40);
button->setMaximumHeight(20);
button->setFlat(true);
connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEntryButtonPressed()));
connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEntryButtonPressed()));
m_entryButtons.push_back(button);
}
@ -132,9 +132,9 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
m_names.push_back(lineEdit);
connect(m_names[labelId],
TQT_SIGNAL(textChanged(const TQString&)),
TQ_SIGNAL(textChanged(const TQString&)),
this,
TQT_SLOT(slotNameChanged(const TQString&)));
TQ_SLOT(slotNameChanged(const TQString&)));
++labelId;
}

4
src/gui/studio/RemapInstrumentDialog.cpp
Unescape View File

@ -65,8 +65,8 @@ RemapInstrumentDialog::RemapInstrumentDialog(TQWidget *parent,
m_instrumentButton = new TQRadioButton(i18n("Instrument"), m_buttonGroup);
connect(m_buttonGroup, TQT_SIGNAL(released(int)),
this, TQT_SLOT(slotRemapReleased(int)));
connect(m_buttonGroup, TQ_SIGNAL(released(int)),
this, TQ_SLOT(slotRemapReleased(int)));
TQGroupBox *groupBox = new TQGroupBox(2, TQt::Horizontal,
i18n("Choose Source and Destination"),

12
src/gui/studio/SynthPluginManagerDialog.cpp
Unescape View File

@ -133,8 +133,8 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
}
}
connect(pluginCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPluginChanged(int)));
connect(pluginCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPluginChanged(int)));
pluginLayout->addWidget(pluginCombo, i, 1);
@ -142,7 +142,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
TQPushButton *controlsButton = new TQPushButton(i18n("Controls"), pluginFrame);
pluginLayout->addWidget(controlsButton, i, 2);
connect(controlsButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotControlsButtonClicked()));
connect(controlsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotControlsButtonClicked()));
m_controlsButtons.push_back(controlsButton);
#ifdef HAVE_LIBLO
@ -151,7 +151,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
pluginLayout->addWidget(guiButton, i, 3);
guiButton->setEnabled(m_guiManager->hasGUI
(id, Instrument::SYNTH_PLUGIN_POSITION));
connect(guiButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotGUIButtonClicked()));
connect(guiButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotGUIButtonClicked()));
m_guiButtons.push_back(guiButton);
#endif
@ -170,11 +170,11 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
layout->addSpacing(5);
TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()),
TQ_SLOT(slotClose()),
actionCollection());
closeButton->setText(close->text());
connect(closeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClose()));
connect(closeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClose()));
mainLayout->addWidget(btnBox);

2
src/gui/studio/TimerCallbackAssistant.cpp
Unescape View File

@ -36,7 +36,7 @@ TimerCallbackAssistant::TimerCallbackAssistant(int ms, void (*callback)(void *da
m_data(data)
{
TQTimer *timer = new TQTimer(this);
connect(timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotCallback()));
connect(timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotCallback()));
timer->start(ms, FALSE);
}

8
src/gui/widgets/AudioFaderBox.cpp
Unescape View File

@ -81,8 +81,8 @@ AudioFaderBox::AudioFaderBox(TQWidget *parent,
m_plugins.push_back(plugin);
m_signalMapper->setMapping(plugin, i);
connect(plugin, TQT_SIGNAL(clicked()),
m_signalMapper, TQT_SLOT(map()));
connect(plugin, TQ_SIGNAL(clicked()),
m_signalMapper, TQ_SLOT(map()));
}
m_synthButton = new TQPushButton(this);
@ -127,8 +127,8 @@ AudioFaderBox::AudioFaderBox(TQWidget *parent,
m_stereoButton->setPixmap(m_monoPixmap); // default is mono
m_stereoButton->setFixedSize(24, 24);
connect(m_stereoButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotChannelStateChanged()));
connect(m_stereoButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotChannelStateChanged()));
m_synthGUIButton = new TQPushButton(this);
m_synthGUIButton->setText(i18n("Editor"));

8
src/gui/widgets/AudioRouteMenu.cpp
Unescape View File

@ -58,15 +58,15 @@ AudioRouteMenu::AudioRouteMenu(TQWidget *par,
case Compact: {
m_combo = 0;
m_button = new WheelyButton(par);
connect(m_button, TQT_SIGNAL(wheel(bool)), this, TQT_SLOT(slotWheel(bool)));
connect(m_button, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotShowMenu()));
connect(m_button, TQ_SIGNAL(wheel(bool)), this, TQ_SLOT(slotWheel(bool)));
connect(m_button, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotShowMenu()));
break;
}
case Regular: {
m_button = 0;
m_combo = new KComboBox(par);
connect(m_combo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotEntrySelected(int)));
connect(m_combo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotEntrySelected(int)));
break;
}
@ -135,7 +135,7 @@ AudioRouteMenu::slotShowMenu()
for (int i = 0; i < getNumEntries(); ++i) {
menu->insertItem(getEntryText(i), this, TQT_SLOT(slotEntrySelected(int)),
menu->insertItem(getEntryText(i), this, TQ_SLOT(slotEntrySelected(int)),
0, i);
menu->setItemParameter(i, i);
}

2
src/gui/widgets/CollapsingFrame.cpp
Unescape View File

@ -62,7 +62,7 @@ CollapsingFrame::CollapsingFrame(TQString label, TQWidget *parent, const char *n
TQPixmap pixmap(pixmapDir + "/misc/arrow-expanded.png");
m_toggleButton->setIconSet(pixmap);
connect(m_toggleButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(toggle()));
connect(m_toggleButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(toggle()));
m_layout->addMultiCellWidget(m_toggleButton, 0, 0, 0, 2);
}

4
src/gui/widgets/ColourTable.cpp
Unescape View File

@ -49,8 +49,8 @@ ColourTable::ColourTable
horizontalHeader()->setLabel(0, i18n("Name"));
horizontalHeader()->setLabel(1, i18n("Color"));
populate_table(input, list);
connect(this, TQT_SIGNAL(doubleClicked(int, int, int, const TQPoint&)),
TQT_SLOT(slotEditEntry(int, int)));
connect(this, TQ_SIGNAL(doubleClicked(int, int, int, const TQPoint&)),
TQ_SLOT(slotEditEntry(int, int)));
}

4
src/gui/widgets/CurrentProgressDialog.cpp
Unescape View File

@ -54,8 +54,8 @@ CurrentProgressDialog::set(ProgressDialog* d)
m_currentProgressDialog = d;
// this lets the progress dialog deregister itself when it's deleted
connect(d, TQT_SIGNAL(destroyed()),
getInstance(), TQT_SLOT(slotCurrentProgressDialogDestroyed()));
connect(d, TQ_SIGNAL(destroyed()),
getInstance(), TQ_SLOT(slotCurrentProgressDialogDestroyed()));
}
void CurrentProgressDialog::freeze()

48
src/gui/widgets/DiatonicPitchChooser.cpp
Unescape View File

@ -89,41 +89,41 @@ DiatonicPitchChooser::DiatonicPitchChooser(TQString title,
m_pitchLabel->setMinimumWidth(40);
connect(m_accidental, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetAccidental(int)));
connect(m_accidental, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetAccidental(int)));
connect(m_octave, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetOctave(int)));
connect(m_octave, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetOctave(int)));
connect(m_step, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetStep(int)));
connect(m_step, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetStep(int)));
//connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SIGNAL(pitchChanged(int)));
//connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SIGNAL(pitchChanged(int)));
//connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SIGNAL(preview(int)));
//connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int,int,int)),
this, TQT_SLOT(slotSetNote(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int,int,int)),
this, TQ_SLOT(slotSetNote(int,int,int)));
//connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
// this, TQT_SLOT(slotSetPitch(int)));
//connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
// this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int,int,int)),
this, TQT_SLOT(slotSetNote(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int,int,int)),
this, TQ_SLOT(slotSetNote(int,int,int)));
//connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
// this, TQT_SIGNAL(pitchChanged(int)));
//connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
// this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int,int,int)),
this, TQT_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int,int,int)),
this, TQ_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int,int,int)),
this, TQT_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int,int,int)),
this, TQ_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQT_SIGNAL(preview(int)),
this, TQT_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(preview(int)),
this, TQ_SIGNAL(preview(int)));
}

6
src/gui/widgets/Fader.cpp
Unescape View File

@ -76,7 +76,7 @@ Fader::Fader(AudioLevel::FaderType type,
calculateGroovePixmap();
setFader(0.0);
connect(m_floatTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotFloatTimeout()));
connect(m_floatTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotFloatTimeout()));
m_float->hide();
}
@ -113,7 +113,7 @@ Fader::Fader(int min, int max, int deflt,
calculateGroovePixmap();
setFader(deflt);
connect(m_floatTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotFloatTimeout()));
connect(m_floatTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotFloatTimeout()));
m_float->hide();
}
@ -144,7 +144,7 @@ Fader::Fader(int min, int max, int deflt,
calculateGroovePixmap();
setFader(deflt);
connect(m_floatTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotFloatTimeout()));
connect(m_floatTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotFloatTimeout()));
m_float->hide();
}

2
src/gui/widgets/HSpinBox.cpp
Unescape View File

@ -64,7 +64,7 @@ HSpinBox::HSpinBox( TQWidget* parent, float initialValue, int step,
initialize(decimals);
setValuef(initialValue);
if (recv != NULL && mem != NULL)
TQObject::connect(this, TQT_SIGNAL(valueChanged(int)), recv, mem);
TQObject::connect(this, TQ_SIGNAL(valueChanged(int)), recv, mem);
}
float HSpinBox::valuef() { return float(value()) / m_scaleFactor; }

28
src/gui/widgets/PitchChooser.cpp
Unescape View File

@ -59,26 +59,26 @@ PitchChooser::PitchChooser(TQString title,
m_pitchLabel = new TQLabel(pl.getTQString(), hbox);
m_pitchLabel->setMinimumWidth(40);
connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSetPitch(int)));
connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
this, TQT_SIGNAL(pitchChanged(int)));
connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
this, TQT_SIGNAL(preview(int)));
connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQ_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int)),
this, TQT_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int)),
this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
this, TQT_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
this, TQT_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(preview(int)),
this, TQT_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(preview(int)),
this, TQ_SIGNAL(preview(int)));
}

4
src/gui/widgets/PluginControl.cpp
Unescape View File

@ -146,8 +146,8 @@ PluginControl::PluginControl(TQWidget *parent,
m_dial->setKnobColour(GUIPalette::getColour(GUIPalette::RotaryPlugin));
connect(m_dial, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotValueChanged(float)));
connect(m_dial, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotValueChanged(float)));
TQLabel *upp;
if (port->getDisplayHint() &

8
src/gui/widgets/ProgressDialog.cpp
Unescape View File

@ -52,8 +52,8 @@ ProgressDialog::ProgressDialog(TQWidget *creator,
RG_DEBUG << "ProgressDialog::ProgressDialog type 1 - "
<< labelText() << " - modal : " << modal << endl;
connect(progressBar(), TQT_SIGNAL(percentageChanged (int)),
this, TQT_SLOT(slotCheckShow(int)));
connect(progressBar(), TQ_SIGNAL(percentageChanged (int)),
this, TQ_SLOT(slotCheckShow(int)));
m_chrono.start();
@ -83,8 +83,8 @@ ProgressDialog::ProgressDialog(
RG_DEBUG << "ProgressDialog::ProgressDialog type 2 - "
<< labelText << " - modal : " << modal << endl;
connect(progressBar(), TQT_SIGNAL(percentageChanged (int)),
this, TQT_SLOT(slotCheckShow(int)));
connect(progressBar(), TQ_SIGNAL(percentageChanged (int)),
this, TQ_SLOT(slotCheckShow(int)));
m_chrono.start();

6
src/gui/widgets/QuantizeParameters.cpp
Unescape View File

@ -180,8 +180,8 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
m_advancedButton =
new TQPushButton(i18n("Show advanced options"), this);
m_mainLayout->addWidget(m_advancedButton, zero + 2, 0, TQt::AlignLeft);
TQObject::connect(m_advancedButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAdvancedChanged()));
TQObject::connect(m_advancedButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAdvancedChanged()));
}
TQFrame *postFrame = new TQFrame(m_postProcessingBox);
@ -335,7 +335,7 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
break;
}
connect(m_typeCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotTypeChanged(int)));
connect(m_typeCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotTypeChanged(int)));
}
Quantizer *

8
src/gui/widgets/Rotary.cpp
Unescape View File

@ -97,8 +97,8 @@ Rotary::Rotary(TQWidget *parent,
}
// connect timer
connect(_floatTimer, TQT_SIGNAL(timeout()), this,
TQT_SLOT(slotFloatTimeout()));
connect(_floatTimer, TQ_SIGNAL(timeout()), this,
TQ_SLOT(slotFloatTimeout()));
_float->hide();
TQToolTip::add
@ -113,8 +113,8 @@ Rotary::~Rotary()
{
// Remove this connection
//
disconnect(_floatTimer, TQT_SIGNAL(timeout()), this,
TQT_SLOT(slotFloatTimeout()));
disconnect(_floatTimer, TQ_SIGNAL(timeout()), this,
TQ_SLOT(slotFloatTimeout()));
delete _float;
_float = 0;

32
src/gui/widgets/TimeWidget.cpp
Unescape View File

@ -129,8 +129,8 @@ TimeWidget::init(bool editable)
(NotePixmapFactory::makeNoteMenuPixmap(duration, error));
m_note->insertItem(pmap, label); // ignore error
}
connect(m_note, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotNoteChanged(int)));
connect(m_note, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotNoteChanged(int)));
layout->addMultiCellWidget(m_note, 0, 0, 1, 3);
} else {
@ -154,8 +154,8 @@ TimeWidget::init(bool editable)
m_timeT = new TQSpinBox(frame);
m_timeT->setLineStep
(Note(Note::Shortest).getDuration());
connect(m_timeT, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotTimeTChanged(int)));
connect(m_timeT, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotTimeTChanged(int)));
layout->addWidget(m_timeT, 0, 5);
} else {
m_timeT = 0;
@ -176,8 +176,8 @@ TimeWidget::init(bool editable)
m_timeT = new TQSpinBox(frame);
m_timeT->setLineStep
(Note(Note::Shortest).getDuration());
connect(m_timeT, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotTimeTChanged(int)));
connect(m_timeT, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotTimeTChanged(int)));
layout->addWidget(m_timeT, 0, 1);
layout->addWidget(new TQLabel(i18n("units"), frame), 0, 2);
} else {
@ -197,8 +197,8 @@ TimeWidget::init(bool editable)
m_bar = new TQSpinBox(frame);
if (m_isDuration)
m_bar->setMinValue(0);
connect(m_bar, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotBarBeatOrFractionChanged(int)));
connect(m_bar, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotBarBeatOrFractionChanged(int)));
layout->addWidget(m_bar, 1, 1);
} else {
m_bar = 0;
@ -215,8 +215,8 @@ TimeWidget::init(bool editable)
m_beatLabel = 0;
m_beat = new TQSpinBox(frame);
m_beat->setMinValue(1);
connect(m_beat, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotBarBeatOrFractionChanged(int)));
connect(m_beat, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotBarBeatOrFractionChanged(int)));
layout->addWidget(m_beat, 1, 3);
} else {
m_beat = 0;
@ -236,8 +236,8 @@ TimeWidget::init(bool editable)
m_fractionLabel = 0;
m_fraction = new TQSpinBox(frame);
m_fraction->setMinValue(1);
connect(m_fraction, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotBarBeatOrFractionChanged(int)));
connect(m_fraction, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotBarBeatOrFractionChanged(int)));
layout->addWidget(m_fraction, 1, 5);
} else {
m_fraction = 0;
@ -258,8 +258,8 @@ TimeWidget::init(bool editable)
m_sec = new TQSpinBox(frame);
if (m_isDuration)
m_sec->setMinValue(0);
connect(m_sec, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSecOrMSecChanged(int)));
connect(m_sec, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSecOrMSecChanged(int)));
layout->addWidget(m_sec, 2, 1);
} else {
m_sec = 0;
@ -277,8 +277,8 @@ TimeWidget::init(bool editable)
m_msec = new TQSpinBox(frame);
m_msec->setMinValue(0);
m_msec->setLineStep(10);
connect(m_msec, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSecOrMSecChanged(int)));
connect(m_msec, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSecOrMSecChanged(int)));
layout->addWidget(m_msec, 2, 3);
} else {
m_msec = 0;

16
src/gui/widgets/VUMeter.cpp
Unescape View File

@ -92,26 +92,26 @@ VUMeter::VUMeter(TQWidget *parent,
//
m_fallTimerLeft = new TQTimer();
connect(m_fallTimerLeft, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotReduceLevelLeft()));
connect(m_fallTimerLeft, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotReduceLevelLeft()));
if (m_showPeakLevel) {
m_peakTimerLeft = new TQTimer();
connect(m_peakTimerLeft, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotStopShowingPeakLeft()));
connect(m_peakTimerLeft, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotStopShowingPeakLeft()));
}
if (stereo) {
m_fallTimerRight = new TQTimer();
connect(m_fallTimerRight, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotReduceLevelRight()));
connect(m_fallTimerRight, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotReduceLevelRight()));
if (m_showPeakLevel) {
m_peakTimerRight = new TQTimer();
connect(m_peakTimerRight, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotStopShowingPeakRight()));
connect(m_peakTimerRight, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotStopShowingPeakRight()));
}
}

4
src/sequencer/RosegardenSequencerApp.cpp
Unescape View File

@ -118,8 +118,8 @@ RosegardenSequencerApp::RosegardenSequencerApp() :
// Check for new clients every so often
//
m_newClientTimer = new TQTimer(this);
connect(m_newClientTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCheckForNewClients()));
connect(m_newClientTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCheckForNewClients()));
m_newClientTimer->start(3000); // every 3 seconds
}

2
src/sequencer/main.cpp
Unescape View File

@ -101,7 +101,7 @@ int main(int argc, char *argv[])
roseSeq = new RosegardenSequencerApp;
}
TQObject::connect(&app, TQT_SIGNAL(lastWindowClosed()), &app, TQT_SLOT(quit()));
TQObject::connect(&app, TQ_SIGNAL(lastWindowClosed()), &app, TQ_SLOT(quit()));
app.disableSessionManagement(); // we don't want to be
// saved/restored by session

4
src/sound/AudioFileManager.cpp
Unescape View File

@ -95,8 +95,8 @@ AudioFileManager::AudioFileManager() :
// Retransmit progress
//
connect(&m_peakManager, TQT_SIGNAL(setProgress(int)),
this, TQT_SIGNAL(setProgress(int)));
connect(&m_peakManager, TQ_SIGNAL(setProgress(int)),
this, TQ_SIGNAL(setProgress(int)));
}
AudioFileManager::~AudioFileManager()

4
src/sound/PeakFileManager.cpp
Unescape View File

@ -176,8 +176,8 @@ PeakFileManager::generatePeaks(AudioFile *audioFile,
if (audioFile->getType() == WAV) {
m_currentPeakFile = getPeakFile(audioFile);
TQObject::connect(m_currentPeakFile, TQT_SIGNAL(setProgress(int)),
this, TQT_SIGNAL(setProgress(int)));
TQObject::connect(m_currentPeakFile, TQ_SIGNAL(setProgress(int)),
this, TQ_SIGNAL(setProgress(int)));
// Just write out a peak file
//

Write Preview
Loading…
Cancel
Save