src/qt3support/other/q3mimefactory.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the Qt3Support module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "q3mimefactory.h"
  43
  44 #ifndef QT_NO_MIMEFACTORY
  45
  46 #include "qmap.h"
  47 #include "qmime.h"
  48 #include "qstringlist.h"
  49 #include "qfileinfo.h"
  50 #include "qdir.h"
  51 #include "q3dragobject.h"
  52 #include "qpixmap.h"
  53 #include "qimagereader.h"
  54 #include "q3cleanuphandler.h"
  55 #include "private/qtextimagehandler_p.h"
  56
  57 QT_BEGIN_NAMESPACE
  58
  59 static Q3MimeSourceFactory* defaultfactory = 0;
  60 static Q3SingleCleanupHandler<Q3MimeSourceFactory> qmime_cleanup_factory;
  61
  62 class Q3MimeSourceFactoryData {
  63 public:
  64     Q3MimeSourceFactoryData() :
  65         last(0)
  66     {
  67     }
  68
  69     ~Q3MimeSourceFactoryData()
  70     {
  71         QMap<QString, QMimeSource*>::Iterator it = stored.begin();
  72         while (it != stored.end()) {
  73             delete *it;
  74             ++it;
  75         }
  76         delete last;
  77     }
  78
  79     QMap<QString, QMimeSource*> stored;
  80     QMap<QString, QString> extensions;
  81     QStringList path;
  82     QMimeSource* last;
  83     QList<Q3MimeSourceFactory*> factories;
  84 };
  85
  86 static QImage richTextImageLoader(const QString &name, const QString &context)
  87 {
  88     QImage img;
  89
  90     const QMimeSource *src = Q3MimeSourceFactory::defaultFactory()->data(name, context);
  91     if (src && Q3ImageDrag::decode(src, img))
  92         return img;
  93
  94     return QImage();
  95 }
  96
  97 /*!
  98     \class Q3MimeSourceFactory
  99     \brief The Q3MimeSourceFactory class is an extensible provider of mime-typed data.
 100
 101     \compat
 102
 103     A Q3MimeSourceFactory provides an abstract interface to a
 104     collection of information. Each piece of information is
 105     represented by a QMimeSource object which can be examined and
 106     converted to concrete data types by functions such as
 107     Q3ImageDrag::canDecode() and Q3ImageDrag::decode().
 108
 109     The base Q3MimeSourceFactory can be used in two ways: as an
 110     abstraction of a collection of files or as specifically stored
 111     data. For it to access files, call setFilePath() before accessing
 112     data. For stored data, call setData() for each item (there are
 113     also convenience functions, e.g. setText(), setImage() and
 114     setPixmap(), that simply call setData() with appropriate
 115     parameters).
 116
 117     The rich text widgets, QTextEdit and QTextBrowser, use
 118     Q3MimeSourceFactory to resolve references such as images or links
 119     within rich text documents. They either access the default factory
 120     (see \l{defaultFactory()}) or their own. Other classes that are
 121     capable of displaying rich text (such as QLabel, QWhatsThis or
 122     QMessageBox) always use the default factory.
 123
 124     A factory can also be used as a container to store data associated
 125     with a name. This technique is useful whenever rich text contains
 126     images that are stored in the program itself, not loaded from the
 127     hard disk. Your program may, for example, define some image data
 128     as:
 129     \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 0
 130
 131     To be able to use this image within some rich text, for example
 132     inside a QLabel, you must create a QImage from the raw data and
 133     insert it into the factory with a unique name:
 134     \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 1
 135
 136     Now you can create a rich text QLabel with
 137
 138     \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 2
 139
 140     When no longer needed, you can clear the data from the factory:
 141
 142     \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 3
 143 */
 144
 145
 146 /*!
 147     Constructs a Q3MimeSourceFactory that has no file path and no
 148     stored content.
 149 */
 150 Q3MimeSourceFactory::Q3MimeSourceFactory() :
 151     d(new Q3MimeSourceFactoryData)
 152 {
 153     addFilePath(QLatin1String(":/qt/q3mimesourcefactory/")); //to get from the resources
 154     // add some reasonable defaults
 155     setExtensionType(QLatin1String("htm"), "text/html;charset=iso8859-1");
 156     setExtensionType(QLatin1String("html"), "text/html;charset=iso8859-1");
 157     setExtensionType(QLatin1String("txt"), "text/plain");
 158     setExtensionType(QLatin1String("xml"), "text/xml;charset=UTF-8");
 159     setExtensionType(QLatin1String("jpg"), "image/jpeg"); // support misspelled jpeg files
 160 }
 161
 162 /*!
 163     Destroys the Q3MimeSourceFactory, deleting all stored content.
 164 */
 165 Q3MimeSourceFactory::~Q3MimeSourceFactory()
 166 {
 167     if (defaultFactory() == this)
 168         defaultfactory = 0;
 169     delete d;
 170 }
 171
 172 QMimeSource* Q3MimeSourceFactory::dataInternal(const QString& abs_name, const QMap<QString, QString> &extensions) const
 173 {
 174     QMimeSource* r = 0;
 175     QStringList attempted_names(abs_name);
 176     QFileInfo fi(abs_name);
 177     if (fi.isReadable()) {
 178         // get the right mimetype
 179         QString e = fi.extension(false);
 180         QByteArray mimetype("application/octet-stream");
 181         if (extensions.contains(e))
 182             mimetype = extensions[e].latin1();
 183         if (!QImageReader::imageFormat(abs_name).isEmpty())
 184             mimetype = "application/x-qt-image";
 185
 186         QFile f(abs_name);
 187         if (f.open(QIODevice::ReadOnly) && f.size()) {
 188             QByteArray ba;
 189             ba.resize(f.size());
 190             f.readBlock(ba.data(), ba.size());
 191             Q3StoredDrag* sr = new Q3StoredDrag(mimetype);
 192             sr->setEncodedData(ba);
 193             delete d->last;
 194             d->last = r = sr;
 195         }
 196     }
 197
 198     // we didn't find the mime-source, so ask the default factory for
 199     // the mime-source (this one will iterate over all installed ones)
 200     //
 201     // this looks dangerous, as this dataInternal() function will be
 202     // called again when the default factory loops over all installed
 203     // factories (including this), but the static bool looping in
 204     // data() avoids endless recursions
 205     if (!r && this != defaultFactory())
 206         r = (QMimeSource*)defaultFactory()->data(abs_name);
 207
 208     return r;
 209 }
 210
 211
 212 /*!
 213     Returns a reference to the data associated with \a abs_name. The
 214     return value remains valid only until the next data() or setData()
 215     call, so you should immediately decode the result.
 216
 217     If there is no data associated with \a abs_name in the factory's
 218     store, the factory tries to access the local filesystem. If \a
 219     abs_name isn't an absolute file name, the factory will search for
 220     it in all defined paths (see \l{setFilePath()}).
 221
 222     The factory understands all the image formats supported by
 223     QImageReader. Any other mime types are determined by the file name
 224     extension. The default settings are
 225     \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 4
 226     The effect of these is that file names ending in "txt" will be
 227     treated as text encoded in the local encoding; those ending in
 228     "xml" will be treated as text encoded in Unicode UTF-8 encoding.
 229     The text/html type is treated specially, since the encoding can be
 230     specified in the html file itself. "html" or "htm" will be treated
 231     as text encoded in the encoding specified by the html meta tag, if
 232     none could be found, the charset of the mime type will be used.
 233     The text subtype ("html", "plain", or "xml") does not affect the
 234     factory, but users of the factory may behave differently. We
 235     recommend creating "xml" files where practical. These files can be
 236     viewed regardless of the runtime encoding and can encode any
 237     Unicode characters without resorting to encoding definitions
 238     inside the file.
 239
 240     Any file data that is not recognized will be retrieved as a
 241     QMimeSource providing the "application/octet-stream" mime type,
 242     meaning uninterpreted binary data.
 243
 244     You can add further extensions or change existing ones with
 245     subsequent calls to setExtensionType(). If the extension mechanism
 246     is not sufficient for your problem domain, you can inherit
 247     Q3MimeSourceFactory and reimplement this function to perform some
 248     more specialized mime-type detection. The same applies if you want
 249     to use the mime source factory to access URL referenced data over
 250     a network.
 251 */
 252 const QMimeSource *Q3MimeSourceFactory::data(const QString& abs_name) const
 253 {
 254     if (d->stored.contains(abs_name))
 255         return d->stored[abs_name];
 256
 257     const QMimeSource *r = 0;
 258     if (abs_name.isEmpty())
 259         return r;
 260     QStringList::Iterator it;
 261     if (abs_name[0] == QLatin1Char('/')
 262 #ifdef Q_WS_WIN
 263             || (abs_name[0].isLetter() && abs_name[1] == QLatin1Char(':')) || abs_name.startsWith(QLatin1String("\\\\"))
 264 #endif
 265    )
 266     {
 267         // handle absolute file names directly
 268         r = dataInternal(abs_name, d->extensions);
 269     }
 270     else { // check list of paths
 271         for (it = d->path.begin(); !r && it != d->path.end(); ++it) {
 272             QString filename = *it;
 273             if (filename[(int)filename.length()-1] != QLatin1Char('/'))
 274                 filename += QLatin1Char('/');
 275             filename += abs_name;
 276             r = dataInternal(filename, d->extensions);
 277         }
 278     }
 279
 280     static bool looping = false;
 281     if (!r && this == defaultFactory()) {
 282         // we found no mime-source and we are the default factory, so
 283         // we know all the other installed mime-source factories, so
 284         // ask them
 285         if (!looping) {
 286             // to avoid endless recustions, don't enter the loop below
 287             // if data() got called from within the loop below
 288             looping = true;
 289             for (int i = 0; i < d->factories.size(); ++i) {
 290                 const Q3MimeSourceFactory *f = d->factories.at(i);
 291                 if (f == this)
 292                     continue;
 293                 r = static_cast<const QMimeSource *>(f->data(abs_name));
 294                 if (r) {
 295                     looping = false;
 296                     return r;
 297                 }
 298             }
 299             looping = false;
 300         }
 301     } else if (!r) {
 302         // we are not the default mime-source factory, so ask the
 303         // default one for the mime-source, as this one will loop over
 304         // all installed mime-source factories and ask these
 305         r = static_cast<const QMimeSource *>(defaultFactory()->data(abs_name));
 306     }
 307     return r;
 308 }
 309
 310 /*!
 311     \fn void Q3MimeSourceFactory::setFilePath(const QStringList &path)
 312     \fn void Q3MimeSourceFactory::setFilePath(const QString &path)
 313
 314     Sets the list of directories that will be searched when named data
 315     is requested to those given in the string list \a path.
 316
 317     \sa filePath()
 318 */
 319 void Q3MimeSourceFactory::setFilePath(const QStringList& path)
 320 {
 321     d->path = path;
 322 }
 323
 324 /*!
 325     Returns the currently set search paths.
 326 */
 327 QStringList Q3MimeSourceFactory::filePath() const
 328 {
 329     return d->path;
 330 }
 331
 332 /*!
 333     Adds another search path, \a p to the existing search paths.
 334
 335     \sa setFilePath()
 336 */
 337 void Q3MimeSourceFactory::addFilePath(const QString& p)
 338 {
 339     d->path += p;
 340 }
 341
 342 /*!
 343     Sets the mime-type to be associated with the file name extension,
 344     \a ext to \a mimetype. This determines the mime-type for files
 345     found via the paths set by setFilePath().
 346 */
 347 void Q3MimeSourceFactory::setExtensionType(const QString& ext, const char* mimetype)
 348 {
 349     d->extensions.insert(ext, QLatin1String(mimetype));
 350 }
 351
 352 /*!
 353     Converts the absolute or relative data item name \a
 354     abs_or_rel_name to an absolute name, interpreted within the
 355     context (path) of the data item named \a context (this must be an
 356     absolute name).
 357 */
 358 QString Q3MimeSourceFactory::makeAbsolute(const QString& abs_or_rel_name, const QString& context) const
 359 {
 360     if (context.isNull() ||
 361          !(context[0] == QLatin1Char('/')
 362 #ifdef Q_WS_WIN
 363          || (context[0].isLetter() && context[1] == QLatin1Char(':'))
 364 #endif
 365           ))
 366         return abs_or_rel_name;
 367     if (abs_or_rel_name.isEmpty())
 368         return context;
 369     QFileInfo c(context);
 370     if (!c.isDir()) {
 371         QFileInfo r(c.dir(true), abs_or_rel_name);
 372         return r.absFilePath();
 373     } else {
 374         QDir d(context);
 375         QFileInfo r(d, abs_or_rel_name);
 376         return r.absFilePath();
 377     }
 378 }
 379
 380 /*!
 381     \overload
 382     A convenience function. See data(const QString& abs_name). The
 383     file name is given in \a abs_or_rel_name and the path is in \a
 384     context.
 385 */
 386 const QMimeSource* Q3MimeSourceFactory::data(const QString& abs_or_rel_name, const QString& context) const
 387 {
 388     const QMimeSource* r = data(makeAbsolute(abs_or_rel_name,context));
 389     if (!r && !d->path.isEmpty())
 390         r = data(abs_or_rel_name);
 391     return r;
 392 }
 393
 394
 395 /*!
 396     Sets \a text to be the data item associated with the absolute name
 397     \a abs_name.
 398
 399     Equivalent to setData(abs_name, new Q3TextDrag(text)).
 400 */
 401 void Q3MimeSourceFactory::setText(const QString& abs_name, const QString& text)
 402 {
 403     setData(abs_name, new Q3TextDrag(text));
 404 }
 405
 406 /*!
 407     Sets \a image to be the data item associated with the absolute
 408     name \a abs_name.
 409
 410     Equivalent to setData(abs_name, new Q3ImageDrag(image)).
 411 */
 412 void Q3MimeSourceFactory::setImage(const QString& abs_name, const QImage& image)
 413 {
 414     setData(abs_name, new Q3ImageDrag(image));
 415 }
 416
 417 /*!
 418     Sets \a pixmap to be the data item associated with the absolute
 419     name \a abs_name.
 420 */
 421 void Q3MimeSourceFactory::setPixmap(const QString& abs_name, const QPixmap& pixmap)
 422 {
 423     setData(abs_name, new Q3ImageDrag(pixmap.convertToImage()));
 424 }
 425
 426 /*!
 427   Sets \a data to be the data item associated with
 428   the absolute name \a abs_name. Note that the ownership of \a data is
 429   transferred to the factory: do not delete or access the pointer after
 430   passing it to this function.
 431
 432   Passing 0 for data removes previously stored data.
 433 */
 434 void Q3MimeSourceFactory::setData(const QString& abs_name, QMimeSource* data)
 435 {
 436     if (d->stored.contains(abs_name))
 437         delete d->stored[abs_name];
 438     d->stored.insert(abs_name,data);
 439 }
 440
 441
 442 /*!
 443     Returns the application-wide default mime source factory. This
 444     factory is used by rich text rendering classes such as
 445     QSimpleRichText, QWhatsThis and QMessageBox to resolve named
 446     references within rich text documents. It serves also as the
 447     initial factory for the more complex render widgets, QTextEdit and
 448     QTextBrowser.
 449
 450     \sa setDefaultFactory()
 451 */
 452 Q3MimeSourceFactory* Q3MimeSourceFactory::defaultFactory()
 453 {
 454     if (!defaultfactory)
 455     {
 456         defaultfactory = new Q3MimeSourceFactory();
 457         qmime_cleanup_factory.set(&defaultfactory);
 458         QTextImageHandler::externalLoader = richTextImageLoader;
 459     }
 460     return defaultfactory;
 461 }
 462
 463 /*!
 464     Sets the default \a factory, destroying any previously set mime
 465     source provider. The ownership of the factory is transferred to
 466     Qt.
 467
 468     \sa defaultFactory()
 469 */
 470 void Q3MimeSourceFactory::setDefaultFactory(Q3MimeSourceFactory* factory)
 471 {
 472     if (!defaultfactory)
 473         qmime_cleanup_factory.set(&defaultfactory);
 474     else if (defaultfactory != factory)
 475         delete defaultfactory;
 476     defaultfactory = factory;
 477 }
 478
 479 /*!
 480     Sets the defaultFactory() to 0 and returns the previous one.
 481 */
 482
 483 Q3MimeSourceFactory* Q3MimeSourceFactory::takeDefaultFactory()
 484 {
 485     Q3MimeSourceFactory *f = defaultfactory;
 486     defaultfactory = 0;
 487     return f;
 488 }
 489
 490 /*!
 491     Adds the Q3MimeSourceFactory \a f to the list of available
 492     mimesource factories. If the defaultFactory() can't resolve a
 493     data() it iterates over the list of installed mimesource factories
 494     until the data can be resolved.
 495
 496     \sa removeFactory()
 497 */
 498
 499 void Q3MimeSourceFactory::addFactory(Q3MimeSourceFactory *f)
 500 {
 501     Q3MimeSourceFactory::defaultFactory()->d->factories.append(f);
 502 }
 503
 504 /*!
 505     Removes the mimesource factory \a f from the list of available
 506     mimesource factories.
 507
 508     \sa addFactory()
 509 */
 510
 511 void Q3MimeSourceFactory::removeFactory(Q3MimeSourceFactory *f)
 512 {
 513     Q3MimeSourceFactory::defaultFactory()->d->factories.removeAll(f);
 514 }
 515
 516 QPixmap qPixmapFromMimeSource(const QString &abs_name)
 517 {
 518     const QMimeSource *m = Q3MimeSourceFactory::defaultFactory()->data(abs_name);
 519     if (!m) {
 520         if (QFile::exists(abs_name))
 521             return QPixmap(abs_name);
 522         if (!abs_name.isEmpty())
 523             qWarning("QPixmap::fromMimeSource: Cannot find pixmap \"%s\" in the mime source factory",
 524                       abs_name.latin1());
 525         return QPixmap();
 526     }
 527     QPixmap pix;
 528     Q3ImageDrag::decode(m, pix);
 529     return pix;
 530 }
 531
 532 QImage qImageFromMimeSource(const QString &abs_name)
 533 {
 534     const QMimeSource *m = Q3MimeSourceFactory::defaultFactory()->data(abs_name);
 535     if (!m) {
 536         qWarning("QImage::fromMimeSource: Cannot find image \"%s\" in the mime source factory", abs_name.latin1());
 537         return QImage();
 538     }
 539     QImage img;
 540     Q3ImageDrag::decode(m, img);
 541     return img;
 542 }
 543
 544 QT_END_NAMESPACE
 545
 546 #endif // QT_NO_MIMEFACTORY