#include <SignalManager.h>

Inheritance diagram for Kwave::SignalManager:

Collaboration diagram for Kwave::SignalManager:

Public Slots
void	undo ()

void	redo ()

Signals
void	sigSelectionChanged (sample_index_t offset, sample_index_t length)

void	sigTrackInserted (unsigned int index, Kwave::Track *track)

void	sigTrackDeleted (unsigned int index, Kwave::Track *track)

void	sigTrackSelectionChanged (bool enabled)

void	sigSamplesInserted (unsigned int track, sample_index_t offset, sample_index_t length)

void	sigSamplesDeleted (unsigned int track, sample_index_t offset, sample_index_t length)

void	sigSamplesModified (unsigned int track, sample_index_t offset, sample_index_t length)

void	sigMetaDataChanged (Kwave::MetaDataList meta)

void	sigUndoRedoInfo (const QString &undo, const QString &redo)

void	sigModified ()

Public Member Functions
	SignalManager (QWidget *parent)

virtual	~SignalManager ()

int	loadFile (const QUrl &url)

void	newSignal (sample_index_t samples, double rate, unsigned int bits, unsigned int tracks)

void	close ()

bool	isClosed ()

bool	isEmpty ()

bool	isModified ()

Kwave::PlaybackController &	playbackController ()

int	executeCommand (const QString &command)

QString	signalName ()

unsigned int	bits () const

double	rate () const

unsigned int	tracks ()

sample_index_t	length ()

Kwave::Selection &	selection ()

bool	trackSelected (unsigned int track)

const QList< unsigned int >	selectedTracks ()

const QList< unsigned int >	allTracks ()

int	save (const QUrl &url, bool selection)

bool	deleteRange (sample_index_t offset, sample_index_t length, const QList< unsigned int > &track_list)

bool	deleteRange (sample_index_t offset, sample_index_t length)

bool	insertSpace (sample_index_t offset, sample_index_t length, const QList< unsigned int > &track_list)

void	selectRange (sample_index_t offset, sample_index_t length)

void	appendTrack ()

void	insertTrack (unsigned int index)

void	deleteTrack (unsigned int index)

void	selectTracks (QList< unsigned int > &track_list)

void	selectTrack (unsigned int track, bool select)

Kwave::Writer *	openWriter (Kwave::InsertMode mode, unsigned int track, sample_index_t left=0, sample_index_t right=0)

Kwave::SampleReader *	openReader (Kwave::ReaderMode mode, unsigned int track, sample_index_t left=0, sample_index_t right=SAMPLE_INDEX_MAX)

QList< Kwave::Stripe::List >	stripes (const QList< unsigned int > &track_list, sample_index_t left=0, sample_index_t right=SAMPLE_INDEX_MAX)

bool	mergeStripes (const QList< Kwave::Stripe::List > &stripes, const QList< unsigned int > &track_list)

Kwave::UndoManager &	undoManager ()

bool	undoEnabled () const

bool	canUndo () const

bool	canRedo () const

void	enableUndo ()

void	disableUndo ()

void	setFileInfo (const Kwave::FileInfo &new_info, bool with_undo)

Kwave::Label	addLabel (sample_index_t pos, const QString &name)

void	deleteLabel (int index, bool with_undo)

bool	modifyLabel (int index, sample_index_t pos, const QString &name, bool with_undo)

int	labelIndex (const Kwave::Label &label) const

Kwave::Label	findLabel (sample_index_t pos)

Kwave::MetaDataList &	metaData ()

const Kwave::MetaDataList &	metaData () const

void	mergeMetaData (const Kwave::MetaDataList &meta_data)

QUuid	uuidOfTrack (unsigned int track)

void	setParentWidget (QWidget *new_parent)

Protected Member Functions
void	deleteRange (unsigned int track, sample_index_t offset, sample_index_t length)

bool	registerUndoAction (Kwave::UndoAction *action)

bool	saveUndoDelete (QList< unsigned int > &track_list, sample_index_t offset, sample_index_t length)

void	abortUndoTransaction ()

void	startUndoTransaction (const QString &name=QString())

void	flushUndoBuffers ()

void	flushRedoBuffer ()

void	setModified (bool mod)

QWidget *	parentWidget () const

Private Slots
void	slotTrackInserted (unsigned int index, Kwave::Track *track)

void	slotTrackDeleted (unsigned int index, Kwave::Track *track)

void	slotSamplesInserted (unsigned int track, sample_index_t offset, sample_index_t length)

void	slotSamplesDeleted (unsigned int track, sample_index_t offset, sample_index_t length)

void	slotSamplesModified (unsigned int track, sample_index_t offset, sample_index_t length)

void	closeUndoTransaction ()

void	emitUndoRedoInfo ()

Private Member Functions
bool	continueWithoutUndo ()

qint64	usedUndoRedoMemory ()

void	freeUndoMemory (qint64 needed)

void	enableModifiedChange (bool en)

void	rememberCurrentSelection ()

void	checkSelectionChange ()

Private Attributes
QWidget *	m_parent_widget

bool	m_closed

bool	m_empty

bool	m_modified

bool	m_modified_enabled

Kwave::Signal	m_signal

Kwave::Selection	m_selection

Kwave::Selection	m_last_selection

QList< unsigned int >	m_last_track_selection

sample_index_t	m_last_length

Kwave::PlaybackController	m_playback_controller

bool	m_undo_enabled

QList< Kwave::UndoTransaction * >	m_undo_buffer

QList< Kwave::UndoTransaction * >	m_redo_buffer

Kwave::UndoTransaction *	m_undo_transaction

unsigned int	m_undo_transaction_level

QMutex	m_undo_transaction_lock

Kwave::UndoManager	m_undo_manager

Kwave::MetaDataList	m_meta_data

Friends
class	Kwave::UndoInsertAction

class	MultiTrackWriter

class	PlaybackController

class	PluginManager

class	MainWidget

class	UndoTransactionGuard

Detailed Description

The SignalManager class manages multi channel signals.

Definition at line 64 of file SignalManager.h.

Constructor & Destructor Documentation

◆ SignalManager()

Kwave::SignalManager::SignalManager ( QWidget * parent )

explicit

Default constructor.

Definition at line 72 of file SignalManager.cpp.

References Kwave::connect(), m_signal, sigSamplesDeleted(), sigSamplesInserted(), sigSamplesModified(), sigTrackDeleted(), sigTrackInserted(), sigTrackSelectionChanged(), slotSamplesDeleted(), slotSamplesInserted(), slotSamplesModified(), slotTrackDeleted(), and slotTrackInserted().

     :QObject(),
     m_parent_widget(parent),
     m_closed(true),
     m_empty(true),
     m_modified(false),
     m_modified_enabled(true),
     m_signal(),
     m_selection(0,0),
     m_last_selection(0,0),
     m_last_track_selection(),
     m_last_length(0),
     m_playback_controller(*this),
     m_undo_enabled(false),
     m_undo_buffer(),
     m_redo_buffer(),
     m_undo_transaction(Q_NULLPTR),
     m_undo_transaction_level(0),
     m_undo_transaction_lock(QMutex::Recursive),
     m_meta_data()
 {
     // connect to the track's signals
     Kwave::Signal *sig = &m_signal;
     connect(sig, SIGNAL(sigTrackInserted(uint,Kwave::Track*)),
             this, SLOT(slotTrackInserted(uint,Kwave::Track*)));
     connect(sig, SIGNAL(sigTrackDeleted(uint,Kwave::Track*)),
             this, SLOT(slotTrackDeleted(uint,Kwave::Track*)));
     connect(sig, SIGNAL(sigTrackSelectionChanged(bool)),
             this,SIGNAL(sigTrackSelectionChanged(bool)));
     connect(sig, SIGNAL(sigSamplesDeleted(unsigned int, sample_index_t,
             sample_index_t)),
             this, SLOT(slotSamplesDeleted(unsigned int, sample_index_t,
             sample_index_t)));
     connect(sig, SIGNAL(sigSamplesInserted(unsigned int, sample_index_t,
             sample_index_t)),
             this, SLOT(slotSamplesInserted(unsigned int, sample_index_t,
             sample_index_t)));
     connect(sig, SIGNAL(sigSamplesModified(unsigned int, sample_index_t,
             sample_index_t)),
             this, SLOT(slotSamplesModified(unsigned int, sample_index_t,
             sample_index_t)));
 }

Here is the call graph for this function:

◆ ~SignalManager()

Kwave::SignalManager::~SignalManager ( )

virtual

Default destructor

Definition at line 116 of file SignalManager.cpp.

References close().

 {
     close();
 }

Here is the call graph for this function:

Member Function Documentation

◆ abortUndoTransaction()

void Kwave::SignalManager::abortUndoTransaction ( )

protected

Aborts an undo transaction by deleting all of it's undo actions.

Definition at line 1361 of file SignalManager.cpp.

References Kwave::UndoTransaction::abort(), and m_undo_transaction.

