pluginmanager.cpp 41.4 KB
Newer Older
1
/**************************************************************************
con's avatar
con committed
2
3
4
**
** This file is part of Qt Creator
**
hjk's avatar
hjk committed
5
** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
con's avatar
con committed
6
**
7
** Contact: Nokia Corporation (qt-info@nokia.com)
con's avatar
con committed
8
**
9
**
10
** GNU Lesser General Public License Usage
11
**
hjk's avatar
hjk committed
12
13
14
15
16
17
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this file.
** Please review the following information to ensure the GNU Lesser General
** Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18
**
con's avatar
con committed
19
** In addition, as a special exception, Nokia gives you certain additional
hjk's avatar
hjk committed
20
** rights. These rights are described in the Nokia Qt LGPL Exception
con's avatar
con committed
21
22
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
23
24
25
26
27
** Other Usage
**
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
con's avatar
con committed
28
** If you have questions regarding the use of this file, please contact
29
** Nokia at qt-info@nokia.com.
con's avatar
con committed
30
**
31
**************************************************************************/
hjk's avatar
hjk committed
32

con's avatar
con committed
33
34
35
36
37
38
#include "pluginmanager.h"
#include "pluginmanager_p.h"
#include "pluginspec.h"
#include "pluginspec_p.h"
#include "optionsparser.h"
#include "iplugin.h"
39
#include "plugincollection.h"
con's avatar
con committed
40

41
42
43
44
45
46
47
48
49
50
#include <QEventLoop>
#include <QDateTime>
#include <QDir>
#include <QMetaProperty>
#include <QSettings>
#include <QTextStream>
#include <QTime>
#include <QWriteLocker>
#include <QtDebug>
#include <QTimer>
51

con's avatar
con committed
52
53
54
55
#ifdef WITH_TESTS
#include <QTest>
#endif

56
57
static const char C_IGNORED_PLUGINS[] = "Plugins/Ignored";
static const char C_FORCEENABLED_PLUGINS[] = "Plugins/ForceEnabled";
58
static const int DELAYED_INITIALIZE_INTERVAL = 20; // ms
59

60
typedef QList<ExtensionSystem::PluginSpec *> PluginSpecSet;
con's avatar
con committed
61
62
63
64
65

enum { debugLeaks = 0 };

/*!
    \namespace ExtensionSystem
66
67
    \brief The ExtensionSystem namespace provides classes that belong to the
           core plugin system.
con's avatar
con committed
68

69
    The basic extension system contains the plugin manager and its supporting classes,
con's avatar
con committed
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
    and the IPlugin interface that must be implemented by plugin providers.
*/

/*!
    \namespace ExtensionSystem::Internal
    \internal
*/

