2 files changed, 22 insertions, 24 deletions

diff --git a/kabc/stdaddressbook.cpp b/kabc/stdaddressbook.cpp
index f9fc70b..8faaaef 100644
--- a/kabc/stdaddressbook.cpp
+++ b/kabc/stdaddressbook.cpp
@@ -1,135 +1,122 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
-#ifndef DESKTOP_VERSION
-#include <qpe/global.h>
-#else
-
-#include <qdir.h>
-#endif
-#ifdef KAB_EMBEDDED
 
+/*US
 #include <stdlib.h>
-#else //KAB_EMBEDDED
 
-#include <stdlib.h>
-
-//US#include <kresources/manager.h>
 #include <kapplication.h>
 #include <kcrash.h>
 #include <ksimpleconfig.h>
-
-
-#endif //KAB_EMBEDDED
+*/
 
 #include "resource.h"
 #include <kresources/manager.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kstaticdeleter.h>
 #include <kstandarddirs.h>
 
 #include "stdaddressbook.h"
 
 using namespace KABC;
 
 StdAddressBook *StdAddressBook::mSelf = 0;
 bool StdAddressBook::mAutomaticSave = true;
 
 static KStaticDeleter<StdAddressBook> addressBookDeleter;
 
 QString StdAddressBook::fileName()
 {
   return locateLocal( "data", "kabc/std.vcf" );
 }
 
 QString StdAddressBook::directoryName()
 {
-  qDebug("StdAddressBook::directoryName() WILL FAIL OR NOT" );
   return locateLocal( "data", "kabc/stdvcf" );
 }
 
 void StdAddressBook::handleCrash()
 {
   StdAddressBook::self()->cleanUp();
 }
 
 StdAddressBook *StdAddressBook::self()
 {
  
   if ( !mSelf )
   { 
       QString appdir = StdAddressBook::setTempAppDir();
 
   kdDebug(5700) << "StdAddressBook::self()" << endl;
 // US im am not sure why I have to use the other format here??
 #ifdef KAB_EMBEDDED
     mSelf = addressBookDeleter.setObject( new StdAddressBook );
 #else //KAB_EMBEDDED
     addressBookDeleter.setObject( mSelf, new StdAddressBook );
 #endif //KAB_EMBEDDED  
     KStandardDirs::setAppDir( appdir );  
   }
 
   return mSelf;
 }
 
 QString StdAddressBook::setTempAppDir()
 {
     QString appDIR = KStandardDirs::appDir();
 #ifdef DESKTOP_VERSION
     QString appdir = QDir::homeDirPath();
       if ( appdir.right(1) == "\\" ||   appdir.right(1) == "/" )
           appdir += "kaddressbook/";
       else
           appdir += "/kaddressbook/";
       KStandardDirs::setAppDir( QDir::convertSeparators( appdir ));
 #else
       KStandardDirs::setAppDir( Global::applicationFileName( "kaddressbook", "" ) );  
 #endif
 
     return appDIR;
 }
 StdAddressBook *StdAddressBook::self( bool onlyFastResources )
 {
  
    if ( !mSelf )
   { 
       QString appdir =StdAddressBook::setTempAppDir();
 #ifdef KAB_EMBEDDED
     mSelf = addressBookDeleter.setObject( new StdAddressBook( onlyFastResources ) );
 #else //KAB_EMBEDDED
     addressBookDeleter.setObject( mSelf, new StdAddressBook( onlyFastResources ) );
 #endif //KAB_EMBEDDED 
     KStandardDirs::setAppDir( appdir );  
   }
   return mSelf;
 }
 
 StdAddressBook::StdAddressBook()
 //US  : AddressBook( "kabcrc" )
   : AddressBook( locateLocal( "config", "kabcrc") )
 {
@@ -150,100 +137,97 @@ StdAddressBook::~StdAddressBook()
   if ( mAutomaticSave )
     save();
 }
 
 void StdAddressBook::init( bool )
 {
   KRES::Manager<Resource> *manager = resourceManager();
   KRES::Manager<Resource>::ActiveIterator it;
 
   for ( it = manager->activeBegin(); it != manager->activeEnd(); ++it ) {
     (*it)->setAddressBook( this );
     if ( !(*it)->open() )
       error( QString( "Unable to open resource '%1'!" ).arg( (*it)->resourceName() ) );
   }
   
   Resource *res = standardResource();
   if ( !res ) {
     res = manager->createResource( "file" );
     if ( res )
     {
       addResource( res );
     }
     else
       kdDebug(5700) << "No resource available!!!" << endl;
   }
 
   setStandardResource( res );
   manager->writeConfig();
 
   load();
 }
 
 bool StdAddressBook::save()
 {
   kdDebug(5700) << "StdAddressBook::save()" << endl;
 
   bool ok = true;
   AddressBook *ab = self();
 
   ab->deleteRemovedAddressees();
 
   KRES::Manager<Resource>::ActiveIterator it;
   KRES::Manager<Resource> *manager = ab->resourceManager();
   for ( it = manager->activeBegin(); it != manager->activeEnd(); ++it ) {
     if ( !(*it)->readOnly() && (*it)->isOpen() ) {
       Ticket *ticket = ab->requestSaveTicket( *it );
 //        qDebug("StdAddressBook::save '%s'", (*it)->resourceName().latin1() );
       if ( !ticket ) {
         ab->error( i18n( "Unable to save to resource '%1'. It is locked." )
                    .arg( (*it)->resourceName() ) );
         return false;
       }
 
       if ( !ab->save( ticket ) )
         ok = false;
     }
   }
   
   return ok;
 }
 
 void StdAddressBook::close()
 {
 //US destructObject is not defined on my system???. Is setObject(0) the same ???
-#ifndef KAB_EMBEDDED
-  addressBookDeleter.destructObject();
-#else //KAB_EMBEDDED
+//US  addressBookDeleter.destructObject();
   addressBookDeleter.setObject(0);
-#endif //KAB_EMBEDDED
   
 }
 
 void StdAddressBook::setAutomaticSave( bool enable )
 {
   mAutomaticSave = enable;
 }
 
 bool StdAddressBook::automaticSave()
 {
   return mAutomaticSave;
 }
 
 // should get const for 4.X
 Addressee StdAddressBook::whoAmI()
 {
 //US  KConfig config( "kabcrc" );
   KConfig config( locateLocal("config", "kabcrc") );
   config.setGroup( "General" );
 
   return findByUid( config.readEntry( "WhoAmI" ) );
 }
 
 void StdAddressBook::setWhoAmI( const Addressee &addr )
 {
 //US  KConfig config( "kabcrc" );
   KConfig config( locateLocal("config", "kabcrc") );
   config.setGroup( "General" );
 
   config.writeEntry( "WhoAmI", addr.uid() );
 }
