Kwave::PluginManager Class Reference

#include <PluginManager.h>

Inheritance diagram for Kwave::PluginManager:

Collaboration diagram for Kwave::PluginManager:

Classes
struct	PluginModule

Public Slots
void	signalClosed ()
void	setSignalName (const QString &name)

Signals
void	sigCommand (const QString &command)
void	sigClosed ()
void	sigSignalNameChanged (const QString &name)
void	sigProgress (const QString &message)

Public Member Functions
	PluginManager (QWidget *parent, Kwave::SignalManager &signal_manager)
virtual	~PluginManager ()
bool	loadAllPlugins ()
void	stopAllPlugins ()
int	executePlugin (const QString &name, QStringList *params)
bool	canClose ()
bool	onePluginRunning ()
void	sync ()
int	setupPlugin (const QString &name, const QStringList &params)
QStringList	defaultParams (const QString &name)
sample_index_t	signalLength ()
double	signalRate ()
sample_index_t	selectionStart ()
sample_index_t	selectionEnd ()
void	selectRange (sample_index_t offset, sample_index_t length)
Kwave::SampleSink *	openMultiTrackPlayback (unsigned int tracks, const Kwave::PlayBackParam *playback_params=Q_NULLPTR)
Kwave::PlaybackController &	playbackController ()
void	setParentWidget (QWidget *new_parent)
QPointer< QWidget >	parentWidget ()
Kwave::SignalManager &	signalManager ()
void	insertView (Kwave::SignalView *view, QWidget *controls)
void	registerViewManager (Kwave::ViewManager *view_manager)
void	enqueueCommand (const QString &command)
void	searchPluginModules ()
const QList< PluginModule >	pluginInfoList () const
void	migratePluginToActiveContext (Kwave::Plugin *plugin)
void	setActive ()

Private Types
typedef QPointer< Kwave::Plugin >	KwavePluginPointer
typedef QList< KwavePluginPointer >	PluginList
typedef QMutableListIterator< KwavePluginPointer >	PluginListMutableIterator
typedef QListIterator< KwavePluginPointer >	PluginListIterator

Private Slots
void	pluginClosed (Kwave::Plugin *p)
void	pluginStarted (Kwave::Plugin *p)
void	pluginDone (Kwave::Plugin *p)

Private Member Functions
Kwave::Plugin *	createPluginInstance (const QString &name)
void	savePluginDefaults (const QString &name, QStringList &params)
void	connectPlugin (Kwave::Plugin *plugin)
void	disconnectPlugin (Kwave::Plugin *plugin)

Private Attributes
PluginList	m_plugin_instances
PluginList	m_running_plugins
QPointer< QWidget >	m_parent_widget
Kwave::SignalManager &	m_signal_manager
ViewManager *	m_view_manager

Static Private Attributes
static Kwave::PluginManager *	m_active_instance = Q_NULLPTR
static QMap< QString, PluginModule >	m_plugin_modules

Detailed Description

Manages the loading, initializing, starting, running and closing of the plugins of kwave. Each instance of a TopWidget creates a new instance of the PluginManager to be independent from other toplevel widgets.

Definition at line 59 of file PluginManager.h.

Member Typedef Documentation

KwavePluginPointer

typedef QPointer<Kwave::Plugin> Kwave::PluginManager::KwavePluginPointer

private

typedef: QPointer to a Kwave::Plugin

Definition at line 319 of file PluginManager.h.

PluginList

typedef QList< KwavePluginPointer > Kwave::PluginManager::PluginList

private

typedef: list of pointers to kwave plugins

Definition at line 322 of file PluginManager.h.

PluginListIterator

typedef QListIterator< KwavePluginPointer > Kwave::PluginManager::PluginListIterator

private

typedef: const iterator for PluginList

Definition at line 330 of file PluginManager.h.

PluginListMutableIterator

typedef QMutableListIterator< KwavePluginPointer > Kwave::PluginManager::PluginListMutableIterator

private

typedef: mutable iterator for PluginList

Definition at line 326 of file PluginManager.h.

Constructor & Destructor Documentation

PluginManager()

Kwave::PluginManager::PluginManager	(	QWidget *	parent,
		Kwave::SignalManager &	signal_manager
	)

Constructor.

Parameters

parent	reference to the toplevel widget (our parent)
signal_manager	reference to a SignalManager

Definition at line 63 of file PluginManager.cpp.

    :m_plugin_instances(),
     m_running_plugins(),
     m_parent_widget(parent),
     m_signal_manager(signal_manager),
     m_view_manager(Q_NULLPTR)
{
}

~PluginManager()

