Make harlekin happy. AkA uncomitted code

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
@@ -520,97 +520,96 @@ QString OGenericPluginLoader::unlibify( const QString& str ) {
  * \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;
 
 
     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.
          */
         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;
 }
 
 /**
@@ -627,97 +626,97 @@ void OGenericPluginLoader::installTranslators(const QString& type) {
     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 )
+    : 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
  *
  * @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;
@@ -826,53 +825,66 @@ void OPluginManager::save() {
         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
+    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
@@ -112,95 +112,96 @@ private:
     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 );
     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
  *
  * \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