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>
pull/19/head
Michele Calgaro 5 months ago
parent 9b054308ce
commit e9f46130c2
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 void
AudioSegmentRescaleCommand::connectProgressDialog(ProgressDialog *dlg) AudioSegmentRescaleCommand::connectProgressDialog(ProgressDialog *dlg)
{ {
TQObject::connect(m_stretcher, TQT_SIGNAL(setProgress(int)), TQObject::connect(m_stretcher, TQ_SIGNAL(setProgress(int)),
dlg->progressBar(), TQT_SLOT(setValue(int))); dlg->progressBar(), TQ_SLOT(setValue(int)));
TQObject::connect(dlg, TQT_SIGNAL(cancelClicked()), TQObject::connect(dlg, TQ_SIGNAL(cancelClicked()),
m_stretcher, TQT_SLOT(slotStopTimestretch())); m_stretcher, TQ_SLOT(slotStopTimestretch()));
} }
void void
AudioSegmentRescaleCommand::disconnectProgressDialog(ProgressDialog *dlg) AudioSegmentRescaleCommand::disconnectProgressDialog(ProgressDialog *dlg)
{ {
TQObject::disconnect(m_stretcher, TQT_SIGNAL(setProgress(int)), TQObject::disconnect(m_stretcher, TQ_SIGNAL(setProgress(int)),
dlg->progressBar(), TQT_SLOT(setValue(int))); dlg->progressBar(), TQ_SLOT(setValue(int)));
TQObject::disconnect(dlg, TQT_SIGNAL(cancelClicked()), TQObject::disconnect(dlg, TQ_SIGNAL(cancelClicked()),
m_stretcher, TQT_SLOT(slotStopTimestretch())); m_stretcher, TQ_SLOT(slotStopTimestretch()));
} }
void 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))); TDEToolBarPopupAction *undo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Undo)));
if (undo) { if (undo) {
connect(undo, TQT_SIGNAL(activated()), connect(undo, TQ_SIGNAL(activated()),
this, TQT_SLOT(slotUndo())); this, TQ_SLOT(slotUndo()));
connect connect
(undo->popupMenu(), (undo->popupMenu(),
TQT_SIGNAL(aboutToShow()), TQ_SIGNAL(aboutToShow()),
this, this,
TQT_SLOT(slotUndoAboutToShow())); TQ_SLOT(slotUndoAboutToShow()));
connect connect
(undo->popupMenu(), (undo->popupMenu(),
TQT_SIGNAL(activated(int)), TQ_SIGNAL(activated(int)),
this, this,
TQT_SLOT(slotUndoActivated(int))); TQ_SLOT(slotUndoActivated(int)));
} }
TDEToolBarPopupAction *redo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Redo))); TDEToolBarPopupAction *redo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Redo)));
if (redo) { if (redo) {
connect(redo, TQT_SIGNAL(activated()), connect(redo, TQ_SIGNAL(activated()),
this, TQT_SLOT(slotRedo())); this, TQ_SLOT(slotRedo()));
connect connect
(redo->popupMenu(), (redo->popupMenu(),
TQT_SIGNAL(aboutToShow()), TQ_SIGNAL(aboutToShow()),
this, this,
TQT_SLOT(slotRedoAboutToShow())); TQ_SLOT(slotRedoAboutToShow()));
connect connect
(redo->popupMenu(), (redo->popupMenu(),
TQT_SIGNAL(activated(int)), TQ_SIGNAL(activated(int)),
this, this,
TQT_SLOT(slotRedoActivated(int))); TQ_SLOT(slotRedoActivated(int)));
} }
m_views.insert(collection); 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_viewList.setAutoDelete(false);
m_editViewList.setAutoDelete(false); m_editViewList.setAutoDelete(false);
connect(m_commandHistory, TQT_SIGNAL(commandExecuted(KCommand *)), connect(m_commandHistory, TQ_SIGNAL(commandExecuted(KCommand *)),
this, TQT_SLOT(slotDocumentModified())); this, TQ_SLOT(slotDocumentModified()));
connect(m_commandHistory, TQT_SIGNAL(documentRestored()), connect(m_commandHistory, TQ_SIGNAL(documentRestored()),
this, TQT_SLOT(slotDocumentRestored())); this, TQ_SLOT(slotDocumentRestored()));
// autoload a new document // autoload a new document
if (!skipAutoload) if (!skipAutoload)
@ -584,8 +584,8 @@ bool RosegardenGUIDoc::openDocument(const TQString& filename,
100, 100,
(TQWidget*)parent()); (TQWidget*)parent());
connect(&progressDlg, TQT_SIGNAL(cancelClicked()), connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&m_audioFileManager, TQT_SLOT(slotStopPreview())); &m_audioFileManager, TQ_SLOT(slotStopPreview()));
progressDlg.setMinimumDuration(500); progressDlg.setMinimumDuration(500);
progressDlg.setAutoReset(true); // we're re-using it for the preview generation 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 // reuse the previous one
progressDlg.setLabel(i18n("Generating audio previews...")); progressDlg.setLabel(i18n("Generating audio previews..."));
connect(&m_audioFileManager, TQT_SIGNAL(setProgress(int)), connect(&m_audioFileManager, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int))); progressDlg.progressBar(), TQ_SLOT(setValue(int)));
try { try {
// generate any audio previews after loading the files // generate any audio previews after loading the files
m_audioFileManager.generatePreviews(); m_audioFileManager.generatePreviews();
@ -1575,14 +1575,14 @@ RosegardenGUIDoc::xmlParse(TQString fileContents, TQString &errMsg,
RoseXmlHandler handler(this, elementCount, permanent); RoseXmlHandler handler(this, elementCount, permanent);
if (progress) { if (progress) {
connect(&handler, TQT_SIGNAL(setProgress(int)), connect(&handler, TQ_SIGNAL(setProgress(int)),
progress->progressBar(), TQT_SLOT(setValue(int))); progress->progressBar(), TQ_SLOT(setValue(int)));
connect(&handler, TQT_SIGNAL(setOperationName(TQString)), connect(&handler, TQ_SIGNAL(setOperationName(TQString)),
progress, TQT_SLOT(slotSetOperationName(TQString))); progress, TQ_SLOT(slotSetOperationName(TQString)));
connect(&handler, TQT_SIGNAL(incrementProgress(int)), connect(&handler, TQ_SIGNAL(incrementProgress(int)),
progress->progressBar(), TQT_SLOT(advance(int))); progress->progressBar(), TQ_SLOT(advance(int)));
connect(progress, TQT_SIGNAL(cancelClicked()), connect(progress, TQ_SIGNAL(cancelClicked()),
&handler, TQT_SLOT(slotCancel())); &handler, TQ_SLOT(slotCancel()));
} }
TQXmlInputSource source; TQXmlInputSource source;
@ -2789,11 +2789,11 @@ RosegardenGUIDoc::finalizeAudioFile(InstrumentId iid)
progressDlg->setAutoReset(false); progressDlg->setAutoReset(false);
progressDlg->show(); progressDlg->show();
connect(progressDlg, TQT_SIGNAL(cancelClicked()), connect(progressDlg, TQ_SIGNAL(cancelClicked()),
&m_audioFileManager, TQT_SLOT(slotStopPreview())); &m_audioFileManager, TQ_SLOT(slotStopPreview()));
connect(&m_audioFileManager, TQT_SIGNAL(setProgress(int)), connect(&m_audioFileManager, TQ_SIGNAL(setProgress(int)),
progressDlg->progressBar(), TQT_SLOT(setValue(int))); progressDlg->progressBar(), TQ_SLOT(setValue(int)));
try { try {
m_audioFileManager.generatePreview(newAudioFile->getId()); 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); 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; 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_lirc = lirc;
m_rgGUIApp = rgGUIApp; m_rgGUIApp = rgGUIApp;
connect(m_lirc, TQT_SIGNAL(buttonPressed(char *)), connect(m_lirc, TQ_SIGNAL(buttonPressed(char *)),
this, TQT_SLOT(slotExecute(char *)) ); this, TQ_SLOT(slotExecute(char *)) );
connect(this, TQT_SIGNAL(play()), connect(this, TQ_SIGNAL(play()),
m_rgGUIApp, TQT_SLOT(slotPlay()) ); m_rgGUIApp, TQ_SLOT(slotPlay()) );
connect(this, TQT_SIGNAL(stop()), connect(this, TQ_SIGNAL(stop()),
m_rgGUIApp, TQT_SLOT(slotStop()) ); m_rgGUIApp, TQ_SLOT(slotStop()) );
connect(this, TQT_SIGNAL(record()), connect(this, TQ_SIGNAL(record()),
m_rgGUIApp, TQT_SLOT(slotRecord()) ); m_rgGUIApp, TQ_SLOT(slotRecord()) );
connect(this, TQT_SIGNAL(rewind()), connect(this, TQ_SIGNAL(rewind()),
m_rgGUIApp, TQT_SLOT(slotRewind()) ); m_rgGUIApp, TQ_SLOT(slotRewind()) );
connect(this, TQT_SIGNAL(rewindToBeginning()), connect(this, TQ_SIGNAL(rewindToBeginning()),
m_rgGUIApp, TQT_SLOT(slotRewindToBeginning()) ); m_rgGUIApp, TQ_SLOT(slotRewindToBeginning()) );
connect(this, TQT_SIGNAL(fastForward()), connect(this, TQ_SIGNAL(fastForward()),
m_rgGUIApp, TQT_SLOT(slotFastforward()) ); m_rgGUIApp, TQ_SLOT(slotFastforward()) );
connect(this, TQT_SIGNAL(fastForwardToEnd()), connect(this, TQ_SIGNAL(fastForwardToEnd()),
m_rgGUIApp, TQT_SLOT(slotFastForwardToEnd()) ); m_rgGUIApp, TQ_SLOT(slotFastForwardToEnd()) );
connect(this, TQT_SIGNAL(toggleRecord()), connect(this, TQ_SIGNAL(toggleRecord()),
m_rgGUIApp, TQT_SLOT(slotToggleRecord()) ); m_rgGUIApp, TQ_SLOT(slotToggleRecord()) );
connect(this, TQT_SIGNAL(trackDown()), connect(this, TQ_SIGNAL(trackDown()),
m_rgGUIApp, TQT_SLOT(slotTrackDown()) ); m_rgGUIApp, TQ_SLOT(slotTrackDown()) );
connect(this, TQT_SIGNAL(trackUp()), connect(this, TQ_SIGNAL(trackUp()),
m_rgGUIApp, TQT_SLOT(slotTrackUp()) ); m_rgGUIApp, TQ_SLOT(slotTrackUp()) );
connect(this, TQT_SIGNAL(trackMute()), connect(this, TQ_SIGNAL(trackMute()),
m_rgGUIApp, TQT_SLOT(slotToggleMutedCurrentTrack()) ); m_rgGUIApp, TQ_SLOT(slotToggleMutedCurrentTrack()) );
connect(this, TQT_SIGNAL(trackRecord()), connect(this, TQ_SIGNAL(trackRecord()),
m_rgGUIApp, TQT_SLOT(slotToggleRecordCurrentTrack()) ); m_rgGUIApp, TQ_SLOT(slotToggleRecordCurrentTrack()) );
} }
LircCommander::command LircCommander::commands[] = 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*/); m_rulerScale, showTrackLabels, unitsPerPixel, this /*hbox*/);
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegment(Segment*)), TQ_SIGNAL(editSegment(Segment*)),
TQT_SLOT(slotEditSegment(Segment*))); TQ_SLOT(slotEditSegment(Segment*)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentNotation(Segment*)), TQ_SIGNAL(editSegmentNotation(Segment*)),
TQT_SLOT(slotEditSegmentNotation(Segment*))); TQ_SLOT(slotEditSegmentNotation(Segment*)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentMatrix(Segment*)), TQ_SIGNAL(editSegmentMatrix(Segment*)),
TQT_SLOT(slotEditSegmentMatrix(Segment*))); TQ_SLOT(slotEditSegmentMatrix(Segment*)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentAudio(Segment*)), TQ_SIGNAL(editSegmentAudio(Segment*)),
TQT_SLOT(slotEditSegmentAudio(Segment*))); TQ_SLOT(slotEditSegmentAudio(Segment*)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(audioSegmentAutoSplit(Segment*)), TQ_SIGNAL(audioSegmentAutoSplit(Segment*)),
TQT_SLOT(slotSegmentAutoSplit(Segment*))); TQ_SLOT(slotSegmentAutoSplit(Segment*)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentEventList(Segment*)), TQ_SIGNAL(editSegmentEventList(Segment*)),
TQT_SLOT(slotEditSegmentEventList(Segment*))); TQ_SLOT(slotEditSegmentEventList(Segment*)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editRepeat(Segment*, timeT)), TQ_SIGNAL(editRepeat(Segment*, timeT)),
TQT_SLOT(slotEditRepeat(Segment*, timeT))); TQ_SLOT(slotEditRepeat(Segment*, timeT)));
connect(m_trackEditor->getSegmentCanvas(), connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(setPointerPosition(timeT)), TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT))); doc, TQ_SLOT(slotSetPointerPosition(timeT)));
connect(m_trackEditor, connect(m_trackEditor,
TQT_SIGNAL(droppedDocument(TQString)), TQ_SIGNAL(droppedDocument(TQString)),
parent, parent,
TQT_SLOT(slotOpenDroppedURL(TQString))); TQ_SLOT(slotOpenDroppedURL(TQString)));
connect(m_trackEditor, connect(m_trackEditor,
TQT_SIGNAL(droppedAudio(TQString)), TQ_SIGNAL(droppedAudio(TQString)),
this, this,
TQT_SLOT(slotDroppedAudio(TQString))); TQ_SLOT(slotDroppedAudio(TQString)));
connect(m_trackEditor, connect(m_trackEditor,
TQT_SIGNAL(droppedNewAudio(TQString)), TQ_SIGNAL(droppedNewAudio(TQString)),
this, this,
TQT_SLOT(slotDroppedNewAudio(TQString))); TQ_SLOT(slotDroppedNewAudio(TQString)));
connect(m_instrumentParameterBox, connect(m_instrumentParameterBox,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)), TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, this,
TQT_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString))); TQ_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
connect(m_instrumentParameterBox, connect(m_instrumentParameterBox,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)), TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
m_trackParameterBox, m_trackParameterBox,
TQT_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString))); TQ_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
connect(m_trackEditor->getTrackButtons(), connect(m_trackEditor->getTrackButtons(),
TQT_SIGNAL(nameChanged()), TQ_SIGNAL(nameChanged()),
m_trackParameterBox, m_trackParameterBox,
TQT_SLOT(slotSelectedTrackNameChanged())); TQ_SLOT(slotSelectedTrackNameChanged()));
connect(m_trackEditor->getTrackButtons(), connect(m_trackEditor->getTrackButtons(),
TQT_SIGNAL(instrumentSelected(int)), TQ_SIGNAL(instrumentSelected(int)),
m_trackParameterBox, m_trackParameterBox,
TQT_SLOT(slotUpdateControls(int))); TQ_SLOT(slotUpdateControls(int)));
connect(m_trackParameterBox, connect(m_trackParameterBox,
TQT_SIGNAL(instrumentSelected(TrackId, int)), TQ_SIGNAL(instrumentSelected(TrackId, int)),
m_trackEditor->getTrackButtons(), m_trackEditor->getTrackButtons(),
TQT_SLOT(slotTrackInstrumentSelection(TrackId, int))); TQ_SLOT(slotTrackInstrumentSelection(TrackId, int)));
connect(this, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)), connect(this, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
this, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *))); this, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
if (doc) { if (doc) {
/* signal no longer exists /* signal no longer exists
connect(doc, TQT_SIGNAL(recordingSegmentUpdated(Segment *, connect(doc, TQ_SIGNAL(recordingSegmentUpdated(Segment *,
timeT)), timeT)),
this, TQT_SLOT(slotUpdateRecordingSegment(Segment *, this, TQ_SLOT(slotUpdateRecordingSegment(Segment *,
timeT))); timeT)));
*/ */
TQObject::connect TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()), (getCommandHistory(), TQ_SIGNAL(commandExecuted()),
m_trackEditor->getSegmentCanvas(), TQT_SLOT(slotUpdateSegmentsDrawBuffer())); 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 // For tempo changes (ugh -- it'd be nicer to make a tempo change
// command that could interpret all this stuff from the dialog) // command that could interpret all this stuff from the dialog)
// //
connect(notationView, TQT_SIGNAL(changeTempo(timeT, connect(notationView, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction)), TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT, RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction))); TempoDialog::TempoDialogAction)));
connect(notationView, TQT_SIGNAL(windowActivated()), connect(notationView, TQ_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged())); this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(notationView, TQT_SIGNAL(selectTrack(int)), connect(notationView, TQ_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int))); this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(notationView, TQT_SIGNAL(play()), connect(notationView, TQ_SIGNAL(play()),
RosegardenGUIApp::self(), TQT_SLOT(slotPlay())); RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
connect(notationView, TQT_SIGNAL(stop()), connect(notationView, TQ_SIGNAL(stop()),
RosegardenGUIApp::self(), TQT_SLOT(slotStop())); RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
connect(notationView, TQT_SIGNAL(fastForwardPlayback()), connect(notationView, TQ_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastforward())); RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
connect(notationView, TQT_SIGNAL(rewindPlayback()), connect(notationView, TQ_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewind())); RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
connect(notationView, TQT_SIGNAL(fastForwardPlaybackToEnd()), connect(notationView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd())); RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
connect(notationView, TQT_SIGNAL(rewindPlaybackToBeginning()), connect(notationView, TQ_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning())); RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
connect(notationView, TQT_SIGNAL(panic()), connect(notationView, TQ_SIGNAL(panic()),
RosegardenGUIApp::self(), TQT_SLOT(slotPanic())); RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
connect(notationView, TQT_SIGNAL(saveFile()), connect(notationView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave())); RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(notationView, TQT_SIGNAL(jumpPlaybackTo(timeT)), connect(notationView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQT_SLOT(slotSetPointerPosition(timeT))); getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
connect(notationView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)), connect(notationView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)), connect(notationView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)), connect(notationView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)), connect(notationView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
/* hjj: WHAT DO DO WITH THIS ? /* hjj: WHAT DO DO WITH THIS ?
connect(notationView, TQT_SIGNAL(editMetadata(TQString)), connect(notationView, TQ_SIGNAL(editMetadata(TQString)),
this, TQT_SLOT(slotEditMetadata(TQString))); this, TQ_SLOT(slotEditMetadata(TQString)));
*/ */
connect(notationView, TQT_SIGNAL(editTriggerSegment(int)), connect(notationView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int))); this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(notationView, TQT_SIGNAL(staffLabelChanged(TrackId, TQString)), connect(notationView, TQ_SIGNAL(staffLabelChanged(TrackId, TQString)),
this, TQT_SLOT(slotChangeTrackLabel(TrackId, TQString))); this, TQ_SLOT(slotChangeTrackLabel(TrackId, TQString)));
connect(notationView, TQT_SIGNAL(toggleSolo(bool)), connect(notationView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool))); RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
connect(notationView, TQT_SIGNAL(editTimeSignature(timeT)), connect(notationView, TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT))); RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
SequenceManager *sM = getDocument()->getSequenceManager(); SequenceManager *sM = getDocument()->getSequenceManager();
connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)), connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
notationView, TQT_SLOT(slotInsertableNoteOnReceived(int, int))); notationView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)), connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
notationView, TQT_SLOT(slotInsertableNoteOffReceived(int, int))); notationView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(notationView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)), connect(notationView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *))); this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)), connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
notationView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *))); notationView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()), connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
notationView, TQT_SLOT(slotCompositionStateUpdate())); notationView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, TQT_SIGNAL(compositionStateUpdate()), connect(this, TQ_SIGNAL(compositionStateUpdate()),
notationView, TQT_SLOT(slotCompositionStateUpdate())); notationView, TQ_SLOT(slotCompositionStateUpdate()));
// Encourage the notation view window to open to the same // Encourage the notation view window to open to the same
// interval as the current segment view // 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 // For tempo changes (ugh -- it'd be nicer to make a tempo change
// command that could interpret all this stuff from the dialog) // command that could interpret all this stuff from the dialog)
// //
connect(matrixView, TQT_SIGNAL(changeTempo(timeT, connect(matrixView, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction)), TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT, RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction))); TempoDialog::TempoDialogAction)));
connect(matrixView, TQT_SIGNAL(windowActivated()), connect(matrixView, TQ_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged())); this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(matrixView, TQT_SIGNAL(selectTrack(int)), connect(matrixView, TQ_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int))); this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(matrixView, TQT_SIGNAL(play()), connect(matrixView, TQ_SIGNAL(play()),
RosegardenGUIApp::self(), TQT_SLOT(slotPlay())); RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
connect(matrixView, TQT_SIGNAL(stop()), connect(matrixView, TQ_SIGNAL(stop()),
RosegardenGUIApp::self(), TQT_SLOT(slotStop())); RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
connect(matrixView, TQT_SIGNAL(fastForwardPlayback()), connect(matrixView, TQ_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastforward())); RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
connect(matrixView, TQT_SIGNAL(rewindPlayback()), connect(matrixView, TQ_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewind())); RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
connect(matrixView, TQT_SIGNAL(fastForwardPlaybackToEnd()), connect(matrixView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd())); RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
connect(matrixView, TQT_SIGNAL(rewindPlaybackToBeginning()), connect(matrixView, TQ_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning())); RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
connect(matrixView, TQT_SIGNAL(panic()), connect(matrixView, TQ_SIGNAL(panic()),
RosegardenGUIApp::self(), TQT_SLOT(slotPanic())); RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
connect(matrixView, TQT_SIGNAL(saveFile()), connect(matrixView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave())); RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(matrixView, TQT_SIGNAL(jumpPlaybackTo(timeT)), connect(matrixView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQT_SLOT(slotSetPointerPosition(timeT))); getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
connect(matrixView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)), connect(matrixView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)), connect(matrixView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)), connect(matrixView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(editTriggerSegment(int)), connect(matrixView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int))); this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(matrixView, TQT_SIGNAL(toggleSolo(bool)), connect(matrixView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool))); RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
connect(matrixView, TQT_SIGNAL(editTimeSignature(timeT)), connect(matrixView, TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT))); RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
SequenceManager *sM = getDocument()->getSequenceManager(); SequenceManager *sM = getDocument()->getSequenceManager();
connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)), connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
matrixView, TQT_SLOT(slotInsertableNoteOnReceived(int, int))); matrixView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)), connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
matrixView, TQT_SLOT(slotInsertableNoteOffReceived(int, int))); matrixView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(matrixView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)), connect(matrixView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *))); this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)), connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
matrixView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *))); matrixView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()), connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
matrixView, TQT_SLOT(slotCompositionStateUpdate())); matrixView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, TQT_SIGNAL(compositionStateUpdate()), connect(this, TQ_SIGNAL(compositionStateUpdate()),
matrixView, TQT_SLOT(slotCompositionStateUpdate())); matrixView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, connect(this,
TQT_SIGNAL(instrumentLevelsChanged(InstrumentId, TQ_SIGNAL(instrumentLevelsChanged(InstrumentId,
const LevelInfo &)), const LevelInfo &)),
matrixView, matrixView,
TQT_SLOT(slotInstrumentLevelsChanged(InstrumentId, TQ_SLOT(slotInstrumentLevelsChanged(InstrumentId,
const LevelInfo &))); const LevelInfo &)));
// Encourage the matrix view window to open to the same // Encourage the matrix view window to open to the same
@ -1543,12 +1543,12 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
// Connect the progress dialog // Connect the progress dialog
// //
connect(&aFM, TQT_SIGNAL(setProgress(int)), connect(&aFM, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int))); progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&aFM, TQT_SIGNAL(setOperationName(TQString)), connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
&progressDlg, TQT_SLOT(slotSetOperationName(TQString))); &progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()), connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport())); &aFM, TQ_SLOT(slotStopImport()));
try { try {
audioFileId = aFM.importURL(kurl, sampleRate); audioFileId = aFM.importURL(kurl, sampleRate);
@ -1564,10 +1564,10 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
return ; return ;
} }
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()), disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport())); &aFM, TQ_SLOT(slotStopImport()));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()), connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview())); &aFM, TQ_SLOT(slotStopPreview()));
progressDlg.progressBar()->show(); progressDlg.progressBar()->show();
progressDlg.slotSetOperationName(i18n("Generating audio preview...")); progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
@ -1581,8 +1581,8 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
//return false; //return false;
} }
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()), disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview())); &aFM, TQ_SLOT(slotStopPreview()));
// add the file at the sequencer // add the file at the sequencer
emit addAudioFile(audioFileId); emit addAudioFile(audioFileId);
@ -1747,8 +1747,8 @@ RosegardenGUIView::slotUpdateRecordingSegment(Segment *segment,
/* signal no longer exists /* signal no longer exists
TQObject::connect TQObject::connect
(getDocument(), TQT_SIGNAL(recordingSegmentUpdated(Segment *, timeT)), (getDocument(), TQ_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
view, TQT_SLOT(slotUpdateRecordingSegment(Segment *, timeT))); view, TQ_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
*/ */
view->show(); view->show();
@ -1998,31 +1998,31 @@ RosegardenGUIView::createEventView(std::vector<Segment *> segmentsToEdit)
segmentsToEdit, segmentsToEdit,
this); this);
connect(eventView, TQT_SIGNAL(windowActivated()), connect(eventView, TQ_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged())); this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(eventView, TQT_SIGNAL(selectTrack(int)), connect(eventView, TQ_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int))); this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(eventView, TQT_SIGNAL(saveFile()), connect(eventView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave())); RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(eventView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)), connect(eventView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)), connect(eventView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)), connect(eventView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)), connect(eventView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>))); this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(editTriggerSegment(int)), connect(eventView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int))); this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(this, TQT_SIGNAL(compositionStateUpdate()), connect(this, TQ_SIGNAL(compositionStateUpdate()),
eventView, TQT_SLOT(slotCompositionStateUpdate())); eventView, TQ_SLOT(slotCompositionStateUpdate()));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()), connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
eventView, TQT_SLOT(slotCompositionStateUpdate())); eventView, TQ_SLOT(slotCompositionStateUpdate()));
connect(eventView, TQT_SIGNAL(toggleSolo(bool)), connect(eventView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool))); RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
// create keyboard accelerators on view // create keyboard accelerators on view
// //

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