/*!
    \class ExtensionSystem::PluginManager
    \mainclass

    \brief Core plugin system that manages the plugins, their life cycle and their registered objects.

    The plugin manager is used for the following tasks:
    \list
    \o Manage plugins and their state
    \o Manipulate a 'common object pool'
    \endlist

    \section1 Plugins
    Plugins consist of an xml descriptor file, and of a library that contains a Qt plugin
    (declared via Q_EXPORT_PLUGIN) that must derive from the IPlugin class.
    The plugin manager is used to set a list of file system directories to search for
    plugins, retrieve information about the state of these plugins, and to load them.

    Usually the application creates a PluginManager instance and initiates the loading.
    \code
        ExtensionSystem::PluginManager *manager = new ExtensionSystem::PluginManager();
        manager->setPluginPaths(QStringList() << "plugins"); // 'plugins' and subdirs will be searched for plugins
        manager->loadPlugins(); // try to load all the plugins
    \endcode
    Additionally it is possible to directly access to the plugin specifications
    (the information in the descriptor file), and the plugin instances (via PluginSpec),
    and their state.

    \section1 Object Pool
    Plugins (and everybody else) can add objects to a common 'pool' that is located in
    the plugin manager. Objects in the pool must derive from QObject, there are no other
    prerequisites. All objects of a specified type can be retrieved from the object pool
    via the getObjects() and getObject() methods. They are aware of Aggregation::Aggregate, i.e.
    these methods use the Aggregation::query methods instead of a qobject_cast to determine
    the matching objects.

    Whenever the state of the object pool changes a corresponding signal is emitted by the plugin manager.

    A common usecase for the object pool is that a plugin (or the application) provides
    an "extension point" for other plugins, which is a class / interface that can
    be implemented and added to the object pool. The plugin that provides the
    extension point looks for implementations of the class / interface in the object pool.
    \code
121
        // Plugin A provides a "MimeTypeHandler" extension point
con's avatar
con committed
122
123
124
        // in plugin B:
        MyMimeTypeHandler *handler = new MyMimeTypeHandler();
        ExtensionSystem::PluginManager::instance()->addObject(handler);
125
        // In plugin A:
con's avatar
con committed
126
127
128
129
        QList<MimeTypeHandler *> mimeHandlers =
            ExtensionSystem::PluginManager::instance()->getObjects<MimeTypeHandler>();
    \endcode

130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

    The \c{ExtensionSystem::Invoker} class template provides "syntactic sugar"
    for using "soft" extension points that may or may not be provided by an
    object in the pool. This approach does neither require the "user" plugin being
    linked against the "provider" plugin nor a common shared
    header file. The exposed interface is implicitly given by the
    invokable methods of the "provider" object in the object pool.

    The \c{ExtensionSystem::invoke} function template encapsulates
    {ExtensionSystem::Invoker} construction for the common case where 
    the success of the call is not checked.

    \code
        // In the "provide" plugin A:
        namespace PluginA {
        class SomeProvider : public QObject
        {
            Q_OBJECT

        public:
            Q_INVOKABLE QString doit(const QString &msg, int n) {
            {
                qDebug() << "I AM DOING IT " << msg;
                return QString::number(n);
            }
        };
        } // namespace PluginA


        // In the "user" plugin B:
        int someFuntionUsingPluginA()
        {
            using namespace ExtensionSystem;

            QObject *target = PluginManager::instance()
                ->getObjectByClassName("PluginA::SomeProvider");

            if (target) {
                // Some random argument.
                QString msg = "REALLY.";

                // Plain function call, no return value.
                invoke<void>(target, "doit", msg, 2);

                // Plain function with no return value.
                qDebug() << "Result: " << invoke<QString>(target, "doit", msg, 21);

                // Record success of function call with return value.
                Invoker<QString> in1(target, "doit", msg, 21);
                qDebug() << "Success: (expected)" << in1.wasSuccessful();

                // Try to invoke a non-existing function.
                Invoker<QString> in2(target, "doitWrong", msg, 22);
                qDebug() << "Success (not expected):" << in2.wasSuccessful();

            } else {

                // We have to cope with plugin A's absence.
            }
        };
    \endcode

    \bold Note: The type of the parameters passed to the \c{invoke()} calls
    is deduced from the parameters themselves and must match the type of
    the arguments of the called functions \e{exactly}. No conversion or even
    integer promotions are applicable, so to invoke a function with a \c{long}
    parameter explicitly use \c{long(43)} or such.

con's avatar
con committed
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
    \bold Note: The object pool manipulating functions are thread-safe.
*/

/*!
    \fn void PluginManager::objectAdded(QObject *obj)
    Signal that \a obj has been added to the object pool.
*/

/*!
    \fn void PluginManager::aboutToRemoveObject(QObject *obj)
    Signal that \a obj will be removed from the object pool.
*/

/*!
    \fn void PluginManager::pluginsChanged()
    Signal that the list of available plugins has changed.

    \sa plugins()
*/

/*!
    \fn T *PluginManager::getObject() const
    Retrieve the object of a given type from the object pool.
    This method is aware of Aggregation::Aggregate, i.e. it uses
    the Aggregation::query methods instead of qobject_cast to
    determine the type of an object.
    If there are more than one object of the given type in
    the object pool, this method will choose an arbitrary one of them.

    \sa addObject()
*/

/*!
    \fn QList<T *> PluginManager::getObjects() const
    Retrieve all objects of a given type from the object pool.
    This method is aware of Aggregation::Aggregate, i.e. it uses
    the Aggregation::query methods instead of qobject_cast to
    determine the type of an object.

    \sa addObject()
*/

using namespace ExtensionSystem;
using namespace ExtensionSystem::Internal;

243
244
245
246
247
static bool lessThanByPluginName(const PluginSpec *one, const PluginSpec *two)
{
    return one->name() < two->name();
}

con's avatar
con committed
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
PluginManager *PluginManager::m_instance = 0;

/*!
    \fn PluginManager *PluginManager::instance()
    Get the unique plugin manager instance.
*/
PluginManager *PluginManager::instance()
{
    return m_instance;
}

/*!
    \fn PluginManager::PluginManager()
    Create a plugin manager. Should be done only once per application.
*/
PluginManager::PluginManager()
    : d(new PluginManagerPrivate(this))
{
    m_instance = this;
}

