pluginmanager.cpp 43.8 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
con's avatar
con committed
2
**
hjk's avatar
hjk committed
3
4
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
con's avatar
con committed
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
con's avatar
con committed
7
**
hjk's avatar
hjk committed
8
9
10
11
12
13
14
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
15
**
16
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17
18
19
20
21
22
23
24
25
** Alternatively, 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.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
con's avatar
con committed
26
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
hjk's avatar
hjk committed
29

con's avatar
con committed
30
31
32
33
34
35
#include "pluginmanager.h"
#include "pluginmanager_p.h"
#include "pluginspec.h"
#include "pluginspec_p.h"
#include "optionsparser.h"
#include "iplugin.h"
36
#include "plugincollection.h"
con's avatar
con committed
37

38
39
40
41
42
43
44
45
#include <QEventLoop>
#include <QDateTime>
#include <QDir>
#include <QMetaProperty>
#include <QSettings>
#include <QTextStream>
#include <QTime>
#include <QWriteLocker>
hjk's avatar
hjk committed
46
#include <QDebug>
47
#include <QTimer>
48

con's avatar
con committed
49
50
51
52
#ifdef WITH_TESTS
#include <QTest>
#endif

53
54
static const char C_IGNORED_PLUGINS[] = "Plugins/Ignored";
static const char C_FORCEENABLED_PLUGINS[] = "Plugins/ForceEnabled";
55
static const int DELAYED_INITIALIZE_INTERVAL = 20; // ms
56

57
typedef QList<ExtensionSystem::PluginSpec *> PluginSpecSet;
con's avatar
con committed
58
59
60
61
62

enum { debugLeaks = 0 };

/*!
    \namespace ExtensionSystem
63
64
    \brief The ExtensionSystem namespace provides classes that belong to the
           core plugin system.
con's avatar
con committed
65

66
    The basic extension system contains the plugin manager and its supporting classes,
con's avatar
con committed
67
68
69
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
    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
118
        // Plugin A provides a "MimeTypeHandler" extension point
con's avatar
con committed
119
120
121
        // in plugin B:
        MyMimeTypeHandler *handler = new MyMimeTypeHandler();
        ExtensionSystem::PluginManager::instance()->addObject(handler);
122
        // In plugin A:
con's avatar
con committed
123
124
125
126
        QList<MimeTypeHandler *> mimeHandlers =
            ExtensionSystem::PluginManager::instance()->getObjects<MimeTypeHandler>();
    \endcode

127
128
129
130
131
132
133
134
135

    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
Orgad Shaneh's avatar
Orgad Shaneh committed
136
    {ExtensionSystem::Invoker} construction for the common case where
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
    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
195
196
197
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
    \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;

240
241
242
243
244
static bool lessThanByPluginName(const PluginSpec *one, const PluginSpec *two)
{
    return one->name() < two->name();
}

con's avatar
con committed
245
246
247
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
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)
{
290
    m_instance->d->addObject(obj);
con's avatar
con committed
291
292
293
294
295
296
297
298
299
}

/*!
    \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)
{
300
    m_instance->d->removeObject(obj);
con's avatar
con committed
301
302
303
304
305
306
307
308
309
}

/*!
    \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()
*/
310
QList<QObject *> PluginManager::allObjects()
con's avatar
con committed
311
{
312
    return m_instance->d->allObjects;
con's avatar
con committed
313
314
315
316
317
318
319
320
321
322
323
324
325
}

/*!
    \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()
{
326
    return m_instance->d->loadPlugins();
con's avatar
con committed
327
328
}

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

344
345
346
347
348
349
350
351
352
/*!
    \fn void PluginManager::shutdown()
    Shuts down and deletes all plugins.
*/
void PluginManager::shutdown()
{
    d->shutdown();
}

con's avatar
con committed
353
354
355
356
357
358
/*!
    \fn QStringList PluginManager::pluginPaths() const
    The list of paths were the plugin manager searches for plugins.

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

/*!
    \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)
{
375
    m_instance->d->setPluginPaths(paths);
con's avatar
con committed
376
377
378
379
380
381
382
383
384
}

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

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

/*!
    \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)
{
399
    m_instance->d->extension = extension;
con's avatar
con committed
400
401
}

402
403
404
405
/*!
    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().
*/
406
void PluginManager::setSettings(QSettings *settings)
407
{
408
    m_instance->d->setSettings(settings);
409
410
}