Kwave::PluginManager::~PluginManager ( )

virtual

Default destructor

Definition at line 74 of file PluginManager.cpp.

References m_active_instance, Kwave::PluginManager::PluginModule::m_factory, m_plugin_instances, m_plugin_modules, Kwave::PluginManager::PluginModule::m_use_count, name, sigClosed(), and sync().

{
    // inform all plugins and client windows that we close now
    emit sigClosed();

    // wait until all plugins are really closed
    this->sync();

    // give all plugins that still are loaded the chance to do some cleanups
    // or unregistration tasks. Ideally this should also trigger a "release"
    // of these remaining plugins, so that afterwards we have no more
    // plugin instances left.
    while (!m_plugin_instances.isEmpty()) {
        KwavePluginPointer p = m_plugin_instances.takeLast();
        Q_ASSERT(p);
        if (p) p->unload();
    }

    // this should make the cleanup handlers run (deferred delete)
    QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);

    // release all loaded modules
    foreach (const QString &name, m_plugin_modules.keys()) {
        PluginModule &p = m_plugin_modules[name];
        p.m_use_count--;

//      qDebug("PluginManager: releasing module '%s' [refcnt=%d]",
//             DBG(name), p.m_use_count);
        if (p.m_use_count == 0) {
            // take out the pointer to the loadable module
            KPluginFactory *factory = p.m_factory;
            p.m_factory = Q_NULLPTR;

            // remove the module from the list
            m_plugin_modules.remove(name);

            // now the handle of the shared object can be released too
            if (factory) delete factory;
        } else {
            // still in use
        }
    }

    // we are no longer the active instance
    if (m_active_instance == this)
        m_active_instance = Q_NULLPTR;
}

Here is the call graph for this function:

Member Function Documentation

canClose()

bool Kwave::PluginManager::canClose

(

)

Returns true if there is no running plugin that blocks a "close" operation.

Definition at line 288 of file PluginManager.cpp.

References m_plugin_instances.

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    if (!m_plugin_instances.isEmpty())
        foreach (const KwavePluginPointer &plugin, m_plugin_instances)
            if (plugin && !plugin->canClose()) return false;

    return true;
}

connectPlugin()

void Kwave::PluginManager::connectPlugin ( Kwave::Plugin *  plugin )

private

connects all signals of and for a plugin

Definition at line 557 of file PluginManager.cpp.

References Kwave::connect(), pluginClosed(), pluginDone(), pluginStarted(), and sigClosed().

Referenced by createPluginInstance(), and migratePluginToActiveContext().

