Kwave::PlayerToolBar Class Reference

#include <PlayerToolBar.h>

Inheritance diagram for Kwave::PlayerToolBar:

Collaboration diagram for Kwave::PlayerToolBar:

Public Slots
void	contextSwitched (Kwave::FileContext *context)
void	contextDestroyed (Kwave::FileContext *context)
int	executeCommand (const QString &command)
void	metaDataChanged (Kwave::MetaDataList meta_data)
void	visibleRangeChanged (sample_index_t offset, sample_index_t visible, sample_index_t total)

Signals
void	sigCommand (const QString &command)
void	sigSetMenuItemEnabled (const QString &uid, bool enable)

Public Member Functions
	PlayerToolBar (KMainWindow *parent, const QString &name, Kwave::MenuManager &menu_manager)
virtual	~PlayerToolBar ()

Private Slots
void	toolbarRewindPrev ()
void	toolbarRewind ()
void	toolbarRecord ()
void	toolbarStart ()
void	toolbarLoop ()
void	playbackPaused ()
void	toolbarPause ()
void	toolbarStop ()
void	blinkPause ()
void	toolbarForward ()
void	toolbarForwardNext ()
void	updateState ()
void	updatePlaybackPos (sample_index_t pos)

Private Attributes
Kwave::FileContext *	m_context
QAction *	m_action_prev
QAction *	m_action_rewind
QAction *	m_action_record
QAction *	m_action_play
QAction *	m_action_loop
QAction *	m_action_pause
QAction *	m_action_stop
QAction *	m_action_forward
QAction *	m_action_next
QTimer *	m_pause_timer
bool	m_blink_on
QPointer< Kwave::PlaybackController >	m_playback
Kwave::MenuManager &	m_menu_manager
Kwave::LabelList	m_labels
unsigned int	m_last_tracks
sample_index_t	m_last_offset
sample_index_t	m_last_visible
sample_index_t	m_last_length

Detailed Description

Definition at line 44 of file PlayerToolBar.h.

Constructor & Destructor Documentation

PlayerToolBar()

Kwave::PlayerToolBar::PlayerToolBar	(	KMainWindow *	parent,
		const QString &	name,
		Kwave::MenuManager &	menu_manager
	)

Constructor

Parameters

parent	a KMainWidget
name	the name of the toolbar (for config)
menu_manager	the MenuManager

Definition at line 50 of file PlayerToolBar.cpp.

References _, m_action_forward, m_action_loop, m_action_next, m_action_pause, m_action_play, m_action_prev, m_action_record, m_action_rewind, m_action_stop, toolbarForward(), toolbarForwardNext(), toolbarLoop(), toolbarPause(), toolbarRecord(), toolbarRewind(), toolbarRewindPrev(), toolbarStart(), toolbarStop(), and updateState().

    :KToolBar(name, parent, true),
     m_context(Q_NULLPTR),
     m_action_prev(),
     m_action_rewind(Q_NULLPTR),
     m_action_record(Q_NULLPTR),
     m_action_play(Q_NULLPTR),
     m_action_loop(Q_NULLPTR),
     m_action_pause(Q_NULLPTR),
     m_action_stop(Q_NULLPTR),
     m_action_forward(Q_NULLPTR),
     m_action_next(Q_NULLPTR),
     m_pause_timer(Q_NULLPTR),
     m_blink_on(false),
     m_playback(Q_NULLPTR),
     m_menu_manager(menu_manager),
     m_labels(),
     m_last_tracks(0),
     m_last_offset(0),
     m_last_visible(0),
     m_last_length(0)
{
    m_action_prev = addAction(
        QIcon::fromTheme(_("kwave_player_start")),
        i18n("Previous"),
        this, SLOT(toolbarRewindPrev()));

    m_action_rewind = addAction(
        QIcon::fromTheme(_("kwave_player_rew")),
        i18n("Rewind"),
        this, SLOT(toolbarRewind()));

    m_action_record = addAction(
        QIcon::fromTheme(_("kwave_player_record")),
        i18n("Record"),
        this, SLOT(toolbarRecord()));

    m_action_play = addAction(
        QIcon::fromTheme(_("kwave_player_play")),
        i18n("Start playback"),
        this, SLOT(toolbarStart()));

    m_action_loop = addAction(
        QIcon::fromTheme(_("kwave_player_loop")),
        i18n("Start playback and loop"),
        this, SLOT(toolbarLoop()));

    m_action_pause = addAction(
        QIcon::fromTheme(_("kwave_player_pause")),
        QString(),
        this, SLOT(toolbarPause()));

    m_action_stop = addAction(
        QIcon::fromTheme(_("kwave_player_stop")),
        i18n("Stop playback or loop"),
        this, SLOT(toolbarStop()));

    m_action_forward = addAction(
        QIcon::fromTheme(_("kwave_player_fwd")),
        i18n("Forward"),
        this, SLOT(toolbarForward()));

    m_action_next = addAction(
        QIcon::fromTheme(_("kwave_player_end")),
        i18n("Next"),
        this, SLOT(toolbarForwardNext()));

    // initial state update
    updateState();
}