diff --git a/microkde/kdecore/klibloader.cpp b/microkde/kdecore/klibloader.cpp
index 1410308..130cc7c 100644
--- a/microkde/kdecore/klibloader.cpp
+++ b/microkde/kdecore/klibloader.cpp
@@ -96,129 +96,130 @@ QObject* KLibFactory::createObject( QObject*, const char*, const char*, const QS
 }
 
 
 // -----------------------------------------------
 
 //US KLibrary::KLibrary( const QString& libname, const QString& filename, void * handle )
 KLibrary::KLibrary( const QString& libname, const QString& filename, QLibrary* handle )
 {
     /* Make sure, we have a KLibLoader */
     (void) KLibLoader::self();
     m_libname = libname;
     m_filename = filename;
     m_handle = handle;
     m_factory = 0;
     m_timer = 0;
 }
 
 KLibrary::~KLibrary()
 {
 //    kdDebug(150) << "Deleting KLibrary " << this << "  " << m_libname << endl;
     if ( m_timer && m_timer->isActive() )
         m_timer->stop();
 
     // If any object is remaining, delete
     if ( m_objs.count() > 0 )
         {
             QPtrListIterator<QObject> it( m_objs );
             for ( ; it.current() ; ++it )
                 {
                     kdDebug(150) << "Factory still has object " << it.current() << " " << it.current()->name () << " Library = " << m_libname << endl;
                     disconnect( it.current(), SIGNAL( destroyed() ),
                                 this, SLOT( slotObjectDestroyed() ) );
                 }
             m_objs.setAutoDelete(true);
             m_objs.clear();
         }
 
     if ( m_factory ) {
         //kdDebug(150) << " ... deleting the factory " << m_factory << endl;
         delete m_factory;
     }
 }
 
 QString KLibrary::name() const
 {
     return m_libname;
 }
 
 QString KLibrary::fileName() const
 {
     return m_filename;
 }
 
 KLibFactory* KLibrary::factory()
 {
     if ( m_factory )
         return m_factory;
 
         QCString symname;
         symname.sprintf("init_%s", name().latin1() );
 
     void* sym = symbol( symname );
         if ( !sym )
         {
-            kdWarning(150) << "KLibrary: The library " << name() << " does not offer an init_" << name() << " function" << endl;
+            qDebug("KLibrary: The library %s does not offer an %s function", name().latin1(), symname.data());
+            kdWarning(150) << "KLibrary: The library " << name().latin1() << " does not offer an init_" << name().latin1() << " function" << endl;
             return 0;
     }
 
     typedef KLibFactory* (*t_func)();
     t_func func = (t_func)sym;
     m_factory = func();
 
     if( !m_factory )
     {
         kdWarning(150) << "KLibrary: The library " << name() << " does not offer a KDE compatible factory" << endl;
         return 0;
     }
 
     connect( m_factory, SIGNAL( objectCreated( QObject * ) ),
              this, SLOT( slotObjectCreated( QObject * ) ) );
 
     return m_factory;
 }
 
 void* KLibrary::symbol( const char* symname ) const
 {
 //US     void* sym = lt_dlsym( (lt_dlhandle) m_handle, symname );
          void* sym = m_handle->resolve( symname );    
     if ( !sym )
     {
 //US        kdWarning(150) << "KLibrary: " << lt_dlerror() << endl;
         kdWarning(150) << "KLibrary: " << m_libname << ", symbol:" << symname << " not found " << endl;
         return 0;
     }
 
     return sym;
 }
 
 bool KLibrary::hasSymbol( const char* symname ) const
 {
 //US    void* sym = lt_dlsym( (lt_dlhandle) m_handle, symname );
          void* sym = m_handle->resolve( symname );    
     return (sym != 0L );
 }
 
 void KLibrary::unload() const
 {
    if (KLibLoader::s_self)
       KLibLoader::s_self->unloadLibrary(QFile::encodeName(name()));
 }
 
 void KLibrary::slotObjectCreated( QObject *obj )
 {
   if ( !obj )
     return;
 
   if ( m_timer && m_timer->isActive() )
     m_timer->stop();
 
   if ( m_objs.containsRef( obj ) )
       return; // we know this object already
 
   connect( obj, SIGNAL( destroyed() ),
            this, SLOT( slotObjectDestroyed() ) );
 
   m_objs.append( obj );
 }
 
 void KLibrary::slotObjectDestroyed()