{
    Q_ASSERT(plugin);
    if (!plugin) return;

    connect(this, SIGNAL(sigClosed()),
            plugin, SLOT(close()));

    connect(plugin, SIGNAL(sigClosed(Kwave::Plugin*)),
            this, SLOT(pluginClosed(Kwave::Plugin*)),
            Qt::QueuedConnection);

    connect(plugin, SIGNAL(sigRunning(Kwave::Plugin*)),
            this, SLOT(pluginStarted(Kwave::Plugin*)),
            Qt::DirectConnection);

    connect(plugin, SIGNAL(sigDone(Kwave::Plugin*)),
            this, SLOT(pluginDone(Kwave::Plugin*)),
            Qt::QueuedConnection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

createPluginInstance()

Kwave::Plugin * Kwave::PluginManager::createPluginInstance ( const QString &  name )

private

Creates an instance of a plugin.

Parameters

name	the name of the plugin (filename)

Returns

pointer to the loaded plugin or zero if the plugin was not found or invalid

Definition at line 173 of file PluginManager.cpp.

References connectPlugin(), DBG, Kwave::MessageBox::error(), Kwave::PluginManager::PluginModule::m_description, Kwave::PluginManager::PluginModule::m_factory, Kwave::PluginManager::PluginModule::m_name, m_parent_widget, m_plugin_instances, m_plugin_modules, and name.

Referenced by executePlugin(), loadAllPlugins(), and setupPlugin().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    // show an error message and abort if the plugin is unknown
    if (!(m_plugin_modules.contains(name))) {
        Kwave::MessageBox::error(m_parent_widget,
            i18n("The plugin '%1' is unknown or invalid.", name),
            i18n("Error On Loading Plugin"));
        return Q_NULLPTR;
    }

    PluginModule &info = m_plugin_modules[name];
//     qDebug("loadPlugin(%s) [module use count=%d]",
//         DBG(name), info.m_use_count);

    KPluginFactory *factory = info.m_factory;
    Q_ASSERT(factory);

    // call the loader function to create an instance
    QVariantList args;
    args << info.m_name;
    args << info.m_description;
    Kwave::Plugin *plugin = factory->create<Kwave::Plugin>(this, args);
    Q_ASSERT(plugin);
    if (!plugin) {
        qWarning("PluginManager::loadPlugin('%s'): out of memory", DBG(name));
        return Q_NULLPTR;
    }
    // now we have a newly created plugin, the use count is 1

    // append to our list of loaded plugins
    m_plugin_instances.append(plugin);

    // connect all necessary signals/slots
    connectPlugin(plugin);

    return plugin;
}

Here is the call graph for this function:

Here is the caller graph for this function:

defaultParams()

QStringList Kwave::PluginManager::defaultParams

(

const QString &

name

)

loads a plugin's default parameters from the user's configuration file. If nothing is found in the config file, the return value will be 0. If the current version number of the plugin does not match the version number in the config file, the return value will also be 0.

Parameters

name	the name of the plugin

Returns

list of strings

Definition at line 363 of file PluginManager.cpp.

References _, DBG, m_plugin_modules, Kwave::PluginManager::PluginModule::m_version, and name.

Referenced by executePlugin(), loadAllPlugins(), Kwave::RecordPlugin::setup(), and setupPlugin().

{
    QString def_version;
    QString section = _("plugin ");
    QStringList list;
    section += name;

    // get the plugin version
    if (!m_plugin_modules.contains(name)) return list;
    const PluginModule &info = m_plugin_modules[name];
    QString version = info.m_version;

    Q_ASSERT(KSharedConfig::openConfig());
    if (!KSharedConfig::openConfig()) return list;
    KConfigGroup cfg = KSharedConfig::openConfig()->group(section);

    cfg.sync();

    def_version = cfg.readEntry("version");
    if (!def_version.length()) {
        return list;
    }
    if (!(def_version == version)) {
        qDebug("PluginManager::defaultParams: "
            "plugin '%s': defaults for version '%s' not loaded, found "
            "old ones of version '%s'.",
            DBG(name), DBG(version), DBG(def_version));

        // delete the old settings
        cfg.deleteEntry("version");
        cfg.deleteEntry("defaults");

        return list;
    }

    list = cfg.readEntry("defaults").split(QLatin1Char(','));
    return list;
}

Here is the caller graph for this function:

disconnectPlugin()

void Kwave::PluginManager::disconnectPlugin ( Kwave::Plugin *  plugin )

private

connects all signals from and to a plugin

Definition at line 579 of file PluginManager.cpp.

References pluginClosed(), pluginDone(), pluginStarted(), and sigClosed().

Referenced by migratePluginToActiveContext(), and pluginClosed().

{
    Q_ASSERT(plugin);
    if (!plugin) return;

    disconnect(plugin, SIGNAL(sigDone(Kwave::Plugin*)),
               this, SLOT(pluginDone(Kwave::Plugin*)));

    disconnect(plugin, SIGNAL(sigRunning(Kwave::Plugin*)),
               this, SLOT(pluginStarted(Kwave::Plugin*)));

    disconnect(this, SIGNAL(sigClosed()),
               plugin, SLOT(close()));

    disconnect(plugin, SIGNAL(sigClosed(Kwave::Plugin*)),
               this, SLOT(pluginClosed(Kwave::Plugin*)));

}

Here is the call graph for this function:

Here is the caller graph for this function:

enqueueCommand()

void Kwave::PluginManager::enqueueCommand

(

const QString &

command

)

Enqueues a command that will be processed threadsafe in the X11 thread.

Definition at line 494 of file PluginManager.cpp.

References sigCommand().

Referenced by Kwave::Plugin::emitCommand(), and Kwave::UndoReverseAction::undo().

{
    emit sigCommand(command);
}

Here is the caller graph for this function:

executePlugin()

int Kwave::PluginManager::executePlugin	(	const QString &	name,
		QStringList *	params
	)

Executes a plugin in the context of a given parent widget.

Parameters

name	the name of the plugin
params	pointer to a parameter list or null if defaults should be used

Returns

zero on success or negative error code

Definition at line 216 of file PluginManager.cpp.

References _, createPluginInstance(), defaultParams(), m_plugin_instances, name, savePluginDefaults(), sigCommand(), and sync().

Referenced by Kwave::K3BExportPlugin::saveBlocks().

{
    QString command;
    int result = 0;

    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    // synchronize: wait until any currently running plugins are done
    this->sync();

    // load the new plugin
    KwavePluginPointer plugin = createPluginInstance(name);
    if (!plugin) return -ENOMEM;

    if (params) {
        // parameters were specified -> call directly
        // without setup dialog
        result = plugin->start(*params);

        // maybe the start() function has called close() ?
        if (!m_plugin_instances.contains(plugin)) {
            qDebug("PluginManager: plugin closed itself in start()");
            result = -1;
            plugin = Q_NULLPTR;
        }

        if (plugin && (result >= 0)) {
            plugin->execute(*params);
        }
    } else {
        // load previous parameters from config
        QStringList last_params = defaultParams(name);

        // call the plugin's setup function
        params = plugin->setup(last_params);
        if (params) {
            // we have a non-zero parameter list, so
            // the setup function has not been aborted.
            // Now we can create a command string and
            // emit a new command.

            // store parameters for the next time
            savePluginDefaults(name, *params);

            // We DO NOT call the plugin's "execute"
            // function directly, as it should be possible
            // to record all function calls in the
            // macro recorder
            command = _("plugin:execute(");
            command += name;
            foreach (const QString &p, *params)
                command += _(", ") + p;
            delete params;
            command += _(")");
//          qDebug("PluginManager: command='%s'",command.data());
        }
    }

    // now the plugin is no longer needed here, release it
    if (plugin) plugin->release();

    // emit a command, let the toplevel window (and macro recorder) get
    // it and call us again later...
    if (command.length()) emit sigCommand(command);

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

insertView()

void Kwave::PluginManager::insertView	(	Kwave::SignalView *	view,
		QWidget *	controls
	)

Insert a new signal view into this widget (or the upper/lower dock area.

Parameters

view	the signal view, must not be a null pointer
controls	a widget with controls, optionally, can be null

Definition at line 480 of file PluginManager.cpp.

References Kwave::ViewManager::insertView(), and m_view_manager.

{
    if (m_view_manager)
        m_view_manager->insertView(view, controls);
}

Here is the call graph for this function:

loadAllPlugins()

bool Kwave::PluginManager::loadAllPlugins

(

)

Tries to load all plugins. If a pesistent plugin is found, it will stay loaded in memory, all other (non-persistent) plugins will be unloaded afterwards. This also filters out all plugins that do not correctly load.

used once by each toplevel window at startup

Returns

true if at least one plugin was loaded, false if none

Definition at line 123 of file PluginManager.cpp.

References createPluginInstance(), DBG, defaultParams(), m_plugin_modules, and name.

{
    // Try to load all plugins. This has to be called only once per
    // instance of the main window!
    // NOTE: this also gives each plugin the chance to stay in memory
    //       if necessary (e.g. for codecs)
    foreach (const QString &name, m_plugin_modules.keys()) {
        KwavePluginPointer plugin = createPluginInstance(name);
        if (plugin) {
//          qDebug("PluginManager::loadAllPlugins(): plugin '%s'",
//                 DBG(plugin->name()));

            // get the last settings and call the "load" function
            // now the plugin is present and loaded
            QStringList last_params = defaultParams(name);
            plugin->load(last_params);

            // reduce use count again, we loaded the plugin only to give
            // it a chance to register some service if necessary (e.g. a
            // codec)
            // Most plugins fall back to use count zero and will be
            // deleted again.
            plugin->release();
        } else {
            // loading failed => remove it from the list
            qWarning("PluginManager::loadAllPlugins(): removing '%s' "
                    "from list", DBG(name));
            m_plugin_modules.remove(name);
        }
    }

    return !m_plugin_modules.isEmpty();
}

Here is the call graph for this function:

migratePluginToActiveContext()

void Kwave::PluginManager::migratePluginToActiveContext

(

Kwave::Plugin *

plugin

)

Migrate a plugin to the currently active file context (which might be different from the one that is currently executing the plugin). The plugin will be removed from our lists and inserted into the currently active plugin manager instance.

Parameters

plugin

the plugin to migrate

Definition at line 685 of file PluginManager.cpp.

References connectPlugin(), disconnectPlugin(), m_active_instance, m_plugin_instances, m_running_plugins, and Kwave::Plugin::setPluginManager().

Referenced by Kwave::Plugin::migrateToActiveContext().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    Q_ASSERT(plugin);
    if (!plugin) return;
    if (m_active_instance == this) return; // nothing to do
    Q_ASSERT(m_active_instance);
    if (!m_active_instance) return; // should never happen

    Kwave::PluginManager *old_mgr = this;
    old_mgr->m_plugin_instances.removeAll(plugin);
    old_mgr->m_running_plugins.removeAll(plugin);
    old_mgr->disconnectPlugin(plugin);

    Kwave::PluginManager *new_mgr = m_active_instance;
    new_mgr->m_plugin_instances.append(plugin);
    new_mgr->m_running_plugins.append(plugin);
    new_mgr->connectPlugin(plugin);

    plugin->setPluginManager(new_mgr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

onePluginRunning()

bool Kwave::PluginManager::onePluginRunning

(

)

Returns true if at least one plugin is currently running

Definition at line 302 of file PluginManager.cpp.

References m_plugin_instances.

Referenced by sync().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    if (!m_plugin_instances.isEmpty())
        foreach (const KwavePluginPointer &plugin, m_plugin_instances)
            if (plugin && plugin->isRunning()) return true;

    return false;
}

Here is the caller graph for this function:

openMultiTrackPlayback()

Kwave::SampleSink * Kwave::PluginManager::openMultiTrackPlayback	(	unsigned int	tracks,
		const Kwave::PlayBackParam *	playback_params = Q_NULLPTR
	)

Opens a Kwave::MultiTrackSink for playback purposes.

Parameters

tracks	number of tracks
playback_params	points to a class that holds all playback parameters. If null, the default parameters of the current signal will be used

Returns

a multitrack sink that receives the playback stream

Definition at line 457 of file PluginManager.cpp.

References m_signal_manager, Kwave::PlaybackController::openDevice(), and Kwave::SignalManager::playbackController().

Referenced by Kwave::FilterPlugin::startPreListen(), and Kwave::PlayBackPlugin::testPlayBack().

{
    Kwave::PlayBackDevice *device =
        m_signal_manager.playbackController().openDevice(
            tracks, playback_params);
    if (!device) return Q_NULLPTR;

    // create the multi track playback sink
    Kwave::SampleSink *sink = new Kwave::MultiPlaybackSink(tracks, device);
    Q_ASSERT(sink);
    return sink;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parentWidget()

QPointer<QWidget> Kwave::PluginManager::parentWidget ( )

inline

returns a pointer to the parent widget

Definition at line 198 of file PluginManager.h.

Referenced by Kwave::Plugin::parentWidget(), and Kwave::Plugin::setPluginManager().

        {
            return m_parent_widget;
        }

Here is the caller graph for this function:

playbackController()

Kwave::PlaybackController & Kwave::PluginManager::playbackController

(

)

Returns a reference to the current playback controller. This is only needed for plugins doing playback.

Definition at line 474 of file PluginManager.cpp.

References m_signal_manager, and Kwave::SignalManager::playbackController().

{
    return m_signal_manager.playbackController();
}

Here is the call graph for this function:

pluginClosed

void Kwave::PluginManager::pluginClosed ( Kwave::Plugin *  p )

privateslot

Will be connected to the plugin's "closed" signal.

Parameters

p	pointer to the plugin to be closed

Definition at line 506 of file PluginManager.cpp.

References disconnectPlugin(), and m_plugin_instances.

Referenced by connectPlugin(), and disconnectPlugin().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    Q_ASSERT(p);
    if (!p) return;

    // disconnect the signals to avoid recursion
    disconnectPlugin(p);

    if (m_plugin_instances.contains(p))
        m_plugin_instances.removeAll(p);

    // schedule the deferred delete/unload of the plugin
    p->deleteLater();
}

Here is the call graph for this function:

Here is the caller graph for this function:

pluginDone

void Kwave::PluginManager::pluginDone ( Kwave::Plugin *  p )

privateslot

called when a plugin has finished it's worker thread

Definition at line 540 of file PluginManager.cpp.

References m_running_plugins, and Kwave::Plugin::release().

Referenced by connectPlugin(), and disconnectPlugin().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    Q_ASSERT(p);
    if (!p) return;

    // remove the plugin from the list of running plugins
    m_running_plugins.removeAll(p);

    // release the plugin, at least we do no longer need it
    p->release();
}

Here is the call graph for this function:

Here is the caller graph for this function:

pluginInfoList()

const QList< Kwave::PluginManager::PluginModule > Kwave::PluginManager::pluginInfoList

(

)

const

returns a list with info of all known plugins

Todo:

rename to pluginModuleList

Definition at line 679 of file PluginManager.cpp.

References m_plugin_modules.

{
    return m_plugin_modules.values();
}

pluginStarted

void Kwave::PluginManager::pluginStarted ( Kwave::Plugin *  p )

privateslot

called when a plugin has started (running) it's worker thread

Definition at line 526 of file PluginManager.cpp.

References m_running_plugins, and Kwave::Plugin::use().

Referenced by connectPlugin(), and disconnectPlugin().

{
    Q_ASSERT(p);
    if (!p) return;

    // the plugin is running -> increase the usage count in order to
    // prevent our lists from containing invalid entries
    p->use();

    // add the plugin to the list of running plugins
    m_running_plugins.append(p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerViewManager()

void Kwave::PluginManager::registerViewManager

(

Kwave::ViewManager *

view_manager

)

registers a view manager, must only be called once!

Definition at line 487 of file PluginManager.cpp.

References m_view_manager.

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

{
    Q_ASSERT(!view_manager || !m_view_manager);
    m_view_manager = view_manager;
}

Here is the caller graph for this function:

savePluginDefaults()

void Kwave::PluginManager::savePluginDefaults ( const QString &  name, QStringList &  params  )

private

Saves a plugin's default parameters to the user's configuration file. The whole section in the configuration file will be deleted before saving the new settings in order to wipe out invalid entries and settings that belong to an older version.

Parameters

name	the name of the plugin
params	a list of configuration strings

Definition at line 403 of file PluginManager.cpp.

References _, m_plugin_modules, Kwave::PluginManager::PluginModule::m_version, and name.

Referenced by executePlugin(), and setupPlugin().

{

    // get the plugin version
    if (!m_plugin_modules.contains(name)) return;
    const PluginModule &info = m_plugin_modules[name];
    QString version = info.m_version;

    QString section = _("plugin ");
    section += name;

    Q_ASSERT(KSharedConfig::openConfig());
    if (!KSharedConfig::openConfig()) return;
    KConfigGroup cfg = KSharedConfig::openConfig()->group(section);

    cfg.sync();
    cfg.writeEntry("version", version);
    cfg.writeEntry("defaults", params.join(QLatin1Char(',')));
    cfg.sync();
}

Here is the caller graph for this function:

searchPluginModules()

void Kwave::PluginManager::searchPluginModules

(

)

Searches the standard KDE data directories for plugins (through the KDE's standard search algorithm) and creates a map of plugin names and file names. First it collects a list of filenames and then filters it to sort out invalid entries.

Definition at line 605 of file PluginManager.cpp.

References _, DBG, Kwave::PluginManager::PluginModule::m_author, Kwave::PluginManager::PluginModule::m_description, Kwave::PluginManager::PluginModule::m_factory, Kwave::PluginManager::PluginModule::m_name, m_plugin_modules, Kwave::PluginManager::PluginModule::m_use_count, Kwave::PluginManager::PluginModule::m_version, name, and sigProgress().

{
    if (!m_plugin_modules.isEmpty()) {
        // this is not the first call -> increment module use count only
        foreach (const QString &name, m_plugin_modules.keys()) {
            PluginModule &p = m_plugin_modules[name];
            p.m_use_count++;
        }
        return;
    }

    KPluginInfo::List plugins = KPluginTrader::self()->query(
        _("kwave"), _("Kwave/Plugin")
    );
    foreach (const KPluginInfo &i, plugins) {
        QString library     = i.libraryPath();
        QString description = i.name();
        QString name        = i.pluginName();
        QString version_raw = i.version();
        QString version;
        QString settings;
        QString author      = i.author();

        if (version_raw.contains(_(":"))) {
            version  = version_raw.split(_(":")).at(0);
            settings = version_raw.split(_(":")).at(1);
        }

//      qDebug("file='%s', name='%s', description='%s', binary_version='%s', "
//             "settings_version='%s', author='%s'",
//             DBG(library), DBG(name), DBG(description), DBG(version),
//             DBG(settings), DBG(author)
//      );

        if ( library.isEmpty() || description.isEmpty() ||
             name.isEmpty() || version.isEmpty() ) {
            qWarning("plugin '%s' has no library, name or version", DBG(name));
            continue;
        }

        if (version != _(KWAVE_VERSION)) {
            qWarning("plugin '%s' has wrong ABI version: '%s' (should be %s)",
                     DBG(name), DBG(version), KWAVE_VERSION);
            continue;
        }

        KPluginLoader loader(library);
        KPluginFactory* factory = loader.factory();
        if (!factory) {
            qWarning("plugin '%s': loading failed", DBG(name));
            continue;
        }

        emit sigProgress(i18n("Loading plugin %1...", name));
        QApplication::processEvents();

        PluginModule info;
        info.m_name        = name;
        info.m_author      = author;
        info.m_description = i18n(description.toUtf8());
        info.m_version     = settings;
        info.m_factory     = factory;
        info.m_use_count   = 1;

        m_plugin_modules.insert(info.m_name, info);

        qDebug("%16s %5s written by %s", DBG(name), DBG(settings), DBG(author));
    }

    qDebug("--- \n found %d plugins\n", m_plugin_modules.count());
}

selectionEnd()

sample_index_t Kwave::PluginManager::selectionEnd

(

)

Returns the end of the selection. If nothing is currently selected this will be the last sample (length-1).

Definition at line 444 of file PluginManager.cpp.

References Kwave::Selection::last(), m_signal_manager, and Kwave::SignalManager::selection().

Referenced by Kwave::Plugin::selection().

{
    return m_signal_manager.selection().last();
}

Here is the call graph for this function:

Here is the caller graph for this function:

selectionStart()

sample_index_t Kwave::PluginManager::selectionStart

(

)

Returns the start of the selection. If nothing is currently selected this will be the first sample (0).

Definition at line 438 of file PluginManager.cpp.

References Kwave::Selection::first(), m_signal_manager, and Kwave::SignalManager::selection().

Referenced by Kwave::Plugin::selection(), and Kwave::SelectRangePlugin::setup().

{
    return m_signal_manager.selection().first();
}

Here is the call graph for this function:

Here is the caller graph for this function:

selectRange()

void Kwave::PluginManager::selectRange	(	sample_index_t	offset,
		sample_index_t	length
	)

Sets the current start and length of the selection to new values.

Parameters

offset	index of the first sample
length	number of samples

Definition at line 450 of file PluginManager.cpp.

References m_signal_manager, and Kwave::SignalManager::selectRange().

Referenced by Kwave::Plugin::selectRange().

{
    m_signal_manager.selectRange(offset, length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setActive()

void Kwave::PluginManager::setActive ( )

inline

Let this instance be the active one

Definition at line 262 of file PluginManager.h.

{ m_active_instance = this; }

setParentWidget()

void Kwave::PluginManager::setParentWidget ( QWidget *  new_parent )

inline

assigns a new parent widget, to be used for messages

Parameters

new_parent

pointer to a QWidget

Definition at line 193 of file PluginManager.h.

                                                         {
            m_parent_widget = new_parent;
        }

setSignalName

void Kwave::PluginManager::setSignalName ( const QString &  name )

slot

Called if the name of the current signal has changed. This will be forwarded to all plugins by emitting the signal sigSignalNameChanged.

See also

sigSignalNameChanged()

Definition at line 599 of file PluginManager.cpp.

References sigSignalNameChanged().

{
    emit sigSignalNameChanged(name);
}

setupPlugin()

int Kwave::PluginManager::setupPlugin	(	const QString &	name,
		const QStringList &	params
	)

Loads a plugin, calls it's setup function and then closes it again. The parameters will be loaded before the setup and saved if the setup has not been aborted.

Parameters

name	the name of the plugin
params	pointer to a parameter list or null if defaults should be used

Return values

0	if succeeded and accepted
1	if canceled
-1	if failed

Definition at line 335 of file PluginManager.cpp.

References createPluginInstance(), defaultParams(), Kwave::Plugin::release(), savePluginDefaults(), and Kwave::Plugin::setup().

{
    // load the plugin
    Kwave::Plugin *plugin = createPluginInstance(name);
    if (!plugin) return -ENOMEM;

    // now the plugin is present and loaded
    QStringList prev_params = (params.isEmpty()) ?
        defaultParams(name) : params;

    // call the plugins' setup function
    QStringList *new_params = plugin->setup(prev_params);
    if (new_params) {
        // we have a non-zero parameter list, so
        // the setup function has not been aborted.
        savePluginDefaults(name, *new_params);
        delete new_params;
    } else {
        plugin->release();
        return 1;
    }

    plugin->release();
    return 0;
}

Here is the call graph for this function:

sigClosed

void Kwave::PluginManager::sigClosed ( )

signal

Informs all plugins and client windows that we close down

Referenced by connectPlugin(), disconnectPlugin(), signalClosed(), and ~PluginManager().

Here is the caller graph for this function:

sigCommand

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

signal

Forwards commands to the parent TopWidget execute a command

Referenced by enqueueCommand(), and executePlugin().

Here is the caller graph for this function:

signalClosed

void Kwave::PluginManager::signalClosed ( )

slot

Notify all plugins that the signal or file is to be closed

Definition at line 500 of file PluginManager.cpp.

References sigClosed().

{
    emit sigClosed();
}

signalLength()

sample_index_t Kwave::PluginManager::signalLength

(

)

Returns the length of the current signal in samples. If no signal is present the return value will be 0.

Definition at line 426 of file PluginManager.cpp.

References Kwave::SignalManager::length(), and m_signal_manager.

Referenced by Kwave::Plugin::selection(), and Kwave::Plugin::signalLength().

{
    return m_signal_manager.length();
}

Here is the call graph for this function:

Here is the caller graph for this function:

signalManager()

Kwave::SignalManager& Kwave::PluginManager::signalManager ( )

inline

returns a reference to our signal manager

Definition at line 204 of file PluginManager.h.

Referenced by Kwave::NoisePlugin::createDialog(), Kwave::RecordPlugin::resetRecording(), Kwave::VolumePlugin::setup(), and Kwave::Plugin::signalManager().

        {
            return m_signal_manager;
        }

Here is the caller graph for this function:

signalRate()

double Kwave::PluginManager::signalRate

(

)

Returns the current sample rate in samples per second. If no signal is present the return value will be 0.

Definition at line 432 of file PluginManager.cpp.

References m_signal_manager, and Kwave::SignalManager::rate().

Referenced by Kwave::Plugin::signalRate().

{
    return m_signal_manager.rate();
}

Here is the call graph for this function:

Here is the caller graph for this function:

sigProgress

void Kwave::PluginManager::sigProgress ( const QString &  message )

signal

informs about progress, e.g. for showing a message in a splash screen or status bar.

Referenced by searchPluginModules().

Here is the caller graph for this function:

sigSignalNameChanged

void Kwave::PluginManager::sigSignalNameChanged ( const QString &  name )

signal

Informs the plugins that the name of the signal has changed. This might be used to update the caption of a window.

Referenced by setSignalName().

Here is the caller graph for this function:

stopAllPlugins()

void Kwave::PluginManager::stopAllPlugins

(

)

Stops all currently running plugins

Definition at line 158 of file PluginManager.cpp.

References m_plugin_instances, and sync().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    if (!m_plugin_instances.isEmpty())
        foreach (const KwavePluginPointer &plugin, m_plugin_instances)
            if (plugin && plugin->isRunning())
                plugin->stop() ;

    sync();
}

Here is the call graph for this function:

sync()

void Kwave::PluginManager::sync

(

)

Waits until all currently running actions have completed.

Definition at line 316 of file PluginManager.cpp.

References onePluginRunning(), and Kwave::yield().

Referenced by executePlugin(), Kwave::TopWidget::forwardCommand(), stopAllPlugins(), and ~PluginManager().

{
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    // this triggers all kinds of garbage collector (objects queued for
    // deletion through obj->deleteLater()
    qApp->processEvents(QEventLoop::ExcludeUserInputEvents);

    // wait until all plugins have finished their work...
    while (onePluginRunning()) {
        Kwave::yield();
        qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
        usleep(100000);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_active_instance

Kwave::PluginManager * Kwave::PluginManager::m_active_instance = Q_NULLPTR

staticprivate

pointer to the currently active instance

Definition at line 362 of file PluginManager.h.

Referenced by migratePluginToActiveContext(), and ~PluginManager().

m_parent_widget

QPointer<QWidget> Kwave::PluginManager::m_parent_widget

private

reference to our parent toplevel widget

Definition at line 377 of file PluginManager.h.

Referenced by createPluginInstance().

m_plugin_instances

PluginList Kwave::PluginManager::m_plugin_instances

private

list of all plugins that were loaded by this instance

Definition at line 371 of file PluginManager.h.

Referenced by canClose(), createPluginInstance(), executePlugin(), migratePluginToActiveContext(), onePluginRunning(), pluginClosed(), stopAllPlugins(), and ~PluginManager().

m_plugin_modules

QMap< QString, Kwave::PluginManager::PluginModule > Kwave::PluginManager::m_plugin_modules

staticprivate

map with plugin information: key = short name of the plugin, data = plugin info (description, author, version etc...)

Definition at line 368 of file PluginManager.h.

Referenced by createPluginInstance(), defaultParams(), loadAllPlugins(), pluginInfoList(), savePluginDefaults(), searchPluginModules(), and ~PluginManager().

m_running_plugins

PluginList Kwave::PluginManager::m_running_plugins

private

list of currently running plugins

Definition at line 374 of file PluginManager.h.

Referenced by migratePluginToActiveContext(), pluginDone(), and pluginStarted().

m_signal_manager

Kwave::SignalManager& Kwave::PluginManager::m_signal_manager

private

reference to our signal manager

Definition at line 380 of file PluginManager.h.

Referenced by openMultiTrackPlayback(), playbackController(), selectionEnd(), selectionStart(), selectRange(), signalLength(), and signalRate().

m_view_manager

ViewManager* Kwave::PluginManager::m_view_manager

private

interface for registering a SignalView

Definition at line 383 of file PluginManager.h.

Referenced by insertView(), and registerViewManager().

---

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

• libkwave/PluginManager.h
• libkwave/PluginManager.cpp