/*!
    \fn PluginManager::~PluginManager()
    \internal
*/
PluginManager::~PluginManager()
{
    delete d;
    d = 0;
}

/*!
    \fn void PluginManager::addObject(QObject *obj)
    Add the given object \a obj to the object pool, so it can be retrieved again from the pool by type.
    The plugin manager does not do any memory management - added objects
    must be removed from the pool and deleted manually by whoever is responsible for the object.

    Emits the objectAdded() signal.

    \sa PluginManager::removeObject()
    \sa PluginManager::getObject()
    \sa PluginManager::getObjects()
*/
void PluginManager::addObject(QObject *obj)
{
293
    m_instance->d->addObject(obj);
con's avatar
con committed
294
295
296
297
298
299
300
301
302
}

/*!
    \fn void PluginManager::removeObject(QObject *obj)
    Emits aboutToRemoveObject() and removes the object \a obj from the object pool.
    \sa PluginManager::addObject()
*/
void PluginManager::removeObject(QObject *obj)
{
303
    m_instance->d->removeObject(obj);
con's avatar
con committed
304
305
306
307
308
309
310
311
312
}

/*!
    \fn QList<QObject *> PluginManager::allObjects() const
    Retrieve the list of all objects in the pool, unfiltered.
    Usually clients do not need to call this.
    \sa PluginManager::getObject()
    \sa PluginManager::getObjects()
*/
313
QList<QObject *> PluginManager::allObjects()
con's avatar
con committed
314
{
315
    return m_instance->d->allObjects;
con's avatar
con committed
316
317
318
319
320
321
322
323
324
325
326
327
328
}

/*!
    \fn void PluginManager::loadPlugins()
    Tries to load all the plugins that were previously found when
    setting the plugin search paths. The plugin specs of the plugins
    can be used to retrieve error and state information about individual plugins.

    \sa setPluginPaths()
    \sa plugins()
*/
void PluginManager::loadPlugins()
{
329
    return m_instance->d->loadPlugins();
con's avatar
con committed
330
331
}

332
333
334
335
336
/*!
    \fn bool PluginManager::hasError() const
    Returns true if any plugin has errors even though it is enabled.
    Most useful to call after loadPlugins().
*/
337
bool PluginManager::hasError()
338
339
340
341
342
343
344
345
346
347
{
    foreach (PluginSpec *spec, plugins()) {
        // only show errors on startup if plugin is enabled.
        if (spec->hasError() && spec->isEnabled() && !spec->isDisabledIndirectly()) {
            return true;
        }
    }
    return false;
}

348
349
350
351
352
353
354
355
356
/*!
    \fn void PluginManager::shutdown()
    Shuts down and deletes all plugins.
*/
void PluginManager::shutdown()
{
    d->shutdown();
}

con's avatar
con committed
357
358
359
360
361
362
/*!
    \fn QStringList PluginManager::pluginPaths() const
    The list of paths were the plugin manager searches for plugins.

    \sa setPluginPaths()
*/
363
QStringList PluginManager::pluginPaths()
con's avatar
con committed
364
{
365
    return m_instance->d->pluginPaths;
con's avatar
con committed
366
367
368
369
370
371
372
373
374
375
376
377
378
}

/*!
    \fn void PluginManager::setPluginPaths(const QStringList &paths)
    Sets the plugin search paths, i.e. the file system paths where the plugin manager
    looks for plugin descriptions. All given \a paths and their sub directory trees
    are searched for plugin xml description files.

    \sa pluginPaths()
    \sa loadPlugins()
*/
void PluginManager::setPluginPaths(const QStringList &paths)
{
379
    m_instance->d->setPluginPaths(paths);
con's avatar
con committed
380
381
382
383
384
385
386
387
388
}

/*!
    \fn QString PluginManager::fileExtension() const
    The file extension of plugin description files.
    The default is "xml".

    \sa setFileExtension()
*/
389
QString PluginManager::fileExtension()
con's avatar
con committed
390
{
391
    return m_instance->d->extension;
con's avatar
con committed
392
393
394
395
396
397
398
399
400
401
402
}

/*!
    \fn void PluginManager::setFileExtension(const QString &extension)
    Sets the file extension of plugin description files.
    The default is "xml".
    At the moment this must be called before setPluginPaths() is called.
    // ### TODO let this + setPluginPaths read the plugin specs lazyly whenever loadPlugins() or plugins() is called.
*/
void PluginManager::setFileExtension(const QString &extension)
{
403
    m_instance->d->extension = extension;
con's avatar
con committed
404
405
}

