runtime/kioslave/thumbnail/thumbnail.cpp

   1 /*  This file is part of the KDE libraries
   2     Copyright (C) 2000 Malte Starostik <malte@kde.org>
   3                   2000 Carsten Pfeiffer <pfeiffer@kde.org>
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public License
  16     along with this library; see the file COPYING.LIB.  If not, write to
  17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18     Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #ifdef __FreeBSD__
  24     #include <machine/param.h>
  25 #endif
  26 #include <sys/types.h>
  27 #include <sys/ipc.h>
  28 #include <sys/shm.h>
  29
  30 #include <QtCore/QBuffer>
  31 #include <QtCore/QFile>
  32 #include <QtGui/QBitmap>
  33 #include <QtGui/QImage>
  34 #include <QtGui/QPainter>
  35 #include <QtGui/QPixmap>
  36
  37 #include <kurl.h>
  38 #include <kapplication.h>
  39 #include <kcmdlineargs.h>
  40 #include <kaboutdata.h>
  41 #include <kglobal.h>
  42 #include <kiconloader.h>
  43 #include <kmimetype.h>
  44 #include <klibloader.h>
  45 #include <kdebug.h>
  46 #include <kservice.h>
  47 #include <kservicetype.h>
  48 #include <kservicetypetrader.h>
  49 #include <kmimetypetrader.h>
  50 #include <kfilemetainfo.h>
  51 #include <klocale.h>
  52
  53 #include <config-runtime.h> // For HAVE_NICE
  54 #include "thumbnail.h"
  55 #include <kio/thumbcreator.h>
  56 #include <kconfiggroup.h>
  57
  58 // Use correctly KComponentData instead of KApplication (but then no QPixmap)
  59 #undef USE_KINSTANCE
  60 // Fix thumbnail: protocol
  61 #define THUMBNAIL_HACK (1)
  62
  63 #ifdef THUMBNAIL_HACK
  64 # include <QFileInfo>
  65 #endif
  66
  67 // Recognized metadata entries:
  68 // mimeType     - the mime type of the file, used for the overlay icon if any
  69 // width        - maximum width for the thumbnail
  70 // height       - maximum height for the thumbnail
  71 // iconSize     - the size of the overlay icon to use if any
  72 // iconAlpha    - the transparency value used for icon overlays
  73 // plugin       - the name of the plugin library to be used for thumbnail creation.
  74 //                Provided by the application to save an addition KTrader
  75 //                query here.
  76 // shmid        - the shared memory segment id to write the image's data to.
  77 //                The segment is assumed to provide enough space for a 32-bit
  78 //                image sized width x height pixels.
  79 //                If this is given, the data returned by the slave will be:
  80 //                    int width
  81 //                    int height
  82 //                    int depth
  83 //                Otherwise, the data returned is the image in PNG format.
  84
  85 using namespace KIO;
  86
  87 extern "C"
  88 {
  89     KDE_EXPORT int kdemain(int argc, char **argv);
  90 }
  91
  92
  93 int kdemain(int argc, char **argv)
  94 {
  95 #ifdef HAVE_NICE
  96     nice( 5 );
  97 #endif
  98
  99 #ifdef USE_KINSTANCE
 100     KComponentData componentData("kio_thumbnail");
 101 #else
 102     // creating KApplication in a slave in not a very good idea,
 103     // as dispatchLoop() doesn't allow it to process its messages,
 104     // so it for example wouldn't reply to ksmserver - on the other
 105     // hand, this slave uses QPixmaps for some reason, and they
 106     // need QApplication
 107     // and HTML previews need even KApplication :(
 108     putenv(strdup("SESSION_MANAGER="));
 109     //KApplication::disableAutoDcopRegistration();
 110     KAboutData about("kio_thumbnail", 0, ki18n("kio_thumbmail"), "KDE 4.x.x");
 111     KCmdLineArgs::init(&about);
 112
 113     KApplication app( true);
 114 #endif
 115
 116     if (argc != 4)
 117     {
 118         kError(7115) << "Usage: kio_thumbnail protocol domain-socket1 domain-socket2" << endl;
 119         exit(-1);
 120     }
 121
 122     ThumbnailProtocol slave(argv[2], argv[3]);
 123     slave.dispatchLoop();
 124
 125     return 0;
 126 }
 127
 128 ThumbnailProtocol::ThumbnailProtocol(const QByteArray &pool, const QByteArray &app)
 129     : SlaveBase("thumbnail", pool, app)
 130 {
 131     m_iconSize = 0;
 132 }
 133
 134 ThumbnailProtocol::~ThumbnailProtocol()
 135 {
 136   qDeleteAll( m_creators );
 137   m_creators.clear();
 138 }
 139
 140 void ThumbnailProtocol::get(const KUrl &url)
 141 {
 142     m_mimeType = metaData("mimeType");
 143     kDebug(7115) << "Wanting MIME Type:" << m_mimeType;
 144 #ifdef THUMBNAIL_HACK
 145     // ### HACK
 146     bool direct=false;
 147     if (m_mimeType.isEmpty())
 148     {
 149         kDebug(7115) << "PATH: " << url.path();
 150         QFileInfo info(url.path());
 151         if (info.isDir())
 152         {
 153             // We cannot process a directory
 154             error(KIO::ERR_IS_DIRECTORY,url.path());
 155             return;
 156         }
 157         else if (!info.exists())
 158         {
 159             // The file does not exist
 160             error(KIO::ERR_DOES_NOT_EXIST,url.path());
 161             return;
 162         }
 163         else if (!info.isReadable())
 164         {
 165             // The file is not readable!
 166             error(KIO::ERR_COULD_NOT_READ,url.path());
 167             return;
 168         }
 169         m_mimeType = KMimeType::findByUrl(url)->name();
 170         kDebug(7115) << "Guessing MIME Type:" << m_mimeType;
 171         direct=true; // thumbnail: was probably called from Konqueror
 172     }
 173 #endif
 174
 175     if (m_mimeType.isEmpty())
 176     {
 177         error(KIO::ERR_INTERNAL, i18n("No MIME Type specified."));
 178         return;
 179     }
 180
 181     m_width = metaData("width").toInt();
 182     m_height = metaData("height").toInt();
 183     int iconSize = metaData("iconSize").toInt();
 184
 185     if (m_width < 0 || m_height < 0)
 186     {
 187         error(KIO::ERR_INTERNAL, i18n("No or invalid size specified."));
 188         return;
 189     }
 190 #ifdef THUMBNAIL_HACK
 191     else if (!m_width || !m_height)
 192     {
 193         kDebug(7115) << "Guessing height, width, icon size!";
 194         m_width=128;
 195         m_height=128;
 196         iconSize=128;
 197     }
 198 #endif
 199
 200     if (!iconSize)
 201         iconSize = KIconLoader::global()->currentSize(KIconLoader::Desktop);
 202     if (iconSize != m_iconSize) {
 203         m_iconDict.clear();
 204     }
 205     m_iconSize = iconSize;
 206
 207     m_iconAlpha = metaData("iconAlpha").toInt();
 208
 209     QImage img;
 210
 211     KConfigGroup group( KGlobal::config(), "PreviewSettings" );
 212
 213
 214     // ### KFMI
 215     bool kfmiThumb = false;
 216     if (group.readEntry( "UseFileThumbnails", true)) {
 217         KService::Ptr service =
 218             KMimeTypeTrader::self()->preferredService( m_mimeType, "KFilePlugin");
 219
 220         if ( service && service->isValid() && /*url.isLocalFile() && */
 221             service->property("SupportsThumbnail").toBool())
 222         {
 223             KFileMetaInfo info(url.path(), m_mimeType, KFileMetaInfo::Thumbnail);
 224             if (info.isValid())
 225             {
 226                 KFileMetaInfoItem item = info.item("thumbnail");
 227                 if (item.isValid() && item.value().type() == QVariant::Image)
 228                 {
 229                     img = item.value().value<QImage>();
 230                     kDebug(7115) << "using KFMI for the thumbnail\n";
 231                     kfmiThumb = true;
 232                 }
 233             }
 234         }
 235     }
 236     ThumbCreator::Flags flags = ThumbCreator::None;
 237
 238     if (!kfmiThumb)
 239     {
 240         kDebug(7115) << "using thumb creator for the thumbnail\n";
 241         QString plugin = metaData("plugin");
 242 #ifdef THUMBNAIL_HACK
 243         if (plugin.isEmpty())
 244         {
 245             KService::List offers = KMimeTypeTrader::self()->query( m_mimeType, QLatin1String( "ThumbCreator" ) );
 246
 247             if(!offers.isEmpty())
 248             {
 249                 KService::Ptr serv;
 250                 serv = offers.first();
 251                 plugin = serv->library();
 252             }
 253         }
 254         kDebug(7115) << "Guess plugin: " << plugin;
 255 #endif
 256         if (plugin.isEmpty())
 257         {
 258             error(KIO::ERR_INTERNAL, i18n("No plugin specified."));
 259             return;
 260         }
 261
 262         ThumbCreator *creator = m_creators[plugin];
 263         if (!creator)
 264         {
 265             // Don't use KLibFactory here, this is not a QObject and
 266             // neither is ThumbCreator
 267             KLibrary *library = KLibLoader::self()->library(plugin);
 268             if (library)
 269             {
 270                 newCreator create = (newCreator)library->resolveFunction("new_creator");
 271                 if (create)
 272                     creator = create();
 273             }
 274             if (!creator)
 275             {
 276                 error(KIO::ERR_INTERNAL, i18n("Cannot load ThumbCreator %1", plugin));
 277                 return;
 278             }
 279             m_creators.insert(plugin, creator);
 280         }
 281
 282         if (!creator->create(url.path(), m_width, m_height, img))
 283         {
 284             error(KIO::ERR_INTERNAL, i18n("Cannot create thumbnail for %1", url.path()));
 285             return;
 286         }
 287         flags = creator->flags();
 288     }
 289
 290     if (img.width() > m_width || img.height() > m_height)
 291     {
 292         double imgRatio = (double)img.height() / (double)img.width();
 293         if (imgRatio > (double)m_height / (double)m_width)
 294             img = img.scaled( int(qMax((double)m_height / imgRatio, 1.0)), m_height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 295         else
 296             img = img.scaled(m_width, int(qMax((double)m_width * imgRatio, 1.0)), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 297     }
 298
 299 // ### FIXME
 300 #ifndef USE_KINSTANCE
 301     if (flags & ThumbCreator::DrawFrame)
 302     {
 303         QPixmap pix = QPixmap::fromImage( img );
 304         int x2 = pix.width() - 1;
 305         int y2 = pix.height() - 1;
 306         // paint a black rectangle around the "page"
 307         QPainter p;
 308         p.begin( &pix );
 309         p.setPen( QColor( 48, 48, 48 ));
 310         p.drawLine( x2, 0, x2, y2 );
 311         p.drawLine( 0, y2, x2, y2 );
 312         p.setPen( QColor( 215, 215, 215 ));
 313         p.drawLine( 0, 0, x2, 0 );
 314         p.drawLine( 0, 0, 0, y2 );
 315         p.end();
 316
 317         const QBitmap& mask = pix.mask();
 318         if ( !mask.isNull() ) // need to update it so we can see the frame
 319         {
 320             QBitmap bitmap( mask );
 321             QPainter painter;
 322             painter.begin( &bitmap );
 323             painter.drawLine( x2, 0, x2, y2 );
 324             painter.drawLine( 0, y2, x2, y2 );
 325             painter.drawLine( 0, 0, x2, 0 );
 326             painter.drawLine( 0, 0, 0, y2 );
 327             painter.end();
 328
 329             pix.setMask( bitmap );
 330         }
 331
 332         img = pix.toImage();
 333     }
 334 #endif
 335
 336     if ((flags & ThumbCreator::BlendIcon) && KIconLoader::global()->alphaBlending(KIconLoader::Desktop))
 337     {
 338         // blending the mimetype icon in
 339         QImage icon = getIcon();
 340
 341         int x = img.width() - icon.width() - 4;
 342         x = qMax( x, 0 );
 343         int y = img.height() - icon.height() - 6;
 344         y = qMax( y, 0 );
 345         QPainter p(&img);
 346         p.setOpacity(m_iconAlpha/255.0);
 347         p.drawImage(x, y, icon);
 348     }
 349
 350     if (img.isNull())
 351     {
 352         error(KIO::ERR_INTERNAL, i18n("Failed to create a thumbnail."));
 353         return;
 354     }
 355
 356     const QString shmid = metaData("shmid");
 357     if (shmid.isEmpty())
 358     {
 359 #ifdef THUMBNAIL_HACK
 360         if (direct)
 361         {
 362             // If thumbnail was called directly from Konqueror, then the image needs to be raw
 363             //kDebug(7115) << "RAW IMAGE TO STREAM";
 364             QBuffer buf;
 365             if (!buf.open(QIODevice::WriteOnly))
 366             {
 367                 error(KIO::ERR_INTERNAL, i18n("Could not write image."));
 368                 return;
 369             }
 370             img.save(&buf,"PNG");
 371             buf.close();
 372             data(buf.buffer());
 373         }
 374         else
 375 #endif
 376         {
 377             QByteArray imgData;
 378             QDataStream stream( &imgData, QIODevice::WriteOnly );
 379             //kDebug(7115) << "IMAGE TO STREAM";
 380             stream << img;
 381             data(imgData);
 382         }
 383     }
 384     else
 385     {
 386         QByteArray imgData;
 387         QDataStream stream( &imgData, QIODevice::WriteOnly );
 388         //kDebug(7115) << "IMAGE TO SHMID";
 389         void *shmaddr = shmat(shmid.toInt(), 0, 0);
 390         if (shmaddr == (void *)-1)
 391         {
 392             error(KIO::ERR_INTERNAL, i18n("Failed to attach to shared memory segment %1", shmid));
 393             return;
 394         }
 395         if (img.width() * img.height() > m_width * m_height)
 396         {
 397             error(KIO::ERR_INTERNAL, i18n("Image is too big for the shared memory segment"));
 398             shmdt((char*)shmaddr);
 399             return;
 400         }
 401         if( img.depth() != 32 ) // KIO::PreviewJob and this code below completely ignores colortable :-/,
 402             img = img.convertToFormat(QImage::Format_ARGB32); //  so make sure there is none
 403         // Keep in sync with kdelibs/kio/kio/previewjob.cpp
 404         stream << img.width() << img.height() << quint8(img.format());
 405         memcpy(shmaddr, img.bits(), img.numBytes());
 406         shmdt((char*)shmaddr);
 407         data(imgData);
 408     }
 409     finished();
 410 }
 411
 412 const QImage ThumbnailProtocol::getIcon()
 413 {
 414     if ( !m_iconDict.contains(m_mimeType) ) { // generate it
 415         QImage icon( KIconLoader::global()->loadMimeTypeIcon( KMimeType::mimeType(m_mimeType)->iconName(), KIconLoader::Desktop, m_iconSize ).toImage() );
 416         icon.setAlphaBuffer( true );
 417         m_iconDict.insert( m_mimeType, icon );
 418
 419         return icon;
 420     }
 421
 422     return m_iconDict.value( m_mimeType );
 423 }
 424