Kwave::FileContext Class Reference

#include <FileContext.h>

Inheritance diagram for Kwave::FileContext:

Collaboration diagram for Kwave::FileContext:

Classes
class	UsageGuard

Public Slots
int	executeCommand (const QString &command)

Signals
void	sigStatusBarMessage (const QString &message, unsigned int ms)
void	sigZoomChanged (Kwave::FileContext *context, double zoom)
void	sigMetaDataChanged (Kwave::MetaDataList meta_data)
void	sigSelectionChanged (sample_index_t offset, sample_index_t length)
void	sigUndoRedoInfo (const QString &undo, const QString &redo)
void	sigVisibleRangeChanged (sample_index_t offset, sample_index_t visible, sample_index_t total)
void	sigModified ()
void	destroyed (Kwave::FileContext *context)

Public Member Functions
	FileContext (Kwave::App &app)
virtual	~FileContext ()
bool	init (Kwave::TopWidget *top_widget)
bool	createMainWidget (const QSize &preferred_size)
void	setParent (Kwave::TopWidget *top_widget)
Kwave::App &	app () const
QWidget *	mainWidget () const
Kwave::SignalManager *	signalManager () const
Kwave::PluginManager *	pluginManager () const
Kwave::Zoomable *	zoomable () const
bool	isEmpty () const
bool	isActive () const
bool	isInUse () const
QString	signalName () const
int	instanceNr () const
QString	windowCaption (bool with_modified) const
int	loadBatch (const QUrl &url)
int	saveFile ()
int	saveFileAs (const QString &filename, bool selection=false)
bool	closeFile ()

Protected Member Functions
void	use ()
void	release ()

Private Slots
void	contextSwitched (Kwave::FileContext *context)
void	forwardZoomChanged (double zoom)
void	updatePlaybackPos (sample_index_t offset)
void	metaDataChanged (Kwave::MetaDataList meta_data)
void	selectionChanged (sample_index_t offset, sample_index_t length)
void	setUndoRedoInfo (const QString &undo, const QString &redo)
void	visibleRangeChanged (sample_index_t offset, sample_index_t visible, sample_index_t total)
void	modifiedChanged ()
void	processDelayedCommand ()

Private Member Functions
void	activated ()
void	statusBarMessage (const QString &msg, unsigned int ms)
int	parseCommands (QTextStream &stream)
void	enqueueCommand (unsigned int delay, const QString &command)
int	revert ()
int	delegateCommand (const char *plugin, Kwave::Parser &parser, unsigned int param_count)

Private Attributes
QAtomicInt	m_use_count
Kwave::App &	m_application
QPointer< Kwave::TopWidget >	m_top_widget
QPointer< Kwave::MainWidget >	m_main_widget
QPointer< Kwave::SignalManager >	m_signal_manager
QPointer< Kwave::PluginManager >	m_plugin_manager
bool	m_active
double	m_last_zoom
sample_index_t	m_last_playback_pos
QString	m_last_status_message_text
QElapsedTimer	m_last_status_message_timer
unsigned int	m_last_status_message_ms
QString	m_last_undo
QString	m_last_redo
int	m_instance_nr
QTimer	m_delayed_command_timer
QList< QPair< unsigned int, QString > >	m_delayed_command_queue

Friends
class	App
class	TopWidget
class	UsageGuard

Detailed Description

Definition at line 55 of file FileContext.h.

Constructor & Destructor Documentation

FileContext()

Kwave::FileContext::FileContext ( Kwave::App &  app )

explicit

Constructor. Creates a new toplevel window, signal manager, plugin manager and so on.

Parameters

app	reference to the Kwave application

Definition at line 69 of file FileContext.cpp.

References Kwave::connect(), m_delayed_command_timer, and processDelayedCommand().

    :QObject(),
     m_use_count(1),
     m_application(app),
     m_top_widget(Q_NULLPTR),
     m_main_widget(Q_NULLPTR),
     m_signal_manager(Q_NULLPTR),
     m_plugin_manager(Q_NULLPTR),
     m_active(true),
     m_last_zoom(0),
     m_last_playback_pos(0),
     m_last_status_message_text(),
     m_last_status_message_timer(),
     m_last_status_message_ms(0),
     m_last_undo(QString()),
     m_last_redo(QString()),
     m_instance_nr(-1),
     m_delayed_command_timer(),
     m_delayed_command_queue()
{
    m_delayed_command_timer.setSingleShot(true);
    connect(&m_delayed_command_timer, SIGNAL(timeout()),
            this, SLOT(processDelayedCommand()));
}

Here is the call graph for this function:

~FileContext()

Kwave::FileContext::~FileContext ( )

virtual

Destructor

Definition at line 95 of file FileContext.cpp.

References m_main_widget, m_plugin_manager, m_signal_manager, and m_top_widget.

{
    if (m_main_widget) delete m_main_widget;
    m_main_widget = Q_NULLPTR;

    m_top_widget = Q_NULLPTR;

    if (m_plugin_manager) delete m_plugin_manager;
    m_plugin_manager = Q_NULLPTR;

    if (m_signal_manager) delete m_signal_manager;
    m_signal_manager = Q_NULLPTR;
}

Member Function Documentation

activated()

void Kwave::FileContext::activated ( )

private

should be called when this context got active, to update the status bar, toolbar etc.

Definition at line 619 of file FileContext.cpp.

References forwardZoomChanged(), m_last_playback_pos, m_last_redo, m_last_status_message_ms, m_last_status_message_text, m_last_status_message_timer, m_last_undo, m_last_zoom, m_main_widget, m_plugin_manager, m_signal_manager, sigMetaDataChanged(), sigModified(), sigStatusBarMessage(), sigUndoRedoInfo(), sigVisibleRangeChanged(), Kwave::toUint(), and updatePlaybackPos().

Referenced by contextSwitched().

{
    // let our plugin manager be the active one
    if (m_plugin_manager) m_plugin_manager->setActive();

    // emit last playback position if playback is running
    if (m_signal_manager && m_signal_manager->playbackController().running())
        updatePlaybackPos(m_last_playback_pos);

    // emit last zoom factor
    forwardZoomChanged(m_last_zoom);

    // erase the status message of the previous context
    emit sigStatusBarMessage(QString(), 0);

    // emit our last status bar message if it has not expired
    if (m_last_status_message_timer.isValid()) {
        quint64 elapsed = m_last_status_message_timer.elapsed();
        if (elapsed < m_last_status_message_ms) {
            unsigned int remaining =
                Kwave::toUint(m_last_status_message_ms - elapsed);
            emit sigStatusBarMessage(m_last_status_message_text, remaining);
        } else
            m_last_status_message_timer.invalidate();
    } else if (m_last_status_message_ms == 0) {
        // static message without expiration
        if (m_last_status_message_text.length()) {
            emit sigStatusBarMessage(m_last_status_message_text, 0);
        }
    }

    // emit latest meta data
    if (m_signal_manager)
        emit sigMetaDataChanged(m_signal_manager->metaData());

    // emit latest view range change
    if (m_main_widget && m_signal_manager) {
        sample_index_t offset  = m_main_widget->visibleOffset();
        sample_index_t visible = m_main_widget->visibleSamples();
        sample_index_t total   = m_signal_manager->length();
        emit sigVisibleRangeChanged(offset, visible, total);
    }

    // force update of the "modified" state
    emit sigModified();

    // emit last undo/redo info
    emit sigUndoRedoInfo(m_last_undo, m_last_redo);

}

