shell/plugincontroller.cpp

   1 /* This file is part of the KDE project
   2 Copyright 2004, 2007 Alexander Dymo <adymo@kdevelop.org>
   3 Copyright 2006 Matt Rogers <mattr@kde.org
   4 Copyright 2007 Andreas Pakulat <apaku@gmx.de>
   5
   6 Based on code from Kopete
   7 Copyright (c) 2002-2003 Martijn Klingens <klingens@kde.org>
   8
   9 This library is free software; you can redistribute it and/or
  10 modify it under the terms of the GNU Library General Public
  11 License as published by the Free Software Foundation; either
  12 version 2 of the License, or (at your option) any later version.
  13
  14 This library is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 Library General Public License for more details.
  18
  19 You should have received a copy of the GNU Library General Public License
  20 along with this library; see the file COPYING.LIB.  If not, write to
  21 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.
  23 */
  24 #include "plugincontroller.h"
  25
  26 #include <QtCore/QFile>
  27 #include <QtCore/QTimer>
  28 #include <QtGui/QApplication>
  29 #include <QtGui/QAction>
  30 #include <QtDesigner/QExtensionManager>
  31
  32 #include <kcmdlineargs.h>
  33 #include <klibloader.h>
  34 #include <kservice.h>
  35 #include <kservicetypetrader.h>
  36 #include <kmessagebox.h>
  37 #include <kconfig.h>
  38 #include <klocale.h>
  39 #include <kxmlguiwindow.h>
  40 #include <assert.h>
  41 #include <kdebug.h>
  42 #include <kdialog.h>
  43 #include <kstandarddirs.h>
  44 #include <kaction.h>
  45 #include <kxmlguifactory.h>
  46 #include <kmenu.h>
  47
  48 #include <interfaces/contextmenuextension.h>
  49 #include <interfaces/iplugin.h>
  50
  51 #include "profileengine.h"
  52 #include "mainwindow.h"
  53 #include "core.h"
  54 #include "shellextension.h"
  55
  56 namespace KDevelop
  57 {
  58
  59 class PluginControllerPrivate
  60 {
  61 public:
  62     QList<KPluginInfo> plugins;
  63
  64     //map plugin infos to currently loaded plugins
  65     typedef QMap<KPluginInfo, IPlugin*> InfoToPluginMap;
  66     InfoToPluginMap loadedPlugins;
  67
  68     // The plugin manager's mode. The mode is StartingUp until loadAllPlugins()
  69     // has finished loading the plugins, after which it is set to Running.
  70     // ShuttingDown and DoneShutdown are used during shutdown by the
  71     // async unloading of plugins.
  72     enum CleanupMode
  73     {
  74         Running     /**< the plugin manager is running */,
  75         CleaningUp  /**< the plugin manager is cleaning up for shutdown */,
  76         CleanupDone /**< the plugin manager has finished cleaning up */
  77     };
  78     CleanupMode cleanupMode;
  79
  80     QString profile;
  81     ProfileEngine engine;
  82     Core *core;
  83     QExtensionManager* m_manager;
  84 };
  85
  86 PluginController::PluginController(Core *core)
  87     : IPluginController(), d(new PluginControllerPrivate)
  88 {
  89     d->core = core;
  90     d->profile = ShellExtension::getInstance() ->defaultProfile();
  91     kDebug() << "Loading plugins which match:" << QString( "[X-KDevelop-Version] == %1" ).arg(KDEVELOP_PLUGIN_VERSION);
  92     d->plugins = KPluginInfo::fromServices( KServiceTypeTrader::self()->query( QLatin1String( "KDevelop/Plugin" ),
  93         QString( "[X-KDevelop-Version] == %1" ).arg(KDEVELOP_PLUGIN_VERSION) ) );
  94     d->cleanupMode = PluginControllerPrivate::Running;
  95     d->m_manager = new QExtensionManager();
  96 }
  97
  98 PluginController::~PluginController()
  99 {
 100     if ( d->cleanupMode != PluginControllerPrivate::CleanupDone )
 101         kWarning(9501) << "Destructing plugin controller without going through the shutdown process! Backtrace is: "
 102                        << endl << kBacktrace() << endl;
 103
 104     delete d->m_manager;
 105     delete d;
 106 }
 107
 108 QString PluginController::currentProfile() const
 109 {
 110     return d->profile;
 111 }
 112
 113 ProfileEngine& PluginController::engine() const
 114 {
 115     return d->engine;
 116 }
 117
 118 KPluginInfo PluginController::pluginInfo( const IPlugin* plugin ) const
 119 {
 120     for ( PluginControllerPrivate::InfoToPluginMap::ConstIterator it = d->loadedPlugins.begin();
 121           it != d->loadedPlugins.end(); ++it )
 122     {
 123         if ( it.value() == plugin )
 124             return it.key();
 125     }
 126     return KPluginInfo();
 127 }
 128
 129 void PluginController::cleanup()
 130 {
 131     if(d->cleanupMode != PluginControllerPrivate::Running)
 132     {
 133         kDebug() << "called when not running. state =" << d->cleanupMode;
 134         return;
 135     }
 136
 137     d->cleanupMode = PluginControllerPrivate::CleaningUp;
 138
 139     // Ask all plugins to unload
 140     while ( !d->loadedPlugins.isEmpty() )
 141     {
 142         //Let the plugin do some stuff before unloading
 143         unloadPlugin(d->loadedPlugins.begin().value(), Now);
 144     }
 145
 146     d->cleanupMode = PluginControllerPrivate::CleanupDone;
 147 }
 148
 149 IPlugin* PluginController::loadPlugin( const QString& pluginName )
 150 {
 151     return loadPluginInternal( pluginName );
 152 }
 153
 154 void PluginController::loadPlugins( PluginType type )
 155 {
 156     KPluginInfo::List offers = d->engine.offers( d->profile, type );
 157     foreach( const KPluginInfo& pi, offers )
 158     {
 159         loadPluginInternal( pi.pluginName() );
 160     }
 161 }
 162
 163 void PluginController::unloadPlugins( PluginType type )
 164 {
 165     //TODO see if this can be optimized so it's not something like O(n^2)
 166     KPluginInfo::List offers = d->engine.offers( d->profile, type );
 167     foreach( const KPluginInfo& pi, offers )
 168     {
 169         foreach ( const KPluginInfo& lpi, d->loadedPlugins.keys() )
 170         {
 171             if ( pi.pluginName() == lpi.pluginName() )
 172                 unloadPlugin( pi.pluginName() );
 173         }
 174     }
 175 }
 176
 177 QList<IPlugin *> PluginController::loadedPlugins() const
 178 {
 179     return d->loadedPlugins.values();
 180 }
 181
 182 void PluginController::unloadPlugin( const QString & pluginId )
 183 {
 184     if( IPlugin *thePlugin = plugin( pluginId ) )
 185     {
 186         unloadPlugin(thePlugin, Later);
 187     }
 188 }
 189
 190 void PluginController::unloadPlugin(IPlugin* plugin, PluginDeletion deletion)
 191 {
 192     plugin->unload();
 193
 194     //Remove the plugin from our list of plugins so we create a new
 195     //instance when we're asked for it again.
 196     //This is important to do right here, not later when the plugin really
 197     //vanishes. For example project re-opening might try to reload the plugin
 198     //and then would get the "old" pointer which will be deleted in the next
 199     //event loop run and thus causing crashes.
 200     for ( PluginControllerPrivate::InfoToPluginMap::Iterator it = d->loadedPlugins.begin();
 201             it != d->loadedPlugins.end(); ++it )
 202     {
 203         if ( it.value() == plugin )
 204         {
 205             d->loadedPlugins.erase( it );
 206             break;
 207         }
 208     }
 209
 210     if (deletion == Later)
 211         plugin->deleteLater();
 212     else
 213         delete plugin;
 214 }
 215
 216 KUrl::List PluginController::profileResources( const QString &nameFilter )
 217 {
 218     return d->engine.resources( currentProfile(), nameFilter );
 219 }
 220
 221 KUrl::List PluginController::profileResourcesRecursive( const QString &nameFilter )
 222 {
 223     return d->engine.resourcesRecursive( currentProfile(), nameFilter );
 224 }
 225
 226 QString PluginController::changeProfile( const QString &newProfile )
 227 {
 228         Q_UNUSED( newProfile );
 229     /* FIXME disabled for now
 230     QStringList unload;
 231     KService::List coreLoad;
 232     KService::List globalLoad;
 233     d->engine.diffProfiles( ProfileEngine::Core,
 234                            currentProfile(),
 235                            newProfile,
 236                            unload,
 237                            coreLoad );
 238     d->engine.diffProfiles( ProfileEngine::Global,
 239                            currentProfile(),
 240                            newProfile,
 241                            unload,
 242                            globalLoad );
 243
 244     QString oldProfile = d->profile;
 245     d->profile = newProfile;
 246
 247     unloadPlugins( unload );
 248     loadPlugins( coreLoad );
 249     loadPlugins( globalLoad );
 250
 251     return oldProfile;
 252     */
 253     return QString();
 254 }
 255
 256 KPluginInfo PluginController::infoForPluginId( const QString &pluginId ) const
 257 {
 258     QList<KPluginInfo>::ConstIterator it;
 259     for ( it = d->plugins.begin(); it != d->plugins.end(); ++it )
 260     {
 261         if ( it->pluginName() == pluginId )
 262             return *it;
 263     }
 264
 265     return KPluginInfo();
 266 }
 267
 268 IPlugin *PluginController::loadPluginInternal( const QString &pluginId )
 269 {
 270     KPluginInfo info = infoForPluginId( pluginId );
 271     if ( !info.isValid() )
 272     {
 273         kWarning(9501) << "Unable to find a plugin named '" << pluginId << "'!" ;
 274         return 0L;
 275     }
 276
 277     if ( d->loadedPlugins.contains( info ) )
 278         return d->loadedPlugins[ info ];
 279
 280     kDebug() << "Attempting to load '" << pluginId << "'";
 281     emit loadingPlugin( info.name() );
 282     QString str_error;
 283     IPlugin *plugin = 0;
 284     QStringList missingInterfaces;
 285     kDebug() << "Checking... " << info.name();
 286     if ( checkForDependencies( info, missingInterfaces ) )
 287     {
 288         QVariant prop = info.property( "X-KDevelop-PluginType" );
 289         kDebug() << "Checked... starting to load:" << info.name() << "type:" << prop;
 290         if(prop.toString()=="Kross")
 291         {
 292             kDebug() << "it is a kross plugin!!";
 293             QStringList interfaces=info.property( "X-KDevelop-Interfaces" ).toStringList();
 294             plugin = KServiceTypeTrader::createInstanceFromQuery<IPlugin>( QLatin1String( "KDevelop/Plugin" ),
 295                             QString::fromLatin1( "[X-KDE-PluginInfo-Name]=='KDevKrossManager'" ),
 296                             d->core, QVariantList() << interfaces << info.pluginName(), &str_error );
 297             kDebug() << "kross plugin:" << plugin;
 298         }
 299         else
 300         {
 301             plugin = KServiceTypeTrader::createInstanceFromQuery<IPlugin>( QLatin1String( "KDevelop/Plugin" ),
 302                     QString::fromLatin1( "[X-KDE-PluginInfo-Name]=='%1'" ).arg( pluginId ), d->core, QVariantList(), &str_error );
 303         }
 304         loadDependencies( info );
 305         loadOptionalDependencies( info );
 306     }
 307
 308     if ( plugin )
 309     {
 310         d->loadedPlugins.insert( info, plugin );
 311         plugin->registerExtensions();
 312         info.setPluginEnabled( true );
 313
 314         kDebug() << "Successfully loaded plugin '" << pluginId << "'";
 315
 316         emit pluginLoaded( plugin );
 317     }
 318     else
 319     {
 320         if( str_error.isEmpty() && !missingInterfaces.isEmpty() )
 321         {
 322             kWarning() << "Can't load plugin '" << pluginId
 323                     << "' some of its required dependecies could not be fulfilled:" << endl
 324                     << missingInterfaces.join(",") << endl;
 325         }
 326         else
 327         {
 328             kWarning() << "Loading plugin '" << pluginId
 329                 << "' failed, KPluginLoader reported error: '" << endl <<
 330                 str_error << "'";
 331         }
 332     }
 333
 334     return plugin;
 335 }
 336
 337
 338 IPlugin* PluginController::plugin( const QString& pluginId )
 339 {
 340     KPluginInfo info = infoForPluginId( pluginId );
 341     if ( !info.isValid() )
 342         return 0L;
 343
 344     if ( d->loadedPlugins.contains( info ) )
 345         return d->loadedPlugins[ info ];
 346     else
 347         return 0L;
 348 }
 349
 350 ///@todo plugin load operation should be O(n)
 351 bool PluginController::checkForDependencies( const KPluginInfo& info, QStringList& missing ) const
 352 {
 353     QVariant prop = info.property( "X-KDevelop-IRequired" );
 354     bool result = true;
 355     if( prop.canConvert<QStringList>() )
 356     {
 357         QStringList deps = prop.toStringList();
 358         foreach( QString iface, deps )
 359         {
 360             KPluginInfo::List l = queryPlugins( QString("'%1' in [X-KDevelop-Interfaces]").arg(iface) );
 361             if( l.isEmpty() )
 362             {
 363                 result = false;
 364                 missing << iface;
 365             }
 366         }
 367     }
 368     return result;
 369 }
 370
 371 void PluginController::loadOptionalDependencies( const KPluginInfo& info )
 372 {
 373     QVariant prop = info.property( "X-KDevelop-IOptional" );
 374     if( prop.canConvert<QStringList>() )
 375     {
 376         QStringList deps = prop.toStringList();
 377         foreach( QString iface, deps )
 378         {
 379             KPluginInfo info = queryPlugins( QString("'%1' in [X-KDevelop-Interfaces]").arg(iface) ).first();
 380             if( !loadPluginInternal( info.pluginName() ) )
 381             {
 382                     kDebug() << "Couldn't load optional dependecy:" << iface << info.pluginName();
 383             }
 384         }
 385     }
 386 }
 387
 388 void PluginController::loadDependencies( const KPluginInfo& info )
 389 {
 390     QVariant prop = info.property( "X-KDevelop-IRequired" );
 391     if( prop.canConvert<QStringList>() )
 392     {
 393         QStringList deps = prop.toStringList();
 394         foreach( QString iface, deps )
 395         {
 396             KPluginInfo info = queryPlugins( QString("'%1' in [X-KDevelop-Interfaces]").arg(iface) ).first();
 397             loadPluginInternal( info.pluginName() );
 398         }
 399     }
 400 }
 401
 402 IPlugin* PluginController::pluginForExtension( const QString& extension, const QString& pluginname)
 403 {
 404     kDebug() << "Loading Plugin ("<< pluginname << ") for Extension:" << extension;
 405     QStringList constraints;
 406     if (!pluginname.isEmpty())
 407         constraints << QString("[X-KDE-PluginInfo-Name]=='%1'").arg( pluginname );
 408
 409     return pluginForExtension(extension, constraints);
 410 }
 411
 412 IPlugin *PluginController::pluginForExtension(const QString &extension, const QStringList &constraints)
 413 {
 414     kDebug() << "Finding Plugin for Extension:" << extension << "|" << constraints;
 415     KPluginInfo::List infos = queryExtensionPlugins(extension, constraints);
 416
 417     if( infos.isEmpty() )
 418         return 0;
 419     if( d->plugins.contains( infos.first() ) )
 420         return d->loadedPlugins[ infos.first() ];
 421     else
 422         return loadPluginInternal( infos.first().pluginName() );
 423 }
 424
 425 QList<IPlugin*> PluginController::allPluginsForExtension(const QString &extension, const QStringList &constraints)
 426 {
 427     kDebug() << "Finding all Plugins for Extension:" << extension << "|" << constraints;
 428     KPluginInfo::List infos = queryExtensionPlugins(extension, constraints);
 429     QList<IPlugin*> plugins;
 430     foreach (const KPluginInfo &info, infos)
 431     {
 432         IPlugin* plugin;
 433         if( d->plugins.contains( info ) )
 434             plugin = d->loadedPlugins[ info ];
 435         else
 436             plugin = loadPluginInternal( info.pluginName() );
 437
 438         if (plugin)
 439             plugins << plugin;
 440         else
 441             kWarning(9501) << "Null plugin retrieved! Loading error?";
 442     }
 443     return plugins;
 444 }
 445
 446 KPluginInfo::List PluginController::queryExtensionPlugins(const QString &extension, const QStringList &constraints)
 447 {
 448     QStringList c = constraints;
 449     c << QString("'%1' in [X-KDevelop-Interfaces]").arg( extension );
 450     return queryPlugins( c.join(" and ") );
 451 }
 452
 453 QExtensionManager* PluginController::extensionManager()
 454 {
 455     return d->m_manager;
 456 }
 457
 458 QStringList PluginController::allPluginNames()
 459 {
 460     QStringList names;
 461     Q_FOREACH( const KPluginInfo& info , d->plugins )
 462     {
 463         names << info.pluginName();
 464     }
 465     return names;
 466 }
 467
 468 QList<ContextMenuExtension> PluginController::queryPluginsForContextMenuExtensions( KDevelop::Context* context ) const
 469 {
 470     QList<ContextMenuExtension> exts;
 471     Q_FOREACH( const KPluginInfo& info, d->loadedPlugins.keys() )
 472     {
 473         IPlugin* plug = d->loadedPlugins[info];
 474         exts << plug->contextMenuExtension( context );
 475     }
 476     return exts;
 477 }
 478
 479 QStringList PluginController::projectPlugins()
 480 {
 481     QStringList names;
 482     Q_FOREACH( const KPluginInfo& info , d->plugins )
 483     {
 484         if( info.property("X-KDevelop-Category").toString() == "Project" )
 485             names << info.pluginName();
 486     }
 487     return names;
 488 }
 489
 490 }
 491 #include "plugincontroller.moc"
 492