406
407
408
409
/*!
    Define the user specific settings to use for information about enabled/disabled plugins.
    Needs to be set before the plugin search path is set with setPluginPaths().
*/
410
void PluginManager::setSettings(QSettings *settings)
411
{
412
    m_instance->d->setSettings(settings);
413
414
}

415
416
417
418
419
420
/*!
    Define the global (user-independent) settings to use for information about default disabled plugins.
    Needs to be set before the plugin search path is set with setPluginPaths().
*/
void PluginManager::setGlobalSettings(QSettings *settings)
{
421
    m_instance->d->setGlobalSettings(settings);
422
423
424
425
426
}

/*!
    Returns the user specific settings used for information about enabled/disabled plugins.
*/
427
QSettings *PluginManager::settings()
428
{
429
    return m_instance->d->settings;
430
431
}

432
433
434
/*!
    Returns the global (user-independent) settings used for information about default disabled plugins.
*/
435
QSettings *PluginManager::globalSettings()
436
{
437
    return m_instance->d->globalSettings;
438
439
440
441
}

void PluginManager::writeSettings()
{
442
    m_instance->d->writeSettings();
443
444
}

con's avatar
con committed
445
446
447
448
449
/*!
    \fn QStringList PluginManager::arguments() const
    The arguments left over after parsing (Neither startup nor plugin
    arguments). Typically, this will be the list of files to open.
*/
450
QStringList PluginManager::arguments()
con's avatar
con committed
451
{
452
    return m_instance->d->arguments;
con's avatar
con committed
453
454
455
}

/*!
456
    \fn QList<PluginSpec *> PluginManager::plugins() const
con's avatar
con committed
457
458
459
460
461
462
463
464
    List of all plugin specifications that have been found in the plugin search paths.
    This list is valid directly after the setPluginPaths() call.
    The plugin specifications contain the information from the plugins' xml description files
    and the current state of the plugins. If a plugin's library has been already successfully loaded,
    the plugin specification has a reference to the created plugin instance as well.

    \sa setPluginPaths()
*/
465
QList<PluginSpec *> PluginManager::plugins()
con's avatar
con committed
466
{
467
    return m_instance->d->pluginSpecs;
con's avatar
con committed
468
469
}

470
QHash<QString, PluginCollection *> PluginManager::pluginCollections()
471
{
472
    return m_instance->d->pluginCategories;
473
474
}

475
476
477
478
479
480
481
482
483
484
485
486
487
/*!
    \fn QString PluginManager::serializedArguments() const

    Serialize plugin options and arguments for sending in a single string
    via QtSingleApplication:
    ":myplugin|-option1|-option2|:arguments|argument1|argument2",
    as a list of lists started by a keyword with a colon. Arguments are last.

    \sa setPluginPaths()
*/

static const char argumentKeywordC[] = ":arguments";

488
QString PluginManager::serializedArguments()
489
490
491
492
493
494
495
496
497
498
499
500
501
{
    const QChar separator = QLatin1Char('|');
    QString rc;
    foreach (const PluginSpec *ps, plugins()) {
        if (!ps->arguments().isEmpty()) {
            if (!rc.isEmpty())
                rc += separator;
            rc += QLatin1Char(':');
            rc += ps->name();
            rc += separator;
            rc +=  ps->arguments().join(QString(separator));
        }
    }
502
    if (!m_instance->d->arguments.isEmpty()) {
503
504
505
506
507
        if (!rc.isEmpty())
            rc += separator;
        rc += QLatin1String(argumentKeywordC);
        // If the argument appears to be a file, make it absolute
        // when sending to another instance.
508
        foreach (const QString &argument, m_instance->d->arguments) {
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
            rc += separator;
            const QFileInfo fi(argument);
            if (fi.exists() && fi.isRelative()) {
                rc += fi.absoluteFilePath();
            } else {
                rc += argument;
            }
        }
    }
    return rc;
}

/* Extract a sublist from the serialized arguments
 * indicated by a keyword starting with a colon indicator:
 * ":a,i1,i2,:b:i3,i4" with ":a" -> "i1,i2"
 */
static QStringList subList(const QStringList &in, const QString &key)
{
    QStringList rc;
    // Find keyword and copy arguments until end or next keyword
    const QStringList::const_iterator inEnd = in.constEnd();
    QStringList::const_iterator it = qFind(in.constBegin(), inEnd, key);
    if (it != inEnd) {
        const QChar nextIndicator = QLatin1Char(':');
        for (++it; it != inEnd && !it->startsWith(nextIndicator); ++it)
            rc.append(*it);
    }
    return rc;
}

