Kwave::MultiTrackWriter Class Reference

#include <MultiTrackWriter.h>

Inheritance diagram for Kwave::MultiTrackWriter:

Collaboration diagram for Kwave::MultiTrackWriter:

Public Member Functions
	MultiTrackWriter (Kwave::SignalManager &signal_manager, const QList< unsigned int > &track_list, Kwave::InsertMode mode, sample_index_t left, sample_index_t right)
	MultiTrackWriter (Kwave::SignalManager &signal_manager, Kwave::InsertMode mode)
virtual	~MultiTrackWriter ()
Public Member Functions inherited from Kwave::MultiWriter
	MultiWriter ()
virtual	~MultiWriter () Q_DECL_OVERRIDE
virtual sample_index_t	last () const
virtual void	flush ()
virtual void	clear () Q_DECL_OVERRIDE
virtual bool	insert (unsigned int track, Kwave::Writer *writer) Q_DECL_OVERRIDE
bool	isCanceled () const
Public Member Functions inherited from Kwave::MultiTrackSink< Kwave::Writer, false >
	MultiTrackSink (unsigned int tracks, QObject *parent=Q_NULLPTR)
virtual	~MultiTrackSink () Q_DECL_OVERRIDE
virtual bool	done () const Q_DECL_OVERRIDE
virtual unsigned int	tracks () const Q_DECL_OVERRIDE
virtual Kwave::Writer *	at (unsigned int track) const
virtual Kwave::Writer *	operator[] (unsigned int track) Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::SampleSink
	SampleSink (QObject *parent=Q_NULLPTR)
virtual	~SampleSink ()
Public Member Functions inherited from Kwave::StreamObject
	StreamObject (QObject *parent=Q_NULLPTR)
virtual	~StreamObject ()
virtual unsigned int	tracksOfPort (const char *port) const
virtual Kwave::StreamObject *	port (const char *port, unsigned int track)
virtual unsigned int	blockSize () const
void	setAttribute (const char *attribute, const QVariant &value)

Private Member Functions
	MultiTrackWriter ()
bool	init (Kwave::SignalManager &signal_manager, const QList< unsigned int > &track_list, Kwave::InsertMode mode, sample_index_t left, sample_index_t right)

Additional Inherited Members
Public Slots inherited from Kwave::MultiWriter
void	cancel ()
Signals inherited from Kwave::MultiWriter
void	progress (qreal percent)
void	written (quint64 samples)
Signals inherited from Kwave::StreamObject
void	attributeChanged (const QVariant value)
Static Public Member Functions inherited from Kwave::StreamObject
static void	setInteractive (bool interactive)
Protected Attributes inherited from Kwave::MultiWriter
bool	m_canceled

Detailed Description

A MultiTrackWriter encapsulates a set of TrackWriters for easier use of multi-track signals.

Definition at line 40 of file MultiTrackWriter.h.

Constructor & Destructor Documentation

MultiTrackWriter() [1/3]

Kwave::MultiTrackWriter::MultiTrackWriter ( )

private

Default constructor

Definition at line 31 of file MultiTrackWriter.cpp.

    :Kwave::MultiWriter()
{
}

MultiTrackWriter() [2/3]

Kwave::MultiTrackWriter::MultiTrackWriter	(	Kwave::SignalManager &	signal_manager,
		const QList< unsigned int > &	track_list,
		Kwave::InsertMode	mode,
		sample_index_t	left,
		sample_index_t	right
	)

Constructor

Parameters

signal_manager	reference to a SignalManager
track_list	list of track indices
mode	specifies where and how to insert
left	index of the first sample
right	index of the last sample

Definition at line 37 of file MultiTrackWriter.cpp.

References init().

    :Kwave::MultiWriter()
{
    if (!init(signal_manager, track_list, mode, left, right)) {
        // out of memory or aborted
        qWarning("MultiTrackWriter::init FAILED");
     }
}

Here is the call graph for this function:

MultiTrackWriter() [3/3]

Kwave::MultiTrackWriter::MultiTrackWriter	(	Kwave::SignalManager &	signal_manager,
		Kwave::InsertMode	mode
	)

Constructor that opens a set of Writers using the currently selected list of tracks and the current selection. If nothing is selected, the whole signal will be selected.

Parameters

signal_manager	reference to a SignalManager
mode	specifies where and how to insert

Definition at line 51 of file MultiTrackWriter.cpp.

