Kwave::SelectRangePlugin Class Reference

#include <SelectRangePlugin.h>

Inheritance diagram for Kwave::SelectRangePlugin:

Collaboration diagram for Kwave::SelectRangePlugin:

Public Member Functions
	SelectRangePlugin (QObject *parent, const QVariantList &args)
virtual	~SelectRangePlugin () Q_DECL_OVERRIDE
virtual QStringList *	setup (QStringList &previous_params) Q_DECL_OVERRIDE
virtual int	start (QStringList &params) Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::Plugin
	Plugin (QObject *parent, const QVariantList &args)
virtual	~Plugin () Q_DECL_OVERRIDE
virtual QString	name () const
virtual QString	description () const
virtual QString	progressText ()
virtual bool	canClose () const
bool	isRunning () const
bool	shouldStop () const
virtual void	load (QStringList &params)
virtual void	unload ()
virtual int	stop ()
virtual void	run (QStringList params)
Kwave::PluginManager &	manager () const
Kwave::SignalManager &	signalManager ()
QWidget *	parentWidget () const
QString	signalName ()
virtual sample_index_t	signalLength ()
virtual double	signalRate ()
virtual const QList< unsigned int >	selectedTracks ()
virtual sample_index_t	selection (QList< unsigned int > *tracks=Q_NULLPTR, sample_index_t *left=Q_NULLPTR, sample_index_t *right=Q_NULLPTR, bool expand_if_empty=false)
virtual void	selectRange (sample_index_t offset, sample_index_t length)
virtual void	migrateToActiveContext ()
Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

Protected Member Functions
int	interpreteParameters (QStringList &params)
Protected Member Functions inherited from Kwave::Plugin
int	execute (QStringList &params)
void	emitCommand (const QString &command)
void	use ()
void	setPluginManager (Kwave::PluginManager *new_plugin_manager)
virtual void	run_wrapper (const QVariant &params) Q_DECL_OVERRIDE

Private Attributes
Kwave::SelectTimeWidget::Mode	m_start_mode
Kwave::SelectTimeWidget::Mode	m_range_mode
unsigned int	m_start
unsigned int	m_range

Additional Inherited Members
Public Slots inherited from Kwave::Plugin
virtual void	setProgressDialogEnabled (bool enable)
virtual void	updateProgress (qreal progress)
virtual void	cancel ()
virtual void	close ()
void	release ()
Signals inherited from Kwave::Plugin
void	sigRunning (Kwave::Plugin *plugin)
void	sigDone (Kwave::Plugin *plugin)
void	sigClosed (Kwave::Plugin *p)
void	sigCommand (const QString &command)
void	setProgressText (const QString &text)

Detailed Description

Definition at line 34 of file SelectRangePlugin.h.

Constructor & Destructor Documentation

SelectRangePlugin()

Kwave::SelectRangePlugin::SelectRangePlugin	(	QObject *	parent,
		const QVariantList &	args
	)

Constructor

Parameters

parent	reference to our plugin manager
args	argument list [unused]

Definition at line 37 of file SelectRangePlugin.cpp.

    :Kwave::Plugin(parent, args),
     m_start_mode(Kwave::SelectTimeWidget::bySamples),
     m_range_mode(Kwave::SelectTimeWidget::bySamples),
     m_start(0), m_range(0)
{
}

~SelectRangePlugin()

Kwave::SelectRangePlugin::~SelectRangePlugin ( )

virtual

Destructor

Definition at line 47 of file SelectRangePlugin.cpp.

{
}

Member Function Documentation

interpreteParameters()

int Kwave::SelectRangePlugin::interpreteParameters ( QStringList &  params )

protected

Reads values from the parameter list

Definition at line 127 of file SelectRangePlugin.cpp.

References Kwave::SelectTimeWidget::byPercents, Kwave::SelectTimeWidget::bySamples, Kwave::SelectTimeWidget::byTime, m_range, m_range_mode, m_start, and m_start_mode.

Referenced by setup(), and start().

{
    bool ok;
    QString param;
    int mode;

    // evaluate the parameter list
    if (params.count() != 4) {
        return -EINVAL;
    }

    // selection mode for start
    param = params[0];
    mode = param.toInt(&ok);
    Q_ASSERT(ok);
    if (!ok) return -EINVAL;
    Q_ASSERT(
        (mode == static_cast<int>(Kwave::SelectTimeWidget::byTime)) ||
        (mode == static_cast<int>(Kwave::SelectTimeWidget::bySamples)) ||
        (mode == static_cast<int>(Kwave::SelectTimeWidget::byPercents))
    );
    if ((mode != static_cast<int>(Kwave::SelectTimeWidget::byTime)) &&
        (mode != static_cast<int>(Kwave::SelectTimeWidget::bySamples)) &&
        (mode != static_cast<int>(Kwave::SelectTimeWidget::byPercents)))
    {
        return -EINVAL;
    }
    m_start_mode = static_cast<Kwave::SelectTimeWidget::Mode>(mode);


    // selection mode
    param = params[1];
    mode = param.toInt(&ok);
    Q_ASSERT(ok);
    if (!ok) return -EINVAL;
    Q_ASSERT(
        (mode == static_cast<int>(Kwave::SelectTimeWidget::byTime)) ||
        (mode == static_cast<int>(Kwave::SelectTimeWidget::bySamples)) ||
        (mode == static_cast<int>(Kwave::SelectTimeWidget::byPercents))
    );
    if ((mode != static_cast<int>(Kwave::SelectTimeWidget::byTime)) &&
        (mode != static_cast<int>(Kwave::SelectTimeWidget::bySamples)) &&
        (mode != static_cast<int>(Kwave::SelectTimeWidget::byPercents)))
    {
        return -EINVAL;
    }
    m_range_mode = static_cast<Kwave::SelectTimeWidget::Mode>(mode);

    // offset in ms, samples or percent
    param = params[2];
    m_start = param.toUInt(&ok);
    if (!ok) return -EINVAL;

    // range in ms, samples or percent
    param = params[3];
    m_range = param.toUInt(&ok);
    if (!ok) return -EINVAL;

    return 0;
}