Here is the call graph for this function:

~PlayerToolBar()

Kwave::PlayerToolBar::~PlayerToolBar ( )

virtual

Destructor

Definition at line 123 of file PlayerToolBar.cpp.

References m_context, and m_pause_timer.

{
    if (m_pause_timer) delete m_pause_timer;
    m_pause_timer = Q_NULLPTR;
    m_context = Q_NULLPTR;
}

Member Function Documentation

blinkPause

void Kwave::PlayerToolBar::blinkPause ( )

privateslot

toggles the state of the pause button

Definition at line 305 of file PlayerToolBar.cpp.

References _, m_action_pause, m_blink_on, and m_playback.

Referenced by playbackPaused(), and updateState().

{
    const bool paused = m_playback && m_playback->paused();

    Q_ASSERT(m_action_pause);
    if (!m_action_pause) return;

    m_action_pause->setIcon(QIcon::fromTheme(_((paused && m_blink_on) ?
        "kwave_player_pause_2" : "kwave_player_pause")));

    m_blink_on = !m_blink_on;
}

Here is the caller graph for this function:

contextDestroyed

void Kwave::PlayerToolBar::contextDestroyed ( Kwave::FileContext *  context )

slot

called when a file context has been deleted

Definition at line 178 of file PlayerToolBar.cpp.

References contextSwitched(), and m_context.

{
    if (context != m_context) return; // not of interest
    contextSwitched(Q_NULLPTR);
}

Here is the call graph for this function:

contextSwitched

void Kwave::PlayerToolBar::contextSwitched ( Kwave::FileContext *  context )

slot

called when the file context has been (updates the toolbar)

Definition at line 131 of file PlayerToolBar.cpp.

References Kwave::connect(), m_context, m_playback, Kwave::SignalManager::playbackController(), playbackPaused(), Kwave::FileContext::signalManager(), updatePlaybackPos(), updateState(), and visibleRangeChanged().

Referenced by contextDestroyed().

{
    if (context == m_context) return; // nothing to do

    // disconnect the playback controller of the previous context
    if (m_context && m_playback) {
        disconnect(m_playback, SIGNAL(sigPlaybackStarted()),
                   this,       SLOT(updateState()));
        disconnect(m_playback, SIGNAL(sigPlaybackPaused()),
                   this,       SLOT(playbackPaused()));
        disconnect(m_playback, SIGNAL(sigPlaybackStopped()),
                   this,       SLOT(updateState()));
        disconnect(m_playback, SIGNAL(sigPlaybackPos(sample_index_t)),
                   this,       SLOT(updatePlaybackPos(sample_index_t)));
        disconnect(m_context, SIGNAL(sigVisibleRangeChanged(sample_index_t,
            sample_index_t, sample_index_t)),
            this, SLOT(visibleRangeChanged(sample_index_t,
            sample_index_t, sample_index_t)) );
    }

    // use the new context
    m_context = context;

    Kwave::SignalManager *signal =
        (m_context) ? m_context->signalManager() : Q_NULLPTR;
    m_playback = (signal) ? &signal->playbackController() : Q_NULLPTR;

    // connect the playback controller of the new context
    if (m_context && m_playback) {
        connect(m_playback, SIGNAL(sigPlaybackStarted()),
                this,       SLOT(updateState()));
        connect(m_playback, SIGNAL(sigPlaybackPaused()),
                this,       SLOT(playbackPaused()));
        connect(m_playback, SIGNAL(sigPlaybackStopped()),
                this,       SLOT(updateState()));
        connect(m_playback, SIGNAL(sigPlaybackPos(sample_index_t)),
                this,       SLOT(updatePlaybackPos(sample_index_t)));
        connect(m_context, SIGNAL(sigVisibleRangeChanged(sample_index_t,
            sample_index_t, sample_index_t)),
            this, SLOT(visibleRangeChanged(sample_index_t,
            sample_index_t, sample_index_t)) );
    }

    updateState();
}