References Kwave::Selection::first(), init(), Kwave::Selection::last(), Kwave::SignalManager::length(), Kwave::SignalManager::selectedTracks(), and Kwave::SignalManager::selection().

    :Kwave::MultiWriter()
{
    QList<unsigned int> track_list = signal_manager.selectedTracks();
    sample_index_t left = 0;
    sample_index_t right = 0;

    if (signal_manager.length()) {
        // default if signal is present: current selection
        left  = signal_manager.selection().first();
        right = signal_manager.selection().last();
        if (left == right) {
            // if no selection: whole signal
            left  = 0;
            right = signal_manager.length() - 1;
        }
    }

    if (!init(signal_manager, track_list, mode, left, right)) {
        // out of memory or aborted
        qWarning("MultiTrackWriter::init FAILED");
     }
}

Here is the call graph for this function:

~MultiTrackWriter()

Kwave::MultiTrackWriter::~MultiTrackWriter ( )

virtual

Destructor

Definition at line 77 of file MultiTrackWriter.cpp.

References Kwave::MultiWriter::clear(), and Kwave::MultiWriter::flush().

{
    flush();
    clear();
}

Here is the call graph for this function:

Member Function Documentation

init()

bool Kwave::MultiTrackWriter::init ( Kwave::SignalManager &  signal_manager, const QList< unsigned int > &  track_list, Kwave::InsertMode  mode, sample_index_t  left, sample_index_t  right  )

private

Intializer, see constructor...

Parameters

signal_manager	reference to a SignalManager
track_list	array of indices of tracks for reading
mode	specifies where and how to insert
left	index of the first sample
right	index of the last sample

Definition at line 84 of file MultiTrackWriter.cpp.

References Kwave::Append, Kwave::MultiTrackSink< Kwave::Writer, false >::at(), Kwave::MultiWriter::clear(), Kwave::connect(), Kwave::Writer::first(), Kwave::Insert, Kwave::MultiWriter::insert(), Kwave::Writer::last(), Kwave::SignalManager::openWriter(), Kwave::Overwrite, Kwave::SignalManager::parentWidget(), Kwave::SignalManager::registerUndoAction(), Kwave::SignalManager::startUndoTransaction(), Kwave::MultiTrackSink< Kwave::Writer, false >::tracks(), and Kwave::SignalManager::undoEnabled().

Referenced by MultiTrackWriter().

{
    Kwave::UndoTransactionGuard guard(signal_manager, QString());

    unsigned int index = 0;
    foreach (unsigned int track, track_list) {
        // NOTE: this function is *nearly* identical to the one in the
        //       Signal class, except for undo support
        Kwave::Writer *writer = signal_manager.openWriter(
            mode, track, left, right);
        if (writer) {
            insert(index++, writer);

            // get the real/effective left and right sample
            left  = writer->first();
            right = writer->last();
        } else {
            // out of memory or aborted
            clear();
            return false;
        }
    }

    // skip all that undo handling below if undo is not enabled
    // or the writer creation has failed
    if (!signal_manager.undoEnabled()) return true;

    // enter a new undo transaction and let it close when the writer closes
    signal_manager.startUndoTransaction();
    QObject::connect(this, SIGNAL(destroyed()),
                     &signal_manager,   SLOT(closeUndoTransaction()),
                     Qt::QueuedConnection);

    // create an undo action for the modification of the samples
    UndoAction *undo = Q_NULLPTR;
    switch (mode) {
        case Kwave::Append:
        case Kwave::Insert: {
            undo = new(std::nothrow) Kwave::UndoInsertAction(
                signal_manager.parentWidget(),
                track_list,
                left,
                right - left + 1
            );

            if (undo) {
                Kwave::Writer *last_writer = at(tracks() - 1);
                QObject::connect(
                    last_writer,
                    SIGNAL(sigSamplesWritten(sample_index_t)),
                    static_cast<Kwave::UndoInsertAction *>(undo),
                    SLOT(setLength(sample_index_t)));
            }
            break;
        }
        case Kwave::Overwrite: {
            foreach (unsigned int track, track_list) {
                undo = new(std::nothrow) Kwave::UndoModifyAction(
                    track, left, right - left + 1);
                if (!signal_manager.registerUndoAction(undo)) {
                    // aborted, do not continue without undo
                    clear();
                    return false;
                }
            }
            break;
        }
    }

    if ( (mode != Kwave::Overwrite) &&
         !signal_manager.registerUndoAction(undo) )
    {
        // aborted, do not continue without undo
        clear();
        return false;
    }

    // Everything was ok, the action now is owned by the current undo
    // transaction. The transaction is owned by the SignalManager and
    // will be closed when the writer gets closed.
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• libkwave/MultiTrackWriter.h
• libkwave/MultiTrackWriter.cpp