411
412
413
414
415
416
/*!
    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)
{
417
    m_instance->d->setGlobalSettings(settings);
418
419
420
421
422
}

/*!
    Returns the user specific settings used for information about enabled/disabled plugins.
*/
423
QSettings *PluginManager::settings()
424
{
425
    return m_instance->d->settings;
426
427
}

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

void PluginManager::writeSettings()
{
438
    m_instance->d->writeSettings();
439
440
}

con's avatar
con committed
441
442
443
444
445
/*!
    \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.
*/
446
QStringList PluginManager::arguments()
con's avatar
con committed
447
{
448
    return m_instance->d->arguments;
con's avatar
con committed
449
450
451
}

/*!
452
    \fn QList<PluginSpec *> PluginManager::plugins() const
con's avatar
con committed
453
454
455
456
457
458
459
460
    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()
*/
461
QList<PluginSpec *> PluginManager::plugins()
con's avatar
con committed
462
{
463
    return m_instance->d->pluginSpecs;
con's avatar
con committed
464
465
}

466
QHash<QString, PluginCollection *> PluginManager::pluginCollections()
467
{
468
    return m_instance->d->pluginCategories;
469
470
}

471
472
473
474
475
476
477
478
479
480
481
482
483
/*!
    \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";

484
QString PluginManager::serializedArguments()
485
486
487
488
489
490
491
492
493
494
495
496
497
{
    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));
        }
    }
498
    if (!m_instance->d->arguments.isEmpty()) {
499
500
501
502
503
        if (!rc.isEmpty())
            rc += separator;
        rc += QLatin1String(argumentKeywordC);
        // If the argument appears to be a file, make it absolute
        // when sending to another instance.
504
        foreach (const QString &argument, m_instance->d->arguments) {
505
506
            rc += separator;
            const QFileInfo fi(argument);
507
            if (fi.exists() && fi.isRelative())
508
                rc += fi.absoluteFilePath();
509
            else
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
                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
555
556
557
558
559
560
561
562
/*!
    \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.
563

con's avatar
con committed
564
565
566
567
    \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.
568

con's avatar
con committed
569
570
571
572
573
574
575
    Returns if there was an error.
 */
bool PluginManager::parseOptions(const QStringList &args,
    const QMap<QString, bool> &appOptions,
    QMap<QString, QString> *foundAppOptions,
    QString *errorString)
{
576
    OptionsParser options(args, appOptions, foundAppOptions, errorString, m_instance->d);
con's avatar
con committed
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
    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();
    }
600
    indent(str, qMax(1, remainingIndent));
con's avatar
con committed
601
602
603
604
605
606
607
608
609
610
611
612
613
614
    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);
615
616
617
    formatOption(str, QLatin1String(OptionsParser::PROFILE_OPTION),
                 QString(), QLatin1String("Profile plugin loading"),
                 optionIndentation, descriptionIndentation);
Eike Ziller's avatar
Eike Ziller committed
618
#ifdef WITH_TESTS
619
620
621
622
623
    formatOption(str, QString::fromLatin1(OptionsParser::TEST_OPTION)
                 + QLatin1String(" <plugin> [testfunction[:testdata]]..."), QString(),
                 QLatin1String("Run plugin's tests"), optionIndentation, descriptionIndentation);
    formatOption(str, QString::fromLatin1(OptionsParser::TEST_OPTION) + QLatin1String(" all"),
                 QString(), QLatin1String("Run tests from all plugins"),
Eike Ziller's avatar
Eike Ziller committed
624
625
                 optionIndentation, descriptionIndentation);
#endif
con's avatar
con committed
626
627
628
629
630
631
632
633
}

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

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

634
void PluginManager::formatPluginOptions(QTextStream &str, int optionIndentation, int descriptionIndentation)
con's avatar
con committed
635
636
637
{
    typedef PluginSpec::PluginArgumentDescriptions PluginArgumentDescriptions;
    // Check plugins for options
638
639
    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
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
        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.
*/

656
void PluginManager::formatPluginVersions(QTextStream &str)
con's avatar
con committed
657
{
658
659
    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
660
661
662
663
664
665
666
667
        const PluginSpec *ps = *it;
        str << "  " << ps->name() << ' ' << ps->version() << ' ' << ps->description() <<  '\n';
    }
}