Here is the call graph for this function:

Here is the caller graph for this function:

executeCommand

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

slot

Executes a playback command

Parameters

command

string with the command

Definition at line 475 of file PlayerToolBar.cpp.

References CASE_COMMAND, m_action_forward, m_action_loop, m_action_next, m_action_pause, m_action_play, m_action_prev, m_action_rewind, and m_action_stop.

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

{
    int result = 0;
    Kwave::Parser parser(command);

    if (false) {
    CASE_COMMAND("prev")
        m_action_prev->activate(QAction::Trigger);
    CASE_COMMAND("rewind")
        m_action_rewind->activate(QAction::Trigger);
    CASE_COMMAND("start")
        m_action_play->activate(QAction::Trigger);
    CASE_COMMAND("loop")
        m_action_loop->activate(QAction::Trigger);
    CASE_COMMAND("pause")
        m_action_pause->activate(QAction::Trigger);
    CASE_COMMAND("continue")
        m_action_pause->activate(QAction::Trigger);
    CASE_COMMAND("stop")
        m_action_stop->activate(QAction::Trigger);
    CASE_COMMAND("forward")
        m_action_forward->activate(QAction::Trigger);
    CASE_COMMAND("next")
        m_action_next->activate(QAction::Trigger);
    } else {
        result = -1; // unknown command ?
    }

    return result;
}

Here is the caller graph for this function:

metaDataChanged

void Kwave::PlayerToolBar::metaDataChanged ( Kwave::MetaDataList  meta_data )

slot

Called when the meta data of the current signal has changed, to track changes in signal length

Parameters

meta_data

the new meta data, after the change

Definition at line 507 of file PlayerToolBar.cpp.

References Kwave::FileInfo::length(), m_labels, m_last_length, m_last_tracks, m_playback, Kwave::FileInfo::tracks(), and updateState().

{
    const Kwave::FileInfo info(meta_data);
    sample_index_t length = info.length();
    unsigned int tracks   = info.tracks();
    bool playing          = m_playback && m_playback->running();

    m_labels = LabelList(meta_data);

    if (!playing && (length == m_last_length) && (tracks == m_last_tracks))
        return; // nothing interesting for us changed

    // transition empty <-> not empty
    m_last_length = length;
    m_last_tracks = tracks;

    updateState();
}

Here is the call graph for this function:

playbackPaused

void Kwave::PlayerToolBar::playbackPaused ( )

privateslot

playback has been paused

Definition at line 264 of file PlayerToolBar.cpp.

References blinkPause(), Kwave::connect(), m_blink_on, m_pause_timer, and updateState().

Referenced by contextSwitched().

