[2] | 1 | /****************************************************************************
|
---|
| 2 | ** $Id: qgpluginmanager.cpp 8 2005-11-16 19:36:46Z dmik $
|
---|
| 3 | **
|
---|
| 4 | ** Implementation of QGPluginManager class
|
---|
| 5 | **
|
---|
| 6 | ** Copyright (C) 2000-2003 Trolltech AS. All rights reserved.
|
---|
| 7 | **
|
---|
| 8 | ** This file is part of the tools module of the Qt GUI Toolkit.
|
---|
| 9 | **
|
---|
| 10 | ** This file may be distributed under the terms of the Q Public License
|
---|
| 11 | ** as defined by Trolltech AS of Norway and appearing in the file
|
---|
| 12 | ** LICENSE.QPL included in the packaging of this file.
|
---|
| 13 | **
|
---|
| 14 | ** This file may be distributed and/or modified under the terms of the
|
---|
| 15 | ** GNU General Public License version 2 as published by the Free Software
|
---|
| 16 | ** Foundation and appearing in the file LICENSE.GPL included in the
|
---|
| 17 | ** packaging of this file.
|
---|
| 18 | **
|
---|
| 19 | ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
|
---|
| 20 | ** licenses may use this file in accordance with the Qt Commercial License
|
---|
| 21 | ** Agreement provided with the Software.
|
---|
| 22 | **
|
---|
| 23 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
---|
| 24 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
---|
| 25 | **
|
---|
| 26 | ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
|
---|
| 27 | ** information about Qt Commercial License Agreements.
|
---|
| 28 | ** See http://www.trolltech.com/qpl/ for QPL licensing information.
|
---|
| 29 | ** See http://www.trolltech.com/gpl/ for GPL licensing information.
|
---|
| 30 | **
|
---|
| 31 | ** Contact info@trolltech.com if any conditions of this licensing are
|
---|
| 32 | ** not clear to you.
|
---|
| 33 | **
|
---|
| 34 | **********************************************************************/
|
---|
| 35 |
|
---|
| 36 | #include "qgpluginmanager_p.h"
|
---|
| 37 | #ifndef QT_NO_COMPONENT
|
---|
| 38 | #include "qcomlibrary_p.h"
|
---|
| 39 | #include "qmap.h"
|
---|
| 40 | #include "qdir.h"
|
---|
| 41 |
|
---|
| 42 | /*
|
---|
| 43 | The following co-occurrence code is borrowed from Qt Linguist.
|
---|
| 44 |
|
---|
| 45 | How similar are two texts? The approach used here relies on
|
---|
| 46 | co-occurrence matrices and is very efficient.
|
---|
| 47 |
|
---|
| 48 | Let's see with an example: how similar are "here" and "hither"? The
|
---|
| 49 | co-occurrence matrix M for "here" is M[h,e] = 1, M[e,r] = 1,
|
---|
| 50 | M[r,e] = 1 and 0 elsewhere; the matrix N for "hither" is N[h,i] = 1,
|
---|
| 51 | N[i,t] = 1, ..., N[h,e] = 1, N[e,r] = 1 and 0 elsewhere. The union
|
---|
| 52 | U of both matrices is the matrix U[i,j] = max { M[i,j], N[i,j] },
|
---|
| 53 | and the intersection V is V[i,j] = min { M[i,j], N[i,j] }. The score
|
---|
| 54 | for a pair of texts is
|
---|
| 55 |
|
---|
| 56 | score = (sum of V[i,j] over all i, j) / (sum of U[i,j] over all i, j),
|
---|
| 57 |
|
---|
| 58 | a formula suggested by Arnt Gulbrandsen. Here we have
|
---|
| 59 |
|
---|
| 60 | score = 2 / 6,
|
---|
| 61 |
|
---|
| 62 | or one third.
|
---|
| 63 |
|
---|
| 64 | The implementation differs from this in a few details. Most
|
---|
| 65 | importantly, repetitions are ignored; for input "xxx", M[x,x] equals
|
---|
| 66 | 1, not 2.
|
---|
| 67 | */
|
---|
| 68 |
|
---|
| 69 | /*
|
---|
| 70 | Every character is assigned to one of 20 buckets so that the
|
---|
| 71 | co-occurrence matrix requires only 20 * 20 = 400 bits, not
|
---|
| 72 | 256 * 256 = 65536 bits or even more if we want the whole Unicode.
|
---|
| 73 | Which character falls in which bucket is arbitrary.
|
---|
| 74 |
|
---|
| 75 | The second half of the table is a replica of the first half, because of
|
---|
| 76 | laziness.
|
---|
| 77 | */
|
---|
| 78 | static const char indexOf[256] = {
|
---|
| 79 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
---|
| 80 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
---|
| 81 | // ! " # $ % & ' ( ) * + , - . /
|
---|
| 82 | 0, 2, 6, 7, 10, 12, 15, 19, 2, 6, 7, 10, 12, 15, 19, 0,
|
---|
| 83 | // 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
|
---|
| 84 | 1, 3, 4, 5, 8, 9, 11, 13, 14, 16, 2, 6, 7, 10, 12, 15,
|
---|
| 85 | // @ A B C D E F G H I J K L M N O
|
---|
| 86 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 10, 11, 12, 13, 14,
|
---|
| 87 | // P Q R S T U V W X Y Z [ \ ] ^ _
|
---|
| 88 | 15, 12, 16, 17, 18, 19, 2, 10, 15, 7, 19, 2, 6, 7, 10, 0,
|
---|
| 89 | // ` a b c d e f g h i j k l m n o
|
---|
| 90 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 10, 11, 12, 13, 14,
|
---|
| 91 | // p q r s t u v w x y z { | } ~
|
---|
| 92 | 15, 12, 16, 17, 18, 19, 2, 10, 15, 7, 19, 2, 6, 7, 10, 0,
|
---|
| 93 |
|
---|
| 94 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
---|
| 95 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
---|
| 96 | 0, 2, 6, 7, 10, 12, 15, 19, 2, 6, 7, 10, 12, 15, 19, 0,
|
---|
| 97 | 1, 3, 4, 5, 8, 9, 11, 13, 14, 16, 2, 6, 7, 10, 12, 15,
|
---|
| 98 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 10, 11, 12, 13, 14,
|
---|
| 99 | 15, 12, 16, 17, 18, 19, 2, 10, 15, 7, 19, 2, 6, 7, 10, 0,
|
---|
| 100 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 10, 11, 12, 13, 14,
|
---|
| 101 | 15, 12, 16, 17, 18, 19, 2, 10, 15, 7, 19, 2, 6, 7, 10, 0
|
---|
| 102 | };
|
---|
| 103 |
|
---|
| 104 | /*
|
---|
| 105 | The entry bitCount[i] (for i between 0 and 255) is the number of
|
---|
| 106 | bits used to represent i in binary.
|
---|
| 107 | */
|
---|
| 108 | static const char bitCount[256] = {
|
---|
| 109 | 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
|
---|
| 110 | 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
---|
| 111 | 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
---|
| 112 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
---|
| 113 | 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
---|
| 114 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
---|
| 115 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
---|
| 116 | 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
---|
| 117 | 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
---|
| 118 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
---|
| 119 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
---|
| 120 | 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
---|
| 121 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
---|
| 122 | 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
---|
| 123 | 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
---|
| 124 | 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
|
---|
| 125 | };
|
---|
| 126 |
|
---|
| 127 | class QCoMatrix
|
---|
| 128 | {
|
---|
| 129 | public:
|
---|
| 130 | /*
|
---|
| 131 | The matrix has 20 * 20 = 400 entries. This requires 50 bytes, or
|
---|
| 132 | 13 words. Some operations are performed on words for more
|
---|
| 133 | efficiency.
|
---|
| 134 | */
|
---|
| 135 | union {
|
---|
| 136 | Q_UINT8 b[52];
|
---|
| 137 | Q_UINT32 w[13];
|
---|
| 138 | };
|
---|
| 139 |
|
---|
| 140 | QCoMatrix() { memset( b, 0, 52 ); }
|
---|
| 141 | QCoMatrix( const char *text ) {
|
---|
| 142 | char c = '\0', d;
|
---|
| 143 | memset( b, 0, 52 );
|
---|
| 144 | while ( (d = *text) != '\0' ) {
|
---|
| 145 | setCoocc( c, d );
|
---|
| 146 | if ( (c = *++text) != '\0' ) {
|
---|
| 147 | setCoocc( d, c );
|
---|
| 148 | text++;
|
---|
| 149 | }
|
---|
| 150 | }
|
---|
| 151 | }
|
---|
| 152 |
|
---|
| 153 | void setCoocc( char c, char d ) {
|
---|
| 154 | int k = indexOf[(uchar) c] + 20 * indexOf[(uchar) d];
|
---|
| 155 | b[k >> 3] |= k & 0x7;
|
---|
| 156 | }
|
---|
| 157 |
|
---|
| 158 | int worth() const {
|
---|
| 159 | int result = 0;
|
---|
| 160 | for ( int i = 0; i < 50; i++ )
|
---|
| 161 | result += bitCount[b[i]];
|
---|
| 162 | return result;
|
---|
| 163 | }
|
---|
| 164 |
|
---|
| 165 | static QCoMatrix reunion( const QCoMatrix& m, const QCoMatrix& n )
|
---|
| 166 | {
|
---|
| 167 | QCoMatrix p;
|
---|
| 168 | for ( int i = 0; i < 13; i++ )
|
---|
| 169 | p.w[i] = m.w[i] | n.w[i];
|
---|
| 170 | return p;
|
---|
| 171 | }
|
---|
| 172 | static QCoMatrix intersection( const QCoMatrix& m, const QCoMatrix& n )
|
---|
| 173 | {
|
---|
| 174 | QCoMatrix p;
|
---|
| 175 | for ( int i = 0; i < 13; i++ )
|
---|
| 176 | p.w[i] = m.w[i] & n.w[i];
|
---|
| 177 | return p;
|
---|
| 178 | }
|
---|
| 179 | };
|
---|
| 180 |
|
---|
| 181 | /*
|
---|
| 182 | Returns an integer between 0 (dissimilar) and 15 (very similar)
|
---|
| 183 | depending on how similar the string is to \a target.
|
---|
| 184 |
|
---|
| 185 | This function is efficient, but its results might change in future
|
---|
| 186 | versions of Qt as the algorithm evolves.
|
---|
| 187 |
|
---|
| 188 | \code
|
---|
| 189 | QString s( "color" );
|
---|
| 190 | a = similarity( s, "color" ); // a == 15
|
---|
| 191 | a = similarity( s, "colour" ); // a == 8
|
---|
| 192 | a = similarity( s, "flavor" ); // a == 4
|
---|
| 193 | a = similarity( s, "dahlia" ); // a == 0
|
---|
| 194 | \endcode
|
---|
| 195 | */
|
---|
| 196 | static int similarity( const QString& s1, const QString& s2 )
|
---|
| 197 | {
|
---|
| 198 | QCoMatrix m1( s1 );
|
---|
| 199 | QCoMatrix m2( s2 );
|
---|
| 200 | return ( 15 * (QCoMatrix::intersection(m1, m2).worth() + 1) ) /
|
---|
| 201 | ( QCoMatrix::reunion(m1, m2).worth() + 1 );
|
---|
| 202 | }
|
---|
| 203 |
|
---|
| 204 | /*!
|
---|
| 205 | \class QPluginManager qpluginmanager.h
|
---|
| 206 | \reentrant
|
---|
| 207 | \brief The QPluginManager class provides basic functions to access a certain kind of functionality in libraries.
|
---|
| 208 | \ingroup componentmodel
|
---|
| 209 |
|
---|
| 210 | \internal
|
---|
| 211 |
|
---|
| 212 | A common usage of components is to extend the existing functionality in an application using plugins. The application
|
---|
| 213 | defines interfaces that abstract a certain group of functionality, and a plugin provides a specialized implementation
|
---|
| 214 | of one or more of those interfaces.
|
---|
| 215 |
|
---|
| 216 | The QPluginManager template has to be instantiated with an interface definition and the IID for this interface.
|
---|
| 217 |
|
---|
| 218 | \code
|
---|
| 219 | QPluginManager<MyPluginInterface> *manager = new QPluginManager<MyPluginInterface>( IID_MyPluginInterface );
|
---|
| 220 | \endcode
|
---|
| 221 |
|
---|
| 222 | It searches a specified directory for all shared libraries, queries for components that implement the specific interface and
|
---|
| 223 | reads information about the features the plugin wants to add to the application. The component can provide the set of features
|
---|
| 224 | provided by implementing either the QFeatureListInterface or the QComponentInformationInterface. The strings returned by the implementations
|
---|
| 225 | of
|
---|
| 226 |
|
---|
| 227 | \code
|
---|
| 228 | QStringList QFeatureListInterface::featureList() const
|
---|
| 229 | \endcode
|
---|
| 230 |
|
---|
| 231 | or
|
---|
| 232 |
|
---|
| 233 | \code
|
---|
| 234 | QString QComponentInformationInterface::name() const
|
---|
| 235 | \endcode
|
---|
| 236 |
|
---|
| 237 | respectively, can then be used to access the component that provides the requested feature:
|
---|
| 238 |
|
---|
| 239 | \code
|
---|
| 240 | MyPluginInterface *iface;
|
---|
| 241 | manager->queryInterface( "feature", &iface );
|
---|
| 242 | if ( iface )
|
---|
| 243 | iface->execute( "feature" );
|
---|
| 244 | \endcode
|
---|
| 245 |
|
---|
| 246 | The application can use a QPluginManager instance to create parts of the user interface based on the list of features
|
---|
| 247 | found in plugins:
|
---|
| 248 |
|
---|
| 249 | \code
|
---|
| 250 | QPluginManager<MyPluginInterface> *manager = new QPluginManager<MyPluginInterface>( IID_ImageFilterInterface );
|
---|
| 251 | manager->addLibraryPath(...);
|
---|
| 252 |
|
---|
| 253 | QStringList features = manager->featureList();
|
---|
| 254 | for ( QStringList::Iterator it = features.begin(); it != features.end(); ++it ) {
|
---|
| 255 | MyPluginInterface *iface;
|
---|
| 256 | manager->queryInterface( *it, &iface );
|
---|
| 257 |
|
---|
| 258 | // use QAction to provide toolbuttons and menuitems for each feature...
|
---|
| 259 | }
|
---|
| 260 | \endcode
|
---|
| 261 | */
|
---|
| 262 |
|
---|
| 263 | /*!
|
---|
| 264 | \fn QPluginManager::QPluginManager( const QUuid& id, const QStringList& paths = QString::null, const QString &suffix = QString::null, bool cs = TRUE )
|
---|
| 265 |
|
---|
| 266 | Creates an QPluginManager for interfaces \a id that will load all shared library files in the \a paths + \a suffix.
|
---|
| 267 | If \a cs is FALSE the manager will handle feature strings case insensitive.
|
---|
| 268 |
|
---|
| 269 | \warning
|
---|
| 270 | Setting the cs flag to FALSE requires that components also convert to lower case when comparing with passed strings, so this has
|
---|
| 271 | to be handled with care and documented very well.
|
---|
| 272 |
|
---|
| 273 | \sa QApplication::libraryPaths()
|
---|
| 274 | */
|
---|
| 275 |
|
---|
| 276 |
|
---|
| 277 | /*!
|
---|
| 278 | \fn QRESULT QPluginManager::queryInterface(const QString& feature, Type** iface) const
|
---|
| 279 |
|
---|
| 280 | Sets \a iface to point to the interface providing \a feature.
|
---|
| 281 |
|
---|
| 282 | \sa featureList(), library()
|
---|
| 283 | */
|
---|
| 284 |
|
---|
| 285 |
|
---|
| 286 |
|
---|
| 287 | #include <qptrlist.h>
|
---|
| 288 |
|
---|
| 289 | QGPluginManager::QGPluginManager( const QUuid& id, const QStringList& paths, const QString &suffix, bool cs )
|
---|
| 290 | : interfaceId( id ), plugDict( 17, cs ), casesens( cs ), autounload( TRUE )
|
---|
| 291 | {
|
---|
| 292 | // Every QLibrary object is destroyed on destruction of the manager
|
---|
| 293 | libDict.setAutoDelete( TRUE );
|
---|
| 294 | for ( QStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it ) {
|
---|
| 295 | QString path = *it;
|
---|
| 296 | addLibraryPath( path + suffix );
|
---|
| 297 | }
|
---|
| 298 | }
|
---|
| 299 |
|
---|
| 300 | QGPluginManager::~QGPluginManager()
|
---|
| 301 | {
|
---|
| 302 | if ( !autounload ) {
|
---|
| 303 | QDictIterator<QLibrary> it( libDict );
|
---|
| 304 | while ( it.current() ) {
|
---|
| 305 | QLibrary *lib = it.current();
|
---|
| 306 | ++it;
|
---|
| 307 | lib->setAutoUnload( FALSE );
|
---|
| 308 | }
|
---|
| 309 | }
|
---|
| 310 | }
|
---|
| 311 |
|
---|
| 312 | void QGPluginManager::addLibraryPath( const QString& path )
|
---|
| 313 | {
|
---|
| 314 | if ( !enabled() || !QDir( path ).exists( ".", TRUE ) )
|
---|
| 315 | return;
|
---|
| 316 |
|
---|
[8] | 317 | #if defined(Q_OS_WIN32) || defined(Q_OS_OS2)
|
---|
[2] | 318 | QString filter = "*.dll";
|
---|
| 319 | #elif defined(Q_OS_MACX)
|
---|
| 320 | QString filter = "*.dylib; *.so; *.bundle";
|
---|
| 321 | #elif defined(Q_OS_HPUX)
|
---|
| 322 | QString filter = "*.sl";
|
---|
| 323 | #elif defined(Q_OS_UNIX)
|
---|
| 324 | QString filter = "*.so";
|
---|
| 325 | #endif
|
---|
| 326 |
|
---|
| 327 | QStringList plugins = QDir(path).entryList( filter );
|
---|
| 328 | for ( QStringList::Iterator p = plugins.begin(); p != plugins.end(); ++p ) {
|
---|
| 329 | QString lib = QDir::cleanDirPath( path + "/" + *p );
|
---|
| 330 | if ( libList.contains( lib ) )
|
---|
| 331 | continue;
|
---|
| 332 | libList.append( lib );
|
---|
| 333 | }
|
---|
| 334 | }
|
---|
| 335 |
|
---|
| 336 | const QLibrary* QGPluginManager::library( const QString& feature ) const
|
---|
| 337 | {
|
---|
| 338 | if ( !enabled() || feature.isEmpty() )
|
---|
| 339 | return 0;
|
---|
| 340 |
|
---|
| 341 | // We already have a QLibrary object for this feature
|
---|
| 342 | QLibrary *library = 0;
|
---|
| 343 | if ( ( library = plugDict[feature] ) )
|
---|
| 344 | return library;
|
---|
| 345 |
|
---|
| 346 | // Find the filename that matches the feature request best
|
---|
| 347 | QMap<int, QStringList> map;
|
---|
| 348 | QStringList::ConstIterator it = libList.begin();
|
---|
| 349 | int best = 0;
|
---|
| 350 | int worst = 15;
|
---|
| 351 | while ( it != libList.end() ) {
|
---|
| 352 | if ( (*it).isEmpty() || libDict[*it] ) {
|
---|
| 353 | ++it;
|
---|
| 354 | continue;
|
---|
| 355 | }
|
---|
| 356 | QString basename = QFileInfo(*it).baseName();
|
---|
| 357 | int s = similarity( feature, basename );
|
---|
| 358 | if ( s < worst )
|
---|
| 359 | worst = s;
|
---|
| 360 | if ( s > best )
|
---|
| 361 | best = s;
|
---|
| 362 | map[s].append( basename + QChar(0xfffd) + *it );
|
---|
| 363 | ++it;
|
---|
| 364 | }
|
---|
| 365 |
|
---|
| 366 | if ( map.isEmpty() )
|
---|
| 367 | return 0; // no libraries to add
|
---|
| 368 |
|
---|
| 369 | // Start with the best match to get the library object
|
---|
| 370 | QGPluginManager *that = (QGPluginManager*)this;
|
---|
| 371 | for ( int s = best; s >= worst; --s ) {
|
---|
| 372 | QStringList group = map[s];
|
---|
| 373 | group.sort(); // sort according to the base name
|
---|
| 374 | QStringList::ConstIterator git = group.begin();
|
---|
| 375 | while ( git != group.end() ) {
|
---|
| 376 | QString lib = (*git).mid( (*git).find( QChar(0xfffd) ) + 1 );
|
---|
| 377 | QString basename = (*git).left( (*git).find( QChar(0xfffd) ) );
|
---|
| 378 | ++git;
|
---|
| 379 |
|
---|
| 380 | QStringList sameBasename;
|
---|
| 381 | while( git != group.end() &&
|
---|
| 382 | basename == (*git).left( (*git).find( QChar(0xfffd) ) ) ) {
|
---|
| 383 | sameBasename << (*git).mid( (*git).find( QChar(0xfffd) ) + 1 );
|
---|
| 384 | ++git;
|
---|
| 385 | }
|
---|
| 386 |
|
---|
| 387 | if ( sameBasename.isEmpty() ) {
|
---|
| 388 | that->addLibrary( new QComLibrary( lib ) );
|
---|
| 389 | } else {
|
---|
| 390 | QPtrList<QComLibrary> same;
|
---|
| 391 | same.setAutoDelete( TRUE );
|
---|
| 392 | for ( QStringList::ConstIterator bit = sameBasename.begin();
|
---|
| 393 | bit != sameBasename.end(); ++bit )
|
---|
| 394 | same.append( new QComLibrary( *bit ) );
|
---|
| 395 | QComLibrary* bestMatch = 0;
|
---|
| 396 | for ( QComLibrary* candidate = same.first(); candidate; candidate = same.next() )
|
---|
| 397 | if ( candidate->qtVersion() && candidate->qtVersion() <= QT_VERSION
|
---|
| 398 | && ( !bestMatch || candidate->qtVersion() > bestMatch->qtVersion() ) )
|
---|
| 399 | bestMatch = candidate;
|
---|
| 400 | if ( bestMatch ) {
|
---|
| 401 | same.find( bestMatch );
|
---|
| 402 | that->addLibrary( same.take() );
|
---|
| 403 | }
|
---|
| 404 | }
|
---|
| 405 |
|
---|
| 406 | if ( ( library = that->plugDict[feature] ) )
|
---|
| 407 | return library;
|
---|
| 408 | }
|
---|
| 409 | }
|
---|
| 410 | return 0;
|
---|
| 411 | }
|
---|
| 412 |
|
---|
| 413 | QStringList QGPluginManager::featureList() const
|
---|
| 414 | {
|
---|
| 415 | QStringList features;
|
---|
| 416 |
|
---|
| 417 | if ( !enabled() )
|
---|
| 418 | return features;
|
---|
| 419 |
|
---|
| 420 | QGPluginManager *that = (QGPluginManager*)this;
|
---|
| 421 | QStringList theLibs = libList;
|
---|
| 422 | QStringList phase2Libs;
|
---|
| 423 | QStringList phase2Deny;
|
---|
| 424 |
|
---|
| 425 | /* In order to get the feature list we need to add all interesting
|
---|
| 426 | libraries. If there are libraries with the same base name, we
|
---|
| 427 | prioritze the one that fits our Qt version number and ignore the
|
---|
| 428 | others */
|
---|
| 429 | QStringList::Iterator it;
|
---|
| 430 | for ( it = theLibs.begin(); it != theLibs.end(); ++it ) {
|
---|
| 431 | if ( (*it).isEmpty() || libDict[*it] )
|
---|
| 432 | continue;
|
---|
| 433 | QComLibrary* library = new QComLibrary( *it );
|
---|
| 434 | if ( library->qtVersion() == QT_VERSION ) {
|
---|
| 435 | that->addLibrary( library );
|
---|
| 436 | phase2Deny << QFileInfo( *it ).baseName();
|
---|
| 437 | } else {
|
---|
| 438 | delete library;
|
---|
| 439 | phase2Libs << *it;
|
---|
| 440 | }
|
---|
| 441 | }
|
---|
| 442 | for ( it = phase2Libs.begin(); it != phase2Libs.end(); ++it )
|
---|
| 443 | if ( !phase2Deny.contains( QFileInfo( *it ).baseName() ) )
|
---|
| 444 | that->addLibrary( new QComLibrary( *it ) );
|
---|
| 445 |
|
---|
| 446 | for ( QDictIterator<QLibrary> pit( plugDict ); pit.current(); ++pit )
|
---|
| 447 | features << pit.currentKey();
|
---|
| 448 |
|
---|
| 449 | return features;
|
---|
| 450 | }
|
---|
| 451 |
|
---|
| 452 | bool QGPluginManager::addLibrary( QLibrary* lib )
|
---|
| 453 | {
|
---|
| 454 | if ( !enabled() || !lib )
|
---|
| 455 | return FALSE;
|
---|
| 456 |
|
---|
| 457 | QComLibrary* plugin = (QComLibrary*)lib;
|
---|
| 458 | bool useful = FALSE;
|
---|
| 459 |
|
---|
| 460 | QUnknownInterface* iFace = 0;
|
---|
| 461 | plugin->queryInterface( interfaceId, &iFace );
|
---|
| 462 | if ( iFace ) {
|
---|
| 463 | QFeatureListInterface *fliFace = 0;
|
---|
| 464 | QComponentInformationInterface *cpiFace = 0;
|
---|
| 465 | iFace->queryInterface( IID_QFeatureList, (QUnknownInterface**)&fliFace );
|
---|
| 466 | if ( !fliFace )
|
---|
| 467 | plugin->queryInterface( IID_QFeatureList, (QUnknownInterface**)&fliFace );
|
---|
| 468 | if ( !fliFace ) {
|
---|
| 469 | iFace->queryInterface( IID_QComponentInformation, (QUnknownInterface**)&cpiFace );
|
---|
| 470 | if ( !cpiFace )
|
---|
| 471 | plugin->queryInterface( IID_QComponentInformation, (QUnknownInterface**)&cpiFace );
|
---|
| 472 | }
|
---|
| 473 | QStringList fl;
|
---|
| 474 | if ( fliFace )
|
---|
| 475 | // Map all found features to the library
|
---|
| 476 | fl = fliFace->featureList();
|
---|
| 477 | else if ( cpiFace )
|
---|
| 478 | fl << cpiFace->name();
|
---|
| 479 |
|
---|
| 480 | for ( QStringList::Iterator f = fl.begin(); f != fl.end(); ++f ) {
|
---|
| 481 | QLibrary *old = plugDict[*f];
|
---|
| 482 | if ( !old ) {
|
---|
| 483 | useful = TRUE;
|
---|
| 484 | plugDict.replace( *f, plugin );
|
---|
| 485 | } else {
|
---|
| 486 | // we have old *and* plugin, which one to pick?
|
---|
| 487 | QComLibrary* first = (QComLibrary*)old;
|
---|
| 488 | QComLibrary* second = (QComLibrary*)plugin;
|
---|
| 489 | bool takeFirst = TRUE;
|
---|
| 490 | if ( first->qtVersion() != QT_VERSION ) {
|
---|
| 491 | if ( second->qtVersion() == QT_VERSION )
|
---|
| 492 | takeFirst = FALSE;
|
---|
| 493 | else if ( second->qtVersion() < QT_VERSION &&
|
---|
| 494 | first->qtVersion() > QT_VERSION )
|
---|
| 495 | takeFirst = FALSE;
|
---|
| 496 | }
|
---|
| 497 | if ( !takeFirst ) {
|
---|
| 498 | useful = TRUE;
|
---|
| 499 | plugDict.replace( *f, plugin );
|
---|
| 500 | qWarning("%s: Discarding feature %s in %s!",
|
---|
| 501 | (const char*) QFile::encodeName( plugin->library()),
|
---|
| 502 | (*f).latin1(),
|
---|
| 503 | (const char*) QFile::encodeName( old->library() ) );
|
---|
| 504 | } else {
|
---|
| 505 | qWarning("%s: Feature %s already defined in %s!",
|
---|
| 506 | (const char*) QFile::encodeName( old->library() ),
|
---|
| 507 | (*f).latin1(),
|
---|
| 508 | (const char*) QFile::encodeName( plugin->library() ) );
|
---|
| 509 | }
|
---|
| 510 | }
|
---|
| 511 | }
|
---|
| 512 | if ( fliFace )
|
---|
| 513 | fliFace->release();
|
---|
| 514 | if ( cpiFace )
|
---|
| 515 | cpiFace->release();
|
---|
| 516 | iFace->release();
|
---|
| 517 | }
|
---|
| 518 |
|
---|
| 519 | if ( useful ) {
|
---|
| 520 | libDict.replace( plugin->library(), plugin );
|
---|
| 521 | if ( !libList.contains( plugin->library() ) )
|
---|
| 522 | libList.append( plugin->library() );
|
---|
| 523 | return TRUE;
|
---|
| 524 | }
|
---|
| 525 | delete plugin;
|
---|
| 526 | return FALSE;
|
---|
| 527 | }
|
---|
| 528 |
|
---|
| 529 |
|
---|
| 530 | bool QGPluginManager::enabled() const
|
---|
| 531 | {
|
---|
| 532 | #ifdef QT_SHARED
|
---|
| 533 | return TRUE;
|
---|
| 534 | #else
|
---|
| 535 | return FALSE;
|
---|
| 536 | #endif
|
---|
| 537 | }
|
---|
| 538 |
|
---|
| 539 | QRESULT QGPluginManager::queryUnknownInterface(const QString& feature, QUnknownInterface** iface) const
|
---|
| 540 | {
|
---|
| 541 | QComLibrary* plugin = 0;
|
---|
| 542 | plugin = (QComLibrary*)library( feature );
|
---|
| 543 | return plugin ? plugin->queryInterface( interfaceId, (QUnknownInterface**)iface ) : QE_NOINTERFACE;
|
---|
| 544 | }
|
---|
| 545 |
|
---|
| 546 | #endif //QT_NO_COMPONENT
|
---|