1 /*

     2     Copyright (C) 2009 Jakub Wieczorek <faw217@gmail.com>

     3 

     4     This library is free software; you can redistribute it and/or

     5     modify it under the terms of the GNU Library General Public

     6     License as published by the Free Software Foundation; either

     7     version 2 of the License, or (at your option) any later version.

     8 

     9     This library is distributed in the hope that it will be useful,

    10     but WITHOUT ANY WARRANTY; without even the implied warranty of

    11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12     Library General Public License for more details.

    13 

    14     You should have received a copy of the GNU Library General Public License

    15     along with this library; see the file COPYING.LIB.  If not, write to

    16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    17     Boston, MA 02110-1301, USA.

    18 */

    19 

    20 #include "config.h"

    21 #include "qwebplugindatabase_p.h"

    22 

    23 #include "PluginDatabase.h"

    24 #include "PluginPackage.h"

    25 

    26 using namespace WebCore;

    27 

    28 /*!

    29     \internal

    30     \typedef QWebPluginInfo::MimeType

    31     \since 4.6

    32     \brief Represents a single MIME type supported by a plugin.

    33 */

    34 

    35 /*!

    36     \class QWebPluginInfo

    37     \internal

    38     \since 4.6

    39     \brief The QWebPluginInfo class represents a single Netscape plugin.

    40 

    41     A QWebPluginInfo object represents a Netscape plugin picked up by WebKit

    42     and included in the plugin database. This class contains information about

    43     the plugin, such as its name(), description(), a list of MIME types that it

    44     supports (can be accessed with mimeTypes()) and the path of the plugin

    45     file.

    46 

    47     Plugins can be enabled and disabled with setEnabled(). If a plugin is

    48     disabled, it will not be used by WebKit to handle supported MIME types. To

    49     check if a plugin is enabled or not, use enabled().

    50 

    51     \sa QWebPluginDatabase

    52 */

    53 

    54 /*!

    55     Constructs a null QWebPluginInfo.

    56 */

    57 QWebPluginInfo::QWebPluginInfo()

    58     : m_package(0)

    59 {

    60 }

    61 

    62 QWebPluginInfo::QWebPluginInfo(PluginPackage* package)

    63     : m_package(package)

    64 {

    65     if (m_package)

    66         m_package->ref();

    67 }

    68 

    69 /*!

    70     Contructs a copy of \a other.

    71 */

    72 QWebPluginInfo::QWebPluginInfo(const QWebPluginInfo& other)

    73     : m_package(other.m_package)

    74 {

    75     if (m_package)

    76         m_package->ref();

    77 }

    78 

    79 /*!

    80     Destroys the plugin info.

    81 */

    82 QWebPluginInfo::~QWebPluginInfo()

    83 {

    84     if (m_package)

    85         m_package->deref();

    86 }

    87 

    88 /*!

    89     Returns the name of the plugin.

    90 

    91     \sa description()

    92 */

    93 QString QWebPluginInfo::name() const

    94 {

    95     if (!m_package)

    96         return QString();

    97     return m_package->name();

    98 }

    99 

   100 /*!

   101     Returns the description of the plugin.

   102 

   103     \sa name()

   104 */

   105 QString QWebPluginInfo::description() const

   106 {

   107     if (!m_package)

   108         return QString();

   109     return m_package->description();

   110 }

   111 

   112 /*!

   113     Returns a list of MIME types supported by the plugin.

   114 

   115     \sa supportsMimeType()

   116 */

   117 QList<QWebPluginInfo::MimeType> QWebPluginInfo::mimeTypes() const

   118 {

   119     if (m_package && m_mimeTypes.isEmpty()) {

   120         const MIMEToDescriptionsMap& mimeToDescriptions = m_package->mimeToDescriptions();

   121         MIMEToDescriptionsMap::const_iterator end = mimeToDescriptions.end();

   122 

   123         for (MIMEToDescriptionsMap::const_iterator it = mimeToDescriptions.begin(); it != end; ++it) {

   124             MimeType mimeType;

   125             mimeType.name = it->first;

   126             mimeType.description = it->second;

   127 

   128             QStringList fileExtensions;

   129             Vector<String> extensions = m_package->mimeToExtensions().get(mimeType.name);

   130 

   131             for (unsigned i = 0; i < extensions.size(); ++i)

   132                 fileExtensions.append(extensions[i]);

   133 

   134             mimeType.fileExtensions = fileExtensions;

   135             m_mimeTypes.append(mimeType);

   136         }

   137     }

   138 

   139     return m_mimeTypes;

   140 }

   141 

   142 /*!

   143     Returns true if the plugin supports a specific \a mimeType; otherwise

   144     returns false.

   145 

   146     \sa mimeTypes()

   147 */

   148 bool QWebPluginInfo::supportsMimeType(const QString& mimeType) const

   149 {

   150     if (!m_package)

   151         return false;

   152     return m_package->mimeToDescriptions().contains(mimeType);

   153 }

   154 

   155 /*!

   156     Returns an absolute path to the plugin file.

   157 */

   158 QString QWebPluginInfo::path() const

   159 {

   160     if (!m_package)

   161         return QString();

   162     return m_package->path();

   163 }

   164 

   165 /*!

   166     Returns true if the plugin is a null plugin; otherwise returns false.

   167 */

   168 bool QWebPluginInfo::isNull() const

   169 {

   170     return !m_package;

   171 }

   172 

   173 /*!

   174     Enables or disables the plugin, depending on the \a enabled parameter.

   175 

   176     Disabled plugins will not be picked up by WebKit when looking for a plugin

   177     supporting a particular MIME type.

   178 

   179     \sa isEnabled()

   180 */

   181 void QWebPluginInfo::setEnabled(bool enabled)

   182 {

   183     if (!m_package)

   184         return;

   185     m_package->setEnabled(enabled);

   186 }

   187 

   188 /*!

   189     Returns true if the plugin is enabled; otherwise returns false.

   190 

   191     \sa setEnabled()

   192 */

   193 bool QWebPluginInfo::isEnabled() const

   194 {

   195     if (!m_package)

   196         return false;

   197     return m_package->isEnabled();

   198 }

   199 

   200 /*!

   201     Returns true if this plugin info is the same as the \a other plugin info.

   202 */

   203 bool QWebPluginInfo::operator==(const QWebPluginInfo& other) const

   204 {

   205     return m_package == other.m_package;

   206 }

   207 

   208 /*!

   209     Returns true if this plugin info is different from the \a other plugin info.

   210 */

   211 bool QWebPluginInfo::operator!=(const QWebPluginInfo& other) const

   212 {

   213     return m_package != other.m_package;

   214 }

   215 

   216 /*!

   217     Assigns the \a other plugin info to this plugin info, and returns a reference

   218     to this plugin info.

   219 */

   220 QWebPluginInfo &QWebPluginInfo::operator=(const QWebPluginInfo& other)

   221 {

   222     if (this == &other)

   223         return *this;

   224 

   225     if (m_package)

   226         m_package->deref();

   227     m_package = other.m_package;

   228     if (m_package)

   229         m_package->ref();

   230     m_mimeTypes = other.m_mimeTypes;

   231 

   232     return *this;

   233 }

   234 

   235 /*!

   236     \class QWebPluginDatabase

   237     \internal

   238     \since 4.6

   239     \brief The QWebPluginDatabase class provides an interface for managing

   240     Netscape plugins used by WebKit in QWebPages.

   241 

   242     The QWebPluginDatabase class is a database of Netscape plugins that are used

   243     by WebKit. The plugins are picked up by WebKit by looking up a set of search paths.

   244     The default set can be accessed using defaultSearchPaths(). The search paths

   245     can be changed, see searchPaths() and setSearchPaths(). Additional search paths

   246     can also be added using addSearchPath().

   247 

   248     The plugins that have been detected are exposed by the plugins() method.

   249     The list contains QWebPlugin objects that hold both the metadata and the MIME

   250     types that are supported by particular plugins.

   251 

   252     WebKit specifies a plugin for a MIME type by looking for the first plugin that

   253     supports the specific MIME type. To get a plugin, that is used by WebKit to

   254     handle a specific MIME type, you can use the pluginForMimeType() function.

   255 

   256     To change the way of resolving MIME types ambiguity, you can explicitly set

   257     a preferred plugin for a specific MIME type, using setPreferredPluginForMimeType().

   258 

   259     \sa QWebPluginInfo, QWebSettings::pluginDatabase()

   260 */

   261 

   262 QWebPluginDatabase::QWebPluginDatabase(QObject* parent)

   263     : QObject(parent)

   264     , m_database(PluginDatabase::installedPlugins())

   265 {

   266 }

   267 

   268 QWebPluginDatabase::~QWebPluginDatabase()

   269 {

   270 }

   271 

   272 /*!

   273     Returns a list of plugins installed in the search paths.

   274 

   275     This list will contain disabled plugins, although they will not be used by

   276     WebKit.

   277 

   278     \sa pluginForMimeType()

   279 */

   280 QList<QWebPluginInfo> QWebPluginDatabase::plugins() const

   281 {

   282     QList<QWebPluginInfo> qwebplugins;

   283     const Vector<PluginPackage*>& plugins = m_database->plugins();

   284 

   285     for (unsigned int i = 0; i < plugins.size(); ++i) {

   286         PluginPackage* plugin = plugins[i];

   287         qwebplugins.append(QWebPluginInfo(plugin));

   288     }

   289 

   290     return qwebplugins;

   291 }

   292 

   293 /*!

   294     Returns a default set of search paths.

   295 

   296     \sa searchPaths(), setSearchPaths()

   297 */

   298 QStringList QWebPluginDatabase::defaultSearchPaths()

   299 {

   300     QStringList paths;

   301 

   302     const Vector<String>& directories = PluginDatabase::defaultPluginDirectories();

   303     for (unsigned int i = 0; i < directories.size(); ++i)

   304         paths.append(directories[i]);

   305 

   306     return paths;

   307 }

   308 

   309 /*!

   310     Returns a list of search paths that are used by WebKit to look for plugins.

   311 

   312     \sa defaultSearchPaths(), setSearchPaths()

   313 */

   314 QStringList QWebPluginDatabase::searchPaths() const

   315 {

   316     QStringList paths;

   317 

   318     const Vector<String>& directories = m_database->pluginDirectories();

   319     for (unsigned int i = 0; i < directories.size(); ++i)

   320         paths.append(directories[i]);

   321 

   322     return paths;

   323 }

   324 

   325 /*!

   326     Changes the search paths to \a paths.

   327     The database is automatically refreshed.

   328 

   329     \sa searchPaths(), defaultSearchPaths()

   330 */

   331 void QWebPluginDatabase::setSearchPaths(const QStringList& paths)

   332 {

   333     Vector<String> directories;

   334 

   335     for (int i = 0; i < paths.count(); ++i)

   336         directories.append(paths.at(i));

   337 

   338     m_database->setPluginDirectories(directories);

   339     // PluginDatabase::setPluginDirectories() does not refresh the database.

   340     m_database->refresh();

   341 }

   342 

   343 /*!

   344     Adds an additional \a path to the current set.

   345     The database is automatically refreshed.

   346 

   347     \sa searchPaths(), setSearchPaths()

   348 */

   349 void QWebPluginDatabase::addSearchPath(const QString& path)

   350 {

   351     m_database->addExtraPluginDirectory(path);

   352     // PluginDatabase::addExtraPluginDirectory() does refresh the database.

   353 }

   354 

   355 /*!

   356     Refreshes the plugin database, adds new plugins that have been found and removes

   357     the ones that are no longer available in the search paths.

   358 

   359     You can call this function when the set of plugins installed in the search paths

   360     changes. You do not need to call this function when changing search paths,

   361     in that case WebKit automatically refreshes the database.

   362 */

   363 void QWebPluginDatabase::refresh()

   364 {

   365     m_database->refresh();

   366 }

   367 

   368 /*!

   369     Returns the plugin that is currently used by WebKit for a given \a mimeType.

   370 

   371     \sa setPreferredPluginForMimeType()

   372 */

   373 QWebPluginInfo QWebPluginDatabase::pluginForMimeType(const QString& mimeType)

   374 {

   375     return QWebPluginInfo(m_database->pluginForMIMEType(mimeType));

   376 }

   377 

   378 /*!

   379     Changes the preferred plugin for a given \a mimeType to \a plugin. The \a plugin

   380     has to support the given \a mimeType, otherwise the setting will have no effect.

   381 

   382     Calling the function with a null \a plugin resets the setting.

   383 

   384     \sa pluginForMimeType()

   385 */

   386 void QWebPluginDatabase::setPreferredPluginForMimeType(const QString& mimeType, const QWebPluginInfo& plugin)

   387 {

   388     m_database->setPreferredPluginForMIMEType(mimeType, plugin.m_package);

   389 }