/*!
    \fn PluginManager::remoteArguments(const QString &argument)

    Parses the options encoded by serializedArguments() const
    and passes them on to the respective plugins along with the arguments.
*/

void PluginManager::remoteArguments(const QString &serializedArgument)
{
    if (serializedArgument.isEmpty())
        return;
    QStringList serializedArguments = serializedArgument.split(QLatin1Char('|'));
    const QStringList arguments = subList(serializedArguments, QLatin1String(argumentKeywordC));
    foreach (const PluginSpec *ps, plugins()) {
        if (ps->state() == PluginSpec::Running) {
            const QStringList pluginOptions = subList(serializedArguments, QLatin1Char(':') + ps->name());
            ps->plugin()->remoteCommand(pluginOptions, arguments);
        }
    }
}

con's avatar
con committed
560
561
562
563
564
565
566
567
/*!
    \fn bool PluginManager::parseOptions(const QStringList &args, const QMap<QString, bool> &appOptions, QMap<QString, QString> *foundAppOptions, QString *errorString)
    Takes the list of command line options in \a args and parses them.
    The plugin manager itself might process some options itself directly (-noload <plugin>), and
    adds options that are registered by plugins to their plugin specs.
    The caller (the application) may register itself for options via the \a appOptions list, containing pairs
    of "option string" and a bool that indicates if the option requires an argument.
    Application options always override any plugin's options.
568

con's avatar
con committed
569
570
571
572
    \a foundAppOptions is set to pairs of ("option string", "argument") for any application options that were found.
    The command line options that were not processed can be retrieved via the arguments() method.
    If an error occurred (like missing argument for an option that requires one), \a errorString contains
    a descriptive message of the error.
573

con's avatar
con committed
574
575
576
577
578
579
580
    Returns if there was an error.
 */
bool PluginManager::parseOptions(const QStringList &args,
    const QMap<QString, bool> &appOptions,
    QMap<QString, QString> *foundAppOptions,
    QString *errorString)
{
581
    OptionsParser options(args, appOptions, foundAppOptions, errorString, m_instance->d);
con's avatar
con committed
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
    return options.parse();
}



static inline void indent(QTextStream &str, int indent)
{
    const QChar blank = QLatin1Char(' ');
    for (int i = 0 ; i < indent; i++)
        str << blank;
}

static inline void formatOption(QTextStream &str,
                                const QString &opt, const QString &parm, const QString &description,
                                int optionIndentation, int descriptionIndentation)
{
    int remainingIndent = descriptionIndentation - optionIndentation - opt.size();
    indent(str, optionIndentation);
    str << opt;
    if (!parm.isEmpty()) {
        str << " <" << parm << '>';
        remainingIndent -= 3 + parm.size();
    }
605
    indent(str, qMax(1, remainingIndent));
con's avatar
con committed
606
607
608
609
610
611
612
613
614
615
616
617
618
619
    str << description << '\n';
}

/*!
    \fn static PluginManager::formatOptions(QTextStream &str, int optionIndentation, int descriptionIndentation)

    Format the startup options of the plugin manager for command line help.
*/

void PluginManager::formatOptions(QTextStream &str, int optionIndentation, int descriptionIndentation)
{
    formatOption(str, QLatin1String(OptionsParser::NO_LOAD_OPTION),
                 QLatin1String("plugin"), QLatin1String("Do not load <plugin>"),
                 optionIndentation, descriptionIndentation);
620
621
622
    formatOption(str, QLatin1String(OptionsParser::PROFILE_OPTION),
                 QString(), QLatin1String("Profile plugin loading"),
                 optionIndentation, descriptionIndentation);
Eike Ziller's avatar
Eike Ziller committed
623
624
625
626
627
#ifdef WITH_TESTS
    formatOption(str, QLatin1String(OptionsParser::TEST_OPTION),
                 QLatin1String("plugin|all"), QLatin1String("Run plugin's tests"),
                 optionIndentation, descriptionIndentation);
#endif
con's avatar
con committed
628
629
630
631
632
633
634
635
}

/*!
    \fn PluginManager::formatPluginOptions(QTextStream &str, int optionIndentation, int descriptionIndentation) const

    Format the plugin  options of the plugin specs for command line help.
*/