{
    updateState();

    if (!m_pause_timer) {
        m_pause_timer = new QTimer(this);
        Q_ASSERT(m_pause_timer);
        if (!m_pause_timer) return;

        m_blink_on = true;
        m_pause_timer->start(500);
        connect(m_pause_timer, SIGNAL(timeout()),
                this, SLOT(blinkPause()));
        blinkPause();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sigCommand

void Kwave::PlayerToolBar::sigCommand ( const QString &  command )

signal

Tells this widget's parent to execute a command

Referenced by toolbarForward(), toolbarForwardNext(), toolbarRecord(), toolbarRewind(), and toolbarRewindPrev().

Here is the caller graph for this function:

sigSetMenuItemEnabled

void Kwave::PlayerToolBar::sigSetMenuItemEnabled ( const QString &  uid, bool  enable  )

signal

Emitted when an action has been enabled/disabled

toolbarForward

void Kwave::PlayerToolBar::toolbarForward ( )

privateslot

toolbar button for "forward" pressed

Definition at line 319 of file PlayerToolBar.cpp.

References _, m_action_forward, m_playback, SEEK_LENGTH, and sigCommand().

Referenced by PlayerToolBar().

{
    if (!m_action_forward || !m_action_forward->isEnabled() ||
        !m_playback) return;

    const bool play = m_playback->running() || m_playback->paused();
    if (play) {
        sample_index_t first = m_playback->startPos();
        sample_index_t last  = m_playback->endPos();
        sample_index_t pos   = m_playback->currentPos();

        if (pos < first) pos = first;
        if (pos > last)  pos = last;

        if ((pos + SEEK_LENGTH) <= last) {
            // simple case: seek without wraparound
            pos = pos + SEEK_LENGTH;
        } else if (m_playback->loop() && ((first + SEEK_LENGTH) <= last)) {
            // loop mode: wrap around
            pos = first + SEEK_LENGTH - (last - pos);
        } else {
            // must be loop mode but selection too small: wrap to left border
            pos = first;
        }

        m_playback->seekTo(pos);
    } else {
        emit sigCommand(_("view:scroll_right()"));
    }
}

Here is the caller graph for this function:

toolbarForwardNext

void Kwave::PlayerToolBar::toolbarForwardNext ( )

privateslot

toolbar button for "forward to end" pressed

Definition at line 351 of file PlayerToolBar.cpp.

References _, m_action_next, m_labels, m_playback, Kwave::LabelList::nextLabelRight(), and sigCommand().

Referenced by PlayerToolBar().

{
    if (!m_action_next || !m_action_next->isEnabled() || !m_playback) return;

    const bool play = m_playback->running() || m_playback->paused();
    if (play) {
        sample_index_t last = m_playback->endPos();
        sample_index_t next = m_labels.nextLabelRight(m_playback->currentPos());
        if (next >= last)
            next = m_playback->startPos(); // wrap around to start
        m_playback->seekTo(next);
    } else {
        emit sigCommand(_("view:scroll_next_label()"));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

toolbarLoop

void Kwave::PlayerToolBar::toolbarLoop ( )

privateslot

toolbar button for "loop" pressed

Definition at line 258 of file PlayerToolBar.cpp.

References m_playback.

Referenced by PlayerToolBar().

{
    if (m_playback) m_playback->playbackLoop();
}

Here is the caller graph for this function:

toolbarPause

void Kwave::PlayerToolBar::toolbarPause ( )

privateslot

connected to the clicked() signal of the pause button

Definition at line 282 of file PlayerToolBar.cpp.

References m_action_pause, m_last_length, m_last_tracks, and m_playback.

Referenced by PlayerToolBar().

{
    if (!m_action_pause || !m_action_pause->isEnabled() || !m_playback) return;

    const bool have_signal = (m_last_length && m_last_tracks);
    const bool playing     = m_playback->running();

    if (!have_signal) return;

    if (playing) {
        m_playback->playbackPause();
    } else {
        m_playback->playbackContinue();
    }
}

Here is the caller graph for this function:

toolbarRecord

void Kwave::PlayerToolBar::toolbarRecord ( )

privateslot

toolbar button for "record" pressed

Definition at line 244 of file PlayerToolBar.cpp.

References _, m_action_record, and sigCommand().

Referenced by PlayerToolBar().

{
    if (!m_action_record || !m_action_record->isEnabled()) return;

    emit sigCommand(_("plugin(record)"));
}

Here is the caller graph for this function:

toolbarRewind

void Kwave::PlayerToolBar::toolbarRewind ( )

privateslot

toolbar button for "rewind" pressed

Definition at line 213 of file PlayerToolBar.cpp.

References _, m_action_rewind, m_playback, SEEK_LENGTH, and sigCommand().

Referenced by PlayerToolBar().

{
    if (!m_action_rewind || !m_action_rewind->isEnabled() || !m_playback) return;

    const bool play = m_playback->running() || m_playback->paused();
    if (play) {
        sample_index_t first = m_playback->startPos();
        sample_index_t last  = m_playback->endPos();
        sample_index_t pos   = m_playback->currentPos();

        if (pos < first) pos = first;
        if (pos > last)  pos = last;

        if ((first + SEEK_LENGTH) <= pos) {
            // simple case: seek without wraparound
            pos = pos - SEEK_LENGTH;
        } else if (m_playback->loop() && ((first + SEEK_LENGTH) <= last)) {
            // loop mode: wrap around
            pos = last - (first + SEEK_LENGTH - pos);
        } else {
            // normal mode: stick to left border
            pos = first;
        }

        m_playback->seekTo(pos);
    } else {
        emit sigCommand(_("view:scroll_left()"));
    }
}

Here is the caller graph for this function:

toolbarRewindPrev

void Kwave::PlayerToolBar::toolbarRewindPrev ( )

privateslot

toolbar button for "rewind to start" pressed

Definition at line 185 of file PlayerToolBar.cpp.

References _, m_action_prev, m_labels, m_playback, Kwave::LabelList::nextLabelLeft(), and sigCommand().

Referenced by PlayerToolBar().

{
    if (!m_action_prev || !m_action_prev->isEnabled() || !m_playback) return;

    const bool play = m_playback->running() || m_playback->paused();
    if (play) {
        const sample_index_t first = m_playback->startPos();
        sample_index_t prev = m_labels.nextLabelLeft(m_playback->currentPos());

        if (!m_labels.isEmpty()) {
            // go to the start marker of the current block
            if (prev > first) {
                // seek back to the start of the previous block
                prev = m_labels.nextLabelLeft(prev);
            } else if (m_playback->loop()) {
                // in loop mode: wrap around to last block
                prev = m_labels.nextLabelLeft(m_playback->endPos());
            }
        }

        if (prev < first) prev = first;
        m_playback->seekTo(prev);
    } else {
        emit sigCommand(_("view:scroll_prev_label()"));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

toolbarStart

void Kwave::PlayerToolBar::toolbarStart ( )

privateslot

toolbar button for "start" pressed

Definition at line 252 of file PlayerToolBar.cpp.

References m_playback.

Referenced by PlayerToolBar().

{
    if (m_playback) m_playback->playbackStart();
}

Here is the caller graph for this function:

toolbarStop

void Kwave::PlayerToolBar::toolbarStop ( )

privateslot

toolbar button for "stop" pressed

Definition at line 299 of file PlayerToolBar.cpp.

References m_playback.

Referenced by PlayerToolBar().

{
    if (m_playback) m_playback->playbackStop();
}

Here is the caller graph for this function:

updatePlaybackPos

void Kwave::PlayerToolBar::updatePlaybackPos ( sample_index_t  pos )

privateslot

updates the current playback position

Definition at line 468 of file PlayerToolBar.cpp.

References updateState().

Referenced by contextSwitched().

{
    Q_UNUSED(pos);
    updateState();
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateState

void Kwave::PlayerToolBar::updateState ( )

privateslot

update the state of all toolbar buttons

Definition at line 368 of file PlayerToolBar.cpp.

References _, blinkPause(), m_action_forward, m_action_loop, m_action_next, m_action_pause, m_action_play, m_action_prev, m_action_record, m_action_rewind, m_action_stop, m_blink_on, m_labels, m_last_length, m_last_offset, m_last_tracks, m_last_visible, m_menu_manager, m_pause_timer, m_playback, Kwave::LabelList::nextLabelLeft(), Kwave::LabelList::nextLabelRight(), SEEK_LENGTH, Kwave::MenuManager::setItemEnabled(), and UPDATE_MENU.

Referenced by contextSwitched(), metaDataChanged(), playbackPaused(), PlayerToolBar(), updatePlaybackPos(), and visibleRangeChanged().

{
    if (!m_playback) return;

    bool have_signal    = (m_last_length && m_last_tracks);
    bool playing        = m_playback->running();
    bool paused         = m_playback->paused();
    bool at_start       = (m_last_offset == 0);
    bool at_end         = ((m_last_offset + m_last_visible) >= m_last_length);

    /* --- seek buttons, depending on mode --- */
    if (playing || paused) {
        // seek buttons in playback mode
        bool           loop       = m_playback->loop();
        sample_index_t pos        = m_playback->currentPos();
        sample_index_t first      = m_playback->startPos();
        sample_index_t last       = m_playback->endPos();
        sample_index_t prev       = m_labels.nextLabelLeft(pos);
        sample_index_t next       = m_labels.nextLabelRight(pos);
        sample_index_t seek_len   = SEEK_LENGTH;
        bool           have_label = (prev > first) || (next < last);

        m_action_prev->setEnabled(    (pos > first));
        m_action_rewind->setEnabled(  (pos > first) || (pos > prev));
        m_action_forward->setEnabled(
            loop ||                         // wrap around in loop mode
            ((pos + seek_len) < last)       // forward a bit, by range
        );
        m_action_next->setEnabled(
            (loop && have_label) ||         // wrap around in loop mode
            (next < last)                   // snap to next label
        );

        UPDATE_MENU(prev,   "ID_PLAYBACK_PREV");
        UPDATE_MENU(rewind, "ID_PLAYBACK_REWIND");
        UPDATE_MENU(forward,"ID_PLAYBACK_FORWARD");
        UPDATE_MENU(next,   "ID_PLAYBACK_NEXT");

        // scroll controls per menu
        m_menu_manager.setItemEnabled(_("ID_SCROLL_START"), false);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_END"),   false);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_PREV"),  false);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_NEXT"),  false);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_RIGHT"), false);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_LEFT"),  false);
    } else {
        // seek buttons in normal mode
        m_action_prev->setEnabled(    have_signal && !at_start);
        m_action_rewind->setEnabled(  have_signal && !at_start);
        m_action_forward->setEnabled( have_signal && !at_end);
        m_action_next->setEnabled(    have_signal && !at_end);
        m_menu_manager.setItemEnabled(_("ID_PLAYBACK_PREV"),    false);
        m_menu_manager.setItemEnabled(_("ID_PLAYBACK_REWIND"),  false);
        m_menu_manager.setItemEnabled(_("ID_PLAYBACK_FORWARD"), false);
        m_menu_manager.setItemEnabled(_("ID_PLAYBACK_NEXT"),    false);

        // scroll controls per menu
        m_menu_manager.setItemEnabled(_("ID_SCROLL_START"), !at_start);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_END"),   !at_end);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_PREV"),  !at_start);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_NEXT"),  !at_end);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_RIGHT"), !at_end);
        m_menu_manager.setItemEnabled(_("ID_SCROLL_LEFT"),  !at_start);
    }

    /* --- standard record/playback controls --- */
    m_action_record->setEnabled(                 !playing && !paused);
    m_action_play->setEnabled(    have_signal && !playing);
    m_action_loop->setEnabled(    have_signal && !playing);
    m_action_pause->setEnabled(                   playing ||  paused);
    m_action_stop->setEnabled(                    playing ||  paused);
    UPDATE_MENU(record, "ID_RECORD");
    UPDATE_MENU(play,   "ID_PLAYBACK_START");
    UPDATE_MENU(loop,   "ID_PLAYBACK_LOOP");
    UPDATE_MENU(stop,   "ID_PLAYBACK_STOP");
    m_menu_manager.setItemEnabled(_("ID_PLAYBACK_PAUSE"),    playing);
    m_menu_manager.setItemEnabled(_("ID_PLAYBACK_CONTINUE"), paused);

    /* handling of blink timer */
    if (m_pause_timer && !paused) {
        // stop blinking
        m_pause_timer->stop();
        delete m_pause_timer;
        m_pause_timer = Q_NULLPTR;

        m_blink_on = false;
        blinkPause();
        m_blink_on = false;
    }

    /* pause button: continue/pause playback */
    if (paused) {
        m_action_pause->setToolTip(i18n("Continue playback"));
    } else {
        m_action_pause->setToolTip(i18n("Pause playback"));
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

visibleRangeChanged

void Kwave::PlayerToolBar::visibleRangeChanged ( sample_index_t  offset, sample_index_t  visible, sample_index_t  total  )

slot

Updates the enabled/disabled state of the seek buttons after changes of the currently visible view range

Parameters

offset	index of the first visible sample
visible	number of visible samples
total	length of the whole signal

Definition at line 527 of file PlayerToolBar.cpp.

References m_last_length, m_last_offset, m_last_visible, and updateState().

Referenced by contextSwitched().

{
    bool changed = (offset  != m_last_offset)  ||
                   (visible != m_last_visible) ||
                   (total   != m_last_length);
    if (!changed) return;

    m_last_offset  = offset;
    m_last_visible = visible;
    m_last_length  = total;

    updateState();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_action_forward

QAction* Kwave::PlayerToolBar::m_action_forward

private

action of the "forward" toolbar button

Definition at line 169 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), toolbarForward(), and updateState().

m_action_loop

QAction* Kwave::PlayerToolBar::m_action_loop

private

action of the "start playback and loop" toolbar button

Definition at line 160 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), and updateState().