Referenced by Kwave::UndoTransactionGuard::abort(), Kwave::MainWidget::addLabel(), continueWithoutUndo(), deleteLabel(), deleteRange(), and Kwave::MainWidget::labelProperties().

 {
     // abort the current transaction
     if (m_undo_transaction) m_undo_transaction->abort();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addLabel()

Kwave::Label Kwave::SignalManager::addLabel	(	sample_index_t	pos,
		const QString &	name
	)

add a new label, without undo

Parameters

pos	position of the label [samples]
name	the name of the label

Returns: a newly created label instance

Definition at line 1878 of file SignalManager.cpp.

References Kwave::MetaDataList::add(), findLabel(), m_meta_data, m_undo_enabled, registerUndoAction(), setModified(), sigMetaDataChanged(), and undo().

Referenced by Kwave::MainWidget::addLabel(), Kwave::MainWidget::executeCommand(), and Kwave::DebugPlugin::run().

 {
     // if there already is a label at the given position, do nothing
     if (!findLabel(pos).isNull()) return Kwave::Label();
 
     // create a new label
     Kwave::Label label(pos, name);
 
     // register the undo action
     if (m_undo_enabled) {
         Kwave::UndoTransactionGuard undo(*this, i18n("Add Label"));
         if (!registerUndoAction(new(std::nothrow) UndoAddMetaDataAction(
                 Kwave::MetaDataList(label))))
             return Kwave::Label();
     }
 
     // put the label into the list
     m_meta_data.add(label);
 
     // register this as a modification
     setModified(true);
 
     emit sigMetaDataChanged(m_meta_data);
 
     return label;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allTracks()

const QList< unsigned int > Kwave::SignalManager::allTracks ( )

Returns an array of indices of all present tracks.

Definition at line 601 of file SignalManager.cpp.

References Kwave::Signal::allTracks(), and m_signal.

Referenced by Kwave::MimeData::decode(), executeCommand(), Kwave::OverViewCache::getMinMax(), loadFile(), Kwave::SonagramPlugin::makeAllValid(), Kwave::SampleRatePlugin::run(), Kwave::DebugPlugin::run(), Kwave::PlaybackController::run_wrapper(), and save().

 {
     return m_signal.allTracks();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ appendTrack()

void Kwave::SignalManager::appendTrack ( )

Inserts a new track with the size of the current signal after the last track. The same as insertTrack(tracks()).

Definition at line 902 of file SignalManager.cpp.

References insertTrack(), tracks(), and undo().

Referenced by executeCommand(), and Kwave::DebugPlugin::run().

 {
     Kwave::UndoTransactionGuard undo(*this, i18n("Append Track"));
     insertTrack(tracks());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bits()

unsigned int Kwave::SignalManager::bits ( ) const

inline

Returns the current sample resolution in bits per sample

Definition at line 126 of file SignalManager.h.

References Kwave::FileInfo::bits().

Referenced by save(), Kwave::SelectionItem::startDragging(), and Kwave::RecordPlugin::startRecording().

                                          {
             return Kwave::FileInfo(m_meta_data).bits();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ canRedo()

bool Kwave::SignalManager::canRedo ( ) const

inline

Return true if redo is possible

Definition at line 317 of file SignalManager.h.

References name.

Referenced by Kwave::SignalWidget::contextMenuEvent().

                                     {
             return !m_redo_buffer.isEmpty() && undoEnabled();
         }

Here is the caller graph for this function:

◆ canUndo()

bool Kwave::SignalManager::canUndo ( ) const

inline

Return true if undo is possible

Definition at line 312 of file SignalManager.h.

Referenced by Kwave::SignalWidget::contextMenuEvent().

                                     {
             return !m_undo_buffer.isEmpty() && undoEnabled();
         }

Here is the caller graph for this function:

◆ checkSelectionChange()

void Kwave::SignalManager::checkSelectionChange ( )

private

Check whether the selection has changed since the start of the last undo and create a new undo action if the selection has been modified (e.g. manually)

Definition at line 2006 of file SignalManager.cpp.

References m_last_selection, m_last_track_selection, m_selection, m_undo_transaction_level, selectedTracks(), selectTracks(), tracks(), and undo().

Referenced by redo(), startUndoTransaction(), and undo().

 {
     if (m_undo_transaction_level) return;
 
     // detect sample selection change
     bool range_modified = !(m_selection == m_last_selection);
 
     // detect track selection change
     QList<unsigned int> tracks = selectedTracks();
     bool tracks_modified = !(tracks == m_last_track_selection);
 
     if (range_modified || tracks_modified) {
         // selection has changed since last undo/redo operation
 //      qDebug("SignalManager::checkSelectionChange() => manually modified");
 //      qDebug("    before: [%8u...%8u]", m_last_selection.first(), m_last_selection.last());
 //      qDebug("    after : [%8u...%8u]", m_selection.first(),      m_selection.last());
 
         // temporarily activate the previous selection (last stored)
         Kwave::Selection new_selection(m_selection);
         m_selection = m_last_selection;
         selectTracks(m_last_track_selection);
 
         // save the last selection into a undo action
         if (tracks_modified && !range_modified)
             Kwave::UndoTransactionGuard undo(*this,
                                              i18n("Manual Track Selection"));
         else
             Kwave::UndoTransactionGuard undo(*this,
                                              i18n("Manual Selection"));
 
         // restore the current selection again
         m_selection = new_selection;
         selectTracks(tracks);
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close()

void Kwave::SignalManager::close ( )

Closes the current signal.

Definition at line 533 of file SignalManager.cpp.

References Kwave::Selection::clear(), Kwave::Signal::close(), deleteTrack(), disableUndo(), enableModifiedChange(), flushRedoBuffer(), flushUndoBuffers(), m_closed, m_empty, m_last_length, m_meta_data, m_playback_controller, m_selection, m_signal, Kwave::PlaybackController::playbackStop(), rememberCurrentSelection(), Kwave::PlaybackController::reset(), setModified(), sigMetaDataChanged(), and tracks().

Referenced by loadFile(), and ~SignalManager().

 {
     // stop the playback
     m_playback_controller.playbackStop();
     m_playback_controller.reset();
 
     // fix the modified flag to false
     enableModifiedChange(true);
     setModified(false);
     enableModifiedChange(false);
 
     // reset the last length of the signal
     m_last_length = 0;
 
     // disable undo and discard all undo buffers
     // undo will be re-enabled when a signal is loaded or created
     disableUndo();
 
     // for safety: flush all undo/redo buffers
     flushUndoBuffers();
     flushRedoBuffer();
 
     // reset the selection
     m_selection.clear();
 
     m_empty = true;
     while (tracks()) deleteTrack(tracks() - 1);
     m_signal.close();
 
     // clear all meta data
     m_meta_data.clear();
 
     m_closed = true;
     rememberCurrentSelection();
 
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeUndoTransaction

void Kwave::SignalManager::closeUndoTransaction ( )

privateslot

Closes an undo transaction or recurses the current recursion level of nested undo transactions.

Definition at line 1264 of file SignalManager.cpp.

References emitUndoRedoInfo(), Kwave::UndoTransaction::isAborted(), m_undo_buffer, m_undo_transaction, m_undo_transaction_level, m_undo_transaction_lock, rememberCurrentSelection(), and Kwave::UndoAction::undo().

Referenced by deleteLabel(), and Kwave::UndoTransactionGuard::~UndoTransactionGuard().

 {
     QMutexLocker lock(&m_undo_transaction_lock);
 
     // decrease recursion level
     if (!m_undo_transaction_level) return; // undo was not enabled ?
     m_undo_transaction_level--;
 
     if (!m_undo_transaction_level) {
         // append the current transaction to the undo buffer if
         // not empty
         if (m_undo_transaction) {
             if (!m_undo_transaction->isEmpty()) {
                 // if the transaction has been aborted, undo all actions
                 // that have currently been queued but do not
                 // use the transaction any more, instead delete it.
                 if (m_undo_transaction->isAborted()) {
                     qDebug("SignalManager::closeUndoTransaction(): aborted");
                     while (!m_undo_transaction->isEmpty()) {
                         UndoAction *undo_action;
                         UndoAction *redo_action;
 
                         // unqueue the undo action
                         undo_action = m_undo_transaction->takeLast();
                         Q_ASSERT(undo_action);
                         if (!undo_action) continue;
 
                         // execute the undo operation
                         redo_action = undo_action->undo(*this, false);
 
                         // remove the old undo action if no longer used
                         if (redo_action && (redo_action != undo_action))
                             delete redo_action;
                         delete undo_action;
                     }
                     delete m_undo_transaction;
                     m_undo_transaction = Q_NULLPTR;
                 } else {
                     m_undo_buffer.append(m_undo_transaction);
                 }
             } else {
                 qDebug("SignalManager::closeUndoTransaction(): empty");
                 delete m_undo_transaction;
                 m_undo_transaction = Q_NULLPTR;
             }
         }
 
         // dump, for debugging
 //      if (m_undo_transaction)
 //          m_undo_transaction->dump("closed undo transaction: ");
 
         // declare the current transaction as "closed"
         rememberCurrentSelection();
         m_undo_transaction = Q_NULLPTR;
         emitUndoRedoInfo();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ continueWithoutUndo()

bool Kwave::SignalManager::continueWithoutUndo ( )

private

Ask the user if he wants to continue without undo, maybe registering an undo action has failed due to out-of-memory.

Returns: true if it is ok, false if the user doesn't want to.

Definition at line 1376 of file SignalManager.cpp.

References _, abortUndoTransaction(), enableModifiedChange(), flushUndoBuffers(), Kwave::UndoTransaction::isAborted(), m_parent_widget, m_undo_transaction, setModified(), and Kwave::MessageBox::warningContinueCancel().

Referenced by registerUndoAction().

 {
     // undo has not been enabled before?
     if (!m_undo_transaction) return true;
 
     // transaction has been aborted before
     if (m_undo_transaction->isAborted()) return false;
 
     // transaction is empty -> must have been flushed before, otherwise
     // it would contain at least a undo action for the selection
     // => user already has pressed "continue"
     if (m_undo_transaction->isEmpty()) return true;
 
     if (Kwave::MessageBox::warningContinueCancel(m_parent_widget,
         _("<html>") +
         i18n("Not enough memory for saving undo information.") +
         _("<br><br><b>") +
         i18n("Do you want to continue without the possibility to undo?") +
         _("</b><br><br><i>") +
         i18n("<b>Hint</b>: you can configure the amount of memory<br>"
              "available for undo under '%1'/'%2'.",
              i18n("Settings"),
              i18n("Memory") +
         _("</i></html>"))) == KMessageBox::Continue)
     {
         // the signal was modified, it will stay in this state, it is
         // not possible to change to "non-modified" state through undo
         // from now on...
         setModified(true);
         enableModifiedChange(false);
 
         // flush the current undo transaction
         while (!m_undo_transaction->isEmpty()) {
             Kwave::UndoAction *undo_action = m_undo_transaction->takeLast();
             if (undo_action) delete undo_action;
         }
 
         // flush all undo/redo buffers
         flushUndoBuffers();
         return true;
     }
 
     // Set the undo transaction into "aborted" state. The final
     // closeUndoTransaction() will take care of the rest when
     // detecting that state and clean up...
     abortUndoTransaction();
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deleteLabel()

void Kwave::SignalManager::deleteLabel	(	int	index,
		bool	with_undo
	)

delete an existing label

Parameters

index	the index of the label [0...N-1]
with_undo	if true, create undo info

Definition at line 1907 of file SignalManager.cpp.

References abortUndoTransaction(), closeUndoTransaction(), m_meta_data, registerUndoAction(), Kwave::MetaDataList::remove(), setModified(), sigMetaDataChanged(), startUndoTransaction(), and Kwave::toInt().

Referenced by Kwave::MainWidget::addLabel(), executeCommand(), and Kwave::MainWidget::labelProperties().

 {
     Kwave::LabelList labels(m_meta_data);
     int count = Kwave::toInt(labels.count());
     if (!count) return;
 
     if (index == -1) {
         // special handling for index == -1 -> delete all labels
 
         if (with_undo) startUndoTransaction(i18n("Delete All Labels"));
 
         for (index = count - 1; index >= 0; --index) {
             Kwave::MetaData label(labels.at(index));
             if (with_undo) {
                 if (!registerUndoAction(new(std::nothrow)
                     UndoDeleteMetaDataAction(Kwave::MetaDataList(label))))
                     break;
             }
             m_meta_data.remove(label);
         }
     } else {
         // delete a single label
         if ((index < 0) || (index >= count)) return;
 
         Kwave::MetaData label(labels.at(index));
 
         // register the undo action
         if (with_undo) {
             startUndoTransaction(i18n("Delete Label"));
             if (!registerUndoAction(new(std::nothrow)
                 UndoDeleteMetaDataAction(Kwave::MetaDataList(label)))) {
                 abortUndoTransaction();
                 return;
             }
         }
 
         m_meta_data.remove(label);
     }
 
     if (with_undo) closeUndoTransaction();
 
     // register this as a modification
     setModified(true);
 
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deleteRange() [1/3]

bool Kwave::SignalManager::deleteRange	(	sample_index_t	offset,
		sample_index_t	length,
		const QList< unsigned int > &	track_list
	)

Deletes a range of samples and creates an undo action.

Parameters

offset	index of the first sample
length	number of samples
track_list	a list of tracks to be affected

Returns: true if successful or nothing to do, false if not enough memory for undo

Definition at line 1064 of file SignalManager.cpp.

References abortUndoTransaction(), Kwave::MetaDataList::copy(), Kwave::Signal::deleteRange(), Kwave::MetaDataList::deleteRange(), m_meta_data, m_parent_widget, m_signal, m_undo_enabled, registerUndoAction(), and sigMetaDataChanged().

Referenced by deleteRange(), executeCommand(), Kwave::ClipBoard::paste(), Kwave::SampleRatePlugin::run(), Kwave::SelectionItem::startDragging(), and Kwave::UndoInsertAction::undo().

 {
     if (!length || track_list.isEmpty()) return true; // nothing to do
 
     // put the selected meta data into a undo action
     if (m_undo_enabled) {
         if (!registerUndoAction(new(std::nothrow) UndoDeleteMetaDataAction(
             m_meta_data.copy(offset, length, track_list))))
         {
             abortUndoTransaction();
             return false;
         }
         m_meta_data.deleteRange(offset, length, track_list);
 
         // store undo data for all audio data (without meta data)
         if (!registerUndoAction(new(std::nothrow) UndoDeleteAction(
             m_parent_widget, track_list, offset, length)))
         {
             abortUndoTransaction();
             return false;
         }
     } else {
         // delete without undo
         m_meta_data.deleteRange(offset, length, track_list);
     }
 
     // delete the ranges in all tracks
     // (this makes all metadata positions after the selected range invalid)
     foreach (unsigned int track, track_list) {
         m_signal.deleteRange(track, offset, length);
     }
 
     emit sigMetaDataChanged(m_meta_data);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deleteRange() [2/3]

bool Kwave::SignalManager::deleteRange	(	sample_index_t	offset,
		sample_index_t	length
	)

Deletes a range of samples and creates an undo action. Same as above, but affects all tracks.

Parameters

offset	index of the first sample
length	number of samples

Returns: true if successful or nothing to do, false if not enough memory for undo

Definition at line 1103 of file SignalManager.cpp.

References deleteRange(), and selectedTracks().

 {
     return deleteRange(offset, length, selectedTracks());
 }

Here is the call graph for this function:

◆ deleteRange() [3/3]

void Kwave::SignalManager::deleteRange	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

inlineprotected

Deletes a range of samples.

Note: only for internal usage in the UndoInsertAction!

Parameters

track	index of the track
offset	index of the first sample
length	number of samples

See also: Signal::deleteRange

Definition at line 591 of file SignalManager.h.

         {
             m_signal.deleteRange(track, offset, length);
         }

◆ deleteTrack()

void Kwave::SignalManager::deleteTrack ( unsigned int index )

Deletes a track from the current signal, including generation of an undo action.

Parameters

index the index of the track to be deleted [0...tracks()-1]

Definition at line 951 of file SignalManager.cpp.

References Kwave::Signal::deleteTrack(), Kwave::MetaDataList::deleteTrack(), m_meta_data, m_signal, m_undo_enabled, registerUndoAction(), Kwave::MetaDataList::selectByTracks(), setModified(), tracks(), and undo().

Referenced by close(), and executeCommand().

 {
     Kwave::UndoTransactionGuard undo(*this, i18n("Delete Track"));
 
     const unsigned int count = tracks();
     Q_ASSERT(index <= count);
     if (index > count) return;
 
     if (m_undo_enabled) {
         // undo action for the track deletion
         if (!registerUndoAction(new(std::nothrow)
             UndoDeleteTrack(m_signal, index)))
                 return;
 
         // undo action for the corresponding meta data change
         QList<unsigned int> tracks;
         for (unsigned int t = index; t < count; t++) tracks.append(t);
         Kwave::MetaDataList list = m_meta_data.selectByTracks(tracks);
         if (!list.isEmpty() && !registerUndoAction(
             new(std::nothrow) Kwave::UndoModifyMetaDataAction(list)))
                 return;
     }
 
     // adjust the track bound meta data
     m_meta_data.deleteTrack(index);
 
     setModified(true);
     m_signal.deleteTrack(index);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disableUndo()

void Kwave::SignalManager::disableUndo ( )

Disables undo and redo. If undo/redo was enabled, all undo data will be discarded in order to avoid trouble when modifications are done while undo is of.

Note: No modifications should be performed while undo is off!

Definition at line 1330 of file SignalManager.cpp.

References flushUndoBuffers(), m_undo_enabled, and m_undo_transaction_level.

Referenced by close(), loadFile(), newSignal(), and Kwave::RecordPlugin::startRecording().

 {
     if (m_undo_transaction_level)
         qWarning("SignalManager::disableUndo(): undo transaction level=%u",
             m_undo_transaction_level);
 
     flushUndoBuffers();
     m_undo_enabled = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ emitUndoRedoInfo

void Kwave::SignalManager::emitUndoRedoInfo ( )

privateslot

Determines the description of undo and redo actions and emits a sigUndoRedoInfo. If undo or redo is currently not available, the descriptions will be zero-length. If an action is available but does not have a description, the description will be set to "last action".

See also: sigUndoRedoInfo

Definition at line 1532 of file SignalManager.cpp.

References Kwave::UndoTransaction::description(), m_redo_buffer, m_undo_buffer, m_undo_enabled, and sigUndoRedoInfo().

Referenced by closeUndoTransaction(), enableUndo(), flushRedoBuffer(), flushUndoBuffers(), redo(), setFileInfo(), and undo().

 {
     QString undo_name = QString();
     QString redo_name = QString();
 
     if (m_undo_enabled) {
         Kwave::UndoTransaction *transaction;
 
         // get the description of the last undo action
         if (!m_undo_buffer.isEmpty()) {
             transaction = m_undo_buffer.last();
             if (transaction) undo_name = transaction->description();
             if (!undo_name.length()) undo_name = i18n("Last Action");
         }
 
         // get the description of the last redo action
         if (!m_redo_buffer.isEmpty()) {
             transaction = m_redo_buffer.first();
             if (transaction) redo_name = transaction->description();
             if (!redo_name.length()) redo_name = i18n("Last Action");
         }
     }
 
     // now emit the undo/redo transaction names
     emit sigUndoRedoInfo(undo_name, redo_name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enableModifiedChange()

void Kwave::SignalManager::enableModifiedChange ( bool en )

private

Enables changes of the modified flag.

Parameters

en	new value for m_modified_enabled

Definition at line 1829 of file SignalManager.cpp.

References m_modified_enabled.

Referenced by close(), continueWithoutUndo(), flushUndoBuffers(), freeUndoMemory(), loadFile(), newSignal(), and save().

 {
     m_modified_enabled = en;
 }

Here is the caller graph for this function:

◆ enableUndo()

void Kwave::SignalManager::enableUndo ( )

Enables undo and redo. If undo/redo is already enabled, nothing will be done.

Definition at line 1323 of file SignalManager.cpp.

References emitUndoRedoInfo(), and m_undo_enabled.

Referenced by loadFile(), newSignal(), and Kwave::RecordPlugin::setup().

 {
     m_undo_enabled = true;
     emitUndoRedoInfo();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeCommand()

int Kwave::SignalManager::executeCommand ( const QString & command )

Execute a Kwave text command

Parameters

command a text command

Returns: zero if succeeded or negative error code if failed

Return values

-ENOSYS is returned if the command is unknown in this component

Definition at line 607 of file SignalManager.cpp.

References Kwave::FileInfo::allKnownProperties(), allTracks(), appendTrack(), CASE_COMMAND, Kwave::ClipBoard::clear(), Kwave::ClipBoard::copy(), DBG, deleteLabel(), Kwave::Signal::deleteRange(), deleteRange(), deleteTrack(), Kwave::MetaDataList::dump(), Kwave::Selection::first(), Kwave::Parser::firstParam(), insertTrack(), Kwave::ClipBoard::instance(), Kwave::ClipBoard::isEmpty(), Kwave::MetaData::isNull(), Kwave::Selection::last(), Kwave::Selection::length(), length(), m_meta_data, m_parent_widget, m_playback_controller, m_redo_buffer, m_selection, m_signal, m_undo_buffer, m_undo_enabled, Kwave::FileInfo::name(), Kwave::Parser::nextParam(), Kwave::Selection::offset(), Kwave::ClipBoard::paste(), Kwave::PlaybackController::playbackStart(), Kwave::Label::pos(), redo(), rememberCurrentSelection(), Kwave::MetaDataList::replace(), saveUndoDelete(), selectedTracks(), selection(), selectRange(), selectTrack(), Kwave::FileInfo::set(), sigMetaDataChanged(), Kwave::Parser::toInt(), Kwave::Parser::toSampleIndex(), Kwave::Parser::toUInt(), tracks(), trackSelected(), and undo().

Referenced by Kwave::MainWidget::executeCommand().

 {
     sample_index_t offset = m_selection.offset();
     sample_index_t length = m_selection.length();
 
     if (!command.length()) return -EINVAL;
     Kwave::Parser parser(command);
 
     if (false) {
     // --- undo / redo ---
     CASE_COMMAND("undo")
         undo();
     CASE_COMMAND("redo")
         redo();
     CASE_COMMAND("undo_all")
         while (m_undo_enabled && !m_undo_buffer.isEmpty())
             undo();
     CASE_COMMAND("redo_all")
         while (!m_redo_buffer.isEmpty())
             redo();
 
     // --- copy & paste + clipboard ---
     CASE_COMMAND("copy")
         if (length) {
             Kwave::ClipBoard &clip = Kwave::ClipBoard::instance();
             clip.copy(
                 m_parent_widget,
                 *this,
                 selectedTracks(),
                 offset, length
             );
             // remember the last selection
             rememberCurrentSelection();
         }
     CASE_COMMAND("insert_at")
         Kwave::ClipBoard &clip = Kwave::ClipBoard::instance();
         if (clip.isEmpty()) return 0;
         if (!selectedTracks().size()) return 0;
         sample_index_t ofs = parser.toSampleIndex();
 
         Kwave::UndoTransactionGuard undo(*this,
                                          i18n("Insert Clipboard at position"));
 
         selectRange(ofs, 0);
         clip.paste(m_parent_widget, *this, ofs, 0);
 
     CASE_COMMAND("paste")
         Kwave::ClipBoard &clip = Kwave::ClipBoard::instance();
         if (clip.isEmpty()) return 0;
         if (!selectedTracks().size()) return 0;
 
         Kwave::UndoTransactionGuard undo(*this, i18n("Paste"));
         clip.paste(m_parent_widget, *this, offset, length);
     CASE_COMMAND("cut")
         if (length) {
             // remember the last selection
             rememberCurrentSelection();
 
             Kwave::ClipBoard &clip = Kwave::ClipBoard::instance();
             clip.copy(
                 m_parent_widget,
                 *this,
                 selectedTracks(),
                 offset, length
             );
             Kwave::UndoTransactionGuard undo(*this, i18n("Cut"));
             deleteRange(offset, length);
             selectRange(m_selection.offset(), 0);
         }
     CASE_COMMAND("clipboard_flush")
         Kwave::ClipBoard::instance().clear();
     CASE_COMMAND("crop")
         if (length) {
             Kwave::UndoTransactionGuard undo(*this, i18n("Crop"));
             sample_index_t rest = this->length() - offset;
             rest = (rest > length) ? (rest-length) : 0;
             QList<unsigned int> tracks = selectedTracks();
             if (saveUndoDelete(tracks, offset+length, rest) &&
                 saveUndoDelete(tracks, 0, offset))
             {
                 // remember the last selection
                 rememberCurrentSelection();
 
                 unsigned int count = tracks.count();
                 while (count--) {
                     m_signal.deleteRange(count, offset+length, rest);
                     m_signal.deleteRange(count, 0, offset);
                 }
                 selectRange(0, length);
             }
         }
     CASE_COMMAND("delete")
         Kwave::UndoTransactionGuard undo(*this, i18n("Delete"));
         deleteRange(offset, length);
         selectRange(m_selection.offset(), 0);
 
 //    CASE_COMMAND("mixpaste")
 //      if (globals.clipboard) {
 //          SignalManager *toinsert = globals.clipboard->getSignal();
 //          if (toinsert) {
 //              unsigned int clipchan = toinsert->channels();
 //              unsigned int sourcechan = 0;
 //
 //              /* ### check if the signal has to be re-sampled ### */
 //
 //              for (unsigned int i = 0; i < m_channels; i++) {
 //                  Q_ASSERT(signal.at(i));
 //                  if (signal.at(i)) {
 //                      signal.at(i)->mixPaste(
 //                          toinsert->getSignal(sourcechan)
 //                      );
 //                  }
 //                  sourcechan++;
 //                  sourcechan %= clipchan;
 //              }
 //          }
 //      }
 
     CASE_COMMAND("label:delete")
         int index = parser.toInt();
         deleteLabel(index, true);
 
     CASE_COMMAND("expandtolabel")
         Kwave::UndoTransactionGuard undo(*this,
                                          i18n("Expand Selection to Label"));
         sample_index_t selection_left  = m_selection.first();
         sample_index_t selection_right = m_selection.last();
         Kwave::LabelList labels(m_meta_data);
         if (labels.isEmpty()) return false; // we need labels for this
         Kwave::Label label_left  = Kwave::Label();
         Kwave::Label label_right = Kwave::Label();
 
         // the last label <= selection start -> label_left
         // the first label >= selection end  -> label_right
         foreach (const Kwave::Label &label, labels) {
             sample_index_t lp = label.pos();
             if (lp <= selection_left)
                 label_left = label;
             if ((lp >= selection_right) && (label_right.isNull())) {
                 label_right = label;
                 break; // done
             }
         }
         // default left label = start of file
         selection_left = (label_left.isNull()) ? 0 :
             label_left.pos();
         // default right label = end of file
         selection_right = (label_right.isNull()) ?
             (this->length() - 1) : label_right.pos();
         sample_index_t len = selection_right - selection_left + 1;
         selectRange(selection_left, len);
 
     CASE_COMMAND("selectnextlabels")
         Kwave::UndoTransactionGuard undo(*this, i18n("Select Next Labels"));
         sample_index_t selection_left;
         sample_index_t selection_right = m_selection.last();
         Kwave::Label label_left  = Kwave::Label();
         Kwave::Label label_right = Kwave::Label();
         Kwave::LabelList labels(m_meta_data);
         if (labels.isEmpty()) return false; // we need labels for this
 
         // special case: nothing selected -> select up to the first label
         if (selection_right == 0) {
             label_right = labels.first();
             selection_left = 0;
         } else {
             // find the first label starting after the current selection
             LabelListIterator it(labels);
             while (it.hasNext()) {
                 Kwave::Label label = it.next();
                 if (label.pos() >= selection_right) {
                     // take it as selection start
                     label_left  = label;
                     // and it's next one as selection end (might be null)
                     label_right = it.hasNext() ? it.next() : Kwave::Label();
                     break;
                 }
             }
             // default selection start = last label
             if (label_left.isNull()) label_left = labels.last();
             if (label_left.isNull()) return false; // no labels at all !?
             selection_left = label_left.pos();
         }
         // default selection end = end of the file
         selection_right = (label_right.isNull()) ?
             (this->length() - 1) : label_right.pos();
         sample_index_t len = (selection_right > selection_left) ?
             (selection_right - selection_left + 1) : 1;
         selectRange(selection_left, len);
 
     CASE_COMMAND("selectprevlabels")
         Kwave::UndoTransactionGuard undo(*this, i18n("Select Previous Labels"));
         sample_index_t selection_left  = selection().first();
         sample_index_t selection_right = selection().last();
         Kwave::Label label_left  = Kwave::Label();
         Kwave::Label label_right = Kwave::Label();
         Kwave::LabelList labels(m_meta_data);
         if (labels.isEmpty()) return false; // we need labels for this
 
         // find the last label before the start of the selection
         foreach (const Kwave::Label &label, labels) {
             if (label.pos() > selection_left)
                 break; // done
             label_left  = label_right;
             label_right = label;
         }
         // default selection start = start of file
         selection_left = (label_left.isNull()) ? 0 :
             label_left.pos();
         // default selection end = first label
         if (label_right.isNull()) label_right = labels.first();
         if (label_right.isNull()) return false; // no labels at all !?
         selection_right = label_right.pos();
         sample_index_t len = selection_right - selection_left + 1;
         selectRange(selection_left, len);
 
     // --- track related functions ---
     CASE_COMMAND("add_track")
         appendTrack();
     CASE_COMMAND("delete_track")
         Kwave::Parser p(command);
         unsigned int track = p.toUInt();
         if (track >= tracks()) return -EINVAL;
         deleteTrack(track);
     CASE_COMMAND("insert_track")
         Kwave::Parser p(command);
         unsigned int track = p.toUInt();
         insertTrack(track);
 
     // track selection
     CASE_COMMAND("select_track:all")
         Kwave::UndoTransactionGuard undo(*this, i18n("Select All Tracks"));
         foreach (unsigned int track, allTracks())
             selectTrack(track, true);
     CASE_COMMAND("select_track:none")
         Kwave::UndoTransactionGuard undo(*this, i18n("Deselect all tracks"));
         foreach (unsigned int track, allTracks())
             selectTrack(track, false);
     CASE_COMMAND("select_track:invert")
         Kwave::UndoTransactionGuard undo(*this, i18n("Invert Track Selection"));
         foreach (unsigned int track, allTracks())
             selectTrack(track, !trackSelected(track));
     CASE_COMMAND("select_track:on")
         unsigned int track = parser.toUInt();
         if (track >= tracks()) return -EINVAL;
         Kwave::UndoTransactionGuard undo(*this, i18n("Select Track"));
         selectTrack(track, true);
     CASE_COMMAND("select_track:off")
         unsigned int track = parser.toUInt();
         if (track >= tracks()) return -EINVAL;
         Kwave::UndoTransactionGuard undo(*this, i18n("Deselect Track"));
         selectTrack(track, false);
     CASE_COMMAND("select_track:toggle")
         unsigned int track = parser.toUInt();
         if (track >= tracks()) return -EINVAL;
         Kwave::UndoTransactionGuard undo(*this, i18n("Toggle Track Selection"));
         selectTrack(track, !(trackSelected(track)));
 
     // playback control
     CASE_COMMAND("playback_start")
         m_playback_controller.playbackStart();
 
     CASE_COMMAND("fileinfo")
         QString property = parser.firstParam();
         QString value    = parser.nextParam();
         Kwave::FileInfo info(m_meta_data);
         bool found = false;
         foreach (Kwave::FileProperty p, info.allKnownProperties()) {
             if (info.name(p) == property) {
                 if (value.length())
                     info.set(p, QVariant(value)); // add/modify
                 else
                     info.set(p, QVariant());      // delete
                 found = true;
                 break;
             }
         }
 
         if (found) {
             m_meta_data.replace(Kwave::MetaDataList(info));
             // we now have new meta data
             emit sigMetaDataChanged(m_meta_data);
         } else
             return -EINVAL;
     CASE_COMMAND("dump_metadata")
         qDebug("DUMP OF META DATA => %s", DBG(parser.firstParam()));
         m_meta_data.dump();
     } else {
         return -ENOSYS;
     }
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findLabel()

Kwave::Label Kwave::SignalManager::findLabel ( sample_index_t pos )

returns the label at a given exact position

Parameters

pos	position of the label [samples]

Returns: valid label at the position or null label if not found

Definition at line 1856 of file SignalManager.cpp.

References m_meta_data, and Kwave::Label::pos().

Referenced by addLabel(), Kwave::MainWidget::labelProperties(), modifyLabel(), and Kwave::LabelItem::moveTo().

 {
     Kwave::LabelList labels(m_meta_data);
     foreach (const Kwave::Label &label, labels) {
         if (label.pos() == pos) return label; // found it
     }
     return Kwave::Label(); // nothing found
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flushRedoBuffer()

void Kwave::SignalManager::flushRedoBuffer ( )

protected

Removes all redo transactions.

Definition at line 1368 of file SignalManager.cpp.

References emitUndoRedoInfo(), and m_redo_buffer.

Referenced by close(), startUndoTransaction(), and undo().

 {
     qDeleteAll(m_redo_buffer);
     m_redo_buffer.clear();
     emitUndoRedoInfo();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flushUndoBuffers()

void Kwave::SignalManager::flushUndoBuffers ( )

protected

Removes all undo and redo transactions.

Note: must not be called if an undo transaction is currently active!

Definition at line 1341 of file SignalManager.cpp.

References emitUndoRedoInfo(), enableModifiedChange(), m_modified, m_redo_buffer, m_undo_buffer, and m_undo_transaction_lock.

Referenced by close(), continueWithoutUndo(), disableUndo(), and save().

 {
     QMutexLocker lock(&m_undo_transaction_lock);
 
     // if the signal was modified, it will stay in this state, it is
     // not possible to change to "non-modified" state through undo
     if ((!m_undo_buffer.isEmpty()) && (m_modified)) {
         enableModifiedChange(false);
     }
 
     // clear all buffers
     qDeleteAll(m_undo_buffer);
     qDeleteAll(m_redo_buffer);
     m_undo_buffer.clear();
     m_redo_buffer.clear();
 
     emitUndoRedoInfo();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ freeUndoMemory()

void Kwave::SignalManager::freeUndoMemory ( qint64 needed )

private

Makes sure that enough memory for a following undo (or redo) action is available. If necessary, it deletes old undo transactions and if still no enough, it also removes old redo transactions.

Parameters

needed the amount of memory that should be free afterwards

Definition at line 1503 of file SignalManager.cpp.

References enableModifiedChange(), Kwave::MemoryManager::instance(), m_modified, m_redo_buffer, m_undo_buffer, redo(), undo(), Kwave::MemoryManager::undoLimit(), Kwave::UndoTransaction::undoSize(), and usedUndoRedoMemory().

Referenced by redo(), registerUndoAction(), and undo().

 {
     qint64 size = usedUndoRedoMemory() + needed;
     qint64 undo_limit = Kwave::MemoryManager::instance().undoLimit() << 20;
 
     // remove old undo actions if not enough free memory
     while (!m_undo_buffer.isEmpty() && (size > undo_limit)) {
         Kwave::UndoTransaction *undo = m_undo_buffer.takeFirst();
         if (!undo) continue;
         qint64 s = undo->undoSize();
         size = (size >= s) ? (size - s) : 0;
         delete undo;
 
         // if the signal was modified, it will stay in this state, it is
         // not possible to change to "non-modified" state through undo
         if (m_modified) enableModifiedChange(false);
     }
 
     // remove old redo actions if still not enough memory
     while (!m_redo_buffer.isEmpty() && (size > undo_limit)) {
         Kwave::UndoTransaction *redo = m_redo_buffer.takeLast();
         if (!redo) continue;
         qint64 s = redo->undoSize();
         size = (size >= s) ? (size - s) : 0;
         delete redo;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insertSpace()

bool Kwave::SignalManager::insertSpace	(	sample_index_t	offset,
		sample_index_t	length,
		const QList< unsigned int > &	track_list
	)

Inserts space at a given position and creates an undo action.

Parameters

offset	position of the first sample to insert
length	number of samples
track_list	a list of tracks to be affected

Returns: true if successful or nothing to do, false if not enough memory for undo

Definition at line 1110 of file SignalManager.cpp.

References Kwave::Signal::insertSpace(), m_parent_widget, m_signal, m_undo_enabled, registerUndoAction(), and undo().

Referenced by Kwave::SampleRatePlugin::run(), and Kwave::UndoDeleteAction::undo().

 {
     if (!length) return true; // nothing to do
     Kwave::UndoTransactionGuard undo(*this, i18n("Insert Space"));
 
     unsigned int count = track_list.count();
     if (!count) return true; // nothing to do
 
     // first store undo data for all tracks
     unsigned int track;
     if (m_undo_enabled) {
         if (!registerUndoAction(new(std::nothrow) Kwave::UndoInsertAction(
             m_parent_widget, track_list, offset, length))) return false;
     }
 
     // then insert space into all tracks
     foreach (track, track_list) {
         m_signal.insertSpace(track, offset, length);
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insertTrack()

void Kwave::SignalManager::insertTrack ( unsigned int index )

Inserts a new track in the current signal.

Parameters

index position at which the new track will be inserted [0...tracks()]

Definition at line 909 of file SignalManager.cpp.

References Kwave::Signal::appendTrack(), Kwave::Signal::insertTrack(), Kwave::MetaDataList::insertTrack(), length(), m_last_length, m_meta_data, m_signal, m_undo_enabled, registerUndoAction(), Kwave::MetaDataList::selectByTracks(), tracks(), and undo().

Referenced by appendTrack(), and executeCommand().

 {
     Kwave::UndoTransactionGuard undo(*this, i18n("Insert Track"));
 
     const unsigned int count = tracks();
     Q_ASSERT(index <= count);
     if (index > count) index = count;
 
     // undo action for the track insert
     if (m_undo_enabled && !registerUndoAction(
         new(std::nothrow) Kwave::UndoInsertTrack(m_signal, index))) return;
 
     // if the signal is currently empty, use the last
     // known length instead of the current one
     sample_index_t len = (count) ? length() : m_last_length;
 
     if (index >= count) {
         // do an "append"
         m_signal.appendTrack(len, Q_NULLPTR);
     } else {
         if (m_undo_enabled) {
             // undo action for the corresponding meta data change
             QList<unsigned int> tracks;
             for (unsigned int t = index; t < count; t++) tracks.append(t);
             Kwave::MetaDataList list = m_meta_data.selectByTracks(tracks);
             if (!list.isEmpty() && !registerUndoAction(
                 new(std::nothrow) Kwave::UndoModifyMetaDataAction(list)))
                     return;
         }
 
         // adjust the track bound meta data
         m_meta_data.insertTrack(index);
 
         // insert into the list
         m_signal.insertTrack(index, len, Q_NULLPTR);
     }
 
     // remember the last length
     m_last_length = length();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isClosed()

bool Kwave::SignalManager::isClosed ( )

inline

Returns true if the signal is closed

Definition at line 98 of file SignalManager.h.

Referenced by Kwave::PlaybackController::openDevice(), signalName(), and Kwave::ZoomToolBar::updateToolbar().

98 { return m_closed; }

Kwave::SignalManager::m_closed

bool m_closed

Definition: SignalManager.h:708

Here is the caller graph for this function:

◆ isEmpty()

bool Kwave::SignalManager::isEmpty ( )

inline

Returns true if the signal is empty.

Definition at line 101 of file SignalManager.h.

Referenced by Kwave::SignalWidget::contextMenuEvent(), Kwave::NoisePlugin::createDialog(), Kwave::MainWidget::dropEvent(), Kwave::MainWidget::fullZoom(), Kwave::TopWidget::newWindow(), Kwave::PlaybackController::openDevice(), Kwave::MainWidget::refreshHorizontalScrollBar(), Kwave::RecordPlugin::resetRecording(), Kwave::VolumePlugin::setup(), and Kwave::MainWidget::updateViewRange().

101 { return m_empty; }

Kwave::SignalManager::m_empty

bool m_empty

Definition: SignalManager.h:711

Here is the caller graph for this function:

◆ isModified()

bool Kwave::SignalManager::isModified ( )

inline

Returns true if the signal is modified

Definition at line 104 of file SignalManager.h.

Referenced by Kwave::UndoTransactionGuard::abort(), Kwave::MainWidget::addLabel(), and Kwave::TopWidget::updateMenu().

104 { return m_modified; }

Kwave::SignalManager::m_modified

bool m_modified

Definition: SignalManager.h:714

Here is the caller graph for this function:

◆ labelIndex()

int Kwave::SignalManager::labelIndex ( const Kwave::Label & label ) const

Returns the index of a label, counting from zero

Parameters

label reference to a Label

Returns: index [0...N-1] or -1 if label is a null pointer or not found

Definition at line 1866 of file SignalManager.cpp.

References m_meta_data.

Referenced by Kwave::MainWidget::addLabel(), Kwave::MainWidget::labelProperties(), and Kwave::LabelItem::moveTo().

 {
     int index = 0;
     Kwave::LabelList labels(m_meta_data);
     foreach (const Kwave::Label &l, labels) {
         if (l == label) return index; // found it
         index++;
     }
     return -1; // nothing found*/
 }

Here is the caller graph for this function:

◆ length()

sample_index_t Kwave::SignalManager::length ( )

inline

Returns the number of samples in the current signal. Will be zero if no signal is loaded.

Definition at line 142 of file SignalManager.h.

Referenced by executeCommand(), Kwave::MainWidget::executeCommand(), Kwave::MainWidget::fixZoomAndOffset(), Kwave::MainWidget::fullZoom(), Kwave::MainWidget::horizontalScrollBarMoved(), insertTrack(), Kwave::MainWidget::labelProperties(), loadFile(), Kwave::SignalView::mouseMoveEvent(), Kwave::SignalView::mousePressEvent(), Kwave::SignalView::mouseReleaseEvent(), Kwave::MultiTrackWriter::MultiTrackWriter(), newSignal(), Kwave::MainWidget::refreshHorizontalScrollBar(), save(), selectRange(), Kwave::PluginManager::signalLength(), Kwave::PlaybackController::startDevicePlayBack(), and Kwave::MainWidget::updateViewRange().

142 { return m_signal.length(); }

Kwave::Signal::length

sample_index_t length()

Definition: Signal.cpp:258

Kwave::SignalManager::m_signal

Kwave::Signal m_signal

Definition: SignalManager.h:725

Here is the caller graph for this function:

◆ loadFile()

int Kwave::SignalManager::loadFile ( const QUrl & url )

Closes the current signal and loads a new file.

Parameters

url	URL of the file to be loaded

Returns: 0 if succeeded or error code < 0

Definition at line 122 of file SignalManager.cpp.

References allTracks(), Kwave::Append, Kwave::Signal::appendTrack(), Kwave::FileInfo::bits(), Kwave::Signal::close(), close(), Kwave::connect(), Kwave::FileInfo::contains(), DBG, Kwave::CodecManager::decoder(), disableUndo(), Kwave::MetaDataList::dump(), enableModifiedChange(), enableUndo(), Kwave::MultiWriter::flush(), Kwave::INF_ESTIMATED_LENGTH, Kwave::INF_FILENAME, Kwave::INF_FILESIZE, Kwave::INF_MIMETYPE, Kwave::MultiWriter::last(), Kwave::Track::length(), length(), Kwave::FileInfo::length(), m_closed, m_empty, m_last_length, m_meta_data, m_parent_widget, m_signal, Kwave::CodecManager::mimeTypeOf(), Kwave::Overwrite, Kwave::FileInfo::rate(), rememberCurrentSelection(), Kwave::MetaDataList::replace(), Kwave::FileInfo::set(), Kwave::FileProgress::setBytePosition(), Kwave::FileProgress::setLength(), Kwave::FileInfo::setLength(), setModified(), Kwave::FileInfo::setTracks(), sigMetaDataChanged(), tracks(), and Kwave::FileInfo::tracks().

Referenced by Kwave::TopWidget::loadFile().

 {
     int res = 0;
     Kwave::FileProgress *dialog = Q_NULLPTR;
 
     // take over the new file name, so that we have a valid signal
     // name during loading
     QString filename = url.path();
     QFile src(filename);
     QFileInfo fi(src);
     {
         Kwave::FileInfo info(m_meta_data);
         info.set(Kwave::INF_FILENAME, fi.absoluteFilePath());
         m_meta_data.replace(Kwave::MetaDataList(info));
     }
 
     // work with a copy of meta data, to avoid flicker effects
     Kwave::MetaDataList meta_data(m_meta_data);
 
     // enter and stay in not modified state
     enableModifiedChange(true);
     setModified(false);
     enableModifiedChange(false);
 
     // disable undo (discards all undo/redo data)
     disableUndo();
 
     QString mimetype = Kwave::CodecManager::mimeTypeOf(url);
     qDebug("SignalManager::loadFile(%s) - [%s]",
            DBG(url.toDisplayString()), DBG(mimetype));
     Kwave::Decoder *decoder = Kwave::CodecManager::decoder(mimetype);
     while (decoder) {
         // be sure that the current signal is really closed
         m_signal.close();
 
         // open the source file
         if (!(res = decoder->open(m_parent_widget, src))) {
             qWarning("unable to open source: '%s'", DBG(url.toDisplayString()));
             res = -EIO;
             break;
         }
 
         // get the initial meta data from the decoder
         meta_data = decoder->metaData();
         Kwave::FileInfo info(meta_data);
 
         // take the preliminary meta data, needed for estimated length
         m_meta_data = meta_data;
 
         // detect stream mode. if so, use one sample as display
         bool streaming = (!info.length());
 
         // we must change to open state to see the file while
         // it is loaded
         m_closed = false;
         m_empty = false;
 
         // create all tracks (empty)
         unsigned int track;
         const unsigned int tracks   = info.tracks();
         const sample_index_t length = info.length();
         Q_ASSERT(tracks);
         if (!tracks) break;
 
         for (track = 0; track < tracks; ++track) {
             Kwave::Track *t = m_signal.appendTrack(length, Q_NULLPTR);
             Q_ASSERT(t);
             if (!t || (t->length() != length)) {
                 qWarning("SignalManager::loadFile: out of memory");
                 res = -ENOMEM;
                 break;
             }
         }
         if (track < tracks) break;
 
         // create the multitrack writer as destination
         // if length was zero -> append mode / decode a stream ?
         Kwave::InsertMode mode = (streaming) ? Kwave::Append : Kwave::Overwrite;
         Kwave::MultiTrackWriter writers(*this, allTracks(), mode, 0,
             (length) ? length-1 : 0);
 
         // try to calculate the resulting length, but if this is
         // not possible, we try to use the source length instead
         quint64 resulting_size = info.tracks() * info.length() *
                                       (info.bits() >> 3);
         bool use_src_size = (!resulting_size);
         if (use_src_size) resulting_size = src.size();
 
         // prepare and show the progress dialog
         dialog = new Kwave::FileProgress(m_parent_widget,
             QUrl(filename), resulting_size,
             info.length(), info.rate(), info.bits(), info.tracks());
         Q_ASSERT(dialog);
 
         if (dialog && use_src_size) {
             // use source size for progress / stream mode
             QObject::connect(decoder, SIGNAL(sourceProcessed(quint64)),
                              dialog,  SLOT(setBytePosition(quint64)));
             QObject::connect(&writers, SIGNAL(written(quint64)),
                              dialog,   SLOT(setLength(quint64)));
         } else {
             // use resulting size percentage for progress
             QObject::connect(&writers, SIGNAL(progress(qreal)),
                              dialog,   SLOT(setValue(qreal)));
         }
         QObject::connect(dialog,   SIGNAL(canceled()),
                          &writers, SLOT(cancel()));
 
         // now decode
         res = 0;
         if (!decoder->decode(m_parent_widget, writers)) {
             qWarning("decoding failed.");
             res = -EIO;
         } else {
             // read information back from the decoder, some settings
             // might have become available during the decoding process
             meta_data = decoder->metaData();
             info = Kwave::FileInfo(meta_data);
         }
 
         decoder->close();
 
         // check for length info in stream mode
         if (!res && streaming) {
             // source was opened in stream mode -> now we have the length
             writers.flush();
             sample_index_t new_length = writers.last();
             if (new_length) new_length++;
             info.setLength(new_length);
         } else {
             info.setLength(this->length());
             info.setTracks(tracks);
         }
 
         // enter the filename/mimetype and size into the file info
         info.set(Kwave::INF_FILENAME, fi.absoluteFilePath());
         info.set(Kwave::INF_FILESIZE, src.size());
         if (!info.contains(Kwave::INF_MIMETYPE))
             info.set(Kwave::INF_MIMETYPE, mimetype);
 
         // remove the estimated length again, it is no longer needed
         info.set(Kwave::INF_ESTIMATED_LENGTH, QVariant());
 
         // take over the decoded and updated file info
         meta_data.replace(Kwave::MetaDataList(info));
         m_meta_data = meta_data;
 
         // update the length info in the progress dialog if needed
         if (dialog && use_src_size) {
             dialog->setLength(
                 quint64(info.length()) *
                 quint64(info.tracks()));
             dialog->setBytePosition(src.size());
         }
 
         break;
     }
 
     if (!decoder) {
         qWarning("unknown file type");
         res = -EINVAL;
     } else {
         delete decoder;
     }
 
     // process any queued events of the writers, like "sigSamplesInserted"
     qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
 
     // remember the last length and selection
     m_last_length = length();
     rememberCurrentSelection();
 
     // from now on, undo is enabled
     enableUndo();
 
     // modified can change from now on
     enableModifiedChange(true);
 
     if (dialog) delete dialog;
     if (res) close();
 
     m_meta_data.dump();
 
     // we now have new meta data
     emit sigMetaDataChanged(m_meta_data);
 
     return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mergeMetaData()

void Kwave::SignalManager::mergeMetaData ( const Kwave::MetaDataList & meta_data )

Merges a list of meta data items

Parameters

meta_data the meta data to merge

Definition at line 1992 of file SignalManager.cpp.

References m_meta_data, Kwave::MetaDataList::merge(), and sigMetaDataChanged().

Referenced by Kwave::UndoModifyMetaDataAction::undo().

 {
     m_meta_data.merge(meta_data);
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mergeStripes()

bool Kwave::SignalManager::mergeStripes	(	const QList< Kwave::Stripe::List > &	stripes,
		const QList< unsigned int > &	track_list
	)

Merge a list of stripes into the signal.

Note: this operation works without undo!

Parameters

stripes	list of stripe list (multi track)
track_list	list with indices of tracks for selecting

Returns: true if succeeded, false if failed

Definition at line 1192 of file SignalManager.cpp.

References m_signal, and Kwave::Signal::mergeStripes().

Referenced by Kwave::UndoDeleteTrack::undo(), Kwave::UndoModifyAction::undo(), and Kwave::UndoDeleteAction::undo().

 {
     Q_ASSERT(stripes.count() == track_list.count());
     if (stripes.count() != track_list.count())
         return false;
 
     QListIterator<Kwave::Stripe::List> it_s(stripes);
     QListIterator<unsigned int>        it_t(track_list);
     while (it_s.hasNext() && it_t.hasNext()) {
         Kwave::Stripe::List s = it_s.next();
         unsigned int        t = it_t.next();
         if (!m_signal.mergeStripes(s, t))
             return false; // operation failed
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ metaData() [1/2]

Kwave::MetaDataList& Kwave::SignalManager::metaData ( )

inline

Retrieves the list of meta data objects, mutable

Returns: list with all MetaData objects

Definition at line 388 of file SignalManager.h.

Referenced by Kwave::SignalWidget::contextMenuEvent(), Kwave::ClipBoard::copy(), Kwave::MimeData::decode(), Kwave::MainWidget::executeCommand(), Kwave::TrackView::findItem(), Kwave::MainWidget::fullZoom(), Kwave::MainWidget::MainWidget(), Kwave::TrackView::paintEvent(), Kwave::SampleRatePlugin::run(), Kwave::DebugPlugin::run(), Kwave::K3BExportPlugin::saveBlocks(), Kwave::MainWidget::saveLabels(), Kwave::SaveBlocksPlugin::start(), Kwave::SelectionItem::startDragging(), Kwave::UndoDeleteAction::store(), Kwave::MP3EncoderDialog::testSettings(), Kwave::UndoModifyMetaDataAction::undo(), Kwave::UndoDeleteMetaDataAction::undo(), Kwave::UndoAddMetaDataAction::undo(), Kwave::UndoDeleteAction::undo(), and Kwave::TopWidget::updateMenu().

388 { return m_meta_data; }

Kwave::SignalManager::m_meta_data

Kwave::MetaDataList m_meta_data

Definition: SignalManager.h:771

Here is the caller graph for this function:

◆ metaData() [2/2]

const Kwave::MetaDataList& Kwave::SignalManager::metaData ( ) const

inline

Retrieves the list of meta data objects, const

Returns: reference to the list of all MetaData objects

Definition at line 394 of file SignalManager.h.

394 { return m_meta_data; }

Kwave::SignalManager::m_meta_data

Kwave::MetaDataList m_meta_data

Definition: SignalManager.h:771

◆ modifyLabel()

bool Kwave::SignalManager::modifyLabel	(	int	index,
		sample_index_t	pos,
		const QString &	name,
		bool	with_undo
	)

modify an existing label at a given index (always without undo)

Parameters

index	the index of the label [0...N-1]
pos	position of the label [samples]
name	the name of the label
with_undo	if true, create undo info

Returns: true if succeeded, false if the index is out of range or if the new position is already occupied by an existing label

Definition at line 1955 of file SignalManager.cpp.

References Kwave::MetaDataList::add(), findLabel(), Kwave::MetaData::isNull(), m_meta_data, m_undo_enabled, Kwave::Label::moveTo(), Kwave::Label::pos(), registerUndoAction(), Kwave::Label::rename(), setModified(), sigMetaDataChanged(), and Kwave::toInt().

Referenced by Kwave::MainWidget::labelProperties(), and Kwave::LabelItem::moveTo().

 {
     Kwave::LabelList labels(m_meta_data);
     if ((index < 0) || (index >= Kwave::toInt(labels.count())))
         return false;
 
     Kwave::Label label = labels.at(index);
 
     // check: if the label should be moved and there already is a label
     // at the new position -> fail
     if ((pos != label.pos()) && !findLabel(pos).isNull())
         return false;
 
     // add a undo action
     if (with_undo && m_undo_enabled) {
         Kwave::UndoModifyMetaDataAction *undo_modify =
             new(std::nothrow) Kwave::UndoModifyMetaDataAction(
                     Kwave::MetaDataList(label));
         if (!registerUndoAction(undo_modify))
             return false;
     }
 
     // now modify the label
     label.moveTo(pos);
     label.rename(name);
     m_meta_data.add(label);
 
     // register this as a modification
     setModified(true);
 
     emit sigMetaDataChanged(m_meta_data);
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ newSignal()

void Kwave::SignalManager::newSignal	(	sample_index_t	samples,
		double	rate,
		unsigned int	bits,
		unsigned int	tracks
	)

Closes the current signal and creates a new empty signal.

Parameters

samples	number of samples per track
rate	sample rate
bits	number of bits per sample
tracks	number of tracks

Definition at line 492 of file SignalManager.cpp.

References Kwave::Signal::appendTrack(), disableUndo(), enableModifiedChange(), enableUndo(), length(), m_closed, m_empty, m_last_length, m_meta_data, m_signal, rememberCurrentSelection(), Kwave::MetaDataList::replace(), Kwave::FileInfo::setBits(), Kwave::FileInfo::setLength(), setModified(), Kwave::FileInfo::setRate(), Kwave::FileInfo::setTracks(), and sigMetaDataChanged().

Referenced by Kwave::MimeData::decode(), Kwave::TopWidget::newSignal(), and Kwave::MP3EncoderDialog::testSettings().

 {
     // enter and stay in modified state
     enableModifiedChange(true);
     setModified(true);
     enableModifiedChange(false);
 
     // disable undo (discards all undo/redo data)
     disableUndo();
 
     m_meta_data.clear();
     Kwave::FileInfo file_info(m_meta_data);
     file_info.setRate(rate);
     file_info.setBits(bits);
     file_info.setTracks(tracks);
     m_meta_data.replace(Kwave::MetaDataList(file_info));
 
     // now the signal is considered not to be empty
     m_closed = false;
     m_empty = false;
 
     // add all empty tracks
     while (tracks) {
         m_signal.appendTrack(samples, Q_NULLPTR);
         tracks--;
     }
 
     // remember the last length
     m_last_length = samples;
     file_info.setLength(length());
     m_meta_data.replace(Kwave::MetaDataList(file_info));
     rememberCurrentSelection();
 
     // from now on, undo is enabled
     enableUndo();
 
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ openReader()

Kwave::SampleReader* Kwave::SignalManager::openReader	(	Kwave::ReaderMode	mode,
		unsigned int	track,
		sample_index_t	left = `0`,
		sample_index_t	right = `SAMPLE_INDEX_MAX`
	)

inline

Opens a stream for reading samples. If the last position is omitted, the value UINT_MAX will be used.

Parameters

mode	a reader mode, see SampleReader::Mode
track	index of the track. If the track does not exist, this function will fail and return 0
left	first offset to be read (default = 0)
right	last position to read (default = UINT_MAX)

Definition at line 274 of file SignalManager.h.

References SAMPLE_INDEX_MAX.

Referenced by Kwave::MultiTrackReader::MultiTrackReader().

         {
             return m_signal.openReader(mode, track, left, right);
         }

Here is the caller graph for this function:

◆ openWriter()

Kwave::Writer* Kwave::SignalManager::openWriter	(	Kwave::InsertMode	mode,
		unsigned int	track,
		sample_index_t	left = `0`,
		sample_index_t	right = `0`
	)

inline

Opens an output stream for a track, starting at a specified sample position.

Parameters

mode	specifies where and how to insert
track	index of the track. If the track does not exist, this function will fail and return 0
left	start of the input (only useful in insert and overwrite mode)
right	end of the input (only useful with overwrite mode)

See also: InsertMode

Definition at line 258 of file SignalManager.h.

Referenced by Kwave::MultiTrackWriter::init(), and Kwave::ReversePlugin::reverseSlice().

         {
             return m_signal.openWriter(mode, track, left, right);
         }

Here is the caller graph for this function:

◆ parentWidget()

QWidget* Kwave::SignalManager::parentWidget ( ) const

inlineprotected

returns the associated parent widget, to be used for messages

Definition at line 662 of file SignalManager.h.

Referenced by Kwave::MultiTrackWriter::init(), and Kwave::PlaybackController::openDevice().

662 { return m_parent_widget; }

Kwave::SignalManager::m_parent_widget

QWidget * m_parent_widget

Definition: SignalManager.h:705

Here is the caller graph for this function:

◆ playbackController()

Kwave::PlaybackController & Kwave::SignalManager::playbackController ( )

Returns a reference to the playback controller.

Definition at line 1213 of file SignalManager.cpp.

References m_playback_controller.

Referenced by Kwave::PlayerToolBar::contextSwitched(), Kwave::MainWidget::MainWidget(), Kwave::SignalView::mousePressEvent(), Kwave::SignalView::mouseReleaseEvent(), Kwave::PluginManager::openMultiTrackPlayback(), Kwave::PluginManager::playbackController(), Kwave::PlayBackPlugin::setup(), and Kwave::TrackView::TrackView().

 {
     return m_playback_controller;
 }

Here is the caller graph for this function:

◆ rate()

double Kwave::SignalManager::rate ( ) const

inline

Returns the current sample rate in samples per second

Definition at line 131 of file SignalManager.h.

References Kwave::FileInfo::rate().

Referenced by Kwave::MimeData::decode(), Kwave::MainWidget::fullZoom(), Kwave::MainWidget::labelProperties(), Kwave::MainWidget::ms2samples(), Kwave::PlaybackController::openDevice(), Kwave::SignalView::samples2ms(), save(), Kwave::TopWidget::selectionChanged(), Kwave::ZoomToolBar::selectZoom(), Kwave::ZoomToolBar::setZoomInfo(), Kwave::PluginManager::signalRate(), Kwave::PlaybackController::startDevicePlayBack(), Kwave::SelectionItem::startDragging(), and Kwave::RecordPlugin::startRecording().

                                    {
             return Kwave::FileInfo(m_meta_data).rate();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ redo

void Kwave::SignalManager::redo ( )

slot

re-does the last undone action.

Definition at line 1707 of file SignalManager.cpp.

References checkSelectionChange(), Kwave::UndoTransaction::containsModification(), Kwave::UndoTransaction::description(), emitUndoRedoInfo(), freeUndoMemory(), Kwave::MemoryManager::instance(), m_meta_data, m_redo_buffer, m_undo_buffer, m_undo_enabled, m_undo_transaction_lock, name, Kwave::UndoTransaction::redoSize(), rememberCurrentSelection(), setModified(), sigMetaDataChanged(), Kwave::UndoAction::undo(), Kwave::MemoryManager::undoLimit(), and Kwave::UndoTransaction::undoSize().

Referenced by executeCommand(), freeUndoMemory(), and usedUndoRedoMemory().

 {
     QMutexLocker lock(&m_undo_transaction_lock);
 
     // get the last redo transaction and abort if none present
     if (m_redo_buffer.isEmpty()) return;
     Kwave::UndoTransaction *redo_transaction = m_redo_buffer.takeFirst();
     if (!redo_transaction) return;
 
     // check for modified selection
     checkSelectionChange();
 
     // temporarily disable undo while redo is running
     bool old_undo_enabled = m_undo_enabled;
     m_undo_enabled = false;
 
     // get free memory for undo
     qint64 undo_limit = Kwave::MemoryManager::instance().undoLimit() << 20;
     qint64 undo_size = redo_transaction->undoSize();
     qint64 redo_size = redo_transaction->redoSize();
     Kwave::UndoTransaction *undo_transaction = Q_NULLPTR;
     if ((undo_size > redo_size) && (undo_size - redo_size > undo_limit)) {
         // not enough memory for undo
         qWarning("SignalManager::redo(): not enough memory for undo !");
     } else {
         // only free the memory if it will be used
         freeUndoMemory(undo_size);
 
         // create a new undo transaction
         QString name = redo_transaction->description();
         undo_transaction = new(std::nothrow) Kwave::UndoTransaction(name);
         Q_ASSERT(undo_transaction);
     }
 
     // if *one* undo fails, all following undoes will also fail or
     // produce inconsistent data -> remove all of them !
     if (!undo_transaction) {
         qDeleteAll(m_undo_buffer);
         m_undo_buffer.clear();
     } else {
         m_undo_buffer.append(undo_transaction);
     }
 
     // set hourglass cursor
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
     // execute all redo actions and store the resulting undo
     // actions into the undo transaction
     bool modified = false;
     while (!redo_transaction->isEmpty()) {
         UndoAction *undo_action;
         UndoAction *redo_action;
 
         // unqueue the undo action
         redo_action = redo_transaction->takeFirst();
 
         // execute the redo operation
         Q_ASSERT(redo_action);
         if (!redo_action) continue;
         modified |= redo_transaction->containsModification();
         undo_action = redo_action->undo(*this, (undo_transaction != Q_NULLPTR));
 
         // remove the old redo action if no longer used
         if (redo_action != undo_action) {
             delete redo_action;
         }
 
         // queue the action into the undo transaction
         if (undo_action) {
             if (undo_transaction) {
                 undo_transaction->append(undo_action);
             } else {
                 // undo is not usable :-(
                 delete undo_action;
             }
         }
     }
 
     // now the redo_transaction should be empty -> get rid of it
     Q_ASSERT(redo_transaction->isEmpty());
     delete redo_transaction;
 
     if (undo_transaction && (undo_transaction->count() < 1)) {
         // if there is no undo action -> no undo possible
         qWarning("SignalManager::redo(): no undo possible");
         m_undo_buffer.removeAll(undo_transaction);
         delete undo_transaction;
     }
 
     // if the redo operation modified something,
     // we have to update the "modified" flag of the current signal
     if (modified) setModified(true);
 
     // remember the last selection
     rememberCurrentSelection();
 
     // re-enable undo
     m_undo_enabled = old_undo_enabled;
 
     // finished / buffers have changed, emit new undo/redo info
     emitUndoRedoInfo();
 
     // maybe the meta data has changed
     emit sigMetaDataChanged(m_meta_data);
 
     // remove hourglass
     QApplication::restoreOverrideCursor();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ registerUndoAction()

bool Kwave::SignalManager::registerUndoAction ( Kwave::UndoAction * action )

protected

Tries to free memory for a new undo action and stores all needed data if successful.

Parameters

action UndoAction to that is to be registered

Returns: true if the action is allowed, false if the user has chosen to abort the operation if the memory limit of the undo buffer would be exceeded. The return value will also be false if the action is null.

Note: If undo is currently not enabled, the passed UndoAction will be ignored and not freed, the return value will be false. So it is safer not to call this function if undo is not enabled.

Definition at line 1426 of file SignalManager.cpp.

References continueWithoutUndo(), freeUndoMemory(), Kwave::MemoryManager::instance(), Kwave::UndoTransaction::isAborted(), m_undo_enabled, m_undo_transaction, m_undo_transaction_lock, Kwave::UndoAction::store(), Kwave::MemoryManager::undoLimit(), and Kwave::UndoAction::undoSize().

Referenced by addLabel(), deleteLabel(), deleteRange(), deleteTrack(), Kwave::MultiTrackWriter::init(), insertSpace(), insertTrack(), modifyLabel(), Kwave::UndoTransactionGuard::registerUndoAction(), saveUndoDelete(), and setFileInfo().

 {
     QMutexLocker lock(&m_undo_transaction_lock);
 
     if (!action) return continueWithoutUndo();
 
     // if undo is not enabled, this will fail -> discard the action
     if (!m_undo_enabled) {
         delete action;
         return true;
     }
 
     // check if the undo action is too large
     qint64 limit_mb     = Kwave::MemoryManager::instance().undoLimit();
     qint64 needed_size  = action->undoSize();
     qint64 needed_mb    = needed_size  >> 20;
     if (needed_mb > limit_mb) {
         delete action;
         return continueWithoutUndo();
     }
 
     // undo has been aborted before ?
     if (!m_undo_transaction) return true;
 
     // transaction has been aborted before
     if (m_undo_transaction->isAborted()) {
         delete action;
         return true;
     }
 
     // make room...
     freeUndoMemory(needed_size);
 
     // now we might have enough place to append the undo action
     // and store all undo info
     if (!action->store(*this)) {
         delete action;
         return continueWithoutUndo();
     }
 
     // everything went ok, register internally
     m_undo_transaction->append(action);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rememberCurrentSelection()

void Kwave::SignalManager::rememberCurrentSelection ( )

private

saves the current sample and track selection

Definition at line 1999 of file SignalManager.cpp.

References m_last_selection, m_last_track_selection, m_selection, and selectedTracks().

Referenced by close(), closeUndoTransaction(), executeCommand(), loadFile(), newSignal(), redo(), and undo().

 {
     m_last_selection       = m_selection;
     m_last_track_selection = selectedTracks();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save()

int Kwave::SignalManager::save	(	const QUrl &	url,
		bool	selection
	)

Saves the signal to a file with a given resolution. If the file already exists, it will be overwritten.

Parameters

url	URL with the name of the file to be saved.
selection	if true, only the selected range will be saved

Returns: zero if succeeded or negative error code

Definition at line 312 of file SignalManager.cpp.

 {
     int res = 0;
     sample_index_t ofs  = 0;
     sample_index_t len  = length();
     unsigned int tracks = this->tracks();
     unsigned int bits   = this->bits();
 
     if (selection) {
         // zero-length -> nothing to do
         ofs = m_selection.offset();
         len = m_selection.length();
         tracks = selectedTracks().count();
     }
 
     if (!tracks || !len) {
         Kwave::MessageBox::error(m_parent_widget,
             i18n("Signal is empty, nothing to save."));
         return 0;
     }
 
     QString mimetype_name;
     mimetype_name = Kwave::CodecManager::mimeTypeOf(url);
     qDebug("SignalManager::save(%s) - [%s] (%d bit, selection=%d)",
         DBG(url.toDisplayString()), DBG(mimetype_name), bits, selection);
 
     Kwave::Encoder *encoder = Kwave::CodecManager::encoder(mimetype_name);
     Kwave::FileInfo file_info(m_meta_data);
     if (encoder) {
 
         // maybe we now have a new mime type
         file_info.set(Kwave::INF_MIMETYPE, mimetype_name);
 
         // check if we lose information and ask the user if this would
         // be acceptable
         QList<Kwave::FileProperty> unsupported = encoder->unsupportedProperties(
             file_info.properties().keys());
         if (!unsupported.isEmpty()) {
             QString list_of_lost_properties = _("\n");
             foreach (const Kwave::FileProperty &p, unsupported) {
                 list_of_lost_properties +=
                     i18n(UTF8(file_info.name(p))) + _("\n");
             }
 
             // show a warning to the user and ask him if he wants to continue
             if (Kwave::MessageBox::warningContinueCancel(m_parent_widget,
                 i18n("Saving in this format will lose the following "
                      "additional file attribute(s):\n"
                      "%1\n"
                      "Do you still want to continue?",
                      list_of_lost_properties),
                 QString(),
                 QString(),
                 QString(),
                 _("accept_lose_attributes_on_export")
                 ) != KMessageBox::Continue)
             {
                 delete encoder;
                 return -1;
             }
         }
 
         // open the destination file
         QString filename = url.path();
         QFile dst(filename);
 
         Kwave::MultiTrackReader src(Kwave::SinglePassForward, *this,
             (selection) ? selectedTracks() : allTracks(),
             ofs, ofs + len - 1);
 
         // update the file information
         file_info.setLength(len);
         file_info.setRate(rate());
         file_info.setBits(bits);
         file_info.setTracks(tracks);
 
         if (!file_info.contains(Kwave::INF_SOFTWARE) &&
             encoder->supportedProperties().contains(Kwave::INF_SOFTWARE))
         {
             // add our Kwave Software tag
             const KAboutData about_data = KAboutData::applicationData();
             QString software = about_data.displayName() + _("-") +
                                about_data.version() +
                                i18n("(built with KDE Frameworks %1)",
                                     _(KXMLGUI_VERSION_STRING));
             file_info.set(Kwave::INF_SOFTWARE, software);
         }
 
         if (!file_info.contains(Kwave::INF_CREATION_DATE) &&
             encoder->supportedProperties().contains(Kwave::INF_CREATION_DATE))
         {
             // add a date tag
             QDate now(QDate::currentDate());
             QString date;
             date = date.sprintf("%04d-%02d-%02d",
                 now.year(), now.month(), now.day());
             qDebug("adding date tag: '%s'", DBG(date));
             file_info.set(Kwave::INF_CREATION_DATE, date);
         }
 
         // prepare and show the progress dialog
         Kwave::FileProgress *dialog = new Kwave::FileProgress(m_parent_widget,
             QUrl(filename), file_info.length() * file_info.tracks() *
             (file_info.bits() >> 3),
             file_info.length(), file_info.rate(), file_info.bits(),
             file_info.tracks());
         Q_ASSERT(dialog);
         QObject::connect(&src,   SIGNAL(progress(qreal)),
                          dialog, SLOT(setValue(qreal)),
                          Qt::QueuedConnection);
         QObject::connect(dialog, SIGNAL(canceled()),
                          &src,   SLOT(cancel()));
 
         // invoke the encoder...
         bool encoded = false;
         m_meta_data.replace(Kwave::MetaDataList(file_info));
 
         if (selection) {
             // use a copy, don't touch the original !
             Kwave::MetaDataList meta = m_meta_data;
 
             // we have to adjust all position aware meta data
             meta.cropByRange(ofs, ofs + len - 1);
 
             // filter out all the track bound meta data that is not selected
             meta.cropByTracks(selectedTracks());
 
             // set the filename in the copy of the fileinfo, the original
             // file which is currently open keeps it's name
             Kwave::FileInfo info(meta);
             info.set(Kwave::INF_FILENAME, filename);
             meta.replace(Kwave::MetaDataList(info));
 
             encoded = encoder->encode(m_parent_widget, src, dst, meta);
         } else {
             // in case of a "save as" -> modify the current filename
             file_info.set(Kwave::INF_FILENAME, filename);
             m_meta_data.replace(Kwave::MetaDataList(file_info));
             encoded = encoder->encode(m_parent_widget, src, dst, m_meta_data);
         }
         if (!encoded) {
             Kwave::MessageBox::error(m_parent_widget,
                 i18n("An error occurred while saving the file."));
             res = -1;
         }
 
         delete encoder;
         encoder = Q_NULLPTR;
 
         if (dialog) {
             qApp->processEvents();
             if (dialog->isCanceled()) {
                 // user really pressed cancel !
                 Kwave::MessageBox::error(m_parent_widget,
                     i18n("The file has been truncated and "
                           "might be corrupted."));
                 res = -EINTR;
             }
             delete dialog;
             dialog = Q_NULLPTR;
         }
     } else {
         Kwave::MessageBox::error(m_parent_widget,
             i18n("Sorry, the file type is not supported."));
         res = -EINVAL;
     }
 
     if (!res && !selection) {
         // saved without error -> no longer modified
         flushUndoBuffers();
         enableModifiedChange(true);
         setModified(false);
     }
 
     emit sigMetaDataChanged(m_meta_data);
     qDebug("SignalManager::save(): res=%d",res);
     return res;
 }

Here is the call graph for this function:

◆ saveUndoDelete()

bool Kwave::SignalManager::saveUndoDelete	(	QList< unsigned int > &	track_list,
		sample_index_t	offset,
		sample_index_t	length
	)

protected

Saves undo data for deleting a range of samples from a list of tracks.

Parameters

track_list	list of indices of tracks
offset	first sample position to delete
length	number of samples to delete

Returns: true if successful, false if out of memory or aborted

Definition at line 1473 of file SignalManager.cpp.

References m_parent_widget, m_undo_enabled, and registerUndoAction().

Referenced by executeCommand().

 {
     if (!m_undo_enabled) return true;
     if (track_list.isEmpty()) return true;
 
     // create a undo action for deletion
     UndoDeleteAction *action = new(std::nothrow)
         UndoDeleteAction(m_parent_widget, track_list, offset, length);
     if (!registerUndoAction(action)) return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectedTracks()

const QList< unsigned int > Kwave::SignalManager::selectedTracks ( )

Returns an array of indices of currently selected tracks.

Definition at line 587 of file SignalManager.cpp.

References m_signal, tracks(), and Kwave::Signal::trackSelected().

Referenced by checkSelectionChange(), Kwave::MimeData::decode(), deleteRange(), executeCommand(), Kwave::MultiTrackWriter::MultiTrackWriter(), Kwave::PlaybackController::openDevice(), Kwave::UndoSelection::redoSize(), rememberCurrentSelection(), Kwave::DebugPlugin::run(), Kwave::PlaybackController::run_wrapper(), save(), Kwave::Plugin::selectedTracks(), Kwave::Plugin::selection(), slotSamplesDeleted(), slotSamplesInserted(), Kwave::SelectionItem::startDragging(), Kwave::UndoSelection::store(), Kwave::UndoSelection::undo(), and undo().

 {
     QList<unsigned int> list;
     const unsigned int tracks = this->tracks();
 
     for (unsigned int track = 0; track < tracks; track++) {
         if (!m_signal.trackSelected(track)) continue;
         list.append(track);
     }
 
     return list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selection()

Kwave::Selection& Kwave::SignalManager::selection ( )

inline

Returns a reference to the current selection

Definition at line 145 of file SignalManager.h.

Referenced by Kwave::SignalWidget::contextMenuEvent(), Kwave::SignalView::dragMoveEvent(), executeCommand(), Kwave::MainWidget::executeCommand(), Kwave::TrackView::findItem(), Kwave::SignalView::mousePressEvent(), Kwave::MultiTrackWriter::MultiTrackWriter(), Kwave::OverViewWidget::OverViewWidget(), Kwave::TrackView::paintEvent(), save(), Kwave::SelectionBorderItem::SelectionBorderItem(), Kwave::PluginManager::selectionEnd(), Kwave::SignalView::selectionPosition(), Kwave::PluginManager::selectionStart(), Kwave::PlaybackController::startDevicePlayBack(), Kwave::SelectionItem::startDragging(), startUndoTransaction(), Kwave::UndoSelection::store(), Kwave::TrackView::TrackView(), Kwave::UndoSelection::undo(), Kwave::ZoomToolBar::updateToolbar(), Kwave::TopWidget::updateToolbar(), and Kwave::MainWidget::zoomSelection().

145 { return m_selection; }

Kwave::SignalManager::m_selection

Kwave::Selection m_selection

Definition: SignalManager.h:728

Here is the caller graph for this function:

◆ selectRange()

void Kwave::SignalManager::selectRange	(	sample_index_t	offset,
		sample_index_t	length
	)

Sets the current start and length of the selection to new values.

Parameters

offset	index of the first sample
length	number of samples

Definition at line 1136 of file SignalManager.cpp.

References length(), m_selection, and Kwave::Selection::select().

Referenced by Kwave::MainWidget::dropEvent(), Kwave::SignalView::dropEvent(), executeCommand(), Kwave::MainWidget::executeCommand(), Kwave::SignalView::mousePressEvent(), Kwave::SignalView::mouseReleaseEvent(), Kwave::SelectionBorderItem::moveTo(), Kwave::ClipBoard::paste(), Kwave::SampleRatePlugin::run(), Kwave::PluginManager::selectRange(), Kwave::SelectionItem::startDragging(), and Kwave::UndoSelection::undo().

 {
     // first do some range checking
     sample_index_t len = this->length();
 
     if (length > len)  length = len;
     if (offset >= len) offset = (len) ? (len - 1) : 0;
     if ((offset + length) > len) length = len - offset;
 
     m_selection.select(offset, length);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectTrack()

void Kwave::SignalManager::selectTrack	(	unsigned int	track,
		bool	select
	)

Sets the selection flag of a track.

Parameters

track	index of the track [0..N-1]
select	if true, the track will be enabled, if false it will be disabled

Definition at line 1164 of file SignalManager.cpp.

References m_signal, Kwave::Signal::selectTrack(), and Kwave::Signal::trackSelected().

Referenced by executeCommand().

 {
     bool old_select = m_signal.trackSelected(track);
     if (select != old_select) {
         m_signal.selectTrack(track, select);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectTracks()

void Kwave::SignalManager::selectTracks ( QList< unsigned int > & track_list )

Selects multiple tracks, all other tracks will be disabled.

Parameters

track_list list od track indices

Definition at line 1150 of file SignalManager.cpp.

References m_signal, Kwave::Signal::selectTrack(), tracks(), and Kwave::Signal::trackSelected().

Referenced by checkSelectionChange(), and Kwave::UndoSelection::undo().

 {
     unsigned int track;
     unsigned int n_tracks = tracks();
     for (track = 0; track < n_tracks; track++) {
         bool old_select = m_signal.trackSelected(track);
         bool new_select = track_list.contains(track);
         if (new_select != old_select) {
             m_signal.selectTrack(track, new_select);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFileInfo()

void Kwave::SignalManager::setFileInfo	(	const Kwave::FileInfo &	new_info,
		bool	with_undo
	)

Sets a complete set of file info, including undo information

Parameters

new_info	a new FileInfo
with_undo	if true, store undo information

Definition at line 1835 of file SignalManager.cpp.

References emitUndoRedoInfo(), m_meta_data, m_undo_enabled, registerUndoAction(), Kwave::MetaDataList::replace(), setModified(), and sigMetaDataChanged().

Referenced by Kwave::FileInfoPlugin::apply(), Kwave::RecordPlugin::recordStopped(), Kwave::SampleRatePlugin::run(), and Kwave::RecordPlugin::startRecording().

 {
     if (m_undo_enabled && with_undo) {
         /* save data for undo */
         Kwave::UndoTransactionGuard undo_transaction(*this,
                                                      i18n("Modify File Info"));
         Kwave::FileInfo old_inf(m_meta_data);
         if (!registerUndoAction(
             new(std::nothrow) Kwave::UndoModifyMetaDataAction(
                 Kwave::MetaDataList(old_inf))))
             return;
     }
 
     m_meta_data.replace(Kwave::MetaDataList(new_info));
     setModified(true);
     emitUndoRedoInfo();
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setModified()

void Kwave::SignalManager::setModified ( bool mod )

protected

Sets the modified flag to a new value if m_modified_enabled is true, otherwise it will be ignored.

Definition at line 1817 of file SignalManager.cpp.

References m_modified, m_modified_enabled, and sigModified().

Referenced by Kwave::UndoTransactionGuard::abort(), Kwave::MainWidget::addLabel(), addLabel(), close(), continueWithoutUndo(), deleteLabel(), deleteTrack(), loadFile(), modifyLabel(), newSignal(), redo(), save(), setFileInfo(), slotSamplesDeleted(), slotSamplesInserted(), slotSamplesModified(), slotTrackDeleted(), slotTrackInserted(), and undo().

 {
     if (!m_modified_enabled) return;
 
     if (m_modified != mod) {
         m_modified = mod;
 //      qDebug("SignalManager::setModified(%d)",mod);
         emit sigModified();
     }
 }

Here is the caller graph for this function:

◆ setParentWidget()

void Kwave::SignalManager::setParentWidget ( QWidget * new_parent )

inline

assigns a new parent widget, to be used for messages

Parameters

new_parent pointer to a QWidget

Definition at line 416 of file SignalManager.h.

                                                          {
             m_parent_widget = new_parent;
         }

◆ sigMetaDataChanged

void Kwave::SignalManager::sigMetaDataChanged ( Kwave::MetaDataList meta )

signal

Emitted whenever meta data has changed, after some operation

Parameters

meta	the current meta data

Referenced by addLabel(), close(), deleteLabel(), deleteRange(), executeCommand(), loadFile(), mergeMetaData(), modifyLabel(), newSignal(), redo(), save(), setFileInfo(), slotSamplesDeleted(), slotSamplesInserted(), slotTrackDeleted(), slotTrackInserted(), and undo().

Here is the caller graph for this function:

◆ sigModified

void Kwave::SignalManager::sigModified ( )

signal

Emitted if the signal changes from non-modified to modified state or vice-versa.

Referenced by setModified().

Here is the caller graph for this function:

◆ signalName()

QString Kwave::SignalManager::signalName ( )

Returns a reference to the current name of the signal. If no signal is loaded the string is zero-length.

Definition at line 572 of file SignalManager.cpp.

References _, Kwave::INF_FILENAME, isClosed(), m_meta_data, and NEW_FILENAME.

Referenced by Kwave::Plugin::signalName().

 {
     // if a file is loaded -> path of the URL if it has one
     QUrl url;
     url = QUrl(Kwave::FileInfo(m_meta_data).get(Kwave::INF_FILENAME).toString());
     if (url.isValid()) return url.path();
 
     // we have something, but no name yet
     if (!isClosed()) return QString(NEW_FILENAME);
 
     // otherwise: closed, nothing loaded
     return _("");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sigSamplesDeleted

void Kwave::SignalManager::sigSamplesDeleted	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

signal

Emitted if samples have been removed from a track.

Parameters

track	index of the track
offset	position from which the data was removed
length	number of samples deleted

Referenced by SignalManager(), and slotSamplesDeleted().

Here is the caller graph for this function:

◆ sigSamplesInserted

void Kwave::SignalManager::sigSamplesInserted	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

signal

Emitted if samples have been inserted into a track. This implies a modification of the inserted data, so no extra sigSamplesModified is emitted.

Parameters

track	index of the track
offset	position from which the data was inserted
length	number of samples inserted

See also: sigSamplesModified

Referenced by SignalManager(), and slotSamplesInserted().

Here is the caller graph for this function:

◆ sigSamplesModified

void Kwave::SignalManager::sigSamplesModified	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

signal

Emitted if samples within a track have been modified.

Parameters

track	index of the track
offset	position from which the data was modified
length	number of samples modified

Referenced by SignalManager(), and slotSamplesModified().

Here is the caller graph for this function:

◆ sigSelectionChanged

void Kwave::SignalManager::sigSelectionChanged	(	sample_index_t	offset,
		sample_index_t	length
	)

signal

Signals a change in the range of selected samples.

Parameters

offset	index of the first selected sample
length	number of selected samples

◆ sigTrackDeleted

void Kwave::SignalManager::sigTrackDeleted	(	unsigned int	index,
		Kwave::Track *	track
	)

signal

Signals that a track has been deleted.

Parameters

index	position of the deleted track [0...tracks()-1]
track	reference to the new track

Referenced by SignalManager(), and slotTrackDeleted().

Here is the caller graph for this function:

◆ sigTrackInserted

void Kwave::SignalManager::sigTrackInserted	(	unsigned int	index,
		Kwave::Track *	track
	)

signal

Signals that a track has been inserted.

Parameters

index	position of the new track [0...tracks()-1]
track	reference to the new track

Referenced by SignalManager(), and slotTrackInserted().

Here is the caller graph for this function:

◆ sigTrackSelectionChanged

void Kwave::SignalManager::sigTrackSelectionChanged ( bool enabled )

signal

Signals that the selection of one of the tracks has changed

Parameters

enabled state of the track, true=selected

Referenced by SignalManager().

Here is the caller graph for this function:

◆ sigUndoRedoInfo

void Kwave::SignalManager::sigUndoRedoInfo	(	const QString &	undo,
		const QString &	redo
	)

signal

Emitted if the state or description of undo/redo has changed. If undo or redo is unavailable the description will be zero.

See also: emitUndoRedoInfo

Referenced by emitUndoRedoInfo().

Here is the caller graph for this function:

◆ slotSamplesDeleted

void Kwave::SignalManager::slotSamplesDeleted	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

privateslot

Connected to the signal's sigSamplesDeleted.

Parameters

track	index of the source track [0...tracks-1]
offset	position from which the data was removed
length	number of samples deleted

See also: Signal::sigSamplesDeleted

Definition at line 1033 of file SignalManager.cpp.

References Kwave::Signal::length(), m_last_length, m_meta_data, m_signal, Kwave::MetaDataList::replace(), selectedTracks(), Kwave::FileInfo::setLength(), setModified(), Kwave::MetaDataList::shiftLeft(), sigMetaDataChanged(), sigSamplesDeleted(), and tracks().

Referenced by SignalManager().

 {
     // remember the last known length
     m_last_length = m_signal.length();
 
     setModified(true);
 
     // only adjust the meta data once per operation
     QList<unsigned int> tracks = selectedTracks();
     if (track == tracks[0]) {
         m_meta_data.shiftLeft(offset, length, tracks);
     }
 
     emit sigSamplesDeleted(track, offset, length);
 
     Kwave::FileInfo info(m_meta_data);
     info.setLength(m_last_length);
     m_meta_data.replace(Kwave::MetaDataList(info));
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slotSamplesInserted

void Kwave::SignalManager::slotSamplesInserted	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

privateslot

Connected to the signal's sigSamplesInserted.

Parameters

track	index of the source track [0...tracks-1]
offset	position from which the data was inserted
length	number of samples inserted

See also: Signal::sigSamplesInserted

Definition at line 1010 of file SignalManager.cpp.

References Kwave::Signal::length(), m_last_length, m_meta_data, m_signal, Kwave::MetaDataList::replace(), selectedTracks(), Kwave::FileInfo::setLength(), setModified(), Kwave::MetaDataList::shiftRight(), sigMetaDataChanged(), sigSamplesInserted(), and tracks().

Referenced by SignalManager().

 {
     // remember the last known length
     m_last_length = m_signal.length();
 
     setModified(true);
 
     // only adjust the meta data once per operation
     QList<unsigned int> tracks = selectedTracks();
     if (track == tracks[0]) {
         m_meta_data.shiftRight(offset, length, tracks);
     }
 
     emit sigSamplesInserted(track, offset, length);
 
     Kwave::FileInfo info(m_meta_data);
     info.setLength(m_last_length);
     m_meta_data.replace(Kwave::MetaDataList(info));
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slotSamplesModified

void Kwave::SignalManager::slotSamplesModified	(	unsigned int	track,
		sample_index_t	offset,
		sample_index_t	length
	)

privateslot

Connected to the signal's sigSamplesModified

Parameters

track	index of the source track [0...tracks-1]
offset	position from which the data was modified
length	number of samples modified

See also: Signal::sigSamplesModified

Definition at line 1056 of file SignalManager.cpp.

References setModified(), and sigSamplesModified().

Referenced by SignalManager().

 {
     setModified(true);
     emit sigSamplesModified(track, offset, length);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slotTrackDeleted

void Kwave::SignalManager::slotTrackDeleted	(	unsigned int	index,
		Kwave::Track *	track
	)

privateslot

Connected to the signal's sigTrackInserted.

Parameters

index	numeric index of the inserted track
track	reference to the track that has been deleted

See also: Signal::sigTrackDeleted

Definition at line 996 of file SignalManager.cpp.

References m_meta_data, Kwave::MetaDataList::replace(), setModified(), Kwave::FileInfo::setTracks(), sigMetaDataChanged(), sigTrackDeleted(), and tracks().

Referenced by SignalManager().

 {
     setModified(true);
 
     Kwave::FileInfo file_info(m_meta_data);
     file_info.setTracks(tracks());
     m_meta_data.replace(Kwave::MetaDataList(file_info));
 
     emit sigTrackDeleted(index, track);
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slotTrackInserted

void Kwave::SignalManager::slotTrackInserted	(	unsigned int	index,
		Kwave::Track *	track
	)

privateslot

Connected to the signal's sigTrackInserted.

Parameters

index	numeric index of the inserted track
track	reference to the track that has been inserted

See also: Signal::sigTrackInserted

Definition at line 982 of file SignalManager.cpp.

References m_meta_data, Kwave::MetaDataList::replace(), setModified(), Kwave::FileInfo::setTracks(), sigMetaDataChanged(), sigTrackInserted(), and tracks().

Referenced by SignalManager().

 {
     setModified(true);
 
     Kwave::FileInfo file_info(m_meta_data);
     file_info.setTracks(tracks());
     m_meta_data.replace(Kwave::MetaDataList(file_info));
 
     emit sigTrackInserted(index, track);
     emit sigMetaDataChanged(m_meta_data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startUndoTransaction()

void Kwave::SignalManager::startUndoTransaction ( const QString & name = QString() )

protected

Starts an undo transaction or enters a currently running transaction recursively.

Parameters

name	the name of the transaction. Will be ignored if there already is an active transaction (optional)

Definition at line 1219 of file SignalManager.cpp.

References checkSelectionChange(), flushRedoBuffer(), m_undo_enabled, m_undo_manager, m_undo_transaction, m_undo_transaction_level, m_undo_transaction_lock, selection(), Kwave::UndoManager::startUndoTransaction(), and Kwave::UndoAction::store().

Referenced by deleteLabel(), Kwave::MultiTrackWriter::init(), and Kwave::UndoTransactionGuard::UndoTransactionGuard().

 {
     if (!m_undo_enabled) return; // undo is currently not enabled
 
     QMutexLocker lock(&m_undo_transaction_lock);
 
     // check for modified selection
     checkSelectionChange();
 
     // increase recursion level
     m_undo_transaction_level++;
 
     // start/create a new transaction if none existing
     if (!m_undo_transaction) {
 
         // if a new action starts, discard all redo actions !
         flushRedoBuffer();
 
         m_undo_transaction = new(std::nothrow) Kwave::UndoTransaction(name);
         Q_ASSERT(m_undo_transaction);
         if (!m_undo_transaction) return;
 
         // give all registered undo handlers a chance to register their own
         // undo actions
         if (!m_undo_manager.startUndoTransaction(m_undo_transaction)) {
             delete m_undo_transaction;
             m_undo_transaction = Q_NULLPTR;
         }
 
         // if it is the start of the transaction, also create one
         // for the selection
         UndoAction *selection = new(std::nothrow) Kwave::UndoSelection(*this);
         Q_ASSERT(selection);
         if (selection && selection->store(*this)) {
             m_undo_transaction->append(selection);
         } else {
             // out of memory
             delete selection;
             delete m_undo_transaction;
             m_undo_transaction = Q_NULLPTR;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stripes()

QList< Kwave::Stripe::List > Kwave::SignalManager::stripes	(	const QList< unsigned int > &	track_list,
		sample_index_t	left = `0`,
		sample_index_t	right = `SAMPLE_INDEX_MAX`
	)

Get a list of stripes that matches a given range of samples

Parameters

track_list	list with indices of tracks for selecting
left	offset of the first sample
right	offset of the last sample

Returns: a list with lists of stripes that cover the given range between left and right

Definition at line 1173 of file SignalManager.cpp.

References m_signal, and Kwave::Signal::stripes().

Referenced by Kwave::DebugPlugin::run(), Kwave::UndoModifyAction::store(), Kwave::UndoDeleteTrack::store(), Kwave::UndoDeleteAction::store(), and Kwave::UndoModifyAction::undo().

 {
     QList<Kwave::Stripe::List> stripes;
 
     foreach (unsigned int track, track_list) {
         Kwave::Stripe::List s = m_signal.stripes(track, left, right);
         if (s.isEmpty()) {
             stripes.clear(); // something went wrong -> abort
             break;
         }
         stripes.append(s);
     }
 
     return stripes;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tracks()

unsigned int Kwave::SignalManager::tracks ( )

inline

Returns the current number of tracks

Definition at line 136 of file SignalManager.h.

Referenced by appendTrack(), checkSelectionChange(), close(), Kwave::MimeData::decode(), deleteTrack(), executeCommand(), insertTrack(), loadFile(), Kwave::SampleRatePlugin::run(), Kwave::DebugPlugin::run(), save(), selectedTracks(), Kwave::TopWidget::selectionChanged(), selectTracks(), Kwave::ZoomToolBar::setZoomInfo(), slotSamplesDeleted(), slotSamplesInserted(), slotTrackDeleted(), Kwave::MainWidget::slotTrackInserted(), slotTrackInserted(), Kwave::RecordPlugin::startRecording(), undo(), Kwave::TopWidget::updateMenu(), Kwave::ZoomToolBar::updateToolbar(), and Kwave::TopWidget::updateToolbar().

136 { return m_signal.tracks(); }

Kwave::SignalManager::m_signal

Kwave::Signal m_signal

Definition: SignalManager.h:725

Kwave::Signal::tracks

unsigned int tracks()

Definition: Signal.cpp:251

Here is the caller graph for this function:

◆ trackSelected()

bool Kwave::SignalManager::trackSelected ( unsigned int track )

inline

Returns true if a given track is selected. If the track does not exist or is not selected the return value is false.

Definition at line 151 of file SignalManager.h.

Referenced by executeCommand().

                                                       {
             return (m_signal.trackSelected(track));
         }

Here is the caller graph for this function:

◆ undo

void Kwave::SignalManager::undo ( )

slot

Un-does the last action if possible.

Definition at line 1560 of file SignalManager.cpp.

References checkSelectionChange(), Kwave::UndoTransaction::containsModification(), Kwave::UndoTransaction::description(), emitUndoRedoInfo(), flushRedoBuffer(), freeUndoMemory(), Kwave::MemoryManager::instance(), Kwave::Selection::length(), m_last_selection, m_last_track_selection, m_meta_data, m_modified, m_redo_buffer, m_selection, m_undo_buffer, m_undo_enabled, m_undo_transaction_lock, name, Kwave::Selection::offset(), Kwave::UndoTransaction::redoSize(), rememberCurrentSelection(), selectedTracks(), setModified(), sigMetaDataChanged(), tracks(), Kwave::UndoAction::undo(), Kwave::MemoryManager::undoLimit(), and Kwave::UndoTransaction::undoSize().

Referenced by addLabel(), appendTrack(), checkSelectionChange(), deleteTrack(), executeCommand(), freeUndoMemory(), insertSpace(), insertTrack(), and usedUndoRedoMemory().

 {
     QMutexLocker lock(&m_undo_transaction_lock);
 
     // check for modified selection
     checkSelectionChange();
 
     // remember the last selection
     rememberCurrentSelection();
 
     // get the last undo transaction and abort if none present
     if (m_undo_buffer.isEmpty()) return;
     Kwave::UndoTransaction *undo_transaction = m_undo_buffer.takeLast();
     if (!undo_transaction) return;
 
     // dump, for debugging
 //     undo_transaction->dump("before undo: ");
 
     // temporarily disable undo while undo itself is running
     bool old_undo_enabled = m_undo_enabled;
     m_undo_enabled = false;
 
     // get free memory for redo
     qint64 undo_limit = Kwave::MemoryManager::instance().undoLimit() << 20;
     qint64 redo_size = undo_transaction->redoSize();
     qint64 undo_size = undo_transaction->undoSize();
     Kwave::UndoTransaction *redo_transaction = Q_NULLPTR;
     if ((redo_size > undo_size) && (redo_size - undo_size > undo_limit)) {
         // not enough memory for redo
         qWarning("SignalManager::undo(): not enough memory for redo !");
     } else {
         // only free the memory if it will be used
         freeUndoMemory(redo_size);
 
         // create a new redo transaction
         QString name = undo_transaction->description();
         redo_transaction = new(std::nothrow) Kwave::UndoTransaction(name);
         Q_ASSERT(redo_transaction);
     }
 
     // if *one* redo fails, all following redoes will also fail or
     // produce inconsistent data -> remove all of them !
     if (!redo_transaction) {
         flushRedoBuffer();
         qDebug("SignalManager::undo(): redo buffer flushed!");
     }
 
     // set hourglass cursor
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
     // execute all undo actions and store the resulting redo
     // actions into the redo transaction
     while (!undo_transaction->isEmpty()) {
         UndoAction *undo_action;
         UndoAction *redo_action;
 
         // unqueue the undo action
         undo_action = undo_transaction->takeLast();
         Q_ASSERT(undo_action);
         if (!undo_action) continue;
 
         // execute the undo operation
         redo_action = undo_action->undo(*this, (redo_transaction != Q_NULLPTR));
 
         // remove the old undo action if no longer used
         if (redo_action != undo_action) {
             delete undo_action;
         }
 
         // queue the action into the redo transaction
         if (redo_action) {
             if (redo_transaction) {
                 redo_transaction->prepend(redo_action);
             } else {
                 // redo is not usable :-(
                 delete redo_action;
             }
         }
     }
 
     // now the undo_transaction should be empty -> get rid of it
     Q_ASSERT(undo_transaction->isEmpty());
     delete undo_transaction;
 
     if (redo_transaction && (redo_transaction->count() < 1)) {
         // if there is no redo action -> no redo possible
         qWarning("SignalManager::undo(): no redo possible");
         delete redo_transaction;
         redo_transaction = Q_NULLPTR;
     }
 
     // check whether the selection has changed, if yes: put a undo action
     // for this selection change at the end of the redo transaction
     if (redo_transaction) {
         bool range_modified = !(m_selection == m_last_selection);
         QList<unsigned int> tracks = selectedTracks();
         bool tracks_modified = !(tracks == m_last_track_selection);
         if (range_modified || tracks_modified) {
             UndoAction *redo_action = new(std::nothrow) Kwave::UndoSelection(
                 *this,
                 m_last_track_selection,
                 m_last_selection.offset(),
                 m_last_selection.length());
             Q_ASSERT(redo_action);
             if (redo_action) redo_transaction->append(redo_action);
         }
     }
 
     // find out if there is still an action in the undo buffer
     // that has to do with modification of the signal
     if (m_modified) {
         bool stay_modified = false;
         foreach (Kwave::UndoTransaction *transaction, m_undo_buffer) {
             if (!transaction) continue;
             if (transaction->containsModification()) {
                 stay_modified = true;
                 break;
             }
         }
         if (!stay_modified) {
             // try to return to non-modified mode (might be a nop if
             // not enabled)
             setModified(false);
         }
     }
 
     // save "redo" information if possible
     if (redo_transaction)
         m_redo_buffer.prepend(redo_transaction);
 
     // remember the last selection
     rememberCurrentSelection();
 
     // re-enable undo
     m_undo_enabled = old_undo_enabled;
 
     // finished / buffers have changed, emit new undo/redo info
     emitUndoRedoInfo();
 
     // maybe the meta data has changed
     emit sigMetaDataChanged(m_meta_data);
 
     // remove hourglass
     QApplication::restoreOverrideCursor();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ undoEnabled()

bool Kwave::SignalManager::undoEnabled ( ) const

inline

Returns true if undo/redo is currently enabled

Definition at line 309 of file SignalManager.h.

Referenced by Kwave::MultiTrackWriter::init().

309 { return m_undo_enabled; }

Kwave::SignalManager::m_undo_enabled

bool m_undo_enabled

Definition: SignalManager.h:747

Here is the caller graph for this function:

◆ undoManager()

Kwave::UndoManager& Kwave::SignalManager::undoManager ( )

inline

Returns a reference to the undo manager

Definition at line 306 of file SignalManager.h.

Referenced by Kwave::SelectionTracker::SelectionTracker().

306 { return m_undo_manager; }

Kwave::SignalManager::m_undo_manager

Kwave::UndoManager m_undo_manager

Definition: SignalManager.h:765

Here is the caller graph for this function:

◆ usedUndoRedoMemory()

qint64 Kwave::SignalManager::usedUndoRedoMemory ( )

private

Returns the amount of memory currently used for undo + redo.

Definition at line 1489 of file SignalManager.cpp.

References m_redo_buffer, m_undo_buffer, redo(), undo(), and Kwave::UndoTransaction::undoSize().

Referenced by freeUndoMemory().

 {
     qint64 size = 0;
 
     foreach (Kwave::UndoTransaction *undo, m_undo_buffer)
         if (undo) size += undo->undoSize();
 
     foreach (Kwave::UndoTransaction *redo, m_redo_buffer)
         if (redo) size += redo->undoSize();
 
     return size;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uuidOfTrack()

QUuid Kwave::SignalManager::uuidOfTrack ( unsigned int track )

inline

Returns the uuid of a track

Parameters

track index of the track [0...tracks-1]

Returns: the QUuid of the track or a "null" uuid if the track does not exist

Definition at line 408 of file SignalManager.h.

Referenced by Kwave::OverViewCache::getMinMax().

                                               {
             return m_signal.uuidOfTrack(track);
         }

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ Kwave::UndoInsertAction

friend class Kwave::UndoInsertAction

friend

Definition at line 581 of file SignalManager.h.

◆ MainWidget

friend class MainWidget

friend

Definition at line 602 of file SignalManager.h.

◆ MultiTrackWriter

friend class MultiTrackWriter

friend

Definition at line 599 of file SignalManager.h.

◆ PlaybackController

friend class PlaybackController

friend

Definition at line 600 of file SignalManager.h.

◆ PluginManager

friend class PluginManager

friend

Definition at line 601 of file SignalManager.h.

◆ UndoTransactionGuard

friend class UndoTransactionGuard

friend

Definition at line 603 of file SignalManager.h.

Member Data Documentation

◆ m_closed

bool Kwave::SignalManager::m_closed

private

true if the signal is closed

Definition at line 708 of file SignalManager.h.

Referenced by close(), loadFile(), and newSignal().

◆ m_empty

bool Kwave::SignalManager::m_empty

private

true if the signal is completely empty

Definition at line 711 of file SignalManager.h.

Referenced by close(), loadFile(), and newSignal().

◆ m_last_length

sample_index_t Kwave::SignalManager::m_last_length

private

Last known length of the signal. This will be used if a track is added to an empty signal and prevents from the creation of a completely empty new signal.

Definition at line 741 of file SignalManager.h.

Referenced by close(), insertTrack(), loadFile(), newSignal(), slotSamplesDeleted(), and slotSamplesInserted().

◆ m_last_selection

Kwave::Selection Kwave::SignalManager::m_last_selection

private

the last selection (stored in undo)

Definition at line 731 of file SignalManager.h.

Referenced by checkSelectionChange(), rememberCurrentSelection(), and undo().

◆ m_last_track_selection

QList<unsigned int> Kwave::SignalManager::m_last_track_selection

private

the last track selection (stored in undo)

Definition at line 734 of file SignalManager.h.

Referenced by checkSelectionChange(), rememberCurrentSelection(), and undo().

◆ m_meta_data

Kwave::MetaDataList Kwave::SignalManager::m_meta_data

private

meta data of the signal

See also: class MetaData

Definition at line 771 of file SignalManager.h.

Referenced by addLabel(), close(), deleteLabel(), deleteRange(), deleteTrack(), executeCommand(), findLabel(), insertTrack(), labelIndex(), loadFile(), mergeMetaData(), modifyLabel(), newSignal(), redo(), save(), setFileInfo(), signalName(), slotSamplesDeleted(), slotSamplesInserted(), slotTrackDeleted(), slotTrackInserted(), and undo().

◆ m_modified

bool Kwave::SignalManager::m_modified

private

true if the signal has been modified

Definition at line 714 of file SignalManager.h.

Referenced by flushUndoBuffers(), freeUndoMemory(), setModified(), and undo().

◆ m_modified_enabled

bool Kwave::SignalManager::m_modified_enabled

private

If set to true, prevents the modified flag from changes. Useful to prevent setting the modified flag during file load and creation, or if the change to the non-modified state through undo operations is no longer possible.

Definition at line 722 of file SignalManager.h.

Referenced by enableModifiedChange(), and setModified().

◆ m_parent_widget

QWidget* Kwave::SignalManager::m_parent_widget

private

Parent widget, used for showing messages

Definition at line 705 of file SignalManager.h.

Referenced by continueWithoutUndo(), deleteRange(), executeCommand(), insertSpace(), loadFile(), save(), and saveUndoDelete().

◆ m_playback_controller

Kwave::PlaybackController Kwave::SignalManager::m_playback_controller

private

the controller for handling of playback

Definition at line 744 of file SignalManager.h.

Referenced by close(), executeCommand(), and playbackController().

◆ m_redo_buffer

QList<Kwave::UndoTransaction *> Kwave::SignalManager::m_redo_buffer

private

fifo for storing all redo transactions

Definition at line 753 of file SignalManager.h.

Referenced by emitUndoRedoInfo(), executeCommand(), flushRedoBuffer(), flushUndoBuffers(), freeUndoMemory(), redo(), undo(), and usedUndoRedoMemory().

◆ m_selection

Kwave::Selection Kwave::SignalManager::m_selection

private

the current selection

Definition at line 728 of file SignalManager.h.

Referenced by checkSelectionChange(), close(), executeCommand(), rememberCurrentSelection(), save(), selectRange(), and undo().

◆ m_signal

Kwave::Signal Kwave::SignalManager::m_signal

private

signal with multiple tracks

Definition at line 725 of file SignalManager.h.

Referenced by allTracks(), close(), deleteRange(), deleteTrack(), executeCommand(), insertSpace(), insertTrack(), loadFile(), mergeStripes(), newSignal(), selectedTracks(), selectTrack(), selectTracks(), SignalManager(), slotSamplesDeleted(), slotSamplesInserted(), and stripes().

◆ m_undo_buffer

QList<Kwave::UndoTransaction *> Kwave::SignalManager::m_undo_buffer

private

fifo used for storing all undo transactions

Definition at line 750 of file SignalManager.h.

Referenced by closeUndoTransaction(), emitUndoRedoInfo(), executeCommand(), flushUndoBuffers(), freeUndoMemory(), redo(), undo(), and usedUndoRedoMemory().

◆ m_undo_enabled

bool Kwave::SignalManager::m_undo_enabled

private

flag for "undo enabled"

Definition at line 747 of file SignalManager.h.

Referenced by addLabel(), deleteRange(), deleteTrack(), disableUndo(), emitUndoRedoInfo(), enableUndo(), executeCommand(), insertSpace(), insertTrack(), modifyLabel(), redo(), registerUndoAction(), saveUndoDelete(), setFileInfo(), startUndoTransaction(), and undo().

◆ m_undo_manager

Kwave::UndoManager Kwave::SignalManager::m_undo_manager

private

Manager for undo/redo actions

Definition at line 765 of file SignalManager.h.

Referenced by startUndoTransaction().

◆ m_undo_transaction

Kwave::UndoTransaction* Kwave::SignalManager::m_undo_transaction

private

the current undo transaction

Definition at line 756 of file SignalManager.h.

Referenced by abortUndoTransaction(), closeUndoTransaction(), continueWithoutUndo(), registerUndoAction(), and startUndoTransaction().

◆ m_undo_transaction_level

unsigned int Kwave::SignalManager::m_undo_transaction_level

private

level of nested undo transactions

Definition at line 759 of file SignalManager.h.

Referenced by checkSelectionChange(), closeUndoTransaction(), disableUndo(), and startUndoTransaction().

◆ m_undo_transaction_lock

QMutex Kwave::SignalManager::m_undo_transaction_lock

private

mutex for locking undo transactions

Definition at line 762 of file SignalManager.h.

Referenced by closeUndoTransaction(), flushUndoBuffers(), redo(), registerUndoAction(), startUndoTransaction(), and undo().

The documentation for this class was generated from the following files:

libkwave/SignalManager.h
libkwave/SignalManager.cpp

Public Slots

Signals

Public Member Functions

Protected Member Functions

Private Slots

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ SignalManager()

◆ ~SignalManager()

Member Function Documentation

◆ abortUndoTransaction()

◆ addLabel()

◆ allTracks()

◆ appendTrack()

◆ bits()

◆ canRedo()

◆ canUndo()

◆ checkSelectionChange()

◆ close()

◆ closeUndoTransaction

◆ continueWithoutUndo()

◆ deleteLabel()

◆ deleteRange() [1/3]

◆ deleteRange() [2/3]

◆ deleteRange() [3/3]

◆ deleteTrack()

◆ disableUndo()

◆ emitUndoRedoInfo

◆ enableModifiedChange()

◆ enableUndo()

◆ executeCommand()

◆ findLabel()

◆ flushRedoBuffer()

◆ flushUndoBuffers()

◆ freeUndoMemory()

◆ insertSpace()

◆ insertTrack()

◆ isClosed()

◆ isEmpty()

◆ isModified()

◆ labelIndex()

◆ length()

◆ loadFile()

◆ mergeMetaData()

◆ mergeStripes()

◆ metaData() [1/2]

◆ metaData() [2/2]

◆ modifyLabel()

◆ newSignal()

◆ openReader()

◆ openWriter()

◆ parentWidget()

◆ playbackController()

◆ rate()

◆ redo

◆ registerUndoAction()

◆ rememberCurrentSelection()

◆ save()

◆ saveUndoDelete()

◆ selectedTracks()

◆ selection()

◆ selectRange()

◆ selectTrack()

◆ selectTracks()

◆ setFileInfo()

◆ setModified()

◆ setParentWidget()

◆ sigMetaDataChanged

◆ sigModified

◆ signalName()

◆ sigSamplesDeleted

◆ sigSamplesInserted

◆ sigSamplesModified

◆ sigSelectionChanged

◆ sigTrackDeleted

◆ sigTrackInserted

◆ sigTrackSelectionChanged