okular/core/textdocumentgenerator.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Tobias Koenig <tokoe@kde.org>                   *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  ***************************************************************************/
   9
  10 #include "textdocumentgenerator.h"
  11 #include "textdocumentgenerator_p.h"
  12
  13 #include <QtCore/QFile>
  14 #include <QtCore/QMutex>
  15 #include <QtCore/QStack>
  16 #include <QtCore/QTextStream>
  17 #include <QtCore/QVector>
  18 #include <QtGui/QFontDatabase>
  19 #include <QtGui/QImage>
  20 #include <QtGui/QPainter>
  21 #include <QtGui/QPrinter>
  22 #if QT_VERSION >= 0x040500
  23 #include <QtGui/QTextDocumentWriter>
  24 #endif
  25
  26 #include <okular/core/action.h>
  27 #include <okular/core/annotations.h>
  28 #include <okular/core/page.h>
  29 #include <okular/core/textpage.h>
  30
  31 #include "document.h"
  32
  33 using namespace Okular;
  34
  35 /**
  36  * Generic Converter Implementation
  37  */
  38 TextDocumentConverter::TextDocumentConverter()
  39     : QObject( 0 ), d_ptr( new TextDocumentConverterPrivate )
  40 {
  41 }
  42
  43 TextDocumentConverter::~TextDocumentConverter()
  44 {
  45     delete d_ptr;
  46 }
  47
  48 DocumentViewport TextDocumentConverter::calculateViewport( QTextDocument *document, const QTextBlock &block )
  49 {
  50     return Utils::calculateViewport( document, block );
  51 }
  52
  53 TextDocumentGenerator* TextDocumentConverter::generator() const
  54 {
  55     return d_ptr->mParent ? d_ptr->mParent->q_func() : 0;
  56 }
  57
  58 /**
  59  * Generic Generator Implementation
  60  */
  61 Okular::TextPage* TextDocumentGeneratorPrivate::createTextPage( int pageNumber ) const
  62 {
  63 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
  64     Q_Q( const TextDocumentGenerator );
  65 #endif
  66
  67     Okular::TextPage *textPage = new Okular::TextPage;
  68
  69     int start, end;
  70
  71 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
  72     q->userMutex()->lock();
  73 #endif
  74     Utils::calculatePositions( mDocument, pageNumber, start, end );
  75
  76     {
  77     QTextCursor cursor( mDocument );
  78     for ( int i = start; i < end - 1; ++i ) {
  79         cursor.setPosition( i );
  80         cursor.setPosition( i + 1, QTextCursor::KeepAnchor );
  81
  82         QString text = cursor.selectedText();
  83         if ( text.length() == 1 ) {
  84             QRectF rect;
  85             Utils::calculateBoundingRect( mDocument, i, i + 1, rect, pageNumber );
  86             if ( pageNumber == -1 )
  87                 text = "\n";
  88
  89             textPage->append( text, new Okular::NormalizedRect( rect.left(), rect.top(), rect.right(), rect.bottom() ) );
  90         }
  91     }
  92     }
  93 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
  94     q->userMutex()->unlock();
  95 #endif
  96
  97     return textPage;
  98 }
  99
 100 void TextDocumentGeneratorPrivate::addAction( Action *action, int cursorBegin, int cursorEnd )
 101 {
 102     if ( !action )
 103         return;
 104
 105     LinkPosition position;
 106     position.link = action;
 107     position.startPosition = cursorBegin;
 108     position.endPosition = cursorEnd;
 109
 110     mLinkPositions.append( position );
 111 }
 112
 113 void TextDocumentGeneratorPrivate::addAnnotation( Annotation *annotation, int cursorBegin, int cursorEnd )
 114 {
 115     if ( !annotation )
 116         return;
 117
 118     annotation->setFlags( annotation->flags() | Okular::Annotation::External );
 119
 120     AnnotationPosition position;
 121     position.annotation = annotation;
 122     position.startPosition = cursorBegin;
 123     position.endPosition = cursorEnd;
 124
 125     mAnnotationPositions.append( position );
 126 }
 127
 128 void TextDocumentGeneratorPrivate::addTitle( int level, const QString &title, const QTextBlock &block )
 129 {
 130     TitlePosition position;
 131     position.level = level;
 132     position.title = title;
 133     position.block = block;
 134
 135     mTitlePositions.append( position );
 136 }
 137
 138 void TextDocumentGeneratorPrivate::addMetaData( const QString &key, const QString &value, const QString &title )
 139 {
 140     mDocumentInfo.set( key, value, title );
 141 }
 142
 143 void TextDocumentGeneratorPrivate::addMetaData( DocumentInfo::Key key, const QString &value )
 144 {
 145     mDocumentInfo.set( key, value );
 146 }
 147
 148 void TextDocumentGeneratorPrivate::generateLinkInfos()
 149 {
 150     for ( int i = 0; i < mLinkPositions.count(); ++i ) {
 151         const LinkPosition &linkPosition = mLinkPositions[ i ];
 152
 153         LinkInfo info;
 154         info.link = linkPosition.link;
 155
 156         Utils::calculateBoundingRect( mDocument, linkPosition.startPosition, linkPosition.endPosition,
 157                                       info.boundingRect, info.page );
 158
 159         if ( info.page >= 0 )
 160             mLinkInfos.append( info );
 161     }
 162 }
 163
 164 void TextDocumentGeneratorPrivate::generateAnnotationInfos()
 165 {
 166     for ( int i = 0; i < mAnnotationPositions.count(); ++i ) {
 167         const AnnotationPosition &annotationPosition = mAnnotationPositions[ i ];
 168
 169         AnnotationInfo info;
 170         info.annotation = annotationPosition.annotation;
 171
 172         Utils::calculateBoundingRect( mDocument, annotationPosition.startPosition, annotationPosition.endPosition,
 173                                       info.boundingRect, info.page );
 174
 175         if ( info.page >= 0 )
 176             mAnnotationInfos.append( info );
 177     }
 178 }
 179
 180 void TextDocumentGeneratorPrivate::generateTitleInfos()
 181 {
 182     QStack<QDomNode> parentNodeStack;
 183
 184     QDomNode parentNode = mDocumentSynopsis;
 185
 186     int level = 1000;
 187     for ( int i = 0; i < mTitlePositions.count(); ++i )
 188         level = qMin( level, mTitlePositions[ i ].level );
 189
 190     for ( int i = 0; i < mTitlePositions.count(); ++i ) {
 191         const TitlePosition &position = mTitlePositions[ i ];
 192
 193         Okular::DocumentViewport viewport = Utils::calculateViewport( mDocument, position.block );
 194
 195         QDomElement item = mDocumentSynopsis.createElement( position.title );
 196         item.setAttribute( "Viewport", viewport.toString() );
 197
 198         int newLevel = position.level;
 199         if ( newLevel == level ) {
 200             parentNode.appendChild( item );
 201         } else if ( newLevel > level ) {
 202             parentNodeStack.push( parentNode );
 203             parentNode = parentNode.lastChildElement();
 204             parentNode.appendChild( item );
 205             level = newLevel;
 206         } else {
 207             for ( int i = level; i > newLevel; i-- ) {
 208                 level--;
 209                 parentNode = parentNodeStack.pop();
 210             }
 211
 212             parentNode.appendChild( item );
 213         }
 214     }
 215 }
 216
 217 TextDocumentGenerator::TextDocumentGenerator( TextDocumentConverter *converter, QObject *parent, const QVariantList &args )
 218     : Okular::Generator( *new TextDocumentGeneratorPrivate( converter ), parent, args )
 219 {
 220     converter->d_ptr->mParent = d_func();
 221
 222     setFeature( TextExtraction );
 223     setFeature( PrintNative );
 224     setFeature( PrintToFile );
 225 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
 226     if ( QFontDatabase::supportsThreadedFontRendering() )
 227         setFeature( Threaded );
 228 #endif
 229
 230     connect( converter, SIGNAL( addAction( Action*, int, int ) ),
 231              this, SLOT( addAction( Action*, int, int ) ) );
 232     connect( converter, SIGNAL( addAnnotation( Annotation*, int, int ) ),
 233              this, SLOT( addAnnotation( Annotation*, int, int ) ) );
 234     connect( converter, SIGNAL( addTitle( int, const QString&, const QTextBlock& ) ),
 235              this, SLOT( addTitle( int, const QString&, const QTextBlock& ) ) );
 236     connect( converter, SIGNAL( addMetaData( const QString&, const QString&, const QString& ) ),
 237              this, SLOT( addMetaData( const QString&, const QString&, const QString& ) ) );
 238     connect( converter, SIGNAL( addMetaData( DocumentInfo::Key, const QString& ) ),
 239              this, SLOT( addMetaData( DocumentInfo::Key, const QString& ) ) );
 240
 241     connect( converter, SIGNAL( error( const QString&, int ) ),
 242              this, SIGNAL( error( const QString&, int ) ) );
 243     connect( converter, SIGNAL( warning( const QString&, int ) ),
 244              this, SIGNAL( warning( const QString&, int ) ) );
 245     connect( converter, SIGNAL( notice( const QString&, int ) ),
 246              this, SIGNAL( notice( const QString&, int ) ) );
 247 }
 248
 249 TextDocumentGenerator::~TextDocumentGenerator()
 250 {
 251 }
 252
 253 bool TextDocumentGenerator::loadDocument( const QString & fileName, QVector<Okular::Page*> & pagesVector )
 254 {
 255     Q_D( TextDocumentGenerator );
 256     d->mDocument = d->mConverter->convert( fileName );
 257
 258     if ( !d->mDocument )
 259     {
 260         // loading failed, cleanup all the stuff eventually gathered from the converter
 261         d->mTitlePositions.clear();
 262         Q_FOREACH ( const TextDocumentGeneratorPrivate::LinkPosition &linkPos, d->mLinkPositions )
 263         {
 264             delete linkPos.link;
 265         }
 266         d->mLinkPositions.clear();
 267         Q_FOREACH ( const TextDocumentGeneratorPrivate::AnnotationPosition &annPos, d->mAnnotationPositions )
 268         {
 269             delete annPos.annotation;
 270         }
 271         d->mAnnotationPositions.clear();
 272
 273         return false;
 274     }
 275
 276     d->generateTitleInfos();
 277     d->generateLinkInfos();
 278     d->generateAnnotationInfos();
 279
 280     pagesVector.resize( d->mDocument->pageCount() );
 281
 282     const QSize size = d->mDocument->pageSize().toSize();
 283
 284     QVector< QLinkedList<Okular::ObjectRect*> > objects( d->mDocument->pageCount() );
 285     for ( int i = 0; i < d->mLinkInfos.count(); ++i ) {
 286         const TextDocumentGeneratorPrivate::LinkInfo &info = d->mLinkInfos.at( i );
 287
 288         const QRectF rect = info.boundingRect;
 289         objects[ info.page ].append( new Okular::ObjectRect( rect.left(), rect.top(), rect.right(), rect.bottom(), false,
 290                                                              Okular::ObjectRect::Action, info.link ) );
 291     }
 292
 293     QVector< QLinkedList<Okular::Annotation*> > annots( d->mDocument->pageCount() );
 294     for ( int i = 0; i < d->mAnnotationInfos.count(); ++i ) {
 295         const TextDocumentGeneratorPrivate::AnnotationInfo &info = d->mAnnotationInfos[ i ];
 296
 297         QRect rect( 0, info.page * size.height(), size.width(), size.height() );
 298         info.annotation->setBoundingRectangle( Okular::NormalizedRect( rect.left(), rect.top(), rect.right(), rect.bottom() ) );
 299         annots[ info.page ].append( info.annotation );
 300     }
 301
 302     for ( int i = 0; i < d->mDocument->pageCount(); ++i ) {
 303         Okular::Page * page = new Okular::Page( i, size.width(), size.height(), Okular::Rotation0 );
 304         pagesVector[ i ] = page;
 305
 306         if ( !objects.at( i ).isEmpty() ) {
 307             page->setObjectRects( objects.at( i ) );
 308         }
 309         QLinkedList<Okular::Annotation*>::ConstIterator annIt = annots.at( i ).begin(), annEnd = annots.at( i ).end();
 310         for ( ; annIt != annEnd; ++annIt ) {
 311             page->addAnnotation( *annIt );
 312         }
 313     }
 314
 315     return true;
 316 }
 317
 318 bool TextDocumentGenerator::doCloseDocument()
 319 {
 320     Q_D( TextDocumentGenerator );
 321     delete d->mDocument;
 322     d->mDocument = 0;
 323
 324     d->mTitlePositions.clear();
 325     d->mLinkPositions.clear();
 326     d->mLinkInfos.clear();
 327     d->mAnnotationPositions.clear();
 328     d->mAnnotationInfos.clear();
 329     // do not use clear() for the following two, otherwise they change type
 330     d->mDocumentInfo = Okular::DocumentInfo();
 331     d->mDocumentSynopsis = Okular::DocumentSynopsis();
 332
 333     return true;
 334 }
 335
 336 bool TextDocumentGenerator::canGeneratePixmap() const
 337 {
 338     return Generator::canGeneratePixmap();
 339 }
 340
 341 void TextDocumentGenerator::generatePixmap( Okular::PixmapRequest * request )
 342 {
 343     Generator::generatePixmap( request );
 344 }
 345
 346 QImage TextDocumentGeneratorPrivate::image( PixmapRequest * request )
 347 {
 348     if ( !mDocument )
 349         return QImage();
 350
 351 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
 352     Q_Q( TextDocumentGenerator );
 353 #endif
 354
 355     QImage image( request->width(), request->height(), QImage::Format_ARGB32 );
 356     image.fill( Qt::white );
 357
 358     QPainter p;
 359     p.begin( &image );
 360
 361     qreal width = request->width();
 362     qreal height = request->height();
 363
 364     const QSize size = mDocument->pageSize().toSize();
 365
 366     p.scale( width / (qreal)size.width(), height / (qreal)size.height() );
 367
 368     QRect rect;
 369     rect = QRect( 0, request->pageNumber() * size.height(), size.width(), size.height() );
 370     p.translate( QPoint( 0, request->pageNumber() * size.height() * -1 ) );
 371 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
 372     q->userMutex()->lock();
 373 #endif
 374     mDocument->drawContents( &p, rect );
 375 #ifdef OKULAR_TEXTDOCUMENT_THREADED_RENDERING
 376     q->userMutex()->unlock();
 377 #endif
 378     p.end();
 379
 380     return image;
 381 }
 382
 383 Okular::TextPage* TextDocumentGenerator::textPage( Okular::Page * page )
 384 {
 385     Q_D( TextDocumentGenerator );
 386     return d->createTextPage( page->number() );
 387 }
 388
 389 bool TextDocumentGenerator::print( QPrinter& printer )
 390 {
 391     Q_D( TextDocumentGenerator );
 392     if ( !d->mDocument )
 393         return false;
 394
 395     d->mDocument->print( &printer );
 396
 397     return true;
 398 }
 399
 400 const Okular::DocumentInfo* TextDocumentGenerator::generateDocumentInfo()
 401 {
 402     Q_D( TextDocumentGenerator );
 403     return &d->mDocumentInfo;
 404 }
 405
 406 const Okular::DocumentSynopsis* TextDocumentGenerator::generateDocumentSynopsis()
 407 {
 408     Q_D( TextDocumentGenerator );
 409     if ( !d->mDocumentSynopsis.hasChildNodes() )
 410         return 0;
 411     else
 412         return &d->mDocumentSynopsis;
 413 }
 414
 415 QVariant TextDocumentGeneratorPrivate::metaData( const QString &key, const QVariant &option ) const
 416 {
 417     Q_UNUSED( option )
 418     if ( key == "DocumentTitle" )
 419     {
 420         return mDocumentInfo.get( "title" );
 421     }
 422     return QVariant();
 423 }
 424
 425 Okular::ExportFormat::List TextDocumentGenerator::exportFormats(   ) const
 426 {
 427     static Okular::ExportFormat::List formats;
 428     if ( formats.isEmpty() ) {
 429         formats.append( Okular::ExportFormat::standardFormat( Okular::ExportFormat::PlainText ) );
 430         formats.append( Okular::ExportFormat::standardFormat( Okular::ExportFormat::PDF ) );
 431 #if QT_VERSION >= 0x040500
 432         if ( QTextDocumentWriter::supportedDocumentFormats().contains( "ODF" ) ) {
 433             formats.append( Okular::ExportFormat::standardFormat( Okular::ExportFormat::OpenDocumentText ) );
 434         }
 435         if ( QTextDocumentWriter::supportedDocumentFormats().contains( "HTML" ) ) {
 436             formats.append( Okular::ExportFormat::standardFormat( Okular::ExportFormat::HTML ) );
 437         }
 438 #endif
 439     }
 440
 441     return formats;
 442 }
 443
 444 bool TextDocumentGenerator::exportTo( const QString &fileName, const Okular::ExportFormat &format )
 445 {
 446     Q_D( TextDocumentGenerator );
 447     if ( !d->mDocument )
 448         return false;
 449
 450     if ( format.mimeType()->name() == QLatin1String( "application/pdf" ) ) {
 451         QFile file( fileName );
 452         if ( !file.open( QIODevice::WriteOnly ) )
 453             return false;
 454
 455         QPrinter printer( QPrinter::HighResolution );
 456         printer.setOutputFormat( QPrinter::PdfFormat );
 457         printer.setOutputFileName( fileName );
 458         d->mDocument->print( &printer );
 459
 460         return true;
 461     } else if ( format.mimeType()->name() == QLatin1String( "text/plain" ) ) {
 462         QFile file( fileName );
 463         if ( !file.open( QIODevice::WriteOnly ) )
 464             return false;
 465
 466         QTextStream out( &file );
 467         out << d->mDocument->toPlainText();
 468
 469         return true;
 470 #if QT_VERSION >= 0x040500
 471     } else if ( format.mimeType()->name() == QLatin1String( "application/vnd.oasis.opendocument.text" ) ) {
 472         QTextDocumentWriter odfWriter( fileName, "odf" );
 473
 474         return odfWriter.write( d->mDocument );
 475     } else if ( format.mimeType()->name() == QLatin1String( "text/html" ) ) {
 476         QTextDocumentWriter odfWriter( fileName, "html" );
 477
 478         return odfWriter.write( d->mDocument );
 479 #endif
 480     }
 481     return false;
 482 }
 483
 484 #include "textdocumentgenerator.moc"
 485