Kwave::SelectTimeWidget Class Reference

#include <SelectTimeWidget.h>

Inheritance diagram for Kwave::SelectTimeWidget:

Collaboration diagram for Kwave::SelectTimeWidget:

Public Types
enum	Mode { byTime = 0, bySamples, byPercents }

Public Slots
void	setOffset (sample_index_t offset)

Signals
void	valueChanged (sample_index_t samples)

Public Member Functions
	SelectTimeWidget (QWidget *widget)
virtual void	init (Mode mode, quint64 range, double sample_rate, sample_index_t offset, sample_index_t signal_length)
virtual	~SelectTimeWidget ()
void	setMode (Mode new_mode)
Mode	mode () const
quint64	time () const
sample_index_t	samples () const
virtual void	setTitle (const QString title)

Static Public Member Functions
static sample_index_t	timeToSamples (Mode mode, quint64 time, double rate, sample_index_t length)
static quint64	samplesToTime (Mode mode, sample_index_t time, double rate, sample_index_t length)

Private Slots
void	modeChanged (bool checked)
void	timeChanged (int)
void	checkNewSampleEdit ()
void	samplesChanged (int)
void	percentsChanged (int p)

Private Member Functions
void	connect ()
void	disconnect ()

Private Attributes
Mode	m_mode
quint64	m_range
double	m_rate
sample_index_t	m_offset
sample_index_t	m_length
QTimer	m_timer

Detailed Description

widget for selecting a time or range

Definition at line 37 of file SelectTimeWidget.h.

Member Enumeration Documentation

Mode

enum Kwave::SelectTimeWidget::Mode

possible mode of the selection

Enumerator
byTime	range in milliseconds
bySamples	number of samples
byPercents	percentage of whole signal

Definition at line 44 of file SelectTimeWidget.h.

                     {
            byTime = 0, 
            bySamples,  
            byPercents  
        } Mode;

Constructor & Destructor Documentation

SelectTimeWidget()

Kwave::SelectTimeWidget::SelectTimeWidget ( QWidget *  widget )

explicit

Constructor

Parameters

widget

pointer to the parent widget

Definition at line 34 of file SelectTimeWidget.cpp.

References modeChanged().

    :QGroupBox(widget), Ui::SelectTimeWidgetBase(),
     m_mode(bySamples), m_range(0), m_rate(1.0), m_offset(0), m_length(0),
     m_timer(this)
{
    setupUi(this);
    modeChanged(true);
}

Here is the call graph for this function:

~SelectTimeWidget()

Kwave::SelectTimeWidget::~SelectTimeWidget ( )

virtual

Destructor

Definition at line 144 of file SelectTimeWidget.cpp.

{
}

Member Function Documentation

checkNewSampleEdit

void Kwave::SelectTimeWidget::checkNewSampleEdit ( )

privateslot

checks for new values in the sample edit field

Definition at line 326 of file SelectTimeWidget.cpp.

References samplesChanged().

Referenced by connect(), and disconnect().