@ -42,10 +42,10 @@ StartupTester::StartupTester() :
m_haveAudioFileImporter(false) m_haveAudioFileImporter(false)
{ {
TQHttp *http = new TQHttp(); TQHttp *http = new TQHttp();
connect(http, TQT_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)), connect(http, TQ_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
this, TQT_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &))); this, TQ_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
connect(http, TQT_SIGNAL(done(bool)), connect(http, TQ_SIGNAL(done(bool)),
this, TQT_SLOT(slotHttpDone(bool))); this, TQ_SLOT(slotHttpDone(bool)));
m_versionHttpFailed = false; m_versionHttpFailed = false;
http->setHost("www.rosegardenmusic.com"); http->setHost("www.rosegardenmusic.com");
http->get("/latest-version.txt"); http->get("/latest-version.txt");
@ -65,8 +65,8 @@ StartupTester::run()
TDEProcess *proc = new TDEProcess(); TDEProcess *proc = new TDEProcess();
m_stdoutBuffer = ""; m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)), TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int))); this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-audiofile-importer"; *proc << "rosegarden-audiofile-importer";
*proc << "--conftest"; *proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All); proc->start(TDEProcess::Block, TDEProcess::All);
@ -83,8 +83,8 @@ StartupTester::run()
proc = new TDEProcess; proc = new TDEProcess;
m_stdoutBuffer = ""; m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)), TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int))); this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-project-package"; *proc << "rosegarden-project-package";
*proc << "--conftest"; *proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All); proc->start(TDEProcess::Block, TDEProcess::All);
@ -103,8 +103,8 @@ StartupTester::run()
proc = new TDEProcess(); proc = new TDEProcess();
m_stdoutBuffer = ""; m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)), TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int))); this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-lilypondview"; *proc << "rosegarden-lilypondview";
*proc << "--conftest"; *proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All); 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 // Ensure quit on last window close
// Register main DCOP interface // 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()->registerAs(app.name(), false);
app.dcopClient()->setDefaultObject(ROSEGARDEN_GUI_IFACE_NAME); app.dcopClient()->setDefaultObject(ROSEGARDEN_GUI_IFACE_NAME);
@ -624,8 +624,8 @@ int main(int argc, char *argv[])
} }
TQObject::connect(&app, TQT_SIGNAL(aboutToSaveState()), TQObject::connect(&app, TQ_SIGNAL(aboutToSaveState()),
rosegardengui, TQT_SLOT(slotDeleteTransport())); rosegardengui, TQ_SLOT(slotDeleteTransport()));
// Now that we've started up, raise start logo // Now that we've started up, raise start logo
// //
@ -661,8 +661,8 @@ int main(int argc, char *argv[])
(*sfxLoadProcess) << sfxLoadPath << soundFontPath; (*sfxLoadProcess) << sfxLoadPath << soundFontPath;
RG_DEBUG << "Starting sfxload : " << sfxLoadPath << " " << soundFontPath << endl; RG_DEBUG << "Starting sfxload : " << sfxLoadPath << " " << soundFontPath << endl;
TQObject::connect(sfxLoadProcess, TQT_SIGNAL(processExited(TDEProcess*)), TQObject::connect(sfxLoadProcess, TQ_SIGNAL(processExited(TDEProcess*)),
&app, TQT_SLOT(sfxLoadExited(TDEProcess*))); &app, TQ_SLOT(sfxLoadExited(TDEProcess*)));
sfxLoadProcess->start(); sfxLoadProcess->start();
} else { } else {
@ -694,7 +694,7 @@ int main(int argc, char *argv[])
if (visibleFor < RealTime(2, 0)) { if (visibleFor < RealTime(2, 0)) {
int waitTime = visibleFor.sec * 1000 + visibleFor.msec(); int waitTime = visibleFor.sec * 1000 + visibleFor.msec();
TQTimer::singleShot(2500 - waitTime, startLogo, TQT_SLOT(close())); TQTimer::singleShot(2500 - waitTime, startLogo, TQ_SLOT(close()));
} else { } else {
startLogo->close(); startLogo->close();
} }

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

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

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

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

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

@ -73,20 +73,20 @@ ColourConfigurationPage::ColourConfigurationPage(RosegardenGUIDoc *doc,
frame); frame);
layout->addWidget(deleteColourButton, 1, 1, TQt::AlignHCenter); layout->addWidget(deleteColourButton, 1, 1, TQt::AlignHCenter);
connect(addColourButton, TQT_SIGNAL(clicked()), connect(addColourButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotAddNew())); this, TQ_SLOT(slotAddNew()));
connect(deleteColourButton, TQT_SIGNAL(clicked()), connect(deleteColourButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotDelete())); this, TQ_SLOT(slotDelete()));
connect(this, TQT_SIGNAL(docColoursChanged()), connect(this, TQ_SIGNAL(docColoursChanged()),
m_doc, TQT_SLOT(slotDocColoursChanged())); m_doc, TQ_SLOT(slotDocColoursChanged()));
connect(m_colourtable, TQT_SIGNAL(entryTextChanged(unsigned int, TQString)), connect(m_colourtable, TQ_SIGNAL(entryTextChanged(unsigned int, TQString)),
this, TQT_SLOT(slotTextChanged(unsigned int, TQString))); this, TQ_SLOT(slotTextChanged(unsigned int, TQString)));
connect(m_colourtable, TQT_SIGNAL(entryColourChanged(unsigned int, TQColor)), connect(m_colourtable, TQ_SIGNAL(entryColourChanged(unsigned int, TQColor)),
this, TQT_SLOT(slotColourChanged(unsigned int, TQColor))); this, TQ_SLOT(slotColourChanged(unsigned int, TQColor)));
addTab(frame, i18n("Color Map")); 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..."), TQPushButton *showStatusButton = new TQPushButton(i18n("Details..."),
frame); frame);
TQObject::connect(showStatusButton, TQT_SIGNAL(clicked()), TQObject::connect(showStatusButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotShowStatus())); this, TQ_SLOT(slotShowStatus()));
layout->addWidget(showStatusButton, row, 2, TQt::AlignRight); layout->addWidget(showStatusButton, row, 2, TQt::AlignRight);
++row; ++row;

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

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

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

@ -68,8 +68,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
layout->addWidget(m_fetchLatencyValues, 1, 3); layout->addWidget(m_fetchLatencyValues, 1, 3);
connect(m_fetchLatencyValues, TQT_SIGNAL(released()), connect(m_fetchLatencyValues, TQ_SIGNAL(released()),
TQT_SLOT(slotFetchLatencyValues())); TQ_SLOT(slotFetchLatencyValues()));
int jackPlaybackValue = (m_cfg->readLongNumEntry( int jackPlaybackValue = (m_cfg->readLongNumEntry(
"jackplaybacklatencyusec", 0) / 1000) + "jackplaybacklatencyusec", 0) / 1000) +
@ -83,8 +83,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
TQLabel *jackPlaybackLabel = new TQLabel(TQString("%1").arg(jackPlaybackValue), TQLabel *jackPlaybackLabel = new TQLabel(TQString("%1").arg(jackPlaybackValue),
frame); frame);
layout->addWidget(jackPlaybackLabel, 2, 2, TQt::AlignHCenter); layout->addWidget(jackPlaybackLabel, 2, 2, TQt::AlignHCenter);
connect(m_jackPlayback, TQT_SIGNAL(valueChanged(int)), connect(m_jackPlayback, TQ_SIGNAL(valueChanged(int)),
jackPlaybackLabel, TQT_SLOT(setNum(int))); jackPlaybackLabel, TQ_SLOT(setNum(int)));
m_jackPlayback->setMinValue(0); m_jackPlayback->setMinValue(0);
layout->addWidget(new TQLabel("0", frame), 3, 1, TQt::AlignRight); 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), TQLabel *jackRecordLabel = new TQLabel(TQString("%1").arg(jackRecordValue),
frame); frame);
layout->addWidget(jackRecordLabel, 4, 2, TQt::AlignHCenter); layout->addWidget(jackRecordLabel, 4, 2, TQt::AlignHCenter);
connect(m_jackRecord, TQT_SIGNAL(valueChanged(int)), connect(m_jackRecord, TQ_SIGNAL(valueChanged(int)),
jackRecordLabel, TQT_SLOT(setNum(int))); jackRecordLabel, TQ_SLOT(setNum(int)));
m_jackRecord->setMinValue(0); m_jackRecord->setMinValue(0);
layout->addWidget(new TQLabel("0", frame), 5, 1, TQt::AlignRight); 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); m_soundFontChoose->setEnabled(false);
} }
connect(m_sfxLoadEnabled, TQT_SIGNAL(toggled(bool)), connect(m_sfxLoadEnabled, TQ_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotSoundFontToggled(bool))); this, TQ_SLOT(slotSoundFontToggled(bool)));
connect(m_sfxLoadChoose, TQT_SIGNAL(clicked()), connect(m_sfxLoadChoose, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSfxLoadPathChoose())); this, TQ_SLOT(slotSfxLoadPathChoose()));
connect(m_soundFontChoose, TQT_SIGNAL(clicked()), connect(m_soundFontChoose, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSoundFontChoose())); this, TQ_SLOT(slotSoundFontChoose()));
layout->setRowStretch(row, 10); layout->setRowStretch(row, 10);
@ -363,7 +363,7 @@ MIDIConfigurationPage::apply()
int midiClock = m_midiSync->currentItem(); int midiClock = m_midiSync->currentItem();
m_cfg->writeEntry("midiclock", midiClock); 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? //!!! No, don't remove -- this controls SPP as well doesn't it?
// //
MappedEvent mEMIDIClock(MidiInstrumentBase, // InstrumentId 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); m_viewButton = new TQPushButton(i18n("View"), frame);
layout->addMultiCellWidget(m_font, row, row, 1, 2); layout->addMultiCellWidget(m_font, row, row, 1, 2);
layout->addWidget(m_viewButton, row, 3); layout->addWidget(m_viewButton, row, 3);
TQObject::connect(m_viewButton, TQT_SIGNAL(clicked()), TQObject::connect(m_viewButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotViewButtonPressed())); this, TQ_SLOT(slotViewButtonPressed()));
#else #else
layout->addMultiCellWidget(m_font, row, row, 1, 3); layout->addMultiCellWidget(m_font, row, row, 1, 3);
#endif #endif
m_font->setEditable(false); m_font->setEditable(false);
TQObject::connect(m_font, TQT_SIGNAL(activated(int)), TQObject::connect(m_font, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotFontComboChanged(int))); this, TQ_SLOT(slotFontComboChanged(int)));
++row; ++row;
TQFrame *subFrame = new TQFrame(frame); 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")); TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm"));
new TDEAction(i18n("&Add Audio File..."), "document-open", 0, this, 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, new TDEAction(i18n("&Unload Audio File"), "edit-delete", 0, this,
TQT_SLOT(slotRemove()), TQ_SLOT(slotRemove()),
actionCollection(), "remove_audio"); actionCollection(), "remove_audio");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm"));
new TDEAction(i18n("&Play Preview"), icon, 0, this, new TDEAction(i18n("&Play Preview"), icon, 0, this,
TQT_SLOT(slotPlayPreview()), TQ_SLOT(slotPlayPreview()),
actionCollection(), "preview_audio"); actionCollection(), "preview_audio");
/*!!! Not actually implemented -- this never worked right! /*!!! Not actually implemented -- this never worked right!
new TDEAction(i18n("Re&label"), 0, 0, this, new TDEAction(i18n("Re&label"), 0, 0, this,
TQT_SLOT(slotRename()), TQ_SLOT(slotRename()),
actionCollection(), "rename_audio"); actionCollection(), "rename_audio");
*/ */
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/insert_audio_into_track.xpm")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/insert_audio_into_track.xpm"));
new TDEAction(i18n("&Insert into Selected Audio Track"), new TDEAction(i18n("&Insert into Selected Audio Track"),
icon, 0, this, TQT_SLOT(slotInsert()), icon, 0, this, TQ_SLOT(slotInsert()),
actionCollection(), "insert_audio"); actionCollection(), "insert_audio");
new TDEAction(i18n("Unload &all Audio Files"), 0, 0, this, new TDEAction(i18n("Unload &all Audio Files"), 0, 0, this,
TQT_SLOT(slotRemoveAll()), TQ_SLOT(slotRemoveAll()),
actionCollection(), "remove_all_audio"); actionCollection(), "remove_all_audio");
new TDEAction(i18n("Unload all &Unused Audio Files"), 0, 0, this, new TDEAction(i18n("Unload all &Unused Audio Files"), 0, 0, this,
TQT_SLOT(slotRemoveAllUnused()), TQ_SLOT(slotRemoveAllUnused()),
actionCollection(), "remove_all_unused_audio"); actionCollection(), "remove_all_unused_audio");
new TDEAction(i18n("&Delete Unused Audio Files..."), 0, 0, this, new TDEAction(i18n("&Delete Unused Audio Files..."), 0, 0, this,
TQT_SLOT(slotDeleteUnused()), TQ_SLOT(slotDeleteUnused()),
actionCollection(), "delete_unused_audio"); actionCollection(), "delete_unused_audio");
new TDEAction(i18n("&Export Audio File..."), "fileexport", 0, this, new TDEAction(i18n("&Export Audio File..."), "fileexport", 0, this,
TQT_SLOT(slotExportAudio()), TQ_SLOT(slotExportAudio()),
actionCollection(), "export_audio"); actionCollection(), "export_audio");
/* /*
new TDEAction(i18n("Distribute Audio on &MIDI"), new TDEAction(i18n("Distribute Audio on &MIDI"),
0, 0, this, 0, 0, this,
TQT_SLOT(slotDistributeOnMidiSegment()), TQ_SLOT(slotDistributeOnMidiSegment()),
actionCollection(), actionCollection(),
"distribute_audio"); "distribute_audio");
*/ */
@ -200,11 +200,11 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
m_fileList->setShowToolTips(true); m_fileList->setShowToolTips(true);
// connect selection mechanism // connect selection mechanism
connect(m_fileList, TQT_SIGNAL(selectionChanged(TQListViewItem*)), connect(m_fileList, TQ_SIGNAL(selectionChanged(TQListViewItem*)),
TQT_SLOT(slotSelectionChanged(TQListViewItem*))); TQ_SLOT(slotSelectionChanged(TQListViewItem*)));
connect(m_fileList, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)), connect(m_fileList, TQ_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*))); TQ_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
// setup local accelerators // setup local accelerators
// //
@ -214,22 +214,22 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
// //
m_accelerators->connectItem(m_accelerators->insertItem(Key_Delete), m_accelerators->connectItem(m_accelerators->insertItem(Key_Delete),
this, this,
TQT_SLOT(slotRemove())); TQ_SLOT(slotRemove()));
slotPopulateFileList(); slotPopulateFileList();
// Connect command history for updates // Connect command history for updates
// //
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted(KCommand *)), connect(getCommandHistory(), TQ_SIGNAL(commandExecuted(KCommand *)),
this, TQT_SLOT(slotCommandExecuted(KCommand *))); this, TQ_SLOT(slotCommandExecuted(KCommand *)));
//setInitialSize(configDialogSize(AudioManagerDialogConfigGroup)); //setInitialSize(configDialogSize(AudioManagerDialogConfigGroup));
connect(m_playTimer, TQT_SIGNAL(timeout()), connect(m_playTimer, TQ_SIGNAL(timeout()),
this, TQT_SLOT(slotCancelPlayingAudio())); this, TQ_SLOT(slotCancelPlayingAudio()));
KStdAction::close(this, KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
createGUI("audiomanager.rc"); createGUI("audiomanager.rc");
@ -1091,12 +1091,12 @@ AudioManagerDialog::addFile(const KURL& kurl)
// Connect the progress dialog // Connect the progress dialog
// //
connect(&aFM, TQT_SIGNAL(setProgress(int)), connect(&aFM, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int))); progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&aFM, TQT_SIGNAL(setOperationName(TQString)), connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
&progressDlg, TQT_SLOT(slotSetOperationName(TQString))); &progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()), connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport())); &aFM, TQ_SLOT(slotStopImport()));
try { try {
id = aFM.importURL(kurl, m_sampleRate); id = aFM.importURL(kurl, m_sampleRate);
@ -1112,10 +1112,10 @@ AudioManagerDialog::addFile(const KURL& kurl)
return false; return false;
} }
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()), disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport())); &aFM, TQ_SLOT(slotStopImport()));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()), connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview())); &aFM, TQ_SLOT(slotStopPreview()));
progressDlg.progressBar()->show(); progressDlg.progressBar()->show();
progressDlg.slotSetOperationName(i18n("Generating audio preview...")); progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
@ -1129,8 +1129,8 @@ AudioManagerDialog::addFile(const KURL& kurl)
KMessageBox::information(this, message); KMessageBox::information(this, message);
} }
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()), disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview())); &aFM, TQ_SLOT(slotStopPreview()));
slotPopulateFileList(); slotPopulateFileList();

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

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

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

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

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

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

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

@ -78,10 +78,10 @@ ConfigureDialog::ConfigureDialog(RosegardenGUIDoc *doc,
page->setPageIndex(pageIndex(pageWidget)); page->setPageIndex(pageIndex(pageWidget));
m_configurationPages.push_back(page); m_configurationPages.push_back(page);
connect(page, TQT_SIGNAL(updateAutoSaveInterval(unsigned int)), connect(page, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)),
this, TQT_SIGNAL(updateAutoSaveInterval(unsigned int))); this, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)));
connect(page, TQT_SIGNAL(updateSidebarStyle(unsigned int)), connect(page, TQ_SIGNAL(updateSidebarStyle(unsigned int)),
this, TQT_SIGNAL(updateSidebarStyle(unsigned int))); this, TQ_SIGNAL(updateSidebarStyle(unsigned int)));
pageWidget = addPage(MIDIConfigurationPage::iconLabel(), pageWidget = addPage(MIDIConfigurationPage::iconLabel(),
MIDIConfigurationPage::title(), 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_progressBar, 0, AlignCenter);
layout->addWidget(m_stopButton, 0, AlignRight); 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 // 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 TQSpinBox *absoluteTime = new TQSpinBox
(INT_MIN, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid); (INT_MIN, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid);
absoluteTime->setValue(event.getAbsoluteTime()); absoluteTime->setValue(event.getAbsoluteTime());
TQObject::connect(absoluteTime, TQT_SIGNAL(valueChanged(int)), TQObject::connect(absoluteTime, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotAbsoluteTimeChanged(int))); this, TQ_SLOT(slotAbsoluteTimeChanged(int)));
slotAbsoluteTimeChanged(event.getAbsoluteTime()); slotAbsoluteTimeChanged(event.getAbsoluteTime());
new TQLabel(i18n("Duration: "), intrinsicGrid); new TQLabel(i18n("Duration: "), intrinsicGrid);
@ -105,8 +105,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *duration = new TQSpinBox TQSpinBox *duration = new TQSpinBox
(0, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid); (0, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid);
duration->setValue(event.getDuration()); duration->setValue(event.getDuration());
TQObject::connect(duration, TQT_SIGNAL(valueChanged(int)), TQObject::connect(duration, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotDurationChanged(int))); this, TQ_SLOT(slotDurationChanged(int)));
slotDurationChanged(event.getDuration()); slotDurationChanged(event.getDuration());
new TQLabel(i18n("Sub-ordering: "), intrinsicGrid); new TQLabel(i18n("Sub-ordering: "), intrinsicGrid);
@ -115,8 +115,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *subOrdering = new TQSpinBox( -100, 100, 1, intrinsicGrid); TQSpinBox *subOrdering = new TQSpinBox( -100, 100, 1, intrinsicGrid);
subOrdering->setValue(event.getSubOrdering()); subOrdering->setValue(event.getSubOrdering());
TQObject::connect(subOrdering, TQT_SIGNAL(valueChanged(int)), TQObject::connect(subOrdering, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSubOrderingChanged(int))); this, TQ_SLOT(slotSubOrderingChanged(int)));
slotSubOrderingChanged(event.getSubOrdering()); slotSubOrderingChanged(event.getSubOrdering());
TQGroupBox *persistentBox = new TQGroupBox TQGroupBox *persistentBox = new TQGroupBox
@ -184,8 +184,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
button->setFixedSize(TQSize(24, 24)); button->setFixedSize(TQSize(24, 24));
TQToolTip::add TQToolTip::add
(button, i18n("Make persistent")); (button, i18n("Make persistent"));
TQObject::connect(button, TQT_SIGNAL(clicked()), TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotPropertyMadePersistent())); this, TQ_SLOT(slotPropertyMadePersistent()));
} }
} }
} }
@ -213,8 +213,8 @@ EventEditDialog::addPersistentProperty(const PropertyName &name)
TQSpinBox *spinBox = new TQSpinBox TQSpinBox *spinBox = new TQSpinBox
(min, max, 1, m_persistentGrid, strtoqstr(name).ascii()); (min, max, 1, m_persistentGrid, strtoqstr(name).ascii());
spinBox->setValue(m_originalEvent.get<Int>(name)); spinBox->setValue(m_originalEvent.get<Int>(name));
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)), TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotIntPropertyChanged(int))); this, TQ_SLOT(slotIntPropertyChanged(int)));
spinBox->show(); spinBox->show();
break; break;
} }
@ -228,8 +228,8 @@ case UInt: {
TQSpinBox *spinBox = new TQSpinBox TQSpinBox *spinBox = new TQSpinBox
(min, max, 1, m_persistentGrid, strtoqstr(name).ascii()); (min, max, 1, m_persistentGrid, strtoqstr(name).ascii());
spinBox->setValue(m_originalEvent.get<UInt>(name)); spinBox->setValue(m_originalEvent.get<UInt>(name));
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)), TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotIntPropertyChanged(int))); this, TQ_SLOT(slotIntPropertyChanged(int)));
spinBox->show(); spinBox->show();
break; break;
} }
@ -245,8 +245,8 @@ case UInt: {
hbox, TQString(strtoqstr(name) + "%sec").ascii()); hbox, TQString(strtoqstr(name) + "%sec").ascii());
spinBox->setValue(realTime.sec); spinBox->setValue(realTime.sec);
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)), TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotRealTimePropertyChanged(int))); this, TQ_SLOT(slotRealTimePropertyChanged(int)));
// nseconds // nseconds
// //
@ -255,8 +255,8 @@ case UInt: {
hbox, TQString(strtoqstr(name) + "%nsec").ascii()); hbox, TQString(strtoqstr(name) + "%nsec").ascii());
spinBox->setValue(realTime.nsec); spinBox->setValue(realTime.nsec);
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)), TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotRealTimePropertyChanged(int))); this, TQ_SLOT(slotRealTimePropertyChanged(int)));
spinBox->show(); spinBox->show();
break; break;
} }
@ -265,8 +265,8 @@ case UInt: {
TQCheckBox *checkBox = new TQCheckBox TQCheckBox *checkBox = new TQCheckBox
("", m_persistentGrid, strtoqstr(name).ascii()); ("", m_persistentGrid, strtoqstr(name).ascii());
checkBox->setChecked(m_originalEvent.get<Bool>(name)); checkBox->setChecked(m_originalEvent.get<Bool>(name));
TQObject::connect(checkBox, TQT_SIGNAL(activated()), TQObject::connect(checkBox, TQ_SIGNAL(activated()),
this, TQT_SLOT(slotBoolPropertyChanged())); this, TQ_SLOT(slotBoolPropertyChanged()));
checkBox->show(); checkBox->show();
break; break;
} }
@ -276,8 +276,8 @@ case UInt: {
(strtoqstr(m_originalEvent.get<String>(name)), (strtoqstr(m_originalEvent.get<String>(name)),
m_persistentGrid, m_persistentGrid,
strtoqstr(name).ascii()); strtoqstr(name).ascii());
TQObject::connect(lineEdit, TQT_SIGNAL(textChanged(const TQString &)), TQObject::connect(lineEdit, TQ_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotStringPropertyChanged(const TQString &))); this, TQ_SLOT(slotStringPropertyChanged(const TQString &)));
lineEdit->show(); lineEdit->show();
break; break;
} }
@ -288,8 +288,8 @@ case UInt: {
button->setFixedSize(TQSize(24, 24)); button->setFixedSize(TQSize(24, 24));
TQToolTip::add TQToolTip::add
(button, i18n("Delete this property")); (button, i18n("Delete this property"));
TQObject::connect(button, TQT_SIGNAL(clicked()), TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotPropertyDeleted())); this, TQ_SLOT(slotPropertyDeleted()));
button->show(); button->show();
} }

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