m_action_next

QAction* Kwave::PlayerToolBar::m_action_next

private

action of the "forward to end" toolbar button

Definition at line 172 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), toolbarForwardNext(), and updateState().

m_action_pause

QAction* Kwave::PlayerToolBar::m_action_pause

private

action of the "pause playback" toolbar button

Definition at line 163 of file PlayerToolBar.h.

Referenced by blinkPause(), executeCommand(), PlayerToolBar(), toolbarPause(), and updateState().

m_action_play

QAction* Kwave::PlayerToolBar::m_action_play

private

action of the "start playback" toolbar button

Definition at line 157 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), and updateState().

m_action_prev

QAction* Kwave::PlayerToolBar::m_action_prev

private

action of the "rewind to start" toolbar button

Definition at line 148 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), toolbarRewindPrev(), and updateState().

m_action_record

QAction* Kwave::PlayerToolBar::m_action_record

private

action of the "start record" toolbar button

Definition at line 154 of file PlayerToolBar.h.

Referenced by PlayerToolBar(), toolbarRecord(), and updateState().

m_action_rewind

QAction* Kwave::PlayerToolBar::m_action_rewind

private

action of the "rewind" toolbar button

Definition at line 151 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), toolbarRewind(), and updateState().

m_action_stop

QAction* Kwave::PlayerToolBar::m_action_stop