636
void PluginManager::formatPluginOptions(QTextStream &str, int optionIndentation, int descriptionIndentation)
con's avatar
con committed
637
638
639
{
    typedef PluginSpec::PluginArgumentDescriptions PluginArgumentDescriptions;
    // Check plugins for options
640
641
    const PluginSpecSet::const_iterator pcend = m_instance->d->pluginSpecs.constEnd();
    for (PluginSpecSet::const_iterator pit = m_instance->d->pluginSpecs.constBegin(); pit != pcend; ++pit) {
con's avatar
con committed
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
        const PluginArgumentDescriptions pargs = (*pit)->argumentDescriptions();
        if (!pargs.empty()) {
            str << "\nPlugin: " <<  (*pit)->name() << '\n';
            const PluginArgumentDescriptions::const_iterator acend = pargs.constEnd();
            for (PluginArgumentDescriptions::const_iterator ait =pargs.constBegin(); ait != acend; ++ait)
                formatOption(str, ait->name, ait->parameter, ait->description, optionIndentation, descriptionIndentation);
        }
    }
}

/*!
    \fn PluginManager::formatPluginVersions(QTextStream &str) const

    Format the version of the plugin specs for command line help.
*/

658
void PluginManager::formatPluginVersions(QTextStream &str)
con's avatar
con committed
659
{
660
661
    const PluginSpecSet::const_iterator cend = m_instance->d->pluginSpecs.constEnd();
    for (PluginSpecSet::const_iterator it = m_instance->d->pluginSpecs.constBegin(); it != cend; ++it) {
con's avatar
con committed
662
663
664
665
666
667
668
669
        const PluginSpec *ps = *it;
        str << "  " << ps->name() << ' ' << ps->version() << ' ' << ps->description() <<  '\n';
    }
}

void PluginManager::startTests()
{
#ifdef WITH_TESTS
hjk's avatar
hjk committed
670
    foreach (PluginSpec *pluginSpec, d->testSpecs) {
671
672
        if (!pluginSpec->plugin())
            continue;
con's avatar
con committed
673
674
675
676
        const QMetaObject *mo = pluginSpec->plugin()->metaObject();
        QStringList methods;
        methods.append("arg0");
        // We only want slots starting with "test"
hjk's avatar
hjk committed
677
        for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
Friedemann Kleint's avatar
Friedemann Kleint committed
678
679
680
681
682
683
684
#if QT_VERSION >= 0x050000
            const QByteArray signature = mo->method(i).methodSignature();
#else
            const QByteArray signature = mo->method(i).signature();
#endif
            if (signature.startsWith("test") && !signature.endsWith("_data()")) {
                const QString method = QString::fromLatin1(signature);
con's avatar
con committed
685
686
687
                methods.append(method.left(method.size()-2));
            }
        }
688
689
690
691
        // Don't run QTest::qExec with only one argument, that'd run
        // *all* slots as tests.
        if (methods.size() > 1)
            QTest::qExec(pluginSpec->plugin(), methods);
con's avatar
con committed
692
    }
hjk's avatar
hjk committed
693
    if (!d->testSpecs.isEmpty())
694
        QTimer::singleShot(1, QCoreApplication::instance(), SLOT(quit()));
con's avatar
con committed
695
696
697
#endif
}

698
699
700
701
/*!
 * \fn bool PluginManager::runningTests() const
 * \internal
 */
702
bool PluginManager::runningTests()
con's avatar
con committed
703
{
704
    return !m_instance->d->testSpecs.isEmpty();
con's avatar
con committed
705
706
}

707
708
709
710
/*!
 * \fn QString PluginManager::testDataDirectory() const
 * \internal
 */
711
QString PluginManager::testDataDirectory()
con's avatar
con committed
712
{
713
    QByteArray ba = qgetenv("QTCREATOR_TEST_DIR");
hjk's avatar
hjk committed
714
    QString s = QString::fromLocal8Bit(ba.constData(), ba.size());
con's avatar
con committed
715
716
717
718
719
720
721
722
    if (s.isEmpty()) {
        s = IDE_TEST_DIR;
        s.append("/tests");
    }
    s = QDir::cleanPath(s);
    return s;
}

723
724
725
726
727
728
729
730
/*!
    \fn void PluginManager::profilingReport(const char *what, const PluginSpec *spec = 0)

    Create a profiling entry showing the elapsed time if profiling is activated.
*/

void PluginManager::profilingReport(const char *what, const PluginSpec *spec)
{
731
    m_instance->d->profilingReport(what, spec);
732
733
}

734
735
736
737
738
739
740
741

/*!
    \fn void PluginManager::loadQueue()

    Returns a list of plugins in load order.
*/
QList<PluginSpec *> PluginManager::loadQueue()
{
742
    return m_instance->d->loadQueue();
743
744
}