@ -128,8 +128,8 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup); cfg->setGroup(EventFilterDialogConfigGroup);
m_pitchFromSpinBox->setValue(cfg->readUnsignedNumEntry("pitchfrom", 0)); m_pitchFromSpinBox->setValue(cfg->readUnsignedNumEntry("pitchfrom", 0));
noteFrameLayout->addWidget(m_pitchFromSpinBox, 1, 2); noteFrameLayout->addWidget(m_pitchFromSpinBox, 1, 2);
connect(m_pitchFromSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_pitchFromSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchFromChanged(int))); TQ_SLOT(slotPitchFromChanged(int)));
m_pitchFromChooserButton = new TQPushButton(i18n("edit"), noteFrame); m_pitchFromChooserButton = new TQPushButton(i18n("edit"), noteFrame);
m_pitchFromChooserButton->setSizePolicy(TQSizePolicy((TQSizePolicy::SizeType)0, m_pitchFromChooserButton->setSizePolicy(TQSizePolicy((TQSizePolicy::SizeType)0,
@ -138,8 +138,8 @@ EventFilterDialog::initDialog()
TQToolTip::add TQToolTip::add
(m_pitchFromChooserButton, i18n("choose a pitch using a staff")); (m_pitchFromChooserButton, i18n("choose a pitch using a staff"));
noteFrameLayout->addWidget(m_pitchFromChooserButton, 1, 3); noteFrameLayout->addWidget(m_pitchFromChooserButton, 1, 3);
connect(m_pitchFromChooserButton, TQT_SIGNAL(clicked()), connect(m_pitchFromChooserButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotPitchFromChooser())); TQ_SLOT(slotPitchFromChooser()));
// Pitch To // Pitch To
m_pitchToSpinBox = new TQSpinBox(noteFrame); m_pitchToSpinBox = new TQSpinBox(noteFrame);
@ -147,15 +147,15 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup); cfg->setGroup(EventFilterDialogConfigGroup);
m_pitchToSpinBox->setValue(cfg->readUnsignedNumEntry("pitchto", 127)); m_pitchToSpinBox->setValue(cfg->readUnsignedNumEntry("pitchto", 127));
noteFrameLayout->addWidget(m_pitchToSpinBox, 1, 4); noteFrameLayout->addWidget(m_pitchToSpinBox, 1, 4);
connect(m_pitchToSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_pitchToSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchToChanged(int))); TQ_SLOT(slotPitchToChanged(int)));
m_pitchToChooserButton = new TQPushButton(i18n("edit"), noteFrame); m_pitchToChooserButton = new TQPushButton(i18n("edit"), noteFrame);
TQToolTip::add TQToolTip::add
(m_pitchToChooserButton, i18n("choose a pitch using a staff")); (m_pitchToChooserButton, i18n("choose a pitch using a staff"));
noteFrameLayout->addWidget(m_pitchToChooserButton, 1, 5); noteFrameLayout->addWidget(m_pitchToChooserButton, 1, 5);
connect(m_pitchToChooserButton, TQT_SIGNAL(clicked()), connect(m_pitchToChooserButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotPitchToChooser())); TQ_SLOT(slotPitchToChooser()));
// Velocity From/To // Velocity From/To
m_velocityFromSpinBox = new TQSpinBox(noteFrame); m_velocityFromSpinBox = new TQSpinBox(noteFrame);
@ -163,30 +163,30 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup); cfg->setGroup(EventFilterDialogConfigGroup);
m_velocityFromSpinBox->setValue(cfg->readUnsignedNumEntry("velocityfrom", 0)); m_velocityFromSpinBox->setValue(cfg->readUnsignedNumEntry("velocityfrom", 0));
noteFrameLayout->addWidget(m_velocityFromSpinBox, 2, 2); noteFrameLayout->addWidget(m_velocityFromSpinBox, 2, 2);
connect(m_velocityFromSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_velocityFromSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityFromChanged(int))); TQ_SLOT(slotVelocityFromChanged(int)));
m_velocityToSpinBox = new TQSpinBox(noteFrame); m_velocityToSpinBox = new TQSpinBox(noteFrame);
m_velocityToSpinBox->setMaxValue(127); m_velocityToSpinBox->setMaxValue(127);
cfg->setGroup(EventFilterDialogConfigGroup); cfg->setGroup(EventFilterDialogConfigGroup);
m_velocityToSpinBox->setValue(cfg->readUnsignedNumEntry("velocityto", 127)); m_velocityToSpinBox->setValue(cfg->readUnsignedNumEntry("velocityto", 127));
noteFrameLayout->addWidget( m_velocityToSpinBox, 2, 4 ); noteFrameLayout->addWidget( m_velocityToSpinBox, 2, 4 );
connect(m_velocityToSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_velocityToSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityToChanged(int))); TQ_SLOT(slotVelocityToChanged(int)));
// Duration From/To // Duration From/To
m_noteDurationFromComboBox = new TQComboBox(0, noteFrame); m_noteDurationFromComboBox = new TQComboBox(0, noteFrame);
m_noteDurationFromComboBox->insertItem(i18n("longest")); m_noteDurationFromComboBox->insertItem(i18n("longest"));
noteFrameLayout->addWidget(m_noteDurationFromComboBox, 3, 2); noteFrameLayout->addWidget(m_noteDurationFromComboBox, 3, 2);
connect(m_noteDurationFromComboBox, TQT_SIGNAL(activated(int)), connect(m_noteDurationFromComboBox, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotDurationFromChanged(int))); TQ_SLOT(slotDurationFromChanged(int)));
m_noteDurationToComboBox = new TQComboBox(0, noteFrame); m_noteDurationToComboBox = new TQComboBox(0, noteFrame);
m_noteDurationToComboBox->insertItem(i18n("longest")); m_noteDurationToComboBox->insertItem(i18n("longest"));
noteFrameLayout->addWidget(m_noteDurationToComboBox, 3, 4); noteFrameLayout->addWidget(m_noteDurationToComboBox, 3, 4);
connect(m_noteDurationToComboBox, TQT_SIGNAL(activated(int)), connect(m_noteDurationToComboBox, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotDurationToChanged(int))); TQ_SLOT(slotDurationToChanged(int)));
populateDurationCombos(); populateDurationCombos();
@ -207,8 +207,8 @@ EventFilterDialog::initDialog()
(m_buttonNone, i18n("Exclude entire range of values")); (m_buttonNone, i18n("Exclude entire range of values"));
buttonLayout->addWidget( m_buttonNone, 0, 1 ); buttonLayout->addWidget( m_buttonNone, 0, 1 );
connect(m_buttonAll, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotToggleAll())); connect(m_buttonAll, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotToggleAll()));
connect(m_buttonNone, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotToggleNone())); 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)); text = i18n("Ringing - set %1 alternating from max to min with both dying to zero").arg(strtoqstr(property));
m_patternCombo->insertItem(text); m_patternCombo->insertItem(text);
connect(m_patternCombo, TQT_SIGNAL(activated(int)), connect(m_patternCombo, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotPatternSelected(int))); this, TQ_SLOT(slotPatternSelected(int)));
TQHBox *value1Box = new TQHBox(vBox); TQHBox *value1Box = new TQHBox(vBox);
m_value1Label = new TQLabel(i18n("Value"), value1Box); 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; ++i;
} }
connect(codecs, TQT_SIGNAL(activated(int)), connect(codecs, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotCodecSelected(int))); this, TQ_SLOT(slotCodecSelected(int)));
new TQLabel(i18n("\nExample text from file:"), vbox); new TQLabel(i18n("\nExample text from file:"), vbox);
m_example = new TQLabel("", 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)); (config->readBoolEntry("interpretarticulate", true));
connect(m_allInterpretations, connect(m_allInterpretations,
TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAllBoxChanged())); TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAllBoxChanged()));
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; m_transposeSegmentBack = NULL;
} }
connect(m_referencenote, TQT_SIGNAL(noteChanged(int,int,int)), connect(m_referencenote, TQ_SIGNAL(noteChanged(int,int,int)),
this, TQT_SLOT(slotSetReferenceNote(int,int,int))); this, TQ_SLOT(slotSetReferenceNote(int,int,int)));
connect(m_targetnote, TQT_SIGNAL(noteChanged(int,int,int)), connect(m_targetnote, TQ_SIGNAL(noteChanged(int,int,int)),
this, TQT_SLOT(slotSetTargetNote(int,int,int))); this, TQ_SLOT(slotSetTargetNote(int,int,int)));
} }
// number of octaves the notes are apart // 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(); conversionFrame->hide();
} }
TQObject::connect(keyUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotKeyUp())); TQObject::connect(keyUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotKeyUp()));
TQObject::connect(keyDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotKeyDown())); TQObject::connect(keyDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotKeyDown()));
TQObject::connect(m_keyCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_keyCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotKeyNameChanged(const TQString &))); this, TQ_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_keyCombo, TQT_SIGNAL(textChanged(const TQString &)), TQObject::connect(m_keyCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotKeyNameChanged(const TQString &))); this, TQ_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_majorMinorCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_majorMinorCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotMajorMinorChanged(const TQString &))); this, TQ_SLOT(slotMajorMinorChanged(const TQString &)));
} }
KeySignatureDialog::ConversionType KeySignatureDialog::ConversionType

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

@ -64,9 +64,9 @@ LyricEditDialog::LyricEditDialog(TQWidget *parent,
// new TQLabel(i18n("Verse:"), hbox); // new TQLabel(i18n("Verse:"), hbox);
m_verseNumber = new KComboBox(hbox); m_verseNumber = new KComboBox(hbox);
m_verseNumber->setEditable(false); 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); 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); TQFrame *f = new TQFrame(hbox);
hbox->setStretchFactor(f, 10); 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); layout->addWidget(new TQLabel(i18n("Instrument"), frame), 1, 0);
m_metronomeInstrument = new KComboBox(frame); m_metronomeInstrument = new KComboBox(frame);
connect(m_metronomeInstrument, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotSetModified())); connect(m_metronomeInstrument, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotSetModified()));
connect(m_metronomeInstrument, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotInstrumentChanged(int))); connect(m_metronomeInstrument, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotInstrumentChanged(int)));
layout->addWidget(m_metronomeInstrument, 1, 1); layout->addWidget(m_metronomeInstrument, 1, 1);
TQGroupBox *beatBox = new TQGroupBox TQGroupBox *beatBox = new TQGroupBox
@ -124,58 +124,58 @@ ManageMetronomeDialog::ManageMetronomeDialog(TQWidget *parent,
m_metronomeResolution->insertItem(i18n("Bars only")); m_metronomeResolution->insertItem(i18n("Bars only"));
m_metronomeResolution->insertItem(i18n("Bars and beats")); m_metronomeResolution->insertItem(i18n("Bars and beats"));
m_metronomeResolution->insertItem(i18n("Bars, beats, and divisions")); 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(m_metronomeResolution, 0, 1);
layout->addWidget(new TQLabel(i18n("Bar velocity"), frame), 1, 0); layout->addWidget(new TQLabel(i18n("Bar velocity"), frame), 1, 0);
m_metronomeBarVely = new TQSpinBox(frame); m_metronomeBarVely = new TQSpinBox(frame);
m_metronomeBarVely->setMinValue(0); m_metronomeBarVely->setMinValue(0);
m_metronomeBarVely->setMaxValue(127); 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(m_metronomeBarVely, 1, 1);
layout->addWidget(new TQLabel(i18n("Beat velocity"), frame), 2, 0); layout->addWidget(new TQLabel(i18n("Beat velocity"), frame), 2, 0);
m_metronomeBeatVely = new TQSpinBox(frame); m_metronomeBeatVely = new TQSpinBox(frame);
m_metronomeBeatVely->setMinValue(0); m_metronomeBeatVely->setMinValue(0);
m_metronomeBeatVely->setMaxValue(127); 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(m_metronomeBeatVely, 2, 1);
layout->addWidget(new TQLabel(i18n("Sub-beat velocity"), frame), 3, 0); layout->addWidget(new TQLabel(i18n("Sub-beat velocity"), frame), 3, 0);
m_metronomeSubBeatVely = new TQSpinBox(frame); m_metronomeSubBeatVely = new TQSpinBox(frame);
m_metronomeSubBeatVely->setMinValue(0); m_metronomeSubBeatVely->setMinValue(0);
m_metronomeSubBeatVely->setMaxValue(127); 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); layout->addWidget(m_metronomeSubBeatVely, 3, 1);
vbox = new TQVBox(hbox); vbox = new TQVBox(hbox);
m_metronomePitch = new PitchChooser(i18n("Pitch"), vbox, 60); m_metronomePitch = new PitchChooser(i18n("Pitch"), vbox, 60);
connect(m_metronomePitch, TQT_SIGNAL(pitchChanged(int)), this, TQT_SLOT(slotPitchChanged(int))); connect(m_metronomePitch, TQ_SIGNAL(pitchChanged(int)), this, TQ_SLOT(slotPitchChanged(int)));
connect(m_metronomePitch, TQT_SIGNAL(preview(int)), this, TQT_SLOT(slotPreviewPitch(int))); connect(m_metronomePitch, TQ_SIGNAL(preview(int)), this, TQ_SLOT(slotPreviewPitch(int)));
m_metronomePitchSelector = new KComboBox(m_metronomePitch); m_metronomePitchSelector = new KComboBox(m_metronomePitch);
m_metronomePitchSelector->insertItem(i18n("for Bar")); m_metronomePitchSelector->insertItem(i18n("for Bar"));
m_metronomePitchSelector->insertItem(i18n("for Beat")); m_metronomePitchSelector->insertItem(i18n("for Beat"));
m_metronomePitchSelector->insertItem(i18n("for Sub-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 TQGroupBox *enableBox = new TQGroupBox
(1, TQt::Horizontal, i18n("Metronome Activated"), vbox); (1, TQt::Horizontal, i18n("Metronome Activated"), vbox);
m_playEnabled = new TQCheckBox(i18n("Playing"), enableBox); m_playEnabled = new TQCheckBox(i18n("Playing"), enableBox);
m_recordEnabled = new TQCheckBox(i18n("Recording"), enableBox); m_recordEnabled = new TQCheckBox(i18n("Recording"), enableBox);
connect(m_playEnabled, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetModified())); connect(m_playEnabled, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetModified()));
connect(m_recordEnabled, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetModified())); connect(m_recordEnabled, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetModified()));
// populate the dialog // populate the dialog
populate(m_metronomeDevice->currentItem()); populate(m_metronomeDevice->currentItem());
// connect up the device list // connect up the device list
connect(m_metronomeDevice, TQT_SIGNAL(activated(int)), connect(m_metronomeDevice, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(populate(int))); this, TQ_SLOT(populate(int)));
// connect up the device list // connect up the device list
connect(m_metronomeDevice, TQT_SIGNAL(activated(int)), connect(m_metronomeDevice, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetModified())); this, TQ_SLOT(slotSetModified()));
setModified(false); 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); TQRadioButton *button = new TQRadioButton(i->second, pasteTypeGroup);
button->setChecked(m_defaultType == i->first); button->setChecked(m_defaultType == i->first);
TQObject::connect(button, TQT_SIGNAL(clicked()), TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotPasteTypeChanged())); this, TQ_SLOT(slotPasteTypeChanged()));
m_pasteTypeButtons.push_back(button); 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); m_pitchChooser = new PitchChooser(title, vbox, defaultPitch);
setButtonText(User1, i18n("Reset")); setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()), connect(this, TQ_SIGNAL(user1Clicked()),
m_pitchChooser, TQT_SLOT(slotResetToDefault())); m_pitchChooser, TQ_SLOT(slotResetToDefault()));
} }
int int

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

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

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

@ -101,8 +101,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
// Connect up the combos // Connect up the combos
// //
connect(m_typeCombo, TQT_SIGNAL(activated(int)), connect(m_typeCombo, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotEventTypeChanged(int))); TQ_SLOT(slotEventTypeChanged(int)));
} else { } else {
@ -119,10 +119,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_timeSpinBox, 1, 1); layout->addWidget(m_timeSpinBox, 1, 1);
layout->addWidget(m_timeEditButton, 1, 2); layout->addWidget(m_timeEditButton, 1, 2);
connect(m_timeSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_timeSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotAbsoluteTimeChanged(int))); TQ_SLOT(slotAbsoluteTimeChanged(int)));
connect(m_timeEditButton, TQT_SIGNAL(released()), connect(m_timeEditButton, TQ_SIGNAL(released()),
TQT_SLOT(slotEditAbsoluteTime())); TQ_SLOT(slotEditAbsoluteTime()));
m_durationLabel = new TQLabel(i18n("Duration:"), frame); m_durationLabel = new TQLabel(i18n("Duration:"), frame);
layout->addWidget(m_durationLabel, 2, 0); layout->addWidget(m_durationLabel, 2, 0);
@ -131,10 +131,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_durationSpinBox, 2, 1); layout->addWidget(m_durationSpinBox, 2, 1);
layout->addWidget(m_durationEditButton, 2, 2); layout->addWidget(m_durationEditButton, 2, 2);
connect(m_durationSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_durationSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotDurationChanged(int))); TQ_SLOT(slotDurationChanged(int)));
connect(m_durationEditButton, TQT_SIGNAL(released()), connect(m_durationEditButton, TQ_SIGNAL(released()),
TQT_SLOT(slotEditDuration())); TQ_SLOT(slotEditDuration()));
m_pitchLabel = new TQLabel(i18n("Pitch:"), frame); m_pitchLabel = new TQLabel(i18n("Pitch:"), frame);
layout->addWidget(m_pitchLabel, 3, 0); layout->addWidget(m_pitchLabel, 3, 0);
@ -143,10 +143,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_pitchSpinBox, 3, 1); layout->addWidget(m_pitchSpinBox, 3, 1);
layout->addWidget(m_pitchEditButton, 3, 2); layout->addWidget(m_pitchEditButton, 3, 2);
connect(m_pitchSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_pitchSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchChanged(int))); TQ_SLOT(slotPitchChanged(int)));
connect(m_pitchEditButton, TQT_SIGNAL(released()), connect(m_pitchEditButton, TQ_SIGNAL(released()),
TQT_SLOT(slotEditPitch())); TQ_SLOT(slotEditPitch()));
m_pitchSpinBox->setMinValue(MidiMinValue); m_pitchSpinBox->setMinValue(MidiMinValue);
m_pitchSpinBox->setMaxValue(MidiMaxValue); m_pitchSpinBox->setMaxValue(MidiMaxValue);
@ -163,8 +163,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
m_velocitySpinBox = new TQSpinBox(frame); m_velocitySpinBox = new TQSpinBox(frame);
layout->addWidget(m_velocitySpinBox, 5, 1); layout->addWidget(m_velocitySpinBox, 5, 1);
connect(m_velocitySpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_velocitySpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityChanged(int))); TQ_SLOT(slotVelocityChanged(int)));
m_velocitySpinBox->setMinValue(MidiMinValue); m_velocitySpinBox->setMinValue(MidiMinValue);
m_velocitySpinBox->setMaxValue(MidiMaxValue); m_velocitySpinBox->setMaxValue(MidiMaxValue);
@ -179,12 +179,12 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
m_sysexSaveButton = new TQPushButton(i18n("Save data"), frame); m_sysexSaveButton = new TQPushButton(i18n("Save data"), frame);
layout->addWidget(m_sysexSaveButton, 4, 2); layout->addWidget(m_sysexSaveButton, 4, 2);
connect(m_metaEdit, TQT_SIGNAL(textChanged(const TQString &)), connect(m_metaEdit, TQ_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(slotMetaChanged(const TQString &))); TQ_SLOT(slotMetaChanged(const TQString &)));
connect(m_sysexLoadButton, TQT_SIGNAL(released()), connect(m_sysexLoadButton, TQ_SIGNAL(released()),
TQT_SLOT(slotSysexLoad())); TQ_SLOT(slotSysexLoad()));
connect(m_sysexSaveButton, TQT_SIGNAL(released()), connect(m_sysexSaveButton, TQ_SIGNAL(released()),
TQT_SLOT(slotSysexSave())); TQ_SLOT(slotSysexSave()));
m_notationGroupBox = new TQGroupBox m_notationGroupBox = new TQGroupBox
(1, TQt::Horizontal, i18n("Notation Properties"), vbox); (1, TQt::Horizontal, i18n("Notation Properties"), vbox);
@ -197,8 +197,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addMultiCellWidget(m_lockNotationValues, 0, 0, 0, 2); layout->addMultiCellWidget(m_lockNotationValues, 0, 0, 0, 2);
m_lockNotationValues->setChecked(true); m_lockNotationValues->setChecked(true);
connect(m_lockNotationValues, TQT_SIGNAL(released()), connect(m_lockNotationValues, TQ_SIGNAL(released()),
TQT_SLOT(slotLockNotationChanged())); TQ_SLOT(slotLockNotationChanged()));
m_notationTimeLabel = new TQLabel(i18n("Notation time:"), frame); m_notationTimeLabel = new TQLabel(i18n("Notation time:"), frame);
layout->addWidget(m_notationTimeLabel, 1, 0); layout->addWidget(m_notationTimeLabel, 1, 0);
@ -207,10 +207,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_notationTimeSpinBox, 1, 1); layout->addWidget(m_notationTimeSpinBox, 1, 1);
layout->addWidget(m_notationTimeEditButton, 1, 2); layout->addWidget(m_notationTimeEditButton, 1, 2);
connect(m_notationTimeSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_notationTimeSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotNotationAbsoluteTimeChanged(int))); TQ_SLOT(slotNotationAbsoluteTimeChanged(int)));
connect(m_notationTimeEditButton, TQT_SIGNAL(released()), connect(m_notationTimeEditButton, TQ_SIGNAL(released()),
TQT_SLOT(slotEditNotationAbsoluteTime())); TQ_SLOT(slotEditNotationAbsoluteTime()));
m_notationDurationLabel = new TQLabel(i18n("Notation duration:"), frame); m_notationDurationLabel = new TQLabel(i18n("Notation duration:"), frame);
layout->addWidget(m_notationDurationLabel, 2, 0); layout->addWidget(m_notationDurationLabel, 2, 0);
@ -219,10 +219,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_notationDurationSpinBox, 2, 1); layout->addWidget(m_notationDurationSpinBox, 2, 1);
layout->addWidget(m_notationDurationEditButton, 2, 2); layout->addWidget(m_notationDurationEditButton, 2, 2);
connect(m_notationDurationSpinBox, TQT_SIGNAL(valueChanged(int)), connect(m_notationDurationSpinBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotNotationDurationChanged(int))); TQ_SLOT(slotNotationDurationChanged(int)));
connect(m_notationDurationEditButton, TQT_SIGNAL(released()), connect(m_notationDurationEditButton, TQ_SIGNAL(released()),
TQT_SLOT(slotEditNotationDuration())); TQ_SLOT(slotEditNotationDuration()));
setupForEvent(); 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); m_tempoValueSpinBox = new HSpinBox(frame, 0, 100000, 0.0, 1000.0, 5);
layout->addWidget(m_tempoValueSpinBox, 0, 2); layout->addWidget(m_tempoValueSpinBox, 0, 2);
connect(m_tempoValueSpinBox, TQT_SIGNAL(valueChanged(const TQString &)), connect(m_tempoValueSpinBox, TQ_SIGNAL(valueChanged(const TQString &)),
TQT_SLOT(slotTempoChanged(const TQString &))); TQ_SLOT(slotTempoChanged(const TQString &)));
m_tempoTap= new TQPushButton(i18n("Tap"), frame); m_tempoTap= new TQPushButton(i18n("Tap"), frame);
layout->addWidget(m_tempoTap, 0, 3); 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); 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_tempoRampToTarget, 3, 1);
layout->addWidget(m_tempoTargetSpinBox, 3, 2); layout->addWidget(m_tempoTargetSpinBox, 3, 2);
// connect(m_tempoTargetCheckBox, TQT_SIGNAL(clicked()), // connect(m_tempoTargetCheckBox, TQ_SIGNAL(clicked()),
// TQT_SLOT(slotTargetCheckBoxClicked())); // TQ_SLOT(slotTargetCheckBoxClicked()));
connect(m_tempoConstant, TQT_SIGNAL(clicked()), connect(m_tempoConstant, TQ_SIGNAL(clicked()),
TQT_SLOT(slotTempoConstantClicked())); TQ_SLOT(slotTempoConstantClicked()));
connect(m_tempoRampToNext, TQT_SIGNAL(clicked()), connect(m_tempoRampToNext, TQ_SIGNAL(clicked()),
TQT_SLOT(slotTempoRampToNextClicked())); TQ_SLOT(slotTempoRampToNextClicked()));
connect(m_tempoRampToTarget, TQT_SIGNAL(clicked()), connect(m_tempoRampToTarget, TQ_SIGNAL(clicked()),
TQT_SLOT(slotTempoRampToTargetClicked())); TQ_SLOT(slotTempoRampToTargetClicked()));
connect(m_tempoTargetSpinBox, TQT_SIGNAL(valueChanged(const TQString &)), connect(m_tempoTargetSpinBox, TQ_SIGNAL(valueChanged(const TQString &)),
TQT_SLOT(slotTargetChanged(const TQString &))); TQ_SLOT(slotTargetChanged(const TQString &)));
m_tempoBeatLabel = new TQLabel(frame); m_tempoBeatLabel = new TQLabel(frame);
layout->addWidget(m_tempoBeatLabel, 0, 4); layout->addWidget(m_tempoBeatLabel, 0, 4);
@ -173,14 +173,14 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
// new TQLabel(scopeBox); // new TQLabel(scopeBox);
connect(m_tempoChangeHere, TQT_SIGNAL(clicked()), connect(m_tempoChangeHere, TQ_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged())); TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeBefore, TQT_SIGNAL(clicked()), connect(m_tempoChangeBefore, TQ_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged())); TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeStartOfBar, TQT_SIGNAL(clicked()), connect(m_tempoChangeStartOfBar, TQ_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged())); TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeGlobal, TQT_SIGNAL(clicked()), connect(m_tempoChangeGlobal, TQ_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged())); TQ_SLOT(slotActionChanged()));
m_tempoChangeHere->setChecked(true); 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_prevLyric = config->readEntry("previous_lyric", "");
m_prevAnnotation = config->readEntry("previous_annotation", ""); m_prevAnnotation = config->readEntry("previous_annotation", "");
TQObject::connect(m_text, TQT_SIGNAL(textChanged(const TQString &)), TQObject::connect(m_text, TQ_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotTextChanged(const TQString &))); this, TQ_SLOT(slotTextChanged(const TQString &)));
TQObject::connect(m_typeCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_typeCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTypeChanged(const TQString &))); this, TQ_SLOT(slotTypeChanged(const TQString &)));
TQObject::connect(this, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotOK())); TQObject::connect(this, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotOK()));
TQObject::connect(m_dynamicShortcutCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_dynamicShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotDynamicShortcutChanged(const TQString &))); this, TQ_SLOT(slotDynamicShortcutChanged(const TQString &)));
TQObject::connect(m_directionShortcutCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_directionShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotDirectionShortcutChanged(const TQString &))); this, TQ_SLOT(slotDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_localDirectionShortcutCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_localDirectionShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLocalDirectionShortcutChanged(const TQString &))); this, TQ_SLOT(slotLocalDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_tempoShortcutCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_tempoShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTempoShortcutChanged(const TQString &))); this, TQ_SLOT(slotTempoShortcutChanged(const TQString &)));
TQObject::connect(m_localTempoShortcutCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_localTempoShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLocalTempoShortcutChanged(const TQString &))); this, TQ_SLOT(slotLocalTempoShortcutChanged(const TQString &)));
TQObject::connect(m_lilyPondDirectiveCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_lilyPondDirectiveCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLilyPondDirectiveChanged(const TQString &))); this, TQ_SLOT(slotLilyPondDirectiveChanged(const TQString &)));
m_text->setFocus(); m_text->setFocus();
slotTypeChanged(strtoqstr(getTextType())); slotTypeChanged(strtoqstr(getTextType()));

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

