| -rw-r--r-- | libopie2/opiecore/opluginloader.cpp | 18 | ||||
| -rw-r--r-- | libopie2/opiecore/opluginloader.h | 1 |
2 files changed, 16 insertions, 3 deletions
diff --git a/libopie2/opiecore/opluginloader.cpp b/libopie2/opiecore/opluginloader.cpp index 2aca382..87e24d4 100644 --- a/libopie2/opiecore/opluginloader.cpp +++ b/libopie2/opiecore/opluginloader.cpp @@ -536,65 +536,64 @@ OPluginItem::List OGenericPluginLoader::plugins( const QString& _dir, bool sorte 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; OConfig cfg( m_dir+"odpplugins" ); cfg.setGroup( _dir ); 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 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.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. */ @@ -643,65 +642,65 @@ void OGenericPluginLoader::installTranslators(const QString& type) { * * 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 ) + : m_loader( loader ), m_isSorted( false ) { } /** * \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 * @@ -842,37 +841,50 @@ void OPluginManager::save() { /* * 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 + OPluginItem _item; + + /* for all plugins */ + for ( OPluginItem::List::Iterator it=m_plugins.begin();it != m_plugins.end(); ++it ) { + _item = *it; + /* if path and name are the same we will remove, readd and return */ + if ( _item.path() == item.path() && + _item.name() == item.name() ) { + it = m_plugins.remove( it ); + m_plugins.append( item ); + return; + } + + } } } } diff --git a/libopie2/opiecore/opluginloader.h b/libopie2/opiecore/opluginloader.h index 2f9ec2a..740551c 100644 --- a/libopie2/opiecore/opluginloader.h +++ b/libopie2/opiecore/opluginloader.h @@ -128,64 +128,65 @@ private: * * 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 ); virtual ~OPluginLoader(); template<class IFace> IFace* load( const OPluginItem& item, const QUuid& ); }; /** * \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 Opie::Ui::OPluginConfig * */ class OPluginManager { public: + typedef QValueList<OPluginManager*> List; OPluginManager( OGenericPluginLoader* ); OPluginManager( const QString& name, const OPluginItem::List&, bool isSorted = false ); virtual ~OPluginManager(); 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); 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 * |