void PluginManager::startTests()
{
#ifdef WITH_TESTS
668
669
    foreach (const PluginManagerPrivate::TestSpec &testSpec, d->testSpecs) {
        const PluginSpec * const pluginSpec = testSpec.pluginSpec;
670
671
        if (!pluginSpec->plugin())
            continue;
672
673
674

        // Collect all test functions/methods of the plugin.
        QStringList allTestFunctions;
Nikolai Kosjar's avatar
Nikolai Kosjar committed
675
        const QMetaObject *metaObject = pluginSpec->plugin()->metaObject();
676

Nikolai Kosjar's avatar
Nikolai Kosjar committed
677
        for (int i = metaObject->methodOffset(); i < metaObject->methodCount(); ++i) {
Friedemann Kleint's avatar
Friedemann Kleint committed
678
#if QT_VERSION >= 0x050000
Nikolai Kosjar's avatar
Nikolai Kosjar committed
679
            const QByteArray signature = metaObject->method(i).methodSignature();
Friedemann Kleint's avatar
Friedemann Kleint committed
680
#else
Nikolai Kosjar's avatar
Nikolai Kosjar committed
681
            const QByteArray signature = metaObject->method(i).signature();
Friedemann Kleint's avatar
Friedemann Kleint committed
682
683
684
#endif
            if (signature.startsWith("test") && !signature.endsWith("_data()")) {
                const QString method = QString::fromLatin1(signature);
Nikolai Kosjar's avatar
Nikolai Kosjar committed
685
686
                const QString methodName = method.left(method.size() - 2);
                allTestFunctions.append(methodName);
con's avatar
con committed
687
688
            }
        }
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724

        QStringList testFunctionsToExecute;

        // User did not specify any test functions, so add every test function.
        if (testSpec.testFunctions.isEmpty()) {
            testFunctionsToExecute = allTestFunctions;

        // User specified test functions. Add them if they are valid.
        } else {
            foreach (const QString &userTestFunction, testSpec.testFunctions) {
                // There might be a test data suffix like in "testfunction:testdata1".
                QString testFunctionName = userTestFunction;
                const int index = testFunctionName.indexOf(QLatin1Char(':'));
                if (index != -1)
                    testFunctionName = testFunctionName.left(index);

                if (allTestFunctions.contains(testFunctionName)) {
                    // If the specified test data is invalid, the QTest framework will
                    // print a reasonable error message for us.
                    testFunctionsToExecute.append(userTestFunction);
                } else {
                    QTextStream out(stdout);
                    out << "Unknown test function \"" << testFunctionName
                        << "\" for plugin \"" << pluginSpec->name() << "\"." << endl
                        << "  Available test functions for plugin \"" << pluginSpec->name()
                        << "\" are:" << endl;
                    foreach (const QString &testFunction, allTestFunctions)
                        out << "    " << testFunction << endl;
                }
            }
        }

        // QTest::qExec() expects basically QCoreApplication::arguments(),
        // so prepend a fake argument for the application name.
        testFunctionsToExecute.prepend(QLatin1String("arg0"));

725
726
        // Don't run QTest::qExec with only one argument, that'd run
        // *all* slots as tests.
727
728
        if (testFunctionsToExecute.size() > 1)
            QTest::qExec(pluginSpec->plugin(), testFunctionsToExecute);
con's avatar
con committed
729
    }
hjk's avatar
hjk committed
730
    if (!d->testSpecs.isEmpty())
731
        QTimer::singleShot(1, QCoreApplication::instance(), SLOT(quit()));
con's avatar
con committed
732
733
734
#endif
}

735
736
737
738
/*!
 * \fn bool PluginManager::runningTests() const
 * \internal
 */
739
bool PluginManager::runningTests()
con's avatar
con committed
740
{
741
    return !m_instance->d->testSpecs.isEmpty();
con's avatar
con committed
742
743
}

744
745
746
747
/*!
 * \fn QString PluginManager::testDataDirectory() const
 * \internal
 */
748
QString PluginManager::testDataDirectory()
con's avatar
con committed
749
{
750
    QByteArray ba = qgetenv("QTCREATOR_TEST_DIR");
hjk's avatar
hjk committed
751
    QString s = QString::fromLocal8Bit(ba.constData(), ba.size());
con's avatar
con committed
752
    if (s.isEmpty()) {
753
754
        s = QLatin1String(IDE_TEST_DIR);
        s.append(QLatin1String("/tests"));
con's avatar
con committed
755
756
757
758
759
    }
    s = QDir::cleanPath(s);
    return s;
}