@ -47,8 +47,8 @@ TimeDialog::TimeDialog(TQWidget *parent, TQString title,
constrainToCompositionDuration); constrainToCompositionDuration);
setButtonText(User1, i18n("Reset")); setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()), connect(this, TQ_SIGNAL(user1Clicked()),
m_timeWidget, TQT_SLOT(slotResetToDefault())); m_timeWidget, TQ_SLOT(slotResetToDefault()));
} }
TimeDialog::TimeDialog(TQWidget *parent, TQString title, TimeDialog::TimeDialog(TQWidget *parent, TQString title,
@ -64,8 +64,8 @@ TimeDialog::TimeDialog(TQWidget *parent, TQString title,
constrainToCompositionDuration); constrainToCompositionDuration);
setButtonText(User1, i18n("Reset")); setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()), connect(this, TQ_SIGNAL(user1Clicked()),
m_timeWidget, TQT_SLOT(slotResetToDefault())); m_timeWidget, TQ_SLOT(slotResetToDefault()));
} }
timeT 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 *numUp = new BigArrowButton(numBox, TQt::RightArrow);
BigArrowButton *denomUp = new BigArrowButton(denomBox, TQt::RightArrow); BigArrowButton *denomUp = new BigArrowButton(denomBox, TQt::RightArrow);
TQObject::connect(numDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNumDown())); TQObject::connect(numDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNumDown()));
TQObject::connect(numUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNumUp())); TQObject::connect(numUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNumUp()));
TQObject::connect(denomDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDenomDown())); TQObject::connect(denomDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDenomDown()));
TQObject::connect(denomUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDenomUp())); TQObject::connect(denomUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDenomUp()));
if (timeEditable) { if (timeEditable) {
@ -190,8 +190,8 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
m_normalizeRestsButton->setChecked m_normalizeRestsButton->setChecked
(config->readBoolEntry("timesigdialognormalize", true)); (config->readBoolEntry("timesigdialognormalize", true));
TQObject::connect(m_hideSignatureButton, TQT_SIGNAL(clicked()), this, TQObject::connect(m_hideSignatureButton, TQ_SIGNAL(clicked()), this,
TQT_SLOT(slotUpdateCommonTimeButton())); TQ_SLOT(slotUpdateCommonTimeButton()));
slotUpdateCommonTimeButton(); slotUpdateCommonTimeButton();
m_explanatoryLabel = explanatoryLabel; 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_midiOutTimer = new TQTimer(this);
m_clearMetronomeTimer = new TQTimer(this); m_clearMetronomeTimer = new TQTimer(this);
connect(m_midiInTimer, TQT_SIGNAL(timeout()), connect(m_midiInTimer, TQ_SIGNAL(timeout()),
TQT_SLOT(slotClearMidiInLabel())); TQ_SLOT(slotClearMidiInLabel()));
connect(m_midiOutTimer, TQT_SIGNAL(timeout()), connect(m_midiOutTimer, TQ_SIGNAL(timeout()),
TQT_SLOT(slotClearMidiOutLabel())); TQ_SLOT(slotClearMidiOutLabel()));
connect(m_clearMetronomeTimer, TQT_SIGNAL(timeout()), connect(m_clearMetronomeTimer, TQ_SIGNAL(timeout()),
TQT_SLOT(slotResetBackground())); TQ_SLOT(slotResetBackground()));
m_transport->TimeDisplayLabel->hide(); m_transport->TimeDisplayLabel->hide();
m_transport->ToEndLabel->hide(); m_transport->ToEndLabel->hide();
connect(m_transport->TimeDisplayButton, TQT_SIGNAL(clicked()), connect(m_transport->TimeDisplayButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotChangeTimeDisplay())); TQ_SLOT(slotChangeTimeDisplay()));
connect(m_transport->ToEndButton, TQT_SIGNAL(clicked()), connect(m_transport->ToEndButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotChangeToEnd())); TQ_SLOT(slotChangeToEnd()));
connect(m_transport->LoopButton, TQT_SIGNAL(clicked()), connect(m_transport->LoopButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotLoopButtonClicked())); TQ_SLOT(slotLoopButtonClicked()));
connect(m_transport->PanelOpenButton, TQT_SIGNAL(clicked()), connect(m_transport->PanelOpenButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotPanelOpenButtonClicked())); TQ_SLOT(slotPanelOpenButtonClicked()));
connect(m_transport->PanelCloseButton, TQT_SIGNAL(clicked()), connect(m_transport->PanelCloseButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotPanelCloseButtonClicked())); 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_panelOpen = *m_transport->PanelOpenButton->pixmap();
m_panelClosed = *m_transport->PanelCloseButton->pixmap(); m_panelClosed = *m_transport->PanelCloseButton->pixmap();
connect(m_transport->SetStartLPButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetStartLoopingPointAtMarkerPos())); connect(m_transport->SetStartLPButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetStartLoopingPointAtMarkerPos()));
connect(m_transport->SetStopLPButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetStopLoopingPointAtMarkerPos())); connect(m_transport->SetStopLPButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetStopLoopingPointAtMarkerPos()));
// clear labels // clear labels
// //
@ -216,46 +216,46 @@ TransportDialog::TransportDialog(TQWidget *parent,
m_transport->TempoDisplay->setFont( localFont ); m_transport->TempoDisplay->setFont( localFont );
m_transport->TimeSigDisplay->setFont( localFont ); m_transport->TimeSigDisplay->setFont( localFont );
connect(m_transport->TempoDisplay, TQT_SIGNAL(doubleClicked()), connect(m_transport->TempoDisplay, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTempo())); this, TQ_SLOT(slotEditTempo()));
connect(m_transport->TempoDisplay, TQT_SIGNAL(scrollWheel(int)), connect(m_transport->TempoDisplay, TQ_SIGNAL(scrollWheel(int)),
this, TQT_SIGNAL(scrollTempo(int))); this, TQ_SIGNAL(scrollTempo(int)));
connect(m_transport->TimeSigDisplay, TQT_SIGNAL(doubleClicked()), connect(m_transport->TimeSigDisplay, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTimeSignature())); this, TQ_SLOT(slotEditTimeSignature()));
// toil through the individual pixmaps // toil through the individual pixmaps
connect(m_transport->NegativePixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->NegativePixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenHoursPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->TenHoursPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitHoursPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->UnitHoursPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->HourColonPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->HourColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenMinutesPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->TenMinutesPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitMinutesPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->UnitMinutesPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->MinuteColonPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->MinuteColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenSecondsPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->TenSecondsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitSecondsPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->UnitSecondsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->SecondColonPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->SecondColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenthsPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->TenthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->HundredthsPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->HundredthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->HundredthColonPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->HundredthColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenThousandthsPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->TenThousandthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
connect(m_transport->ThousandthsPixmap, TQT_SIGNAL(doubleClicked()), connect(m_transport->ThousandthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime())); this, TQ_SLOT(slotEditTime()));
// accelerator object // 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); m_hasTimingAlready->setChecked(false);
timingLayout->addMultiCellWidget(m_hasTimingAlready, 2, 2, 0, 2); 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(); updateUntupledCombo();
updateTupledCombo(); updateTupledCombo();
@ -157,18 +157,18 @@ TupletDialog::TupletDialog(TQWidget *parent, Note::Type defaultUnitType,
updateTimingDisplays(); updateTimingDisplays();
TQObject::connect(m_unitCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_unitCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotUnitChanged(const TQString &))); this, TQ_SLOT(slotUnitChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_untupledCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotUntupledChanged(const TQString &))); this, TQ_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQT_SIGNAL(textChanged(const TQString &)), TQObject::connect(m_untupledCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotUntupledChanged(const TQString &))); this, TQ_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQT_SIGNAL(activated(const TQString &)), TQObject::connect(m_tupledCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTupledChanged(const TQString &))); this, TQ_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQT_SIGNAL(textChanged(const TQString &)), TQObject::connect(m_tupledCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotTupledChanged(const TQString &))); this, TQ_SLOT(slotTupledChanged(const TQString &)));
} }
void void

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

@ -91,7 +91,7 @@ UseOrnamentDialog::UseOrnamentDialog(TQWidget *parent,
} }
m_mark->insertItem(i18n("Text mark")); 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); m_textLabel = new TQLabel(i18n(" Text: "), frame);
layout->addWidget(m_textLabel, 0, 2); 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 up
// //
connect(m_filterGroup, TQT_SIGNAL(released(int)), connect(m_filterGroup, TQ_SIGNAL(released(int)),
TQT_SLOT(slotModifyFilter(int))); TQ_SLOT(slotModifyFilter(int)));
m_eventList = new TDEListView(getCentralWidget()); m_eventList = new TDEListView(getCentralWidget());
m_eventList->setItemsRenameable(true); m_eventList->setItemsRenameable(true);
@ -169,21 +169,21 @@ EventView::EventView(RosegardenGUIDoc *doc,
layout->addWidget(m_triggerName, 0, 1); layout->addWidget(m_triggerName, 0, 1);
TQPushButton *editButton = new TQPushButton(i18n("edit"), frame); TQPushButton *editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 0, 2); 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); layout->addWidget(new TQLabel(i18n("Base pitch: "), frame), 1, 0);
m_triggerPitch = new TQLabel(TQString("%1").arg(rec->getBasePitch()), frame); m_triggerPitch = new TQLabel(TQString("%1").arg(rec->getBasePitch()), frame);
layout->addWidget(m_triggerPitch, 1, 1); layout->addWidget(m_triggerPitch, 1, 1);
editButton = new TQPushButton(i18n("edit"), frame); editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 1, 2); 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); layout->addWidget(new TQLabel(i18n("Base velocity: "), frame), 2, 0);
m_triggerVelocity = new TQLabel(TQString("%1").arg(rec->getBaseVelocity()), frame); m_triggerVelocity = new TQLabel(TQString("%1").arg(rec->getBaseVelocity()), frame);
layout->addWidget(m_triggerVelocity, 2, 1); layout->addWidget(m_triggerVelocity, 2, 1);
editButton = new TQPushButton(i18n("edit"), frame); editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 2, 2); 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 /*!!! Comment out these two options, which are not yet used
anywhere else -- intended for use with library ornaments, not anywhere else -- intended for use with library ornaments, not
@ -209,11 +209,11 @@ EventView::EventView(RosegardenGUIDoc *doc,
adjust->setCurrentItem(2); 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); TQCheckBox *retune = new TQCheckBox(i18n("Adjust pitch to trigger note by default"), frame);
retune->setChecked(rec->getDefaultRetune()); 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); layout->addMultiCellWidget(retune, 4, 4, 1, 2);
*/ */
@ -230,12 +230,12 @@ EventView::EventView(RosegardenGUIDoc *doc,
// Connect double clicker // Connect double clicker
// //
connect(m_eventList, TQT_SIGNAL(doubleClicked(TQListViewItem*)), connect(m_eventList, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotPopupEventEditor(TQListViewItem*))); TQ_SLOT(slotPopupEventEditor(TQListViewItem*)));
connect(m_eventList, connect(m_eventList,
TQT_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)), TQ_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(slotPopupMenu(TQListViewItem*, const TQPoint&, int))); TQ_SLOT(slotPopupMenu(TQListViewItem*, const TQPoint&, int)));
m_eventList->setAllColumnsShowFocus(true); m_eventList->setAllColumnsShowFocus(true);
m_eventList->setSelectionMode(TQListView::Extended); m_eventList->setSelectionMode(TQListView::Extended);
@ -1119,41 +1119,41 @@ EventView::setupActions()
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert.png")); TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert.png"));
new TDEAction(i18n("&Insert Event"), icon, Key_I, this, new TDEAction(i18n("&Insert Event"), icon, Key_I, this,
TQT_SLOT(slotEditInsert()), actionCollection(), TQ_SLOT(slotEditInsert()), actionCollection(),
"insert"); "insert");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-delete.png"); TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-delete.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(i18n("&Delete Event"), icon, Key_Delete, this, new TDEAction(i18n("&Delete Event"), icon, Key_Delete, this,
TQT_SLOT(slotEditDelete()), actionCollection(), TQ_SLOT(slotEditDelete()), actionCollection(),
"delete"); "delete");
pixmap.load(pixmapDir + "/toolbar/event-edit.png"); pixmap.load(pixmapDir + "/toolbar/event-edit.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(i18n("&Edit Event"), icon, Key_E, this, new TDEAction(i18n("&Edit Event"), icon, Key_E, this,
TQT_SLOT(slotEditEvent()), actionCollection(), TQ_SLOT(slotEditEvent()), actionCollection(),
"edit_simple"); "edit_simple");
pixmap.load(pixmapDir + "/toolbar/event-edit-advanced.png"); pixmap.load(pixmapDir + "/toolbar/event-edit-advanced.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(i18n("&Advanced Event Editor"), icon, Key_A, this, new TDEAction(i18n("&Advanced Event Editor"), icon, Key_A, this,
TQT_SLOT(slotEditEventAdvanced()), actionCollection(), TQ_SLOT(slotEditEventAdvanced()), actionCollection(),
"edit_advanced"); "edit_advanced");
// icon = TQIconSet(TQCanvasPixmap(pixmapDir + "/toolbar/eventfilter.xpm")); // icon = TQIconSet(TQCanvasPixmap(pixmapDir + "/toolbar/eventfilter.xpm"));
new TDEAction(i18n("&Filter Selection"), "filter", Key_F, this, new TDEAction(i18n("&Filter Selection"), "filter", Key_F, this,
TQT_SLOT(slotFilterSelection()), actionCollection(), TQ_SLOT(slotFilterSelection()), actionCollection(),
"filter_selection"); "filter_selection");
new TDEAction(i18n("Select &All"), Key_A + CTRL, this, new TDEAction(i18n("Select &All"), Key_A + CTRL, this,
TQT_SLOT(slotSelectAll()), actionCollection(), TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all"); "select_all");
new TDEAction(i18n("Clear Selection"), Key_Escape, this, new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQT_SLOT(slotClearSelection()), actionCollection(), TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection"); "clear_selection");
m_config->setGroup(EventViewConfigGroup); m_config->setGroup(EventViewConfigGroup);
@ -1165,7 +1165,7 @@ EventView::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this, action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()), TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical"); actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 0) if (timeMode == 0)
@ -1175,7 +1175,7 @@ EventView::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this, action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()), TQ_SLOT(slotRealTime()),
actionCollection(), "time_real"); actionCollection(), "time_real");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 1) if (timeMode == 1)
@ -1185,7 +1185,7 @@ EventView::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this, action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()), TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw"); actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 2) if (timeMode == 2)
@ -1516,8 +1516,8 @@ EventView::createMenu()
m_menu->insertItem(i18n("Open in Event Editor"), 0); m_menu->insertItem(i18n("Open in Event Editor"), 0);
m_menu->insertItem(i18n("Open in Expert Event Editor"), 1); m_menu->insertItem(i18n("Open in Expert Event Editor"), 1);
connect(m_menu, TQT_SIGNAL(activated(int)), connect(m_menu, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotMenuActivated(int))); TQ_SLOT(slotMenuActivated(int)));
} }
void 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); m_startFret = new TQSpinBox(1, 24, 1, page);
topLayout->addWidget(m_startFret, 1, 1); topLayout->addWidget(m_startFret, 1, 1);
connect(m_startFret, TQT_SIGNAL(valueChanged(int)), connect(m_startFret, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotStartFretChanged(int))); this, TQ_SLOT(slotStartFretChanged(int)));
topLayout->addWidget(new TQLabel(i18n("Root"), page), 2, 1); topLayout->addWidget(new TQLabel(i18n("Root"), page), 2, 1);
m_rootNotesList = new TQComboBox(page); 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("common"));
m_chordComplexityCombo->insertItem(i18n("all")); m_chordComplexityCombo->insertItem(i18n("all"));
connect(m_chordComplexityCombo, TQT_SIGNAL(activated(int)), connect(m_chordComplexityCombo, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotComplexityChanged(int))); this, TQ_SLOT(slotComplexityChanged(int)));
TQVBoxLayout* vboxLayout = new TQVBoxLayout(page, 5); TQVBoxLayout* vboxLayout = new TQVBoxLayout(page, 5);
topLayout->addMultiCellLayout(vboxLayout, 1, 3, 2, 2); topLayout->addMultiCellLayout(vboxLayout, 1, 3, 2, 2);
@ -74,12 +74,12 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
vboxLayout->addWidget(m_deleteFingeringButton); vboxLayout->addWidget(m_deleteFingeringButton);
vboxLayout->addWidget(m_editFingeringButton); vboxLayout->addWidget(m_editFingeringButton);
connect(m_newFingeringButton, TQT_SIGNAL(clicked()), connect(m_newFingeringButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotNewFingering())); this, TQ_SLOT(slotNewFingering()));
connect(m_deleteFingeringButton, TQT_SIGNAL(clicked()), connect(m_deleteFingeringButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteFingering())); this, TQ_SLOT(slotDeleteFingering()));
connect(m_editFingeringButton, TQT_SIGNAL(clicked()), connect(m_editFingeringButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotEditFingering())); this, TQ_SLOT(slotEditFingering()));
topLayout->addWidget(new TQLabel(i18n("Fingerings"), page), 0, 3); topLayout->addWidget(new TQLabel(i18n("Fingerings"), page), 0, 3);
m_fingeringsList = new TQListBox(page); m_fingeringsList = new TQListBox(page);
@ -88,12 +88,12 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
m_fingeringBox = new FingeringBox(false, page); m_fingeringBox = new FingeringBox(false, page);
topLayout->addMultiCellWidget(m_fingeringBox, 2, 2, 0, 1); topLayout->addMultiCellWidget(m_fingeringBox, 2, 2, 0, 1);
connect(m_rootNotesList, TQT_SIGNAL(highlighted(int)), connect(m_rootNotesList, TQ_SIGNAL(highlighted(int)),
this, TQT_SLOT(slotRootHighlighted(int))); this, TQ_SLOT(slotRootHighlighted(int)));
connect(m_chordExtList, TQT_SIGNAL(highlighted(int)), connect(m_chordExtList, TQ_SIGNAL(highlighted(int)),
this, TQT_SLOT(slotChordExtHighlighted(int))); this, TQ_SLOT(slotChordExtHighlighted(int)));
connect(m_fingeringsList, TQT_SIGNAL(highlighted(TQListBoxItem*)), connect(m_fingeringsList, TQ_SIGNAL(highlighted(TQListBoxItem*)),
this, TQT_SLOT(slotFingeringHighlighted(TQListBoxItem*))); this, TQ_SLOT(slotFingeringHighlighted(TQListBoxItem*)));
} }
void void

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

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

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

@ -55,11 +55,11 @@ GuitarChordInserter::GuitarChordInserter(NotationView* view)
makeToolbarPixmap("select"))); makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this, new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(), TQ_SLOT(slotSelectSelected()), actionCollection(),
"select"); "select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this, new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(), TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase"); "erase");
icon = TQIconSet icon = TQIconSet
@ -67,7 +67,7 @@ GuitarChordInserter::GuitarChordInserter(NotationView* view)
makeToolbarPixmap("crotchet"))); makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this, new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNoteSelected()), actionCollection(), TQ_SLOT(slotNoteSelected()), actionCollection(),
"notes"); "notes");
m_guitarChordSelector = new GuitarChordSelectorDialog(m_nParentView); 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); m_collapseRest = config->readBoolEntry("collapse", false);
new TDEToggleAction(i18n("Collapse rests after erase"), 0, this, new TDEToggleAction(i18n("Collapse rests after erase"), 0, this,
TQT_SLOT(slotToggleRestCollapse()), actionCollection(), TQ_SLOT(slotToggleRestCollapse()), actionCollection(),
"toggle_rest_collapse"); "toggle_rest_collapse");
TQIconSet icon TQIconSet icon
(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: (NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet"))); makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Insert Tool"), icon, 0, this, new TDEAction(i18n("Switch to Insert Tool"), icon, 0, this,
TQT_SLOT(slotInsertSelected()), actionCollection(), TQ_SLOT(slotInsertSelected()), actionCollection(),
"insert"); "insert");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select"))); makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this, new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(), TQ_SLOT(slotSelectSelected()), actionCollection(),
"select"); "select");
createMenu("notationeraser.rc"); 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_justSelectedBar(false),
m_wholeStaffSelectionComplete(false) m_wholeStaffSelectionComplete(false)
{ {
connect(m_parentView, TQT_SIGNAL(usedSelection()), connect(m_parentView, TQ_SIGNAL(usedSelection()),
this, TQT_SLOT(slotHideSelection())); this, TQ_SLOT(slotHideSelection()));
connect(this, TQT_SIGNAL(editElement(NotationStaff *, NotationElement *, bool)), connect(this, TQ_SIGNAL(editElement(NotationStaff *, NotationElement *, bool)),
m_parentView, TQT_SLOT(slotEditElement(NotationStaff *, NotationElement *, bool))); m_parentView, TQ_SLOT(slotEditElement(NotationStaff *, NotationElement *, bool)));
TQIconSet icon TQIconSet icon
(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: (NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet"))); makeToolbarPixmap("crotchet")));
new TDEToggleAction(i18n("Switch to Insert Tool"), icon, 0, this, new TDEToggleAction(i18n("Switch to Insert Tool"), icon, 0, this,
TQT_SLOT(slotInsertSelected()), actionCollection(), TQ_SLOT(slotInsertSelected()), actionCollection(),
"insert"); "insert");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this, new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(), TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase"); "erase");
// (this crashed, and it might be superfluous with ^N anyway, so I'm // (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 // commenting it out, but leaving it here in case I change my mind about
// fooling with it.) (DMM) // fooling with it.) (DMM)
// new TDEAction(i18n("Normalize Rests"), 0, 0, this, // new TDEAction(i18n("Normalize Rests"), 0, 0, this,
// TQT_SLOT(slotCollapseRests()), actionCollection(), // TQ_SLOT(slotCollapseRests()), actionCollection(),
// "collapse_rests"); // "collapse_rests");
new TDEAction(i18n("Collapse Rests"), 0, 0, this, new TDEAction(i18n("Collapse Rests"), 0, 0, this,
TQT_SLOT(slotCollapseRestsHard()), actionCollection(), TQ_SLOT(slotCollapseRestsHard()), actionCollection(),
"collapse_rests_aggressively"); "collapse_rests_aggressively");
new TDEAction(i18n("Respell as Flat"), 0, 0, this, new TDEAction(i18n("Respell as Flat"), 0, 0, this,
TQT_SLOT(slotRespellFlat()), actionCollection(), TQ_SLOT(slotRespellFlat()), actionCollection(),
"respell_flat"); "respell_flat");
new TDEAction(i18n("Respell as Sharp"), 0, 0, this, new TDEAction(i18n("Respell as Sharp"), 0, 0, this,
TQT_SLOT(slotRespellSharp()), actionCollection(), TQ_SLOT(slotRespellSharp()), actionCollection(),
"respell_sharp"); "respell_sharp");
new TDEAction(i18n("Respell as Natural"), 0, 0, this, new TDEAction(i18n("Respell as Natural"), 0, 0, this,
TQT_SLOT(slotRespellNatural()), actionCollection(), TQ_SLOT(slotRespellNatural()), actionCollection(),
"respell_natural"); "respell_natural");
new TDEAction(i18n("Collapse Notes"), 0, 0, this, new TDEAction(i18n("Collapse Notes"), 0, 0, this,
TQT_SLOT(slotCollapseNotes()), actionCollection(), TQ_SLOT(slotCollapseNotes()), actionCollection(),
"collapse_notes"); "collapse_notes");
new TDEAction(i18n("Interpret"), 0, 0, this, new TDEAction(i18n("Interpret"), 0, 0, this,
TQT_SLOT(slotInterpret()), actionCollection(), TQ_SLOT(slotInterpret()), actionCollection(),
"interpret"); "interpret");
new TDEAction(i18n("Move to Staff Above"), 0, 0, this, new TDEAction(i18n("Move to Staff Above"), 0, 0, this,
TQT_SLOT(slotStaffAbove()), actionCollection(), TQ_SLOT(slotStaffAbove()), actionCollection(),
"move_events_up_staff"); "move_events_up_staff");
new TDEAction(i18n("Move to Staff Below"), 0, 0, this, new TDEAction(i18n("Move to Staff Below"), 0, 0, this,
TQT_SLOT(slotStaffBelow()), actionCollection(), TQ_SLOT(slotStaffBelow()), actionCollection(),
"move_events_down_staff"); "move_events_down_staff");
new TDEAction(i18n("Make Invisible"), 0, 0, this, new TDEAction(i18n("Make Invisible"), 0, 0, this,
TQT_SLOT(slotMakeInvisible()), actionCollection(), TQ_SLOT(slotMakeInvisible()), actionCollection(),
"make_invisible"); "make_invisible");
new TDEAction(i18n("Make Visible"), 0, 0, this, new TDEAction(i18n("Make Visible"), 0, 0, this,
TQT_SLOT(slotMakeVisible()), actionCollection(), TQ_SLOT(slotMakeVisible()), actionCollection(),
"make_visible"); "make_visible");
createMenu("notationselector.rc"); createMenu("notationselector.rc");
@ -256,7 +256,7 @@ void NotationSelector::handleMouseDoubleClick(timeT,
m_justSelectedBar = true; m_justSelectedBar = true;
TQTimer::singleShot(TQApplication::doubleClickInterval(), this, TQTimer::singleShot(TQApplication::doubleClickInterval(), this,
TQT_SLOT(slotClickTimeout())); TQ_SLOT(slotClickTimeout()));
} }
return ; 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); m_frame = new FontViewFrame(pixelSize, box);
connect(m_font, TQT_SIGNAL(activated(const TQString &)), connect(m_font, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotFontChanged(const TQString &))); this, TQ_SLOT(slotFontChanged(const TQString &)));
connect(m_view, TQT_SIGNAL(activated(int)), connect(m_view, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotViewChanged(int))); this, TQ_SLOT(slotViewChanged(int)));
connect(m_rows, TQT_SIGNAL(activated(const TQString &)), connect(m_rows, TQ_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotRowChanged(const TQString &))); this, TQ_SLOT(slotRowChanged(const TQString &)));
slotFontChanged(m_font->currentText()); slotFontChanged(m_font->currentText());
} }

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

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

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