Here is the caller graph for this function:

setup()

QStringList * Kwave::SelectRangePlugin::setup ( QStringList &  previous_params )

virtual

Shows a dialog for selecting the range and emits a command for applying the selection if OK has been pressed.

See also

Kwave::Plugin::setup

Reimplemented from Kwave::Plugin.

Definition at line 52 of file SelectRangePlugin.cpp.

References _, Kwave::Plugin::emitCommand(), interpreteParameters(), m_range, m_range_mode, m_start_mode, Kwave::Plugin::manager(), Kwave::Plugin::parentWidget(), Kwave::SelectRangeDialog::range(), Kwave::SelectRangeDialog::rangeMode(), Kwave::PluginManager::selectionStart(), Kwave::Plugin::signalLength(), Kwave::Plugin::signalRate(), Kwave::SelectRangeDialog::start(), and Kwave::SelectRangeDialog::startMode().

{
    // try to interpret the previous parameters
    interpreteParameters(previous_params);

    // create the setup dialog
    double rate = signalRate();
    sample_index_t offset = manager().selectionStart();
    sample_index_t length = signalLength();

    Kwave::SelectRangeDialog *dialog =
        new Kwave::SelectRangeDialog(parentWidget(),
            m_start_mode, m_range_mode, m_range, rate, offset, length);
    Q_ASSERT(dialog);
    if (!dialog) return Q_NULLPTR;

    QStringList *list = new QStringList();
    Q_ASSERT(list);
    if (list && dialog->exec()) {
        // user has pressed "OK"
        *list << QString::number(dialog->startMode());
        *list << QString::number(dialog->rangeMode());
        *list << QString::number(dialog->start());
        *list << QString::number(dialog->range());

        emitCommand(_("plugin:execute(selectrange,") +
            QString::number(dialog->startMode()) + _(",") +
            QString::number(dialog->rangeMode()) + _(",") +
            QString::number(dialog->start()) + _(",") +
            QString::number(dialog->range())+
            _(")")
        );
    } else {
        // user pressed "Cancel"
        if (list) delete list;
        list = Q_NULLPTR;
    }

    if (dialog) delete dialog;
    return list;
}

Here is the call graph for this function:

start()

int Kwave::SelectRangePlugin::start ( QStringList &  params )

virtual

selects the range

See also

Kwave::Plugin::start()

Reimplemented from Kwave::Plugin.

Definition at line 95 of file SelectRangePlugin.cpp.

References interpreteParameters(), m_range, m_range_mode, m_start, m_start_mode, Kwave::Plugin::selectRange(), Kwave::Plugin::signalLength(), Kwave::Plugin::signalRate(), and Kwave::SelectTimeWidget::timeToSamples().

{
    // interprete the parameters
    int result = interpreteParameters(params);
    if (result) return result;

    const sample_index_t signal_length = signalLength();

    // get current offset of the signal
    sample_index_t offset = Kwave::SelectTimeWidget::timeToSamples(
        m_start_mode, m_start, signalRate(), signal_length);

    // transform into offset and length [samples]
    sample_index_t length = Kwave::SelectTimeWidget::timeToSamples(
        m_range_mode, m_range, signalRate(), signal_length);

    // limit selection to end of signal
    if (length > signal_length)
        length = signal_length;
    if ((offset + length) >= signal_length)
        length = signal_length - offset;

    // change the selection through the signal manager
    {
        Kwave::UndoTransactionGuard undo_guard(*this, i18n("Select Range"));
        selectRange(offset, length);
    }

    return result;
}

Here is the call graph for this function:

Member Data Documentation

m_range

unsigned int Kwave::SelectRangePlugin::m_range

private

range in milliseconds, samples or percents

Definition at line 81 of file SelectRangePlugin.h.

Referenced by interpreteParameters(), setup(), and start().

m_range_mode

Kwave::SelectTimeWidget::Mode Kwave::SelectRangePlugin::m_range_mode

private

selected mode for range: by time, samples, percentage

Definition at line 75 of file SelectRangePlugin.h.

Referenced by interpreteParameters(), setup(), and start().

m_start

unsigned int Kwave::SelectRangePlugin::m_start

private

start in milliseconds, samples or percents

Definition at line 78 of file SelectRangePlugin.h.

Referenced by interpreteParameters(), and start().

m_start_mode

Kwave::SelectTimeWidget::Mode Kwave::SelectRangePlugin::m_start_mode

private

selected mode for start: by time, samples, percentage

Definition at line 72 of file SelectRangePlugin.h.

Referenced by interpreteParameters(), setup(), and start().

---

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

• plugins/selectrange/SelectRangePlugin.h
• plugins/selectrange/SelectRangePlugin.cpp