con's avatar
con committed
745
746
747
748
749
750
751
752
753
754
755
//============PluginManagerPrivate===========

/*!
    \fn PluginSpec *PluginManagerPrivate::createSpec()
    \internal
*/
PluginSpec *PluginManagerPrivate::createSpec()
{
    return new PluginSpec();
}

756
757
758
759
760
761
762
763
764
765
766
767
768
/*!
    \fn void PluginManagerPrivate::setSettings(QSettings *settings)
    \internal
*/
void PluginManagerPrivate::setSettings(QSettings *s)
{
    if (settings)
        delete settings;
    settings = s;
    if (settings)
        settings->setParent(this);
}

769
770
771
772
773
774
775
776
777
778
779
780
/*!
    \internal
*/
void PluginManagerPrivate::setGlobalSettings(QSettings *s)
{
    if (globalSettings)
        delete globalSettings;
    globalSettings = s;
    if (globalSettings)
        globalSettings->setParent(this);
}

con's avatar
con committed
781
782
783
784
785
786
787
788
789
/*!
    \fn PluginSpecPrivate *PluginManagerPrivate::privateSpec(PluginSpec *spec)
    \internal
*/
PluginSpecPrivate *PluginManagerPrivate::privateSpec(PluginSpec *spec)
{
    return spec->d;
}

790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
void PluginManagerPrivate::nextDelayedInitialize()
{
    while (!delayedInitializeQueue.isEmpty()) {
        PluginSpec *spec = delayedInitializeQueue.takeFirst();
        profilingReport(">delayedInitialize", spec);
        bool delay = spec->d->delayedInitialize();
        profilingReport("<delayedInitialize", spec);
        if (delay)
            break; // do next delayedInitialize after a delay
    }
    if (delayedInitializeQueue.isEmpty()) {
        delete delayedInitializeTimer;
        delayedInitializeTimer = 0;
    } else {
        delayedInitializeTimer->start();
    }
}

con's avatar
con committed
808
809
810
811
/*!
    \fn PluginManagerPrivate::PluginManagerPrivate(PluginManager *pluginManager)
    \internal
*/
812
813
PluginManagerPrivate::PluginManagerPrivate(PluginManager *pluginManager) :
    extension(QLatin1String("xml")),
814
815
    delayedInitializeTimer(0),
    shutdownEventLoop(0),
816
    m_profileElapsedMS(0),
817
    m_profilingVerbosity(0),
818
    settings(0),
819
    globalSettings(0),
820
    q(pluginManager)
con's avatar
con committed
821
822
823
{
}

824

con's avatar
con committed
825
826
827
828
829
830
831
/*!
    \fn PluginManagerPrivate::~PluginManagerPrivate()
    \internal
*/
PluginManagerPrivate::~PluginManagerPrivate()
{
    qDeleteAll(pluginSpecs);
832
    qDeleteAll(pluginCategories);
con's avatar
con committed
833
834
}

835
836
837
838
/*!
    \fn void PluginManagerPrivate::writeSettings()
    \internal
*/
839
840
void PluginManagerPrivate::writeSettings()
{
841
842
    if (!settings)
        return;
con's avatar
con committed
843
    QStringList tempDisabledPlugins;
844
    QStringList tempForceEnabledPlugins;
845
    foreach(PluginSpec *spec, pluginSpecs) {
846
        if (!spec->isDisabledByDefault() && !spec->isEnabled())
con's avatar
con committed
847
            tempDisabledPlugins.append(spec->name());
848
        if (spec->isDisabledByDefault() && spec->isEnabled())
849
            tempForceEnabledPlugins.append(spec->name());
850
851
    }

852
853
    settings->setValue(QLatin1String(C_IGNORED_PLUGINS), tempDisabledPlugins);
    settings->setValue(QLatin1String(C_FORCEENABLED_PLUGINS), tempForceEnabledPlugins);
854
855
}

856
/*!
857
    \fn void PluginManagerPrivate::readSettings()
858
859
    \internal
*/
860
void PluginManagerPrivate::readSettings()
861
{
862
863
864
865
866
867
868
    if (globalSettings) {
        defaultDisabledPlugins = globalSettings->value(QLatin1String(C_IGNORED_PLUGINS)).toStringList();
    }
    if (settings) {
        disabledPlugins = settings->value(QLatin1String(C_IGNORED_PLUGINS)).toStringList();
        forceEnabledPlugins = settings->value(QLatin1String(C_FORCEENABLED_PLUGINS)).toStringList();
    }
869
870
}

