summaryrefslogtreecommitdiff
authorzecke <zecke>2004-05-17 21:22:51 (UTC)
committer zecke <zecke>2004-05-17 21:22:51 (UTC)
commitf3d15e6f81369f8495811c7c3624e51d032615ba (patch) (side-by-side diff)
tree8319000a9aa8634a4214306ca19ac49dbcc5bc2b
parente0d8fdf2bcf61f8b6793ee757de35b985aef1b8d (diff)
downloadopie-f3d15e6f81369f8495811c7c3624e51d032615ba.zip
opie-f3d15e6f81369f8495811c7c3624e51d032615ba.tar.gz
opie-f3d15e6f81369f8495811c7c3624e51d032615ba.tar.bz2
OPluginManager first bits of saving, enabling and sorting Plugin Config
At least it compiles, test and GUI will come this week
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--libopie2/opiecore/opluginloader.cpp369
-rw-r--r--libopie2/opiecore/opluginloader.h59
2 files changed, 395 insertions, 33 deletions
diff --git a/libopie2/opiecore/opluginloader.cpp b/libopie2/opiecore/opluginloader.cpp
index b473cd7..2aca382 100644
--- a/libopie2/opiecore/opluginloader.cpp
+++ b/libopie2/opiecore/opluginloader.cpp
@@ -1,37 +1,38 @@
/*
* LGPLv2 or later
* zecke@handhelds.org
*/
#include "opluginloader.h"
#include "oconfig.h"
#include <qpe/qpeapplication.h>
#include <qdir.h>
#include <qdict.h>
#include <qtl.h>
+#include <qfile.h>
#include <stdlib.h>
namespace Opie {
namespace Core {
namespace Internal {
struct OPluginLibraryHolder {
static OPluginLibraryHolder *self();
QLibrary *ref( const QString& );
void deref( QLibrary* );
private:
OPluginLibraryHolder();
~OPluginLibraryHolder();
QDict<QLibrary> m_libs;
static OPluginLibraryHolder* m_self;
};
OPluginLibraryHolder* OPluginLibraryHolder::m_self = 0;
OPluginLibraryHolder* OPluginLibraryHolder::self() {
if ( !m_self )
m_self = new OPluginLibraryHolder;
@@ -89,304 +90,398 @@ private:
bool operator<( const OPluginItem& l, const OPluginItem& r ) {
return l.position() > r.position();
}
bool operator>( const OPluginItem& l, const OPluginItem& r ) {
return l.position() < r.position();
}
bool operator<=( const OPluginItem& l, const OPluginItem& r ) {
return l.position() >= r.position();
}
/**
* \brief Creates an Empty OPluginItem
*
* create an empty pluginitem. Position is set to -1 and the
* other things are used with the default ctors
*/
OPluginItem::OPluginItem()
: m_pos( -1 ) {
}
/**
+ * @todo Create Internal name so we can have the plugin names translated. Or only for the gui? I'm not yet sure
* \brief Create an OPluginItem
*
- * Create a Plugin Item with all information.
+ * Create a Plugin Item with all information. If you for some reasons
+ * need to create your own OPluginItems make sure that 'name' is always the same
+ * as it if used for positions and exclude list.
*
* @param name The if available translated Name
- * @param path The path to the plugin
+ * @param path The path to the plugin must be absolute.
+ * @param b If the OPluginItem is enabled or not
* @param pos The position of the plugin if used for sorting
*
*/
-OPluginItem::OPluginItem( const QString& name, const QString& path, int pos )
- : m_name( name ), m_path( path ), m_pos( pos ) {
-}
+OPluginItem::OPluginItem( const QString& name, const QString& path, bool b, int pos )
+ : m_name( name ), m_path( path ), m_enabled( b ), m_pos( pos )
+{}
/**
* \brief simple d'tor
*/
OPluginItem::~OPluginItem() {
}
/**
+ * \brief Test if this Item is Empty and does not represent a loadable plugin
+ * Test if a OPluginItem is empty. A OPluginItem is empty if name and path are empty
+ * ,pos equals -1 and the item is disabled
+ *
+ * @see QString::isEmpty()
+ *
+ */
+bool OPluginItem::isEmpty()const {
+ if ( m_pos != -1 ) return false;
+ if ( m_enabled ) return false;
+ if ( !m_name.isEmpty() ) return false;
+ if ( !m_path.isEmpty() ) return false;
+
+ return true;
+}
+
+/**
+ * \brief test equality
* operator to test equalness of two OPluginItem
*/
bool OPluginItem::operator==( const OPluginItem& r )const{
- if ( m_pos != r.m_pos ) return false;
- if ( m_name != r.m_name ) return false;
- if ( m_path != r.m_path ) return false;
+ if ( m_pos != r.m_pos ) return false;
+ if ( m_enabled != r.m_enabled) return false;
+ if ( m_name != r.m_name ) return false;
+ if ( m_path != r.m_path ) return false;
return true;
}
+/**
+ * \brief test non equality
+ * operator to test non-equalness of two OPluginItem
+ */
bool OPluginItem::operator!=( const OPluginItem& r )const{
return !( *this == r );
}
/**
+ * \brief returns the name of the plugin
* return the name of this Plugin
*/
QString OPluginItem::name()const {
return m_name;
}
/**
- * return the path of the plugin
+ * \brief return the path of the plugin
*/
QString OPluginItem::path()const {
return m_path;
}
+/**
+ * \brief Return if this item is enabled.
+ */
+bool OPluginItem::isEnabled()const {
+ return m_enabled;
+}
+
+/**
+ * \brief return the position of a plugin.
+ * return the position of the item
+ * -1 is the default value and means normally that the whole items are unsorted.
+ * Higher numbers belong to an upper position. With plugins with the postions 20,19,5,3
+ * the item with pos 20 would be the first in the list returned by the OGenericPluginLoader
+ *
+ * @see OGenericPluginLoader::allAvailable
+ * @see OGenericPluginLoader::filtered
+ */
int OPluginItem::position()const{
return m_pos;
}
/**
+ * \brief set the name of a plugin
* Set the name of the Plugin Item
* @param name
*/
void OPluginItem::setName( const QString& name ) {
m_name = name;
}
/**
- * Set the path of Plugin Item
+ * \brief set the path of a plugin
+ * Set the path of Plugin Item. The path must be absolute.
* @param name The path of the plugin
*/
void OPluginItem::setPath( const QString& name ) {
m_name = name;
}
/**
+ * \brief enable or disable the to load attribute
+ * Set the Enabled attribute. Such changes won't be saved. If you want to save it
+ * use a OPluginManager to configure your plugins manually or Opie::Ui::OPluginConfig
+ * for a graphical frontend.
+ *
+ * @param enabled Enable or Disable the Enabled Attribute
+ */
+void OPluginItem::setEnabled( bool enabled ) {
+ m_enabled = enabled;
+}
+
+/**
+ * \brief Set the position.
* Set the position
* @param pos The position
+ *
+ * @see position()
*/
void OPluginItem::setPosition( int pos ) {
m_pos = pos;
}
/**
* \brief create a PluginLoader
*
* Create a PluginLoader autoDelete is set to false
*
* \code
* Opie::Core::OGenericPluginLoader loader("myapp-plugin");
* Opie::Core::OPluginItem::List lst = loader.filtered();
* for(Opie::Core::OPluginItem::List::Iterator it = lst.begin(); it!=lst.end();++it){
* MyIface* iface = static_cast<MyIface*>(loader.load(*it,IID_MyIface));
* }
* \endcode
*
* \code
* Opie::Core::OGenericPluginLoader loader("myapp-plugin");
* Opie::Core::OPluginItem::List lst = loader.filtered();
* for(Opie::Core::OPluginItem::List::Iterator it = lst.begin(); it!=lst.end();++it){
* MyIface* iface = static_cast<MyIface*>(loader.load(*it,IID_MyIface));
* }
* ...
* loader.clear();
*
* \endcode
*
* @param name The name of the plugin directory.
* @param isSorted Tell the PluginLoader if your Plugins are sorted
*/
OGenericPluginLoader::OGenericPluginLoader( const QString& name, bool isSorted)
: m_dir( name ), m_autoDelete( false ), m_isSafeMode( false ),
m_isSorted( isSorted )
{
setPluginDir( QPEApplication::qpeDir() + "/plugins/"+name );
readConfig();
}
/**
+ * \brief simple d'tor that cleans up depending on autoDelete
+ *
* calls clear if autoDelete is true. This will release all interfaces
* and remove the library from this process if the refcount falls to zero
*/
OGenericPluginLoader::~OGenericPluginLoader() {
if ( m_autoDelete )
clear();
}
/**
+ * \brief Enable or disable autoDelete on destruction
+ *
* enable autoDelete. This will call clear on the d'tor
*
* @see ~OGenericPluginLoader
* @see clear()
*/
void OGenericPluginLoader::setAutoDelete( bool t ) {
m_autoDelete = t;
}
/**
- * see if autoDelet is enabled
+ * \brief See if autoDelete is enabled.
*/
bool OGenericPluginLoader::autoDelete()const{
return m_autoDelete;
}
/**
+ * \brief unload all loaded Plugins
+ *
* This will unload all returned QUnknownInterfaces by load. Unload
* will be called.
*/
void OGenericPluginLoader::clear() {
QPtrDictIterator<QLibrary> it( m_library );
for ( ;it.current(); )
unload( static_cast<QUnknownInterface*>( it.currentKey() ) );
}
/**
+ * \brief unload the Plugin and the accompanied Resources.
+ *
* This will take the iface from the internal QPtrDict, Release it,
* and deref the libray used.
* The visibility depends on the QPtrDict.
* @see QPtrDict::insert
*/
void OGenericPluginLoader::unload( QUnknownInterface* iface ) {
if ( !iface )
return;
iface->release();
Internal::OPluginLibraryHolder::self()->deref( m_library.take( iface ) );
}
/**
+ * \brief The name of the plugins.
+ *
+ * Return the name/type you specified in the constructor.
+ * This is at least used by the OPluginManager to find the right config
+ */
+QString OGenericPluginLoader::name()const {
+ return m_dir;
+}
+
+
+/**
+ * \brief See if loading of a plugin segfaulted
* This tells you
* if by previous tries to load, loading crashed your application.
* If isInSafeMode you can use the GUI to configure the plugins prior to loading
*
* @return true if prior loading failed
*/
bool OGenericPluginLoader::isInSafeMode()const {
return m_isSafeMode;
}
/**
+ * \brief Return all Plugins found in the plugins dirs.
* Return the list of all available plugins. This will go through all plugin
* directories and search for your type of plugins ( by subdir )
*
* @param sorted Tell if you want to have the positions sorted. This only makes sense if you
*/
OPluginItem::List OGenericPluginLoader::allAvailable( bool sorted )const {
OPluginItem::List lst;
for ( QStringList::ConstIterator it = m_plugDirs.begin(); it != m_plugDirs.end(); ++it )
lst += plugins( *it, sorted, false );
if ( sorted )
qHeapSort( lst );
return lst;
}
/**
+ * \brief Return only the enabled plugins
* Return only activated plugins.
*
* @param sorted If the list should be sorted
*/
OPluginItem::List OGenericPluginLoader::filtered( bool sorted )const {
OPluginItem::List lst;
for ( QStringList::ConstIterator it = m_plugDirs.begin(); it != m_plugDirs.end(); ++it )
lst += plugins( *it, sorted, true );
if ( sorted )
qHeapSort( lst );
return lst;
}
/**
+ * \brief Load a OPluginItem for the specified interface
+ * This will open the resource of the OPluginItem::path() and then will query
+ * if the Interface specified in the uuid is available and then will manage the
+ * resource and Interface.
+ *
+ * @param item The OPluginItem that should be loaded
+ * @param uuid The Interface to query for
*
+ * @return Either 0 in case of failure or the Plugin as QUnknownInterface*
*/
QUnknownInterface* OGenericPluginLoader::load( const OPluginItem& item, const QUuid& uuid) {
/*
* Check if there could be a library
*/
QString pa = item.path();
if ( pa.isEmpty() )
return 0l;
/*
* See if we get a library
* return if we've none
*/
setSafeMode( pa, true );
QLibrary *lib = Internal::OPluginLibraryHolder::self()->ref( pa );
if ( !lib ) {
setSafeMode();
return 0l;
}
/**
* try to load the plugin and just in case initialize the pointer to a pointer again
*/
QUnknownInterface* iface=0;
if ( lib->queryInterface( uuid, &iface ) == QS_OK ) {
installTranslators(pa.left( pa.find(".")));
m_library.insert( iface, lib );
}else
iface = 0;
setSafeMode();
return iface;
}
/**
* @internal and reads in the safe mode
*/
void OGenericPluginLoader::readConfig() {
- /* read the config for SafeMode */
+
+
+/* read the config for SafeMode */
OConfig conf( m_dir + "-odpplugins" );
conf.setGroup( "General" );
m_isSafeMode = conf.readBoolEntry( "SafeMode", false );
}
/**
- * Enter or leave SafeMode
+ * @internal Enter or leave SafeMode
*/
void OGenericPluginLoader::setSafeMode(const QString& str, bool b) {
OConfig conf( m_dir + "-odpplugins" );
conf.setGroup( "General" );
conf.writeEntry( "SafeMode", b );
conf.writeEntry( "CrashedPlugin", str );
}
/**
* @internal
*
* Set the List of Plugin Dirs to lst. Currently only QPEApplication::qpeDir()+"/plugins/"+mytype
* is used as plugin dir
*/
void OGenericPluginLoader::setPluginDirs( const QStringList& lst ) {
m_plugDirs = lst;
}
/**
*
* @internal
* Set the Plugin Dir to str. Str will be the only element in the list of plugin dirs
*/
void OGenericPluginLoader::setPluginDir( const QString& str) {
@@ -399,49 +494,53 @@ void OGenericPluginLoader::setPluginDir( const QString& str) {
* @internal
*/
bool OGenericPluginLoader::isSorted()const{
return m_isSorted;
}
/*
* make libfoo.so.1.0.0 -> foo on UNIX
* make libfoo.dylib -> foo on MAC OS X Unix
* windows is obviously missing
*/
/**
* @internal
*/
QString OGenericPluginLoader::unlibify( const QString& str ) {
QString st = str.mid( str.find( "lib" )+3 );
#ifdef Q_OS_MACX
return st.left( st.findRev( ".dylib" ) );
#else
return st.left( st.findRev( ".so" ) );
#endif
}
/**
- * Return a List of Plugins for a dir and add positions and remove disabled.
+ * @internal
+ *
+ * \brief method to return available plugins. Internal and for reeimplementations
+ *
+ *Return a List of Plugins for a dir and add positions and remove disabled.
* If a plugin is on the excluded list assign position -2
*
* @param dir The dir to look in
* @param sorted Should positions be read?
* @param disabled Remove excluded from the list
*/
OPluginItem::List OGenericPluginLoader::plugins( const QString& _dir, bool sorted, bool disabled )const {
#ifdef Q_OS_MACX
QDir dir( _dir, "lib*.dylib" );
#else
QDir dir( _dir, "lib*.so" );
#endif
OPluginItem::List lst;
/*
* get excluded list and then iterate over them
* Excluded list contains the name
* Position is a list with 'name.pos.name.pos.name.pos'
*
* For the look up we will create two QMap<QString,pos>
*/
QMap<QString, int> positionMap;
QMap<QString, int> excludedMap;
@@ -452,90 +551,328 @@ OPluginItem::List OGenericPluginLoader::plugins( const QString& _dir, bool sorte
QStringList excludes = cfg.readListEntry( "Excluded", ',' );
for ( QStringList::Iterator it = excludes.begin(); it != excludes.end(); ++it )
excludedMap.insert( *it, -2 );
if ( m_isSorted ) {
QStringList pos = cfg.readListEntry( "Positions", '.' );
QStringList::Iterator it = pos.begin();
while ( it != pos.end() )
positionMap.insert( *it++, (*it++).toInt() );
}
QStringList list = dir.entryList();
QStringList::Iterator it;
for (QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
QString str = unlibify( *it );
OPluginItem item( str, _dir + "/" + *it );
bool ex = excludedMap.contains( str );
/*
- * if disabled but we should show all assign a -2
+ * if disabled but we should show all mark it as disabled
* else continue because we don't want to add the item
* else if sorted we assign the right position
*/
if ( ex && !disabled)
- item.setPosition( -2 );
+ item.setEnabled( false );
else if ( ex && disabled )
continue;
else if ( sorted )
item.setPosition( positionMap[str] );
lst.append( item );
}
return lst;
}
/**
* @internal generate a list of languages from $LANG
*/
QStringList OGenericPluginLoader::languageList() {
if ( m_languages.isEmpty() ) {
/*
* be_BY.CP1251 We will add, be_BY.CP1251,be_BY,be
* to our list of languages.
*/
QString str = ::getenv( "LANG" );
m_languages += str;
int pos = str.find( '.' );
if ( pos > 0 )
m_languages += str.left( pos );
int n_pos = str.find( '_' );
if ( pos > 0 && n_pos >= pos )
m_languages += str.left( n_pos );
}
return m_languages;
}
+/**
+ * @internal
+ * Tries to install languages using the languageList for the type
+ */
void OGenericPluginLoader::installTranslators(const QString& type) {
QStringList lst = languageList();
/*
* for each language and maybe later for each language dir...
* try to load a Translator
*/
for ( QStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) {
QTranslator* trans = new QTranslator( qApp );
QString tfn = QPEApplication::qpeDir()+"/i18n/" + *it + "/" + type + ".qm" ;
/*
* If loaded then install else clean up and don't leak
*/
if ( trans->load( tfn ) )
qApp->installTranslator( trans );
else
delete trans;
}
}
+/**
+ * \brief Simple c'tor.
+ *
+ * Simple C'tor same as the one of the base class. Additional this
+ * class can cast for you if you nee it.
+ *
+ *
+ * @param name The name of your plugin class
+ * @param sorted If plugins are sorted
+ *
+ * @see OGenericPluginLoader
+ */
+OPluginLoader::OPluginLoader( const QString& name, bool sorted )
+ : OGenericPluginLoader( name, sorted )
+{
+}
+
+/**
+ * d'tor
+ * @see OGenericPluginLoader::~OGenericPluginLoader
+ */
+OPluginLoader::~OPluginLoader() {
+}
+
+/**
+ * \brief C'Tor using a OGenericPluginLoader
+ * The C'tor. Pass your OGenericPluginLoader to manage
+ * OGenericPluginLoader::allAvailable plugins.
+ *
+ *
+ * @param loader A Pointer to your OGenericPluginLoader
+ * @param name The name
+ */
+OPluginManager::OPluginManager( OGenericPluginLoader* loader)
+ : m_loader( loader )
+{
+}
+
+/**
+ * \brief Overloaded c'tor using a List of Plugins and a type name
+ * Overloaded Constructor to work with a 'Type' of plugins
+ * and a correspending list of those. In this case calling load
+ * is a no operation.
+ *
+ * @param name The name of your plugin ('today','inputmethods','applets')
+ * @param lst A List with plugins of your type to manage
+ * @param isSorted If the List should be treated sorted
+ */
+OPluginManager::OPluginManager( const QString& name, const OPluginItem::List& lst, bool isSorted)
+ : m_loader( 0l ), m_cfgName( name ), m_plugins( lst ), m_isSorted( isSorted )
+{
+}
+
+/**
+ * \brief A simple d'tor
+ */
+OPluginManager::~OPluginManager() {
+}
+
+/**
+ * \brief Return the OPluginItem where loading is likely to have crashed on.
+ * Return the Item that made the OGenericPluginLoader crash
+ * the returned OPluginItem could be empty if no crash occured
+ * which should apply most of the time. It could also be empty if the crashed
+ * plugin is not in the current list of available/managed plugins
+ *
+ * @see OPluginItem::isEmpty
+ * @return OPluginItem that crashed the loader
+ */
+OPluginItem OPluginManager::crashedPlugin()const {
+ return m_crashed;
+}
+
+/**
+ * \brief Return a list of plugins that are managed by this OPluginManager
+ *
+ * Return the list of managed plugins. This could either result
+ * from passing a OGenericPluginLoader and calling load or by
+ * giving name and a list of plugins.
+ */
+OPluginItem::List OPluginManager::managedPlugins()const {
+ return m_plugins;
+}
+
+/**
+ * \brief Set the position of the items
+ *
+ * Replace the OPluginItem with the name and path and this way
+ * apply the new position. The search is linear and this way O(n/2)
+ * You still need to call save() to make your changes effective. After saving
+ * a call to OGenericPluginLoader::filtered() returns the newly configured order and items
+ *
+ * @param item The OPluginItem to be replaced internall
+ *
+ */
+void OPluginManager::setPosition( const OPluginItem& item) {
+ replace( item );
+}
+
+/**
+ * \brief Enable the item specified as argument
+ *
+ * This will make sure that OPluginItem::setEnabled is called and then will replace
+ * the item with one that matches name and path internally.
+ * @see setPosition
+ *
+ * @param the Item to enable
+ */
+void OPluginManager::enable( const OPluginItem& item ) {
+ setEnabled( item, true );
+}
+
+/**
+ * \brief disable the Item.
+ *
+ * Disable the OPluginItem. Same applies as in
+ * @see setPosition and @see enable
+ *
+ * @param item Item to disable
+ */
+void OPluginManager::disable( const OPluginItem& item) {
+ setEnabled( item, false );
+}
+
+/**
+ * \brief Enable or disable the OPluginItem.
+ * Depending on the value of the parameter this will either disable
+ * or enable the pluginitem.
+ * Beside that same as in @see disable, @see enable, @see setPosition
+ * applies.
+ *
+ * @param _item The OPluginItem to enable or to disable.
+ * @param b Enable or disable the plugin.
+ *
+ */
+void OPluginManager::setEnabled( const OPluginItem& _item, bool b ) {
+ OPluginItem item = _item;
+ item.setEnabled( b );
+ replace( item );
+}
+
+/**
+ * \brief Load necessary information after constructing the object
+ * If you speified a OGenericPluginLoader you need to call this method
+ * so that this manager knows what to manage and have a right value for \sa crashedPlugin
+ * For the name and the list of plugins this does only try to find out the crashed plugin
+ */
+void OPluginManager::load() {
+ OConfig cfg( configName() );
+ cfg.setGroup( "General" );
+ QString crashedPath = cfg.readEntry( "CrashedPlugin" );
+
+ /* if we've a loader this applies if we were called from the first part */
+ if ( m_loader )
+ m_plugins = m_loader->allAvailable( m_loader->isSorted() );
+
+ /* fast and normal route if we did not crash... */
+ if ( crashedPath.isEmpty() )
+ return;
+
+ /* lets try to find the plugin path and this way the associated item */
+ for ( OPluginItem::List::Iterator it = m_plugins.begin(); it != m_plugins.end(); ++it )
+ if ( (*it).path() == crashedPath ) {
+ m_crashed = *it;
+ break;
+ }
+}
+
+
+/**
+ * \brief Save the values and this way make it available.
+ *
+ * Save the current set of data. A call to @see OGenericPluginLoader::filtered
+ * now would return your saved changes.
+ */
+void OPluginManager::save() {
+ QMap<QString, QStringList> excluded; // map for path to excluded name
+ QMap<QString, QStringList> positions; // if positions matter contains splitted up by dirs
+ bool sorted = m_loader ? m_loader->isSorted() : m_isSorted;
+
+ /*
+ * We will create some maps for the groups to include positions a
+ */
+ for ( OPluginItem::List::Iterator it = m_plugins.begin(); it != m_plugins.end(); ++it ) {
+ OPluginItem item = *it;
+ QString path = QFileInfo( item.path() ).filePath();
+ if ( sorted ) {
+ positions[path].append( item.name() );
+ positions[path].append( QString::number( item.position() ) );
+ }
+
+ if ( !item.isEnabled() )
+ excluded[path].append( item.name() );
+ }
+
+/*
+ * The code below wouldn't work because we can't delete groups/keys from the config
+ * ### for ODP make Config right!
+ */
+// if ( excluded.isEmpty() && positions.isEmpty() ) return;
+ /*
+ * Now safe for each path
+ */
+ OConfig cfg( configName() );
+
+ /* safe excluded items */
+ for ( QMap<QString, QStringList>::Iterator it = excluded.begin(); it != excluded.end(); ++it ) {
+ OConfigGroupSaver saver( &cfg, it.key() );
+ cfg.writeEntry("Excluded", it.data(), ',' );
+ }
+
+ /* safe positions we could also see if positions.contains(path) and remove/write in the above loop
+ * ### Write a Test Suite that can profile these runs...
+ */
+ for ( QMap<QString, QStringList>::Iterator it = positions.begin(); it != positions.end(); ++it ) {
+ OConfigGroupSaver saver( &cfg, it.key() );
+ cfg.writeEntry("Positions", it.data(), '.' );
+ }
+}
+
+/**
+ * @internal
+ */
+QString OPluginManager::configName()const {
+ QString str = m_loader ? m_loader->name() : m_cfgName;
+ return str + "odpplugins";
+}
+
+/**
+ * @internal.. replace in m_plugins by path... this is linear search O(n/2)
+ */
+void OPluginManager::replace( const OPluginItem& item ) {
+// ### fixme
+}
}
}
diff --git a/libopie2/opiecore/opluginloader.h b/libopie2/opiecore/opluginloader.h
index 6166b75..2f9ec2a 100644
--- a/libopie2/opiecore/opluginloader.h
+++ b/libopie2/opiecore/opluginloader.h
@@ -11,171 +11,196 @@
#include <qstringlist.h>
namespace Opie {
namespace Core {
class OConfig;
namespace Internal {
class OPluginLibraryHolder;
}
template class QPtrDict<QLibrary>;
/**
* \brief A small item representing the Plugin Information
* This class contains the information about a Plugin. It contains
* a translated name if available to the system, a config key,
* and the path location.
*
* @since 1.2
*
*/
class OPluginItem {
public:
typedef QValueList<OPluginItem> List;
OPluginItem();
- OPluginItem( const QString& name, const QString& path, int pos = -1 );
+ OPluginItem( const QString& name, const QString& path, bool enabled = true, int pos = -1 );
~OPluginItem();
+ bool isEmpty()const;
+
bool operator==( const OPluginItem& )const;
bool operator!=( const OPluginItem& )const;
QString name()const;
QString path()const;
+ bool isEnabled()const;
int position()const;
void setName( const QString& );
void setPath( const QString& );
+ void setEnabled( bool );
void setPosition( int );
private:
QString m_name;
QString m_path;
+ bool m_enabled : 1;
int m_pos;
struct Private;
Private *d;
};
/**
* \brief A generic class to easily load and manage plugins
*
* This is the generic non sepcialised loader for plugins. Normally
* you would prefer using the OPluginLoader directly. This class
* exists to minimize the application binary size due the usage
* of templates in the specialized API
*
* @since 1.2
* @see OPluginLoader
*/
class OGenericPluginLoader {
public:
typedef OPluginItem::List List;
OGenericPluginLoader( const QString &name, bool isSorted = false );
virtual ~OGenericPluginLoader();
void setAutoDelete( bool );
bool autoDelete()const;
void clear();
-
+ QString name()const;
+ bool isSorted()const;
bool isInSafeMode()const;
- List allAvailable(bool sorted = FALSE)const;
- List filtered(bool sorted = FALSE)const;
+ List allAvailable(bool sorted = false )const;
+ List filtered(bool sorted = false )const;
virtual QUnknownInterface* load( const OPluginItem& item, const QUuid& );
virtual void unload( QUnknownInterface* );
protected:
+ friend class OPluginManager; // we need the static unlibify
void readConfig();
virtual List plugins( const QString& dir, bool sorted, bool disabled )const;
void setPluginDirs( const QStringList& );
void setPluginDir( const QString& );
- bool isSorted()const;
void setSafeMode(const QString& app = QString::null, bool b = false);
static QString unlibify( const QString& str );
-
private:
QStringList languageList();
void installTranslators(const QString& type);
QString m_dir;
QStringList m_plugDirs;
QStringList m_languages;
bool m_autoDelete : 1;
bool m_isSafeMode : 1;
bool m_isSorted : 1;
QPtrDict<QLibrary> m_library;
struct Private;
Private* d;
};
/**
* \brief The class to load your QCOM+ plugins
*
* This class takes care of activation and even the order
* if you need it. It is normally good to place a .directory file
* into your plugin directory if you need order of activation.
*
* You'll create the OPluginLoader and then use it to load the filtered
* plugins.
*
* There is also a GUI for the configuration and a Manager to write the
* mentioned .directory file
*
* On crash the safe mode is activated for the next run. You can then decide
* if you want to load plugins or come up with the Configuration on
* next start yourself then.
*
* @since 1.2
*/
class OPluginLoader : public OGenericPluginLoader {
public:
OPluginLoader( const QString& name, bool sorted = false );
- ~OPluginLoader();
+ virtual ~OPluginLoader();
template<class IFace>
IFace* load( const OPluginItem& item, const QUuid& );
};
/**
- * \brief A class to manager order and activation of plugins
+ * \brief A class to manage order and activation of plugins
*
* Manage order and activation. This is used by the Opie::Ui::OPluginConfig
* This class controls the activation and order of plugins depending
* on the OPluginLoader you supply.
+ * You must call load() and save after construnction an instance
*
- * @see OPluginConfig
+ * @see Opie::Ui::OPluginConfig
*
*/
class OPluginManager {
public:
- OPluginManager( OGenericPluginLoader* , const QString& name);
- OPluginManager( OConfig* conf, const QString&,
- const QCString& group, const OPluginItem::List& );
- ~OPluginManager();
+ OPluginManager( OGenericPluginLoader* );
+ OPluginManager( const QString& name, const OPluginItem::List&, bool isSorted = false );
+ virtual ~OPluginManager();
- QString name();
- void setName( const QString& );
+ OPluginItem crashedPlugin()const;
+
+ OPluginItem::List managedPlugins()const;
void setPosition( const OPluginItem& );
void enable( const OPluginItem& );
void disable( const OPluginItem& );
void setEnabled( const OPluginItem&, bool = true);
- void load();
- void save();
+ virtual void load();
+ virtual void save();
+
+protected:
+ QString configName()const;
+ void replace( const OPluginItem& );
+private:
+ OGenericPluginLoader *m_loader;
+ QString m_cfgName;
+ OPluginItem::List m_plugins;
+ OPluginItem m_crashed;
+ bool m_isSorted : 1;
};
+/**
+ * This is a template method allowing you to safely cast
+ * your load function
+ *
+ * \code
+ * MyTypePlugin *plug = load->load<MyTypePlugin>( item, IID_MyPlugin );
+ * \endcode
+ *
+ */
template<class IFace>
IFace* OPluginLoader::load( const OPluginItem& item, const QUuid& uid ) {
return static_cast<IFace*>( OGenericPluginLoader::load( item, uid ) );
}
}
}
#endif