Here is the call graph for this function:

Here is the caller graph for this function:

app()

Kwave::App& Kwave::FileContext::app ( ) const

inline

returns a reference to the application instance

Definition at line 93 of file FileContext.h.

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

{ return m_application; }

Here is the caller graph for this function:

closeFile()

bool Kwave::FileContext::closeFile

(

)

Closes the current file. If the file has been modified and the user wanted to cancel the close operation, the file will not get closed and the function returns with false.

Returns

true if closing is allowed, false if canceled

Definition at line 1060 of file FileContext.cpp.

References Kwave::App::GUI_MDI, Kwave::App::GUI_SDI, Kwave::App::GUI_TAB, Kwave::App::guiType(), m_application, m_main_widget, m_plugin_manager, m_signal_manager, m_top_widget, saveFile(), and Kwave::MessageBox::warningYesNoCancel().

Referenced by Kwave::TopWidget::closeAllSubWindows(), Kwave::MainWidget::closeEvent(), executeCommand(), Kwave::TopWidget::loadFile(), and Kwave::TopWidget::newWindow().

{
    Kwave::FileContext::UsageGuard _keep(this);

    if (m_plugin_manager && !m_plugin_manager->canClose())
    {
        qWarning("FileContext::closeFile() - currently not possible, "\
                 "a plugin is running :-(");
        return false;
    }

    if (m_signal_manager && m_signal_manager->isModified()) {
        int res =  Kwave::MessageBox::warningYesNoCancel(m_top_widget,
            i18n("This file has been modified.\nDo you want to save it?"));
        if (res == KMessageBox::Cancel) return false;
        if (res == KMessageBox::Yes) {
            // user decided to save
            res = saveFile();
            qDebug("FileContext::closeFile()::saveFile, res=%d",res);
            if (res) return false;
        }
    }

    // close all plugins that still might use the current signal
    if (m_plugin_manager) {
        m_plugin_manager->stopAllPlugins();
        m_plugin_manager->signalClosed();
    }

    if (m_signal_manager) m_signal_manager->close();

    switch (m_application.guiType()) {
        case Kwave::App::GUI_MDI: /* FALLTHROUGH */
        case Kwave::App::GUI_TAB:
            // close the main widget
            if (m_main_widget) delete m_main_widget;
            break;
        case Kwave::App::GUI_SDI:
            break;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

contextSwitched

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

privateslot

called when the current file context has changed

Parameters

context

the new file context (can be "this")

Definition at line 605 of file FileContext.cpp.

References activated(), and m_active.

Referenced by setParent().

{
    Kwave::FileContext::UsageGuard _keep(this);

    if (context == this) {
        if (!m_active) {
            m_active = true;
            activated();
        }
    } else
        m_active = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createMainWidget()

bool Kwave::FileContext::createMainWidget

(

const QSize &

preferred_size

)

create a main widget, within the MDI area or toplevel widget in case of SDI interface

Parameters

preferred_size

preferred size of the main widget

Returns

true if successful, false if failed

Definition at line 127 of file FileContext.cpp.

References Kwave::connect(), executeCommand(), forwardZoomChanged(), m_main_widget, m_signal_manager, m_top_widget, sigVisibleRangeChanged(), sigZoomChanged(), and visibleRangeChanged().

Referenced by Kwave::TopWidget::init(), Kwave::TopWidget::insertContext(), and Kwave::TopWidget::newWindow().

{
    Q_ASSERT(!m_main_widget);

    // create the main widget
    m_main_widget = new(std::nothrow) Kwave::MainWidget(
        m_top_widget, *this, preferred_size
    );
    Q_ASSERT(m_main_widget);
    if (!m_main_widget) return false;
    if (!(m_main_widget->isOK())) {
        delete m_main_widget;
        m_main_widget = Q_NULLPTR;
        return false;
    }

    // connect the main widget
    connect(&(m_signal_manager->playbackController()),
            SIGNAL(sigSeekDone(sample_index_t)),
            m_main_widget, SLOT(scrollTo(sample_index_t)));
    connect(m_main_widget, SIGNAL(sigCommand(QString)),
            this,          SLOT(executeCommand(QString)));
    connect(m_main_widget, SIGNAL(sigZoomChanged(double)),
            this,          SLOT(forwardZoomChanged(double)));
    connect(m_main_widget, SIGNAL(sigVisibleRangeChanged(sample_index_t,
            sample_index_t, sample_index_t)),
            this, SLOT(visibleRangeChanged(sample_index_t,
            sample_index_t, sample_index_t)) );

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

delegateCommand()

int Kwave::FileContext::delegateCommand ( const char *  plugin, Kwave::Parser &  parser, unsigned int  param_count  )

private

delegate a command to a plugin

Parameters

plugin	name of a plugin to delegate the command to
parser	the parser with the parts of the command
param_count	required number of parameters

Definition at line 296 of file FileContext.cpp.

References _, Kwave::Parser::command(), Kwave::Parser::count(), m_plugin_manager, and Kwave::Parser::remainingParams().

Referenced by executeCommand().

{
    if (!m_plugin_manager) return -1;
    if (parser.count() != param_count) return -EINVAL;

    QStringList params;
    params.append(parser.command());
    params.append(parser.remainingParams());
    int result = m_plugin_manager->setupPlugin(_(plugin), params);
    if (result > 0) result = 0;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

destroyed

void Kwave::FileContext::destroyed ( Kwave::FileContext *  context )

signal

emitted when the context is about to be destroyed (in the context of it's destructor)

enqueueCommand()

void Kwave::FileContext::enqueueCommand ( unsigned int  delay, const QString &  command  )

private

enqueues a command for later execution

Parameters

delay	milliseconds to wait before execution
command	the command to execute

Definition at line 795 of file FileContext.cpp.

References m_delayed_command_queue, m_delayed_command_timer, and use().

Referenced by executeCommand().

{
    use();

    m_delayed_command_queue.append(
        QPair<unsigned int, QString>(delay, command)
    );
    if (!m_delayed_command_timer.isActive())
        m_delayed_command_timer.start(delay);
}

Here is the call graph for this function:

Here is the caller graph for this function:

executeCommand

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

slot

Execute a Kwave text command

Parameters

command

a text command

Returns

zero if succeeded or negative error code if failed

Definition at line 312 of file FileContext.cpp.

References _, CASE_COMMAND, closeFile(), Kwave::Parser::command(), Kwave::Parser::commandList(), Kwave::Parser::count(), DBG, delegateCommand(), enqueueCommand(), Kwave::CommandHandler::executeCommand(), Kwave::Parser::firstParam(), Kwave::Parser::hasMultipleCommands(), Kwave::Logger::Info, loadBatch(), Kwave::Logger::log(), m_delayed_command_queue, m_main_widget, m_plugin_manager, m_top_widget, name, Kwave::Parser::nextParam(), Kwave::Parser::remainingParams(), revert(), saveFile(), and saveFileAs().

Referenced by createMainWidget(), Kwave::TopWidget::forwardCommand(), init(), Kwave::TopWidget::loadFile(), parseCommands(), and processDelayedCommand().

{
    Kwave::FileContext::UsageGuard _keep(this);

    int result = 0;
    bool use_recorder = true;
    QString command = line;

//     qDebug("Kwave::FileContext[%p]::executeCommand(%s)", this, DBG(command));

    Q_ASSERT(m_plugin_manager);
    Q_ASSERT(m_top_widget);
    if (!m_plugin_manager || !m_top_widget) return -ENOMEM;

    if (!command.length()) return 0; // empty line -> nothing to do
    if (command.trimmed().startsWith(_("#")))
        return 0; // only a comment

    // special case: if the command contains ";" it is a list of
    // commands -> macro !
    Kwave::Parser parse_list(command);
    if (parse_list.hasMultipleCommands()) {
        QStringList macro = parse_list.commandList();
        foreach (const QString &it, macro) {
            result = executeCommand(_("nomacro:") + it);
            Q_ASSERT(!result);
            if (result) {
                qWarning("macro execution of '%s' failed: %d",
                         DBG(it), result);
                return result; // macro failed :-(
            }

            // wait until the command has completed !
            m_plugin_manager->sync();
        }
        return result;
    }

    // check if the macro recorder has to be disabled for this command
    if (command.startsWith(_("nomacro:"))) {
        use_recorder = false;
        command = command.mid(QString(_("nomacro:")).length());
    }

    // expand variables
    if (command.contains(_("${"))) {
        // current language
        if (command.contains(_("${LANG}"))) {
            QLocale locale;
            if (!m_main_widget.isNull()) locale = m_main_widget->locale();
            QString lang = locale.name().split(_("-")).at(0);
            command.replace(_("${LANG}"), lang);
        }
    }

    // log all commands to the log file if enabled
    Kwave::Logger::log(this, Kwave::Logger::Info, _("CMD: ") + line);

    // parse one single command
    Kwave::Parser parser(command);
    QString cmd = parser.command();

    // exclude menu commands from the recorder
    if (cmd == _("menu")) use_recorder = false;

    // only record plugin:execute, not plugin without parameters
    if (cmd == _("plugin")) use_recorder = false;

    // let through all commands that handle zoom/view or playback like fwd/rew
    bool allow_always =
        (cmd == _("playback")) ||
        cmd.startsWith(_("view:")) ||
        cmd.startsWith(_("playback:")) ||
        cmd.startsWith(_("select_track:")) ||
        (cmd == _("close")) ||
        (cmd == _("quit")) ||
        (cmd == _("window:screenshot")) ||
        (cmd == _("window:sendkey"))
        ;

    // all others only if no plugin is currently running
    if (!allow_always && m_plugin_manager->onePluginRunning())
    {
        qWarning("FileContext::executeCommand('%s') - currently not possible, "
                 "a plugin is running :-(",
                 DBG(cmd));
        return -1;
    }

    if (use_recorder) {
        // append the command to the macro recorder
        // @TODO macro recording...
        qDebug("# %s ", DBG(command));
    }

    if ((result = m_top_widget->executeCommand(command)) != ENOSYS)
        return result;

    if (false) {
    CASE_COMMAND("close")
        result = closeFile() ? 0 : 1;
    CASE_COMMAND("delayed")
        if (parser.count() != 2)
            return -EINVAL;
        unsigned int delay         = parser.firstParam().toUInt();
        QString      delayed_cmd   = parser.nextParam();
        enqueueCommand(delay, delayed_cmd);
        result = 0;
    CASE_COMMAND("loadbatch")
        result = loadBatch(QUrl(parser.nextParam()));
    CASE_COMMAND("plugin")
        QString name(parser.firstParam());
        QStringList params(parser.remainingParams());
        qDebug("FileContext::executeCommand(): loading plugin '%s'", DBG(name));
        qDebug("FileContext::executeCommand(): with %d parameter(s)",
                params.count());
        result = m_plugin_manager->executePlugin(
            name, params.count() ? &params : Q_NULLPTR);
    CASE_COMMAND("plugin:execute")
        QString name(parser.firstParam());
        QStringList params(parser.remainingParams());
        result = m_plugin_manager->executePlugin(name, &params);
    CASE_COMMAND("plugin:setup")
        QString name(parser.firstParam());
        QStringList params(parser.remainingParams());
        result = m_plugin_manager->setupPlugin(name, params);
        if (result > 0) result = 0;
    CASE_COMMAND("revert")
        result = revert();
    CASE_COMMAND("save")
        result = saveFile();
    CASE_COMMAND("saveas")
        result = saveFileAs(parser.nextParam(), false);
    CASE_COMMAND("saveselect")
        result = saveFileAs(QString(), true);
    CASE_COMMAND("sync")
        while (!m_delayed_command_queue.isEmpty()) {
            qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
        }
        result = 0;
    CASE_COMMAND("window:click")
        result = delegateCommand("debug", parser, 3);
    CASE_COMMAND("window:close")
        result = delegateCommand("debug", parser, 1);
    CASE_COMMAND("window:mousemove")
        result = delegateCommand("debug", parser, 3);
    CASE_COMMAND("window:resize")
        result = delegateCommand("debug", parser, 3);
    CASE_COMMAND("window:sendkey")
        result = delegateCommand("debug", parser, 2);
    CASE_COMMAND("window:screenshot")
        result = delegateCommand("debug", parser, 2);
    } else {
        // pass the command to the layer below (main widget)
        Kwave::CommandHandler *layer_below = m_main_widget;
        result = (layer_below) ? layer_below->executeCommand(command) : -ENOSYS;
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

forwardZoomChanged

void Kwave::FileContext::forwardZoomChanged ( double  zoom )

privateslot

emits a sigZoomChanged(this, zoom) when the zoom has changed in the m_main_widget

Definition at line 474 of file FileContext.cpp.

References m_last_zoom, and sigZoomChanged().

Referenced by activated(), and createMainWidget().

{
    m_last_zoom = zoom;
    emit sigZoomChanged(this, zoom);
}

Here is the caller graph for this function:

init()

bool Kwave::FileContext::init

(

Kwave::TopWidget *

top_widget

)

initializes the instance

Parameters

top_widget

pointer to the toplevel widget

Returns

true if successful

Definition at line 160 of file FileContext.cpp.

References _, Kwave::connect(), Kwave::MessageBox::error(), executeCommand(), m_plugin_manager, m_signal_manager, m_top_widget, metaDataChanged(), modifiedChanged(), parseCommands(), selectionChanged(), setParent(), setUndoRedoInfo(), Kwave::Splash::showMessage(), sigMetaDataChanged(), sigModified(), sigUndoRedoInfo(), statusBarMessage(), and updatePlaybackPos().

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

{
    Kwave::FileContext::UsageGuard _keep(this);

    m_top_widget = top_widget;
    Q_ASSERT(m_top_widget);
    if (!m_top_widget) return false;

    m_signal_manager = new(std::nothrow)
        Kwave::SignalManager(m_top_widget);
    Q_ASSERT(m_signal_manager);
    if (!m_signal_manager) return false;

    m_plugin_manager = new(std::nothrow)
        Kwave::PluginManager(m_top_widget, *m_signal_manager);
    Q_ASSERT(m_plugin_manager);
    if (!m_plugin_manager) return false;

    // connect the signal manager
    connect(m_signal_manager, SIGNAL(sigMetaDataChanged(Kwave::MetaDataList)),
            this,             SLOT(metaDataChanged(Kwave::MetaDataList)));
    connect(&(m_signal_manager->selection()),
            SIGNAL(changed(sample_index_t,sample_index_t)),
            this,
            SLOT(selectionChanged(sample_index_t,sample_index_t)));
    connect(m_signal_manager, SIGNAL(sigUndoRedoInfo(const QString&,
                                                     const QString&)),
            this, SLOT(setUndoRedoInfo(QString,QString)));
    connect(m_signal_manager, SIGNAL(sigModified()),
            this,             SLOT(modifiedChanged()));

    // connect the plugin manager
    connect(m_plugin_manager, SIGNAL(sigCommand(QString)),
            this,             SLOT(executeCommand(QString)));

    // connect the playback controller
    connect(&(m_signal_manager->playbackController()),
            SIGNAL(sigPlaybackPos(sample_index_t)),
            this, SLOT(updatePlaybackPos(sample_index_t)));

    setParent(top_widget);

    Kwave::Splash::showMessage(i18n("Scanning plugins..."));
    m_plugin_manager->searchPluginModules();

    // load the menu from file
    QFile menufile(QStandardPaths::locate(
        QStandardPaths::GenericDataLocation,
        _("kwave/menus.config")
    ));
    menufile.open(QIODevice::ReadOnly);
    QTextStream stream(&menufile);
    Q_ASSERT(!stream.atEnd());
    if (!stream.atEnd()) parseCommands(stream);
    menufile.close();

    // now we are initialized, load all plugins
    Kwave::Splash::showMessage(i18n("Loading plugins..."));
    statusBarMessage(i18n("Loading plugins..."), 0);
    if (!m_plugin_manager->loadAllPlugins()) {
        statusBarMessage(i18n("Failed"), 1000);
        QApplication::restoreOverrideCursor();
        Kwave::MessageBox::error(top_widget,
            i18n("Kwave has not been properly installed. "\
                 "No plugins found!")
        );
        QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
        return false;
    }
    statusBarMessage(i18n("Ready"), 1000);

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

instanceNr()

int Kwave::FileContext::instanceNr ( ) const

inline

returns the instance of the loaded file or -1

Definition at line 136 of file FileContext.h.

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

{ return m_instance_nr; }

Here is the caller graph for this function:

isActive()

bool Kwave::FileContext::isActive ( ) const

inline

Returns whether this context is active or not.

Return values

true	if the context is active
false	if the context is inactive

Definition at line 124 of file FileContext.h.

Referenced by metaDataChanged(), modifiedChanged(), Kwave::MainWidget::resizeEvent(), selectionChanged(), setUndoRedoInfo(), statusBarMessage(), and visibleRangeChanged().

{ return m_active; }

Here is the caller graph for this function:

isEmpty()

bool Kwave::FileContext::isEmpty ( ) const

inline

Returns whether this context is empty (has a main widget) or not.

Return values

true	if the context is empty
false	if the context has a main widget

Definition at line 117 of file FileContext.h.

Referenced by Kwave::TopWidget::newWindow(), and Kwave::App::switchGuiType().

{ return m_main_widget.isNull(); }

Here is the caller graph for this function:

isInUse()

bool Kwave::FileContext::isInUse

(

)

const

Returns true it this context has a signal (file is loaded) or the context is executing a script

Definition at line 823 of file FileContext.cpp.

References m_signal_manager, and m_use_count.

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

{
    if (m_use_count >= 2) return true;
    return (m_signal_manager && !m_signal_manager->isEmpty());
}

Here is the caller graph for this function:

loadBatch()

int Kwave::FileContext::loadBatch

(

const QUrl &

url

)

Loads a batch file into memory, parses and executes all commands in it.

Parameters

url	URL of the macro (batch file) to be loaded

Definition at line 863 of file FileContext.cpp.

References parseCommands().

Referenced by executeCommand(), Kwave::TopWidget::loadFile(), and Kwave::MainWidget::loadLabels().

{
    Kwave::FileContext::UsageGuard _keep(this);

    // open the URL, read-only mode is enough
    QFile file(url.path());
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning("unable to open source in read-only mode!");
        return -EIO;
    }

    // use a text stream for parsing the commands
    QTextStream stream(&file);
    int result = parseCommands(stream);
    file.close();

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mainWidget()

QWidget * Kwave::FileContext::mainWidget

(

)

const

returns a pointer to the main widget of this context

Definition at line 271 of file FileContext.cpp.

References m_main_widget.

Referenced by Kwave::TopWidget::init(), Kwave::TopWidget::insertContext(), and parseCommands().

{
    return static_cast<QWidget *>(m_main_widget);
}

Here is the caller graph for this function:

metaDataChanged

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

privateslot

Called when the meta data of the current signal has changed

Parameters

meta_data

the new meta data, after the change

Definition at line 521 of file FileContext.cpp.

References Kwave::App::GUI_SDI, Kwave::App::guiType(), isActive(), m_application, m_instance_nr, m_main_widget, name, Kwave::App::openFiles(), sigMetaDataChanged(), signalName(), and windowCaption().

Referenced by init().

{
    // find out the instance ID
    if (m_instance_nr == -1) {
        // build a list of all currently open files/instances (including this)
        QList<Kwave::App::FileAndInstance> files = m_application.openFiles();

        // filter out all instances of our file name
        QString our_name = signalName();
        QList<int> existing_instances;
        foreach (const Kwave::App::FileAndInstance &it, files) {
            const QString &name = it.first;
            int            inst = it.second;
            if (name == our_name) existing_instances.append(inst);
        }

        // remove our own entry
        if (existing_instances.contains(m_instance_nr))
            existing_instances.removeOne(m_instance_nr);

        // find an empty slot
        if (!existing_instances.isEmpty())
            while (existing_instances.contains(m_instance_nr))
                m_instance_nr = (m_instance_nr != -1) ? (m_instance_nr + 1) : 2;
    }

    if (isActive()) {
        // we are active -> emit the meta data immediately
        emit sigMetaDataChanged(meta_data);
    } // else: we are inactive -> emit the meta data later, when activated

    // update the caption of the sub window
    if (m_main_widget && (m_application.guiType() != Kwave::App::GUI_SDI))
        m_main_widget->setWindowTitle(windowCaption(true));
}

Here is the call graph for this function:

Here is the caller graph for this function:

modifiedChanged

void Kwave::FileContext::modifiedChanged ( )

privateslot

called if the signal now or no longer is modified

Definition at line 592 of file FileContext.cpp.

References Kwave::App::GUI_SDI, Kwave::App::guiType(), isActive(), m_application, m_main_widget, sigModified(), and windowCaption().

Referenced by init().

{
    if (isActive()) {
        // we are active -> emit the modified state immediately
        emit sigModified();
    } // else: we are inactive -> emit the modified state later, when activated

    // update the caption of our main widget
    if (m_main_widget && (m_application.guiType() != Kwave::App::GUI_SDI))
        m_main_widget->setWindowTitle(windowCaption(true));
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseCommands()

int Kwave::FileContext::parseCommands ( QTextStream &  stream )

private

Parses a text stream line by line and executes each line as a command until all commands are done or the first one fails.

Parameters

stream

a QTextStream to read from

Returns

zero if successful, non-zero error code if a command failed

Definition at line 671 of file FileContext.cpp.

References _, CASE_COMMAND, Kwave::Parser::command(), DBG, executeCommand(), Kwave::Parser::firstParam(), Kwave::label_t::hits, m_plugin_manager, m_top_widget, mainWidget(), name, Kwave::label_t::pos, and Kwave::MessageBox::questionYesNo().

Referenced by init(), and loadBatch().

{
    Kwave::FileContext::UsageGuard _keep(this);

    int result = 0;
    QMap<QString, label_t> labels;

    // set hourglass cursor
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

    QString label; // label, jump target of a "GOTO"
    while (!stream.atEnd() && !result) {
        QString line = stream.readLine().simplified();
        if (line.startsWith(_("#"))) continue; // skip comments
        if (!line.length()) continue;          // skip empty lines

        if (line.endsWith(QLatin1Char(':'))) {
            // this line seems to be a "label"
            QString name = line.left(line.length() - 1).simplified();
            if (!labels.contains(name)) {
                // qDebug("new label '%s' at %llu", DBG(name), stream.pos());
                label_t label_pos;
                label_pos.pos  = stream.pos();
                label_pos.hits = 0;
                labels[name] = label_pos;
            }

            // special handling for a label at the end of the file
            if (label.length() && (label == name)) {
                // label found
                label = QString();
            }
            continue;
        }

        Kwave::Parser parser(line);

        // the "GOTO" command
        if ( !label.length() &&
            (line.split(QLatin1Char(' ')).at(0) == _("GOTO")) ) {
            label = line.split(QLatin1Char(' ')).at(1).simplified();
        }

        // jump to a label, scan/seek mode
        if (label.length()) {
            if (labels.contains(label)) {
                labels[label].hits++;
                qDebug(">>> GOTO '%s' @ offset %llu (pass #%d)", DBG(label),
                       labels[label].pos,
                       labels[label].hits
                    );
                stream.seek(labels[label].pos);

                // reset the label to search for
                label = QString();
            }
            // else: maybe the label will follow somewhere below,
            //       scan forward...
            continue;
        }

        // synchronize before the command
        if (m_plugin_manager)
            m_plugin_manager->sync();

        // the "msgbox" command (useful for debugging)
        if (false) { ;
        CASE_COMMAND("msgbox")
            QApplication::restoreOverrideCursor();
            result = (Kwave::MessageBox::questionYesNo(mainWidget(),
                parser.firstParam()) == KMessageBox::Yes) ? 0 : 1;
            QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
            continue;
        }

        // prevent this command from being re-added to the macro recorder
        if (!line.startsWith(_("nomacro:"), Qt::CaseInsensitive))
            line.prepend(_("nomacro:"));

        // process the command in the current context
        // NOTE: this could theoretically also be a command that modifies
        //       or even deletes the current context!
        result = EAGAIN;
        Kwave::FileContext *current_ctx = (m_top_widget) ?
            m_top_widget->currentContext() : Q_NULLPTR;
        if (current_ctx && (current_ctx != this))
            result = m_top_widget->forwardCommand(line);

        // If the call returned with EAGAIN, then the context in duty is
        // different from this instance but not yet completely set up.
        // In that case this context is still responsible for executing the
        // current command.
        if (result == EAGAIN)
            result = executeCommand(line);

        if (result)
            qDebug(">>> '%s' - result=%d", DBG(line), result);

        qApp->processEvents(QEventLoop::ExcludeUserInputEvents);

        // synchronize after the command
        if (m_plugin_manager)
            m_plugin_manager->sync();

        // special handling of the "quit" command
        if (parser.command() == _("quit")) {
            result = ECANCELED;
            break;
        }
    }

    if (label.length()) {
        // oops, if we get here then we have searched for a non-exising label
        qWarning("label '%s' not found", DBG(label));
        result = -ENOENT;
    }

    // remove hourglass
    QApplication::restoreOverrideCursor();

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pluginManager()

Kwave::PluginManager * Kwave::FileContext::pluginManager

(

)

const

returns a pointer to the plugin manager of this context

Definition at line 284 of file FileContext.cpp.

References m_plugin_manager.

Referenced by Kwave::TopWidget::forwardCommand(), Kwave::MainWidget::MainWidget(), and Kwave::MainWidget::~MainWidget().

{
    return m_plugin_manager;
}

Here is the caller graph for this function:

processDelayedCommand

void Kwave::FileContext::processDelayedCommand ( )

privateslot

process the next delayed command from m_delayed_command_queue

Definition at line 808 of file FileContext.cpp.

References executeCommand(), m_delayed_command_queue, m_delayed_command_timer, and release().

Referenced by FileContext().

{
    if (m_delayed_command_queue.isEmpty()) return;

    QPair<unsigned int, QString> current = m_delayed_command_queue.takeFirst();
    executeCommand(current.second);
    if (m_delayed_command_queue.isEmpty()) return;

    QPair<unsigned int, QString> next = m_delayed_command_queue.first();
    m_delayed_command_timer.start(next.first);

    release();
}

Here is the call graph for this function:

Here is the caller graph for this function:

release()

void Kwave::FileContext::release ( )

protected

decrements the usage count of this context, and if it has reached zero this instance will be deleted (delayed)

Definition at line 117 of file FileContext.cpp.

References m_use_count.

Referenced by Kwave::TopWidget::detachAllContexts(), Kwave::TopWidget::insertContext(), Kwave::TopWidget::newWindow(), processDelayedCommand(), Kwave::TopWidget::subWindowDeleted(), and Kwave::App::switchGuiType().

{
    Q_ASSERT(int(m_use_count) > 0);
    if (m_use_count.deref() == false) {
        disconnect();
        deleteLater();
    }
}

Here is the caller graph for this function:

revert()

int Kwave::FileContext::revert ( )

private

Discards all changes to the current file and loads it again.

Returns

zero if succeeded or error code

Definition at line 883 of file FileContext.cpp.

References m_signal_manager, m_top_widget, signalName(), and Kwave::MessageBox::warningContinueCancel().

Referenced by executeCommand().

{
    Kwave::FileContext::UsageGuard _keep(this);

    QUrl url(signalName());
    if (!url.isValid() || !m_signal_manager) return -EINVAL;

    if (m_signal_manager->isModified()) {
        int res =  Kwave::MessageBox::warningContinueCancel(m_top_widget,
            i18n("This file has been modified, changes will be lost.\n"
                 "Do you want to continue?"));
        if (res == KMessageBox::Cancel) return ECANCELED;
    }

    return m_signal_manager->loadFile(url);
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveFile()

int Kwave::FileContext::saveFile

(

)

Saves the current file.

Returns

zero if succeeded, non-zero if failed

Definition at line 901 of file FileContext.cpp.

References m_signal_manager, NEW_FILENAME, saveFileAs(), and signalName().

Referenced by closeFile(), and executeCommand().

{
    if (!m_signal_manager) return -EINVAL;

    int res = 0;

    if (signalName() != NEW_FILENAME) {
        QUrl url;
        url = QUrl(signalName());
        res = m_signal_manager->save(url, false);

        // if saving in current format is not possible (no encoder),
        // then try to "save/as" instead...
        if (res == -EINVAL) res = saveFileAs(QString(), false);
    } else res = saveFileAs(QString(), false);

    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveFileAs()

int Kwave::FileContext::saveFileAs	(	const QString &	filename,
		bool	selection = false
	)

Opens a dialog for saving the current file.

Parameters

filename	the name of the new file or empty string to open the File/SaveAs dialog
selection	if set to true, only the current selection will be saved

Returns

zero if succeeded, non-zero if failed

Definition at line 921 of file FileContext.cpp.

References _, Kwave::App::addRecentFile(), DBG, Kwave::CodecManager::encoder(), Kwave::CodecManager::encodingFilter(), Kwave::CodecBase::extensions(), Kwave::INF_FILENAME, Kwave::INF_MIMETYPE, m_application, m_plugin_manager, m_signal_manager, m_top_widget, Kwave::CodecManager::mimeTypeOf(), name, Kwave::FileDialog::SaveFile, Kwave::FileDialog::selectedUrl(), Kwave::FileInfo::set(), signalName(), and Kwave::MessageBox::warningYesNo().

Referenced by executeCommand(), and saveFile().

{
    if (!m_signal_manager) return -EINVAL;

    QString name = filename;
    QUrl url;
    int res = 0;

    if (name.length()) {
        /* name given -> take it */
        url = QUrl(name);
    } else {
        /*
         * no name given -> show the File/SaveAs dialog...
         */
        QUrl current_url;
        current_url = QUrl(signalName());

        QString what  = Kwave::CodecManager::mimeTypeOf(current_url);
        Kwave::Encoder *encoder = Kwave::CodecManager::encoder(what);
        QString extension; // = "*.wav";
        if (!encoder) {
            // no extension selected yet, use mime type from file info
            QString mime_type = Kwave::FileInfo(
                m_signal_manager->metaData()).get(
                    Kwave::INF_MIMETYPE).toString();
            encoder = Kwave::CodecManager::encoder(mime_type);
            if (encoder) {
                QStringList extensions = encoder->extensions(mime_type);
                if (!extensions.isEmpty()) {
                    QString ext = extensions.first().split(_(" ")).first();
                    if (ext.length()) {
                        extension = ext;
                        QString new_filename = current_url.fileName();
                        new_filename += extension.mid(1); // remove the "*"
                        current_url = current_url.adjusted(QUrl::RemoveFilename);
                        current_url.setPath(current_url.path() + new_filename);
                    }
                }
            }
        }

        QString filter = Kwave::CodecManager::encodingFilter();
        QPointer<Kwave::FileDialog> dlg = new(std::nothrow)Kwave::FileDialog(
            _("kfiledialog:///kwave_save_as"),
            Kwave::FileDialog::SaveFile,
            filter, m_top_widget, current_url, extension
        );
        if (!dlg) return 0;
        dlg->setWindowTitle(i18n("Save As"));
        if (dlg->exec() != QDialog::Accepted) {
            delete dlg;
            return -1;
        }

        url = dlg->selectedUrl();
        if (url.isEmpty()) {
            delete dlg;
            return 0;
        }

        QString new_name = url.path();
        QFileInfo path(new_name);

        // add the correct extension if necessary
        if (!path.suffix().length()) {
            QString ext = dlg->selectedExtension();
            QStringList extensions = ext.split(_(" "));
            ext = extensions.first();
            new_name += ext.mid(1);
            path = new_name;
            url.setPath(new_name);
        }

        delete dlg;
    }

    // check if the file exists and ask before overwriting it
    // if it is not the old filename
    name = url.path();
    if ((url.toDisplayString() != QUrl(signalName()).toDisplayString()) &&
        (QFileInfo(name).exists()))
    {
        if (Kwave::MessageBox::warningYesNo(m_top_widget,
            i18n("The file '%1' already exists.\n"
                 "Do you really want to overwrite it?", name)) !=
                 KMessageBox::Yes)
        {
            return -1;
        }
    }

    // maybe we now have a new mime type
    QString previous_mimetype_name =
        Kwave::FileInfo(m_signal_manager->metaData()).get(
            Kwave::INF_MIMETYPE).toString();

    QString new_mimetype_name = Kwave::CodecManager::mimeTypeOf(url);

    if (new_mimetype_name != previous_mimetype_name) {
        // saving to a different mime type
        // now we have to do as if the mime type and file name
        // has already been selected to satisfy the fileinfo
        // plugin
        qDebug("TopWidget::saveAs(%s) - [%s] (previous:'%s')",
            DBG(url.toDisplayString()), DBG(new_mimetype_name),
            DBG(previous_mimetype_name) );

        // set the new mimetype
        Kwave::FileInfo info(m_signal_manager->metaData());
        info.set(Kwave::INF_MIMETYPE, new_mimetype_name);

        // set the new filename
        info.set(Kwave::INF_FILENAME, url.toDisplayString());
        m_signal_manager->setFileInfo(info, false);

        // now call the fileinfo plugin with the new filename and
        // mimetype
        res = (m_plugin_manager) ?
               m_plugin_manager->setupPlugin(_("fileinfo"), QStringList())
               : -1;

        // restore the mime type and the filename
        info = Kwave::FileInfo(m_signal_manager->metaData());
        info.set(Kwave::INF_MIMETYPE, previous_mimetype_name);
        info.set(Kwave::INF_FILENAME, url.toDisplayString());
        m_signal_manager->setFileInfo(info, false);
    }

    // now we have a file name -> do the "save" operation
    if (!res) res = m_signal_manager->save(url, selection);

    // if saving was successful, add the file to the list of recent files
    if (!res) m_application.addRecentFile(signalName());

    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

selectionChanged

void Kwave::FileContext::selectionChanged ( sample_index_t  offset, sample_index_t  length  )

privateslot

Called when the number of selected samples has changed.

Parameters

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

Definition at line 558 of file FileContext.cpp.

References isActive(), and sigSelectionChanged().

Referenced by init().

{
    if (isActive()) {
        // we are active -> emit the selection change immediately
        emit sigSelectionChanged(offset, length);
    } // else: we are inactive -> not of interest / ignore
}

Here is the call graph for this function:

Here is the caller graph for this function:

setParent()

void Kwave::FileContext::setParent

(

Kwave::TopWidget *

top_widget

)

migrate this context to a different toplevel widget

Parameters

top_widget

pointer to the new toplevel widget

Definition at line 235 of file FileContext.cpp.

References Kwave::connect(), contextSwitched(), m_active, m_main_widget, m_plugin_manager, m_signal_manager, and m_top_widget.

Referenced by Kwave::TopWidget::detachAllContexts(), init(), Kwave::TopWidget::insertContext(), and Kwave::App::switchGuiType().

{
    if (m_top_widget) {
        Kwave::TopWidget *old = m_top_widget;

        // disconnect all old signal/slot relationships
        disconnect(m_plugin_manager, SIGNAL(sigProgress(QString)),
                   old,              SLOT(showInSplashSreen(QString)));
        disconnect(old,  SIGNAL(sigFileContextSwitched(Kwave::FileContext*)),
                   this, SLOT(contextSwitched(Kwave::FileContext*)));

        if (m_signal_manager) m_signal_manager->setParentWidget(Q_NULLPTR);
        if (m_plugin_manager) m_plugin_manager->setParentWidget(Q_NULLPTR);
        if (m_main_widget)    m_main_widget->setParent(Q_NULLPTR);

        m_active = false;
    }

    // set the new top widget
    m_top_widget = top_widget;

    if (m_top_widget) {
        QWidget *top = m_top_widget;

        connect(top,  SIGNAL(sigFileContextSwitched(Kwave::FileContext*)),
                this, SLOT(contextSwitched(Kwave::FileContext*)));
        connect(m_plugin_manager, SIGNAL(sigProgress(QString)),
                top,              SLOT(showInSplashSreen(QString)));

        if (m_signal_manager) m_signal_manager->setParentWidget(m_top_widget);
        if (m_plugin_manager) m_plugin_manager->setParentWidget(m_top_widget);
        if (m_main_widget)    m_main_widget->setParent(m_top_widget);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setUndoRedoInfo

void Kwave::FileContext::setUndoRedoInfo ( const QString &  undo, const QString &  redo  )

privateslot

Called when the undo or redo action has changed.

Parameters

undo	description of the last undo action
redo	description of the last redo action

Definition at line 568 of file FileContext.cpp.

References isActive(), m_last_redo, m_last_undo, and sigUndoRedoInfo().

Referenced by init().

{
    m_last_undo = undo;
    m_last_redo = redo;

    if (isActive()) {
        // we are active -> emit the undo/redo info immediately
        emit sigUndoRedoInfo(undo, redo);
    } // else: we are inactive -> emit the undo/redo info later, when activated
}

Here is the call graph for this function:

Here is the caller graph for this function:

sigMetaDataChanged

void Kwave::FileContext::sigMetaDataChanged ( Kwave::MetaDataList  meta_data )

signal

emitted when the meta data of the current signal has changed

Parameters

meta_data

the new meta data, after the change

Referenced by activated(), init(), and metaDataChanged().

Here is the caller graph for this function:

sigModified

void Kwave::FileContext::sigModified ( )

signal

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

Referenced by activated(), init(), and modifiedChanged().

Here is the caller graph for this function:

signalManager()

Kwave::SignalManager * Kwave::FileContext::signalManager

(

)

const

returns a pointer to the signal manager of this context

Definition at line 277 of file FileContext.cpp.

References m_signal_manager.

Referenced by Kwave::MainWidget::addLabel(), Kwave::PlayerToolBar::contextSwitched(), Kwave::MainWidget::dropEvent(), Kwave::MainWidget::executeCommand(), Kwave::MainWidget::fixZoomAndOffset(), Kwave::MainWidget::fullZoom(), Kwave::MainWidget::horizontalScrollBarMoved(), Kwave::MainWidget::labelProperties(), Kwave::TopWidget::loadFile(), Kwave::MainWidget::loadLabels(), Kwave::MainWidget::MainWidget(), Kwave::MainWidget::ms2samples(), Kwave::TopWidget::newSignal(), Kwave::TopWidget::newWindow(), Kwave::MainWidget::refreshHorizontalScrollBar(), Kwave::MainWidget::saveLabels(), Kwave::TopWidget::selectionChanged(), Kwave::ZoomToolBar::selectZoom(), Kwave::ZoomToolBar::setZoomInfo(), Kwave::MainWidget::slotTrackInserted(), Kwave::TopWidget::updateMenu(), Kwave::ZoomToolBar::updateToolbar(), Kwave::TopWidget::updateToolbar(), Kwave::MainWidget::updateViewRange(), and Kwave::MainWidget::zoomSelection().

{
    Q_ASSERT(m_signal_manager);
    return m_signal_manager;
}

Here is the caller graph for this function:

signalName()

QString Kwave::FileContext::signalName

(

)

const

returns the name of the signal

Definition at line 830 of file FileContext.cpp.

References m_signal_manager.

Referenced by metaDataChanged(), Kwave::TopWidget::openFiles(), revert(), saveFile(), saveFileAs(), Kwave::MainWidget::saveLabels(), Kwave::TopWidget::updateMenu(), and windowCaption().

{
    return (m_signal_manager) ? m_signal_manager->signalName() : QString();
}

Here is the caller graph for this function:

sigSelectionChanged

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

signal

emits a change in the selected range.

Parameters

offset	index of the first selected items
length	number of selected items

Referenced by selectionChanged().

Here is the caller graph for this function:

sigStatusBarMessage

void Kwave::FileContext::sigStatusBarMessage ( const QString &  message, unsigned int  ms  )

signal

emitted when there is a status bar message to show

Parameters

message	the status bar message, already localized
ms	the time in milliseconds to show the message

Referenced by activated(), and statusBarMessage().

Here is the caller graph for this function:

sigUndoRedoInfo

void Kwave::FileContext::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.

Referenced by activated(), init(), and setUndoRedoInfo().

Here is the caller graph for this function:

sigVisibleRangeChanged

void Kwave::FileContext::sigVisibleRangeChanged ( sample_index_t  offset, sample_index_t  visible, sample_index_t  total  )

signal

emitted when the visible range has changed

Referenced by activated(), createMainWidget(), and visibleRangeChanged().

Here is the caller graph for this function:

sigZoomChanged

void Kwave::FileContext::sigZoomChanged ( Kwave::FileContext *  context, double  zoom  )

signal

emitted when the zoom factor of the corresponding main widget has changed

Parameters

context	contains "this"
zoom	new zoom factor

Referenced by createMainWidget(), and forwardZoomChanged().

Here is the caller graph for this function:

statusBarMessage()

void Kwave::FileContext::statusBarMessage ( const QString &  msg, unsigned int  ms  )

private

Show a message in the status bar

Parameters

msg	the status bar message, already localized
ms	the time in milliseconds to show the message

Definition at line 481 of file FileContext.cpp.

References isActive(), m_last_status_message_ms, m_last_status_message_text, m_last_status_message_timer, and sigStatusBarMessage().

Referenced by init(), and updatePlaybackPos().

{
    m_last_status_message_text = msg;
    m_last_status_message_ms   = ms;
    if (ms)
        m_last_status_message_timer.start();
    else
        m_last_status_message_timer.invalidate();

    if (isActive())
        emit sigStatusBarMessage(msg, ms);
}

Here is the call graph for this function:

Here is the caller graph for this function:

updatePlaybackPos

void Kwave::FileContext::updatePlaybackPos ( sample_index_t  offset )

privateslot

Called when the playback position has changed

Parameters

offset

the current playback position [samples]

Definition at line 495 of file FileContext.cpp.

References m_last_playback_pos, m_main_widget, m_plugin_manager, m_signal_manager, Kwave::ms2string(), Kwave::samples2string(), Kwave::Zoomable::scrollTo(), statusBarMessage(), and zoomable().

Referenced by activated(), and init().

{
    if (!m_plugin_manager) return;
    if (!m_main_widget) return;

    bool playing = m_signal_manager->playbackController().running();
    if (!playing) return;

    QString txt;
    double rate = m_plugin_manager->signalRate();
    if (rate > 0) {
        double ms = static_cast<double>(offset) * 1E3 / rate;
        txt = i18n("Playback: %1", Kwave::ms2string(ms));
    } else {
        txt = i18n("Playback: %1 samples", Kwave::samples2string(offset));
    }

    statusBarMessage(txt, 2000);

    // make sure that the current playback position is visible
    m_last_playback_pos = offset;
    Kwave::Zoomable *z = zoomable();
    if (z) z->scrollTo(offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

use()

void Kwave::FileContext::use ( )

protected

increments the usage count of this context, prevents it from being deleted

Definition at line 110 of file FileContext.cpp.

References m_use_count.

Referenced by enqueueCommand().

{
    Q_ASSERT(int(m_use_count) > 0);
    m_use_count.ref();
}

Here is the caller graph for this function:

visibleRangeChanged

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

privateslot

Called 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 581 of file FileContext.cpp.

References isActive(), and sigVisibleRangeChanged().

Referenced by createMainWidget().

{
    if (isActive()) {
        // we are active -> emit the view info immediately
        emit sigVisibleRangeChanged(offset, visible, total);
    } // else: we are inactive -> emit the view info later, when activated
}

Here is the call graph for this function:

Here is the caller graph for this function:

windowCaption()

QString Kwave::FileContext::windowCaption

(

bool

with_modified

)

const

returns a string suitable as window caption

Parameters

with_modified

if true, include the "modified" state

Definition at line 836 of file FileContext.cpp.

References Kwave::App::GUI_SDI, Kwave::App::guiType(), m_application, m_instance_nr, m_signal_manager, name, and signalName().

Referenced by Kwave::TopWidget::executeCommand(), Kwave::TopWidget::insertContext(), metaDataChanged(), modifiedChanged(), Kwave::TopWidget::updateCaption(), and Kwave::TopWidget::updateMenu().

{
    QString name = signalName();

    // shortcut if no file loaded
    if (!name.length()) return QString();

    // if not in SDI mode we have to take care of multiple instances on our
    // own and append a " <n>" manually !
    if (m_application.guiType() != Kwave::App::GUI_SDI)
        if (m_instance_nr != -1)
            name = i18nc(
                "for window title: "
                "%1 = Name of the file, "
                "%2 = Instance number when opened multiple times",
                "%1 <%2>", name, m_instance_nr);

    if (with_modified) {
        bool modified = (m_signal_manager) ?
            m_signal_manager->isModified() : false;
        if (modified)
            return i18nc("%1 = Path to modified file", "* %1 (modified)", name);
    }
        return name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zoomable()

Kwave::Zoomable * Kwave::FileContext::zoomable

(

)

const

Returns a pointer to a GUI element that receives zoom info (the MainWidget)

Definition at line 290 of file FileContext.cpp.

References m_main_widget.

Referenced by Kwave::ZoomToolBar::selectZoom(), Kwave::ZoomToolBar::setZoomInfo(), and updatePlaybackPos().

{
    return m_main_widget;
}

Here is the caller graph for this function:

Friends And Related Function Documentation

App

friend class App

friend

Definition at line 177 of file FileContext.h.

TopWidget

friend class TopWidget

friend

Definition at line 178 of file FileContext.h.

UsageGuard

friend class UsageGuard

friend

Definition at line 179 of file FileContext.h.

Member Data Documentation

m_active

bool Kwave::FileContext::m_active

private

if true, this context is active, otherwise it is inactive

Definition at line 407 of file FileContext.h.

Referenced by contextSwitched(), and setParent().

m_application

Kwave::App& Kwave::FileContext::m_application

private

reference to the global Kwave application object

Definition at line 392 of file FileContext.h.

Referenced by closeFile(), metaDataChanged(), modifiedChanged(), saveFileAs(), and windowCaption().

m_delayed_command_queue

QList< QPair<unsigned int, QString> > Kwave::FileContext::m_delayed_command_queue

private

queue for delayed execution of commands

Definition at line 437 of file FileContext.h.

Referenced by enqueueCommand(), executeCommand(), and processDelayedCommand().

m_delayed_command_timer

QTimer Kwave::FileContext::m_delayed_command_timer

private

timer for delayed commands

Definition at line 434 of file FileContext.h.

Referenced by enqueueCommand(), FileContext(), and processDelayedCommand().

m_instance_nr

int Kwave::FileContext::m_instance_nr

private

instance of the loaded file or -1

Definition at line 431 of file FileContext.h.

Referenced by metaDataChanged(), and windowCaption().

m_last_playback_pos

sample_index_t Kwave::FileContext::m_last_playback_pos

private

last playback position, only valid if playback is running

Definition at line 413 of file FileContext.h.

Referenced by activated(), and updatePlaybackPos().

m_last_redo

QString Kwave::FileContext::m_last_redo

private

name of the last redo action

Definition at line 428 of file FileContext.h.

Referenced by activated(), and setUndoRedoInfo().

m_last_status_message_ms

unsigned int Kwave::FileContext::m_last_status_message_ms

private

number of milliseconds the status message should be shown

Definition at line 422 of file FileContext.h.

Referenced by activated(), and statusBarMessage().

m_last_status_message_text

QString Kwave::FileContext::m_last_status_message_text

private

last status bar message

Definition at line 416 of file FileContext.h.

Referenced by activated(), and statusBarMessage().

m_last_status_message_timer

QElapsedTimer Kwave::FileContext::m_last_status_message_timer

private

time when the last status message has been shown

Definition at line 419 of file FileContext.h.

Referenced by activated(), and statusBarMessage().

m_last_undo

QString Kwave::FileContext::m_last_undo

private

name of the last undo action

Definition at line 425 of file FileContext.h.

Referenced by activated(), and setUndoRedoInfo().

m_last_zoom

double Kwave::FileContext::m_last_zoom

private

last zoom factor

Definition at line 410 of file FileContext.h.

Referenced by activated(), and forwardZoomChanged().

m_main_widget

QPointer<Kwave::MainWidget> Kwave::FileContext::m_main_widget

private

instance of our main widget

Definition at line 398 of file FileContext.h.

Referenced by activated(), closeFile(), createMainWidget(), executeCommand(), mainWidget(), metaDataChanged(), modifiedChanged(), setParent(), updatePlaybackPos(), zoomable(), and ~FileContext().

m_plugin_manager

QPointer<Kwave::PluginManager> Kwave::FileContext::m_plugin_manager

private

instance of our plugin manager

Definition at line 404 of file FileContext.h.

Referenced by activated(), closeFile(), delegateCommand(), executeCommand(), init(), parseCommands(), pluginManager(), saveFileAs(), setParent(), updatePlaybackPos(), and ~FileContext().

m_signal_manager

QPointer<Kwave::SignalManager> Kwave::FileContext::m_signal_manager

private

instance of our signal manager

Definition at line 401 of file FileContext.h.

Referenced by activated(), closeFile(), createMainWidget(), init(), isInUse(), revert(), saveFile(), saveFileAs(), setParent(), signalManager(), signalName(), updatePlaybackPos(), windowCaption(), and ~FileContext().

m_top_widget

QPointer<Kwave::TopWidget> Kwave::FileContext::m_top_widget

private

instance of our toplevel window

Definition at line 395 of file FileContext.h.

Referenced by closeFile(), createMainWidget(), executeCommand(), init(), parseCommands(), revert(), saveFileAs(), setParent(), and ~FileContext().

m_use_count

QAtomicInt Kwave::FileContext::m_use_count

private

usage counter [0...n]

Definition at line 389 of file FileContext.h.

Referenced by isInUse(), release(), and use().

---

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

• kwave/FileContext.h
• kwave/FileContext.cpp