871
872
873
874
/*!
    \fn void PluginManagerPrivate::stopAll()
    \internal
*/
con's avatar
con committed
875
876
void PluginManagerPrivate::stopAll()
{
877
878
879
880
881
    if (delayedInitializeTimer && delayedInitializeTimer->isActive()) {
        delayedInitializeTimer->stop();
        delete delayedInitializeTimer;
        delayedInitializeTimer = 0;
    }
con's avatar
con committed
882
883
884
885
    QList<PluginSpec *> queue = loadQueue();
    foreach (PluginSpec *spec, queue) {
        loadPlugin(spec, PluginSpec::Stopped);
    }
886
887
888
889
890
891
892
893
894
}

/*!
    \fn void PluginManagerPrivate::deleteAll()
    \internal
*/
void PluginManagerPrivate::deleteAll()
{
    QList<PluginSpec *> queue = loadQueue();
con's avatar
con committed
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
    QListIterator<PluginSpec *> it(queue);
    it.toBack();
    while (it.hasPrevious()) {
        loadPlugin(it.previous(), PluginSpec::Deleted);
    }
}

/*!
    \fn void PluginManagerPrivate::addObject(QObject *obj)
    \internal
*/
void PluginManagerPrivate::addObject(QObject *obj)
{
    {
        QWriteLocker lock(&(q->m_lock));
        if (obj == 0) {
            qWarning() << "PluginManagerPrivate::addObject(): trying to add null object";
            return;
        }
        if (allObjects.contains(obj)) {
            qWarning() << "PluginManagerPrivate::addObject(): trying to add duplicate object";
            return;
        }

        if (debugLeaks)
            qDebug() << "PluginManagerPrivate::addObject" << obj << obj->objectName();

922
923
924
925
926
927
928
        if (m_profilingVerbosity && !m_profileTimer.isNull()) {
            // Report a timestamp when adding an object. Useful for profiling
            // its initialization time.
            const int absoluteElapsedMS = m_profileTimer->elapsed();
            qDebug("  %-43s %8dms", obj->metaObject()->className(), absoluteElapsedMS);
        }

con's avatar
con committed
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
        allObjects.append(obj);
    }
    emit q->objectAdded(obj);
}

/*!
    \fn void PluginManagerPrivate::removeObject(QObject *obj)
    \internal
*/
void PluginManagerPrivate::removeObject(QObject *obj)
{
    if (obj == 0) {
        qWarning() << "PluginManagerPrivate::removeObject(): trying to remove null object";
        return;
    }

    if (!allObjects.contains(obj)) {
        qWarning() << "PluginManagerPrivate::removeObject(): object not in list:"
            << obj << obj->objectName();
        return;
    }
    if (debugLeaks)
        qDebug() << "PluginManagerPrivate::removeObject" << obj << obj->objectName();

    emit q->aboutToRemoveObject(obj);
    QWriteLocker lock(&(q->m_lock));
    allObjects.removeAll(obj);
}

/*!
    \fn void PluginManagerPrivate::loadPlugins()
    \internal
*/
void PluginManagerPrivate::loadPlugins()
{
    QList<PluginSpec *> queue = loadQueue();
    foreach (PluginSpec *spec, queue) {
        loadPlugin(spec, PluginSpec::Loaded);
    }
    foreach (PluginSpec *spec, queue) {
        loadPlugin(spec, PluginSpec::Initialized);
    }
    QListIterator<PluginSpec *> it(queue);
    it.toBack();
    while (it.hasPrevious()) {
974
975
976
977
        PluginSpec *spec = it.previous();
        loadPlugin(spec, PluginSpec::Running);
        if (spec->state() == PluginSpec::Running)
            delayedInitializeQueue.append(spec);
con's avatar
con committed
978
979
    }
    emit q->pluginsChanged();
980
981
982
983
984
985
986

    delayedInitializeTimer = new QTimer;
    delayedInitializeTimer->setInterval(DELAYED_INITIALIZE_INTERVAL);
    delayedInitializeTimer->setSingleShot(true);
    connect(delayedInitializeTimer, SIGNAL(timeout()),
            this, SLOT(nextDelayedInitialize()));
    delayedInitializeTimer->start();
con's avatar
con committed
987
988
}

989
990
991
992
993
994
995
996
997
998
999
1000
/*!
    \fn void PluginManagerPrivate::shutdown()
    \internal
*/
void PluginManagerPrivate::shutdown()
{
    stopAll();
    if (!asynchronousPlugins.isEmpty()) {
        shutdownEventLoop = new QEventLoop;
        shutdownEventLoop->exec();
    }
    deleteAll();