okular/core/generator.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005   by Piotr Szymanski <niedakh@gmail.com>           *
   3  *   Copyright (C) 2008   by Albert Astals Cid <aacid@kde.org>             *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  ***************************************************************************/
  10
  11 #include "generator.h"
  12 #include "generator_p.h"
  13
  14 #include <qeventloop.h>
  15 #include <QtGui/QPrinter>
  16
  17 #include <kdebug.h>
  18 #include <kicon.h>
  19 #include <klocale.h>
  20
  21 #include "document.h"
  22 #include "document_p.h"
  23 #include "page.h"
  24 #include "textpage.h"
  25 #include "utils.h"
  26
  27 using namespace Okular;
  28
  29 GeneratorPrivate::GeneratorPrivate()
  30     : m_document( 0 ),
  31       mPixmapGenerationThread( 0 ), mTextPageGenerationThread( 0 ),
  32       m_mutex( 0 ), m_threadsMutex( 0 ), mPixmapReady( true ), mTextPageReady( true ),
  33       m_closing( false ), m_closingLoop( 0 )
  34 {
  35 }
  36
  37 GeneratorPrivate::~GeneratorPrivate()
  38 {
  39     if ( mPixmapGenerationThread )
  40         mPixmapGenerationThread->wait();
  41
  42     delete mPixmapGenerationThread;
  43
  44     if ( mTextPageGenerationThread )
  45         mTextPageGenerationThread->wait();
  46
  47     delete mTextPageGenerationThread;
  48
  49     delete m_mutex;
  50     delete m_threadsMutex;
  51 }
  52
  53 PixmapGenerationThread* GeneratorPrivate::pixmapGenerationThread()
  54 {
  55     if ( mPixmapGenerationThread )
  56         return mPixmapGenerationThread;
  57
  58     Q_Q( Generator );
  59     mPixmapGenerationThread = new PixmapGenerationThread( q );
  60     QObject::connect( mPixmapGenerationThread, SIGNAL( finished() ),
  61                       q, SLOT( pixmapGenerationFinished() ),
  62                       Qt::QueuedConnection );
  63
  64     return mPixmapGenerationThread;
  65 }
  66
  67 TextPageGenerationThread* GeneratorPrivate::textPageGenerationThread()
  68 {
  69     if ( mTextPageGenerationThread )
  70         return mTextPageGenerationThread;
  71
  72     Q_Q( Generator );
  73     mTextPageGenerationThread = new TextPageGenerationThread( q );
  74     QObject::connect( mTextPageGenerationThread, SIGNAL( finished() ),
  75                       q, SLOT( textpageGenerationFinished() ),
  76                       Qt::QueuedConnection );
  77
  78     return mTextPageGenerationThread;
  79 }
  80
  81 void GeneratorPrivate::pixmapGenerationFinished()
  82 {
  83     Q_Q( Generator );
  84     PixmapRequest *request = mPixmapGenerationThread->request();
  85     mPixmapGenerationThread->endGeneration();
  86
  87     QMutexLocker locker( threadsLock() );
  88     mPixmapReady = true;
  89
  90     if ( m_closing )
  91     {
  92         delete request;
  93         if ( mTextPageReady )
  94         {
  95             locker.unlock();
  96             m_closingLoop->quit();
  97         }
  98         return;
  99     }
 100
 101     const QImage& img = mPixmapGenerationThread->image();
 102     request->page()->setPixmap( request->id(), new QPixmap( QPixmap::fromImage( img ) ) );
 103     const int pageNumber = request->page()->number();
 104
 105     q->signalPixmapRequestDone( request );
 106     if ( mPixmapGenerationThread->calcBoundingBox() )
 107         q->updatePageBoundingBox( pageNumber, mPixmapGenerationThread->boundingBox() );
 108 }
 109
 110 void GeneratorPrivate::textpageGenerationFinished()
 111 {
 112     Q_Q( Generator );
 113     Page *page = mTextPageGenerationThread->page();
 114     mTextPageGenerationThread->endGeneration();
 115
 116     QMutexLocker locker( threadsLock() );
 117     mTextPageReady = true;
 118
 119     if ( m_closing )
 120     {
 121         delete mTextPageGenerationThread->textPage();
 122         if ( mPixmapReady )
 123         {
 124             locker.unlock();
 125             m_closingLoop->quit();
 126         }
 127         return;
 128     }
 129
 130     if ( mTextPageGenerationThread->textPage() )
 131     {
 132         TextPage *tp = mTextPageGenerationThread->textPage();
 133         page->setTextPage( tp );
 134         q->signalTextGenerationDone( page, tp );
 135     }
 136 }
 137
 138 QMutex* GeneratorPrivate::threadsLock()
 139 {
 140     if ( !m_threadsMutex )
 141         m_threadsMutex = new QMutex();
 142     return m_threadsMutex;
 143 }
 144
 145 QVariant GeneratorPrivate::metaData( const QString &, const QVariant & ) const
 146 {
 147     return QVariant();
 148 }
 149
 150 QImage GeneratorPrivate::image( PixmapRequest * )
 151 {
 152     return QImage();
 153 }
 154
 155
 156 Generator::Generator( QObject *parent, const QVariantList &args )
 157     : QObject( parent ), d_ptr( new GeneratorPrivate() )
 158 {
 159     d_ptr->q_ptr = this;
 160     Q_UNUSED( args )
 161 }
 162
 163 Generator::Generator( GeneratorPrivate &dd, QObject *parent, const QVariantList &args )
 164     : QObject( parent ), d_ptr( &dd )
 165 {
 166     d_ptr->q_ptr = this;
 167     Q_UNUSED( args )
 168 }
 169
 170 Generator::~Generator()
 171 {
 172     delete d_ptr;
 173 }
 174
 175 bool Generator::loadDocumentFromData( const QByteArray &, QVector< Page * > & )
 176 {
 177     return false;
 178 }
 179
 180 bool Generator::closeDocument()
 181 {
 182     Q_D( Generator );
 183
 184     d->m_closing = true;
 185
 186     d->threadsLock()->lock();
 187     if ( !( d->mPixmapReady && d->mTextPageReady ) )
 188     {
 189         QEventLoop loop;
 190         d->m_closingLoop = &loop;
 191
 192         d->threadsLock()->unlock();
 193
 194         loop.exec();
 195
 196         d->m_closingLoop = 0;
 197     }
 198     else
 199     {
 200         d->threadsLock()->unlock();
 201     }
 202
 203     bool ret = doCloseDocument();
 204
 205     d->m_closing = false;
 206
 207     return ret;
 208 }
 209
 210 bool Generator::canGeneratePixmap() const
 211 {
 212     Q_D( const Generator );
 213     return d->mPixmapReady;
 214 }
 215
 216 void Generator::generatePixmap( PixmapRequest *request )
 217 {
 218     Q_D( Generator );
 219     d->mPixmapReady = false;
 220
 221     if ( hasFeature( Threaded ) )
 222     {
 223         d->pixmapGenerationThread()->startGeneration( request, !request->page()->isBoundingBoxKnown() );
 224
 225         /**
 226          * We create the text page for every page that is visible to the
 227          * user, so he can use the text extraction tools without a delay.
 228          */
 229         if ( hasFeature( TextExtraction ) && !request->page()->hasTextPage() && canGenerateTextPage() ) {
 230             d->mTextPageReady = false;
 231             d->textPageGenerationThread()->startGeneration( request->page() );
 232         }
 233
 234         return;
 235     }
 236
 237     const QImage& img = image( request );
 238     request->page()->setPixmap( request->id(), new QPixmap( QPixmap::fromImage( img ) ) );
 239     const bool bboxKnown = request->page()->isBoundingBoxKnown();
 240     const int pageNumber = request->page()->number();
 241
 242     d->mPixmapReady = true;
 243
 244     signalPixmapRequestDone( request );
 245     if ( !bboxKnown )
 246         updatePageBoundingBox( pageNumber, Utils::imageBoundingBox( &img ) );
 247 }
 248
 249 bool Generator::canGenerateTextPage() const
 250 {
 251     Q_D( const Generator );
 252     return d->mTextPageReady;
 253 }
 254
 255 void Generator::generateTextPage( Page *page )
 256 {
 257     Q_D( Generator );
 258     TextPage *tp = textPage( page );
 259     page->setTextPage( tp );
 260     d->mTextPageReady = true;
 261     signalTextGenerationDone( page, tp );
 262 }
 263
 264 QImage Generator::image( PixmapRequest *request )
 265 {
 266     Q_D( Generator );
 267     return d->image( request );
 268 }
 269
 270 TextPage* Generator::textPage( Page* )
 271 {
 272     return 0;
 273 }
 274
 275 const DocumentInfo * Generator::generateDocumentInfo()
 276 {
 277     return 0;
 278 }
 279
 280 const DocumentSynopsis * Generator::generateDocumentSynopsis()
 281 {
 282     return 0;
 283 }
 284
 285 FontInfo::List Generator::fontsForPage( int )
 286 {
 287     return FontInfo::List();
 288 }
 289
 290 const QList<EmbeddedFile*> * Generator::embeddedFiles() const
 291 {
 292     return 0;
 293 }
 294
 295 Generator::PageSizeMetric Generator::pagesSizeMetric() const
 296 {
 297     return None;
 298 }
 299
 300 bool Generator::isAllowed( Permission ) const
 301 {
 302     return true;
 303 }
 304
 305 void Generator::rotationChanged( Rotation, Rotation )
 306 {
 307 }
 308
 309 PageSize::List Generator::pageSizes() const
 310 {
 311     return PageSize::List();
 312 }
 313
 314 void Generator::pageSizeChanged( const PageSize &, const PageSize & )
 315 {
 316 }
 317
 318 bool Generator::print( QPrinter& )
 319 {
 320     return false;
 321 }
 322
 323 QVariant Generator::metaData( const QString &key, const QVariant &option ) const
 324 {
 325     Q_D( const Generator );
 326     return d->metaData( key, option );
 327 }
 328
 329 ExportFormat::List Generator::exportFormats() const
 330 {
 331     return ExportFormat::List();
 332 }
 333
 334 bool Generator::exportTo( const QString&, const ExportFormat& )
 335 {
 336     return false;
 337 }
 338
 339 bool Generator::hasFeature( GeneratorFeature feature ) const
 340 {
 341     Q_D( const Generator );
 342     return d->m_features.contains( feature );
 343 }
 344
 345 void Generator::signalPixmapRequestDone( PixmapRequest * request )
 346 {
 347     Q_D( Generator );
 348     if ( d->m_document )
 349         d->m_document->requestDone( request );
 350     else
 351     {
 352         delete request;
 353     }
 354 }
 355
 356 void Generator::signalTextGenerationDone( Page *page, TextPage *textPage )
 357 {
 358     Q_D( Generator );
 359     if ( d->m_document )
 360         d->m_document->textGenerationDone( page );
 361     else
 362         delete textPage;
 363 }
 364
 365 const Document * Generator::document() const
 366 {
 367     Q_D( const Generator );
 368     if ( d->m_document )
 369     {
 370         return d->m_document->m_parent;
 371     }
 372     return 0;
 373 }
 374
 375 void Generator::setFeature( GeneratorFeature feature, bool on )
 376 {
 377     Q_D( Generator );
 378     if ( on )
 379         d->m_features.insert( feature );
 380     else
 381         d->m_features.remove( feature );
 382 }
 383
 384 QVariant Generator::documentMetaData( const QString &key, const QVariant &option ) const
 385 {
 386     Q_D( const Generator );
 387     if ( !d->m_document )
 388         return QVariant();
 389
 390     return d->m_document->documentMetaData( key, option );
 391 }
 392
 393 QMutex* Generator::userMutex() const
 394 {
 395     Q_D( const Generator );
 396     if ( !d->m_mutex )
 397     {
 398         d->m_mutex = new QMutex();
 399     }
 400     return d->m_mutex;
 401 }
 402
 403 void Generator::updatePageBoundingBox( int page, const NormalizedRect & boundingBox )
 404 {
 405     Q_D( Generator );
 406     if ( d->m_document ) // still connected to document?
 407         d->m_document->setPageBoundingBox( page, boundingBox );
 408 }
 409
 410 void Generator::requestFontData(const Okular::FontInfo & /*font*/, QByteArray * /*data*/)
 411 {
 412
 413 }
 414
 415 PixmapRequest::PixmapRequest( int id, int pageNumber, int width, int height, int priority, bool asynchronous )
 416   : d( new PixmapRequestPrivate )
 417 {
 418     d->mId = id;
 419     d->mPageNumber = pageNumber;
 420     d->mWidth = width;
 421     d->mHeight = height;
 422     d->mPriority = priority;
 423     d->mAsynchronous = asynchronous;
 424     d->mForce = false;
 425 }
 426
 427 PixmapRequest::~PixmapRequest()
 428 {
 429     delete d;
 430 }
 431
 432 int PixmapRequest::id() const
 433 {
 434     return d->mId;
 435 }
 436
 437 int PixmapRequest::pageNumber() const
 438 {
 439     return d->mPageNumber;
 440 }
 441
 442 int PixmapRequest::width() const
 443 {
 444     return d->mWidth;
 445 }
 446
 447 int PixmapRequest::height() const
 448 {
 449     return d->mHeight;
 450 }
 451
 452 int PixmapRequest::priority() const
 453 {
 454     return d->mPriority;
 455 }
 456
 457 bool PixmapRequest::asynchronous() const
 458 {
 459     return d->mAsynchronous;
 460 }
 461
 462 Page* PixmapRequest::page() const
 463 {
 464     return d->mPage;
 465 }
 466
 467 void PixmapRequestPrivate::swap()
 468 {
 469     qSwap( mWidth, mHeight );
 470 }
 471
 472 class Okular::ExportFormatPrivate : public QSharedData
 473 {
 474     public:
 475         ExportFormatPrivate( const QString &description, const KMimeType::Ptr &mimeType, const KIcon &icon = KIcon() )
 476             : QSharedData(), mDescription( description ), mMimeType( mimeType ), mIcon( icon )
 477         {
 478         }
 479         ~ExportFormatPrivate()
 480         {
 481         }
 482
 483         QString mDescription;
 484         KMimeType::Ptr mMimeType;
 485         KIcon mIcon;
 486 };
 487
 488 ExportFormat::ExportFormat()
 489     : d( new ExportFormatPrivate( QString(), KMimeType::Ptr() ) )
 490 {
 491 }
 492
 493 ExportFormat::ExportFormat( const QString &description, const KMimeType::Ptr &mimeType )
 494     : d( new ExportFormatPrivate( description, mimeType ) )
 495 {
 496 }
 497
 498 ExportFormat::ExportFormat( const KIcon &icon, const QString &description, const KMimeType::Ptr &mimeType )
 499     : d( new ExportFormatPrivate( description, mimeType, icon ) )
 500 {
 501 }
 502
 503 ExportFormat::~ExportFormat()
 504 {
 505 }
 506
 507 ExportFormat::ExportFormat( const ExportFormat &other )
 508     : d( other.d )
 509 {
 510 }
 511
 512 ExportFormat& ExportFormat::operator=( const ExportFormat &other )
 513 {
 514     if ( this == &other )
 515         return *this;
 516
 517     d = other.d;
 518
 519     return *this;
 520 }
 521
 522 QString ExportFormat::description() const
 523 {
 524     return d->mDescription;
 525 }
 526
 527 KMimeType::Ptr ExportFormat::mimeType() const
 528 {
 529     return d->mMimeType;
 530 }
 531
 532 KIcon ExportFormat::icon() const
 533 {
 534     return d->mIcon;
 535 }
 536
 537 bool ExportFormat::isNull() const
 538 {
 539     return d->mMimeType.isNull() || d->mDescription.isNull();
 540 }
 541
 542 ExportFormat ExportFormat::standardFormat( StandardExportFormat type )
 543 {
 544     switch ( type )
 545     {
 546         case PlainText:
 547             return ExportFormat( KIcon( "text-x-generic" ), i18n( "Plain &Text..." ), KMimeType::mimeType( "text/plain" ) );
 548             break;
 549         case PDF:
 550             return ExportFormat( KIcon( "application-pdf" ), i18n( "PDF" ), KMimeType::mimeType( "application/pdf" ) );
 551             break;
 552         case OpenDocumentText:
 553             return ExportFormat(
 554                 KIcon( "application-vnd.oasis.opendocument.text" ),
 555                 i18nc( "This is the document format", "OpenDocument Text" ),
 556                 KMimeType::mimeType( "application/vnd.oasis.opendocument.text" ) );
 557             break;
 558         case HTML:
 559             return ExportFormat( KIcon( "text-html" ), i18nc( "This is the document format", "HTML" ), KMimeType::mimeType( "text/html" ) );
 560             break;
 561     }
 562     return ExportFormat();
 563 }
 564
 565 bool ExportFormat::operator==( const ExportFormat &other ) const
 566 {
 567     return d == other.d;
 568 }
 569
 570 bool ExportFormat::operator!=( const ExportFormat &other ) const
 571 {
 572     return d != other.d;
 573 }
 574
 575 QDebug operator<<( QDebug str, const Okular::PixmapRequest &req )
 576 {
 577     QString s = QString( "%1 PixmapRequest (id: %2) (%3x%4), prio %5, pageNo %6" )
 578         .arg( QString( req.asynchronous() ? "Async" : "Sync" ) )
 579         .arg( req.id() )
 580         .arg( req.width() )
 581         .arg( req.height() )
 582         .arg( req.priority() )
 583         .arg( req.pageNumber() );
 584     str << qPrintable( s );
 585     return str;
 586 }
 587
 588 #include "generator.moc"