@ -58,24 +58,24 @@ RestInserter::RestInserter(NotationView* view)
(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: (NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("dotted-rest-crotchet"))); makeToolbarPixmap("dotted-rest-crotchet")));
new TDEToggleAction(i18n("Dotted rest"), icon, 0, this, new TDEToggleAction(i18n("Dotted rest"), icon, 0, this,
TQT_SLOT(slotToggleDot()), actionCollection(), TQ_SLOT(slotToggleDot()), actionCollection(),
"toggle_dot"); "toggle_dot");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select"))); makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this, new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(), TQ_SLOT(slotSelectSelected()), actionCollection(),
"select"); "select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this, new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(), TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase"); "erase");
icon = TQIconSet icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: (NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet"))); makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this, new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(), TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes"); "notes");
createMenu("restinserter.rc"); 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:: TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select"))); makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this, new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(), TQ_SLOT(slotSelectSelected()), actionCollection(),
"select"); "select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this, new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(), TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase"); "erase");
icon = TQIconSet icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory:: (NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet"))); makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this, new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(), TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes"); "notes");
createMenu("textinserter.rc"); 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); gridLayout->setRowStretch(2, 1);
connect(m_audioFader, TQT_SIGNAL(audioChannelsChanged(int)), connect(m_audioFader, TQ_SIGNAL(audioChannelsChanged(int)),
this, TQT_SLOT(slotAudioChannels(int))); this, TQ_SLOT(slotAudioChannels(int)));
connect(m_audioFader->m_signalMapper, TQT_SIGNAL(mapped(int)), connect(m_audioFader->m_signalMapper, TQ_SIGNAL(mapped(int)),
this, TQT_SLOT(slotSelectPlugin(int))); this, TQ_SLOT(slotSelectPlugin(int)));
connect(m_audioFader->m_fader, TQT_SIGNAL(faderChanged(float)), connect(m_audioFader->m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotSelectAudioLevel(float))); this, TQ_SLOT(slotSelectAudioLevel(float)));
connect(m_audioFader->m_recordFader, TQT_SIGNAL(faderChanged(float)), connect(m_audioFader->m_recordFader, TQ_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotSelectAudioRecordLevel(float))); this, TQ_SLOT(slotSelectAudioRecordLevel(float)));
connect(m_audioFader->m_pan, TQT_SIGNAL(valueChanged(float)), connect(m_audioFader->m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotSetPan(float))); this, TQ_SLOT(slotSetPan(float)));
connect(m_audioFader->m_audioOutput, TQT_SIGNAL(changed()), connect(m_audioFader->m_audioOutput, TQ_SIGNAL(changed()),
this, TQT_SLOT(slotAudioRoutingChanged())); this, TQ_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioInput, TQT_SIGNAL(changed()), connect(m_audioFader->m_audioInput, TQ_SIGNAL(changed()),
this, TQT_SLOT(slotAudioRoutingChanged())); this, TQ_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_synthButton, TQT_SIGNAL(clicked()), connect(m_audioFader->m_synthButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSynthButtonClicked())); this, TQ_SLOT(slotSynthButtonClicked()));
connect(m_audioFader->m_synthGUIButton, TQT_SIGNAL(clicked()), connect(m_audioFader->m_synthGUIButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSynthGUIButtonClicked())); this, TQ_SLOT(slotSynthGUIButtonClicked()));
} }
void void

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

@ -84,39 +84,39 @@ InstrumentParameterBox::InstrumentParameterBox(RosegardenGUIDoc *doc,
m_audioInstrumentParameters->adjustSize(); m_audioInstrumentParameters->adjustSize();
m_noInstrumentParameters->adjustSize(); m_noInstrumentParameters->adjustSize();
connect(m_audioInstrumentParameters, TQT_SIGNAL(updateAllBoxes()), connect(m_audioInstrumentParameters, TQ_SIGNAL(updateAllBoxes()),
this, TQT_SLOT(slotUpdateAllBoxes())); this, TQ_SLOT(slotUpdateAllBoxes()));
connect(m_audioInstrumentParameters, connect(m_audioInstrumentParameters,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)), TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
this, this,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId))); TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
connect(m_audioInstrumentParameters, connect(m_audioInstrumentParameters,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)), TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
this, this,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int))); TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)));
connect(m_audioInstrumentParameters, connect(m_audioInstrumentParameters,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)), TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
this, this,
TQT_SIGNAL(showPluginGUI(InstrumentId, int))); TQ_SIGNAL(showPluginGUI(InstrumentId, int)));
connect(m_midiInstrumentParameters, TQT_SIGNAL(updateAllBoxes()), connect(m_midiInstrumentParameters, TQ_SIGNAL(updateAllBoxes()),
this, TQT_SLOT(slotUpdateAllBoxes())); this, TQ_SLOT(slotUpdateAllBoxes()));
connect(m_midiInstrumentParameters, connect(m_midiInstrumentParameters,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)), TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString))); this, TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
connect(m_audioInstrumentParameters, connect(m_audioInstrumentParameters,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)), TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString))); this, TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
connect(m_midiInstrumentParameters, connect(m_midiInstrumentParameters,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)), TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
this, this,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId))); TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
// Layout the groups left to right. // 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 up the toggle boxes
// //
connect(m_percussionCheckBox, TQT_SIGNAL(toggled(bool)), connect(m_percussionCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotTogglePercussion(bool))); this, TQ_SLOT(slotTogglePercussion(bool)));
connect(m_programCheckBox, TQT_SIGNAL(toggled(bool)), connect(m_programCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleProgramChange(bool))); this, TQ_SLOT(slotToggleProgramChange(bool)));
connect(m_bankCheckBox, TQT_SIGNAL(toggled(bool)), connect(m_bankCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleBank(bool))); this, TQ_SLOT(slotToggleBank(bool)));
connect(m_variationCheckBox, TQT_SIGNAL(toggled(bool)), connect(m_variationCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleVariation(bool))); this, TQ_SLOT(slotToggleVariation(bool)));
// Connect activations // Connect activations
// //
connect(m_bankValue, TQT_SIGNAL(activated(int)), connect(m_bankValue, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectBank(int))); this, TQ_SLOT(slotSelectBank(int)));
connect(m_variationValue, TQT_SIGNAL(activated(int)), connect(m_variationValue, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectVariation(int))); this, TQ_SLOT(slotSelectVariation(int)));
connect(m_programValue, TQT_SIGNAL(activated(int)), connect(m_programValue, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectProgram(int))); this, TQ_SLOT(slotSelectProgram(int)));
connect(m_channelValue, TQT_SIGNAL(activated(int)), connect(m_channelValue, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectChannel(int))); this, TQ_SLOT(slotSelectChannel(int)));
// don't select any of the options in any dropdown // don't select any of the options in any dropdown
m_programValue->setCurrentItem( -1); m_programValue->setCurrentItem( -1);
@ -183,8 +183,8 @@ MIDIInstrumentParameterPanel::MIDIInstrumentParameterPanel(RosegardenGUIDoc *doc
m_channelValue->setCurrentItem( -1); m_channelValue->setCurrentItem( -1);
m_variationValue->setCurrentItem( -1); m_variationValue->setCurrentItem( -1);
connect(m_rotaryMapper, TQT_SIGNAL(mapped(int)), connect(m_rotaryMapper, TQ_SIGNAL(mapped(int)),
this, TQT_SLOT(slotControllerChanged(int))); this, TQ_SLOT(slotControllerChanged(int)));
} }
void void
@ -415,8 +415,8 @@ MIDIInstrumentParameterPanel::setupControllers(MidiDevice *md)
// Connect // Connect
// //
connect(rotary, TQT_SIGNAL(valueChanged(float)), connect(rotary, TQ_SIGNAL(valueChanged(float)),
m_rotaryMapper, TQT_SLOT(map())); m_rotaryMapper, TQ_SLOT(map()));
rmi = m_rotaries.end(); 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); m_doc->getComposition().addObserver(this);
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted()), connect(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(update())); this, TQ_SLOT(update()));
} }
SegmentParameterBox::~SegmentParameterBox() SegmentParameterBox::~SegmentParameterBox()
@ -143,15 +143,15 @@ SegmentParameterBox::initBox()
m_labelButton->setFont(font); m_labelButton->setFont(font);
// m_labelButton->setFixedWidth(50); // m_labelButton->setFixedWidth(50);
connect(m_labelButton, TQT_SIGNAL(released()), connect(m_labelButton, TQ_SIGNAL(released()),
TQT_SLOT(slotEditSegmentLabel())); TQ_SLOT(slotEditSegmentLabel()));
m_repeatValue = new TristateCheckBox(this); m_repeatValue = new TristateCheckBox(this);
m_repeatValue->setFont(font); m_repeatValue->setFont(font);
//m_repeatValue->setFixedHeight(comboHeight); //m_repeatValue->setFixedHeight(comboHeight);
// handle state changes // 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 // non-reversing motif style read-only combo
m_quantizeValue = new KComboBox(this); m_quantizeValue = new KComboBox(this);
@ -159,8 +159,8 @@ SegmentParameterBox::initBox()
//m_quantizeValue->setFixedHeight(comboHeight); //m_quantizeValue->setFixedHeight(comboHeight);
// handle quantize changes from drop down // handle quantize changes from drop down
connect(m_quantizeValue, TQT_SIGNAL(activated(int)), connect(m_quantizeValue, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotQuantizeSelected(int))); TQ_SLOT(slotQuantizeSelected(int)));
// reversing motif style read-write combo // reversing motif style read-write combo
m_transposeValue = new KComboBox(this); m_transposeValue = new KComboBox(this);
@ -168,12 +168,12 @@ SegmentParameterBox::initBox()
//m_transposeValue->setFixedHeight(comboHeight); //m_transposeValue->setFixedHeight(comboHeight);
// handle transpose combo changes // handle transpose combo changes
connect(m_transposeValue, TQT_SIGNAL(activated(int)), connect(m_transposeValue, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotTransposeSelected(int))); TQ_SLOT(slotTransposeSelected(int)));
// and text changes // and text changes
connect(m_transposeValue, TQT_SIGNAL(textChanged(const TQString&)), connect(m_transposeValue, TQ_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotTransposeTextChanged(const TQString&))); TQ_SLOT(slotTransposeTextChanged(const TQString&)));
// reversing motif style read-write combo // reversing motif style read-write combo
m_delayValue = new KComboBox(this); m_delayValue = new KComboBox(this);
@ -181,16 +181,16 @@ SegmentParameterBox::initBox()
//m_delayValue->setFixedHeight(comboHeight); //m_delayValue->setFixedHeight(comboHeight);
// handle delay combo changes // handle delay combo changes
connect(m_delayValue, TQT_SIGNAL(activated(int)), connect(m_delayValue, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotDelaySelected(int))); TQ_SLOT(slotDelaySelected(int)));
// Detect when the document colours are updated // Detect when the document colours are updated
connect(m_doc, TQT_SIGNAL(docColoursChanged()), connect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged())); this, TQ_SLOT(slotDocColoursChanged()));
// handle text changes for delay // handle text changes for delay
connect(m_delayValue, TQT_SIGNAL(textChanged(const TQString&)), connect(m_delayValue, TQ_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotDelayTextChanged(const TQString &))); TQ_SLOT(slotDelayTextChanged(const TQString &)));
// set up combo box for colours // set up combo box for colours
m_colourValue = new KComboBox(false, this); m_colourValue = new KComboBox(false, this);
@ -200,8 +200,8 @@ SegmentParameterBox::initBox()
m_colourValue->setSizeLimit(20); m_colourValue->setSizeLimit(20);
// handle colour combo changes // handle colour combo changes
connect(m_colourValue, TQT_SIGNAL(activated(int)), connect(m_colourValue, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotColourSelected(int))); TQ_SLOT(slotColourSelected(int)));
// pre-set width of buttons so they don't grow later // pre-set width of buttons so they don't grow later
// width = fontMetrics.width(i18n("used internally for spacing", "High: ----")); // width = fontMetrics.width(i18n("used internally for spacing", "High: ----"));
@ -214,8 +214,8 @@ SegmentParameterBox::initBox()
// m_highButton->setFont(font); // m_highButton->setFont(font);
// m_highButton->setMinimumWidth(width); // m_highButton->setMinimumWidth(width);
// connect(m_highButton, TQT_SIGNAL(released()), // connect(m_highButton, TQ_SIGNAL(released()),
// TQT_SLOT(slotHighestPressed())); // TQ_SLOT(slotHighestPressed()));
// lowest playable note // lowest playable note
// //
@ -225,14 +225,14 @@ SegmentParameterBox::initBox()
// m_lowButton->setFont(font); // m_lowButton->setFont(font);
// m_lowButton->setMinimumWidth(width); // m_lowButton->setMinimumWidth(width);
// connect(m_lowButton, TQT_SIGNAL(released()), // connect(m_lowButton, TQ_SIGNAL(released()),
// TQT_SLOT(slotLowestPressed())); // TQ_SLOT(slotLowestPressed()));
// Audio autofade enabled // Audio autofade enabled
// //
// m_autoFadeBox = new TQCheckBox(this); // m_autoFadeBox = new TQCheckBox(this);
// connect(m_autoFadeBox, TQT_SIGNAL(stateChanged(int)), // connect(m_autoFadeBox, TQ_SIGNAL(stateChanged(int)),
// this, TQT_SLOT(slotAudioFadeChanged(int))); // this, TQ_SLOT(slotAudioFadeChanged(int)));
// Fade in and out times // Fade in and out times
// //
@ -240,15 +240,15 @@ SegmentParameterBox::initBox()
// m_fadeInSpin->setMinValue(0); // m_fadeInSpin->setMinValue(0);
// m_fadeInSpin->setMaxValue(5000); // m_fadeInSpin->setMaxValue(5000);
// m_fadeInSpin->setSuffix(i18n(" ms")); // m_fadeInSpin->setSuffix(i18n(" ms"));
// connect(m_fadeInSpin, TQT_SIGNAL(valueChanged(int)), // connect(m_fadeInSpin, TQ_SIGNAL(valueChanged(int)),
// this, TQT_SLOT(slotFadeInChanged(int))); // this, TQ_SLOT(slotFadeInChanged(int)));
// m_fadeOutSpin = new TQSpinBox(this); // m_fadeOutSpin = new TQSpinBox(this);
// m_fadeOutSpin->setMinValue(0); // m_fadeOutSpin->setMinValue(0);
// m_fadeOutSpin->setMaxValue(5000); // m_fadeOutSpin->setMaxValue(5000);
// m_fadeOutSpin->setSuffix(i18n(" ms")); // m_fadeOutSpin->setSuffix(i18n(" ms"));
// connect(m_fadeOutSpin, TQT_SIGNAL(valueChanged(int)), // connect(m_fadeOutSpin, TQ_SIGNAL(valueChanged(int)),
// this, TQT_SLOT(slotFadeOutChanged(int))); // this, TQ_SLOT(slotFadeOutChanged(int)));
label->setFont(font); label->setFont(font);
repeatLabel->setFont(font); repeatLabel->setFont(font);
@ -382,14 +382,14 @@ void
SegmentParameterBox::setDocument(RosegardenGUIDoc* doc) SegmentParameterBox::setDocument(RosegardenGUIDoc* doc)
{ {
if (m_doc != 0) if (m_doc != 0)
disconnect(m_doc, TQT_SIGNAL(docColoursChanged()), disconnect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged())); this, TQ_SLOT(slotDocColoursChanged()));
m_doc = doc; m_doc = doc;
// Detect when the document colours are updated // Detect when the document colours are updated
connect (m_doc, TQT_SIGNAL(docColoursChanged()), connect (m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged())); this, TQ_SLOT(slotDocColoursChanged()));
slotDocColoursChanged(); // repopulate combo 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); groupLayout->addMultiCellWidget(m_transpLbl, row, row, 3, 4, AlignRight);
m_defTranspose = new KComboBox(m_defaultsGroup); m_defTranspose = new KComboBox(m_defaultsGroup);
connect(m_defTranspose, TQT_SIGNAL(activated(int)), connect(m_defTranspose, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotTransposeIndexChanged(int))); TQ_SLOT(slotTransposeIndexChanged(int)));
int transposeRange = 48; int transposeRange = 48;
for (int i = -transposeRange; i < transposeRange + 1; i++) { for (int i = -transposeRange; i < transposeRange + 1; i++) {
@ -359,43 +359,43 @@ TrackParameterBox::TrackParameterBox( RosegardenGUIDoc *doc,
mainLayout->setRowStretch(mainLayout->numRows() - 1, 1); mainLayout->setRowStretch(mainLayout->numRows() - 1, 1);
// Connections // Connections
connect( m_playDevice, TQT_SIGNAL(activated(int)), connect( m_playDevice, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotPlaybackDeviceChanged(int))); this, TQ_SLOT(slotPlaybackDeviceChanged(int)));
connect( m_instrument, TQT_SIGNAL(activated(int)), connect( m_instrument, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotInstrumentChanged(int))); this, TQ_SLOT(slotInstrumentChanged(int)));
connect( m_recDevice, TQT_SIGNAL(activated(int)), connect( m_recDevice, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotRecordingDeviceChanged(int))); this, TQ_SLOT(slotRecordingDeviceChanged(int)));
connect( m_recChannel, TQT_SIGNAL(activated(int)), connect( m_recChannel, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotRecordingChannelChanged(int))); this, TQ_SLOT(slotRecordingChannelChanged(int)));
connect( m_defClef, TQT_SIGNAL(activated(int)), connect( m_defClef, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotClefChanged(int))); this, TQ_SLOT(slotClefChanged(int)));
// Detect when the document colours are updated // Detect when the document colours are updated
connect(m_doc, TQT_SIGNAL(docColoursChanged()), connect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged())); this, TQ_SLOT(slotDocColoursChanged()));
// handle colour combo changes // handle colour combo changes
connect(m_defColor, TQT_SIGNAL(activated(int)), connect(m_defColor, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotColorChanged(int))); TQ_SLOT(slotColorChanged(int)));
connect(m_highButton, TQT_SIGNAL(released()), connect(m_highButton, TQ_SIGNAL(released()),
TQT_SLOT(slotHighestPressed())); TQ_SLOT(slotHighestPressed()));
connect(m_lowButton, TQT_SIGNAL(released()), connect(m_lowButton, TQ_SIGNAL(released()),
TQT_SLOT(slotLowestPressed())); TQ_SLOT(slotLowestPressed()));
connect(m_presetButton, TQT_SIGNAL(released()), connect(m_presetButton, TQ_SIGNAL(released()),
TQT_SLOT(slotPresetPressed())); TQ_SLOT(slotPresetPressed()));
connect(m_staffSizeCombo, TQT_SIGNAL(activated(int)), connect(m_staffSizeCombo, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotStaffSizeChanged(int))); this, TQ_SLOT(slotStaffSizeChanged(int)));
connect(m_staffBracketCombo, TQT_SIGNAL(activated(int)), connect(m_staffBracketCombo, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotStaffBracketChanged(int))); this, TQ_SLOT(slotStaffBracketChanged(int)));
} }
TrackParameterBox::~TrackParameterBox() 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->addWidget(m_closeButton);
layout->addSpacing(5); layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()), connect(m_addButton, TQ_SIGNAL(released()),
TQT_SLOT(slotAdd())); TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()), connect(m_deleteButton, TQ_SIGNAL(released()),
TQT_SLOT(slotDelete())); TQ_SLOT(slotDelete()));
setupActions(); setupActions();
m_doc->getCommandHistory()->attachView(actionCollection()); m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate())); this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)), connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *))); TQ_SLOT(slotEdit(TQListViewItem *)));
// Highlight all columns - enable extended selection mode // Highlight all columns - enable extended selection mode
// //
@ -336,11 +336,11 @@ void
ControlEditorDialog::setupActions() ControlEditorDialog::setupActions()
{ {
TDEAction* close = KStdAction::close(this, TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
m_closeButton->setText(close->text()); 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 // some adjustments
new TDEToolBarPopupAction(i18n("Und&o"), 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); m_ipbPosition = new KComboBox(frame);
layout->addMultiCellWidget(m_ipbPosition, 8, 8, 1, 2); layout->addMultiCellWidget(m_ipbPosition, 8, 8, 1, 2);
connect(m_nameEdit, TQT_SIGNAL(textChanged(const TQString&)), connect(m_nameEdit, TQ_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotNameChanged(const TQString&))); TQ_SLOT(slotNameChanged(const TQString&)));
connect(m_typeCombo, TQT_SIGNAL(activated(int)), connect(m_typeCombo, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotTypeChanged(int))); TQ_SLOT(slotTypeChanged(int)));
connect(m_description, TQT_SIGNAL(textChanged(const TQString&)), connect(m_description, TQ_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotDescriptionChanged(const TQString &))); TQ_SLOT(slotDescriptionChanged(const TQString &)));
connect(m_controllerBox, TQT_SIGNAL(valueChanged(int)), connect(m_controllerBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotControllerChanged(int))); TQ_SLOT(slotControllerChanged(int)));
connect(m_minBox, TQT_SIGNAL(valueChanged(int)), connect(m_minBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotMinChanged(int))); TQ_SLOT(slotMinChanged(int)));
connect(m_maxBox, TQT_SIGNAL(valueChanged(int)), connect(m_maxBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotMaxChanged(int))); TQ_SLOT(slotMaxChanged(int)));
connect(m_defaultBox, TQT_SIGNAL(valueChanged(int)), connect(m_defaultBox, TQ_SIGNAL(valueChanged(int)),
TQT_SLOT(slotDefaultChanged(int))); TQ_SLOT(slotDefaultChanged(int)));
connect(m_colourCombo, TQT_SIGNAL(activated(int)), connect(m_colourCombo, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotColourChanged(int))); TQ_SLOT(slotColourChanged(int)));
connect(m_ipbPosition, TQT_SIGNAL(activated(int)), connect(m_ipbPosition, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotIPBPositionChanged(int))); TQ_SLOT(slotIPBPositionChanged(int)));
//m_nameEdit->selectAll(); //m_nameEdit->selectAll();
//m_description->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->addWidget(m_closeButton);
layout->addSpacing(5); layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()), connect(m_addButton, TQ_SIGNAL(released()),
TQT_SLOT(slotAdd())); TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()), connect(m_deleteButton, TQ_SIGNAL(released()),
TQT_SLOT(slotDelete())); TQ_SLOT(slotDelete()));
connect(m_closeButton, TQT_SIGNAL(released()), connect(m_closeButton, TQ_SIGNAL(released()),
TQT_SLOT(slotClose())); TQ_SLOT(slotClose()));
connect(m_deleteAllButton, TQT_SIGNAL(released()), connect(m_deleteAllButton, TQ_SIGNAL(released()),
TQT_SLOT(slotDeleteAll())); TQ_SLOT(slotDeleteAll()));
setupActions(); setupActions();
m_doc->getCommandHistory()->attachView(actionCollection()); m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate())); this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)), connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *))); TQ_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQT_SIGNAL(pressed(TQListViewItem *)), connect(m_listView, TQ_SIGNAL(pressed(TQListViewItem *)),
this, TQT_SLOT(slotItemClicked(TQListViewItem *))); this, TQ_SLOT(slotItemClicked(TQListViewItem *)));
// Highlight all columns - enable extended selection mode // Highlight all columns - enable extended selection mode
// //
@ -366,11 +366,11 @@ void
MarkerEditor::setupActions() MarkerEditor::setupActions()
{ {
TDEAction* close = KStdAction::close(this, TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
m_closeButton->setText(close->text()); 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 // some adjustments
new TDEToolBarPopupAction(i18n("Und&o"), new TDEToolBarPopupAction(i18n("Und&o"),
@ -395,7 +395,7 @@ MarkerEditor::setupActions()
TQIconSet icon(pixmap); TQIconSet icon(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this, action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()), TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical"); actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 0) if (timeMode == 0)
@ -405,7 +405,7 @@ MarkerEditor::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this, action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()), TQ_SLOT(slotRealTime()),
actionCollection(), "time_real"); actionCollection(), "time_real");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 1) if (timeMode == 1)
@ -415,7 +415,7 @@ MarkerEditor::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this, action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()), TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw"); actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 2) 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_deleteButton ->setText(i18n("Delete"));
m_clearButton ->setText(i18n("Clear")); m_clearButton ->setText(i18n("Clear"));
connect(m_openButton, TQT_SIGNAL(clicked()), connect(m_openButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotOpenFiles())); TQ_SLOT(slotOpenFiles()));
connect(m_playButton, TQT_SIGNAL(clicked()), connect(m_playButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotPlay())); TQ_SLOT(slotPlay()));
connect(m_deleteButton, TQT_SIGNAL(clicked()), connect(m_deleteButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotDeleteCurrent())); TQ_SLOT(slotDeleteCurrent()));
connect(m_clearButton, TQT_SIGNAL(clicked()), connect(m_clearButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotClear())); TQ_SLOT(slotClear()));
connect(m_moveUpButton, TQT_SIGNAL(clicked()), connect(m_moveUpButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotMoveUp())); TQ_SLOT(slotMoveUp()));
connect(m_moveDownButton, TQT_SIGNAL(clicked()), connect(m_moveDownButton, TQ_SIGNAL(clicked()),
TQT_SLOT(slotMoveDown())); TQ_SLOT(slotMoveDown()));
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)), connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)),
TQT_SLOT(slotCurrentItemChanged(TQListViewItem*))); TQ_SLOT(slotCurrentItemChanged(TQListViewItem*)));
connect(m_listView, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)), connect(m_listView, TQ_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*))); TQ_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
restore(); restore();

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

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

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

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

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