private

action of the "stop playback" toolbar button

Definition at line 166 of file PlayerToolBar.h.

Referenced by executeCommand(), PlayerToolBar(), and updateState().

m_blink_on

bool Kwave::PlayerToolBar::m_blink_on

private

determines the state of blinking toolbar buttons

Definition at line 178 of file PlayerToolBar.h.

Referenced by blinkPause(), playbackPaused(), and updateState().

m_context

Kwave::FileContext* Kwave::PlayerToolBar::m_context

private

the current file context (could be null)

Definition at line 145 of file PlayerToolBar.h.

Referenced by contextDestroyed(), contextSwitched(), and ~PlayerToolBar().

m_labels

Kwave::LabelList Kwave::PlayerToolBar::m_labels

private

list of labels (sorted)

Definition at line 187 of file PlayerToolBar.h.

Referenced by metaDataChanged(), toolbarForwardNext(), toolbarRewindPrev(), and updateState().

m_last_length

sample_index_t Kwave::PlayerToolBar::m_last_length

private

last length of the signal

Definition at line 199 of file PlayerToolBar.h.

Referenced by metaDataChanged(), toolbarPause(), updateState(), and visibleRangeChanged().

m_last_offset

sample_index_t Kwave::PlayerToolBar::m_last_offset

private

