Blokkal

an Extendable KDE Blogging Client

• Download
• Screenshots
• LiveJournal Community
• API Documentation
• Contact

• Class Hierarchy
• Class List
• File List
• Class Members

blokkalpluginmanager.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Martin Müller   *
 *   orvio@orvio.de   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "blokkalpluginmanager.h"
#include "blokkalpluginmanager.moc"

#include "blokkalprotocol.h"
#include "blokkalplugin.h"
#include "blokkalui/editentryviewfactory.h"
#include "blokkalui/browseentryviewfactory.h"

#include <kparts/componentfactory.h>
#include <ktrader.h>
#include <kdebug.h>

#include <qtimer.h>

#include <iostream>


class Blokkal::PluginManagerPrivate {
public:
        PluginManagerPrivate( void ):
        availablePlugins( KPluginInfo::fromServices( KServiceTypeTrader::self()->query( QString::fromLatin1(  "Blokkal/Plugin" ) ) ) ),
        shuttingDown( FALSE )
        {}

        KPluginInfo::List availablePlugins;
        QMap<KPluginInfo, Plugin *> infoPluginMap;

        bool shuttingDown;

        PluginManager instance;

        KPluginInfo::List filterPlugins( const QString & serviceType )
        {
                if( availablePlugins.isEmpty() ) {
                        return availablePlugins;
                }
        
                KPluginInfo::List filteredPluginList;
                for( KPluginInfo::List::ConstIterator it = availablePlugins.begin();
                     it != availablePlugins.end();
                     ++it )
                {
                        if( (*it).service()->serviceTypes().contains( serviceType ) ) {
                                filteredPluginList.append( *it );
                        }
                }

                return filteredPluginList;
        }
};

K_GLOBAL_STATIC( Blokkal::PluginManagerPrivate, _bpmp );

Blokkal::PluginManager::PluginManager( void ):
QObject( 0 )
{
        setObjectName( "PluginManger" );
        KGlobal::ref();
}

Blokkal::PluginManager::~PluginManager( void )
{
}

Blokkal::PluginManager * Blokkal::PluginManager::self( void )
{

        return &_bpmp->instance;
}

KPluginInfo::List Blokkal::PluginManager::availablePlugins( void ) const
{
        return _bpmp->availablePlugins;
}

KPluginInfo::List Blokkal::PluginManager::availableProtocols( void ) const
{
        return _bpmp->filterPlugins( "Blokkal/Protocol" );
}


KPluginInfo::List Blokkal::PluginManager::availableEditEntryViewFactorys( void ) const
{
        return _bpmp->filterPlugins( "Blokkal/EditEntryViewFactory" );
}

Blokkal::Protocol * Blokkal::PluginManager::protocol( const QString & pluginName )
{
        Blokkal::Plugin * plugin = this->loadPlugin( pluginName );

        if( !plugin ) {
                return 0;
        }

        KPluginInfo info = pluginInfo( plugin );
        if( info.service()->serviceTypes().contains( "Blokkal/Protocol" ) ) {
                return (Blokkal::Protocol*) plugin;
        }
        
        kError() << pluginName << " does not provide service type Blokkal/Protocol";
        return 0 ;
}


Blokkal::Ui::EditEntryViewFactory * Blokkal::PluginManager::editEntryViewFactory( const QString & pluginName )
{
        Blokkal::Plugin * plugin = loadPlugin( pluginName.isEmpty() ? "blokkal_eevp" : pluginName );
        if( !plugin ) {
                return 0;
        }

        KPluginInfo info = pluginInfo( plugin );
        if( info.service()->serviceTypes().contains( "Blokkal/EditEntryViewFactory" ) ) {
                return (Blokkal::Ui::EditEntryViewFactory*) plugin;
        }
        
        kError() << pluginName << " does not provide service type Blokkal/EditEntryViewFactory";
        return 0 ;
}

Blokkal::Plugin * Blokkal::PluginManager::plugin( const QString & pluginName )
{
        return loadPlugin( pluginName );
}

KPluginInfo Blokkal::PluginManager::pluginInfo( const QString & pluginName ) const
{
        for( KPluginInfo::List::ConstIterator it = _bpmp->availablePlugins.begin();
             it != _bpmp->availablePlugins.end();
             ++it )
        {
                if( (*it).pluginName() == pluginName ) {
                        return *it;
                }
        }

        return KPluginInfo();
}