@@ -307,217 +308,230 @@ public:
 
     QString errorMessage;
 };
 
 KLibLoader* KLibLoader::s_self = 0;
 
 KLibLoader* KLibLoader::self()
 {
     if ( !s_self )
         s_self = new KLibLoader;
     return s_self;
 }
 
 void KLibLoader::cleanUp()
 {
   if ( !s_self )
     return;
 
   delete s_self;
   s_self = 0;
 }
 
 KLibLoader::KLibLoader( QObject* parent, const char* name )
     : QObject( parent, name )
 {
     s_self = this;
     d = new KLibLoaderPrivate;
 //US    lt_dlinit();
     d->unload_mode = KLibLoaderPrivate::UNKNOWN;
     if (getenv("KDE_NOUNLOAD") != 0)
         d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;
     else if (getenv("KDE_DOUNLOAD") != 0)
         d->unload_mode = KLibLoaderPrivate::UNLOAD;
     d->loaded_stack.setAutoDelete( true );
 }
 
 KLibLoader::~KLibLoader()
 {
 //    kdDebug(150) << "Deleting KLibLoader " << this << "  " << name() << endl;
 
     QAsciiDictIterator<KLibWrapPrivate> it( m_libs );
     for (; it.current(); ++it )
     {
       kdDebug(150) << "The KLibLoader contains the library " << it.current()->name
         << " (" << it.current()->lib << ")" << endl;
       d->pending_close.append(it.current());
     }
 
     close_pending(0);
 
     delete d;
 }
 
 //static
 QString KLibLoader::findLibrary( const char * name/*US , const KInstance * instance*/ )
 {
     QCString libname( name );
 
     // only append ".la" if there is no extension
     // this allows to load non-libtool libraries as well
     // (mhk, 20000228)
     int pos = libname.findRev('/');
     if (pos < 0)
       pos = 0;
-    if (libname.find('.', pos) < 0)
+/*US      
+    if (libname.find('.', pos) < 0) {
       libname += ".la";
+    }
+*/    
+//US in the microedition we work only with shared libraries.
+    if (libname.find('.', pos) < 0) {
+      libname += ".so";
+    }
 
     // only look up the file if it is not an absolute filename
     // (mhk, 20000228)
     QString libfile;
     if (libname[0] == '/')
       libfile = libname;
     else
     {
+//US at this point the libname must exist as real filesname. No expansions will be made later
+// in findResources. Because of that we prepend the lib prefix here to the name 
+//US I add also the "lib" prefix. I do not how could this could have worked before without it?
+    libname.insert(pos, "lib");
+    
+    
 //US      libfile = instance->dirs()->findResource( "module", libname );
       libfile = KGlobal::dirs()->findResource( "module", libname );
       if ( libfile.isEmpty() )
       {
 //US        libfile = instance->dirs()->findResource( "lib", libname );
         libfile = KGlobal::dirs()->findResource( "lib", libname );
 #ifndef NDEBUG
         if ( !libfile.isEmpty() && libname.left(3) == "lib" ) // don't warn for kdeinit modules
           kdDebug(150) << "library " << libname << " not found under 'module' but under 'lib'" << endl;
 #endif
       }
       if ( libfile.isEmpty() )
       {
 #ifndef NDEBUG
         kdDebug(150) << "library=" << libname << ": No file names " << libname.data() << " found in paths." << endl;
 #endif
             self()->d->errorMessage = i18n("Library files for \"%1\" not found in paths").arg(libname); 
+            
+        qDebug("KLibLoader::library could not find library: %s", libname.data());
+            
       }
       else
             self()->d->errorMessage = QString::null;
     }
     return libfile;
 }
 
 
 KLibrary* KLibLoader::globalLibrary( const char *name )
 {
 KLibrary *tmp;
 /*US
 int olt_dlopen_flag = lt_dlopen_flag;
 
    lt_dlopen_flag |= LT_GLOBAL;
    kdDebug(150) << "Loading the next library global with flag " 
                 << lt_dlopen_flag
                 << "." << endl;
 */                
    tmp = library(name);
 /*US   
    lt_dlopen_flag = olt_dlopen_flag;
 */
 return tmp;
 }
 
 
 KLibrary* KLibLoader::library( const char *name )
 {
     if (!name)
         return 0;
 
     KLibWrapPrivate* wrap = m_libs[name];
     if (wrap) {
       /* Nothing to do to load the library.  */
       wrap->ref_count++;
       return wrap->lib;
     }
 
     /* Test if this library was loaded at some time, but got
        unloaded meanwhile, whithout being dlclose()'ed.  */
     QPtrListIterator<KLibWrapPrivate> it(d->loaded_stack);
     for (; it.current(); ++it) {
       if (it.current()->name == name)
         wrap = it.current();
     }
 
     if (wrap) {
       d->pending_close.removeRef(wrap);
       if (!wrap->lib) {
         /* This lib only was in loaded_stack, but not in m_libs.  */
         wrap->lib = new KLibrary( name, wrap->filename, wrap->handle );
       }
       wrap->ref_count++;
     } else {
       QString libfile = findLibrary( name );
       if ( libfile.isEmpty() )
         return 0;
 
-      const QString & qpeDir = QPEApplication::qpeDir();
-      libfile = qpeDir + libfile;
-//US      QLibrary *lib = new QLibrary( qpeDir + "/plugins/korganizer/libopiekabc.so", QLibrary::Immediately );
       QLibrary *qlib = new QLibrary( libfile.latin1(), QLibrary::Immediately );
         
 //US      lt_dlhandle handle = lt_dlopen( libfile.latin1() );
 //US      if ( !handle )
       if ( !qlib )
       {
 //US        const char* errmsg = lt_dlerror();
         char* errmsg;
         sprintf(errmsg, "KLibLoader::library could not load library: %s", libfile.latin1());
         qDebug(errmsg);
         
         if(errmsg)
             d->errorMessage = QString::fromLatin1(errmsg);
         else
             d->errorMessage = QString::null;
         kdWarning(150) << "library=" << name << ": file=" << libfile << ": " << d->errorMessage << endl;
         return 0;
       }
       else
         d->errorMessage = QString::null;
 
       KLibrary *lib = new KLibrary( name, libfile, qlib );
       wrap = new KLibWrapPrivate(lib, qlib);
       d->loaded_stack.prepend(wrap);
     }
     m_libs.insert( name, wrap );
 
     connect( wrap->lib, SIGNAL( destroyed() ),
              this, SLOT( slotLibraryDestroyed() ) );
 
     return wrap->lib;
 }
 
 QString KLibLoader::lastErrorMessage() const
 {
     return d->errorMessage;
 }
 
 void KLibLoader::unloadLibrary( const char *libname )
 {
   KLibWrapPrivate *wrap = m_libs[ libname ];
   if (!wrap)
     return;
   if (--wrap->ref_count)
     return;
 
 //  kdDebug(150) << "closing library " << libname << endl;
 
   m_libs.remove( libname );
 
   disconnect( wrap->lib, SIGNAL( destroyed() ),
               this, SLOT( slotLibraryDestroyed() ) );
   close_pending( wrap );
 }
 
 KLibFactory* KLibLoader::factory( const char* name )
 {
     KLibrary* lib = library( name );
     if ( !lib )
         return 0;
 
     return lib->factory();
 }