{
    static int last_samples = -1;
    if (edSamples->value() != last_samples) {
        last_samples = edSamples->value();
        samplesChanged(last_samples);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

connect()

void Kwave::SelectTimeWidget::connect ( )

private

connects all widgets for getting informed about changes

Definition at line 149 of file SelectTimeWidget.cpp.

References checkNewSampleEdit(), Kwave::connect(), m_timer, samplesChanged(), timeChanged(), and valueChanged().

Referenced by init(), percentsChanged(), samplesChanged(), setOffset(), and timeChanged().

{
    // connect the time controls
    QObject::connect(sbMilliseconds, SIGNAL(valueChanged(int)),
                     this, SLOT(timeChanged(int)));
    QObject::connect(sbSeconds, SIGNAL(valueChanged(int)),
                     this, SLOT(timeChanged(int)));
    QObject::connect(sbMinutes, SIGNAL(valueChanged(int)),
                     this, SLOT(timeChanged(int)));
    QObject::connect(sbHours, SIGNAL(valueChanged(int)),
                     this, SLOT(timeChanged(int)));

    // connect sample count control
    QObject::connect(edSamples, SIGNAL(valueChanged(int)),
                     this, SLOT(samplesChanged(int)));

    // connect the timer for the sample edit
    QObject::connect(&m_timer, SIGNAL(timeout()),
                     this, SLOT(checkNewSampleEdit()));

}

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect()

void Kwave::SelectTimeWidget::disconnect ( )

private

disconnect all widgets for avoiding recursion

Definition at line 172 of file SelectTimeWidget.cpp.

References checkNewSampleEdit(), m_timer, samplesChanged(), timeChanged(), and valueChanged().

Referenced by percentsChanged(), samplesChanged(), setOffset(), and timeChanged().

{
    // disconnect the time controls
    QObject::disconnect(sbMilliseconds, SIGNAL(valueChanged(int)),
                        this, SLOT(timeChanged(int)));
    QObject::disconnect(sbSeconds, SIGNAL(valueChanged(int)),
                        this, SLOT(timeChanged(int)));
    QObject::disconnect(sbMinutes, SIGNAL(valueChanged(int)),
                        this, SLOT(timeChanged(int)));
    QObject::disconnect(sbHours, SIGNAL(valueChanged(int)),
                        this, SLOT(timeChanged(int)));

    // disconnect sample count control
    QObject::disconnect(edSamples, SIGNAL(valueChanged(int)),
                        this, SLOT(samplesChanged(int)));

    // disconnect the timer for the sample edit
    QObject::disconnect(&m_timer, SIGNAL(timeout()),
                        this, SLOT(checkNewSampleEdit()));

}

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Kwave::SelectTimeWidget::init ( Mode  mode, quint64  range, double  sample_rate, sample_index_t  offset, sample_index_t  signal_length  )

virtual

Constructor

Parameters

mode	selectionMode: byTime, bySamples, byPercents
range	length of the selection in ms, samples or percent
sample_rate	number of samples per second, needed for converting between samples and time
offset	start of the selection [samples]
signal_length	length of the signal in samples, needed for converting samples to percentage

Definition at line 44 of file SelectTimeWidget.cpp.

References byPercents, bySamples, byTime, Kwave::connect(), connect(), m_length, m_mode, m_offset, m_range, m_rate, mode(), modeChanged(), percentsChanged(), samples(), samplesChanged(), setMode(), timeChanged(), Kwave::toInt(), and valueChanged().

{
    m_mode  = mode;
    m_range = range;
    m_rate  = sample_rate;
    m_offset = offset;
    m_length = signal_length;

    Q_ASSERT(m_rate > 0);
    Q_ASSERT(m_length);
    Q_ASSERT(rbTime);
    Q_ASSERT(rbSamples);
    Q_ASSERT(rbPercents);
    Q_ASSERT(m_offset < m_length);
    if (m_rate <= 0) m_rate = 1.0;
    if (!m_length) m_length = 1;

    // limit the length if necessary
    if ((m_length - m_offset) > INT_MAX)
        m_length = m_offset + INT_MAX;

    // set range of selection by sample
    edSamples->setRange(0, Kwave::toInt(m_length - m_offset));
    edSamples->setSingleStep(1);

    // set range of time controls
    {
        quint64 t = static_cast<quint64>((m_length * 1E3) / m_rate);
        sbMilliseconds->setMaximum(Kwave::toInt(qMax(t, quint64(999))));
        t /= 1000;
        sbSeconds->setMaximum(Kwave::toInt(qMax(t, quint64(59))));
        t /= 60;
        sbMinutes->setMaximum(Kwave::toInt(qMax(t, quint64(59))));
        t /= 60;
        sbHours->setMaximum(Kwave::toInt(t));
    }

    // activate the current mode
    setMode(mode);
    m_range = range;

    // set initial values
    switch (m_mode) {
        case byTime: {
            quint64 t = m_range;
            sbMilliseconds->setValue(Kwave::toInt(t % 1000));
            t /= 1000;
            sbSeconds->setValue(Kwave::toInt(t % 60));
            t /= 60;
            sbMinutes->setValue(Kwave::toInt(t % 60));
            t /= 60;
            sbHours->setValue(Kwave::toInt(t));
            break;
        }
        case bySamples: {
            quint64 samples = qMin<quint64>(m_range, INT_MAX);
            edSamples->setValue(Kwave::toInt(samples));
            break;
        }
        case byPercents: {
            sbPercents->setValue(Kwave::toInt(m_range));
            break;
        }
    }

    // connect mode controls
    QObject::connect(rbTime, SIGNAL(toggled(bool)),
                     this, SLOT(modeChanged(bool)));
    QObject::connect(rbSamples,SIGNAL(toggled(bool)),
                     this, SLOT(modeChanged(bool)));
    QObject::connect(rbPercents,SIGNAL(toggled(bool)),
                     this, SLOT(modeChanged(bool)));

    connect();

    // connect percentage control
    QObject::connect(sbPercents, SIGNAL(valueChanged(int)),
                     this, SLOT(percentsChanged(int)));

    // update all controls
    switch (m_mode) {
        case byTime:
            timeChanged(0);
            break;
        case bySamples:
            samplesChanged(0);
            break;
        case byPercents:
            percentsChanged(Kwave::toInt(m_range));
            break;
    }

    adjustSize();
    setMinimumSize(sizeHint());
    modeChanged(true);
}

Here is the call graph for this function:

mode()

Mode Kwave::SelectTimeWidget::mode ( ) const

inline

Returns the current selection mode (byTime, bySamples, byPercents)

Definition at line 76 of file SelectTimeWidget.h.

Referenced by init().

{ return m_mode; }

Here is the caller graph for this function:

modeChanged

void Kwave::SelectTimeWidget::modeChanged ( bool  checked )

privateslot

called whenever one of the radio buttons changed it's state

Definition at line 222 of file SelectTimeWidget.cpp.

References byPercents, bySamples, byTime, m_mode, m_timer, percentsChanged(), samplesChanged(), and timeChanged().

Referenced by init(), and SelectTimeWidget().

{
    if (!checked) return; // ignore disabling of radio buttons

    if (rbTime->isChecked()) {
        m_mode = byTime;
        rbSamples->setChecked(false);
        rbPercents->setChecked(false);
        timeChanged(0); // (sets m_range)
    }

    if (rbSamples->isChecked()) {
        m_mode = bySamples;
        rbTime->setChecked(false);
        rbPercents->setChecked(false);
        samplesChanged(0); // (sets m_range)

        if (rbTime->isChecked()) {
            m_timer.stop();
        } else {
            // activate the sample edit timer
            m_timer.setSingleShot(false);
            m_timer.start(100);
        }

    }

    if (rbPercents->isChecked()) {
        m_mode = byPercents;
        rbTime->setChecked(false);
        rbSamples->setChecked(false);
        percentsChanged(sbPercents->value()); // (sets m_range)
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

percentsChanged

void Kwave::SelectTimeWidget::percentsChanged ( int  p )

privateslot

called when percentage changed

Definition at line 373 of file SelectTimeWidget.cpp.

References byPercents, byTime, connect(), disconnect(), m_length, m_mode, m_offset, m_range, m_rate, samples(), samplesToTime(), timeToSamples(), Kwave::toInt(), and valueChanged().

Referenced by init(), and modeChanged().

{
    if (m_mode != byPercents) return;
    disconnect();

    // limit to rest of signal
    int max_percents = 100;
    if (m_length)
        max_percents = Kwave::toInt(
            (100U * static_cast<quint64>(m_length - m_offset)) /
                    static_cast<quint64>(m_length));
    if (p > max_percents) p = max_percents;

    // update in byPercents mode [0...100]
    m_range = p;

    if (slidePercents->value() != p) slidePercents->setValue(p);
    if (sbPercents->value() != p) sbPercents->setValue(p);

    // update the other widgets
    sample_index_t samples = timeToSamples(byPercents, p, m_rate, m_length);
    edSamples->setValue(Kwave::toInt(samples));

    quint64 t = samplesToTime(byTime, samples, m_rate, m_length);
    sbMilliseconds->setValue(Kwave::toInt(t % 1000));
    t /= 1000;
    sbSeconds->setValue(Kwave::toInt(t % 60));
    t /= 60;
    sbMinutes->setValue(Kwave::toInt(t % 60));
    t /= 60;
    sbHours->setValue(Kwave::toInt(t));

    emit valueChanged(samples); // emit the change
    connect();
}

Here is the call graph for this function:

Here is the caller graph for this function:

samples()

sample_index_t Kwave::SelectTimeWidget::samples

(

)

const

Returns the time in units of samples

Definition at line 458 of file SelectTimeWidget.cpp.

Referenced by init(), percentsChanged(), samplesChanged(), samplesToTime(), setOffset(), and timeChanged().

{
    return (edSamples) ? edSamples->value() : 0;
}

Here is the caller graph for this function:

samplesChanged

void Kwave::SelectTimeWidget::samplesChanged ( int  )

privateslot

called when sample count has changed

Definition at line 336 of file SelectTimeWidget.cpp.

References byPercents, bySamples, byTime, connect(), disconnect(), m_length, m_mode, m_offset, m_range, m_rate, m_timer, samples(), samplesToTime(), Kwave::toInt(), and valueChanged().

Referenced by checkNewSampleEdit(), connect(), disconnect(), init(), and modeChanged().

{
    if (m_mode != bySamples) return;
    disconnect();

    sample_index_t max_samples = m_length - m_offset;
    sample_index_t samples     = edSamples->value();

    // limit the current value
    if (samples > max_samples) samples = max_samples;

    // update the other widgets
    quint64 t = samplesToTime(byTime, samples, m_rate, m_length);
    sbMilliseconds->setValue(Kwave::toInt(t % 1000));
    t /= 1000;
    sbSeconds->setValue(Kwave::toInt(t % 60));
    t /= 60;
    sbMinutes->setValue(Kwave::toInt(t % 60));
    t /= 60;
    sbHours->setValue(Kwave::toInt(t));

    quint64 percents = samplesToTime(byPercents, samples, m_rate, m_length);
    sbPercents->setValue(Kwave::toInt(percents));

    // update in samples mode
    m_range = samples;

    // re-activate the sample edit timer
    m_timer.stop();
    m_timer.setSingleShot(false);
    m_timer.start(100);

    emit valueChanged(samples); // emit the change
    connect();
}

Here is the call graph for this function:

Here is the caller graph for this function:

samplesToTime()

quint64 Kwave::SelectTimeWidget::samplesToTime ( Mode  mode, sample_index_t  time, double  rate, sample_index_t  length  )

static

Conversion from samples into time

Parameters

mode	time mode (byTime, bySamples, byPercents)
time	position in samples
rate	number of samples per second
length	signal length

Returns

time converted to the given mode

Definition at line 491 of file SelectTimeWidget.cpp.

References byPercents, bySamples, byTime, samples(), and time().

Referenced by percentsChanged(), samplesChanged(), setOffset(), and timeChanged().

{
    quint64 time = 0;

    switch (mode) {
        case Kwave::SelectTimeWidget::byTime:
            // convert from samples to ms
            time = static_cast<quint64>(
                rint(static_cast<double>(samples) * 1E3 / rate));
            break;
        case Kwave::SelectTimeWidget::bySamples:
            // simple case -> already in samples
            time = samples;
            break;
        case Kwave::SelectTimeWidget::byPercents:
            // by percentage of whole signal
            time = static_cast<quint64>(100.0 *
                static_cast<double>(samples) /
                static_cast<double>(length));
            break;
    }

    return time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setMode()

void Kwave::SelectTimeWidget::setMode

(

Mode

new_mode

)

Sets a new selection mode

Definition at line 195 of file SelectTimeWidget.cpp.

References byPercents, bySamples, byTime, and m_mode.

Referenced by init().

{
    // enable the selected mode
    switch (new_mode) {
        case byTime:
            rbTime->setChecked(true);
            Q_ASSERT(rbTime->isChecked());
            Q_ASSERT(!rbSamples->isChecked());
            Q_ASSERT(!rbPercents->isChecked());
            break;
        case bySamples:
            rbSamples->setChecked(true);
            Q_ASSERT(!rbTime->isChecked());
            Q_ASSERT(rbSamples->isChecked());
            Q_ASSERT(!rbPercents->isChecked());
            break;
        case byPercents:
            rbPercents->setChecked(true);
            Q_ASSERT(!rbTime->isChecked());
            Q_ASSERT(!rbSamples->isChecked());
            Q_ASSERT(rbPercents->isChecked());
            break;
    }
    m_mode = new_mode;
}

Here is the caller graph for this function:

setOffset

void Kwave::SelectTimeWidget::setOffset ( sample_index_t  offset )

slot

Sets/updates the start offset from which the selection starts. The current selection length will be reduced to fit in the available range.

Parameters

offset

index of the first selected sample

Definition at line 416 of file SelectTimeWidget.cpp.

References bySamples, connect(), disconnect(), m_length, m_offset, m_rate, samples(), samplesToTime(), and Kwave::toInt().

{
    m_offset = offset;
    sample_index_t max_samples = m_length - m_offset;
    sample_index_t samples = edSamples->value();

    // the range of the sample edit should always get updated
    if (max_samples > INT_MAX)
        max_samples = INT_MAX; // limit the length to INT_MAX
    edSamples->setRange(0, Kwave::toInt(max_samples));
    edSamples->setSingleStep(1);

    // no range conflict -> nothing to do
    if (samples <= max_samples) return;

    // limit the length to the rest
    samples = max_samples;

    // update all widgets
    disconnect();

    quint64 t = samplesToTime(bySamples, samples, m_rate, m_length);
    sbMilliseconds->setValue(Kwave::toInt(t % 1000));
    t /= 1000;
    sbSeconds->setValue(Kwave::toInt(t % 60));
    t /= 60;
    sbMinutes->setValue(Kwave::toInt(t % 60));
    t /= 60;
    sbHours->setValue(Kwave::toInt(t));

    Q_ASSERT(samples <= INT_MAX);
    if (samples > INT_MAX) samples = INT_MAX;
    edSamples->setValue(Kwave::toInt(samples));

    double percents = 100.0 * static_cast<double>(samples) /
        static_cast<double>(m_length);
    sbPercents->setValue(Kwave::toInt(percents));

    connect();
}

Here is the call graph for this function:

setTitle()

void Kwave::SelectTimeWidget::setTitle ( const QString  title )

virtual

Sets the title of the, shown in the frame around the controls

Definition at line 410 of file SelectTimeWidget.cpp.

{
    QGroupBox::setTitle(title);
}

time()

quint64 Kwave::SelectTimeWidget::time ( ) const

inline

Returns the number of ms, samples or percents

Definition at line 79 of file SelectTimeWidget.h.

References Kwave::connect().

Referenced by samplesToTime(), and timeToSamples().

{ return m_range; }

Here is the call graph for this function:

Here is the caller graph for this function:

timeChanged

void Kwave::SelectTimeWidget::timeChanged ( int  )

privateslot

called whenever one of the time controls changed their value

Definition at line 259 of file SelectTimeWidget.cpp.

References byPercents, byTime, connect(), disconnect(), m_length, m_mode, m_offset, m_range, m_rate, samples(), samplesToTime(), timeToSamples(), Kwave::toInt(), and valueChanged().

Referenced by connect(), disconnect(), init(), and modeChanged().

{
    if (m_mode != byTime) return;
    disconnect();

    // get current time and correct wrap-overs
    int milliseconds = sbMilliseconds->value();
    int seconds = sbSeconds->value();
    int minutes = sbMinutes->value();
    int hours = sbHours->value();

    if (milliseconds < 0) {
        milliseconds = 999;
        seconds--;
    }
    if (seconds < 0) {
        seconds = 59;
        minutes--;
    }
    if (minutes < 0) {
        minutes = 59;
        hours--;
    }
    if (hours < 0) {
        hours = 0;
        minutes = 0;
        seconds = 0;
        milliseconds = 0;
    }
    Q_ASSERT((hours >= 0) && (minutes >= 0) && (seconds >= 0) &&
             (milliseconds >= 0));

    quint64 ms = milliseconds +
        (seconds + (minutes + (hours * 60)) * 60) * 1000;

    // limit time
    quint64 max_ms = static_cast<quint64>(
        ceil(((m_length - m_offset) * 1E3) / m_rate));
    if (ms > max_ms) ms = max_ms;
    quint64 t = ms;

    milliseconds = Kwave::toInt(t % 1000L);
    t /= 1000L;
    seconds = Kwave::toInt(t % 60L);
    t /= 60L;
    minutes = Kwave::toInt(t % 60L);
    hours   = Kwave::toInt(t / 60L);

    sbMilliseconds->setValue(milliseconds);
    sbSeconds->setValue(seconds);
    sbMinutes->setValue(minutes);
    sbHours->setValue(hours);

    // update the other widgets
    sample_index_t samples = timeToSamples(byTime, ms, m_rate, m_length);
    edSamples->setValue(Kwave::toInt(samples));
    quint64 percents = samplesToTime(byPercents, samples, m_rate, m_length);
    sbPercents->setValue(Kwave::toInt(percents));

    // set range in byTime mode [ms]
    m_range = ms;

    emit valueChanged(samples); // emit the change
    connect();
}

Here is the call graph for this function:

Here is the caller graph for this function:

timeToSamples()

sample_index_t Kwave::SelectTimeWidget::timeToSamples ( Mode  mode, quint64  time, double  rate, sample_index_t  length  )

static

Conversion from time into samples

Parameters

mode	time mode (byTime, bySamples, byPercents)
time	a time, given in ms, samples or percents
rate	number of samples per second
length	signal length

Returns

time converted to samples

Definition at line 464 of file SelectTimeWidget.cpp.

References byPercents, bySamples, byTime, and time().

Referenced by percentsChanged(), Kwave::ZeroPlugin::run(), Kwave::GotoPluginBase::start(), Kwave::SelectRangePlugin::start(), and timeChanged().

{
    sample_index_t pos = 0;
    switch (mode) {
        case Kwave::SelectTimeWidget::byTime:
            // convert from ms to samples
            pos = static_cast<sample_index_t>(ceil(
                static_cast<double>(time) * (rate * 1E-3)));
            break;
        case Kwave::SelectTimeWidget::bySamples:
            // simple case -> already in samples
            pos = time;
            break;
        case Kwave::SelectTimeWidget::byPercents:
            // by percentage of whole signal
            pos = static_cast<unsigned int>(rint(
                static_cast<double>(length * (time / 100.0))));
            break;
    }

    if (pos > INT_MAX) pos = INT_MAX;
    return pos;
}

Here is the call graph for this function:

Here is the caller graph for this function:

valueChanged

void Kwave::SelectTimeWidget::valueChanged ( sample_index_t  samples )

signal

Emitted when the value has been changed

Referenced by connect(), disconnect(), init(), percentsChanged(), samplesChanged(), and timeChanged().

Here is the caller graph for this function:

Member Data Documentation

m_length

sample_index_t Kwave::SelectTimeWidget::m_length

private

length of the whole signal [samples]

Definition at line 164 of file SelectTimeWidget.h.

Referenced by init(), percentsChanged(), samplesChanged(), setOffset(), and timeChanged().

m_mode

Mode Kwave::SelectTimeWidget::m_mode

private

selectionMode: byTime, bySamples or byPercent

Definition at line 152 of file SelectTimeWidget.h.

Referenced by init(), modeChanged(), percentsChanged(), samplesChanged(), setMode(), and timeChanged().

m_offset

sample_index_t Kwave::SelectTimeWidget::m_offset

private

start offset of the selection [samples]

Definition at line 161 of file SelectTimeWidget.h.

Referenced by init(), percentsChanged(), samplesChanged(), setOffset(), and timeChanged().

m_range

quint64 Kwave::SelectTimeWidget::m_range

private

selected range in ms, samples or percent

Definition at line 155 of file SelectTimeWidget.h.

Referenced by init(), percentsChanged(), samplesChanged(), and timeChanged().

m_rate

double Kwave::SelectTimeWidget::m_rate

private

sample rate [samples/second]

Definition at line 158 of file SelectTimeWidget.h.

Referenced by init(), percentsChanged(), samplesChanged(), setOffset(), and timeChanged().

m_timer

QTimer Kwave::SelectTimeWidget::m_timer

private

timer that checks for changes in the sample edit

Definition at line 167 of file SelectTimeWidget.h.

Referenced by connect(), disconnect(), modeChanged(), and samplesChanged().

---

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

• libgui/SelectTimeWidget.h
• libgui/SelectTimeWidget.cpp