@ -68,8 +68,8 @@ TrackLabel::TrackLabel(TrackId id,
m_pressTimer = new TQTimer(this); m_pressTimer = new TQTimer(this);
connect(m_pressTimer, TQT_SIGNAL(timeout()), connect(m_pressTimer, TQ_SIGNAL(timeout()),
this, TQT_SIGNAL(changeToInstrumentList())); this, TQ_SIGNAL(changeToInstrumentList()));
TQToolTip::add TQToolTip::add
(this, i18n("Click and hold with left mouse button to assign this Track to an Instrument.")); (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->addWidget(m_closeButton);
layout->addSpacing(5); layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()), connect(m_addButton, TQ_SIGNAL(released()),
TQT_SLOT(slotAdd())); TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()), connect(m_deleteButton, TQ_SIGNAL(released()),
TQT_SLOT(slotDelete())); TQ_SLOT(slotDelete()));
connect(m_closeButton, TQT_SIGNAL(released()), connect(m_closeButton, TQ_SIGNAL(released()),
TQT_SLOT(slotClose())); TQ_SLOT(slotClose()));
connect(m_deleteAllButton, TQT_SIGNAL(released()), connect(m_deleteAllButton, TQ_SIGNAL(released()),
TQT_SLOT(slotDeleteAll())); TQ_SLOT(slotDeleteAll()));
setupActions(); setupActions();
m_doc->getCommandHistory()->attachView(actionCollection()); m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate())); this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)), connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *))); TQ_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQT_SIGNAL(pressed(TQListViewItem *)), connect(m_listView, TQ_SIGNAL(pressed(TQListViewItem *)),
this, TQT_SLOT(slotItemClicked(TQListViewItem *))); this, TQ_SLOT(slotItemClicked(TQListViewItem *)));
// Highlight all columns - enable extended selection mode // Highlight all columns - enable extended selection mode
// //
@ -374,11 +374,11 @@ void
TriggerSegmentManager::setupActions() TriggerSegmentManager::setupActions()
{ {
TDEAction* close = KStdAction::close(this, TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
m_closeButton->setText(close->text()); 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/"); TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
@ -396,7 +396,7 @@ TriggerSegmentManager::setupActions()
KStdAction::stdName(KStdAction::Redo)); KStdAction::stdName(KStdAction::Redo));
new TDEAction(i18n("Pa&ste as New Triggered Segment"), CTRL + SHIFT + Key_V, this, 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"); "paste_to_trigger_segment");
kapp->config()->setGroup(TriggerManagerConfigGroup); kapp->config()->setGroup(TriggerManagerConfigGroup);
@ -408,7 +408,7 @@ TriggerSegmentManager::setupActions()
TQIconSet icon(pixmap); TQIconSet icon(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this, action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()), TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical"); actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 0) if (timeMode == 0)
@ -418,7 +418,7 @@ TriggerSegmentManager::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this, action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()), TQ_SLOT(slotRealTime()),
actionCollection(), "time_real"); actionCollection(), "time_real");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 1) if (timeMode == 1)
@ -428,7 +428,7 @@ TriggerSegmentManager::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this, action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()), TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw"); actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 2) 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 AudioPreviewUpdater *updater = new AudioPreviewUpdater
(*m_audioPreviewThread, m_composition, segment, segRect, this); (*m_audioPreviewThread, m_composition, segment, segRect, this);
connect(updater, TQT_SIGNAL(audioPreviewComplete(AudioPreviewUpdater*)), connect(updater, TQ_SIGNAL(audioPreviewComplete(AudioPreviewUpdater*)),
this, TQT_SLOT(slotAudioPreviewComplete(AudioPreviewUpdater*))); this, TQ_SLOT(slotAudioPreviewComplete(AudioPreviewUpdater*)));
m_audioPreviewUpdaterMap[segment] = updater; 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) { if (doc) {
m_toolBox = new SegmentToolBox(this, doc); m_toolBox = new SegmentToolBox(this, doc);
connect(m_toolBox, TQT_SIGNAL(showContextHelp(const TQString &)), connect(m_toolBox, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SLOT(slotToolHelpChanged(const TQString &))); this, TQ_SLOT(slotToolHelpChanged(const TQString &)));
} }
setDragAutoScroll(true); setDragAutoScroll(true);
@ -144,43 +144,43 @@ CompositionView::CompositionView(RosegardenGUIDoc* doc,
TQScrollBar* hsb = horizontalScrollBar(); TQScrollBar* hsb = horizontalScrollBar();
// dynamically adjust content size when scrolling past current composition's end // dynamically adjust content size when scrolling past current composition's end
connect(hsb, TQT_SIGNAL(nextLine()), connect(hsb, TQ_SIGNAL(nextLine()),
this, TQT_SLOT(scrollRight())); this, TQ_SLOT(scrollRight()));
connect(hsb, TQT_SIGNAL(prevLine()), connect(hsb, TQ_SIGNAL(prevLine()),
this, TQT_SLOT(scrollLeft())); this, TQ_SLOT(scrollLeft()));
// connect(this, TQT_SIGNAL(contentsMoving(int, int)), // connect(this, TQ_SIGNAL(contentsMoving(int, int)),
// this, TQT_SLOT(slotAllDrawBuffersNeedRefresh())); // this, TQ_SLOT(slotAllDrawBuffersNeedRefresh()));
// connect(this, TQT_SIGNAL(contentsMoving(int, int)), // connect(this, TQ_SIGNAL(contentsMoving(int, int)),
// this, TQT_SLOT(slotContentsMoving(int, int))); // this, TQ_SLOT(slotContentsMoving(int, int)));
connect(model, TQT_SIGNAL(needContentUpdate()), connect(model, TQ_SIGNAL(needContentUpdate()),
this, TQT_SLOT(slotUpdateSegmentsDrawBuffer())); this, TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(model, TQT_SIGNAL(needContentUpdate(const TQRect&)), connect(model, TQ_SIGNAL(needContentUpdate(const TQRect&)),
this, TQT_SLOT(slotUpdateSegmentsDrawBuffer(const TQRect&))); this, TQ_SLOT(slotUpdateSegmentsDrawBuffer(const TQRect&)));
connect(model, TQT_SIGNAL(needArtifactsUpdate()), connect(model, TQ_SIGNAL(needArtifactsUpdate()),
this, TQT_SLOT(slotArtifactsDrawBufferNeedsRefresh())); this, TQ_SLOT(slotArtifactsDrawBufferNeedsRefresh()));
connect(model, TQT_SIGNAL(needSizeUpdate()), connect(model, TQ_SIGNAL(needSizeUpdate()),
this, TQT_SLOT(slotUpdateSize())); this, TQ_SLOT(slotUpdateSize()));
if (doc) { if (doc) {
connect(doc, TQT_SIGNAL(docColoursChanged()), connect(doc, TQ_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotRefreshColourCache())); this, TQ_SLOT(slotRefreshColourCache()));
// recording-related signals // recording-related signals
connect(doc, TQT_SIGNAL(newMIDIRecordingSegment(Segment*)), connect(doc, TQ_SIGNAL(newMIDIRecordingSegment(Segment*)),
this, TQT_SLOT(slotNewMIDIRecordingSegment(Segment*))); this, TQ_SLOT(slotNewMIDIRecordingSegment(Segment*)));
connect(doc, TQT_SIGNAL(newAudioRecordingSegment(Segment*)), connect(doc, TQ_SIGNAL(newAudioRecordingSegment(Segment*)),
this, TQT_SLOT(slotNewAudioRecordingSegment(Segment*))); this, TQ_SLOT(slotNewAudioRecordingSegment(Segment*)));
// connect(doc, TQT_SIGNAL(recordMIDISegmentUpdated(Segment*, timeT)), // connect(doc, TQ_SIGNAL(recordMIDISegmentUpdated(Segment*, timeT)),
// this, TQT_SLOT(slotRecordMIDISegmentUpdated(Segment*, timeT))); // this, TQ_SLOT(slotRecordMIDISegmentUpdated(Segment*, timeT)));
connect(doc, TQT_SIGNAL(stoppedAudioRecording()), connect(doc, TQ_SIGNAL(stoppedAudioRecording()),
this, TQT_SLOT(slotStoppedRecording())); this, TQ_SLOT(slotStoppedRecording()));
connect(doc, TQT_SIGNAL(stoppedMIDIRecording()), connect(doc, TQ_SIGNAL(stoppedMIDIRecording()),
this, TQT_SLOT(slotStoppedRecording())); this, TQ_SLOT(slotStoppedRecording()));
connect(doc, TQT_SIGNAL(audioFileFinalized(Segment*)), connect(doc, TQ_SIGNAL(audioFileFinalized(Segment*)),
getModel(), TQT_SLOT(slotAudioFileFinalized(Segment*))); getModel(), TQ_SLOT(slotAudioFileFinalized(Segment*)));
} }
CompositionModelImpl* cmi = dynamic_cast<CompositionModelImpl*>(model); 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() void SegmentMover::ready()
{ {
m_canvas->viewport()->setCursor(TQt::sizeAllCursor); m_canvas->viewport()->setCursor(TQt::sizeAllCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
setBasicContextHelp(); setBasicContextHelp();
} }
void SegmentMover::stow() void SegmentMover::stow()
{ {
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
} }
void SegmentMover::slotCanvasScrolled(int newX, int newY) 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() void SegmentPencil::ready()
{ {
m_canvas->viewport()->setCursor(TQt::ibeamCursor); m_canvas->viewport()->setCursor(TQt::ibeamCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
setContextHelpFor(TQPoint(0, 0)); setContextHelpFor(TQPoint(0, 0));
} }
void SegmentPencil::stow() void SegmentPencil::stow()
{ {
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
} }
void SegmentPencil::slotCanvasScrolled(int newX, int newY) 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() void SegmentResizer::ready()
{ {
m_canvas->viewport()->setCursor(TQt::sizeHorCursor); m_canvas->viewport()->setCursor(TQt::sizeHorCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
setBasicContextHelp(false); setBasicContextHelp(false);
} }
void SegmentResizer::stow() void SegmentResizer::stow()
{ {
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
} }
void SegmentResizer::slotCanvasScrolled(int newX, int newY) void SegmentResizer::slotCanvasScrolled(int newX, int newY)
@ -177,10 +177,10 @@ void SegmentResizer::handleMouseButtonRelease(TQMouseEvent *e)
progressDlg.setLabel(i18n("Generating audio preview...")); progressDlg.setLabel(i18n("Generating audio preview..."));
command->disconnectProgressDialog(&progressDlg); command->disconnectProgressDialog(&progressDlg);
connect(&m_doc->getAudioFileManager(), TQT_SIGNAL(setProgress(int)), connect(&m_doc->getAudioFileManager(), TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int))); progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()), connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&m_doc->getAudioFileManager(), TQT_SLOT(slotStopPreview())); &m_doc->getAudioFileManager(), TQ_SLOT(slotStopPreview()));
int fid = command->getNewAudioFileId(); int fid = command->getNewAudioFileId();
if (fid >= 0) { if (fid >= 0) {

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

@ -74,8 +74,8 @@ SegmentSelector::~SegmentSelector()
void SegmentSelector::ready() void SegmentSelector::ready()
{ {
m_canvas->viewport()->setCursor(TQt::arrowCursor); m_canvas->viewport()->setCursor(TQt::arrowCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)), connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int))); this, TQ_SLOT(slotCanvasScrolled(int, int)));
setContextHelp(i18n("Click and drag to select segments")); 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 up
// //
connect(m_filterGroup, TQT_SIGNAL(released(int)), connect(m_filterGroup, TQ_SIGNAL(released(int)),
TQT_SLOT(slotModifyFilter(int))); TQ_SLOT(slotModifyFilter(int)));
m_list = new TDEListView(getCentralWidget()); m_list = new TDEListView(getCentralWidget());
m_list->setItemsRenameable(true); m_list->setItemsRenameable(true);
@ -106,8 +106,8 @@ TempoView::TempoView(RosegardenGUIDoc *doc, TQWidget *parent, timeT openTime):
// Connect double clicker // Connect double clicker
// //
connect(m_list, TQT_SIGNAL(doubleClicked(TQListViewItem*)), connect(m_list, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotPopupEditor(TQListViewItem*))); TQ_SLOT(slotPopupEditor(TQListViewItem*)));
m_list->setAllColumnsShowFocus(true); m_list->setAllColumnsShowFocus(true);
m_list->setSelectionMode(TQListView::Extended); m_list->setSelectionMode(TQListView::Extended);
@ -487,12 +487,12 @@ TempoView::slotEditInsertTempo()
dialog.setTempoPosition(insertTime); dialog.setTempoPosition(insertTime);
connect(&dialog, connect(&dialog,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction)), TempoDialog::TempoDialogAction)),
this, this,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction))); TempoDialog::TempoDialogAction)));
@ -577,36 +577,36 @@ TempoView::setupActions()
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png")); TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png"));
new TDEAction(AddTempoChangeCommand::getGlobalName(), icon, Key_I, this, new TDEAction(AddTempoChangeCommand::getGlobalName(), icon, Key_I, this,
TQT_SLOT(slotEditInsertTempo()), actionCollection(), TQ_SLOT(slotEditInsertTempo()), actionCollection(),
"insert_tempo"); "insert_tempo");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-insert-timesig.png"); TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-insert-timesig.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(AddTimeSignatureCommand::getGlobalName(), icon, Key_G, this, new TDEAction(AddTimeSignatureCommand::getGlobalName(), icon, Key_G, this,
TQT_SLOT(slotEditInsertTimeSignature()), actionCollection(), TQ_SLOT(slotEditInsertTimeSignature()), actionCollection(),
"insert_timesig"); "insert_timesig");
pixmap.load(pixmapDir + "/toolbar/event-delete.png"); pixmap.load(pixmapDir + "/toolbar/event-delete.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(i18n("&Delete"), icon, Key_Delete, this, new TDEAction(i18n("&Delete"), icon, Key_Delete, this,
TQT_SLOT(slotEditDelete()), actionCollection(), TQ_SLOT(slotEditDelete()), actionCollection(),
"delete"); "delete");
pixmap.load(pixmapDir + "/toolbar/event-edit.png"); pixmap.load(pixmapDir + "/toolbar/event-edit.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(i18n("&Edit Item"), icon, Key_E, this, new TDEAction(i18n("&Edit Item"), icon, Key_E, this,
TQT_SLOT(slotEdit()), actionCollection(), TQ_SLOT(slotEdit()), actionCollection(),
"edit"); "edit");
new TDEAction(i18n("Select &All"), 0, this, new TDEAction(i18n("Select &All"), 0, this,
TQT_SLOT(slotSelectAll()), actionCollection(), TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all"); "select_all");
new TDEAction(i18n("Clear Selection"), Key_Escape, this, new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQT_SLOT(slotClearSelection()), actionCollection(), TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection"); "clear_selection");
m_config->setGroup(TempoViewConfigGroup); m_config->setGroup(TempoViewConfigGroup);
@ -618,7 +618,7 @@ TempoView::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this, action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQT_SLOT(slotMusicalTime()), TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical"); actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 0) if (timeMode == 0)
@ -628,7 +628,7 @@ TempoView::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this, action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQT_SLOT(slotRealTime()), TQ_SLOT(slotRealTime()),
actionCollection(), "time_real"); actionCollection(), "time_real");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 1) if (timeMode == 1)
@ -638,7 +638,7 @@ TempoView::setupActions()
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this, action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQT_SLOT(slotRawTime()), TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw"); actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode"); action->setExclusiveGroup("timeMode");
if (timeMode == 2) if (timeMode == 2)
@ -784,12 +784,12 @@ TempoView::slotPopupEditor(TQListViewItem *qitem)
dialog.setTempoPosition(time); dialog.setTempoPosition(time);
connect(&dialog, connect(&dialog,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction)), TempoDialog::TempoDialogAction)),
this, this,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction))); 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); if (!tool) tool = createTool(toolName);
connect(tool, TQT_SIGNAL(showContextHelp(const TQString &)), connect(tool, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SIGNAL(showContextHelp(const TQString &))); this, TQ_SIGNAL(showContextHelp(const TQString &)));
return tool; 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->setHoverCloseButton(true);
m_controlRulers->setHoverCloseButtonDelayed(false); m_controlRulers->setHoverCloseButtonDelayed(false);
connect(m_controlRulers, TQT_SIGNAL(closeRequest(TQWidget*)), connect(m_controlRulers, TQ_SIGNAL(closeRequest(TQWidget*)),
this, TQT_SLOT(slotRemoveControlRuler(TQWidget*))); this, TQ_SLOT(slotRemoveControlRuler(TQWidget*)));
(dynamic_cast<TQBoxLayout*>(m_bottomBox->layout()))->setDirection(TQBoxLayout::BottomToTop); (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); m_grid->addLayout(gl, TOPBARBUTTONS_ROW, m_mainCol);
if (m_canvasView) { if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int))); m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int))); m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
} }
} }
@ -296,10 +296,10 @@ void EditView::setBottomStandardRuler(StandardRuler* w)
// m_bottomBox->insertWidget(0, w); // m_bottomBox->insertWidget(0, w);
if (m_canvasView) { if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int))); m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int))); m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
} }
} }
@ -343,10 +343,10 @@ void EditView::addRuler(TQWidget* w)
m_rulerBox->addWidget(w); m_rulerBox->addWidget(w);
if (m_canvasView) { if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
w, TQT_SLOT(slotScrollHoriz(int))); w, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
w, TQT_SLOT(slotScrollHoriz(int))); w, TQ_SLOT(slotScrollHoriz(int)));
} }
} }
@ -363,14 +363,14 @@ void EditView::addControlRuler(ControlRuler* ruler)
m_controlRulers->showPage(ruler); m_controlRulers->showPage(ruler);
if (m_canvasView) { if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
ruler->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int))); ruler->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)), connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
ruler->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int))); ruler->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)));
} }
connect(ruler, TQT_SIGNAL(stateChange(const TQString&, bool)), connect(ruler, TQ_SIGNAL(stateChange(const TQString&, bool)),
this, TQT_SLOT(slotStateChanged(const TQString&, bool))); this, TQ_SLOT(slotStateChanged(const TQString&, bool)));
stateChanged("have_control_ruler", KXMLGUIClient::StateReverse); stateChanged("have_control_ruler", KXMLGUIClient::StateReverse);
} }
@ -424,10 +424,10 @@ void EditView::setCanvasView(RosegardenCanvasView *canvasView)
// m_horizontalScrollBar->setSteps(m_canvasView->horizontalScrollBar()->lineStep(), // m_horizontalScrollBar->setSteps(m_canvasView->horizontalScrollBar()->lineStep(),
// m_canvasView->horizontalScrollBar()->pageStep()); // m_canvasView->horizontalScrollBar()->pageStep());
// connect(m_horizontalScrollBar, TQT_SIGNAL(valueChanged(int)), // connect(m_horizontalScrollBar, TQ_SIGNAL(valueChanged(int)),
// m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int))); // m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)));
// connect(m_horizontalScrollBar, TQT_SIGNAL(sliderMoved(int)), // connect(m_horizontalScrollBar, TQ_SIGNAL(sliderMoved(int)),
// m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int))); // m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)));
} }
@ -726,132 +726,132 @@ EditView::setupActions()
TQIconSet icon = TQIconSet(pixmap); TQIconSet icon = TQIconSet(pixmap);
new TDEAction(AddTempoChangeCommand::getGlobalName(), new TDEAction(AddTempoChangeCommand::getGlobalName(),
icon, 0, icon, 0,
this, TQT_SLOT(slotAddTempo()), this, TQ_SLOT(slotAddTempo()),
actionCollection(), "add_tempo"); actionCollection(), "add_tempo");
pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png"); pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png");
icon = TQIconSet(pixmap); icon = TQIconSet(pixmap);
new TDEAction(AddTimeSignatureCommand::getGlobalName(), new TDEAction(AddTimeSignatureCommand::getGlobalName(),
icon, 0, icon, 0,
this, TQT_SLOT(slotAddTimeSignature()), this, TQ_SLOT(slotAddTimeSignature()),
actionCollection(), "add_time_signature"); actionCollection(), "add_time_signature");
// //
// Transforms // Transforms
// //
new TDEAction(i18n("&Halve Durations"), Key_H + CTRL, this, new TDEAction(i18n("&Halve Durations"), Key_H + CTRL, this,
TQT_SLOT(slotHalveDurations()), actionCollection(), TQ_SLOT(slotHalveDurations()), actionCollection(),
"halve_durations"); "halve_durations");
new TDEAction(i18n("&Double Durations"), Key_H + CTRL + SHIFT, this, new TDEAction(i18n("&Double Durations"), Key_H + CTRL + SHIFT, this,
TQT_SLOT(slotDoubleDurations()), actionCollection(), TQ_SLOT(slotDoubleDurations()), actionCollection(),
"double_durations"); "double_durations");
new TDEAction(RescaleCommand::getGlobalName(), 0, this, new TDEAction(RescaleCommand::getGlobalName(), 0, this,
TQT_SLOT(slotRescale()), actionCollection(), TQ_SLOT(slotRescale()), actionCollection(),
"rescale"); "rescale");
new TDEAction(TransposeCommand::getGlobalName(1), 0, new TDEAction(TransposeCommand::getGlobalName(1), 0,
Key_Up, this, Key_Up, this,
TQT_SLOT(slotTransposeUp()), actionCollection(), TQ_SLOT(slotTransposeUp()), actionCollection(),
"transpose_up"); "transpose_up");
new TDEAction(TransposeCommand::getGlobalName(12), 0, new TDEAction(TransposeCommand::getGlobalName(12), 0,
Key_Up + CTRL, this, Key_Up + CTRL, this,
TQT_SLOT(slotTransposeUpOctave()), actionCollection(), TQ_SLOT(slotTransposeUpOctave()), actionCollection(),
"transpose_up_octave"); "transpose_up_octave");
new TDEAction(TransposeCommand::getGlobalName( -1), 0, new TDEAction(TransposeCommand::getGlobalName( -1), 0,
Key_Down, this, Key_Down, this,
TQT_SLOT(slotTransposeDown()), actionCollection(), TQ_SLOT(slotTransposeDown()), actionCollection(),
"transpose_down"); "transpose_down");
new TDEAction(TransposeCommand::getGlobalName( -12), 0, new TDEAction(TransposeCommand::getGlobalName( -12), 0,
Key_Down + CTRL, this, Key_Down + CTRL, this,
TQT_SLOT(slotTransposeDownOctave()), actionCollection(), TQ_SLOT(slotTransposeDownOctave()), actionCollection(),
"transpose_down_octave"); "transpose_down_octave");
new TDEAction(TransposeCommand::getGlobalName(0), 0, this, new TDEAction(TransposeCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotTranspose()), actionCollection(), TQ_SLOT(slotTranspose()), actionCollection(),
"general_transpose"); "general_transpose");
new TDEAction(TransposeCommand::getDiatonicGlobalName(0,0), 0, this, new TDEAction(TransposeCommand::getDiatonicGlobalName(0,0), 0, this,
TQT_SLOT(slotDiatonicTranspose()), actionCollection(), TQ_SLOT(slotDiatonicTranspose()), actionCollection(),
"general_diatonic_transpose"); "general_diatonic_transpose");
new TDEAction(InvertCommand::getGlobalName(0), 0, this, new TDEAction(InvertCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotInvert()), actionCollection(), TQ_SLOT(slotInvert()), actionCollection(),
"invert"); "invert");
new TDEAction(RetrogradeCommand::getGlobalName(0), 0, this, new TDEAction(RetrogradeCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotRetrograde()), actionCollection(), TQ_SLOT(slotRetrograde()), actionCollection(),
"retrograde"); "retrograde");
new TDEAction(RetrogradeInvertCommand::getGlobalName(0), 0, this, new TDEAction(RetrogradeInvertCommand::getGlobalName(0), 0, this,
TQT_SLOT(slotRetrogradeInvert()), actionCollection(), TQ_SLOT(slotRetrogradeInvert()), actionCollection(),
"retrograde_invert"); "retrograde_invert");
new TDEAction(i18n("Jog &Left"), Key_Left + ALT, this, new TDEAction(i18n("Jog &Left"), Key_Left + ALT, this,
TQT_SLOT(slotJogLeft()), actionCollection(), TQ_SLOT(slotJogLeft()), actionCollection(),
"jog_left"); "jog_left");
new TDEAction(i18n("Jog &Right"), Key_Right + ALT, this, new TDEAction(i18n("Jog &Right"), Key_Right + ALT, this,
TQT_SLOT(slotJogRight()), actionCollection(), TQ_SLOT(slotJogRight()), actionCollection(),
"jog_right"); "jog_right");
// Control rulers // Control rulers
// //
new TDEAction(i18n("Show Velocity Property Ruler"), 0, this, new TDEAction(i18n("Show Velocity Property Ruler"), 0, this,
TQT_SLOT(slotShowVelocityControlRuler()), actionCollection(), TQ_SLOT(slotShowVelocityControlRuler()), actionCollection(),
"show_velocity_control_ruler"); "show_velocity_control_ruler");
/* /*
new TDEAction(i18n("Show Controllers Events Ruler"), 0, this, new TDEAction(i18n("Show Controllers Events Ruler"), 0, this,
TQT_SLOT(slotShowControllerEventsRuler()), actionCollection(), TQ_SLOT(slotShowControllerEventsRuler()), actionCollection(),
"show_controller_events_ruler"); "show_controller_events_ruler");
*/ */
// Disabled for now // Disabled for now
// //
// new TDEAction(i18n("Add Control Ruler..."), 0, this, // new TDEAction(i18n("Add Control Ruler..."), 0, this,
// TQT_SLOT(slotShowPropertyControlRuler()), actionCollection(), // TQ_SLOT(slotShowPropertyControlRuler()), actionCollection(),
// "add_control_ruler"); // "add_control_ruler");
// //
// Control Ruler context menu // Control Ruler context menu
// //
new TDEAction(i18n("Insert item"), 0, this, new TDEAction(i18n("Insert item"), 0, this,
TQT_SLOT(slotInsertControlRulerItem()), actionCollection(), TQ_SLOT(slotInsertControlRulerItem()), actionCollection(),
"insert_control_ruler_item"); "insert_control_ruler_item");
// This was on Key_Delete, but that conflicts with existing Delete commands // This was on Key_Delete, but that conflicts with existing Delete commands
// on individual edit views // on individual edit views
new TDEAction(i18n("Erase selected items"), 0, this, new TDEAction(i18n("Erase selected items"), 0, this,
TQT_SLOT(slotEraseControlRulerItem()), actionCollection(), TQ_SLOT(slotEraseControlRulerItem()), actionCollection(),
"erase_control_ruler_item"); "erase_control_ruler_item");
new TDEAction(i18n("Clear ruler"), 0, this, new TDEAction(i18n("Clear ruler"), 0, this,
TQT_SLOT(slotClearControlRulerItem()), actionCollection(), TQ_SLOT(slotClearControlRulerItem()), actionCollection(),
"clear_control_ruler_item"); "clear_control_ruler_item");
new TDEAction(i18n("Insert line of controllers"), 0, this, new TDEAction(i18n("Insert line of controllers"), 0, this,
TQT_SLOT(slotStartControlLineItem()), actionCollection(), TQ_SLOT(slotStartControlLineItem()), actionCollection(),
"start_control_line_item"); "start_control_line_item");
new TDEAction(i18n("Flip forward"), Key_BracketRight, this, new TDEAction(i18n("Flip forward"), Key_BracketRight, this,
TQT_SLOT(slotFlipForwards()), actionCollection(), TQ_SLOT(slotFlipForwards()), actionCollection(),
"flip_control_events_forward"); "flip_control_events_forward");
new TDEAction(i18n("Flip backwards"), Key_BracketLeft, this, new TDEAction(i18n("Flip backwards"), Key_BracketLeft, this,
TQT_SLOT(slotFlipBackwards()), actionCollection(), TQ_SLOT(slotFlipBackwards()), actionCollection(),
"flip_control_events_back"); "flip_control_events_back");
new TDEAction(i18n("Draw property line"), 0, this, new TDEAction(i18n("Draw property line"), 0, this,
TQT_SLOT(slotDrawPropertyLine()), actionCollection(), TQ_SLOT(slotDrawPropertyLine()), actionCollection(),
"draw_property_line"); "draw_property_line");
new TDEAction(i18n("Select all property values"), 0, this, new TDEAction(i18n("Select all property values"), 0, this,
TQT_SLOT(slotSelectAllProperties()), actionCollection(), TQ_SLOT(slotSelectAllProperties()), actionCollection(),
"select_all_properties"); "select_all_properties");
} }
@ -901,8 +901,8 @@ EditView::setupAddControlRulerMenu()
addControlRulerMenu->insertItem(itemStr, i++); addControlRulerMenu->insertItem(itemStr, i++);
} }
connect(addControlRulerMenu, TQT_SIGNAL(activated(int)), connect(addControlRulerMenu, TQ_SIGNAL(activated(int)),
TQT_SLOT(slotAddControlRuler(int))); TQ_SLOT(slotAddControlRuler(int)));
} }
} }
@ -1114,7 +1114,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction new TDEAction
(flat.arg(notePitchNames[i]), (flat.arg(notePitchNames[i]),
CTRL + SHIFT + notePitchKeys[octave][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()); TQString("insert_%1_flat%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction); menu->insert(insertPitchAction);
@ -1124,7 +1124,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction new TDEAction
(notePitchNames[i], (notePitchNames[i],
notePitchKeys[octave][i], notePitchKeys[octave][i],
this, TQT_SLOT(slotInsertNoteFromAction()), actionCollection(), this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1%2").arg(i).arg(octaveSuffix).ascii()); TQString("insert_%1%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction); menu->insert(insertPitchAction);
@ -1137,7 +1137,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction new TDEAction
(sharp.arg(notePitchNames[i]), (sharp.arg(notePitchNames[i]),
SHIFT + notePitchKeys[octave][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()); TQString("insert_%1_sharp%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction); menu->insert(insertPitchAction);
@ -1218,12 +1218,12 @@ void EditView::slotAddTempo()
TempoDialog tempoDlg(this, getDocument()); TempoDialog tempoDlg(this, getDocument());
connect(&tempoDlg, connect(&tempoDlg,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction)), TempoDialog::TempoDialogAction)),
this, this,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction))); TempoDialog::TempoDialogAction)));

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

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

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

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

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

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

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