760
761
762
763
764
765
766
767
/*!
    \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)
{
768
    m_instance->d->profilingReport(what, spec);
769
770
}

771
772
773
774
775
776
777
778

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

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

con's avatar
con committed
782
783
784
785
786
787
788
789
790
791
792
//============PluginManagerPrivate===========

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

793
794
795
796
797
798
799
800
801
802
803
804
805
/*!
    \fn void PluginManagerPrivate::setSettings(QSettings *settings)
    \internal
*/
void PluginManagerPrivate::setSettings(QSettings *s)
{
    if (settings)
        delete settings;
    settings = s;
    if (settings)
        settings->setParent(this);
}

806
807
808
809
810
811
812
813
814
815
816
817
/*!
    \internal
*/
void PluginManagerPrivate::setGlobalSettings(QSettings *s)
{
    if (globalSettings)
        delete globalSettings;
    globalSettings = s;
    if (globalSettings)
        globalSettings->setParent(this);
}

con's avatar
con committed
818
819
820
821
822
823
824
825
826
/*!
    \fn PluginSpecPrivate *PluginManagerPrivate::privateSpec(PluginSpec *spec)
    \internal
*/
PluginSpecPrivate *PluginManagerPrivate::privateSpec(PluginSpec *spec)
{
    return spec->d;
}

827
828
829
830
831
832
833
834
835
836
837
838
839
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;
Tobias Hunger's avatar
Tobias Hunger committed
840
        emit q->initializationDone();
841
842
843
844
845
    } else {
        delayedInitializeTimer->start();
    }
}

con's avatar
con committed
846
847
848
849
/*!
    \fn PluginManagerPrivate::PluginManagerPrivate(PluginManager *pluginManager)
    \internal
*/
850
851
PluginManagerPrivate::PluginManagerPrivate(PluginManager *pluginManager) :
    extension(QLatin1String("xml")),
852
853
    delayedInitializeTimer(0),
    shutdownEventLoop(0),
854
    m_profileElapsedMS(0),
855
    m_profilingVerbosity(0),
856
    settings(0),
857
    globalSettings(0),
858
    q(pluginManager)
con's avatar
con committed
859
860
861
{
}

862

con's avatar
con committed
863
864
865
866
867
868
869
/*!
    \fn PluginManagerPrivate::~PluginManagerPrivate()
    \internal
*/
PluginManagerPrivate::~PluginManagerPrivate()
{
    qDeleteAll(pluginSpecs);
870
    qDeleteAll(pluginCategories);
con's avatar
con committed
871
872
}

873
874
875
876
/*!
    \fn void PluginManagerPrivate::writeSettings()
    \internal
*/
877
878
void PluginManagerPrivate::writeSettings()
{
879
880
    if (!settings)
        return;
con's avatar
con committed
881
    QStringList tempDisabledPlugins;
882
    QStringList tempForceEnabledPlugins;
883
    foreach (PluginSpec *spec, pluginSpecs) {
884
        if (!spec->isDisabledByDefault() && !spec->isEnabled())
con's avatar
con committed
885
            tempDisabledPlugins.append(spec->name());
886
        if (spec->isDisabledByDefault() && spec->isEnabled())
887
            tempForceEnabledPlugins.append(spec->name());
888
889
    }

890
891
    settings->setValue(QLatin1String(C_IGNORED_PLUGINS), tempDisabledPlugins);
    settings->setValue(QLatin1String(C_FORCEENABLED_PLUGINS), tempForceEnabledPlugins);
892
893
}

894
/*!
895
    \fn void PluginManagerPrivate::readSettings()
896
897
    \internal
*/
898
void PluginManagerPrivate::readSettings()
899
{
900
    if (globalSettings)
901
902
903
904
905
        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();
    }
906
907
}

908
909
910
911
/*!
    \fn void PluginManagerPrivate::stopAll()
    \internal
*/
con's avatar
con committed
912
913
void PluginManagerPrivate::stopAll()
{
914
915
916
917
918
    if (delayedInitializeTimer && delayedInitializeTimer->isActive()) {
        delayedInitializeTimer->stop();
        delete delayedInitializeTimer;
        delayedInitializeTimer = 0;
    }
con's avatar
con committed
919
920
921
922
    QList<PluginSpec *> queue = loadQueue();
    foreach (PluginSpec *spec, queue) {
        loadPlugin(spec, PluginSpec::Stopped);
    }
923
924
925
926
927
928
929
930
931
}

/*!
    \fn void PluginManagerPrivate::deleteAll()
    \internal
*/
void PluginManagerPrivate::deleteAll()
{
    QList<PluginSpec *> queue = loadQueue();
con's avatar
con committed
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
    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();

959
960
961
962
963
964
965
        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
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
        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()
{
For faster browsing, not all history is shown. View entire blame