diff options
Diffstat (limited to 'src/commands/segment')
114 files changed, 10007 insertions, 0 deletions
diff --git a/src/commands/segment/AddTempoChangeCommand.cpp b/src/commands/segment/AddTempoChangeCommand.cpp new file mode 100644 index 0000000..6665215 --- /dev/null +++ b/src/commands/segment/AddTempoChangeCommand.cpp @@ -0,0 +1,66 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AddTempoChangeCommand.h" + +#include "base/Composition.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +AddTempoChangeCommand::~AddTempoChangeCommand() +{ + // nothing here either +} + +void +AddTempoChangeCommand::execute() +{ + int oldIndex = m_composition->getTempoChangeNumberAt(m_time); + + if (oldIndex >= 0) { + std::pair<timeT, tempoT> data = + m_composition->getTempoChange(oldIndex); + + if (data.first == m_time) + m_oldTempo = data.second; + } + + m_tempoChangeIndex = m_composition->addTempoAtTime(m_time, m_tempo, m_target); +} + +void +AddTempoChangeCommand::unexecute() +{ + m_composition->removeTempoChange(m_tempoChangeIndex); + + if (m_oldTempo != 0) { + m_composition->addTempoAtTime(m_time, m_oldTempo); + } +} + +} diff --git a/src/commands/segment/AddTempoChangeCommand.h b/src/commands/segment/AddTempoChangeCommand.h new file mode 100644 index 0000000..07036dd --- /dev/null +++ b/src/commands/segment/AddTempoChangeCommand.h @@ -0,0 +1,76 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_ADDTEMPOCHANGECOMMAND_H_ +#define _RG_ADDTEMPOCHANGECOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include "base/Composition.h" // for tempoT +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class AddTempoChangeCommand : public KNamedCommand +{ +public: + AddTempoChangeCommand(Composition *composition, + timeT time, + tempoT tempo, + tempoT target = -1): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_time(time), + m_tempo(tempo), + m_target(target), + m_oldTempo(0), + m_tempoChangeIndex(0) {} + + virtual ~AddTempoChangeCommand(); + + static QString getGlobalName() { return i18n("Add Te&mpo Change..."); } + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + timeT m_time; + tempoT m_tempo; + tempoT m_target; + tempoT m_oldTempo; + int m_tempoChangeIndex; +}; + + + +} + +#endif diff --git a/src/commands/segment/AddTimeSignatureAndNormalizeCommand.cpp b/src/commands/segment/AddTimeSignatureAndNormalizeCommand.cpp new file mode 100644 index 0000000..45b391b --- /dev/null +++ b/src/commands/segment/AddTimeSignatureAndNormalizeCommand.cpp @@ -0,0 +1,78 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AddTimeSignatureAndNormalizeCommand.h" + +#include "AddTimeSignatureCommand.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "commands/notation/MakeRegionViableCommand.h" + + +namespace Rosegarden +{ + +AddTimeSignatureAndNormalizeCommand::AddTimeSignatureAndNormalizeCommand +(Composition *composition, timeT time, TimeSignature timeSig) : + KMacroCommand(AddTimeSignatureCommand::getGlobalName()) +{ + addCommand(new AddTimeSignatureCommand(composition, time, timeSig)); + + // only up to the next time signature + timeT nextTimeSigTime(composition->getDuration()); + + int index = composition->getTimeSignatureNumberAt(time); + if (composition->getTimeSignatureCount() > index + 1) { + nextTimeSigTime = composition->getTimeSignatureChange(index + 1).first; + } + + for (Composition::iterator i = composition->begin(); + i != composition->end(); ++i) { + + if ((*i)->getType() != Segment::Internal) continue; + + timeT startTime = (*i)->getStartTime(); + timeT endTime = (*i)->getEndTime(); + + if (startTime >= nextTimeSigTime || endTime <= time) + continue; + + // "Make Notes Viable" splits and ties notes at barlines, and + // also does a rest normalize. It's what we normally want + // when adding a time signature. + + addCommand(new MakeRegionViableCommand + (**i, + std::max(startTime, time), + std::min(endTime, nextTimeSigTime))); + } +} + +AddTimeSignatureAndNormalizeCommand::~AddTimeSignatureAndNormalizeCommand() +{ + // well, nothing really +} + +} diff --git a/src/commands/segment/AddTimeSignatureAndNormalizeCommand.h b/src/commands/segment/AddTimeSignatureAndNormalizeCommand.h new file mode 100644 index 0000000..f22faa4 --- /dev/null +++ b/src/commands/segment/AddTimeSignatureAndNormalizeCommand.h @@ -0,0 +1,53 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_ADDTIMESIGNATUREANDNORMALIZECOMMAND_H_ +#define _RG_ADDTIMESIGNATUREANDNORMALIZECOMMAND_H_ + +#include "base/NotationTypes.h" +#include "base/Event.h" +#include <kcommand.h> + + +namespace Rosegarden +{ + +class Composition; + + +class AddTimeSignatureAndNormalizeCommand : public KMacroCommand +{ +public: + AddTimeSignatureAndNormalizeCommand(Composition *composition, + timeT time, + TimeSignature timeSig); + virtual ~AddTimeSignatureAndNormalizeCommand(); +}; + + + +} + +#endif diff --git a/src/commands/segment/AddTimeSignatureCommand.cpp b/src/commands/segment/AddTimeSignatureCommand.cpp new file mode 100644 index 0000000..88f2d07 --- /dev/null +++ b/src/commands/segment/AddTimeSignatureCommand.cpp @@ -0,0 +1,78 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AddTimeSignatureCommand.h" + +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +AddTimeSignatureCommand::AddTimeSignatureCommand(Composition *composition, + timeT time, + TimeSignature timeSig) : + KNamedCommand(getGlobalName()), + m_composition(composition), + m_time(time), + m_timeSignature(timeSig), + m_oldTimeSignature(0) +{ + // nothing else +} + +AddTimeSignatureCommand::~AddTimeSignatureCommand() +{ + if (m_oldTimeSignature) + delete m_oldTimeSignature; +} + +void +AddTimeSignatureCommand::execute() +{ + int oldIndex = m_composition->getTimeSignatureNumberAt(m_time); + if (oldIndex >= 0) { + std::pair<timeT, TimeSignature> data = + m_composition->getTimeSignatureChange(oldIndex); + if (data.first == m_time) { + m_oldTimeSignature = new TimeSignature(data.second); + } + } + + m_timeSigIndex = m_composition->addTimeSignature(m_time, m_timeSignature); +} + +void +AddTimeSignatureCommand::unexecute() +{ + m_composition->removeTimeSignature(m_timeSigIndex); + if (m_oldTimeSignature) { + m_composition->addTimeSignature(m_time, *m_oldTimeSignature); + } +} + +} diff --git a/src/commands/segment/AddTimeSignatureCommand.h b/src/commands/segment/AddTimeSignatureCommand.h new file mode 100644 index 0000000..fbc875d --- /dev/null +++ b/src/commands/segment/AddTimeSignatureCommand.h @@ -0,0 +1,71 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_ADDTIMESIGNATURECOMMAND_H_ +#define _RG_ADDTIMESIGNATURECOMMAND_H_ + +#include "base/NotationTypes.h" +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class AddTimeSignatureCommand : public KNamedCommand +{ +public: + AddTimeSignatureCommand(Composition *composition, + timeT time, + TimeSignature timeSig); + virtual ~AddTimeSignatureCommand(); + + static QString getGlobalName() { return i18n("Add Time Si&gnature Change..."); } + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + timeT m_time; + TimeSignature m_timeSignature; + + TimeSignature *m_oldTimeSignature; // for undo + int m_timeSigIndex; // for undo +}; + + + + +} + +#endif diff --git a/src/commands/segment/AddTracksCommand.cpp b/src/commands/segment/AddTracksCommand.cpp new file mode 100644 index 0000000..1f09227 --- /dev/null +++ b/src/commands/segment/AddTracksCommand.cpp @@ -0,0 +1,137 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AddTracksCommand.h" + +#include "misc/Debug.h" +#include "base/Composition.h" +#include "base/MidiProgram.h" +#include "base/Track.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +AddTracksCommand::AddTracksCommand(Composition *composition, + unsigned int nbTracks, + InstrumentId id, + int position): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_nbNewTracks(nbTracks), + m_instrumentId(id), + m_position(position), + m_detached(false) + +{ +} + +AddTracksCommand::~AddTracksCommand() +{ + if (m_detached) { + for (unsigned int i = 0; i < m_newTracks.size(); ++i) + delete m_newTracks[i]; + } +} + +void AddTracksCommand::execute() +{ + // Re-attach tracks + // + if (m_detached) { + + for (unsigned int i = 0; i < m_newTracks.size(); i++) { + m_composition->addTrack(m_newTracks[i]); + } + + for (TrackPositionMap::iterator i = m_oldPositions.begin(); + i != m_oldPositions.end(); ++i) { + + int newPosition = i->second + m_nbNewTracks; + Track *track = m_composition->getTrackById(i->first); + if (track) track->setPosition(newPosition); + } + + return; + } + + int highPosition = 0; + + for (Composition::trackiterator it = m_composition->getTracks().begin(); + it != m_composition->getTracks().end(); ++it) { + + int pos = it->second->getPosition(); + + if (pos > highPosition) { + highPosition = pos; + } + } + + if (m_position == -1) m_position = highPosition + 1; + if (m_position < 0) m_position = 0; + if (m_position > highPosition + 1) m_position = highPosition + 1; + + for (Composition::trackiterator it = m_composition->getTracks().begin(); + it != m_composition->getTracks().end(); ++it) { + + int pos = it->second->getPosition(); + + if (pos >= m_position) { + m_oldPositions[it->first] = pos; + it->second->setPosition(pos + m_nbNewTracks); + } + } + + for (unsigned int i = 0; i < m_nbNewTracks; ++i) { + + TrackId trackId = m_composition->getNewTrackId(); + Track *track = new Track(trackId); + + track->setPosition(m_position + i); + track->setInstrument(m_instrumentId); + + m_composition->addTrack(track); + m_newTracks.push_back(track); + } +} + +void AddTracksCommand::unexecute() +{ + for (unsigned int i = 0; i < m_newTracks.size(); i++) { + m_composition->detachTrack(m_newTracks[i]); + } + + for (TrackPositionMap::iterator i = m_oldPositions.begin(); + i != m_oldPositions.end(); ++i) { + + Track *track = m_composition->getTrackById(i->first); + if (track) track->setPosition(i->second); + } + + m_detached = true; +} + +} diff --git a/src/commands/segment/AddTracksCommand.h b/src/commands/segment/AddTracksCommand.h new file mode 100644 index 0000000..d3e09ca --- /dev/null +++ b/src/commands/segment/AddTracksCommand.h @@ -0,0 +1,77 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_ADDTRACKSCOMMAND_H_ +#define _RG_ADDTRACKSCOMMAND_H_ + +#include "base/MidiProgram.h" +#include "base/Composition.h" +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <map> +#include <klocale.h> + + + +namespace Rosegarden +{ + +class Track; +class Composition; + + +class AddTracksCommand : public KNamedCommand +{ +public: + AddTracksCommand(Composition *composition, + unsigned int nbTracks, + InstrumentId id, + int position); // -1 -> at end + virtual ~AddTracksCommand(); + + static QString getGlobalName() { return i18n("Add Tracks..."); } + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + unsigned int m_nbNewTracks; + InstrumentId m_instrumentId; + int m_position; + + typedef std::map<TrackId, int> TrackPositionMap; + + std::vector<Track *> m_newTracks; + TrackPositionMap m_oldPositions; + + bool m_detached; +}; + + +} + +#endif diff --git a/src/commands/segment/AddTriggerSegmentCommand.cpp b/src/commands/segment/AddTriggerSegmentCommand.cpp new file mode 100644 index 0000000..12d406e --- /dev/null +++ b/src/commands/segment/AddTriggerSegmentCommand.cpp @@ -0,0 +1,90 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AddTriggerSegmentCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" +#include "base/TriggerSegment.h" +#include "document/RosegardenGUIDoc.h" + + +namespace Rosegarden +{ + +AddTriggerSegmentCommand::AddTriggerSegmentCommand(RosegardenGUIDoc *doc, + timeT duration, + int basePitch, + int baseVelocity) : + KNamedCommand(i18n("Add Triggered Segment")), + m_composition(&doc->getComposition()), + m_duration(duration), + m_basePitch(basePitch), + m_baseVelocity(baseVelocity), + m_id(0), + m_segment(0), + m_detached(false) +{ + // nothing else +} + +AddTriggerSegmentCommand::~AddTriggerSegmentCommand() +{ + if (m_detached) + delete m_segment; +} + +TriggerSegmentId +AddTriggerSegmentCommand::getId() const +{ + return m_id; +} + +void +AddTriggerSegmentCommand::execute() +{ + if (m_segment) { + m_composition->addTriggerSegment(m_segment, m_id, m_basePitch, m_baseVelocity); + } else { + m_segment = new Segment(); + m_segment->setEndMarkerTime(m_duration); + TriggerSegmentRec *rec = m_composition->addTriggerSegment + (m_segment, m_basePitch, m_baseVelocity); + if (rec) + m_id = rec->getId(); + } + m_detached = false; +} + +void +AddTriggerSegmentCommand::unexecute() +{ + if (m_segment) + m_composition->detachTriggerSegment(m_id); + m_detached = true; +} + +} diff --git a/src/commands/segment/AddTriggerSegmentCommand.h b/src/commands/segment/AddTriggerSegmentCommand.h new file mode 100644 index 0000000..46d23cb --- /dev/null +++ b/src/commands/segment/AddTriggerSegmentCommand.h @@ -0,0 +1,72 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_ADDTRIGGERSEGMENTCOMMAND_H_ +#define _RG_ADDTRIGGERSEGMENTCOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; +class RosegardenGUIDoc; +class Composition; + + +class AddTriggerSegmentCommand : public KNamedCommand +{ +public: + AddTriggerSegmentCommand(RosegardenGUIDoc *doc, + timeT duration, // start time always 0 + int basePitch = -1, + int baseVelocity = -1); + virtual ~AddTriggerSegmentCommand(); + + TriggerSegmentId getId() const; // after invocation + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + timeT m_duration; + int m_basePitch; + int m_baseVelocity; + TriggerSegmentId m_id; + Segment *m_segment; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/AudioSegmentAutoSplitCommand.cpp b/src/commands/segment/AudioSegmentAutoSplitCommand.cpp new file mode 100644 index 0000000..d474b64 --- /dev/null +++ b/src/commands/segment/AudioSegmentAutoSplitCommand.cpp @@ -0,0 +1,191 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AudioSegmentAutoSplitCommand.h" + +#include "base/Event.h" +#include "misc/Debug.h" +#include "misc/Strings.h" +#include "base/Composition.h" +#include "base/RealTime.h" +#include "base/Segment.h" +#include "document/RosegardenGUIDoc.h" +#include "sound/AudioFileManager.h" +#include "sound/PeakFileManager.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +struct AutoSplitPoint +{ + timeT time; + timeT lastSoundTime; + Clef clef; + Rosegarden::Key key; + AutoSplitPoint(timeT t, timeT lst, Clef c, Rosegarden::Key k) : + time(t), lastSoundTime(lst), clef(c), key(k) { } +}; + +AudioSegmentAutoSplitCommand::AudioSegmentAutoSplitCommand( + RosegardenGUIDoc *doc, + Segment *segment, + int threshold) : + KNamedCommand(getGlobalName()), + m_segment(segment), + m_composition(segment->getComposition()), + m_audioFileManager(&(doc->getAudioFileManager())), + m_detached(false), + m_threshold(threshold) +{} + +AudioSegmentAutoSplitCommand::~AudioSegmentAutoSplitCommand() +{ + if (m_detached) { + delete m_segment; + } else { + for (unsigned int i = 0; i < m_newSegments.size(); ++i) { + delete m_newSegments[i]; + } + } +} + +void +AudioSegmentAutoSplitCommand::execute() +{ + if (m_newSegments.size() == 0) { + + std::vector<AutoSplitPoint> splitPoints; + + if (m_segment->getType() != Segment::Audio) + return ; + + // Auto split the audio file - we ask for a minimum + // result file size of 0.2secs - that's probably fair + // enough. + // + std::vector<SplitPointPair> rtSplitPoints; + + try { + rtSplitPoints = + m_audioFileManager-> + getSplitPoints(m_segment->getAudioFileId(), + m_segment->getAudioStartTime(), + m_segment->getAudioEndTime(), + m_threshold, + RealTime(0, 200000000)); + } catch (AudioFileManager::BadAudioPathException e) { + std::cerr << "ERROR: AudioSegmentAutoSplitCommand: Bad audio path: " << e.getMessage() << std::endl; + } catch (PeakFileManager::BadPeakFileException e) { + std::cerr << "ERROR: AudioSegmentAutoSplitCommand: Bad peak file: " << e.getMessage() << std::endl; + } + + std::vector<SplitPointPair>::iterator it; + timeT absStartTime, absEndTime; + + char splitNumber[10]; + int splitCount = 0; + + timeT origStartTime = m_segment->getStartTime(); + RealTime audioStart = m_segment->getAudioStartTime(); + RealTime origStartRT = m_composition->getElapsedRealTime(origStartTime); + + for (it = rtSplitPoints.begin(); it != rtSplitPoints.end(); it++) { + // The start time for the segment is the original + // segment's start time, plus whatever it->first translates + // into as an offset from the original segment's start + // time + + RG_DEBUG << "AudioSegmentAutoSplitCommand::execute: range " << it->first << " -> " << it->second << endl; + + absStartTime = m_composition->getElapsedTimeForRealTime + (origStartRT - audioStart + it->first); + + absEndTime = m_composition->getElapsedTimeForRealTime + (origStartRT - audioStart + it->second); + + // absStartTime = m_segment->getStartTime() + + // m_composition->getElapsedTimeForRealTime(it->first - audioStart); + + // absEndTime = m_segment->getStartTime() + + // m_composition->getElapsedTimeForRealTime(it->second - audioStart); + + Segment *newSegment = new Segment(*m_segment); + + newSegment->setStartTime(absStartTime); + newSegment->setAudioFileId(m_segment->getAudioFileId()); + newSegment->setAudioStartTime(it->first); + newSegment->setAudioEndTime(it->second); + newSegment->setEndMarkerTime(absEndTime); + + // label + sprintf(splitNumber, "%d", splitCount++); + newSegment-> + setLabel(qstrtostr(i18n("%1 (autosplit %2)").arg + (strtoqstr(m_segment->getLabel())).arg + (splitNumber))); + + newSegment->setColourIndex(m_segment->getColourIndex()); + + RG_DEBUG << "AudioSegmentAutoSplitCommand::execute " + << "abs start = " << absStartTime + << ", abs end = " << absEndTime + << ", seg start = " << newSegment->getStartTime() + << ", seg end = " << newSegment->getEndMarkerTime() + << ", audio start = " << newSegment->getAudioStartTime() + << ", audio end = " << newSegment->getAudioEndTime() + << endl; + + m_newSegments.push_back(newSegment); + } + } + + RG_DEBUG << "AudioSegmentAutoSplitCommand::execute: have " << m_newSegments.size() << " new segments" << endl; + + for (unsigned int i = 0; i < m_newSegments.size(); ++i) { + m_composition->addSegment(m_newSegments[i]); + } + + if (m_newSegments.size() > 0) { + m_composition->detachSegment(m_segment); + } + + m_detached = true; +} + +void +AudioSegmentAutoSplitCommand::unexecute() +{ + for (unsigned int i = 0; i < m_newSegments.size(); ++i) { + m_composition->detachSegment(m_newSegments[i]); + } + if (m_newSegments.size() > 0) { // otherwise it was never detached + m_composition->addSegment(m_segment); + } + m_detached = false; +} + +} diff --git a/src/commands/segment/AudioSegmentAutoSplitCommand.h b/src/commands/segment/AudioSegmentAutoSplitCommand.h new file mode 100644 index 0000000..a1c4b48 --- /dev/null +++ b/src/commands/segment/AudioSegmentAutoSplitCommand.h @@ -0,0 +1,71 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_AUDIOSEGMENTAUTOSPLITCOMMAND_H_ +#define _RG_AUDIOSEGMENTAUTOSPLITCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Segment; +class RosegardenGUIDoc; +class Composition; +class AudioFileManager; + + +class AudioSegmentAutoSplitCommand : public KNamedCommand +{ +public: + AudioSegmentAutoSplitCommand(RosegardenGUIDoc *doc, + Segment *segment, + int threshold); + virtual ~AudioSegmentAutoSplitCommand(); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName() { return i18n("&Split on Silence"); } + +private: + Segment *m_segment; + Composition *m_composition; + AudioFileManager *m_audioFileManager; + std::vector<Segment *> m_newSegments; + bool m_detached; + int m_threshold; +}; + + +} + +#endif diff --git a/src/commands/segment/AudioSegmentDistributeCommand.cpp b/src/commands/segment/AudioSegmentDistributeCommand.cpp new file mode 100644 index 0000000..9bdfb97 --- /dev/null +++ b/src/commands/segment/AudioSegmentDistributeCommand.cpp @@ -0,0 +1,156 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AudioSegmentDistributeCommand.h" + +#include "base/Event.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/RealTime.h" +#include "base/Segment.h" +#include "base/Selection.h" +#include "sound/AudioFile.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +AudioSegmentDistributeCommand::AudioSegmentDistributeCommand( + Composition *comp, + SegmentSelection &inputSelection, + Segment *audioSegment): + KNamedCommand(getGlobalName()), + m_composition(comp), + m_selection(inputSelection), + m_audioFile(0), + m_audioSegment(audioSegment), + m_executed(false) +{} + +AudioSegmentDistributeCommand::AudioSegmentDistributeCommand( + Composition *comp, + SegmentSelection &inputSelection, + AudioFile *audioFile): + KNamedCommand(getGlobalName()), + m_composition(comp), + m_selection(inputSelection), + m_audioFile(audioFile), + m_audioSegment(0), + m_executed(false) +{} + +AudioSegmentDistributeCommand::~AudioSegmentDistributeCommand() +{ + if (m_executed) { + for (SegmentSelection::iterator i = m_selection.begin(); + i != m_selection.end(); ++i) { + delete *i; + } + } else { + for (unsigned int i = 0; i < m_newSegments.size(); ++i) + delete m_newSegments[i]; + } +} + +void +AudioSegmentDistributeCommand::execute() +{ + // Store the insert times in a local vector + // + std::vector<timeT> insertTimes; + + bool addNew = m_newSegments.size() == 0 ? true : false; + + for (SegmentSelection::iterator i = m_selection.begin(); + i != m_selection.end(); ++i) { + // For MIDI (Internal) Segments only of course + // + if ((*i)->getType() == Segment::Internal) { + if (addNew) { + for (Segment::iterator it = (*i)->begin(); + it != (*i)->end(); ++it) { + if ((*it)->isa(Note::EventType)) { + Segment *segment = + new Segment( + Segment::Audio, + (*it)->getAbsoluteTime()); + segment->setTrack((*i)->getTrack()); + + // If we've constructed against an AudioFile + // + if (m_audioFile) { + segment->setAudioFileId(m_audioFile->getId()); + segment->setAudioStartTime( + RealTime::zeroTime); + segment->setAudioEndTime( + m_audioFile->getLength()); + } else // or an audio Segment + { + segment->setAudioFileId( + m_audioSegment->getAudioFileId()); + segment->setAudioStartTime( + m_audioSegment->getAudioStartTime()); + segment->setAudioEndTime( + m_audioSegment->getAudioEndTime()); + } + + m_composition->addSegment(segment); + m_newSegments.push_back(segment); + } + } + } + + // Detach original Segment + // + m_composition->detachSegment(*i); + } + + } + + if (!addNew && m_newSegments.size()) { + // Reattach new segments + // + for (unsigned int i = 0; i < m_newSegments.size(); ++i) + m_composition->addSegment(m_newSegments[i]); + } + + m_executed = true; +} + +void +AudioSegmentDistributeCommand::unexecute() +{ + for (unsigned int i = 0; i < m_newSegments.size(); ++i) + m_composition->detachSegment(m_newSegments[i]); + + for (SegmentSelection::iterator it = m_selection.begin(); + it != m_selection.end(); ++it) + m_composition->addSegment(*it); + + m_executed = false; +} + +} diff --git a/src/commands/segment/AudioSegmentDistributeCommand.h b/src/commands/segment/AudioSegmentDistributeCommand.h new file mode 100644 index 0000000..d325daf --- /dev/null +++ b/src/commands/segment/AudioSegmentDistributeCommand.h @@ -0,0 +1,86 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_AUDIOSEGMENTDISTRIBUTECOMMAND_H_ +#define _RG_AUDIOSEGMENTDISTRIBUTECOMMAND_H_ + +#include "base/Selection.h" +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; +class AudioFile; + + +/** + * AudioSegmentDistributeCommand - Distribute an Audio Segment triggered + * against the MIDI Note ons in a SegmentSelection. + * + * (I think this is actually unused --cc) + */ +class AudioSegmentDistributeCommand : public KNamedCommand +{ +public: + AudioSegmentDistributeCommand(Composition *comp, + SegmentSelection &inputSelection, + Segment *audioSegment); + + AudioSegmentDistributeCommand(Composition *comp, + SegmentSelection &inputSelection, + AudioFile *audioFile); + + virtual ~AudioSegmentDistributeCommand(); + + static QString getGlobalName() + { return i18n("Distribute Audio Segments over MIDI"); } + + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + SegmentSelection m_selection; + AudioFile *m_audioFile; + Segment *m_audioSegment; + std::vector<Segment*> m_newSegments; + bool m_executed; + +}; + + + +} + +#endif diff --git a/src/commands/segment/AudioSegmentInsertCommand.cpp b/src/commands/segment/AudioSegmentInsertCommand.cpp new file mode 100644 index 0000000..b5167f7 --- /dev/null +++ b/src/commands/segment/AudioSegmentInsertCommand.cpp @@ -0,0 +1,136 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AudioSegmentInsertCommand.h" + +#include <klocale.h> +#include "misc/Debug.h" +#include "misc/Strings.h" +#include "base/Composition.h" +#include "base/RealTime.h" +#include "base/Segment.h" +#include "base/Studio.h" +#include "base/Track.h" +#include "document/RosegardenGUIDoc.h" +#include "gui/general/GUIPalette.h" +#include "sound/AudioFile.h" +#include "sound/AudioFileManager.h" + + +namespace Rosegarden +{ + +AudioSegmentInsertCommand::AudioSegmentInsertCommand(RosegardenGUIDoc *doc, + TrackId track, + timeT startTime, + AudioFileId audioFileId, + const RealTime &audioStartTime, + const RealTime &audioEndTime): + KNamedCommand(i18n("Create Segment")), + m_composition(&(doc->getComposition())), + m_audioFileManager(&(doc->getAudioFileManager())), + m_segment(0), + m_track(track), + m_startTime(startTime), + m_audioFileId(audioFileId), + m_audioStartTime(audioStartTime), + m_audioEndTime(audioEndTime), + m_detached(false) +{} + +AudioSegmentInsertCommand::~AudioSegmentInsertCommand() +{ + if (m_detached) { + delete m_segment; + } +} + +void +AudioSegmentInsertCommand::execute() +{ + if (!m_segment) { + // Create and insert Segment + // + m_segment = new Segment(Segment::Audio); + m_segment->setTrack(m_track); + m_segment->setStartTime(m_startTime); + m_segment->setAudioStartTime(m_audioStartTime); + m_segment->setAudioEndTime(m_audioEndTime); + m_segment->setAudioFileId(m_audioFileId); + + // Set color for audio segment (DMM) + // + m_segment->setColourIndex(GUIPalette::AudioDefaultIndex); + + // Calculate end time + // + RealTime startTime = + m_composition->getElapsedRealTime(m_startTime); + + RealTime endTime = + startTime + m_audioEndTime - m_audioStartTime; + + timeT endTimeT = m_composition->getElapsedTimeForRealTime(endTime); + + RG_DEBUG << "AudioSegmentInsertCommand::execute : start timeT " + << m_startTime << ", startTime " << startTime << ", audioStartTime " << m_audioStartTime << ", audioEndTime " << m_audioEndTime << ", endTime " << endTime << ", end timeT " << endTimeT << endl; + + m_segment->setEndTime(endTimeT); + + if (endTimeT > m_composition->getEndMarker()) { + m_composition->setEndMarker(m_composition->getBarEndForTime(endTimeT)); + } + + // Label by audio file name + // + std::string label = ""; + + AudioFile *aF = + m_audioFileManager->getAudioFile(m_audioFileId); + + if (aF) + label = qstrtostr(i18n("%1 (inserted)").arg + (strtoqstr(aF->getName()))); + else + label = qstrtostr(i18n("unknown audio file")); + + m_segment->setLabel(label); + + m_composition->addSegment(m_segment); + } else { + m_composition->addSegment(m_segment); + } + + m_detached = false; +} + +void +AudioSegmentInsertCommand::unexecute() +{ + m_composition->detachSegment(m_segment); + m_detached = true; +} + +} diff --git a/src/commands/segment/AudioSegmentInsertCommand.h b/src/commands/segment/AudioSegmentInsertCommand.h new file mode 100644 index 0000000..3510833 --- /dev/null +++ b/src/commands/segment/AudioSegmentInsertCommand.h @@ -0,0 +1,77 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_AUDIOSEGMENTINSERTCOMMAND_H_ +#define _RG_AUDIOSEGMENTINSERTCOMMAND_H_ + +#include "base/RealTime.h" +#include "base/Track.h" +#include "sound/AudioFile.h" +#include <kcommand.h> +#include "base/Event.h" + + +namespace Rosegarden +{ + +class Studio; +class Segment; +class RosegardenGUIDoc; +class Composition; +class AudioFileManager; + + +class AudioSegmentInsertCommand : public KNamedCommand +{ +public: + AudioSegmentInsertCommand(RosegardenGUIDoc *doc, + TrackId track, + timeT startTime, + AudioFileId audioFileId, + const RealTime &audioStartTime, + const RealTime &audioEndTime); + virtual ~AudioSegmentInsertCommand(); + + Segment *getNewSegment() { return m_segment; } + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + AudioFileManager *m_audioFileManager; + Segment *m_segment; + int m_track; + timeT m_startTime; + AudioFileId m_audioFileId; + RealTime m_audioStartTime; + RealTime m_audioEndTime; + bool m_detached; +}; + + +} + +#endif diff --git a/src/commands/segment/AudioSegmentRescaleCommand.cpp b/src/commands/segment/AudioSegmentRescaleCommand.cpp new file mode 100644 index 0000000..1386783 --- /dev/null +++ b/src/commands/segment/AudioSegmentRescaleCommand.cpp @@ -0,0 +1,210 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AudioSegmentRescaleCommand.h" + +#include "misc/Strings.h" +#include "base/Event.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include "document/RosegardenGUIDoc.h" +#include "sound/AudioFileTimeStretcher.h" +#include "sound/AudioFileManager.h" +#include "gui/widgets/ProgressDialog.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +AudioSegmentRescaleCommand::AudioSegmentRescaleCommand(RosegardenGUIDoc *doc, + Segment *s, + float ratio) : + KNamedCommand(getGlobalName()), + m_afm(&doc->getAudioFileManager()), + m_stretcher(new AudioFileTimeStretcher(m_afm)), + m_segment(s), + m_newSegment(0), + m_fid(-1), + m_timesGiven(false), + m_startTime(0), + m_endMarkerTime(0), + m_ratio(ratio), + m_detached(false) +{ + // nothing +} + +AudioSegmentRescaleCommand::AudioSegmentRescaleCommand(RosegardenGUIDoc *doc, + Segment *s, + float ratio, + timeT st, + timeT emt) : + KNamedCommand(getGlobalName()), + m_afm(&doc->getAudioFileManager()), + m_stretcher(new AudioFileTimeStretcher(m_afm)), + m_segment(s), + m_newSegment(0), + m_fid(-1), + m_timesGiven(true), + m_startTime(st), + m_endMarkerTime(emt), + m_ratio(ratio), + m_detached(false) +{ + // nothing +} + +AudioSegmentRescaleCommand::~AudioSegmentRescaleCommand() +{ + delete m_stretcher; + + if (m_detached) { + delete m_segment; + } else { + delete m_newSegment; + } +} + +void +AudioSegmentRescaleCommand::connectProgressDialog(ProgressDialog *dlg) +{ + QObject::connect(m_stretcher, SIGNAL(setProgress(int)), + dlg->progressBar(), SLOT(setValue(int))); + QObject::connect(dlg, SIGNAL(cancelClicked()), + m_stretcher, SLOT(slotStopTimestretch())); +} + +void +AudioSegmentRescaleCommand::disconnectProgressDialog(ProgressDialog *dlg) +{ + QObject::disconnect(m_stretcher, SIGNAL(setProgress(int)), + dlg->progressBar(), SLOT(setValue(int))); + QObject::disconnect(dlg, SIGNAL(cancelClicked()), + m_stretcher, SLOT(slotStopTimestretch())); +} + +void +AudioSegmentRescaleCommand::execute() +{ + timeT startTime = m_segment->getStartTime(); + + if (m_segment->getType() != Segment::Audio) { + return; + } + + bool failed = false; + + if (!m_newSegment) { + + m_newSegment = new Segment(*m_segment); + + QString oldLabel = strtoqstr(m_segment->getLabel()); + if (!oldLabel.endsWith(i18n("(rescaled)"))) { + m_newSegment->setLabel(qstrtostr(i18n("%1 (rescaled)").arg + (oldLabel))); + } + + AudioFileId sourceFileId = m_segment->getAudioFileId(); + float absoluteRatio = m_ratio; + + std::cerr << "AudioSegmentRescaleCommand: segment file id " << sourceFileId << ", given ratio " << m_ratio << std::endl; + + if (m_segment->getStretchRatio() != 1.f && + m_segment->getStretchRatio() != 0.f) { + sourceFileId = m_segment->getUnstretchedFileId(); + absoluteRatio *= m_segment->getStretchRatio(); + std::cerr << "AudioSegmentRescaleCommand: unstretched file id " << sourceFileId << ", prev ratio " << m_segment->getStretchRatio() << ", resulting ratio " << absoluteRatio << std::endl; + } + + if (!m_timesGiven) { + m_endMarkerTime = m_segment->getStartTime() + + (m_segment->getEndMarkerTime() - m_segment->getStartTime()) * m_ratio; + } + + try { + m_fid = m_stretcher->getStretchedAudioFile(sourceFileId, + absoluteRatio); + m_newSegment->setAudioFileId(m_fid); + m_newSegment->setUnstretchedFileId(sourceFileId); + m_newSegment->setStretchRatio(absoluteRatio); + m_newSegment->setAudioStartTime(m_segment->getAudioStartTime() * + m_ratio); + if (m_timesGiven) { + m_newSegment->setStartTime(m_startTime); + m_newSegment->setAudioEndTime(m_segment->getAudioEndTime() * + m_ratio); + m_newSegment->setEndMarkerTime(m_endMarkerTime); + } else { + m_newSegment->setEndMarkerTime(m_endMarkerTime); + m_newSegment->setAudioEndTime(m_segment->getAudioEndTime() * + m_ratio); + } + } catch (SoundFile::BadSoundFileException e) { + std::cerr << "AudioSegmentRescaleCommand: ERROR: BadSoundFileException: " + << e.getMessage() << std::endl; + delete m_newSegment; + m_newSegment = 0; + m_fid = -1; + failed = true; + } catch (AudioFileManager::BadAudioPathException e) { + std::cerr << "AudioSegmentRescaleCommand: ERROR: BadAudioPathException: " + << e.getMessage() << std::endl; + delete m_newSegment; + m_newSegment = 0; + m_fid = -1; + failed = true; + } catch (AudioFileTimeStretcher::CancelledException e) { + std::cerr << "AudioSegmentRescaleCommand: ERROR: Rescale cancelled" << std::endl; + delete m_newSegment; + m_newSegment = 0; + m_fid = -1; + failed = true; + } + } + + if (failed) return; + + m_segment->getComposition()->addSegment(m_newSegment); + m_segment->getComposition()->detachSegment(m_segment); + +// m_newSegment->setEndMarkerTime +// (startTime + rescale(m_segment->getEndMarkerTime() - startTime)); + + m_detached = true; +} + +void +AudioSegmentRescaleCommand::unexecute() +{ + if (m_newSegment) { + m_newSegment->getComposition()->addSegment(m_segment); + m_newSegment->getComposition()->detachSegment(m_newSegment); + m_detached = false; + } +} + +} diff --git a/src/commands/segment/AudioSegmentRescaleCommand.h b/src/commands/segment/AudioSegmentRescaleCommand.h new file mode 100644 index 0000000..a4edb13 --- /dev/null +++ b/src/commands/segment/AudioSegmentRescaleCommand.h @@ -0,0 +1,81 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_AUDIOSEGMENTRESCALECOMMAND_H_ +#define _RG_AUDIOSEGMENTRESCALECOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include <klocale.h> + +namespace Rosegarden +{ + +class Segment; +class AudioFileManager; +class AudioFileTimeStretcher; +class RosegardenGUIDoc; +class ProgressDialog; + +class AudioSegmentRescaleCommand : public KNamedCommand +{ +public: + AudioSegmentRescaleCommand(RosegardenGUIDoc *doc, + Segment *segment, float ratio); + AudioSegmentRescaleCommand(RosegardenGUIDoc *doc, + Segment *segment, float ratio, + timeT newStartTime, + timeT newEndMarkerTime); + virtual ~AudioSegmentRescaleCommand(); + + virtual void execute(); + virtual void unexecute(); + + AudioFileTimeStretcher *getStretcher() { return m_stretcher; } + int getNewAudioFileId() const { return m_fid; } + + void connectProgressDialog(ProgressDialog *dlg); + void disconnectProgressDialog(ProgressDialog *dlg); + + static QString getGlobalName() { return i18n("Stretch or S&quash..."); } + +private: + AudioFileManager *m_afm; + AudioFileTimeStretcher *m_stretcher; + Segment *m_segment; + Segment *m_newSegment; + bool m_timesGiven; + timeT m_startTime; + timeT m_endMarkerTime; + int m_fid; + float m_ratio; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/AudioSegmentResizeFromStartCommand.cpp b/src/commands/segment/AudioSegmentResizeFromStartCommand.cpp new file mode 100644 index 0000000..5045500 --- /dev/null +++ b/src/commands/segment/AudioSegmentResizeFromStartCommand.cpp @@ -0,0 +1,87 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AudioSegmentResizeFromStartCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/RealTime.h" +#include "base/Segment.h" + + +namespace Rosegarden +{ + +AudioSegmentResizeFromStartCommand::AudioSegmentResizeFromStartCommand(Segment *segment, + timeT newStartTime) : + KNamedCommand(i18n("Resize Segment")), + m_segment(segment), + m_newSegment(0), + m_detached(false), + m_oldStartTime(segment->getStartTime()), + m_newStartTime(newStartTime) +{} + +AudioSegmentResizeFromStartCommand::~AudioSegmentResizeFromStartCommand() +{ + if (!m_detached) + delete m_segment; + else + delete m_newSegment; +} + +void +AudioSegmentResizeFromStartCommand::execute() +{ + Composition *c = m_segment->getComposition(); + + if (!m_newSegment) { + RealTime oldRT = c->getElapsedRealTime(m_oldStartTime); + RealTime newRT = c->getElapsedRealTime(m_newStartTime); + + m_newSegment = new Segment(*m_segment); + m_newSegment->setStartTime(m_newStartTime); + m_newSegment->setAudioStartTime(m_segment->getAudioStartTime() - + (oldRT - newRT)); + } + + c->addSegment(m_newSegment); + m_newSegment->setEndMarkerTime(m_segment->getEndMarkerTime()); + c->detachSegment(m_segment); + + m_detached = false; +} + +void +AudioSegmentResizeFromStartCommand::unexecute() +{ + Composition *c = m_newSegment->getComposition(); + c->addSegment(m_segment); + c->detachSegment(m_newSegment); + + m_detached = true; +} + +} diff --git a/src/commands/segment/AudioSegmentResizeFromStartCommand.h b/src/commands/segment/AudioSegmentResizeFromStartCommand.h new file mode 100644 index 0000000..734a6e0 --- /dev/null +++ b/src/commands/segment/AudioSegmentResizeFromStartCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_AUDIOSEGMENTRESIZEFROMSTARTCOMMAND_H_ +#define _RG_AUDIOSEGMENTRESIZEFROMSTARTCOMMAND_H_ + +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +/** + * As above, but for audio segments. + */ +class AudioSegmentResizeFromStartCommand : public KNamedCommand +{ +public: + AudioSegmentResizeFromStartCommand(Segment *segment, + timeT newStartTime); + virtual ~AudioSegmentResizeFromStartCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Segment *m_segment; + Segment *m_newSegment; + bool m_detached; + timeT m_oldStartTime; + timeT m_newStartTime; +}; + + + +} + +#endif diff --git a/src/commands/segment/AudioSegmentSplitCommand.cpp b/src/commands/segment/AudioSegmentSplitCommand.cpp new file mode 100644 index 0000000..f0c462e --- /dev/null +++ b/src/commands/segment/AudioSegmentSplitCommand.cpp @@ -0,0 +1,155 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "AudioSegmentSplitCommand.h" + +#include <klocale.h> +#include "misc/Debug.h" +#include "misc/Strings.h" +#include "base/RealTime.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +AudioSegmentSplitCommand::AudioSegmentSplitCommand(Segment *segment, + timeT splitTime) : + KNamedCommand(i18n("Split Audio Segment")), + m_segment(segment), + m_newSegment(0), + m_splitTime(splitTime), + m_previousEndMarkerTime(0), + m_detached(false) +{} + +AudioSegmentSplitCommand::~AudioSegmentSplitCommand() +{ + if (m_detached) { + delete m_newSegment; + } + delete m_previousEndMarkerTime; +} + +void +AudioSegmentSplitCommand::execute() +{ + if (!m_newSegment) { + + m_newSegment = new Segment(Segment::Audio); + + // Basics + // + m_newSegment->setAudioFileId(m_segment->getAudioFileId()); + m_newSegment->setTrack(m_segment->getTrack()); + + // Get the RealTime split time + // + RealTime splitDiff = + m_segment->getComposition()->getRealTimeDifference( + m_segment->getStartTime(), m_splitTime); + + // Set audio start and end + // + m_newSegment->setAudioStartTime + (m_segment->getAudioStartTime() + splitDiff); + m_newSegment->setAudioEndTime(m_segment->getAudioEndTime()); + + // Insert into composition before setting end time + // + m_segment->getComposition()->addSegment(m_newSegment); + + // Set start and end times + // + m_newSegment->setStartTime(m_splitTime); + m_newSegment->setEndTime(m_segment->getEndTime()); + + // Set original end time + // + // m_previousEndAudioTime = m_segment->getAudioEndTime(); + // m_segment->setAudioEndTime(m_newSegment->getAudioStartTime()); + + RG_DEBUG << "AudioSegmentSplitCommand::execute: Set end audio of left segment to " << m_newSegment->getAudioStartTime() << endl; + + + // Set labels + // + m_segmentLabel = m_segment->getLabel(); + QString newLabel = strtoqstr(m_segmentLabel); + if (!newLabel.endsWith(i18n(" (split)"))) { + newLabel = i18n("%1 (split)").arg(newLabel); + } + m_segment->setLabel(qstrtostr(newLabel)); + m_newSegment->setLabel(m_segment->getLabel()); + + // Set color + // + m_newSegment->setColourIndex(m_segment->getColourIndex()); + } + + // Resize left hand Segment + // + const timeT *emt = m_segment->getRawEndMarkerTime(); + if (emt) { + m_previousEndMarkerTime = new timeT(*emt); + } else { + m_previousEndMarkerTime = 0; + } + + RG_DEBUG << "AudioSegmentSplitCommand::execute: Setting end marker of left segment to " << m_splitTime << endl; + + m_segment->setEndMarkerTime(m_splitTime); + + if (!m_newSegment->getComposition()) { + m_segment->getComposition()->addSegment(m_newSegment); + } + + m_detached = false; + +} + +void +AudioSegmentSplitCommand::unexecute() +{ + if (m_previousEndMarkerTime) { + RG_DEBUG << "AudioSegmentSplitCommand::unexecute: Restoring end marker of left segment to " << *m_previousEndMarkerTime << endl; + + m_segment->setEndMarkerTime(*m_previousEndMarkerTime); + delete m_previousEndMarkerTime; + m_previousEndMarkerTime = 0; + } else { + m_segment->clearEndMarker(); + } + + m_segment->setLabel(m_segmentLabel); + // RG_DEBUG << "AudioSegmentSplitCommand::unexecute: Setting audio end time of left segment to " << m_previousEndAudioTime << endl; + // m_segment->setAudioEndTime(m_previousEndAudioTime); + m_segment->getComposition()->detachSegment(m_newSegment); + m_detached = true; +} + +} diff --git a/src/commands/segment/AudioSegmentSplitCommand.h b/src/commands/segment/AudioSegmentSplitCommand.h new file mode 100644 index 0000000..ce7c59c --- /dev/null +++ b/src/commands/segment/AudioSegmentSplitCommand.h @@ -0,0 +1,65 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_AUDIOSEGMENTSPLITCOMMAND_H_ +#define _RG_AUDIOSEGMENTSPLITCOMMAND_H_ + +#include <string> +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +class AudioSegmentSplitCommand : public KNamedCommand +{ +public: + AudioSegmentSplitCommand(Segment *segment, + timeT splitTime); + virtual ~AudioSegmentSplitCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Segment *m_segment; + Segment *m_newSegment; + timeT m_splitTime; + timeT *m_previousEndMarkerTime; + bool m_detached; + std::string m_segmentLabel; +// RealTime m_previousEndAudioTime; +}; + + +} + +#endif diff --git a/src/commands/segment/ChangeCompositionLengthCommand.cpp b/src/commands/segment/ChangeCompositionLengthCommand.cpp new file mode 100644 index 0000000..bdeb7a5 --- /dev/null +++ b/src/commands/segment/ChangeCompositionLengthCommand.cpp @@ -0,0 +1,64 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "ChangeCompositionLengthCommand.h" + +#include "base/Composition.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +ChangeCompositionLengthCommand::ChangeCompositionLengthCommand( + Composition *composition, + timeT startTime, + timeT endTime): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_startTime(startTime), + m_endTime(endTime), + m_oldStartTime(m_composition->getStartMarker()), + m_oldEndTime(m_composition->getEndMarker()) +{} + +ChangeCompositionLengthCommand::~ChangeCompositionLengthCommand() +{} + +void +ChangeCompositionLengthCommand::execute() +{ + m_composition->setStartMarker(m_startTime); + m_composition->setEndMarker(m_endTime); +} + +void +ChangeCompositionLengthCommand::unexecute() +{ + m_composition->setStartMarker(m_oldStartTime); + m_composition->setEndMarker(m_oldEndTime); +} + +} diff --git a/src/commands/segment/ChangeCompositionLengthCommand.h b/src/commands/segment/ChangeCompositionLengthCommand.h new file mode 100644 index 0000000..9e0db9b --- /dev/null +++ b/src/commands/segment/ChangeCompositionLengthCommand.h @@ -0,0 +1,70 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_CHANGECOMPOSITIONLENGTHCOMMAND_H_ +#define _RG_CHANGECOMPOSITIONLENGTHCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include <klocale.h> + + +class Change; + + +namespace Rosegarden +{ + +class Composition; + + +class ChangeCompositionLengthCommand : public KNamedCommand +{ +public: + ChangeCompositionLengthCommand(Composition *composition, + timeT startTime, + timeT endTime); + virtual ~ChangeCompositionLengthCommand(); + + static QString getGlobalName() + { return i18n("Change &Composition Start and End..."); } + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + timeT m_startTime; + timeT m_endTime; + timeT m_oldStartTime; + timeT m_oldEndTime; + +}; + + +} + +#endif diff --git a/src/commands/segment/CreateTempoMapFromSegmentCommand.cpp b/src/commands/segment/CreateTempoMapFromSegmentCommand.cpp new file mode 100644 index 0000000..e548875 --- /dev/null +++ b/src/commands/segment/CreateTempoMapFromSegmentCommand.cpp @@ -0,0 +1,166 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "CreateTempoMapFromSegmentCommand.h" + +#include <klocale.h> +#include "misc/Debug.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/RealTime.h" +#include "base/Segment.h" + + +namespace Rosegarden +{ + +CreateTempoMapFromSegmentCommand::CreateTempoMapFromSegmentCommand(Segment *groove) : + KNamedCommand(i18n("Set Tempos from Beat Segment")), + m_composition(groove->getComposition()) +{ + initialise(groove); +} + +CreateTempoMapFromSegmentCommand::~CreateTempoMapFromSegmentCommand() +{ + // nothing +} + +void +CreateTempoMapFromSegmentCommand::execute() +{ + for (TempoMap::iterator i = m_oldTempi.begin(); i != m_oldTempi.end(); ++i) { + int n = m_composition->getTempoChangeNumberAt(i->first); + if (n < m_composition->getTempoChangeCount()) { + m_composition->removeTempoChange(n); + } + } + + for (TempoMap::iterator i = m_newTempi.begin(); i != m_newTempi.end(); ++i) { + m_composition->addTempoAtTime(i->first, i->second); + } +} + +void +CreateTempoMapFromSegmentCommand::unexecute() +{ + for (TempoMap::iterator i = m_newTempi.begin(); i != m_newTempi.end(); ++i) { + int n = m_composition->getTempoChangeNumberAt(i->first); + if (n < m_composition->getTempoChangeCount()) { + m_composition->removeTempoChange(n); + } + } + + for (TempoMap::iterator i = m_oldTempi.begin(); i != m_oldTempi.end(); ++i) { + m_composition->addTempoAtTime(i->first, i->second); + } +} + +void +CreateTempoMapFromSegmentCommand::initialise(Segment *s) +{ + m_oldTempi.clear(); + m_newTempi.clear(); + + //!!! need an additional option: per-chord, per-beat, per-bar. + // Let's work per-beat for the moment. Even for this, we should + // probably use TimeSignature.getDivisions() + + std::vector<timeT> beatTimeTs; + std::vector<RealTime> beatRealTimes; + + int startBar = m_composition->getBarNumber(s->getStartTime()); + int barNo = startBar; + int beat = 0; + + for (Segment::iterator i = s->begin(); s->isBeforeEndMarker(i); ++i) { + if ((*i)->isa(Note::EventType)) { + + bool isNew; + TimeSignature sig = + m_composition->getTimeSignatureInBar(barNo, isNew); + + beatTimeTs.push_back(m_composition->getBarStart(barNo) + + beat * sig.getBeatDuration()); + + if (++beat >= sig.getBeatsPerBar()) { + ++barNo; + beat = 0; + } + + beatRealTimes.push_back(s->getComposition()->getElapsedRealTime + ((*i)->getAbsoluteTime())); + } + } + + if (beatTimeTs.size() < 2) + return ; + + tempoT prevTempo = 0; + + // set up m_oldTempi and prevTempo + + for (int i = m_composition->getTempoChangeNumberAt(*beatTimeTs.begin() - 1) + 1; + i <= m_composition->getTempoChangeNumberAt(*beatTimeTs.end() - 1); ++i) { + + std::pair<timeT, tempoT> tempoChange = + m_composition->getTempoChange(i); + m_oldTempi[tempoChange.first] = tempoChange.second; + if (prevTempo == 0) + prevTempo = tempoChange.second; + } + + RG_DEBUG << "starting tempo: " << prevTempo << endl; + + timeT quarter = Note(Note::Crotchet).getDuration(); + + for (int beat = 1; beat < beatTimeTs.size(); ++beat) { + + timeT beatTime = beatTimeTs[beat] - beatTimeTs[beat - 1]; + RealTime beatRealTime = beatRealTimes[beat] - beatRealTimes[beat - 1]; + + // Calculate tempo to nearest qpm. + // This is 60 / {quarter note duration in seconds} + // = 60 / ( {beat in seconds} * {quarter in ticks} / { beat in ticks} ) + // = ( 60 * {beat in ticks} ) / ( {beat in seconds} * {quarter in ticks} ) + // Precision is deliberately limited to qpm to avoid silly values. + + double beatSec = double(beatRealTime.sec) + + double(beatRealTime.usec() / 1000000.0); + double qpm = (60.0 * beatTime) / (beatSec * quarter); + tempoT tempo = Composition::getTempoForQpm(int(qpm + 0.001)); + + RG_DEBUG << "prev beat: " << beatTimeTs[beat] << ", prev beat real time " << beatRealTimes[beat] << endl; + RG_DEBUG << "time " << beatTime << ", rt " << beatRealTime << ", beatSec " << beatSec << ", tempo " << tempo << endl; + + if (tempo != prevTempo) { + m_newTempi[beatTimeTs[beat - 1]] = tempo; + prevTempo = tempo; + } + } + +} + +} diff --git a/src/commands/segment/CreateTempoMapFromSegmentCommand.h b/src/commands/segment/CreateTempoMapFromSegmentCommand.h new file mode 100644 index 0000000..f6ea4d5 --- /dev/null +++ b/src/commands/segment/CreateTempoMapFromSegmentCommand.h @@ -0,0 +1,69 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_CREATETEMPOMAPFROMSEGMENTCOMMAND_H_ +#define _RG_CREATETEMPOMAPFROMSEGMENTCOMMAND_H_ + +#include <map> +#include <kcommand.h> +#include "base/Event.h" +#include "base/Composition.h" // for tempoT + + + + +namespace Rosegarden +{ + + +/** + * CreateTempoMapFromSegment applies timings found in a reference + * segment to the composition as a whole via the tempo map. + */ + +class CreateTempoMapFromSegmentCommand : public KNamedCommand +{ +public: + CreateTempoMapFromSegmentCommand(Segment *grooveSegment); + virtual ~CreateTempoMapFromSegmentCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + void initialise(Segment *s); + + Composition *m_composition; + + typedef std::map<timeT, tempoT> TempoMap; + TempoMap m_oldTempi; + TempoMap m_newTempi; +}; + + + +} + +#endif diff --git a/src/commands/segment/CutRangeCommand.cpp b/src/commands/segment/CutRangeCommand.cpp new file mode 100644 index 0000000..df91398 --- /dev/null +++ b/src/commands/segment/CutRangeCommand.cpp @@ -0,0 +1,47 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "CutRangeCommand.h" + +#include <klocale.h> +#include "base/Clipboard.h" +#include "base/Composition.h" +#include "commands/edit/CopyCommand.h" +#include "DeleteRangeCommand.h" + + +namespace Rosegarden +{ + +CutRangeCommand::CutRangeCommand(Composition *composition, + timeT t0, timeT t1, + Clipboard *clipboard) : + KMacroCommand(i18n("Cut Range")) +{ + addCommand(new CopyCommand(composition, t0, t1, clipboard)); + addCommand(new DeleteRangeCommand(composition, t0, t1)); +} + +} diff --git a/src/commands/segment/CutRangeCommand.h b/src/commands/segment/CutRangeCommand.h new file mode 100644 index 0000000..f2b3402 --- /dev/null +++ b/src/commands/segment/CutRangeCommand.h @@ -0,0 +1,53 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_CUTRANGECOMMAND_H_ +#define _RG_CUTRANGECOMMAND_H_ + +#include "base/Event.h" +#include <kcommand.h> + + +namespace Rosegarden +{ + +class Composition; +class Clipboard; + + +class CutRangeCommand : public KMacroCommand +{ +public: + CutRangeCommand(Composition *composition, + timeT begin, + timeT end, + Clipboard *clipboard); +}; + + + +} + +#endif diff --git a/src/commands/segment/DeleteRangeCommand.cpp b/src/commands/segment/DeleteRangeCommand.cpp new file mode 100644 index 0000000..05ec79f --- /dev/null +++ b/src/commands/segment/DeleteRangeCommand.cpp @@ -0,0 +1,127 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "DeleteRangeCommand.h" + +#include "AudioSegmentSplitCommand.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include "base/Selection.h" +#include "EraseSegmentsStartingInRangeCommand.h" +#include "OpenOrCloseRangeCommand.h" +#include "SegmentJoinCommand.h" +#include "SegmentSplitCommand.h" + + +namespace Rosegarden +{ + +DeleteRangeCommand::DeleteRangeCommand(Composition *composition, + timeT t0, timeT t1) : + KMacroCommand(i18n("Delete Range")) +{ + // First add commands to split the segments up. Make a note of + // segments that will need rejoining with their neighbours + // afterwards. + + std::vector<Segment *> rejoins; + + for (int e = 0; e < 2; ++e) { + + // Split all segments at the range end first, then the range + // begin afterwards. This is because the split commands create + // new segments for the right part and leave the left parts in + // the original segments, so that we can use the same segment + // pointer to do the left split as we did for the right + + timeT t = t1; + if (e == 1) + t = t0; + + for (Composition::iterator i = composition->begin(); + i != composition->end(); ++i) { + + if ((*i)->getStartTime() >= t || (*i)->getEndMarkerTime() <= t) { + continue; + } + + if ((*i)->getType() == Segment::Audio) { + addCommand(new AudioSegmentSplitCommand(*i, t)); + } else { + addCommand(new SegmentSplitCommand(*i, t)); + + if (t == t0 && (*i)->getEndMarkerTime() > t1) { + rejoins.push_back(*i); + } + } + } + } + + // Then commands to do the rest of the work + + addCommand(new EraseSegmentsStartingInRangeCommand(composition, t0, t1)); + + addCommand(new OpenOrCloseRangeCommand(composition, t0, t1, false)); + + for (std::vector<Segment *>::iterator i = rejoins.begin(); + i != rejoins.end(); ++i) { + addCommand(new RejoinCommand(composition, *i, + (*i)->getEndMarkerTime() + t0 - t1)); + } +} + +DeleteRangeCommand::~DeleteRangeCommand() +{} + +void +DeleteRangeCommand::RejoinCommand::execute() +{ + if (m_joinCommand) { + m_joinCommand->execute(); + return ; + } + + //!!! Need to remove the "(split)" names from the segment bits + + for (Composition::iterator i = m_composition->begin(); + i != m_composition->end(); ++i) { + if ((*i) == m_segment) + continue; + if ((*i)->getTrack() != m_segment->getTrack()) + continue; + if ((*i)->getEndMarkerTime() != m_endMarkerTime) + continue; + if ((*i)->getStartTime() <= m_segment->getStartTime()) + continue; + SegmentSelection selection; + selection.insert(m_segment); + selection.insert(*i); + m_joinCommand = new SegmentJoinCommand(selection); + m_joinCommand->execute(); + break; + } +} + +} diff --git a/src/commands/segment/DeleteRangeCommand.h b/src/commands/segment/DeleteRangeCommand.h new file mode 100644 index 0000000..6b198ea --- /dev/null +++ b/src/commands/segment/DeleteRangeCommand.h @@ -0,0 +1,84 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_DELETERANGECOMMAND_H_ +#define _RG_DELETERANGECOMMAND_H_ + +#include <kcommand.h> +#include "base/Event.h" +#include <klocale.h> + +#include "SegmentJoinCommand.h" + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class DeleteRangeCommand : public KMacroCommand +{ +public: + DeleteRangeCommand(Composition *composition, + timeT begin, + timeT end); + virtual ~DeleteRangeCommand(); + +private: + class RejoinCommand : public KNamedCommand + { + public: + // This command rejoins s on to a subsequent segment on the same + // track that ends at endMarkerTime (presumably the original end + // marker time of s, with the range duration subtracted). + + RejoinCommand(Composition *c, + Segment *s, + timeT endMarkerTime) : + KNamedCommand(i18n("Rejoin Command")), + m_composition(c), m_segment(s), m_endMarkerTime(endMarkerTime), + m_joinCommand(0) { } + + ~RejoinCommand() { delete m_joinCommand; } + + void execute(); + void unexecute() { if (m_joinCommand) m_joinCommand->unexecute(); } + + private: + Composition *m_composition; + Segment *m_segment; + timeT m_endMarkerTime; + + SegmentJoinCommand *m_joinCommand; + }; +}; + + + +} + +#endif diff --git a/src/commands/segment/DeleteTracksCommand.cpp b/src/commands/segment/DeleteTracksCommand.cpp new file mode 100644 index 0000000..bad2be0 --- /dev/null +++ b/src/commands/segment/DeleteTracksCommand.cpp @@ -0,0 +1,161 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "DeleteTracksCommand.h" + +#include "misc/Debug.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +DeleteTracksCommand::DeleteTracksCommand(Composition *composition, + std::vector<TrackId> tracks): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_tracks(tracks), + m_detached(false) +{} + +DeleteTracksCommand::~DeleteTracksCommand() +{ + if (m_detached) { + for (unsigned int i = 0; i < m_oldTracks.size(); ++i) + delete m_oldTracks[i]; + + for (unsigned int i = 0; i < m_oldSegments.size(); ++i) + delete m_oldSegments[i]; + + m_oldTracks.clear(); + m_oldSegments.clear(); + } +} + +void DeleteTracksCommand::execute() +{ + Track *track = 0; + const Composition::segmentcontainer &segments = + m_composition->getSegments(); + + //cout << "DeleteTracksCommand::execute()" << endl; + + m_oldSegments.clear(); + m_oldTracks.clear(); + + // Remap positions and track numbers + // + + Composition::trackiterator tit; + Composition::trackcontainer + &tracks = m_composition->getTracks(); + + for (unsigned int i = 0; i < m_tracks.size(); ++i) { + // detach segments and store tracks somewhere + track = m_composition->getTrackById(m_tracks[i]); + + if (track) { + // detach all segments for that track + // + for (Composition::segmentcontainer::const_iterator + it = segments.begin(); + it != segments.end(); ++it) { + if ((*it)->getTrack() == m_tracks[i]) { + m_oldSegments.push_back(*it); + m_composition->detachSegment(*it); + } + } + + // store old tracks + m_oldTracks.push_back(track); + if (m_composition->detachTrack(track) == false) { + RG_DEBUG << "DeleteTracksCommand::execute - can't detach track" << endl; + } + } + } + + std::vector<Track*>::iterator otIt; + for (otIt = m_oldTracks.begin(); otIt != m_oldTracks.end(); ++otIt) { + for (tit = tracks.begin(); tit != tracks.end(); ++tit) { + if ((*tit).second->getPosition() > (*otIt)->getPosition()) { + // If the track we've removed was after the current + // track then decrement the track position. + // + int newPosition = (*tit).second->getPosition() - 1; + + (*tit).second->setPosition(newPosition); + + } + } + } + + m_detached = true; +} + +void DeleteTracksCommand::unexecute() +{ + // Add the tracks and the segments back in + // + + // Remap positions and track numbers + // + Composition::trackcontainer + &tracks = m_composition->getTracks(); + Composition::trackiterator tit; + + std::vector<Track*>::iterator otIt; + for (otIt = m_oldTracks.begin(); otIt != m_oldTracks.end(); ++otIt) { + // From the back we shuffle out the tracks to allow the new + // (old) track some space to come back in. + // + tit = tracks.end(); + while (true) { + --tit; + + if ((*tit).second->getPosition() >= (*otIt)->getPosition()) { + // If the track we're adding has position after the + // current track then increment position. + // + int newPosition = (*tit).second->getPosition() + 1; + + (*tit).second->setPosition(newPosition); + } + + if (tit == tracks.begin()) + break; + } + + m_composition->addTrack(*otIt); + } + + for (unsigned int i = 0; i < m_oldSegments.size(); ++i) + m_composition->addSegment(m_oldSegments[i]); + + m_detached = false; +} + +} diff --git a/src/commands/segment/DeleteTracksCommand.h b/src/commands/segment/DeleteTracksCommand.h new file mode 100644 index 0000000..d1d2332 --- /dev/null +++ b/src/commands/segment/DeleteTracksCommand.h @@ -0,0 +1,68 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_DELETETRACKSCOMMAND_H_ +#define _RG_DELETETRACKSCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> +#include "base/Track.h" + + +namespace Rosegarden +{ + +class Track; +class Segment; +class Composition; + + +class DeleteTracksCommand : public KNamedCommand +{ +public: + DeleteTracksCommand(Composition *composition, + std::vector<TrackId> tracks); + virtual ~DeleteTracksCommand(); + + static QString getGlobalName() { return i18n("Delete Tracks..."); } + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + std::vector<TrackId> m_tracks; + + std::vector<Track*> m_oldTracks; + std::vector<Segment*> m_oldSegments; + bool m_detached; +}; + + +} + +#endif diff --git a/src/commands/segment/DeleteTriggerSegmentCommand.cpp b/src/commands/segment/DeleteTriggerSegmentCommand.cpp new file mode 100644 index 0000000..3ddb4af --- /dev/null +++ b/src/commands/segment/DeleteTriggerSegmentCommand.cpp @@ -0,0 +1,78 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "DeleteTriggerSegmentCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" +#include "base/TriggerSegment.h" +#include "document/RosegardenGUIDoc.h" + + +namespace Rosegarden +{ + +DeleteTriggerSegmentCommand::DeleteTriggerSegmentCommand(RosegardenGUIDoc *doc, + TriggerSegmentId id) : + KNamedCommand(i18n("Delete Triggered Segment")), + m_composition(&doc->getComposition()), + m_id(id), + m_segment(0), + m_basePitch( -1), + m_baseVelocity( -1), + m_detached(true) +{ + // nothing else +} + +DeleteTriggerSegmentCommand::~DeleteTriggerSegmentCommand() +{ + if (m_detached) + delete m_segment; +} + +void +DeleteTriggerSegmentCommand::execute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + m_segment = rec->getSegment(); + m_basePitch = rec->getBasePitch(); + m_baseVelocity = rec->getBaseVelocity(); + m_composition->detachTriggerSegment(m_id); + m_detached = true; +} + +void +DeleteTriggerSegmentCommand::unexecute() +{ + if (m_segment) + m_composition->addTriggerSegment(m_segment, m_id, m_basePitch, m_baseVelocity); + m_detached = false; +} + +} diff --git a/src/commands/segment/DeleteTriggerSegmentCommand.h b/src/commands/segment/DeleteTriggerSegmentCommand.h new file mode 100644 index 0000000..30986f7 --- /dev/null +++ b/src/commands/segment/DeleteTriggerSegmentCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_DELETETRIGGERSEGMENTCOMMAND_H_ +#define _RG_DELETETRIGGERSEGMENTCOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Segment; +class RosegardenGUIDoc; +class Composition; + + +class DeleteTriggerSegmentCommand : public KNamedCommand +{ +public: + DeleteTriggerSegmentCommand(RosegardenGUIDoc *doc, + TriggerSegmentId); + virtual ~DeleteTriggerSegmentCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + TriggerSegmentId m_id; + Segment *m_segment; + int m_basePitch; + int m_baseVelocity; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/EraseSegmentsStartingInRangeCommand.cpp b/src/commands/segment/EraseSegmentsStartingInRangeCommand.cpp new file mode 100644 index 0000000..35f7f10 --- /dev/null +++ b/src/commands/segment/EraseSegmentsStartingInRangeCommand.cpp @@ -0,0 +1,99 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "EraseSegmentsStartingInRangeCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" + + +namespace Rosegarden +{ + +EraseSegmentsStartingInRangeCommand::EraseSegmentsStartingInRangeCommand( + Composition *composition, + timeT t0, timeT t1) : + KNamedCommand(i18n("Delete Range")), + m_composition(composition), + m_beginTime(t0), + m_endTime(t1), + m_detached(false) +{} + +EraseSegmentsStartingInRangeCommand::~EraseSegmentsStartingInRangeCommand() +{ + if (m_detached) { + for (std::vector<Segment *>::iterator i = m_detaching.begin(); + i != m_detaching.end(); ++i) { + delete *i; + } + } +} + +void +EraseSegmentsStartingInRangeCommand::execute() +{ + if (m_detaching.empty()) { + + for (Composition::iterator i = m_composition->begin(); + i != m_composition->end(); ++i) { + + if ((*i)->getStartTime() >= m_beginTime && + (*i)->getStartTime() < m_endTime) { + m_detaching.push_back(*i); + } + } + } + + for (std::vector<Segment *>::iterator i = m_detaching.begin(); + i != m_detaching.end(); ++i) { + m_composition->detachSegment(*i); + } + + m_detached = true; +} + +void +EraseSegmentsStartingInRangeCommand::unexecute() +{ + for (std::vector<Segment *>::iterator i = m_detaching.begin(); + i != m_detaching.end(); ++i) { + + m_composition->addSegment(*i); + + //!!! see horrible code in SegmentEraseCommand::unexecute() + // to restore the audio file ID association in audio file mgr + // when an audio segment is restored. Why is this necessary? + // What is the agency that removed the audio file association + // in the first place, and why? Need to investigate that + // before heedlessly duplicating the same horrors here. + + } + + m_detached = false; +} + +} diff --git a/src/commands/segment/EraseSegmentsStartingInRangeCommand.h b/src/commands/segment/EraseSegmentsStartingInRangeCommand.h new file mode 100644 index 0000000..70b6978 --- /dev/null +++ b/src/commands/segment/EraseSegmentsStartingInRangeCommand.h @@ -0,0 +1,67 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_ERASESEGMENTSSTARTINGINRANGECOMMAND_H_ +#define _RG_ERASESEGMENTSSTARTINGINRANGECOMMAND_H_ + +#include <kcommand.h> +#include <vector> +#include "base/Event.h" +#include "gui/application/RosegardenDCOP.h" + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class EraseSegmentsStartingInRangeCommand : public KNamedCommand +{ +public: + EraseSegmentsStartingInRangeCommand(Composition *composition, + timeT begin, + timeT end); + virtual ~EraseSegmentsStartingInRangeCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + timeT m_beginTime; + timeT m_endTime; + + bool m_detached; + std::vector<Segment *> m_detaching; +}; + + +} + +#endif diff --git a/src/commands/segment/InsertRangeCommand.cpp b/src/commands/segment/InsertRangeCommand.cpp new file mode 100644 index 0000000..73dc5fd --- /dev/null +++ b/src/commands/segment/InsertRangeCommand.cpp @@ -0,0 +1,63 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "InsertRangeCommand.h" + +#include <klocale.h> +#include "AudioSegmentSplitCommand.h" +#include "base/Clipboard.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include "OpenOrCloseRangeCommand.h" +#include "SegmentSplitCommand.h" + + +namespace Rosegarden +{ + +InsertRangeCommand::InsertRangeCommand(Composition *composition, + timeT t0, timeT duration) : + KMacroCommand(i18n("Insert Range")) +{ + // Need to split segments before opening, at t0 + + for (Composition::iterator i = composition->begin(); + i != composition->end(); ++i) { + + if ((*i)->getStartTime() >= t0 || (*i)->getEndMarkerTime() <= t0) { + continue; + } + + if ((*i)->getType() == Segment::Audio) { + addCommand(new AudioSegmentSplitCommand(*i, t0)); + } else { + addCommand(new SegmentSplitCommand(*i, t0)); + } + } + + addCommand(new OpenOrCloseRangeCommand(composition, t0, t0 + duration, true)); +} + +} diff --git a/src/commands/segment/InsertRangeCommand.h b/src/commands/segment/InsertRangeCommand.h new file mode 100644 index 0000000..e3960c8 --- /dev/null +++ b/src/commands/segment/InsertRangeCommand.h @@ -0,0 +1,47 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_INSERTRANGECOMMAND_H_ +#define _RG_INSERTRANGECOMMAND_H_ + +#include "base/Event.h" +#include <kcommand.h> + +namespace Rosegarden +{ + +class Composition; + +class InsertRangeCommand : public KMacroCommand +{ +public: + InsertRangeCommand(Composition *composition, + timeT startTime, timeT duration); +}; + + +} + +#endif diff --git a/src/commands/segment/ModifyDefaultTempoCommand.cpp b/src/commands/segment/ModifyDefaultTempoCommand.cpp new file mode 100644 index 0000000..88360a4 --- /dev/null +++ b/src/commands/segment/ModifyDefaultTempoCommand.cpp @@ -0,0 +1,48 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "ModifyDefaultTempoCommand.h" + +#include "base/Composition.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +void +ModifyDefaultTempoCommand::execute() +{ + m_oldTempo = m_composition->getCompositionDefaultTempo(); + m_composition->setCompositionDefaultTempo(m_tempo); +} + +void +ModifyDefaultTempoCommand::unexecute() +{ + m_composition->setCompositionDefaultTempo(m_oldTempo); +} + +} diff --git a/src/commands/segment/ModifyDefaultTempoCommand.h b/src/commands/segment/ModifyDefaultTempoCommand.h new file mode 100644 index 0000000..50f736d --- /dev/null +++ b/src/commands/segment/ModifyDefaultTempoCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_MODIFYDEFAULTTEMPOCOMMAND_H_ +#define _RG_MODIFYDEFAULTTEMPOCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> +#include "base/Composition.h" // for tempoT + + + +namespace Rosegarden +{ + + +class ModifyDefaultTempoCommand : public KNamedCommand +{ +public: + ModifyDefaultTempoCommand(Composition *composition, + tempoT tempo): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_tempo(tempo) {} + + virtual ~ModifyDefaultTempoCommand() {} + + static QString getGlobalName() { return i18n("Modify &Default Tempo..."); } + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + tempoT m_tempo; + tempoT m_oldTempo; +}; + + + +} + +#endif diff --git a/src/commands/segment/MoveTracksCommand.cpp b/src/commands/segment/MoveTracksCommand.cpp new file mode 100644 index 0000000..49c089b --- /dev/null +++ b/src/commands/segment/MoveTracksCommand.cpp @@ -0,0 +1,76 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "MoveTracksCommand.h" + +#include "base/Composition.h" +#include "base/Track.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +MoveTracksCommand::MoveTracksCommand(Composition *composition, + TrackId srcTrack, + TrackId destTrack): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_srcTrack(srcTrack), + m_destTrack(destTrack) +{} + +MoveTracksCommand::~MoveTracksCommand() +{} + +void +MoveTracksCommand::execute() +{ + Track *srcTrack = m_composition->getTrackById(m_srcTrack); + Track *destTrack = m_composition->getTrackById(m_destTrack); + + int srcPosition = srcTrack->getPosition(); + + srcTrack->setPosition(destTrack->getPosition()); + destTrack->setPosition(srcPosition); + + m_composition->updateRefreshStatuses(); +} + +void +MoveTracksCommand::unexecute() +{ + Track *srcTrack = m_composition->getTrackById(m_srcTrack); + Track *destTrack = m_composition->getTrackById(m_destTrack); + + int srcPosition = srcTrack->getPosition(); + + srcTrack->setPosition(destTrack->getPosition()); + destTrack->setPosition(srcPosition); + + m_composition->updateRefreshStatuses(); +} + +} diff --git a/src/commands/segment/MoveTracksCommand.h b/src/commands/segment/MoveTracksCommand.h new file mode 100644 index 0000000..e35af5e --- /dev/null +++ b/src/commands/segment/MoveTracksCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_MOVETRACKSCOMMAND_H_ +#define _RG_MOVETRACKSCOMMAND_H_ + +#include "base/Track.h" +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class MoveTracksCommand : public KNamedCommand +{ +public: + MoveTracksCommand(Composition *composition, + TrackId srcTrack, + TrackId destTrack); + virtual ~MoveTracksCommand(); + + static QString getGlobalName() { return i18n("Move Tracks..."); } + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + + TrackId m_srcTrack; + TrackId m_destTrack; +}; + + +} + +#endif diff --git a/src/commands/segment/OpenOrCloseRangeCommand.cpp b/src/commands/segment/OpenOrCloseRangeCommand.cpp new file mode 100644 index 0000000..ad1db2c --- /dev/null +++ b/src/commands/segment/OpenOrCloseRangeCommand.cpp @@ -0,0 +1,181 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "OpenOrCloseRangeCommand.h" + +#include <klocale.h> +#include "misc/Debug.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include "base/Selection.h" + + +namespace Rosegarden +{ + +OpenOrCloseRangeCommand::OpenOrCloseRangeCommand(Composition *composition, + timeT rangeBegin, + timeT rangeEnd, + bool open) : + KNamedCommand(i18n("Open or Close Range")), + m_composition(composition), + m_beginTime(rangeBegin), + m_endTime(rangeEnd), + m_prepared(false), + m_opening(open) +{} + +OpenOrCloseRangeCommand::~OpenOrCloseRangeCommand() +{} + +void +OpenOrCloseRangeCommand::execute() +{ + timeT offset = m_endTime - m_beginTime; + if (!m_opening) + offset = -offset; + + if (m_opening) { + if (offset + m_composition->getDuration() > + m_composition->getEndMarker()) { + m_composition->setEndMarker + (m_composition->getBarEndForTime + (m_composition->getDuration() + offset)); + } + } + + if (!m_prepared) { + + timeT movingFrom = m_beginTime; + if (!m_opening) + movingFrom = m_endTime; + + for (Composition::iterator i = m_composition->begin(); + i != m_composition->end(); ++i) { + + if ((*i)->getStartTime() >= movingFrom) { + m_moving.push_back(*i); + } + } + + m_timesigsPre = TimeSignatureSelection + (*m_composition, movingFrom, + m_composition->getEndMarker(), + false); + + m_temposPre = TempoSelection + (*m_composition, movingFrom, + m_composition->getEndMarker(), + false); + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_timesigsPre.begin(); i != m_timesigsPre.end(); ++i) { + + timeT t = i->first; + TimeSignature sig = i->second; + m_timesigsPost.addTimeSignature(t + offset, sig); + } + + for (TempoSelection::tempocontainer::const_iterator i = + m_temposPre.begin(); i != m_temposPre.end(); ++i) { + + timeT t = i->first; + TempoSelection::tempochange change = i->second; + m_temposPost.addTempo(t + offset, change.first, change.second); + } + + m_prepared = true; + } + + for (std::vector<Segment *>::iterator i = m_moving.begin(); + i != m_moving.end(); ++i) { + // RG_DEBUG << "Moving segment on track " << (*i)->getTrack() << " from " << (*i)->getStartTime() << " to " << ((*i)->getStartTime() + offset) << " (current end time is " << (*i)->getEndTime() << ", end marker is " << (*i)->getEndMarkerTime() << ")" << endl; + (*i)->setStartTime((*i)->getStartTime() + offset); + } + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_timesigsPre.begin(); i != m_timesigsPre.end(); ++i) { + int n = m_composition->getTimeSignatureNumberAt(i->first); + if (n >= 0) + m_composition->removeTimeSignature(n); + } + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_timesigsPost.begin(); i != m_timesigsPost.end(); ++i) { + m_composition->addTimeSignature(i->first, i->second); + } + + for (TempoSelection::tempocontainer::const_iterator i = + m_temposPre.begin(); i != m_temposPre.end(); ++i) { + int n = m_composition->getTempoChangeNumberAt(i->first); + if (n >= 0) + m_composition->removeTempoChange(n); + } + + for (TempoSelection::tempocontainer::const_iterator i = + m_temposPost.begin(); i != m_temposPost.end(); ++i) { + m_composition->addTempoAtTime(i->first, i->second.first, i->second.second); + } +} + +void +OpenOrCloseRangeCommand::unexecute() +{ + timeT offset = m_beginTime - m_endTime; + if (!m_opening) + offset = -offset; + + for (std::vector<Segment *>::iterator i = m_moving.begin(); + i != m_moving.end(); ++i) { + (*i)->setStartTime((*i)->getStartTime() + offset); + } + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_timesigsPost.begin(); i != m_timesigsPost.end(); ++i) { + int n = m_composition->getTimeSignatureNumberAt(i->first); + if (n >= 0) + m_composition->removeTimeSignature(n); + } + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_timesigsPre.begin(); i != m_timesigsPre.end(); ++i) { + m_composition->addTimeSignature(i->first, i->second); + } + + for (TempoSelection::tempocontainer::const_iterator i = + m_temposPost.begin(); i != m_temposPost.end(); ++i) { + int n = m_composition->getTempoChangeNumberAt(i->first); + if (n >= 0) + m_composition->removeTempoChange(n); + } + + for (TempoSelection::tempocontainer::const_iterator i = + m_temposPre.begin(); i != m_temposPre.end(); ++i) { + m_composition->addTempoAtTime(i->first, i->second.first, i->second.second); + } +} + +} diff --git a/src/commands/segment/OpenOrCloseRangeCommand.h b/src/commands/segment/OpenOrCloseRangeCommand.h new file mode 100644 index 0000000..6cb0f16 --- /dev/null +++ b/src/commands/segment/OpenOrCloseRangeCommand.h @@ -0,0 +1,84 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_OPENORCLOSERANGECOMMAND_H_ +#define _RG_OPENORCLOSERANGECOMMAND_H_ + +#include "base/Selection.h" +#include <kcommand.h> +#include <vector> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +/** + * Pull all segments, time sigs, tempos etc starting after the end of + * a given range back by the duration of that range, so as to fill in + * the (presumably empty) range itself. + * + * This does not actually split any segments etc, it just moves them. + */ +class OpenOrCloseRangeCommand : public KNamedCommand +{ +public: + OpenOrCloseRangeCommand(Composition *composition, + timeT rangeBegin, + timeT rangeEnd, + bool open); + virtual ~OpenOrCloseRangeCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + timeT m_beginTime; + timeT m_endTime; + + bool m_prepared; + bool m_opening; + + std::vector<Segment *> m_moving; + + TimeSignatureSelection m_timesigsPre; + TimeSignatureSelection m_timesigsPost; + + TempoSelection m_temposPre; + TempoSelection m_temposPost; +}; + + + +} + +#endif diff --git a/src/commands/segment/PasteConductorDataCommand.cpp b/src/commands/segment/PasteConductorDataCommand.cpp new file mode 100644 index 0000000..6db082f --- /dev/null +++ b/src/commands/segment/PasteConductorDataCommand.cpp @@ -0,0 +1,128 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "PasteConductorDataCommand.h" + +#include <klocale.h> +#include "base/Clipboard.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Selection.h" + + +namespace Rosegarden +{ + +PasteConductorDataCommand::PasteConductorDataCommand(Composition *composition, + Clipboard *clipboard, + timeT t) : + KNamedCommand(i18n("Paste Tempos and Time Signatures")), + m_composition(composition), + m_clipboard(new Clipboard(*clipboard)), + m_t0(t) +{} + +PasteConductorDataCommand::~PasteConductorDataCommand() +{ + delete m_clipboard; +} + +void +PasteConductorDataCommand::execute() +{ + //!!! current implementation of execute and unexecute require + // that the target area of the composition be empty of tempo and + // timesig data before the command is executed + + if (m_clipboard->hasTimeSignatureSelection()) { + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_clipboard->getTimeSignatureSelection().begin(); + i != m_clipboard->getTimeSignatureSelection().end(); ++i) { + + timeT t = i->first; + t = t - m_clipboard->getBaseTime() + m_t0; + TimeSignature sig = i->second; + + if (i == m_clipboard->getTimeSignatureSelection().begin() && + m_composition->getTimeSignatureAt(t) == sig) + continue; + + m_composition->addTimeSignature(t, sig); + } + } + + if (m_clipboard->hasTempoSelection()) { + + for (TempoSelection::tempocontainer::const_iterator i = + m_clipboard->getTempoSelection().begin(); + i != m_clipboard->getTempoSelection().end(); ++i) { + + timeT t = i->first; + t = t - m_clipboard->getBaseTime() + m_t0; + tempoT tempo = i->second.first; + tempoT targetTempo = i->second.second; + + if (i == m_clipboard->getTempoSelection().begin() && + targetTempo < 0 && + m_composition->getTempoAtTime(t) == tempo) + continue; + + m_composition->addTempoAtTime(t, tempo, targetTempo); + } + } +} + +void +PasteConductorDataCommand::unexecute() +{ + //!!! see note above + + for (TimeSignatureSelection::timesigcontainer::const_iterator i = + m_clipboard->getTimeSignatureSelection().begin(); + i != m_clipboard->getTimeSignatureSelection().end(); ++i) { + + timeT t = i->first; + int n = m_composition->getTimeSignatureNumberAt(t); + + if (n >= 0 && m_composition->getTimeSignatureChange(n).first == t) { + m_composition->removeTimeSignature(n); + } + } + + for (TempoSelection::tempocontainer::const_iterator i = + m_clipboard->getTempoSelection().begin(); + i != m_clipboard->getTempoSelection().end(); ++i) { + + timeT t = i->first; + int n = m_composition->getTempoChangeNumberAt(t); + + if (n >= 0 && m_composition->getTempoChange(n).first == t) { + m_composition->removeTempoChange(n); + } + } +} + +} diff --git a/src/commands/segment/PasteConductorDataCommand.h b/src/commands/segment/PasteConductorDataCommand.h new file mode 100644 index 0000000..15b6e54 --- /dev/null +++ b/src/commands/segment/PasteConductorDataCommand.h @@ -0,0 +1,67 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_PASTECONDUCTORDATACOMMAND_H_ +#define _RG_PASTECONDUCTORDATACOMMAND_H_ + +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Composition; +class Clipboard; + + +/** + * Paste time signature and tempo data from the given clipboard into + * the given composition starting at the given time. + */ +class PasteConductorDataCommand : public KNamedCommand +{ +public: + PasteConductorDataCommand(Composition *composition, + Clipboard *clipboard, + timeT t); + virtual ~PasteConductorDataCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + Clipboard *m_clipboard; + timeT m_t0; +}; + + + +} + +#endif diff --git a/src/commands/segment/PasteRangeCommand.cpp b/src/commands/segment/PasteRangeCommand.cpp new file mode 100644 index 0000000..c2f9a0e --- /dev/null +++ b/src/commands/segment/PasteRangeCommand.cpp @@ -0,0 +1,97 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "PasteRangeCommand.h" + +#include <klocale.h> +#include "AudioSegmentSplitCommand.h" +#include "base/Clipboard.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include "commands/edit/PasteSegmentsCommand.h" +#include "OpenOrCloseRangeCommand.h" +#include "PasteConductorDataCommand.h" +#include "SegmentSplitCommand.h" + + +namespace Rosegarden +{ + +PasteRangeCommand::PasteRangeCommand(Composition *composition, + Clipboard *clipboard, + timeT t0) : + KMacroCommand(i18n("Paste Range")) +{ + timeT clipBeginTime = clipboard->getBaseTime(); + + timeT t1 = t0; + + if (clipboard->hasNominalRange()) { + + clipboard->getNominalRange(clipBeginTime, t1); + t1 = t0 + (t1 - clipBeginTime); + + } else { + + timeT duration = 0; + + for (Clipboard::iterator i = clipboard->begin(); + i != clipboard->end(); ++i) { + timeT durationHere = (*i)->getEndMarkerTime() - clipBeginTime; + if (i == clipboard->begin() || durationHere > duration) { + duration = durationHere; + } + } + + if (duration <= 0) + return ; + t1 = t0 + duration; + } + + // Need to split segments before opening, at t0 + + for (Composition::iterator i = composition->begin(); + i != composition->end(); ++i) { + + if ((*i)->getStartTime() >= t0 || (*i)->getEndMarkerTime() <= t0) { + continue; + } + + if ((*i)->getType() == Segment::Audio) { + addCommand(new AudioSegmentSplitCommand(*i, t0)); + } else { + addCommand(new SegmentSplitCommand(*i, t0)); + } + } + + addCommand(new OpenOrCloseRangeCommand(composition, t0, t1, true)); + addCommand(new PasteSegmentsCommand + (composition, clipboard, t0, + composition->getTrackByPosition(0)->getId(), + true)); + addCommand(new PasteConductorDataCommand(composition, clipboard, t0)); +} + +} diff --git a/src/commands/segment/PasteRangeCommand.h b/src/commands/segment/PasteRangeCommand.h new file mode 100644 index 0000000..f64da24 --- /dev/null +++ b/src/commands/segment/PasteRangeCommand.h @@ -0,0 +1,52 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_PASTERANGECOMMAND_H_ +#define _RG_PASTERANGECOMMAND_H_ + +#include "base/Event.h" +#include <kcommand.h> + + +namespace Rosegarden +{ + +class Composition; +class Clipboard; + + +class PasteRangeCommand : public KMacroCommand +{ +public: + PasteRangeCommand(Composition *composition, + Clipboard *clipboard, + timeT pasteTime); +}; + + + +} + +#endif diff --git a/src/commands/segment/PasteToTriggerSegmentCommand.cpp b/src/commands/segment/PasteToTriggerSegmentCommand.cpp new file mode 100644 index 0000000..0447c40 --- /dev/null +++ b/src/commands/segment/PasteToTriggerSegmentCommand.cpp @@ -0,0 +1,129 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "PasteToTriggerSegmentCommand.h" + +#include "base/Event.h" +#include <klocale.h> +#include "misc/Strings.h" +#include "base/Clipboard.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include "base/TriggerSegment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +PasteToTriggerSegmentCommand::PasteToTriggerSegmentCommand(Composition *composition, + Clipboard *clipboard, + QString label, + int basePitch, + int baseVelocity) : + KNamedCommand(i18n("Paste as New Triggered Segment")), + m_composition(composition), + m_clipboard(new Clipboard(*clipboard)), + m_label(label), + m_basePitch(basePitch), + m_baseVelocity(baseVelocity), + m_segment(0), + m_detached(false) +{ + // nothing else +} + +PasteToTriggerSegmentCommand::~PasteToTriggerSegmentCommand() +{ + if (m_detached) + delete m_segment; + delete m_clipboard; +} + +void +PasteToTriggerSegmentCommand::execute() +{ + if (m_segment) { + + m_composition->addTriggerSegment(m_segment, m_id, m_basePitch, m_baseVelocity); + + } else { + + if (m_clipboard->isEmpty()) + return ; + + m_segment = new Segment(); + + timeT earliestStartTime = 0; + timeT latestEndTime = 0; + + for (Clipboard::iterator i = m_clipboard->begin(); + i != m_clipboard->end(); ++i) { + + if (i == m_clipboard->begin() || + (*i)->getStartTime() < earliestStartTime) { + earliestStartTime = (*i)->getStartTime(); + } + + if ((*i)->getEndMarkerTime() > latestEndTime) + latestEndTime = (*i)->getEndMarkerTime(); + } + + for (Clipboard::iterator i = m_clipboard->begin(); + i != m_clipboard->end(); ++i) { + + for (Segment::iterator si = (*i)->begin(); + (*i)->isBeforeEndMarker(si); ++si) { + if (!(*si)->isa(Note::EventRestType)) { + m_segment->insert + (new Event(**si, + (*si)->getAbsoluteTime() - earliestStartTime)); + } + } + } + + m_segment->setLabel(qstrtostr(m_label)); + + TriggerSegmentRec *rec = + m_composition->addTriggerSegment(m_segment, m_basePitch, m_baseVelocity); + if (rec) + m_id = rec->getId(); + } + + m_composition->getTriggerSegmentRec(m_id)->updateReferences(); + + m_detached = false; +} + +void +PasteToTriggerSegmentCommand::unexecute() +{ + if (m_segment) + m_composition->detachTriggerSegment(m_id); + m_detached = true; +} + +} diff --git a/src/commands/segment/PasteToTriggerSegmentCommand.h b/src/commands/segment/PasteToTriggerSegmentCommand.h new file mode 100644 index 0000000..32f95e7 --- /dev/null +++ b/src/commands/segment/PasteToTriggerSegmentCommand.h @@ -0,0 +1,73 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_PASTETOTRIGGERSEGMENTCOMMAND_H_ +#define _RG_PASTETOTRIGGERSEGMENTCOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <kcommand.h> +#include <qstring.h> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; +class Clipboard; + + +class PasteToTriggerSegmentCommand : public KNamedCommand +{ +public: + /// If basePitch is -1, the first pitch in the selection will be used + PasteToTriggerSegmentCommand(Composition *composition, + Clipboard *clipboard, + QString label, + int basePitch = -1, + int baseVelocity = -1); + virtual ~PasteToTriggerSegmentCommand(); + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + Clipboard *m_clipboard; + QString m_label; + int m_basePitch; + int m_baseVelocity; + Segment *m_segment; + TriggerSegmentId m_id; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/RemoveTempoChangeCommand.cpp b/src/commands/segment/RemoveTempoChangeCommand.cpp new file mode 100644 index 0000000..11a89ad --- /dev/null +++ b/src/commands/segment/RemoveTempoChangeCommand.cpp @@ -0,0 +1,59 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "RemoveTempoChangeCommand.h" + +#include "base/Composition.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +void +RemoveTempoChangeCommand::execute() +{ + if (m_tempoChangeIndex >= 0) { + std::pair<timeT, tempoT> data = + m_composition->getTempoChange(m_tempoChangeIndex); + + // store + m_oldTime = data.first; + m_oldTempo = data.second; + } + + // do we need to (re)store the index number? + // + m_composition->removeTempoChange(m_tempoChangeIndex); + +} + +void +RemoveTempoChangeCommand::unexecute() +{ + m_composition->addTempoAtTime(m_oldTime, m_oldTempo); +} + +} diff --git a/src/commands/segment/RemoveTempoChangeCommand.h b/src/commands/segment/RemoveTempoChangeCommand.h new file mode 100644 index 0000000..1900a8b --- /dev/null +++ b/src/commands/segment/RemoveTempoChangeCommand.h @@ -0,0 +1,75 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_REMOVETEMPOCHANGECOMMAND_H_ +#define _RG_REMOVETEMPOCHANGECOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include "base/Composition.h" // for tempoT +#include <klocale.h> + + +class Remove; + + +namespace Rosegarden +{ + +class Composition; + + +class RemoveTempoChangeCommand : public KNamedCommand +{ +public: + RemoveTempoChangeCommand(Composition *composition, + int index): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_tempoChangeIndex(index), + m_oldTime(0), + m_oldTempo(0){} + + virtual ~RemoveTempoChangeCommand() {} + + static QString getGlobalName() { return i18n("Remove &Tempo Change..."); } + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + int m_tempoChangeIndex; + timeT m_oldTime; + tempoT m_oldTempo; +}; + + + + +} + +#endif diff --git a/src/commands/segment/RemoveTimeSignatureCommand.cpp b/src/commands/segment/RemoveTimeSignatureCommand.cpp new file mode 100644 index 0000000..c6b59b1 --- /dev/null +++ b/src/commands/segment/RemoveTimeSignatureCommand.cpp @@ -0,0 +1,60 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "RemoveTimeSignatureCommand.h" + +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +void +RemoveTimeSignatureCommand::execute() +{ + if (m_timeSigIndex >= 0) { + std::pair<timeT, TimeSignature> data = + m_composition->getTimeSignatureChange(m_timeSigIndex); + + // store + m_oldTime = data.first; + m_oldTimeSignature = data.second; + } + + // do we need to (re)store the index number? + // + m_composition->removeTimeSignature(m_timeSigIndex); + +} + +void +RemoveTimeSignatureCommand::unexecute() +{ + m_composition->addTimeSignature(m_oldTime, m_oldTimeSignature); +} + +} diff --git a/src/commands/segment/RemoveTimeSignatureCommand.h b/src/commands/segment/RemoveTimeSignatureCommand.h new file mode 100644 index 0000000..d29d666 --- /dev/null +++ b/src/commands/segment/RemoveTimeSignatureCommand.h @@ -0,0 +1,74 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_REMOVETIMESIGNATURECOMMAND_H_ +#define _RG_REMOVETIMESIGNATURECOMMAND_H_ + +#include "base/NotationTypes.h" +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include <klocale.h> + + +class Remove; + + +namespace Rosegarden +{ + +class Composition; + + +class RemoveTimeSignatureCommand : public KNamedCommand +{ +public: + RemoveTimeSignatureCommand(Composition *composition, + int index): + KNamedCommand(getGlobalName()), + m_composition(composition), + m_timeSigIndex(index), + m_oldTime(0), + m_oldTimeSignature() { } + + virtual ~RemoveTimeSignatureCommand() {} + + static QString getGlobalName() { return i18n("Remove &Time Signature Change..."); } + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + int m_timeSigIndex; + timeT m_oldTime; + TimeSignature m_oldTimeSignature; +}; + + + +} + +#endif diff --git a/src/commands/segment/RenameTrackCommand.cpp b/src/commands/segment/RenameTrackCommand.cpp new file mode 100644 index 0000000..62d1d7e --- /dev/null +++ b/src/commands/segment/RenameTrackCommand.cpp @@ -0,0 +1,75 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "RenameTrackCommand.h" + +#include "misc/Debug.h" +#include "base/Composition.h" +#include "base/Track.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +RenameTrackCommand::RenameTrackCommand(Composition *composition, + TrackId trackId, + std::string name) : + KNamedCommand(getGlobalName()), + m_composition(composition), + m_track(trackId), + m_newName(name) +{ + Track *track = composition->getTrackById(m_track); + if (!track) { + RG_DEBUG << "Hey! No Track in RenameTrackCommand (track id " << track + << ")!" << endl; + return ; + } + m_oldName = track->getLabel(); +} + +RenameTrackCommand::~RenameTrackCommand() +{} + +void +RenameTrackCommand::execute() +{ + Track *track = m_composition->getTrackById(m_track); + if (!track) + return ; + track->setLabel(m_newName); +} + +void +RenameTrackCommand::unexecute() +{ + Track *track = m_composition->getTrackById(m_track); + if (!track) + return ; + track->setLabel(m_oldName); +} + +} diff --git a/src/commands/segment/RenameTrackCommand.h b/src/commands/segment/RenameTrackCommand.h new file mode 100644 index 0000000..8e63a88 --- /dev/null +++ b/src/commands/segment/RenameTrackCommand.h @@ -0,0 +1,67 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_RENAMETRACKCOMMAND_H_ +#define _RG_RENAMETRACKCOMMAND_H_ + +#include "base/Track.h" +#include <string> +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class RenameTrackCommand : public KNamedCommand +{ +public: + RenameTrackCommand(Composition *composition, + TrackId track, + std::string name); + virtual ~RenameTrackCommand(); + + static QString getGlobalName() { return i18n("Rename Track"); } + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + TrackId m_track; + std::string m_oldName; + std::string m_newName; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentAutoSplitCommand.cpp b/src/commands/segment/SegmentAutoSplitCommand.cpp new file mode 100644 index 0000000..fbd6daa --- /dev/null +++ b/src/commands/segment/SegmentAutoSplitCommand.cpp @@ -0,0 +1,205 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentAutoSplitCommand.h" + +#include "base/Event.h" +#include "misc/Debug.h" +#include "misc/Strings.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +struct AutoSplitPoint +{ + timeT time; + timeT lastSoundTime; + Clef clef; + Rosegarden::Key key; + AutoSplitPoint(timeT t, timeT lst, Clef c, Rosegarden::Key k) : + time(t), lastSoundTime(lst), clef(c), key(k) { } +}; + +SegmentAutoSplitCommand::SegmentAutoSplitCommand(Segment *segment) : + KNamedCommand(getGlobalName()), + m_segment(segment), + m_composition(segment->getComposition()), + m_detached(false) +{} + +SegmentAutoSplitCommand::~SegmentAutoSplitCommand() +{ + if (m_detached) { + delete m_segment; + } else { + for (unsigned int i = 0; i < m_newSegments.size(); ++i) { + delete m_newSegments[i]; + } + } +} + +void +SegmentAutoSplitCommand::execute() +{ + if (m_newSegments.size() == 0) { + + std::vector<AutoSplitPoint> splitPoints; + + Clef clef; + Key key; + timeT segmentStart = m_segment->getStartTime(); + timeT lastSoundTime = segmentStart; + timeT lastSplitTime = segmentStart - 1; + + for (Segment::iterator i = m_segment->begin(); + m_segment->isBeforeEndMarker(i); ++i) { + + timeT myTime = (*i)->getAbsoluteTime(); + int barNo = m_composition->getBarNumber(myTime); + + if ((*i)->isa(Clef::EventType)) { + clef = Clef(**i); + } else if ((*i)->isa(Key::EventType)) { + key = Key(**i); + } + + if (myTime <= lastSplitTime) + continue; + + bool newTimeSig = false; + TimeSignature tsig = + m_composition->getTimeSignatureInBar(barNo, newTimeSig); + + if (newTimeSig) { + + // If there's a new time sig in this bar and we haven't + // already made a split in this bar, make one + + if (splitPoints.size() == 0 || + m_composition->getBarNumber + (splitPoints[splitPoints.size() - 1].time) < barNo) { + + splitPoints.push_back(AutoSplitPoint(myTime, lastSoundTime, + clef, key)); + lastSoundTime = lastSplitTime = myTime; + } + + } else if ((*i)->isa(Note::EventRestType)) { + + // Otherwise never start a subsegment on a rest + + continue; + + } else { + + // When we meet a non-rest event, start a new split + // if an entire bar has passed since the last one + + int lastSoundBarNo = m_composition->getBarNumber(lastSoundTime); + + if (lastSoundBarNo < barNo - 1 || + (lastSoundBarNo == barNo - 1 && + m_composition->getBarStartForTime(lastSoundTime) == + lastSoundTime && + lastSoundTime > segmentStart)) { + + splitPoints.push_back + (AutoSplitPoint + (m_composition->getBarStartForTime(myTime), lastSoundTime, + clef, key)); + lastSplitTime = myTime; + } + } + + lastSoundTime = std::max(lastSoundTime, myTime + (*i)->getDuration()); + } + + for (unsigned int split = 0; split <= splitPoints.size(); ++split) { + + Segment *newSegment = new Segment(); + newSegment->setTrack(m_segment->getTrack()); + newSegment->setLabel(qstrtostr(i18n("%1 (part)").arg + (strtoqstr(m_segment->getLabel())))); + newSegment->setColourIndex(m_segment->getColourIndex()); + + timeT startTime = segmentStart; + if (split > 0) { + + RG_DEBUG << "Auto-split point " << split - 1 << ": time " + << splitPoints[split - 1].time << ", lastSoundTime " + << splitPoints[split - 1].lastSoundTime << endl; + + startTime = splitPoints[split - 1].time; + newSegment->insert(splitPoints[split - 1].clef.getAsEvent(startTime)); + newSegment->insert(splitPoints[split - 1].key.getAsEvent(startTime)); + } + + Segment::iterator i = m_segment->findTime(startTime); + + // A segment has to contain at least one note to be a worthy + // candidate for adding back into the composition + bool haveNotes = false; + + while (m_segment->isBeforeEndMarker(i)) { + timeT t = (*i)->getAbsoluteTime(); + if (split < splitPoints.size() && + t >= splitPoints[split].lastSoundTime) + break; + if ((*i)->isa(Note::EventType)) + haveNotes = true; + newSegment->insert(new Event(**i)); + ++i; + } + + if (haveNotes) + m_newSegments.push_back(newSegment); + else + delete newSegment; + } + } + + m_composition->detachSegment(m_segment); + for (unsigned int i = 0; i < m_newSegments.size(); ++i) { + m_composition->addSegment(m_newSegments[i]); + } + m_detached = true; +} + +void +SegmentAutoSplitCommand::unexecute() +{ + for (unsigned int i = 0; i < m_newSegments.size(); ++i) { + m_composition->detachSegment(m_newSegments[i]); + } + m_composition->addSegment(m_segment); + m_detached = false; +} + +} diff --git a/src/commands/segment/SegmentAutoSplitCommand.h b/src/commands/segment/SegmentAutoSplitCommand.h new file mode 100644 index 0000000..a7e54c7 --- /dev/null +++ b/src/commands/segment/SegmentAutoSplitCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTAUTOSPLITCOMMAND_H_ +#define _RG_SEGMENTAUTOSPLITCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class SegmentAutoSplitCommand : public KNamedCommand +{ +public: + SegmentAutoSplitCommand(Segment *segment); + virtual ~SegmentAutoSplitCommand(); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName() { return i18n("&Split on Silence"); } + +private: + Segment *m_segment; + Composition *m_composition; + std::vector<Segment *> m_newSegments; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentChangePlayableRangeCommand.cpp b/src/commands/segment/SegmentChangePlayableRangeCommand.cpp new file mode 100644 index 0000000..b4d5d3a --- /dev/null +++ b/src/commands/segment/SegmentChangePlayableRangeCommand.cpp @@ -0,0 +1,77 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2007 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentChangePlayableRangeCommand.h" + +#include "base/Segment.h" +#include "gui/editors/notation/NotationStrings.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentChangePlayableRangeCommand::SegmentChangePlayableRangeCommand(int low, int high, Segment *segment) : + KNamedCommand(getGlobalName(low, high)), + m_lowestPlayableNote(low), + m_highestPlayableNote(high), + m_segment(segment) +{ + // nothing +} + +SegmentChangePlayableRangeCommand::~SegmentChangePlayableRangeCommand() +{ + // nothing +} + +void +SegmentChangePlayableRangeCommand::execute() +{ + m_oldLowestPlayableNote = m_segment->getLowestPlayable(); + m_oldHighestPlayableNote = m_segment->getHighestPlayable(); + m_segment->setLowestPlayable(m_lowestPlayableNote); + m_segment->setHighestPlayable(m_highestPlayableNote); +} + +void +SegmentChangePlayableRangeCommand::unexecute() +{ + m_segment->setLowestPlayable(m_oldLowestPlayableNote); + m_segment->setHighestPlayable(m_oldHighestPlayableNote); +} + +QString +SegmentChangePlayableRangeCommand::getGlobalName(int low, int high) +{ + bool unit = false; // fake code to allow trunk/ to compile! + if (!unit) { + return "Undo change playable range"; + } else { + return QString("Change playable range to %1-%2").arg(low, high); + } +} + +} diff --git a/src/commands/segment/SegmentChangePlayableRangeCommand.h b/src/commands/segment/SegmentChangePlayableRangeCommand.h new file mode 100644 index 0000000..d78aa5c --- /dev/null +++ b/src/commands/segment/SegmentChangePlayableRangeCommand.h @@ -0,0 +1,67 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2007 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCHANGEPLAYABLERANGECOMMAND_H_ +#define _RG_SEGMENTCHANGEPLAYABLERANGECOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +class SegmentChangePlayableRangeCommand : public KNamedCommand +{ +public: + /// Set transpose on segments. + SegmentChangePlayableRangeCommand(int /*low*/, int /*high*/, Segment *segment); + virtual ~SegmentChangePlayableRangeCommand(); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName(int, int); + +private: + Segment *m_segment; + int m_oldLowestPlayableNote; + int m_oldHighestPlayableNote; + int m_lowestPlayableNote; + int m_highestPlayableNote; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentChangeQuantizationCommand.cpp b/src/commands/segment/SegmentChangeQuantizationCommand.cpp new file mode 100644 index 0000000..22d09f4 --- /dev/null +++ b/src/commands/segment/SegmentChangeQuantizationCommand.cpp @@ -0,0 +1,115 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentChangeQuantizationCommand.h" + +#include "base/Segment.h" +#include "base/BasicQuantizer.h" +#include "gui/editors/notation/NotationStrings.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentChangeQuantizationCommand::SegmentChangeQuantizationCommand(timeT unit) : + KNamedCommand(getGlobalName(unit)), + m_unit(unit) +{ + // nothing +} + +SegmentChangeQuantizationCommand::~SegmentChangeQuantizationCommand() +{ + // nothing +} + +void +SegmentChangeQuantizationCommand::execute() +{ + for (unsigned int i = 0; i < m_records.size(); ++i) { + + SegmentRec &rec = m_records[i]; + + if (m_unit) { + + rec.oldUnit = rec.segment->getQuantizer()->getUnit(); + rec.segment->setQuantizeLevel(m_unit); + + rec.wasQuantized = rec.segment->hasQuantization(); + rec.segment->setQuantization(true); + + } else { + + rec.wasQuantized = rec.segment->hasQuantization(); + rec.segment->setQuantization(false); + } + } +} + +void +SegmentChangeQuantizationCommand::unexecute() +{ + for (unsigned int i = 0; i < m_records.size(); ++i) { + + SegmentRec &rec = m_records[i]; + + if (m_unit) { + + if (!rec.wasQuantized) + rec.segment->setQuantization(false); + rec.segment->setQuantizeLevel(rec.oldUnit); + + } else { + + if (rec.wasQuantized) + rec.segment->setQuantization(true); + } + } +} + +void +SegmentChangeQuantizationCommand::addSegment(Segment *s) +{ + SegmentRec rec; + rec.segment = s; + rec.oldUnit = 0; // shouldn't matter what we initialise this to + rec.wasQuantized = false; // shouldn't matter what we initialise this to + m_records.push_back(rec); +} + +QString +SegmentChangeQuantizationCommand::getGlobalName(timeT unit) +{ + if (!unit) { + return "Unquantize"; + } else { + timeT error = 0; + QString label = NotationStrings::makeNoteMenuLabel(unit, true, error); + return QString("Quantize to %1").arg(label); + } +} + +} diff --git a/src/commands/segment/SegmentChangeQuantizationCommand.h b/src/commands/segment/SegmentChangeQuantizationCommand.h new file mode 100644 index 0000000..e5d7a36 --- /dev/null +++ b/src/commands/segment/SegmentChangeQuantizationCommand.h @@ -0,0 +1,73 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCHANGEQUANTIZATIONCOMMAND_H_ +#define _RG_SEGMENTCHANGEQUANTIZATIONCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +class SegmentChangeQuantizationCommand : public KNamedCommand +{ +public: + /// Set quantization on segments. If unit is zero, switch quantization off + SegmentChangeQuantizationCommand(timeT); + virtual ~SegmentChangeQuantizationCommand(); + + void addSegment(Segment *s); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName(timeT); + +private: + struct SegmentRec { + Segment *segment; + timeT oldUnit; + bool wasQuantized; + }; + typedef std::vector<SegmentRec> SegmentRecSet; + SegmentRecSet m_records; + + timeT m_unit; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentChangeTransposeCommand.cpp b/src/commands/segment/SegmentChangeTransposeCommand.cpp new file mode 100644 index 0000000..452c2d7 --- /dev/null +++ b/src/commands/segment/SegmentChangeTransposeCommand.cpp @@ -0,0 +1,72 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentChangeTransposeCommand.h" + +#include "base/Segment.h" +#include "gui/editors/notation/NotationStrings.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentChangeTransposeCommand::SegmentChangeTransposeCommand(int unit, Segment *segment) : + KNamedCommand(getGlobalName(unit)), + m_unit(unit), + m_segment(segment) +{ + // nothing +} + +SegmentChangeTransposeCommand::~SegmentChangeTransposeCommand() +{ + // nothing +} + +void +SegmentChangeTransposeCommand::execute() +{ + m_oldUnit = m_segment->getTranspose(); + m_segment->setTranspose(m_unit); +} + +void +SegmentChangeTransposeCommand::unexecute() +{ + m_segment->setTranspose(m_oldUnit); +} + +QString +SegmentChangeTransposeCommand::getGlobalName(int unit) +{ + if (!unit) { + return "Undo change transposition"; + } else { + return QString("Change transposition to %1").arg(unit); + } +} + +} diff --git a/src/commands/segment/SegmentChangeTransposeCommand.h b/src/commands/segment/SegmentChangeTransposeCommand.h new file mode 100644 index 0000000..64bd75a --- /dev/null +++ b/src/commands/segment/SegmentChangeTransposeCommand.h @@ -0,0 +1,65 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCHANGETRANSPOSECOMMAND_H_ +#define _RG_SEGMENTCHANGETRANSPOSECOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +class SegmentChangeTransposeCommand : public KNamedCommand +{ +public: + /// Set transpose on segments. + SegmentChangeTransposeCommand(int, Segment *segment); + virtual ~SegmentChangeTransposeCommand(); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName(int); + +private: + Segment *m_segment; + int m_oldUnit; + int m_unit; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentColourCommand.cpp b/src/commands/segment/SegmentColourCommand.cpp new file mode 100644 index 0000000..7dffc8f --- /dev/null +++ b/src/commands/segment/SegmentColourCommand.cpp @@ -0,0 +1,65 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentColourCommand.h" + +#include "base/Segment.h" +#include "base/Selection.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentColourCommand::SegmentColourCommand( + SegmentSelection &segments, + const unsigned int index): + KNamedCommand(i18n("Change Segment Color")), + m_newColourIndex(index) +{ + for (SegmentSelection::iterator i = segments.begin(); i != segments.end(); ++i) + m_segments.push_back(*i); +} + +SegmentColourCommand::~SegmentColourCommand() +{} + +void +SegmentColourCommand::execute() +{ + for (unsigned int i = 0; i < m_segments.size(); ++i) { + m_oldColourIndexes.push_back(m_segments[i]->getColourIndex()); + m_segments[i]->setColourIndex(m_newColourIndex); + } +} + +void +SegmentColourCommand::unexecute() +{ + for (unsigned int i = 0; i < m_segments.size(); ++i) + m_segments[i]->setColourIndex(m_oldColourIndexes[i]); +} + +} diff --git a/src/commands/segment/SegmentColourCommand.h b/src/commands/segment/SegmentColourCommand.h new file mode 100644 index 0000000..79b7d3d --- /dev/null +++ b/src/commands/segment/SegmentColourCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCOLOURCOMMAND_H_ +#define _RG_SEGMENTCOLOURCOMMAND_H_ + +#include "base/Segment.h" +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class SegmentSelection; + + +class SegmentColourCommand : public KNamedCommand +{ +public: + SegmentColourCommand(SegmentSelection &segments, + const unsigned int index); + virtual ~SegmentColourCommand(); + + static QString getGlobalName() + { return i18n("Change Segment Color..."); } + + virtual void execute(); + virtual void unexecute(); +protected: + + std::vector<Segment*> m_segments; + std::vector<unsigned int> m_oldColourIndexes; + unsigned int m_newColourIndex; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentColourMapCommand.cpp b/src/commands/segment/SegmentColourMapCommand.cpp new file mode 100644 index 0000000..0e09d4b --- /dev/null +++ b/src/commands/segment/SegmentColourMapCommand.cpp @@ -0,0 +1,64 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentColourMapCommand.h" + +#include "base/ColourMap.h" +#include "base/Segment.h" +#include "document/RosegardenGUIDoc.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentColourMapCommand::SegmentColourMapCommand( + RosegardenGUIDoc *doc, + const ColourMap &map): + KNamedCommand(i18n("Change Segment Color Map")), + m_doc(doc), + m_oldMap(m_doc->getComposition().getSegmentColourMap()), + m_newMap(map) +{ +} + +SegmentColourMapCommand::~SegmentColourMapCommand() +{} + +void +SegmentColourMapCommand::execute() +{ + m_doc->getComposition().setSegmentColourMap(m_newMap); + m_doc->slotDocColoursChanged(); +} + +void +SegmentColourMapCommand::unexecute() +{ + m_doc->getComposition().setSegmentColourMap(m_oldMap); + m_doc->slotDocColoursChanged(); +} + +} diff --git a/src/commands/segment/SegmentColourMapCommand.h b/src/commands/segment/SegmentColourMapCommand.h new file mode 100644 index 0000000..257cdce --- /dev/null +++ b/src/commands/segment/SegmentColourMapCommand.h @@ -0,0 +1,71 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCOLOURMAPCOMMAND_H_ +#define _RG_SEGMENTCOLOURMAPCOMMAND_H_ + +#include "base/ColourMap.h" +#include "base/Segment.h" +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class RosegardenGUIDoc; + + +class SegmentColourMapCommand : public KNamedCommand +{ +public: + SegmentColourMapCommand( RosegardenGUIDoc* doc, + const ColourMap& map); + virtual ~SegmentColourMapCommand(); + + static QString getGlobalName() + { return i18n("Change Segment Color Map..."); } + + virtual void execute(); + virtual void unexecute(); +protected: + RosegardenGUIDoc * m_doc; + ColourMap m_oldMap; + ColourMap m_newMap; +}; + + +// Trigger Segment commands. These are the commands that create +// and manage the triggered segments themselves. See editcommands.h +// for SetTriggerCommand and ClearTriggersCommand which manipulate +// the events that do the triggering. + + +} + +#endif diff --git a/src/commands/segment/SegmentCommand.cpp b/src/commands/segment/SegmentCommand.cpp new file mode 100644 index 0000000..68ff846 --- /dev/null +++ b/src/commands/segment/SegmentCommand.cpp @@ -0,0 +1,42 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentCommand.h" + +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentCommand::SegmentCommand(QString name, const std::vector<Segment*>& segments) + : KNamedCommand(name) +{ + m_segments.resize(segments.size()); + std::copy(segments.begin(), segments.end(), m_segments.begin()); +} + +} diff --git a/src/commands/segment/SegmentCommand.h b/src/commands/segment/SegmentCommand.h new file mode 100644 index 0000000..da28a04 --- /dev/null +++ b/src/commands/segment/SegmentCommand.h @@ -0,0 +1,59 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCOMMAND_H_ +#define _RG_SEGMENTCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> + + + + +namespace Rosegarden +{ + +class Segment; + + +/** + * Base class for commands from the SegmentParameterBox + */ +class SegmentCommand : public KNamedCommand +{ +public: + SegmentCommand(QString name, const std::vector<Segment*>&); + + typedef std::vector<Segment*> segmentlist; + +protected: + segmentlist m_segments; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentCommandRepeat.cpp b/src/commands/segment/SegmentCommandRepeat.cpp new file mode 100644 index 0000000..4b707cb --- /dev/null +++ b/src/commands/segment/SegmentCommandRepeat.cpp @@ -0,0 +1,59 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentCommandRepeat.h" + +#include <klocale.h> +#include "base/Segment.h" +#include "SegmentCommand.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentCommandRepeat::SegmentCommandRepeat(const std::vector<Segment*>& segments, + bool repeat) + : SegmentCommand(i18n("Repeat Segments"), segments), + m_repeatState(repeat) +{} + +void SegmentCommandRepeat::execute() +{ + segmentlist::iterator it; + + for (it = m_segments.begin(); it != m_segments.end(); it++) + (*it)->setRepeating(m_repeatState); +} + +void SegmentCommandRepeat::unexecute() +{ + segmentlist::iterator it; + + for (it = m_segments.begin(); it != m_segments.end(); it++) + (*it)->setRepeating(!m_repeatState); +} + +} diff --git a/src/commands/segment/SegmentCommandRepeat.h b/src/commands/segment/SegmentCommandRepeat.h new file mode 100644 index 0000000..0234070 --- /dev/null +++ b/src/commands/segment/SegmentCommandRepeat.h @@ -0,0 +1,81 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTCOMMANDREPEAT_H_ +#define _RG_SEGMENTCOMMANDREPEAT_H_ + +#include "SegmentCommand.h" +#include <vector> + + + + +namespace Rosegarden +{ + +class Segment; + + +/** + * Repeat segment command from the SegmentParameterBox + */ +class SegmentCommandRepeat : public SegmentCommand +{ +public: + SegmentCommandRepeat(const std::vector<Segment*>&, + bool repeat); + + virtual void execute(); + virtual void unexecute(); + +protected: + bool m_repeatState; +}; + +// Disabled until we find a better solution +// +// As it is, command creation happens on every change of the text +// value of the combo box +// +// +// class SegmentCommandChangeTransposeValue : public SegmentCommand +// { +// public: +// SegmentCommandChangeTransposeValue(const std::vector<Segment*>&, +// int transposeValue); + +// virtual void execute(); +// virtual void unexecute(); + +// protected: +// int m_transposeValue; +// std::vector<int> m_savedValues; +// }; + + + +} + +#endif diff --git a/src/commands/segment/SegmentEraseCommand.cpp b/src/commands/segment/SegmentEraseCommand.cpp new file mode 100644 index 0000000..b15788f --- /dev/null +++ b/src/commands/segment/SegmentEraseCommand.cpp @@ -0,0 +1,108 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentEraseCommand.h" + +#include <klocale.h> +#include "misc/Debug.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include "sound/AudioFile.h" +#include "sound/AudioFileManager.h" + + +namespace Rosegarden +{ + +SegmentEraseCommand::SegmentEraseCommand(Segment *segment) : + KNamedCommand(i18n("Erase Segment")), + m_composition(segment->getComposition()), + m_segment(segment), + m_mgr(0), + m_audioFileName(""), + m_detached(false) +{ + // nothing else +} + +SegmentEraseCommand::SegmentEraseCommand(Segment *segment, + AudioFileManager *mgr) : + KNamedCommand(i18n("Erase Segment")), + m_composition(segment->getComposition()), + m_segment(segment), + m_mgr(mgr), + m_detached(false) +{ + // If this is an audio segment, we want to make a note of + // its associated file name in case we need to undo and restore + // the file. + if (m_segment->getType() == Segment::Audio) { + unsigned int id = m_segment->getAudioFileId(); + AudioFile *file = mgr->getAudioFile(id); + if (file) + m_audioFileName = file->getFilename(); + } +} + +SegmentEraseCommand::~SegmentEraseCommand() +{ + // This is the only place in this command that the Segment can + // safely be deleted, and then only if it is not in the + // Composition (i.e. if we executed more recently than we + // unexecuted). Can't safely call through the m_segment pointer + // here; someone else might have got to it first + + if (m_detached) { + delete m_segment; + } +} + +void +SegmentEraseCommand::execute() +{ + m_composition->detachSegment(m_segment); + m_detached = true; +} + +void +SegmentEraseCommand::unexecute() +{ + m_composition->addSegment(m_segment); + m_detached = false; + + if (m_segment->getType() == Segment::Audio && + m_audioFileName != "" && + m_mgr) { + int id = m_mgr->fileExists(m_audioFileName); + + RG_DEBUG << "SegmentEraseCommand::unexecute: file is " << m_audioFileName << endl; + + if (id == -1) + id = (int)m_mgr->addFile(m_audioFileName); + m_segment->setAudioFileId(id); + } +} + +} diff --git a/src/commands/segment/SegmentEraseCommand.h b/src/commands/segment/SegmentEraseCommand.h new file mode 100644 index 0000000..493cd14 --- /dev/null +++ b/src/commands/segment/SegmentEraseCommand.h @@ -0,0 +1,70 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTERASECOMMAND_H_ +#define _RG_SEGMENTERASECOMMAND_H_ + +#include <string> +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; +class AudioFileManager; + + +//////////////////////////////////////////////////////////// + +class SegmentEraseCommand : public KNamedCommand +{ +public: + /// for removing segment normally + SegmentEraseCommand(Segment *segment); + + /// for removing audio segment when removing an audio file + SegmentEraseCommand(Segment *segment, + AudioFileManager *mgr); + virtual ~SegmentEraseCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + Segment *m_segment; + AudioFileManager *m_mgr; + std::string m_audioFileName; + bool m_detached; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentInsertCommand.cpp b/src/commands/segment/SegmentInsertCommand.cpp new file mode 100644 index 0000000..f10ef45 --- /dev/null +++ b/src/commands/segment/SegmentInsertCommand.cpp @@ -0,0 +1,124 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentInsertCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" +#include "base/Studio.h" +#include "base/Track.h" +#include "document/RosegardenGUIDoc.h" + + +namespace Rosegarden +{ + +SegmentInsertCommand::SegmentInsertCommand(RosegardenGUIDoc *doc, + TrackId track, + timeT startTime, + timeT endTime): + KNamedCommand(i18n("Create Segment")), + m_composition(&(doc->getComposition())), + m_studio(&(doc->getStudio())), + m_segment(0), + m_track(track), + m_startTime(startTime), + m_endTime(endTime), + m_detached(false) +{} + +SegmentInsertCommand::SegmentInsertCommand(Composition *composition, + Segment *segment, + TrackId track): + KNamedCommand(i18n("Create Segment")), + m_composition(composition), + m_studio(0), + m_segment(segment), + m_track(track), + m_startTime(0), + m_endTime(0), + m_detached(false) +{} + +SegmentInsertCommand::~SegmentInsertCommand() +{ + if (m_detached) { + delete m_segment; + } +} + +Segment * +SegmentInsertCommand::getSegment() const +{ + return m_segment; +} + +void +SegmentInsertCommand::execute() +{ + if (!m_segment) { + // Create and insert Segment + // + m_segment = new Segment(); + m_segment->setTrack(m_track); + m_segment->setStartTime(m_startTime); + m_composition->addSegment(m_segment); + m_segment->setEndTime(m_endTime); + + // Do our best to label the Segment with whatever is currently + // showing against it. + // + Track *track = m_composition->getTrackById(m_track); + std::string label; + + if (track) { + // try to get a reasonable Segment name by Instrument + // + label = m_studio->getSegmentName(track->getInstrument()); + + // if not use the track label + // + if (label == "") + label = track->getLabel(); + + m_segment->setLabel(label); + } + } else { + m_segment->setTrack(m_track); + m_composition->addSegment(m_segment); + } + + m_detached = false; +} + +void +SegmentInsertCommand::unexecute() +{ + m_composition->detachSegment(m_segment); + m_detached = true; +} + +} diff --git a/src/commands/segment/SegmentInsertCommand.h b/src/commands/segment/SegmentInsertCommand.h new file mode 100644 index 0000000..932919a --- /dev/null +++ b/src/commands/segment/SegmentInsertCommand.h @@ -0,0 +1,76 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTINSERTCOMMAND_H_ +#define _RG_SEGMENTINSERTCOMMAND_H_ + +#include "base/Track.h" +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Studio; +class Segment; +class RosegardenGUIDoc; +class Composition; + + +class SegmentInsertCommand : public KNamedCommand +{ +public: + SegmentInsertCommand(RosegardenGUIDoc *doc, + TrackId track, + timeT startTime, + timeT endTime); + SegmentInsertCommand(Composition *composition, + Segment *segment, + TrackId track); + virtual ~SegmentInsertCommand(); + + Segment *getSegment() const; // after invocation + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + Studio *m_studio; + Segment *m_segment; + int m_track; + timeT m_startTime; + timeT m_endTime; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentJoinCommand.cpp b/src/commands/segment/SegmentJoinCommand.cpp new file mode 100644 index 0000000..27b1bb8 --- /dev/null +++ b/src/commands/segment/SegmentJoinCommand.cpp @@ -0,0 +1,175 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentJoinCommand.h" + +#include "base/Composition.h" +#include "base/Event.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include "base/Selection.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentJoinCommand::SegmentJoinCommand(SegmentSelection & + segments) : + KNamedCommand(getGlobalName()), + m_newSegment(0), + m_detached(false) // true if the old segments are detached, not the new +{ + for (SegmentSelection::iterator i = segments.begin(); + i != segments.end(); ++i) + { + m_oldSegments.push_back(*i); + } + assert(m_oldSegments.size() > 0); +} + +SegmentJoinCommand::~SegmentJoinCommand() +{ + if (m_detached) { + for (unsigned int i = 0; i < m_oldSegments.size(); ++i) { + delete m_oldSegments[i]; + } + } else { + delete m_newSegment; + } +} + +void +SegmentJoinCommand::execute() +{ + Composition *composition = m_oldSegments[0]->getComposition(); + if (!composition) { + std::cerr + << "SegmentJoinCommand::execute: ERROR: old segments are not in composition!" + << std::endl; + return ; + } + + // we normalize rests in any overlapping areas + timeT overlapStart = 0, overlapEnd = 0; + bool haveOverlap = false; + + if (!m_newSegment) { + + m_newSegment = new Segment(*m_oldSegments[0]); + + // that duplicated segment 0; now do the rest + + for (unsigned int i = 1; i < m_oldSegments.size(); ++i) { + + Segment *s = m_oldSegments[i]; + + timeT start = s->getStartTime(), end = s->getEndMarkerTime(); + + timeT os = 0, oe = 0; + bool haveOverlapHere = false; + + if (start < m_newSegment->getEndMarkerTime() && + end > m_newSegment->getStartTime()) { + haveOverlapHere = true; + os = std::max(start, m_newSegment->getStartTime()); + oe = std::min(end, m_newSegment->getEndMarkerTime()); + std::cerr << "overlap here, os = " << os << ", oe = " << oe << std::endl; + } + + if (haveOverlapHere) { + if (haveOverlap) { + overlapStart = std::min(overlapStart, os); + overlapEnd = std::max(overlapEnd, oe); + } else { + overlapStart = os; + overlapEnd = oe; + haveOverlap = true; + } + } + + if (start > m_newSegment->getEndMarkerTime()) { + m_newSegment->setEndMarkerTime(start); + } + + for (Segment::iterator si = s->begin(); + s->isBeforeEndMarker(si); ++si) { + + // weed out duplicate clefs and keys + + if ((*si)->isa(Clef::EventType)) { + try { + Clef newClef(**si); + if (m_newSegment->getClefAtTime + ((*si)->getAbsoluteTime() + 1) == newClef) { + continue; + } + } catch (...) { } + } + + if ((*si)->isa(Key::EventType)) { + try { + Key newKey(**si); + if (m_newSegment->getKeyAtTime + ((*si)->getAbsoluteTime() + 1) == newKey) { + continue; + } + } catch (...) { } + } + + m_newSegment->insert(new Event(**si)); + } + + if (end > m_newSegment->getEndMarkerTime()) { + m_newSegment->setEndMarkerTime(end); + } + } + } + + composition->addSegment(m_newSegment); + + if (haveOverlap) { + m_newSegment->normalizeRests(overlapStart, overlapEnd); + } + + for (unsigned int i = 0; i < m_oldSegments.size(); ++i) { + composition->detachSegment(m_oldSegments[i]); + } + + m_detached = true; +} + +void +SegmentJoinCommand::unexecute() +{ + for (unsigned int i = 0; i < m_oldSegments.size(); ++i) { + m_newSegment->getComposition()->addSegment(m_oldSegments[i]); + } + + m_newSegment->getComposition()->detachSegment(m_newSegment); + m_detached = false; +} + +} diff --git a/src/commands/segment/SegmentJoinCommand.h b/src/commands/segment/SegmentJoinCommand.h new file mode 100644 index 0000000..97c7924 --- /dev/null +++ b/src/commands/segment/SegmentJoinCommand.h @@ -0,0 +1,65 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTJOINCOMMAND_H_ +#define _RG_SEGMENTJOINCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class SegmentSelection; +class Segment; + + +class SegmentJoinCommand : public KNamedCommand +{ +public: + SegmentJoinCommand(SegmentSelection &segments); + virtual ~SegmentJoinCommand(); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName() { return i18n("&Join"); } + +private: + std::vector<Segment *> m_oldSegments; + Segment *m_newSegment; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentLabelCommand.cpp b/src/commands/segment/SegmentLabelCommand.cpp new file mode 100644 index 0000000..8bc0ff4 --- /dev/null +++ b/src/commands/segment/SegmentLabelCommand.cpp @@ -0,0 +1,73 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentLabelCommand.h" + +#include "misc/Strings.h" +#include "base/Segment.h" +#include "base/Selection.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentLabelCommand::SegmentLabelCommand( + SegmentSelection &segments, + const QString &label): + KNamedCommand(i18n("Label Segments")), + m_newLabel(label) +{ + for (SegmentSelection::iterator i = segments.begin(); + i != segments.end(); ++i) + m_segments.push_back(*i); +} + +SegmentLabelCommand::~SegmentLabelCommand() +{} + +void +SegmentLabelCommand::execute() +{ + bool addLabels = false; + if (m_labels.size() == 0) + addLabels = true; + + for (unsigned int i = 0; i < m_segments.size(); ++i) { + if (addLabels) + m_labels.push_back(strtoqstr(m_segments[i]->getLabel())); + + m_segments[i]->setLabel(qstrtostr(m_newLabel)); + } +} + +void +SegmentLabelCommand::unexecute() +{ + for (unsigned int i = 0; i < m_segments.size(); ++i) + m_segments[i]->setLabel(qstrtostr(m_labels[i])); +} + +} diff --git a/src/commands/segment/SegmentLabelCommand.h b/src/commands/segment/SegmentLabelCommand.h new file mode 100644 index 0000000..1c55f3b --- /dev/null +++ b/src/commands/segment/SegmentLabelCommand.h @@ -0,0 +1,67 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTLABELCOMMAND_H_ +#define _RG_SEGMENTLABELCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class SegmentSelection; +class Segment; + + +class SegmentLabelCommand : public KNamedCommand +{ +public: + SegmentLabelCommand(SegmentSelection &segments, + const QString &label); + virtual ~SegmentLabelCommand(); + + static QString getGlobalName() + { return i18n("Re&label..."); } + + virtual void execute(); + virtual void unexecute(); +protected: + + std::vector<Segment*> m_segments; + std::vector<QString> m_labels; + QString m_newLabel; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentQuickCopyCommand.cpp b/src/commands/segment/SegmentQuickCopyCommand.cpp new file mode 100644 index 0000000..1ce432c --- /dev/null +++ b/src/commands/segment/SegmentQuickCopyCommand.cpp @@ -0,0 +1,71 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentQuickCopyCommand.h" + +#include "misc/Strings.h" +#include "base/Composition.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentQuickCopyCommand::SegmentQuickCopyCommand(Segment *segment): + KNamedCommand(getGlobalName()), + m_composition(segment->getComposition()), + m_segmentToCopy(segment), + m_segment(0), + m_detached(false) +{} + +SegmentQuickCopyCommand::~SegmentQuickCopyCommand() +{ + if (m_detached) { + delete m_segment; + } +} + +void +SegmentQuickCopyCommand::execute() +{ + if (!m_segment) { + m_segment = new Segment(*m_segmentToCopy); + m_segment->setLabel(qstrtostr(i18n("%1 (copied)").arg + (strtoqstr(m_segment->getLabel())))); + } + m_composition->addSegment(m_segment); + m_detached = false; +} + +void +SegmentQuickCopyCommand::unexecute() +{ + m_composition->detachSegment(m_segment); + m_detached = true; +} + +} diff --git a/src/commands/segment/SegmentQuickCopyCommand.h b/src/commands/segment/SegmentQuickCopyCommand.h new file mode 100644 index 0000000..638b16a --- /dev/null +++ b/src/commands/segment/SegmentQuickCopyCommand.h @@ -0,0 +1,68 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTQUICKCOPYCOMMAND_H_ +#define _RG_SEGMENTQUICKCOPYCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class SegmentQuickCopyCommand : public KNamedCommand +{ +public: + SegmentQuickCopyCommand(Segment *segment); + virtual ~SegmentQuickCopyCommand(); + + virtual void execute(); + virtual void unexecute(); + + // return pointer to new copy + Segment* getCopy() { return m_segment; } + + static QString getGlobalName() { return i18n("Quick-Copy Segment"); } + +private: + Composition *m_composition; + Segment *m_segmentToCopy; + Segment *m_segment; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentReconfigureCommand.cpp b/src/commands/segment/SegmentReconfigureCommand.cpp new file mode 100644 index 0000000..ec9d1bd --- /dev/null +++ b/src/commands/segment/SegmentReconfigureCommand.cpp @@ -0,0 +1,114 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentReconfigureCommand.h" + +#include "base/Segment.h" +#include "base/Track.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentReconfigureCommand::SegmentReconfigureCommand(QString name) : + KNamedCommand(name) +{} + +SegmentReconfigureCommand::~SegmentReconfigureCommand() +{} + +void +SegmentReconfigureCommand::addSegment(Segment *segment, + timeT startTime, + timeT endMarkerTime, + TrackId track) +{ + SegmentRec record; + record.segment = segment; + record.startTime = startTime; + record.endMarkerTime = endMarkerTime; + record.track = track; + m_records.push_back(record); +} + +void +SegmentReconfigureCommand::addSegments(const SegmentRecSet &records) +{ + for (SegmentRecSet::const_iterator i = records.begin(); i != records.end(); ++i) { + m_records.push_back(*i); + } +} + +void +SegmentReconfigureCommand::execute() +{ + swap(); +} + +void +SegmentReconfigureCommand::unexecute() +{ + swap(); +} + +void +SegmentReconfigureCommand::swap() +{ + for (SegmentRecSet::iterator i = m_records.begin(); + i != m_records.end(); ++i) { + + // set the segment's values from the record, but set the + // previous values back in to the record for use in the + // next iteration of the execute/unexecute cycle. + + // #1083496: look up both of the "old" values before we set + // anything, as setting the start time is likely to change the + // end marker time. + + timeT prevStartTime = i->segment->getStartTime(); + timeT prevEndMarkerTime = i->segment->getEndMarkerTime(); + + if (i->segment->getStartTime() != i->startTime) { + i->segment->setStartTime(i->startTime); + } + + if (i->segment->getEndMarkerTime() != i->endMarkerTime) { + i->segment->setEndMarkerTime(i->endMarkerTime); + } + + i->startTime = prevStartTime; + i->endMarkerTime = prevEndMarkerTime; + + TrackId currentTrack = i->segment->getTrack(); + + if (currentTrack != i->track) { + i->segment->setTrack(i->track); + i->track = currentTrack; + } + } +} + +} diff --git a/src/commands/segment/SegmentReconfigureCommand.h b/src/commands/segment/SegmentReconfigureCommand.h new file mode 100644 index 0000000..be82e47 --- /dev/null +++ b/src/commands/segment/SegmentReconfigureCommand.h @@ -0,0 +1,81 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTRECONFIGURECOMMAND_H_ +#define _RG_SEGMENTRECONFIGURECOMMAND_H_ + +#include "base/Track.h" +#include <kcommand.h> +#include <qstring.h> +#include <vector> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +/** + * SegmentReconfigureCommand is a general-purpose command for + * moving, resizing or changing the track of one or more segments + */ +class SegmentReconfigureCommand : public KNamedCommand +{ +public: + SegmentReconfigureCommand(QString name); + virtual ~SegmentReconfigureCommand(); + + struct SegmentRec { + Segment *segment; + timeT startTime; + timeT endMarkerTime; + TrackId track; + }; + typedef std::vector<SegmentRec> SegmentRecSet; + + void addSegment(Segment *segment, + timeT startTime, + timeT endMarkerTime, + TrackId track); + + void addSegments(const SegmentRecSet &records); + + void execute(); + void unexecute(); + +private: + SegmentRecSet m_records; + void swap(); +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentRecordCommand.cpp b/src/commands/segment/SegmentRecordCommand.cpp new file mode 100644 index 0000000..f457f32 --- /dev/null +++ b/src/commands/segment/SegmentRecordCommand.cpp @@ -0,0 +1,67 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentRecordCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" + + +namespace Rosegarden +{ + +SegmentRecordCommand::SegmentRecordCommand(Segment *s) : + KNamedCommand(i18n("Record")), + m_composition(s->getComposition()), + m_segment(s), + m_detached(false) +{} + +SegmentRecordCommand::~SegmentRecordCommand() +{ + if (m_detached) { + delete m_segment; + } +} + +void +SegmentRecordCommand::execute() +{ + if (!m_segment->getComposition()) { + m_composition->addSegment(m_segment); + } + + m_detached = false; +} + +void +SegmentRecordCommand::unexecute() +{ + m_composition->detachSegment(m_segment); + m_detached = true; +} + +} diff --git a/src/commands/segment/SegmentRecordCommand.h b/src/commands/segment/SegmentRecordCommand.h new file mode 100644 index 0000000..c3f4ffe --- /dev/null +++ b/src/commands/segment/SegmentRecordCommand.h @@ -0,0 +1,67 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTRECORDCOMMAND_H_ +#define _RG_SEGMENTRECORDCOMMAND_H_ + +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +/** + * SegmentRecordCommand pretends to insert a Segment that is actually + * already in the Composition (the currently-being-recorded one). It's + * used at the end of recording, to ensure that GUI updates happen + * correctly, and it provides the ability to undo recording. (The + * unexecute does remove the segment, it doesn't just pretend to.) + */ +class SegmentRecordCommand : public KNamedCommand +{ +public: + SegmentRecordCommand(Segment *segment); + virtual ~SegmentRecordCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + Segment *m_segment; + bool m_detached; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentRepeatToCopyCommand.cpp b/src/commands/segment/SegmentRepeatToCopyCommand.cpp new file mode 100644 index 0000000..a0e0e43 --- /dev/null +++ b/src/commands/segment/SegmentRepeatToCopyCommand.cpp @@ -0,0 +1,106 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentRepeatToCopyCommand.h" + +#include "base/Event.h" +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" + + +namespace Rosegarden +{ + +SegmentRepeatToCopyCommand::SegmentRepeatToCopyCommand( + Segment *segment): + KNamedCommand(i18n("Turn Repeats into Copies")), + m_composition(segment->getComposition()), + m_segment(segment), + m_detached(false) +{} + +SegmentRepeatToCopyCommand::~SegmentRepeatToCopyCommand() +{ + if (m_detached) { + std::vector<Segment*>::iterator it = + m_newSegments.begin(); + + for (; it != m_newSegments.end(); it++) + delete (*it); + } +} + +void +SegmentRepeatToCopyCommand::execute() +{ + if (m_newSegments.size() == 0) { + timeT newStartTime = m_segment->getEndMarkerTime(); + timeT newDuration = + m_segment->getEndMarkerTime() - m_segment->getStartTime(); + Segment *newSegment; + timeT repeatEndTime = m_segment->getRepeatEndTime(); + + while (newStartTime + newDuration < repeatEndTime) { + // Create new segment, transpose and turn off repeat + // + newSegment = new Segment(*m_segment); + newSegment->setStartTime(newStartTime); + newSegment->setRepeating(false); + + // Insert and store + m_composition->addSegment(newSegment); + m_newSegments.push_back(newSegment); + + // Move onto next + newStartTime += newDuration; + } + + // fill remaining partial segment + } else { + std::vector<Segment*>::iterator it = + m_newSegments.begin(); + + for (; it != m_newSegments.end(); it++) + m_composition->addSegment(*it); + } + m_segment->setRepeating(false); + m_detached = false; +} + +void +SegmentRepeatToCopyCommand::unexecute() +{ + std::vector<Segment*>::iterator it = + m_newSegments.begin(); + + for (; it != m_newSegments.end(); it++) + m_composition->detachSegment(*it); + + m_detached = true; + m_segment->setRepeating(true); +} + +} diff --git a/src/commands/segment/SegmentRepeatToCopyCommand.h b/src/commands/segment/SegmentRepeatToCopyCommand.h new file mode 100644 index 0000000..d0cc565 --- /dev/null +++ b/src/commands/segment/SegmentRepeatToCopyCommand.h @@ -0,0 +1,62 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTREPEATTOCOPYCOMMAND_H_ +#define _RG_SEGMENTREPEATTOCOPYCOMMAND_H_ + +#include <kcommand.h> +#include <vector> + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class SegmentRepeatToCopyCommand : public KNamedCommand +{ +public: + SegmentRepeatToCopyCommand(Segment *segment); + virtual ~SegmentRepeatToCopyCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + + Composition *m_composition; + Segment *m_segment; + std::vector<Segment*> m_newSegments; + bool m_detached; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentRescaleCommand.cpp b/src/commands/segment/SegmentRescaleCommand.cpp new file mode 100644 index 0000000..d7a7c80 --- /dev/null +++ b/src/commands/segment/SegmentRescaleCommand.cpp @@ -0,0 +1,148 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentRescaleCommand.h" + +#include "misc/Strings.h" +#include "base/Event.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentRescaleCommand::SegmentRescaleCommand(Segment *s, + int multiplier, + int divisor) : + KNamedCommand(getGlobalName()), + m_segment(s), + m_newSegment(0), + m_startTimeGiven(false), + m_startTime(s->getStartTime()), + m_multiplier(multiplier), + m_divisor(divisor), + m_detached(false) +{ + // nothing +} + +SegmentRescaleCommand::SegmentRescaleCommand(Segment *s, + int multiplier, + int divisor, + timeT st) : + KNamedCommand(getGlobalName()), + m_segment(s), + m_newSegment(0), + m_startTimeGiven(true), + m_startTime(st), + m_multiplier(multiplier), + m_divisor(divisor), + m_detached(false) +{ + // nothing +} + +SegmentRescaleCommand::~SegmentRescaleCommand() +{ + if (m_detached) { + delete m_segment; + } else { + delete m_newSegment; + } +} + +timeT +SegmentRescaleCommand::rescale(timeT t) +{ + // avoid overflows by using doubles + double d = t; + d *= m_multiplier; + d /= m_divisor; + d += 0.5; + return (timeT)d; +} + +void +SegmentRescaleCommand::execute() +{ + timeT startTime = m_segment->getStartTime(); + + if (m_startTimeGiven) startTime = m_startTime; + + if (!m_newSegment) { + + m_newSegment = new Segment(); + m_newSegment->setTrack(m_segment->getTrack()); + QString oldLabel = strtoqstr(m_segment->getLabel()); + if (oldLabel.endsWith(i18n("(rescaled)"))) { + m_newSegment->setLabel(m_segment->getLabel()); + } else { + m_newSegment->setLabel(qstrtostr(i18n("%1 (rescaled)").arg + (oldLabel))); + } + m_newSegment->setColourIndex(m_segment->getColourIndex()); + + for (Segment::iterator i = m_segment->begin(); + m_segment->isBeforeEndMarker(i); ++i) { + + if ((*i)->isa(Note::EventRestType)) + continue; + + timeT dt = (*i)->getAbsoluteTime() - startTime; + timeT duration = (*i)->getDuration(); + + //!!! use doubles for this calculation where necessary + + m_newSegment->insert + (new Event(**i, + startTime + rescale(dt), + rescale(duration))); + } + } + + m_segment->getComposition()->addSegment(m_newSegment); + m_segment->getComposition()->detachSegment(m_segment); + m_newSegment->normalizeRests(m_newSegment->getStartTime(), + m_newSegment->getEndTime()); + + m_newSegment->setEndMarkerTime + (startTime + rescale(m_segment->getEndMarkerTime() - + m_segment->getStartTime())); + + m_detached = true; +} + +void +SegmentRescaleCommand::unexecute() +{ + m_newSegment->getComposition()->addSegment(m_segment); + m_newSegment->getComposition()->detachSegment(m_newSegment); + m_detached = false; +} + +} diff --git a/src/commands/segment/SegmentRescaleCommand.h b/src/commands/segment/SegmentRescaleCommand.h new file mode 100644 index 0000000..7a34727 --- /dev/null +++ b/src/commands/segment/SegmentRescaleCommand.h @@ -0,0 +1,76 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTRESCALECOMMAND_H_ +#define _RG_SEGMENTRESCALECOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include "base/Event.h" +#include <klocale.h> + + + + +namespace Rosegarden +{ + +class Segment; + + +class SegmentRescaleCommand : public KNamedCommand +{ +public: + SegmentRescaleCommand(Segment *segment, + int multiplier, + int divisor); + SegmentRescaleCommand(Segment *segment, + int multiplier, + int divisor, + timeT newStartTime); + virtual ~SegmentRescaleCommand(); + + virtual void execute(); + virtual void unexecute(); + + static QString getGlobalName() { return i18n("Stretch or S&quash..."); } + +private: + Segment *m_segment; + Segment *m_newSegment; + bool m_startTimeGiven; + timeT m_startTime; + int m_multiplier; + int m_divisor; + bool m_detached; + + timeT rescale(timeT); +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentResizeFromStartCommand.cpp b/src/commands/segment/SegmentResizeFromStartCommand.cpp new file mode 100644 index 0000000..a4157bb --- /dev/null +++ b/src/commands/segment/SegmentResizeFromStartCommand.cpp @@ -0,0 +1,85 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentResizeFromStartCommand.h" + +#include <klocale.h> +#include "base/Event.h" +#include "base/Segment.h" +#include "document/BasicCommand.h" + + +namespace Rosegarden +{ + +SegmentResizeFromStartCommand::SegmentResizeFromStartCommand(Segment *s, + timeT time) : + BasicCommand(i18n("Resize Segment"), *s, + std::min(time, s->getStartTime()), + std::max(time, s->getStartTime())), + m_segment(s), + m_oldStartTime(s->getStartTime()), + m_newStartTime(time) +{ + // nothing else +} + +SegmentResizeFromStartCommand::~SegmentResizeFromStartCommand() +{ + // nothing +} + +void +SegmentResizeFromStartCommand::modifySegment() +{ + if (m_newStartTime < m_oldStartTime) { + m_segment->fillWithRests(m_newStartTime, m_oldStartTime); + } else { + + for (Segment::iterator i = m_segment->begin(); + m_segment->isBeforeEndMarker(i); ) { + + Segment::iterator j = i; + ++j; + + if ((*i)->getAbsoluteTime() >= m_newStartTime) + break; + + if ((*i)->getAbsoluteTime() + (*i)->getDuration() <= m_newStartTime) { + m_segment->erase(i); + } else { + Event *e = new Event + (**i, m_newStartTime, + (*i)->getAbsoluteTime() + (*i)->getDuration() - m_newStartTime); + m_segment->erase(i); + m_segment->insert(e); + } + + i = j; + } + } +} + +} diff --git a/src/commands/segment/SegmentResizeFromStartCommand.h b/src/commands/segment/SegmentResizeFromStartCommand.h new file mode 100644 index 0000000..8f0dc89 --- /dev/null +++ b/src/commands/segment/SegmentResizeFromStartCommand.h @@ -0,0 +1,69 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTRESIZEFROMSTARTCOMMAND_H_ +#define _RG_SEGMENTRESIZEFROMSTARTCOMMAND_H_ + +#include "document/BasicCommand.h" +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +/** + * SegmentResizeFromStartCommand moves the start time of a segment + * leaving the events in it at the same absolute times as before, so + * padding with rests or deleting events as appropriate. (Distinct + * from Segment::setStartTime, as used by SegmentReconfigureCommand, + * which moves all the events in the segment.) + * Not for use on audio segments (see AudioSegmentResizeFromStartCommand). + */ +class SegmentResizeFromStartCommand : public BasicCommand +{ +public: + SegmentResizeFromStartCommand(Segment *segment, + timeT newStartTime); + virtual ~SegmentResizeFromStartCommand(); + +protected: + virtual void modifySegment(); + +private: + Segment *m_segment; + timeT m_oldStartTime; + timeT m_newStartTime; +}; + + + +} + +#endif diff --git a/src/commands/segment/SegmentSingleRepeatToCopyCommand.cpp b/src/commands/segment/SegmentSingleRepeatToCopyCommand.cpp new file mode 100644 index 0000000..c9b92fb --- /dev/null +++ b/src/commands/segment/SegmentSingleRepeatToCopyCommand.cpp @@ -0,0 +1,73 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentSingleRepeatToCopyCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/Segment.h" + + +namespace Rosegarden +{ + +SegmentSingleRepeatToCopyCommand::SegmentSingleRepeatToCopyCommand( + Segment *segment, + timeT time): + KNamedCommand(i18n("Turn Single Repeat into Copy")), + m_composition(segment->getComposition()), + m_segment(segment), + m_newSegment(0), + m_time(time), + m_detached(false) +{} + +SegmentSingleRepeatToCopyCommand::~SegmentSingleRepeatToCopyCommand() +{ + if (m_detached) + delete m_newSegment; +} + +void +SegmentSingleRepeatToCopyCommand::execute() +{ + if (!m_newSegment) { + m_newSegment = new Segment(*m_segment); + m_newSegment->setStartTime(m_time); + m_newSegment->setRepeating(true); + } + + m_composition->addSegment(m_newSegment); + m_detached = false; +} + +void +SegmentSingleRepeatToCopyCommand::unexecute() +{ + m_composition->detachSegment(m_newSegment); + m_detached = true; +} + +} diff --git a/src/commands/segment/SegmentSingleRepeatToCopyCommand.h b/src/commands/segment/SegmentSingleRepeatToCopyCommand.h new file mode 100644 index 0000000..0c4984e --- /dev/null +++ b/src/commands/segment/SegmentSingleRepeatToCopyCommand.h @@ -0,0 +1,65 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTSINGLEREPEATTOCOPYCOMMAND_H_ +#define _RG_SEGMENTSINGLEREPEATTOCOPYCOMMAND_H_ + +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class SegmentSingleRepeatToCopyCommand : public KNamedCommand +{ +public: + SegmentSingleRepeatToCopyCommand(Segment *segment, + timeT time); + virtual ~SegmentSingleRepeatToCopyCommand(); + + virtual void execute(); + virtual void unexecute(); + + Segment *getNewSegment() const { return m_newSegment; } + +private: + Composition *m_composition; + Segment *m_segment; + Segment *m_newSegment; + timeT m_time; + bool m_detached; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentSplitByPitchCommand.cpp b/src/commands/segment/SegmentSplitByPitchCommand.cpp new file mode 100644 index 0000000..2000a35 --- /dev/null +++ b/src/commands/segment/SegmentSplitByPitchCommand.cpp @@ -0,0 +1,280 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentSplitByPitchCommand.h" + +#include "base/BaseProperties.h" +#include "base/Sets.h" +#include "misc/Strings.h" +#include "base/Composition.h" +#include "base/Event.h" +#include "base/NotationTypes.h" +#include "base/NotationQuantizer.h" +#include "base/Segment.h" +#include "base/SegmentNotationHelper.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentSplitByPitchCommand::SegmentSplitByPitchCommand(Segment *segment, + int p, bool r, bool d, + ClefHandling c) : + KNamedCommand(i18n("Split by Pitch")), + m_composition(segment->getComposition()), + m_segment(segment), + m_newSegmentA(0), + m_newSegmentB(0), + m_splitPitch(p), + m_ranging(r), + m_dupNonNoteEvents(d), + m_clefHandling(c), + m_executed(false) +{} + +SegmentSplitByPitchCommand::~SegmentSplitByPitchCommand() +{ + if (m_executed) { + delete m_segment; + } else { + delete m_newSegmentA; + delete m_newSegmentB; + } +} + +void +SegmentSplitByPitchCommand::execute() +{ + if (!m_newSegmentA) { + + m_newSegmentA = new Segment; + m_newSegmentB = new Segment; + + m_newSegmentA->setTrack(m_segment->getTrack()); + m_newSegmentA->setStartTime(m_segment->getStartTime()); + + m_newSegmentB->setTrack(m_segment->getTrack()); + m_newSegmentB->setStartTime(m_segment->getStartTime()); + + int splitPitch(m_splitPitch); + + for (Segment::iterator i = m_segment->begin(); + m_segment->isBeforeEndMarker(i); ++i) { + + if ((*i)->isa(Note::EventRestType)) + continue; + if ((*i)->isa(Clef::EventType) && + m_clefHandling != LeaveClefs) + continue; + + if ((*i)->isa(Note::EventType)) { + + if (m_ranging) { + splitPitch = getSplitPitchAt(i, splitPitch); + } + + if ((*i)->has(BaseProperties::PITCH) && + (*i)->get + <Int>(BaseProperties::PITCH) < + splitPitch) { + if (m_newSegmentB->empty()) { + m_newSegmentB->fillWithRests((*i)->getAbsoluteTime()); + } + m_newSegmentB->insert(new Event(**i)); + } + else { + if (m_newSegmentA->empty()) { + m_newSegmentA->fillWithRests((*i)->getAbsoluteTime()); + } + m_newSegmentA->insert(new Event(**i)); + } + + } else { + + m_newSegmentA->insert(new Event(**i)); + + if (m_dupNonNoteEvents) { + m_newSegmentB->insert(new Event(**i)); + } + } + } + + //!!! m_newSegmentA->fillWithRests(m_segment->getEndMarkerTime()); + // m_newSegmentB->fillWithRests(m_segment->getEndMarkerTime()); + m_newSegmentA->normalizeRests(m_segment->getStartTime(), + m_segment->getEndMarkerTime()); + m_newSegmentB->normalizeRests(m_segment->getStartTime(), + m_segment->getEndMarkerTime()); + } + + m_composition->addSegment(m_newSegmentA); + m_composition->addSegment(m_newSegmentB); + + SegmentNotationHelper helperA(*m_newSegmentA); + SegmentNotationHelper helperB(*m_newSegmentB); + + if (m_clefHandling == RecalculateClefs) { + + m_newSegmentA->insert + (helperA.guessClef(m_newSegmentA->begin(), + m_newSegmentA->end()).getAsEvent + (m_newSegmentA->getStartTime())); + + m_newSegmentB->insert + (helperB.guessClef(m_newSegmentB->begin(), + m_newSegmentB->end()).getAsEvent + (m_newSegmentB->getStartTime())); + + } else if (m_clefHandling == UseTrebleAndBassClefs) { + + m_newSegmentA->insert + (Clef(Clef::Treble).getAsEvent + (m_newSegmentA->getStartTime())); + + m_newSegmentB->insert + (Clef(Clef::Bass).getAsEvent + (m_newSegmentB->getStartTime())); + } + + //!!! m_composition->getNotationQuantizer()->quantize(m_newSegmentA); + // m_composition->getNotationQuantizer()->quantize(m_newSegmentB); + helperA.autoBeam(m_newSegmentA->begin(), m_newSegmentA->end(), + BaseProperties::GROUP_TYPE_BEAMED); + helperB.autoBeam(m_newSegmentB->begin(), m_newSegmentB->end(), + BaseProperties::GROUP_TYPE_BEAMED); + + std::string label = m_segment->getLabel(); + m_newSegmentA->setLabel(qstrtostr(i18n("%1 (upper)").arg + (strtoqstr(label)))); + m_newSegmentB->setLabel(qstrtostr(i18n("%1 (lower)").arg + (strtoqstr(label)))); + m_newSegmentA->setColourIndex(m_segment->getColourIndex()); + m_newSegmentB->setColourIndex(m_segment->getColourIndex()); + + m_composition->detachSegment(m_segment); + m_executed = true; +} + +void +SegmentSplitByPitchCommand::unexecute() +{ + m_composition->addSegment(m_segment); + m_composition->detachSegment(m_newSegmentA); + m_composition->detachSegment(m_newSegmentB); + m_executed = false; +} + +int +SegmentSplitByPitchCommand::getSplitPitchAt(Segment::iterator i, + int lastSplitPitch) +{ + typedef std::set<int>::iterator PitchItr; + std::set<int> pitches; + + // when this algorithm appears to be working ok, we should be + // able to make it much quicker + + const Quantizer *quantizer + (m_segment->getComposition()->getNotationQuantizer()); + + int myHighest, myLowest; + int prevHighest = 0, prevLowest = 0; + bool havePrev = false; + + Chord c0(*m_segment, i, quantizer); + std::vector<int> c0p(c0.getPitches()); + pitches.insert<std::vector<int>::iterator>(c0p.begin(), c0p.end()); + + myLowest = c0p[0]; + myHighest = c0p[c0p.size() - 1]; + + Segment::iterator j(c0.getPreviousNote()); + if (j != m_segment->end()) { + + havePrev = true; + + Chord c1(*m_segment, j, quantizer); + std::vector<int> c1p(c1.getPitches()); + pitches.insert<std::vector<int>::iterator>(c1p.begin(), c1p.end()); + + prevLowest = c1p[0]; + prevHighest = c1p[c1p.size() - 1]; + } + + if (pitches.size() < 2) + return lastSplitPitch; + + PitchItr pi = pitches.begin(); + int lowest(*pi); + + pi = pitches.end(); + --pi; + int highest(*pi); + + if ((pitches.size() == 2 || highest - lowest <= 18) && + myHighest > lastSplitPitch && + myLowest < lastSplitPitch && + prevHighest > lastSplitPitch && + prevLowest < lastSplitPitch) { + + if (havePrev) { + if ((myLowest > prevLowest && myHighest > prevHighest) || + (myLowest < prevLowest && myHighest < prevHighest)) { + int avgDiff = ((myLowest - prevLowest) + + (myHighest - prevHighest)) / 2; + if (avgDiff < -5) + avgDiff = -5; + if (avgDiff > 5) + avgDiff = 5; + return lastSplitPitch + avgDiff; + } + } + + return lastSplitPitch; + } + + int middle = (highest - lowest) / 2 + lowest; + + while (lastSplitPitch > middle && lastSplitPitch > m_splitPitch - 12) { + if (lastSplitPitch - lowest < 12) + return lastSplitPitch; + if (lastSplitPitch <= m_splitPitch - 12) + return lastSplitPitch; + --lastSplitPitch; + } + + while (lastSplitPitch < middle && lastSplitPitch < m_splitPitch + 12) { + if (highest - lastSplitPitch < 12) + return lastSplitPitch; + if (lastSplitPitch >= m_splitPitch + 12) + return lastSplitPitch; + ++lastSplitPitch; + } + + return lastSplitPitch; +} + +} diff --git a/src/commands/segment/SegmentSplitByPitchCommand.h b/src/commands/segment/SegmentSplitByPitchCommand.h new file mode 100644 index 0000000..e536be6 --- /dev/null +++ b/src/commands/segment/SegmentSplitByPitchCommand.h @@ -0,0 +1,83 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTSPLITBYPITCHCOMMAND_H_ +#define _RG_SEGMENTSPLITBYPITCHCOMMAND_H_ + +#include "base/Segment.h" +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> +#include "gui/general/ClefIndex.h" + + + + +namespace Rosegarden +{ + +class Composition; + + +class SegmentSplitByPitchCommand : public KNamedCommand +{ +public: + enum ClefHandling { + LeaveClefs, + RecalculateClefs, + UseTrebleAndBassClefs + }; + + SegmentSplitByPitchCommand(Segment *segment, + int splitPitch, + bool ranging, + bool duplicateNonNoteEvents, + ClefHandling clefHandling); + virtual ~SegmentSplitByPitchCommand(); + + static QString getGlobalName() + { return i18n("Split by &Pitch..."); } + + virtual void execute(); + virtual void unexecute(); + +private: + int getSplitPitchAt(Segment::iterator i, int lastSplitPitch); + + Composition *m_composition; + Segment *m_segment; + Segment *m_newSegmentA; + Segment *m_newSegmentB; + int m_splitPitch; + bool m_ranging; + bool m_dupNonNoteEvents; + ClefHandling m_clefHandling; + bool m_executed; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentSplitByRecordingSrcCommand.cpp b/src/commands/segment/SegmentSplitByRecordingSrcCommand.cpp new file mode 100644 index 0000000..fbb3c1b --- /dev/null +++ b/src/commands/segment/SegmentSplitByRecordingSrcCommand.cpp @@ -0,0 +1,153 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentSplitByRecordingSrcCommand.h" + +#include "base/BaseProperties.h" +#include "misc/Strings.h" +#include "base/Composition.h" +#include "base/Event.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentSplitByRecordingSrcCommand::SegmentSplitByRecordingSrcCommand ( + Segment *segment, int channel, int device ) : + KNamedCommand(i18n("Split by Recording Source")), + m_composition(segment->getComposition()), + m_segment(segment), + m_newSegmentA(0), + m_channel(channel), + m_device(device), + m_executed(false) +{} + +void +SegmentSplitByRecordingSrcCommand::execute() +{ + if (!m_newSegmentA) { + + m_newSegmentA = new Segment; + m_newSegmentB = new Segment; + + m_newSegmentA->setTrack(m_segment->getTrack()); + m_newSegmentA->setStartTime(m_segment->getStartTime()); + + m_newSegmentB->setTrack(m_segment->getTrack()); + m_newSegmentB->setStartTime(m_segment->getStartTime()); + + bool selectedC = false; + bool selectedD = false; + + for (Segment::iterator i = m_segment->begin(); + m_segment->isBeforeEndMarker(i); ++i) { + + if ((*i)->isa(Note::EventRestType)) + continue; + + if ( (*i)->isa(Clef::EventType) || + (*i)->isa(Key::EventType) ) { + + m_newSegmentA->insert(new Event(**i)); + m_newSegmentB->insert(new Event(**i)); + continue; + } + + selectedC = false; + selectedD = false; + + if ((*i)->has(BaseProperties::RECORDED_CHANNEL)) { + selectedC = true; + if (m_channel > -1) + selectedC = ( m_channel == + (*i)->get + <Int>(BaseProperties::RECORDED_CHANNEL) ); + } + + if ((*i)->has(BaseProperties::RECORDED_PORT)) { + selectedD = true; + if (m_device > -1) + selectedD = ( m_device == + (*i)->get + <Int>(BaseProperties::RECORDED_PORT) ); + } + + if (selectedC & selectedD) { + if (m_newSegmentB->empty()) { + m_newSegmentB->fillWithRests((*i)->getAbsoluteTime()); + } + m_newSegmentB->insert(new Event(**i)); + } else { + if (m_newSegmentA->empty()) { + m_newSegmentA->fillWithRests((*i)->getAbsoluteTime()); + } + m_newSegmentA->insert(new Event(**i)); + } + } + + m_newSegmentA->normalizeRests(m_segment->getStartTime(), + m_segment->getEndMarkerTime()); + m_newSegmentB->normalizeRests(m_segment->getStartTime(), + m_segment->getEndMarkerTime()); + + std::string label = m_segment->getLabel(); + m_newSegmentA->setLabel(qstrtostr(i18n("%1 (split)").arg + (strtoqstr(label)))); + m_newSegmentB->setLabel(qstrtostr(i18n("%1 (split)").arg + (strtoqstr(label)))); + m_newSegmentA->setColourIndex(m_segment->getColourIndex()); + m_newSegmentB->setColourIndex(m_segment->getColourIndex()); + } + + m_composition->addSegment(m_newSegmentA); + m_composition->addSegment(m_newSegmentB); + m_composition->detachSegment(m_segment); + m_executed = true; +} + +void +SegmentSplitByRecordingSrcCommand::unexecute() +{ + m_composition->addSegment(m_segment); + m_composition->detachSegment(m_newSegmentA); + m_composition->detachSegment(m_newSegmentB); + m_executed = false; +} + +SegmentSplitByRecordingSrcCommand::~SegmentSplitByRecordingSrcCommand() +{ + if (m_executed) { + delete m_segment; + } else { + delete m_newSegmentA; + delete m_newSegmentB; + } +} + +} diff --git a/src/commands/segment/SegmentSplitByRecordingSrcCommand.h b/src/commands/segment/SegmentSplitByRecordingSrcCommand.h new file mode 100644 index 0000000..3b087ab --- /dev/null +++ b/src/commands/segment/SegmentSplitByRecordingSrcCommand.h @@ -0,0 +1,70 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTSPLITBYRECORDINGSRCCOMMAND_H_ +#define _RG_SEGMENTSPLITBYRECORDINGSRCCOMMAND_H_ + +#include <kcommand.h> +#include <qstring.h> +#include <klocale.h> +#include "gui/application/RosegardenDCOP.h" + + + + +namespace Rosegarden +{ + +class Segment; +class Composition; + + +class SegmentSplitByRecordingSrcCommand : public KNamedCommand +{ +public: + SegmentSplitByRecordingSrcCommand(Segment *segment, + int channel, int device); + virtual ~SegmentSplitByRecordingSrcCommand(); + + static QString getGlobalName() + { return i18n("Split by &Recording Source..."); } + + virtual void execute(); + virtual void unexecute(); + +private: + Composition *m_composition; + Segment *m_segment; + Segment *m_newSegmentA; + Segment *m_newSegmentB; + int m_channel; + int m_device; + bool m_executed; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentSplitCommand.cpp b/src/commands/segment/SegmentSplitCommand.cpp new file mode 100644 index 0000000..450ad3e --- /dev/null +++ b/src/commands/segment/SegmentSplitCommand.cpp @@ -0,0 +1,185 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentSplitCommand.h" + +#include <klocale.h> +#include "misc/Strings.h" +#include "base/Event.h" +#include "base/Composition.h" +#include "base/NotationTypes.h" +#include "base/Segment.h" +#include <qstring.h> + + +namespace Rosegarden +{ + +SegmentSplitCommand::SegmentSplitCommand(Segment *segment, + timeT splitTime) : + KNamedCommand(i18n("Split Segment")), + m_segment(segment), + m_newSegmentA(0), + m_newSegmentB(0), + m_splitTime(splitTime), + m_previousEndMarkerTime(0), + m_detached(true) +{} + +SegmentSplitCommand::~SegmentSplitCommand() +{ + if (m_detached) { + delete m_newSegmentA; + delete m_newSegmentB; + } + delete m_previousEndMarkerTime; +} + +void +SegmentSplitCommand::execute() +{ + if (m_newSegmentA) { + + m_segment->getComposition()->addSegment(m_newSegmentA); + m_segment->getComposition()->addSegment(m_newSegmentB); + + m_segment->getComposition()->detachSegment(m_segment); + + m_detached = false; // i.e. new segments are not detached + return; + } + + m_newSegmentA = new Segment(*m_segment); + m_newSegmentB = new Segment(); + + m_newSegmentB->setTrack(m_segment->getTrack()); + m_newSegmentB->setStartTime(m_splitTime); + + m_segment->getComposition()->addSegment(m_newSegmentA); + m_segment->getComposition()->addSegment(m_newSegmentB); + + Event *clefEvent = 0; + Event *keyEvent = 0; + + // Copy the last occurrence of clef and key + // from the left hand side of the split (nb. timesig events + // don't appear in segments, only in composition) + // + Segment::iterator it = m_segment->findTime(m_splitTime); + + while (it != m_segment->begin()) { + + --it; + + if (!clefEvent && (*it)->isa(Clef::EventType)) { + clefEvent = new Event(**it, m_splitTime); + } + + if (!keyEvent && (*it)->isa(Key::EventType)) { + keyEvent = new Event(**it, m_splitTime); + } + + if (clefEvent && keyEvent) + break; + } + + // Insert relevant meta info if we've found some + // + if (clefEvent) + m_newSegmentB->insert(clefEvent); + + if (keyEvent) + m_newSegmentB->insert(keyEvent); + + // Copy through the Events + // + it = m_segment->findTime(m_splitTime); + + if (it != m_segment->end() && (*it)->getAbsoluteTime() > m_splitTime) { + m_newSegmentB->fillWithRests((*it)->getAbsoluteTime()); + } + + while (it != m_segment->end()) { + m_newSegmentB->insert(new Event(**it)); + ++it; + } + m_newSegmentB->setEndTime(m_segment->getEndTime()); + m_newSegmentB->setEndMarkerTime(m_segment->getEndMarkerTime()); + + // Set labels + // + m_segmentLabel = m_segment->getLabel(); + QString newLabel = strtoqstr(m_segmentLabel); + if (!newLabel.endsWith(i18n(" (split)"))) { + newLabel = i18n("%1 (split)").arg(newLabel); + } + m_newSegmentA->setLabel(newLabel); + m_newSegmentB->setLabel(newLabel); + + m_newSegmentB->setColourIndex(m_segment->getColourIndex()); + m_newSegmentB->setTranspose(m_segment->getTranspose()); + m_newSegmentB->setDelay(m_segment->getDelay()); + + // Resize left hand Segment + // + std::vector<Event *> toErase, toInsert; + for (Segment::iterator i = m_newSegmentA->findTime(m_splitTime); + i != m_newSegmentA->end(); ++i) { + if ((*i)->getAbsoluteTime() >= m_splitTime) break; + if ((*i)->getAbsoluteTime() + (*i)->getDuration() > m_splitTime) { + Event *e = new Event(**i, (*i)->getAbsoluteTime(), + m_splitTime - (*i)->getAbsoluteTime()); + toErase.push_back(*i); + toInsert.push_back(e); + } + } + + for (int i = 0; i < toErase.size(); ++i) { + m_newSegmentA->eraseSingle(toErase[i]); + delete toErase[i]; + } + for (int i = 0; i < toInsert.size(); ++i) { + m_newSegmentA->insert(toInsert[i]); + } + + m_newSegmentA->setEndTime(m_splitTime); + + m_segment->getComposition()->detachSegment(m_segment); + + m_detached = false; // i.e. new segments are not detached +} + +void +SegmentSplitCommand::unexecute() +{ + m_newSegmentA->getComposition()->addSegment(m_segment); + + m_segment->getComposition()->detachSegment(m_newSegmentA); + m_segment->getComposition()->detachSegment(m_newSegmentB); + + m_detached = true; // i.e. new segments are not detached +} + +} diff --git a/src/commands/segment/SegmentSplitCommand.h b/src/commands/segment/SegmentSplitCommand.h new file mode 100644 index 0000000..8b59b76 --- /dev/null +++ b/src/commands/segment/SegmentSplitCommand.h @@ -0,0 +1,65 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTSPLITCOMMAND_H_ +#define _RG_SEGMENTSPLITCOMMAND_H_ + +#include <string> +#include <kcommand.h> +#include "base/Event.h" + + + + +namespace Rosegarden +{ + +class Segment; + + +class SegmentSplitCommand : public KNamedCommand +{ +public: + SegmentSplitCommand(Segment *segment, + timeT splitTime); + virtual ~SegmentSplitCommand(); + + virtual void execute(); + virtual void unexecute(); + +private: + Segment *m_segment; + Segment *m_newSegmentA; + Segment *m_newSegmentB; + timeT m_splitTime; + timeT *m_previousEndMarkerTime; + bool m_detached; + std::string m_segmentLabel; +}; + + +} + +#endif diff --git a/src/commands/segment/SegmentSyncClefCommand.cpp b/src/commands/segment/SegmentSyncClefCommand.cpp new file mode 100644 index 0000000..5e3560b --- /dev/null +++ b/src/commands/segment/SegmentSyncClefCommand.cpp @@ -0,0 +1,67 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentSyncClefCommand.h" + +#include "base/Selection.h" +#include "commands/notation/ClefInsertionCommand.h" + +namespace Rosegarden +{ +SegmentSyncClefCommand::SegmentSyncClefCommand(Segment &segment, const Clef& clef) : + KMacroCommand(i18n("Sync segment clef")) +{ + processSegment(segment, clef); +} + +void +SegmentSyncClefCommand::processSegment(Segment &segment, const Clef& clef) +{ + KMacroCommand * macroCommand = this; + + // TODO delete it somewhere. + EventSelection * wholeSegment = new EventSelection(segment, segment.getStartTime(), segment.getEndMarkerTime()); + + EventSelection::eventcontainer::iterator i; + + for (i = wholeSegment->getSegmentEvents().begin(); + i != wholeSegment->getSegmentEvents().end(); ++i) { + if ((*i)->isa(Rosegarden::Clef::EventType)) { + macroCommand->addCommand + (new ClefInsertionCommand + (segment, + (*i)->getAbsoluteTime(), + clef, false, false)); + } + } + +} + + +SegmentSyncClefCommand::~SegmentSyncClefCommand() +{} + + +} diff --git a/src/commands/segment/SegmentSyncClefCommand.h b/src/commands/segment/SegmentSyncClefCommand.h new file mode 100644 index 0000000..01b97fd --- /dev/null +++ b/src/commands/segment/SegmentSyncClefCommand.h @@ -0,0 +1,55 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTSYNCCLEFCOMMAND_H_ +#define _RG_SEGMENTSYNCCLEFCOMMAND_H_ + +#include <kcommand.h> +#include "base/Event.h" +#include "base/NotationTypes.h" +#include "document/MultiViewCommandHistory.h" +#include <klocale.h> + +namespace Rosegarden +{ + +class Segment; +class SegmentSelection; + + +class SegmentSyncClefCommand : public KMacroCommand +{ +public: + SegmentSyncClefCommand(Segment &segment, const Clef& clef); + + virtual ~SegmentSyncClefCommand(); + +protected: + void processSegment(Segment &segment, const Clef& clef); +}; + +} + +#endif diff --git a/src/commands/segment/SegmentSyncCommand.cpp b/src/commands/segment/SegmentSyncCommand.cpp new file mode 100644 index 0000000..d5e9734 --- /dev/null +++ b/src/commands/segment/SegmentSyncCommand.cpp @@ -0,0 +1,103 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2007 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentSyncCommand.h" + +#include "base/Selection.h" +#include "commands/notation/KeyInsertionCommand.h" +#include "commands/edit/TransposeCommand.h" +#include "commands/segment/SegmentChangeTransposeCommand.h" +#include "commands/segment/SegmentTransposeCommand.h" +#include "commands/segment/SegmentSyncClefCommand.h" + +namespace Rosegarden +{ +SegmentSyncCommand::SegmentSyncCommand(Segment &segment, int newTranspose, int lowRange, int highRange, const Clef& clef) : + KMacroCommand(i18n("Sync segment parameters")) +{ + processSegment(segment, newTranspose, lowRange, highRange, clef); +} + +SegmentSyncCommand::SegmentSyncCommand(SegmentSelection selection, int newTranspose, int lowRange, int highRange, const Clef& clef) : + KMacroCommand(i18n("Sync segment parameters")) +{ + for (SegmentSelection::iterator i = selection.begin(); + i != selection.end(); ++i) + { + Segment &segment = **i; + processSegment(segment, newTranspose, lowRange, highRange, clef); + } +} + +SegmentSyncCommand::SegmentSyncCommand(std::vector<Segment *> segments, int newTranspose, int lowRange, int highRange, const Clef& clef) : + KMacroCommand(i18n("Sync segment parameters")) +{ + for (int i = 0; i < segments.size(); i++) { + processSegment(*(segments[i]), newTranspose, lowRange, highRange, clef); + } +} + +SegmentSyncCommand::SegmentSyncCommand(Composition::segmentcontainer& segments, TrackId selectedTrack, int newTranspose, int lowRange, int highRange, const Clef& clef) : + KMacroCommand(i18n("Sync segment parameters")) +{ + for (Composition::segmentcontainer::const_iterator si = segments.begin(); + si != segments.end(); ++si) { + if ((*si)->getTrack() == selectedTrack) { + processSegment(**si, newTranspose, lowRange, highRange, clef); + } + } +} + +void +SegmentSyncCommand::processSegment(Segment &segment, int newTranspose, int lowRange, int highRange, const Clef& clef) +{ + KMacroCommand * macroCommand = this; + + // if the new desired setting for 'transpose' is higher, we need to + // transpose the notes upwards to compensate: + int semitones = segment.getTranspose() - newTranspose; + + // Say the old transpose was -2 and the new is 0, this corresponds to + // Bb and C. The height of the old transpose is 1 below the height of the new. + int oldHeight = Pitch(segment.getTranspose()).getHeightOnStaff(Clef::Treble, Key("C major")); + int newHeight = Pitch(newTranspose).getHeightOnStaff(Clef::Treble, Key("C major")); + int steps = oldHeight - newHeight; + + SegmentTransposeCommand* command = new SegmentTransposeCommand(segment, true, steps, semitones, true); + macroCommand->addCommand(command); + + // TODO do this in an undoable fashion: + segment.setLowestPlayable(lowRange); + segment.setHighestPlayable(highRange); + + macroCommand->addCommand(new SegmentSyncClefCommand(segment, clef)); +} + + +SegmentSyncCommand::~SegmentSyncCommand() +{} + + +} diff --git a/src/commands/segment/SegmentSyncCommand.h b/src/commands/segment/SegmentSyncCommand.h new file mode 100644 index 0000000..0d8e189 --- /dev/null +++ b/src/commands/segment/SegmentSyncCommand.h @@ -0,0 +1,66 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2007 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTSYNCCOMMAND_H_ +#define _RG_SEGMENTSYNCCOMMAND_H_ + +#include <kcommand.h> +#include "base/Composition.h" +#include "base/Event.h" +#include "base/NotationTypes.h" +#include "document/MultiViewCommandHistory.h" +#include <klocale.h> + +namespace Rosegarden +{ + +class Segment; +class SegmentSelection; + + +class SegmentSyncCommand : public KMacroCommand +{ +public: + SegmentSyncCommand(Segment &segment, + int newTranspose, int lowRange, int highRange, const Clef& clef); + + SegmentSyncCommand(SegmentSelection selection, + int newTranspose, int lowRange, int highRange, const Clef& clef); + + SegmentSyncCommand(std::vector<Segment *> segments, + int newTranspose, int lowRange, int highRange, const Clef& clef); + + SegmentSyncCommand(Composition::segmentcontainer& segments, TrackId track, + int newTranspose, int lowRange, int highRange, const Clef& clef); + + virtual ~SegmentSyncCommand(); + +protected: + void processSegment(Segment &segment, int newTranspose, int lowRange, int highRange, const Clef& clef); +}; + +} + +#endif diff --git a/src/commands/segment/SegmentTransposeCommand.cpp b/src/commands/segment/SegmentTransposeCommand.cpp new file mode 100644 index 0000000..d3e4221 --- /dev/null +++ b/src/commands/segment/SegmentTransposeCommand.cpp @@ -0,0 +1,123 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SegmentTransposeCommand.h" + +#include "base/Selection.h" +#include "commands/notation/KeyInsertionCommand.h" +#include "commands/edit/TransposeCommand.h" +#include "commands/segment/SegmentChangeTransposeCommand.h" + +namespace Rosegarden +{ +SegmentTransposeCommand::SegmentTransposeCommand(Segment &segment, bool changeKey, int steps, int semitones, bool transposeSegmentBack) : + KMacroCommand(i18n("Change segment transposition")) +{ + processSegment(segment, changeKey, steps, semitones, transposeSegmentBack); +} + +SegmentTransposeCommand::SegmentTransposeCommand(SegmentSelection selection, bool changeKey, int steps, int semitones, bool transposeSegmentBack) : + KMacroCommand(i18n("Change segment transposition")) +{ + //SegmentSelection selection(m_view->getSelection()); + for (SegmentSelection::iterator i = selection.begin(); + i != selection.end(); ++i) + { + Segment &segment = **i; + processSegment(segment, changeKey, steps, semitones, transposeSegmentBack); + } +} + +void +SegmentTransposeCommand::processSegment(Segment &segment, bool changeKey, int steps, int semitones, bool transposeSegmentBack) +{ + KMacroCommand * macroCommand = this; + + // TODO delete it somewhere. + EventSelection * wholeSegment = new EventSelection(segment, segment.getStartTime(), segment.getEndMarkerTime()); + macroCommand->addCommand(new TransposeCommand + (semitones, steps, *wholeSegment)); + + // Key insertion can do transposition, but a C4 to D becomes a D4, while + // a C4 to G becomes a G3. Because we let the user specify an explicit number + // of octaves to move the notes up/down, we add the keys without transposing + // and handle the transposition seperately: + if (changeKey) + { + Rosegarden::Key initialKey = segment.getKeyAtTime(segment.getStartTime()); + Rosegarden::Key newInitialKey = initialKey.transpose(semitones, steps); + + EventSelection::eventcontainer::iterator i; + //std::list<KeyInsertionCommand*> commands; + + for (i = wholeSegment->getSegmentEvents().begin(); + i != wholeSegment->getSegmentEvents().end(); ++i) { + // transpose key + if ((*i)->isa(Rosegarden::Key::EventType)) { + Rosegarden::Key trKey = (Rosegarden::Key (**i)).transpose(semitones, steps); + //commands.push_front + macroCommand->addCommand + (new KeyInsertionCommand + (segment, + (*i)->getAbsoluteTime(), + trKey, + false, + false, + false, + true)); + } + } + std::list<KeyInsertionCommand*>::iterator ci; + //for (ci=commands.begin(); ci!=commands.end(); ci++) + //{ + // commandHistory->addCommand(*ci); + //} + + KeyInsertionCommand *firstKeyCommand = new KeyInsertionCommand + (segment, + segment.getStartTime(), + newInitialKey, + false, + false, + false, + true); + //commandHistory->addCommand(firstKeyCommand); + macroCommand->addCommand(firstKeyCommand); + } + + if (transposeSegmentBack) + { + // Transpose segment in opposite direction + int newTranspose = segment.getTranspose() - semitones; + macroCommand->addCommand(new SegmentChangeTransposeCommand(newTranspose, &segment)); + } +} + + +SegmentTransposeCommand::~SegmentTransposeCommand() +{} + + +} diff --git a/src/commands/segment/SegmentTransposeCommand.h b/src/commands/segment/SegmentTransposeCommand.h new file mode 100644 index 0000000..74af8d4 --- /dev/null +++ b/src/commands/segment/SegmentTransposeCommand.h @@ -0,0 +1,64 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SEGMENTTRANSPOSECOMMAND_H_ +#define _RG_SEGMENTTRANSPOSECOMMAND_H_ + +#include <kcommand.h> +#include "base/Event.h" +#include "document/MultiViewCommandHistory.h" +#include <klocale.h> + +namespace Rosegarden +{ + +class Segment; +class SegmentSelection; + + +class SegmentTransposeCommand : public KMacroCommand +{ +public: + SegmentTransposeCommand(Segment &segment, + bool changeKey, int steps, int semitones, bool transposeSegmentBack); + + SegmentTransposeCommand(SegmentSelection selection, + bool changeKey, int steps, int semitones, bool transposeSegmentBack); + + virtual ~SegmentTransposeCommand(); + + static QString getGlobalName(int semitones = 0, int step = 0) { + switch (semitones) { + default: return i18n("Transpose by &Interval..."); + } + } + +protected: + void processSegment(Segment &segment, bool changeKey, int steps, int semitones, bool transposeSegmentBack); +}; + +} + +#endif diff --git a/src/commands/segment/SetTriggerSegmentBasePitchCommand.cpp b/src/commands/segment/SetTriggerSegmentBasePitchCommand.cpp new file mode 100644 index 0000000..9bb1bc3 --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentBasePitchCommand.cpp @@ -0,0 +1,74 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SetTriggerSegmentBasePitchCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/TriggerSegment.h" + + +namespace Rosegarden +{ + +SetTriggerSegmentBasePitchCommand::SetTriggerSegmentBasePitchCommand(Composition *composition, + TriggerSegmentId id, + int newPitch) : + KNamedCommand(i18n("Set Base Pitch")), + m_composition(composition), + m_id(id), + m_newPitch(newPitch), + m_oldPitch( -1) +{ + // nothing +} + +SetTriggerSegmentBasePitchCommand::~SetTriggerSegmentBasePitchCommand() +{ + // nothing +} + +void +SetTriggerSegmentBasePitchCommand::execute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + if (m_oldPitch == -1) { + m_oldPitch = rec->getBasePitch(); + } + rec->setBasePitch(m_newPitch); +} + +void +SetTriggerSegmentBasePitchCommand::unexecute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + rec->setBasePitch(m_oldPitch); +} + +} diff --git a/src/commands/segment/SetTriggerSegmentBasePitchCommand.h b/src/commands/segment/SetTriggerSegmentBasePitchCommand.h new file mode 100644 index 0000000..0d79c7c --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentBasePitchCommand.h @@ -0,0 +1,63 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SETTRIGGERSEGMENTBASEPITCHCOMMAND_H_ +#define _RG_SETTRIGGERSEGMENTBASEPITCHCOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class SetTriggerSegmentBasePitchCommand : public KNamedCommand +{ +public: + SetTriggerSegmentBasePitchCommand(Composition *composition, + TriggerSegmentId id, + int newPitch); + virtual ~SetTriggerSegmentBasePitchCommand(); + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + TriggerSegmentId m_id; + int m_newPitch; + int m_oldPitch; +}; + + + +} + +#endif diff --git a/src/commands/segment/SetTriggerSegmentBaseVelocityCommand.cpp b/src/commands/segment/SetTriggerSegmentBaseVelocityCommand.cpp new file mode 100644 index 0000000..f1bba10 --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentBaseVelocityCommand.cpp @@ -0,0 +1,74 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SetTriggerSegmentBaseVelocityCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/TriggerSegment.h" + + +namespace Rosegarden +{ + +SetTriggerSegmentBaseVelocityCommand::SetTriggerSegmentBaseVelocityCommand(Composition *composition, + TriggerSegmentId id, + int newVelocity) : + KNamedCommand(i18n("Set Base Velocity")), + m_composition(composition), + m_id(id), + m_newVelocity(newVelocity), + m_oldVelocity( -1) +{ + // nothing +} + +SetTriggerSegmentBaseVelocityCommand::~SetTriggerSegmentBaseVelocityCommand() +{ + // nothing +} + +void +SetTriggerSegmentBaseVelocityCommand::execute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + if (m_oldVelocity == -1) { + m_oldVelocity = rec->getBaseVelocity(); + } + rec->setBaseVelocity(m_newVelocity); +} + +void +SetTriggerSegmentBaseVelocityCommand::unexecute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + rec->setBaseVelocity(m_oldVelocity); +} + +} diff --git a/src/commands/segment/SetTriggerSegmentBaseVelocityCommand.h b/src/commands/segment/SetTriggerSegmentBaseVelocityCommand.h new file mode 100644 index 0000000..26875ec --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentBaseVelocityCommand.h @@ -0,0 +1,63 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SETTRIGGERSEGMENTBASEVELOCITYCOMMAND_H_ +#define _RG_SETTRIGGERSEGMENTBASEVELOCITYCOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class SetTriggerSegmentBaseVelocityCommand : public KNamedCommand +{ +public: + SetTriggerSegmentBaseVelocityCommand(Composition *composition, + TriggerSegmentId id, + int newVelocity); + virtual ~SetTriggerSegmentBaseVelocityCommand(); + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + TriggerSegmentId m_id; + int m_newVelocity; + int m_oldVelocity; +}; + + + +} + +#endif diff --git a/src/commands/segment/SetTriggerSegmentDefaultRetuneCommand.cpp b/src/commands/segment/SetTriggerSegmentDefaultRetuneCommand.cpp new file mode 100644 index 0000000..35ae878 --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentDefaultRetuneCommand.cpp @@ -0,0 +1,75 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SetTriggerSegmentDefaultRetuneCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/TriggerSegment.h" + + +namespace Rosegarden +{ + +SetTriggerSegmentDefaultRetuneCommand::SetTriggerSegmentDefaultRetuneCommand(Composition *composition, + TriggerSegmentId id, + bool newDefaultRetune) : + KNamedCommand(i18n("Set Default Retune")), + m_composition(composition), + m_id(id), + m_newDefaultRetune(newDefaultRetune), + m_oldDefaultRetune(false), + m_haveOldDefaultRetune(false) +{ + // nothing +} + +SetTriggerSegmentDefaultRetuneCommand::~SetTriggerSegmentDefaultRetuneCommand() +{ + // nothing +} + +void +SetTriggerSegmentDefaultRetuneCommand::execute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + if (!m_haveOldDefaultRetune) { + m_oldDefaultRetune = rec->getDefaultRetune(); + } + rec->setDefaultRetune(m_newDefaultRetune); +} + +void +SetTriggerSegmentDefaultRetuneCommand::unexecute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + rec->setDefaultRetune(m_oldDefaultRetune); +} + +} diff --git a/src/commands/segment/SetTriggerSegmentDefaultRetuneCommand.h b/src/commands/segment/SetTriggerSegmentDefaultRetuneCommand.h new file mode 100644 index 0000000..4563594 --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentDefaultRetuneCommand.h @@ -0,0 +1,64 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SETTRIGGERSEGMENTDEFAULTRETUNECOMMAND_H_ +#define _RG_SETTRIGGERSEGMENTDEFAULTRETUNECOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class SetTriggerSegmentDefaultRetuneCommand : public KNamedCommand +{ +public: + SetTriggerSegmentDefaultRetuneCommand(Composition *composition, + TriggerSegmentId id, + bool newDefaultRetune); + virtual ~SetTriggerSegmentDefaultRetuneCommand(); + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + TriggerSegmentId m_id; + bool m_newDefaultRetune; + bool m_oldDefaultRetune; + bool m_haveOldDefaultRetune; +}; + + + +} + +#endif diff --git a/src/commands/segment/SetTriggerSegmentDefaultTimeAdjustCommand.cpp b/src/commands/segment/SetTriggerSegmentDefaultTimeAdjustCommand.cpp new file mode 100644 index 0000000..deb49a1 --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentDefaultTimeAdjustCommand.cpp @@ -0,0 +1,74 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + + +#include "SetTriggerSegmentDefaultTimeAdjustCommand.h" + +#include <klocale.h> +#include "base/Composition.h" +#include "base/TriggerSegment.h" + + +namespace Rosegarden +{ + +SetTriggerSegmentDefaultTimeAdjustCommand::SetTriggerSegmentDefaultTimeAdjustCommand(Composition *composition, + TriggerSegmentId id, + std::string newDefaultTimeAdjust) : + KNamedCommand(i18n("Set Default Time Adjust")), + m_composition(composition), + m_id(id), + m_newDefaultTimeAdjust(newDefaultTimeAdjust), + m_oldDefaultTimeAdjust("") +{ + // nothing +} + +SetTriggerSegmentDefaultTimeAdjustCommand::~SetTriggerSegmentDefaultTimeAdjustCommand() +{ + // nothing +} + +void +SetTriggerSegmentDefaultTimeAdjustCommand::execute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + if (m_oldDefaultTimeAdjust == "") { + m_oldDefaultTimeAdjust = rec->getDefaultTimeAdjust(); + } + rec->setDefaultTimeAdjust(m_newDefaultTimeAdjust); +} + +void +SetTriggerSegmentDefaultTimeAdjustCommand::unexecute() +{ + TriggerSegmentRec *rec = m_composition->getTriggerSegmentRec(m_id); + if (!rec) + return ; + rec->setDefaultTimeAdjust(m_oldDefaultTimeAdjust); +} + +} diff --git a/src/commands/segment/SetTriggerSegmentDefaultTimeAdjustCommand.h b/src/commands/segment/SetTriggerSegmentDefaultTimeAdjustCommand.h new file mode 100644 index 0000000..7d31b26 --- /dev/null +++ b/src/commands/segment/SetTriggerSegmentDefaultTimeAdjustCommand.h @@ -0,0 +1,64 @@ + +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Rosegarden + A MIDI and audio sequencer and musical notation editor. + + This program is Copyright 2000-2008 + Guillaume Laurent <[email protected]>, + Chris Cannam <[email protected]>, + Richard Bown <[email protected]> + + The moral rights of Guillaume Laurent, Chris Cannam, and Richard + Bown to claim authorship of this work have been asserted. + + Other copyrights also apply to some parts of this work. Please + see the AUTHORS file and individual file headers for details. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef _RG_SETTRIGGERSEGMENTDEFAULTTIMEADJUSTCOMMAND_H_ +#define _RG_SETTRIGGERSEGMENTDEFAULTTIMEADJUSTCOMMAND_H_ + +#include "base/TriggerSegment.h" +#include <string> +#include <kcommand.h> + + + + +namespace Rosegarden +{ + +class Composition; + + +class SetTriggerSegmentDefaultTimeAdjustCommand : public KNamedCommand +{ +public: + SetTriggerSegmentDefaultTimeAdjustCommand(Composition *composition, + TriggerSegmentId id, + std::string newDefaultTimeAdjust); + virtual ~SetTriggerSegmentDefaultTimeAdjustCommand(); + + virtual void execute(); + virtual void unexecute(); + +protected: + Composition *m_composition; + TriggerSegmentId m_id; + std::string m_newDefaultTimeAdjust; + std::string m_oldDefaultTimeAdjust; +}; + + + +} + +#endif |