KPluginInfo Blokkal::PluginManager::pluginInfo( const Plugin * plugin ) const
{
        if( !plugin ) {
                kError() << "called with 0 pointer!" << endl;
        }

        if( _bpmp->infoPluginMap.isEmpty() ) {
                kError() << "trying to get plugin info while no plugins are loaded" << endl;
                return KPluginInfo();
        }
        
        //kdDebug() << "Starting search" << endl;
        KPluginInfo::List keys = _bpmp->infoPluginMap.keys();
        for( KPluginInfo::List::ConstIterator it = keys.begin();
             it != keys.end();
             ++it )
        {
                //kdDebug() << *it << endl;
                //kdDebug() << _bpmp->infoPluginMap[ *it ] << " <?> " << plugin << endl;
                if( _bpmp->infoPluginMap[ *it ] == plugin ) {
                        return *it;
                }
        }

        kError() << "unable to find info for loaded plugin!" << endl;
        if( plugin ) {
                kError() <<  "Problem caused by: " << plugin->metaObject()->className() << endl;
        }
        return KPluginInfo();
}

void Blokkal::PluginManager::unloadPlugin( const QString & pluginName )
{
        //kDebug() << "unloading plugin: " << pluginName << endl;
        KPluginInfo info = pluginInfo( pluginName );
        if( !info.isValid() ) {
                kWarning() << "Trying to unload nonexistent plugin with name " << pluginName << endl;
        }
        
        if( _bpmp->infoPluginMap.contains( info ) ) {
                //the plugin will emit readyToUnload and eventually
                //then it is deleted which will in turn case
                //QObject::destroyed() to be emitted. This will
                //call removePlugin()
                _bpmp->infoPluginMap[ info ]->prepareToUnload();
        }
}

void Blokkal::PluginManager::unloadAllPlugins( void )
{
        for( QMap<KPluginInfo, Plugin *>::Iterator it = _bpmp->infoPluginMap.begin();
             it != _bpmp->infoPluginMap.end() ;
              )
        {
                QString pluginName = it.key().pluginName();
                ++it;
                unloadPlugin( pluginName );
        }
}

void Blokkal::PluginManager::deletePlugin( Blokkal::Plugin * plugin )
{
        QTimer::singleShot( 0, plugin, SLOT( deleteLater( void ) ) );
}

Blokkal::Plugin * Blokkal::PluginManager::loadPlugin( const QString & pluginName )
{
        KPluginInfo info = pluginInfo( pluginName );
        if( !info.isValid() ) {
                kError() << "No plugin found with name " << pluginName << endl;
                return 0;
        }

        Blokkal::Plugin * plugin = 0;
        if( _bpmp->infoPluginMap.contains( info ) ) {
                plugin = _bpmp->infoPluginMap[ info ];
                return plugin;
        }
        
        QString error;
        plugin = KServiceTypeTrader::createInstanceFromQuery<Blokkal::Plugin>( QString::fromLatin1( "Blokkal/Plugin" ), QString::fromLatin1( "[X-KDE-PluginInfo-Name]=='%1'" ).arg( pluginName ), this, QVariantList(), & error );

        if( plugin ) {
                _bpmp->infoPluginMap.insert( info, plugin );
                connect( plugin, SIGNAL( readyToUnload( Blokkal::Plugin * ) ),
                         this, SLOT( deletePlugin( Blokkal::Plugin * ) ) );
                connect( plugin, SIGNAL( destroyed ( QObject * ) ),
                         this, SLOT( removePlugin( QObject * ) ) );
                emit pluginLoaded( plugin );
                return plugin;
        }
        else {
                kError() << "error loading plugin " << pluginName << endl;
        }

        return plugin;
}

void Blokkal::PluginManager::removePlugin( QObject * plugin )
{
        if( _bpmp->infoPluginMap.isEmpty() ) {
                return;
        }
        
        for( QMap<KPluginInfo, Plugin *>::Iterator it = _bpmp->infoPluginMap.begin();
             it != _bpmp->infoPluginMap.end();
             ++it )
        {
                if( it.value() == plugin ) {
                        _bpmp->infoPluginMap.remove( it.key() );
                        break;
                }
        }

        if( _bpmp->shuttingDown && _bpmp->infoPluginMap.isEmpty() ) {
                KGlobal::deref();
        }
}

void Blokkal::PluginManager::shutdown( void )
{
        _bpmp->shuttingDown = TRUE;
        unloadAllPlugins();
}

KPluginInfo::List Blokkal::PluginManager::availableBrowseEntryViewFactorys( void ) const
{
        return _bpmp->filterPlugins( "Blokkal/BrowseEntryViewFactory" );
}

Blokkal::Ui::BrowseEntryViewFactory * Blokkal::PluginManager::browseEntryViewFactory( const QString & pluginName )
{
        Blokkal::Plugin * plugin = loadPlugin( pluginName.isEmpty() ? "blokkal_bevp" : pluginName );
        if( !plugin ) {
                return 0;
        }

        KPluginInfo info = pluginInfo( plugin );
        if( info.service()->serviceTypes().contains( "Blokkal/BrowseEntryViewFactory" ) ) {
                return (Blokkal::Ui::BrowseEntryViewFactory*) plugin;
        }
                
        kError() << pluginName << " does not provide service type Blokkal/BrowseEntryViewFactory";
        return 0 ;
}