@ -64,8 +64,8 @@ RosegardenScrollView::RosegardenScrollView(TQWidget* parent,
m_autoScrolling(false) m_autoScrolling(false)
{ {
setDragAutoScroll(true); setDragAutoScroll(true);
connect( &m_autoScrollTimer, TQT_SIGNAL( timeout() ), connect( &m_autoScrollTimer, TQ_SIGNAL( timeout() ),
this, TQT_SLOT( doAutoScroll() ) ); this, TQ_SLOT( doAutoScroll() ) );
} }
void RosegardenScrollView::setBottomFixedWidget(TQWidget* w) 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(); m_compositionRefreshStatusId = m_composition->getNewRefreshStatusId();
TQObject::connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), TQObject::connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(update())); this, TQ_SLOT(update()));
TQToolTip::add TQToolTip::add
(this, i18n("Chord name ruler.\nTurn it on and off from the Settings->Rulers menu.")); (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(); m_compositionRefreshStatusId = m_composition->getNewRefreshStatusId();
TQObject::connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), TQObject::connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(update())); this, TQ_SLOT(update()));
for (std::vector<Segment *>::iterator i = segments.begin(); for (std::vector<Segment *>::iterator i = segments.begin();
i != segments.end(); ++i) { i != segments.end(); ++i) {

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

@ -86,8 +86,8 @@ ControlRuler::ControlRuler(Segment *segment,
setFixedHeight(sizeHint().height()); setFixedHeight(sizeHint().height());
connect(this, TQT_SIGNAL(stateChange(const TQString&, bool)), connect(this, TQ_SIGNAL(stateChange(const TQString&, bool)),
m_parentEditView, TQT_SLOT(slotStateChanged(const TQString&, bool))); m_parentEditView, TQ_SLOT(slotStateChanged(const TQString&, bool)));
m_numberFloat = new TextFloat(this); m_numberFloat = new TextFloat(this);
m_numberFloat->hide(); 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")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert.png"));
new TDEAction(i18n("Insert Marker"), icon, 0, this, new TDEAction(i18n("Insert Marker"), icon, 0, this,
TQT_SLOT(slotInsertMarkerHere()), actionCollection(), TQ_SLOT(slotInsertMarkerHere()), actionCollection(),
"insert_marker_here"); "insert_marker_here");
new TDEAction(i18n("Insert Marker at Playback Position"), 0, this, new TDEAction(i18n("Insert Marker at Playback Position"), 0, this,
TQT_SLOT(slotInsertMarkerAtPointer()), actionCollection(), TQ_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
"insert_marker_at_pointer"); "insert_marker_at_pointer");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png"));
new TDEAction(i18n("Delete Marker"), icon, 0, this, new TDEAction(i18n("Delete Marker"), icon, 0, this,
TQT_SLOT(slotDeleteMarker()), actionCollection(), TQ_SLOT(slotDeleteMarker()), actionCollection(),
"delete_marker"); "delete_marker");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png"));
new TDEAction(i18n("Edit Marker..."), icon, 0, this, new TDEAction(i18n("Edit Marker..."), icon, 0, this,
TQT_SLOT(slotEditMarker()), actionCollection(), TQ_SLOT(slotEditMarker()), actionCollection(),
"edit_marker"); "edit_marker");
TQToolTip::add TQToolTip::add

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

@ -74,8 +74,8 @@ StandardRuler::StandardRuler(RosegardenGUIDoc *doc,
} }
TQObject::connect TQObject::connect
(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), (doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(update())); 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 // so they are re-emitted from the loop ruler by this widget
// //
TQObject::connect TQObject::connect
(m_loopRuler, TQT_SIGNAL(setPointerPosition(timeT)), (m_loopRuler, TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT))); doc, TQ_SLOT(slotSetPointerPosition(timeT)));
TQObject::connect TQObject::connect
(m_hButtonBar, TQT_SIGNAL(setPointerPosition(timeT)), (m_hButtonBar, TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT))); doc, TQ_SLOT(slotSetPointerPosition(timeT)));
TQObject::connect TQObject::connect
(m_hButtonBar, TQT_SIGNAL(editMarkers()), (m_hButtonBar, TQ_SIGNAL(editMarkers()),
RosegardenGUIApp::self(), TQT_SLOT(slotEditMarkers())); RosegardenGUIApp::self(), TQ_SLOT(slotEditMarkers()));
TQObject::connect TQObject::connect
(m_hButtonBar, TQT_SIGNAL(addMarker(timeT)), (m_hButtonBar, TQ_SIGNAL(addMarker(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotAddMarker(timeT))); RosegardenGUIApp::self(), TQ_SLOT(slotAddMarker(timeT)));
TQObject::connect TQObject::connect
(m_hButtonBar, TQT_SIGNAL(deleteMarker(int, timeT, TQString, TQString)), (m_hButtonBar, TQ_SIGNAL(deleteMarker(int, timeT, TQString, TQString)),
RosegardenGUIApp::self(), TQT_SLOT(slotDeleteMarker(int, timeT, TQString, TQString))); RosegardenGUIApp::self(), TQ_SLOT(slotDeleteMarker(int, timeT, TQString, TQString)));
TQObject::connect TQObject::connect
(m_loopRuler, TQT_SIGNAL(dragPointerToPosition(timeT)), (m_loopRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SIGNAL(dragPointerToPosition(timeT))); this, TQ_SIGNAL(dragPointerToPosition(timeT)));
TQObject::connect TQObject::connect
(m_loopRuler, TQT_SIGNAL(dragLoopToPosition(timeT)), (m_loopRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SIGNAL(dragLoopToPosition(timeT))); this, TQ_SIGNAL(dragLoopToPosition(timeT)));
TQObject::connect TQObject::connect
(m_loopRuler, TQT_SIGNAL(setPlayPosition(timeT)), (m_loopRuler, TQ_SIGNAL(setPlayPosition(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotSetPlayPosition(timeT))); RosegardenGUIApp::self(), TQ_SLOT(slotSetPlayPosition(timeT)));
TQObject::connect TQObject::connect
(m_hButtonBar, TQT_SIGNAL(setLoop(timeT, timeT)), (m_hButtonBar, TQ_SIGNAL(setLoop(timeT, timeT)),
doc, TQT_SLOT(slotSetLoop(timeT, timeT))); doc, TQ_SLOT(slotSetLoop(timeT, timeT)));
TQObject::connect TQObject::connect
(m_loopRuler, TQT_SIGNAL(setLoop(timeT, timeT)), (m_loopRuler, TQ_SIGNAL(setLoop(timeT, timeT)),
doc, TQT_SLOT(slotSetLoop(timeT, timeT))); doc, TQ_SLOT(slotSetLoop(timeT, timeT)));
TQObject::connect TQObject::connect
(doc, TQT_SIGNAL(loopChanged(timeT, timeT)), (doc, TQ_SIGNAL(loopChanged(timeT, timeT)),
m_loopRuler, m_loopRuler,
TQT_SLOT(slotSetLoopMarker(timeT, timeT))); TQ_SLOT(slotSetLoopMarker(timeT, timeT)));
m_loopRuler->setBackgroundColor(GUIPalette::getColour(GUIPalette::PointerRuler)); 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); setBackgroundMode(TQt::NoBackground);
TQObject::connect TQObject::connect
(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), (doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(update())); this, TQ_SLOT(update()));
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/"); TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
TQIconSet icon; TQIconSet icon;
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png"));
new TDEAction(i18n("Insert Tempo Change"), icon, 0, this, new TDEAction(i18n("Insert Tempo Change"), icon, 0, this,
TQT_SLOT(slotInsertTempoHere()), actionCollection(), TQ_SLOT(slotInsertTempoHere()), actionCollection(),
"insert_tempo_here"); "insert_tempo_here");
new TDEAction(i18n("Insert Tempo Change at Playback Position"), 0, 0, this, new TDEAction(i18n("Insert Tempo Change at Playback Position"), 0, 0, this,
TQT_SLOT(slotInsertTempoAtPointer()), actionCollection(), TQ_SLOT(slotInsertTempoAtPointer()), actionCollection(),
"insert_tempo_at_pointer"); "insert_tempo_at_pointer");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png"));
new TDEAction(i18n("Delete Tempo Change"), icon, 0, this, new TDEAction(i18n("Delete Tempo Change"), icon, 0, this,
TQT_SLOT(slotDeleteTempoChange()), actionCollection(), TQ_SLOT(slotDeleteTempoChange()), actionCollection(),
"delete_tempo"); "delete_tempo");
new TDEAction(i18n("Ramp Tempo to Next Tempo"), 0, 0, this, new TDEAction(i18n("Ramp Tempo to Next Tempo"), 0, 0, this,
TQT_SLOT(slotRampToNext()), actionCollection(), TQ_SLOT(slotRampToNext()), actionCollection(),
"ramp_to_next"); "ramp_to_next");
new TDEAction(i18n("Un-Ramp Tempo"), 0, 0, this, new TDEAction(i18n("Un-Ramp Tempo"), 0, 0, this,
TQT_SLOT(slotUnramp()), actionCollection(), TQ_SLOT(slotUnramp()), actionCollection(),
"unramp"); "unramp");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png")); icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png"));
new TDEAction(i18n("Edit Tempo..."), icon, 0, this, new TDEAction(i18n("Edit Tempo..."), icon, 0, this,
TQT_SLOT(slotEditTempo()), actionCollection(), TQ_SLOT(slotEditTempo()), actionCollection(),
"edit_tempo"); "edit_tempo");
new TDEAction(i18n("Edit Time Signature..."), 0, 0, this, new TDEAction(i18n("Edit Time Signature..."), 0, 0, this,
TQT_SLOT(slotEditTimeSignature()), actionCollection(), TQ_SLOT(slotEditTimeSignature()), actionCollection(),
"edit_time_signature"); "edit_time_signature");
new TDEAction(i18n("Open Tempo and Time Signature Editor"), 0, 0, this, new TDEAction(i18n("Open Tempo and Time Signature Editor"), 0, 0, this,
TQT_SLOT(slotEditTempos()), actionCollection(), TQ_SLOT(slotEditTempos()), actionCollection(),
"edit_tempos"); "edit_tempos");
setMouseTracking(false); setMouseTracking(false);
@ -172,47 +172,47 @@ void
TempoRuler::connectSignals() TempoRuler::connectSignals()
{ {
connect(this, connect(this,
TQT_SIGNAL(doubleClicked(timeT)), TQ_SIGNAL(doubleClicked(timeT)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempos(timeT))); TQ_SLOT(slotEditTempos(timeT)));
connect(this, connect(this,
TQT_SIGNAL(changeTempo(timeT, TQ_SIGNAL(changeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction)), TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotChangeTempo(timeT, TQ_SLOT(slotChangeTempo(timeT,
tempoT, tempoT,
tempoT, tempoT,
TempoDialog::TempoDialogAction))); TempoDialog::TempoDialogAction)));
connect(this, connect(this,
TQT_SIGNAL(moveTempo(timeT, TQ_SIGNAL(moveTempo(timeT,
timeT)), timeT)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotMoveTempo(timeT, TQ_SLOT(slotMoveTempo(timeT,
timeT))); timeT)));
connect(this, connect(this,
TQT_SIGNAL(deleteTempo(timeT)), TQ_SIGNAL(deleteTempo(timeT)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotDeleteTempo(timeT))); TQ_SLOT(slotDeleteTempo(timeT)));
connect(this, connect(this,
TQT_SIGNAL(editTempo(timeT)), TQ_SIGNAL(editTempo(timeT)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempo(timeT))); TQ_SLOT(slotEditTempo(timeT)));
connect(this, connect(this,
TQT_SIGNAL(editTimeSignature(timeT)), TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotEditTimeSignature(timeT))); TQ_SLOT(slotEditTimeSignature(timeT)));
connect(this, connect(this,
TQT_SIGNAL(editTempos(timeT)), TQ_SIGNAL(editTempos(timeT)),
RosegardenGUIApp::self(), RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempos(timeT))); TQ_SLOT(slotEditTempos(timeT)));
} }
void void

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

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

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

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

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

@ -95,13 +95,13 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
populate(); populate();
KStdAction::close(this, KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play"))); ("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this, TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQT_SIGNAL(play()), actionCollection(), "play"); TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play // Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut(); TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) ); playShortcut.append( KKey(Key_Return + CTRL) );
@ -110,68 +110,68 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop"))); ("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, this, new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQT_SIGNAL(stop()), actionCollection(), "stop"); TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind"))); ("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, this, new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQT_SIGNAL(rewindPlayback()), actionCollection(), TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar"); "playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd"))); ("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this, new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQT_SIGNAL(fastForwardPlayback()), actionCollection(), TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar"); "playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end"))); ("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this, new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(), TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start"); "playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end"))); ("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this, new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(), TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end"); "playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-record"))); ("transport-record")));
new TDEAction(i18n("&Record"), icon, 0, this, new TDEAction(i18n("&Record"), icon, 0, this,
TQT_SIGNAL(record()), actionCollection(), TQ_SIGNAL(record()), actionCollection(),
"record"); "record");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic"))); ("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this, new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQT_SIGNAL(panic()), actionCollection(), TQ_SIGNAL(panic()), actionCollection(),
"panic"); "panic");
unsigned int mixerOptions = m_studio->getMixerDisplayOptions(); unsigned int mixerOptions = m_studio->getMixerDisplayOptions();
(new TDEToggleAction(i18n("Show Audio &Faders"), 0, this, (new TDEToggleAction(i18n("Show Audio &Faders"), 0, this,
TQT_SLOT(slotToggleFaders()), actionCollection(), TQ_SLOT(slotToggleFaders()), actionCollection(),
"show_audio_faders"))->setChecked "show_audio_faders"))->setChecked
(!(mixerOptions & MIXER_OMIT_FADERS)); (!(mixerOptions & MIXER_OMIT_FADERS));
(new TDEToggleAction(i18n("Show Synth &Faders"), 0, this, (new TDEToggleAction(i18n("Show Synth &Faders"), 0, this,
TQT_SLOT(slotToggleSynthFaders()), actionCollection(), TQ_SLOT(slotToggleSynthFaders()), actionCollection(),
"show_synth_faders"))->setChecked "show_synth_faders"))->setChecked
(!(mixerOptions & MIXER_OMIT_SYNTH_FADERS)); (!(mixerOptions & MIXER_OMIT_SYNTH_FADERS));
(new TDEToggleAction(i18n("Show &Submasters"), 0, this, (new TDEToggleAction(i18n("Show &Submasters"), 0, this,
TQT_SLOT(slotToggleSubmasters()), actionCollection(), TQ_SLOT(slotToggleSubmasters()), actionCollection(),
"show_audio_submasters"))->setChecked "show_audio_submasters"))->setChecked
(!(mixerOptions & MIXER_OMIT_SUBMASTERS)); (!(mixerOptions & MIXER_OMIT_SUBMASTERS));
(new TDEToggleAction(i18n("Show &Plugin Buttons"), 0, this, (new TDEToggleAction(i18n("Show &Plugin Buttons"), 0, this,
TQT_SLOT(slotTogglePluginButtons()), actionCollection(), TQ_SLOT(slotTogglePluginButtons()), actionCollection(),
"show_plugin_buttons"))->setChecked "show_plugin_buttons"))->setChecked
(!(mixerOptions & MIXER_OMIT_PLUGINS)); (!(mixerOptions & MIXER_OMIT_PLUGINS));
(new TDEToggleAction(i18n("Show &Unassigned Faders"), 0, this, (new TDEToggleAction(i18n("Show &Unassigned Faders"), 0, this,
TQT_SLOT(slotToggleUnassignedFaders()), actionCollection(), TQ_SLOT(slotToggleUnassignedFaders()), actionCollection(),
"show_unassigned_faders"))->setChecked "show_unassigned_faders"))->setChecked
(mixerOptions & MIXER_SHOW_UNASSIGNED_FADERS); (mixerOptions & MIXER_SHOW_UNASSIGNED_FADERS);
@ -181,7 +181,7 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action = action =
new TDERadioAction(i18n("1 Input", "%n Inputs", i), new TDERadioAction(i18n("1 Input", "%n Inputs", i),
0, this, 0, this,
TQT_SLOT(slotSetInputCountFromAction()), actionCollection(), TQ_SLOT(slotSetInputCountFromAction()), actionCollection(),
TQString("inputs_%1").arg(i).ascii()); TQString("inputs_%1").arg(i).ascii());
action->setExclusiveGroup("inputs"); action->setExclusiveGroup("inputs");
if (i == int(m_studio->getRecordIns().size())) if (i == int(m_studio->getRecordIns().size()))
@ -191,7 +191,7 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action = new TDERadioAction action = new TDERadioAction
(i18n("No Submasters"), (i18n("No Submasters"),
0, this, 0, this,
TQT_SLOT(slotSetSubmasterCountFromAction()), actionCollection(), TQ_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQString("submasters_0").ascii()); TQString("submasters_0").ascii());
action->setExclusiveGroup("submasters"); action->setExclusiveGroup("submasters");
action->setChecked(true); action->setChecked(true);
@ -200,7 +200,7 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action = new TDERadioAction action = new TDERadioAction
(i18n("1 Submaster", "%n Submasters", i), (i18n("1 Submaster", "%n Submasters", i),
0, this, 0, this,
TQT_SLOT(slotSetSubmasterCountFromAction()), actionCollection(), TQ_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQString("submasters_%1").arg(i).ascii()); TQString("submasters_%1").arg(i).ascii());
action->setExclusiveGroup("submasters"); action->setExclusiveGroup("submasters");
if (i == int(m_studio->getBusses().size()) - 1) if (i == int(m_studio->getBusses().size()) - 1)
@ -388,8 +388,8 @@ AudioMixerWindow::populate()
TQToolTip::add TQToolTip::add
(plugin, i18n("Audio plugin button")); (plugin, i18n("Audio plugin button"));
rec.m_plugins.push_back(plugin); rec.m_plugins.push_back(plugin);
connect(plugin, TQT_SIGNAL(clicked()), connect(plugin, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSelectPlugin())); this, TQ_SLOT(slotSelectPlugin()));
} }
TQLabel *idLabel; TQLabel *idLabel;
@ -441,30 +441,30 @@ AudioMixerWindow::populate()
updatePluginButtons((*i)->getId()); updatePluginButtons((*i)->getId());
if (rec.m_input) { if (rec.m_input) {
connect(rec.m_input, TQT_SIGNAL(changed()), connect(rec.m_input, TQ_SIGNAL(changed()),
this, TQT_SLOT(slotInputChanged())); this, TQ_SLOT(slotInputChanged()));
} }
connect(rec.m_output, TQT_SIGNAL(changed()), connect(rec.m_output, TQ_SIGNAL(changed()),
this, TQT_SLOT(slotOutputChanged())); this, TQ_SLOT(slotOutputChanged()));
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)), connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float))); this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_pan, TQT_SIGNAL(valueChanged(float)), connect(rec.m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPanChanged(float))); this, TQ_SLOT(slotPanChanged(float)));
connect(rec.m_soloButton, TQT_SIGNAL(clicked()), connect(rec.m_soloButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSoloChanged())); this, TQ_SLOT(slotSoloChanged()));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()), connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged())); this, TQ_SLOT(slotMuteChanged()));
connect(rec.m_stereoButton, TQT_SIGNAL(clicked()), connect(rec.m_stereoButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotChannelsChanged())); this, TQ_SLOT(slotChannelsChanged()));
connect(rec.m_recordButton, TQT_SIGNAL(clicked()), connect(rec.m_recordButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotRecordChanged())); this, TQ_SLOT(slotRecordChanged()));
++count; ++count;
@ -519,8 +519,8 @@ AudioMixerWindow::populate()
TQToolTip::add TQToolTip::add
(plugin, i18n("Audio plugin button")); (plugin, i18n("Audio plugin button"));
rec.m_plugins.push_back(plugin); rec.m_plugins.push_back(plugin);
connect(plugin, TQT_SIGNAL(clicked()), connect(plugin, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotSelectPlugin())); this, TQ_SLOT(slotSelectPlugin()));
} }
TQLabel *idLabel = new TQLabel(i18n("Sub %1").arg(count), m_mainBox, "subMaster"); TQLabel *idLabel = new TQLabel(i18n("Sub %1").arg(count), m_mainBox, "subMaster");
@ -546,14 +546,14 @@ AudioMixerWindow::populate()
updateFader(count); updateFader(count);
updatePluginButtons(count); updatePluginButtons(count);
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)), connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float))); this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_pan, TQT_SIGNAL(valueChanged(float)), connect(rec.m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPanChanged(float))); this, TQ_SLOT(slotPanChanged(float)));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()), connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged())); this, TQ_SLOT(slotMuteChanged()));
++count; ++count;
@ -597,11 +597,11 @@ AudioMixerWindow::populate()
m_master = rec; m_master = rec;
updateFader(0); updateFader(0);
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)), connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float))); this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()), connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged())); this, TQ_SLOT(slotMuteChanged()));
} }
m_mainBox->show(); 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->addWidget(m_closeButton);
layout->addSpacing(5); layout->addSpacing(5);
connect(m_applyButton, TQT_SIGNAL(clicked()), connect(m_applyButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotApply())); this, TQ_SLOT(slotApply()));
connect(m_resetButton, TQT_SIGNAL(clicked()), connect(m_resetButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotReset())); this, TQ_SLOT(slotReset()));
// //
// Left-side list view // Left-side list view
@ -191,8 +191,8 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
(m_pastePrograms, (m_pastePrograms,
i18n("Paste Program names from clipboard to current Bank")); i18n("Paste Program names from clipboard to current Bank"));
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)), connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)),
this, TQT_SLOT(slotPopulateDevice(TQListViewItem*))); this, TQ_SLOT(slotPopulateDevice(TQListViewItem*)));
TQFrame *vbox = new TQFrame(splitter); TQFrame *vbox = new TQFrame(splitter);
TQVBoxLayout *vboxLayout = new TQVBoxLayout(vbox, 8, 6); TQVBoxLayout *vboxLayout = new TQVBoxLayout(vbox, 8, 6);
@ -217,44 +217,44 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
m_variationCombo->insertItem(i18n("MSB")); m_variationCombo->insertItem(i18n("MSB"));
// device/bank modification // device/bank modification
connect(m_listView, TQT_SIGNAL(itemRenamed (TQListViewItem*, const TQString&, int)), connect(m_listView, TQ_SIGNAL(itemRenamed (TQListViewItem*, const TQString&, int)),
this, TQT_SLOT(slotModifyDeviceOrBankName(TQListViewItem*, const TQString&, int))); this, TQ_SLOT(slotModifyDeviceOrBankName(TQListViewItem*, const TQString&, int)));
connect(m_addBank, TQT_SIGNAL(clicked()), connect(m_addBank, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotAddBank())); this, TQ_SLOT(slotAddBank()));
connect(m_addKeyMapping, TQT_SIGNAL(clicked()), connect(m_addKeyMapping, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotAddKeyMapping())); this, TQ_SLOT(slotAddKeyMapping()));
connect(m_delete, TQT_SIGNAL(clicked()), connect(m_delete, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotDelete())); this, TQ_SLOT(slotDelete()));
connect(m_deleteAll, TQT_SIGNAL(clicked()), connect(m_deleteAll, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteAll())); this, TQ_SLOT(slotDeleteAll()));
connect(m_importBanks, TQT_SIGNAL(clicked()), connect(m_importBanks, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotImport())); this, TQ_SLOT(slotImport()));
connect(m_exportBanks, TQT_SIGNAL(clicked()), connect(m_exportBanks, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotExport())); this, TQ_SLOT(slotExport()));
connect(m_copyPrograms, TQT_SIGNAL(clicked()), connect(m_copyPrograms, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotEditCopy())); this, TQ_SLOT(slotEditCopy()));
connect(m_pastePrograms, TQT_SIGNAL(clicked()), connect(m_pastePrograms, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotEditPaste())); this, TQ_SLOT(slotEditPaste()));
connect(m_variationToggle, TQT_SIGNAL(clicked()), connect(m_variationToggle, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotVariationToggled())); this, TQ_SLOT(slotVariationToggled()));
connect(m_variationCombo, TQT_SIGNAL(activated(int)), connect(m_variationCombo, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotVariationChanged(int))); this, TQ_SLOT(slotVariationChanged(int)));
setupActions(); setupActions();
m_doc->getCommandHistory()->attachView(actionCollection()); m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()), connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate())); this, TQ_SLOT(slotUpdate()));
// Initialise the dialog // Initialise the dialog
// //
@ -301,14 +301,14 @@ BankEditorDialog::~BankEditorDialog()
void void
BankEditorDialog::setupActions() 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()); m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(clicked()), connect(m_closeButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotFileClose())); this, TQ_SLOT(slotFileClose()));
KStdAction::copy (this, TQT_SLOT(slotEditCopy()), actionCollection()); KStdAction::copy (this, TQ_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQT_SLOT(slotEditPaste()), actionCollection()); KStdAction::paste (this, TQ_SLOT(slotEditPaste()), actionCollection());
// some adjustments // 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 *addButton = new TQPushButton(i18n("Add Play Device"), hbox);
TQPushButton *addRButton = new TQPushButton(i18n("Add Record Device"), hbox); TQPushButton *addRButton = new TQPushButton(i18n("Add Record Device"), hbox);
TQPushButton *deleteButton = new TQPushButton(i18n("Delete Device"), hbox); TQPushButton *deleteButton = new TQPushButton(i18n("Delete Device"), hbox);
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddPlayDevice())); connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayDevice()));
connect(addRButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddRecordDevice())); connect(addRButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddRecordDevice()));
connect(deleteButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeleteDevice())); connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeleteDevice()));
connect(m_table, TQT_SIGNAL(valueChanged(int, int)), connect(m_table, TQ_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotValueChanged (int, int))); this, TQ_SLOT(slotValueChanged (int, int)));
setMinimumHeight(250); setMinimumHeight(250);

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