last offset of the current view

Definition at line 193 of file PlayerToolBar.h.

Referenced by updateState(), and visibleRangeChanged().

m_last_tracks

unsigned int Kwave::PlayerToolBar::m_last_tracks

private

last number of tracks

Definition at line 190 of file PlayerToolBar.h.

Referenced by metaDataChanged(), toolbarPause(), and updateState().

m_last_visible

sample_index_t Kwave::PlayerToolBar::m_last_visible

private

last number of visible samples

Definition at line 196 of file PlayerToolBar.h.

Referenced by updateState(), and visibleRangeChanged().

m_menu_manager

Kwave::MenuManager& Kwave::PlayerToolBar::m_menu_manager

private

reference to a menu manager

Definition at line 184 of file PlayerToolBar.h.

Referenced by updateState().

m_pause_timer

QTimer* Kwave::PlayerToolBar::m_pause_timer

private

Timer used to let the pause button blink...

Definition at line 175 of file PlayerToolBar.h.

Referenced by playbackPaused(), updateState(), and ~PlayerToolBar().

m_playback

QPointer<Kwave::PlaybackController> Kwave::PlayerToolBar::m_playback

private

pointer to a playback controller

Definition at line 181 of file PlayerToolBar.h.

Referenced by blinkPause(), contextSwitched(), metaDataChanged(), toolbarForward(), toolbarForwardNext(), toolbarLoop(), toolbarPause(), toolbarRewind(), toolbarRewindPrev(), toolbarStart(), toolbarStop(), and updateState().

---

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

• kwave/PlayerToolBar.h
• kwave/PlayerToolBar.cpp