@ -138,17 +138,17 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
(m_controllersButton, (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 ")); 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(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayDevice()));
connect(m_deletePlayButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeletePlayDevice())); connect(m_deletePlayButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeletePlayDevice()));
connect(m_importButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotImport())); connect(m_importButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotImport()));
connect(m_exportButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotExport())); connect(m_exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotExport()));
connect(m_banksButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetBanks())); connect(m_banksButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetBanks()));
connect(m_controllersButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetControllers())); connect(m_controllersButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetControllers()));
connect(m_playTable, TQT_SIGNAL(valueChanged(int, int)), connect(m_playTable, TQ_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotPlayValueChanged (int, int))); this, TQ_SLOT(slotPlayValueChanged (int, int)));
connect(m_playTable, TQT_SIGNAL(currentChanged(int, int)), connect(m_playTable, TQ_SIGNAL(currentChanged(int, int)),
this, TQT_SLOT(slotPlayDeviceSelected (int, int))); this, TQ_SLOT(slotPlayDeviceSelected (int, int)));
mainLayout->addWidget(groupBox); mainLayout->addWidget(groupBox);
groupBox = new TQGroupBox(2, TQt::Horizontal, i18n("Record devices"), mainBox); groupBox = new TQGroupBox(2, TQt::Horizontal, i18n("Record devices"), mainBox);
@ -181,15 +181,15 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
(m_deleteRecordButton, (m_deleteRecordButton,
i18n("Delete the selected device")); i18n("Delete the selected device"));
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddRecordDevice())); connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddRecordDevice()));
connect(m_deleteRecordButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeleteRecordDevice())); connect(m_deleteRecordButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeleteRecordDevice()));
connect(m_recordTable, TQT_SIGNAL(currentChanged(int, int)), connect(m_recordTable, TQ_SIGNAL(currentChanged(int, int)),
this, TQT_SLOT(slotRecordDeviceSelected (int, int))); this, TQ_SLOT(slotRecordDeviceSelected (int, int)));
connect(m_recordTable, TQT_SIGNAL(valueChanged(int, int)), connect(m_recordTable, TQ_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotRecordValueChanged (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"); m_noConnectionString = i18n("No connection");
@ -213,11 +213,11 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
layout->addSpacing(5); layout->addSpacing(5);
TDEAction* close = KStdAction::close(this, TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
closeButton->setText(close->text()); 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); mainLayout->addWidget(btnBox);
@ -237,8 +237,8 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
createGUI("devicemanager.rc"); createGUI("devicemanager.rc");
m_document->getCommandHistory()->attachView(actionCollection()); m_document->getCommandHistory()->attachView(actionCollection());
connect(m_document->getCommandHistory(), TQT_SIGNAL(commandExecuted()), connect(m_document->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQT_SLOT(populate())); this, TQ_SLOT(populate()));
m_playTable->setCurrentCell( -1, 0); m_playTable->setCurrentCell( -1, 0);
m_recordTable->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(); setupTabs();
KStdAction::close(this, KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play"))); ("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this, TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQT_SIGNAL(play()), actionCollection(), "play"); TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play // Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut(); TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) ); playShortcut.append( KKey(Key_Return + CTRL) );
@ -86,42 +86,42 @@ MidiMixerWindow::MidiMixerWindow(TQWidget *parent,
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop"))); ("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, this, new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQT_SIGNAL(stop()), actionCollection(), "stop"); TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind"))); ("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, this, new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQT_SIGNAL(rewindPlayback()), actionCollection(), TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar"); "playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd"))); ("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this, new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQT_SIGNAL(fastForwardPlayback()), actionCollection(), TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar"); "playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end"))); ("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this, new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(), TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start"); "playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end"))); ("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this, new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(), TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end"); "playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-record"))); ("transport-record")));
new TDEAction(i18n("&Record"), icon, 0, this, new TDEAction(i18n("&Record"), icon, 0, this,
TQT_SIGNAL(record()), actionCollection(), TQ_SIGNAL(record()), actionCollection(),
"record"); "record");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic"))); ("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this, new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQT_SIGNAL(panic()), actionCollection(), TQ_SIGNAL(panic()), actionCollection(),
"panic"); "panic");
createGUI("midimixer.rc"); createGUI("midimixer.rc");
@ -144,8 +144,8 @@ MidiMixerWindow::setupTabs()
// //
m_tabWidget = new TQTabWidget(this); m_tabWidget = new TQTabWidget(this);
setCentralWidget(m_tabWidget); setCentralWidget(m_tabWidget);
connect(m_tabWidget, TQT_SIGNAL(currentChanged(TQWidget *)), connect(m_tabWidget, TQ_SIGNAL(currentChanged(TQWidget *)),
this, TQT_SLOT(slotCurrentTabChanged(TQWidget *))); this, TQ_SLOT(slotCurrentTabChanged(TQWidget *)));
m_tabWidget->setTabPosition(TQTabWidget::Bottom); m_tabWidget->setTabPosition(TQTabWidget::Bottom);
setCaption(i18n("MIDI Mixer")); setCaption(i18n("MIDI Mixer"));
@ -246,8 +246,8 @@ MidiMixerWindow::setupTabs()
controller->setKnobColour(knobColour); controller->setKnobColour(knobColour);
connect(controller, TQT_SIGNAL(valueChanged(float)), connect(controller, TQ_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotControllerChanged(float))); this, TQ_SLOT(slotControllerChanged(float)));
mainLayout->addWidget(controller, i + 1, posCount, mainLayout->addWidget(controller, i + 1, posCount,
TQt::AlignCenter); TQt::AlignCenter);
@ -291,8 +291,8 @@ MidiMixerWindow::setupTabs()
// Connect them up // Connect them up
// //
connect(fader, TQT_SIGNAL(faderChanged(float)), connect(fader, TQ_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float))); this, TQ_SLOT(slotFaderLevelChanged(float)));
// Update all the faders and controllers // 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), gridLayout->addWidget(new TQLabel(i18n("Percussion"), frame),
0, 0, AlignLeft); 0, 0, AlignLeft);
gridLayout->addWidget(m_percussion, 0, 1, AlignLeft); gridLayout->addWidget(m_percussion, 0, 1, AlignLeft);
connect(m_percussion, TQT_SIGNAL(clicked()), connect(m_percussion, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotNewPercussion())); this, TQ_SLOT(slotNewPercussion()));
gridLayout->addWidget(new TQLabel(i18n("MSB Value"), frame), gridLayout->addWidget(new TQLabel(i18n("MSB Value"), frame),
1, 0, AlignLeft); 1, 0, AlignLeft);
@ -108,8 +108,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
(m_lsb, (m_lsb,
i18n("Selects a LSB controller Bank number (MSB/LSB pairs are always unique for any Device)")); i18n("Selects a LSB controller Bank number (MSB/LSB pairs are always unique for any Device)"));
connect(m_msb, TQT_SIGNAL(valueChanged(int)), connect(m_msb, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotNewMSB(int))); this, TQ_SLOT(slotNewMSB(int)));
gridLayout->addWidget(new TQLabel(i18n("LSB Value"), frame), gridLayout->addWidget(new TQLabel(i18n("LSB Value"), frame),
2, 0, AlignLeft); 2, 0, AlignLeft);
@ -117,8 +117,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
m_lsb->setMaxValue(127); m_lsb->setMaxValue(127);
gridLayout->addWidget(m_lsb, 2, 1, AlignLeft); gridLayout->addWidget(m_lsb, 2, 1, AlignLeft);
connect(m_lsb, TQT_SIGNAL(valueChanged(int)), connect(m_lsb, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotNewLSB(int))); this, TQ_SLOT(slotNewLSB(int)));
return frame; return frame;
} }
@ -472,12 +472,12 @@ MidiProgramsEditor::slotEntryButtonPressed()
int currentEntry = 0; int currentEntry = 0;
menu->insertItem(i18n("<no key mapping>"), this, menu->insertItem(i18n("<no key mapping>"), this,
TQT_SLOT(slotEntryMenuItemSelected(int)), 0, 0); TQ_SLOT(slotEntryMenuItemSelected(int)), 0, 0);
menu->setItemParameter(0, 0); menu->setItemParameter(0, 0);
for (int i = 0; i < kml.size(); ++i) { for (int i = 0; i < kml.size(); ++i) {
menu->insertItem(strtoqstr(kml[i].getName()), menu->insertItem(strtoqstr(kml[i].getName()),
this, TQT_SLOT(slotEntryMenuItemSelected(int)), this, TQ_SLOT(slotEntryMenuItemSelected(int)),
0, i + 1); 0, i + 1);
menu->setItemParameter(i + 1, i + 1); menu->setItemParameter(i + 1, i + 1);
if (currentMapping && (kml[i] == *currentMapping)) 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 // Initial label; button to adjust whether labels start at 0 or 1
m_initialLabel = new TQPushButton(numberText, numBox); m_initialLabel = new TQPushButton(numberText, numBox);
connect(m_initialLabel, connect(m_initialLabel,
TQT_SIGNAL(clicked()), TQ_SIGNAL(clicked()),
this, this,
TQT_SLOT(slotToggleInitialLabel())); TQ_SLOT(slotToggleInitialLabel()));
} else { } else {
TQLabel *label = new TQLabel(numberText, numBox); TQLabel *label = new TQLabel(numberText, numBox);
label->setFixedWidth(40); label->setFixedWidth(40);
@ -120,8 +120,8 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
button->setMaximumWidth(40); button->setMaximumWidth(40);
button->setMaximumHeight(20); button->setMaximumHeight(20);
button->setFlat(true); button->setFlat(true);
connect(button, TQT_SIGNAL(clicked()), connect(button, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotEntryButtonPressed())); this, TQ_SLOT(slotEntryButtonPressed()));
m_entryButtons.push_back(button); m_entryButtons.push_back(button);
} }
@ -132,9 +132,9 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
m_names.push_back(lineEdit); m_names.push_back(lineEdit);
connect(m_names[labelId], connect(m_names[labelId],
TQT_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(textChanged(const TQString&)),
this, this,
TQT_SLOT(slotNameChanged(const TQString&))); TQ_SLOT(slotNameChanged(const TQString&)));
++labelId; ++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); m_instrumentButton = new TQRadioButton(i18n("Instrument"), m_buttonGroup);
connect(m_buttonGroup, TQT_SIGNAL(released(int)), connect(m_buttonGroup, TQ_SIGNAL(released(int)),
this, TQT_SLOT(slotRemapReleased(int))); this, TQ_SLOT(slotRemapReleased(int)));
TQGroupBox *groupBox = new TQGroupBox(2, TQt::Horizontal, TQGroupBox *groupBox = new TQGroupBox(2, TQt::Horizontal,
i18n("Choose Source and Destination"), 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)), connect(pluginCombo, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotPluginChanged(int))); this, TQ_SLOT(slotPluginChanged(int)));
pluginLayout->addWidget(pluginCombo, i, 1); pluginLayout->addWidget(pluginCombo, i, 1);
@ -142,7 +142,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
TQPushButton *controlsButton = new TQPushButton(i18n("Controls"), pluginFrame); TQPushButton *controlsButton = new TQPushButton(i18n("Controls"), pluginFrame);
pluginLayout->addWidget(controlsButton, i, 2); 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); m_controlsButtons.push_back(controlsButton);
#ifdef HAVE_LIBLO #ifdef HAVE_LIBLO
@ -151,7 +151,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
pluginLayout->addWidget(guiButton, i, 3); pluginLayout->addWidget(guiButton, i, 3);
guiButton->setEnabled(m_guiManager->hasGUI guiButton->setEnabled(m_guiManager->hasGUI
(id, Instrument::SYNTH_PLUGIN_POSITION)); (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); m_guiButtons.push_back(guiButton);
#endif #endif
@ -170,11 +170,11 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
layout->addSpacing(5); layout->addSpacing(5);
TDEAction* close = KStdAction::close(this, TDEAction* close = KStdAction::close(this,
TQT_SLOT(slotClose()), TQ_SLOT(slotClose()),
actionCollection()); actionCollection());
closeButton->setText(close->text()); 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); 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) m_data(data)
{ {
TQTimer *timer = new TQTimer(this); 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); 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_plugins.push_back(plugin);
m_signalMapper->setMapping(plugin, i); m_signalMapper->setMapping(plugin, i);
connect(plugin, TQT_SIGNAL(clicked()), connect(plugin, TQ_SIGNAL(clicked()),
m_signalMapper, TQT_SLOT(map())); m_signalMapper, TQ_SLOT(map()));
} }
m_synthButton = new TQPushButton(this); m_synthButton = new TQPushButton(this);
@ -127,8 +127,8 @@ AudioFaderBox::AudioFaderBox(TQWidget *parent,
m_stereoButton->setPixmap(m_monoPixmap); // default is mono m_stereoButton->setPixmap(m_monoPixmap); // default is mono
m_stereoButton->setFixedSize(24, 24); m_stereoButton->setFixedSize(24, 24);
connect(m_stereoButton, TQT_SIGNAL(clicked()), connect(m_stereoButton, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotChannelStateChanged())); this, TQ_SLOT(slotChannelStateChanged()));
m_synthGUIButton = new TQPushButton(this); m_synthGUIButton = new TQPushButton(this);
m_synthGUIButton->setText(i18n("Editor")); m_synthGUIButton->setText(i18n("Editor"));

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

@ -58,15 +58,15 @@ AudioRouteMenu::AudioRouteMenu(TQWidget *par,
case Compact: { case Compact: {
m_combo = 0; m_combo = 0;
m_button = new WheelyButton(par); m_button = new WheelyButton(par);
connect(m_button, TQT_SIGNAL(wheel(bool)), this, TQT_SLOT(slotWheel(bool))); connect(m_button, TQ_SIGNAL(wheel(bool)), this, TQ_SLOT(slotWheel(bool)));
connect(m_button, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotShowMenu())); connect(m_button, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotShowMenu()));
break; break;
} }
case Regular: { case Regular: {
m_button = 0; m_button = 0;
m_combo = new KComboBox(par); 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; break;
} }
@ -135,7 +135,7 @@ AudioRouteMenu::slotShowMenu()
for (int i = 0; i < getNumEntries(); ++i) { 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); 0, i);
menu->setItemParameter(i, 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"); TQPixmap pixmap(pixmapDir + "/misc/arrow-expanded.png");
m_toggleButton->setIconSet(pixmap); 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); 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(0, i18n("Name"));
horizontalHeader()->setLabel(1, i18n("Color")); horizontalHeader()->setLabel(1, i18n("Color"));
populate_table(input, list); populate_table(input, list);
connect(this, TQT_SIGNAL(doubleClicked(int, int, int, const TQPoint&)), connect(this, TQ_SIGNAL(doubleClicked(int, int, int, const TQPoint&)),
TQT_SLOT(slotEditEntry(int, int))); 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; m_currentProgressDialog = d;
// this lets the progress dialog deregister itself when it's deleted // this lets the progress dialog deregister itself when it's deleted
connect(d, TQT_SIGNAL(destroyed()), connect(d, TQ_SIGNAL(destroyed()),
getInstance(), TQT_SLOT(slotCurrentProgressDialogDestroyed())); getInstance(), TQ_SLOT(slotCurrentProgressDialogDestroyed()));
} }
void CurrentProgressDialog::freeze() void CurrentProgressDialog::freeze()

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

@ -89,41 +89,41 @@ DiatonicPitchChooser::DiatonicPitchChooser(TQString title,
m_pitchLabel->setMinimumWidth(40); m_pitchLabel->setMinimumWidth(40);
connect(m_accidental, TQT_SIGNAL(activated(int)), connect(m_accidental, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetAccidental(int))); this, TQ_SLOT(slotSetAccidental(int)));
connect(m_octave, TQT_SIGNAL(activated(int)), connect(m_octave, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetOctave(int))); this, TQ_SLOT(slotSetOctave(int)));
connect(m_step, TQT_SIGNAL(activated(int)), connect(m_step, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetStep(int))); this, TQ_SLOT(slotSetStep(int)));
//connect(m_pitch, TQT_SIGNAL(valueChanged(int)), //connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
// this, TQT_SIGNAL(pitchChanged(int))); // this, TQ_SIGNAL(pitchChanged(int)));
//connect(m_pitch, TQT_SIGNAL(valueChanged(int)), //connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
// this, TQT_SIGNAL(preview(int))); // this, TQ_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int,int,int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int,int,int)),
this, TQT_SLOT(slotSetNote(int,int,int))); this, TQ_SLOT(slotSetNote(int,int,int)));
//connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)), //connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
// this, TQT_SLOT(slotSetPitch(int))); // this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int,int,int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int,int,int)),
this, TQT_SLOT(slotSetNote(int,int,int))); this, TQ_SLOT(slotSetNote(int,int,int)));
//connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)), //connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
// this, TQT_SIGNAL(pitchChanged(int))); // this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int,int,int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int,int,int)),
this, TQT_SIGNAL(noteChanged(int,int,int))); this, TQ_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int,int,int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int,int,int)),
this, TQT_SIGNAL(noteChanged(int,int,int))); this, TQ_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQT_SIGNAL(preview(int)), connect(m_pitchDragLabel, TQ_SIGNAL(preview(int)),
this, TQT_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(); calculateGroovePixmap();
setFader(0.0); 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(); m_float->hide();
} }
@ -113,7 +113,7 @@ Fader::Fader(int min, int max, int deflt,
calculateGroovePixmap(); calculateGroovePixmap();
setFader(deflt); 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(); m_float->hide();
} }
@ -144,7 +144,7 @@ Fader::Fader(int min, int max, int deflt,
calculateGroovePixmap(); calculateGroovePixmap();
setFader(deflt); 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(); 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); initialize(decimals);
setValuef(initialValue); setValuef(initialValue);
if (recv != NULL && mem != NULL) 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; } 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 = new TQLabel(pl.getTQString(), hbox);
m_pitchLabel->setMinimumWidth(40); m_pitchLabel->setMinimumWidth(40);
connect(m_pitch, TQT_SIGNAL(valueChanged(int)), connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSetPitch(int))); this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitch, TQT_SIGNAL(valueChanged(int)), connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQT_SIGNAL(pitchChanged(int))); this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitch, TQT_SIGNAL(valueChanged(int)), connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQT_SIGNAL(preview(int))); this, TQ_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int)),
this, TQT_SLOT(slotSetPitch(int))); this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
this, TQT_SLOT(slotSetPitch(int))); this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)), connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
this, TQT_SIGNAL(pitchChanged(int))); this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(preview(int)), connect(m_pitchDragLabel, TQ_SIGNAL(preview(int)),
this, TQT_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)); m_dial->setKnobColour(GUIPalette::getColour(GUIPalette::RotaryPlugin));
connect(m_dial, TQT_SIGNAL(valueChanged(float)), connect(m_dial, TQ_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotValueChanged(float))); this, TQ_SLOT(slotValueChanged(float)));
TQLabel *upp; TQLabel *upp;
if (port->getDisplayHint() & 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 - " RG_DEBUG << "ProgressDialog::ProgressDialog type 1 - "
<< labelText() << " - modal : " << modal << endl; << labelText() << " - modal : " << modal << endl;
connect(progressBar(), TQT_SIGNAL(percentageChanged (int)), connect(progressBar(), TQ_SIGNAL(percentageChanged (int)),
this, TQT_SLOT(slotCheckShow(int))); this, TQ_SLOT(slotCheckShow(int)));
m_chrono.start(); m_chrono.start();
@ -83,8 +83,8 @@ ProgressDialog::ProgressDialog(
RG_DEBUG << "ProgressDialog::ProgressDialog type 2 - " RG_DEBUG << "ProgressDialog::ProgressDialog type 2 - "
<< labelText << " - modal : " << modal << endl; << labelText << " - modal : " << modal << endl;
connect(progressBar(), TQT_SIGNAL(percentageChanged (int)), connect(progressBar(), TQ_SIGNAL(percentageChanged (int)),
this, TQT_SLOT(slotCheckShow(int))); this, TQ_SLOT(slotCheckShow(int)));
m_chrono.start(); m_chrono.start();

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

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

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

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

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

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

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

@ -92,26 +92,26 @@ VUMeter::VUMeter(TQWidget *parent,
// //
m_fallTimerLeft = new TQTimer(); m_fallTimerLeft = new TQTimer();
connect(m_fallTimerLeft, TQT_SIGNAL(timeout()), connect(m_fallTimerLeft, TQ_SIGNAL(timeout()),
this, TQT_SLOT(slotReduceLevelLeft())); this, TQ_SLOT(slotReduceLevelLeft()));
if (m_showPeakLevel) { if (m_showPeakLevel) {
m_peakTimerLeft = new TQTimer(); m_peakTimerLeft = new TQTimer();
connect(m_peakTimerLeft, TQT_SIGNAL(timeout()), connect(m_peakTimerLeft, TQ_SIGNAL(timeout()),
this, TQT_SLOT(slotStopShowingPeakLeft())); this, TQ_SLOT(slotStopShowingPeakLeft()));
} }
if (stereo) { if (stereo) {
m_fallTimerRight = new TQTimer(); m_fallTimerRight = new TQTimer();
connect(m_fallTimerRight, TQT_SIGNAL(timeout()), connect(m_fallTimerRight, TQ_SIGNAL(timeout()),
this, TQT_SLOT(slotReduceLevelRight())); this, TQ_SLOT(slotReduceLevelRight()));
if (m_showPeakLevel) { if (m_showPeakLevel) {
m_peakTimerRight = new TQTimer(); m_peakTimerRight = new TQTimer();
connect(m_peakTimerRight, TQT_SIGNAL(timeout()), connect(m_peakTimerRight, TQ_SIGNAL(timeout()),
this, TQT_SLOT(slotStopShowingPeakRight())); 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 // Check for new clients every so often
// //
m_newClientTimer = new TQTimer(this); m_newClientTimer = new TQTimer(this);
connect(m_newClientTimer, TQT_SIGNAL(timeout()), connect(m_newClientTimer, TQ_SIGNAL(timeout()),
this, TQT_SLOT(slotCheckForNewClients())); this, TQ_SLOT(slotCheckForNewClients()));
m_newClientTimer->start(3000); // every 3 seconds 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; 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 app.disableSessionManagement(); // we don't want to be
// saved/restored by session // saved/restored by session

4
src/sound/AudioFileManager.cpp
Unescape View File

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

4
src/sound/PeakFileManager.cpp
Unescape View File

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

Write Preview
Loading…
Cancel
Save