okular/generators/djvu/kdjvu.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Pino Toscano <toscano.pino@tiscali.it>          *
   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 "kdjvu.h"
  11
  12 #include <qbytearray.h>
  13 #include <qdom.h>
  14 #include <qfile.h>
  15 #include <qhash.h>
  16 #include <qlist.h>
  17 #include <qpainter.h>
  18 #include <qqueue.h>
  19 #include <qstring.h>
  20
  21 #include <kdebug.h>
  22 #include <klocale.h>
  23
  24 #include <libdjvu/ddjvuapi.h>
  25 #include <libdjvu/miniexp.h>
  26
  27 #include <stdio.h>
  28
  29 QDebug &operator<<( QDebug & s, const ddjvu_rect_t &r )
  30 {
  31     s.nospace() << "[" << r.x << "," << r.y << " - " << r.w << "x" << r.h << "]";
  32     return s.space();
  33 }
  34
  35 static void which_ddjvu_message( const ddjvu_message_t *msg )
  36 {
  37 #ifdef KDJVU_DEBUG
  38     kDebug() << "which_djvu_message(...):" << msg->m_any.tag;
  39     switch( msg->m_any.tag )
  40     {
  41         case DDJVU_ERROR:
  42             kDebug().nospace() << "ERROR: file " << msg->m_error.filename << ", line " << msg->m_error.lineno;
  43             kDebug().nospace() << "ERROR: function '" << msg->m_error.function << "'";
  44             kDebug().nospace() << "ERROR: '" << msg->m_error.message << "'";
  45             break;
  46         case DDJVU_INFO:
  47             kDebug().nospace() << "INFO: '" << msg->m_info.message << "'";
  48             break;
  49         case DDJVU_CHUNK:
  50             kDebug().nospace() << "CHUNK: '" << QByteArray( msg->m_chunk.chunkid ) << "'";
  51             break;
  52         case DDJVU_PROGRESS:
  53             kDebug().nospace() << "PROGRESS: '" << msg->m_progress.percent << "'";
  54             break;
  55         default: ;
  56     }
  57 #else
  58     Q_UNUSED( msg );
  59 #endif
  60 }
  61
  62 /**
  63  * Explore the message queue until there are message left in it.
  64  */
  65 static void handle_ddjvu_messages( ddjvu_context_t *ctx, int wait )
  66 {
  67     const ddjvu_message_t *msg;
  68     if ( wait )
  69         ddjvu_message_wait( ctx );
  70     while ( ( msg = ddjvu_message_peek( ctx ) ) )
  71     {
  72         which_ddjvu_message( msg );
  73         ddjvu_message_pop( ctx );
  74     }
  75 }
  76
  77 /**
  78  * Explore the message queue until the message \p mid is found.
  79  */
  80 static void wait_for_ddjvu_message( ddjvu_context_t *ctx, ddjvu_message_tag_t mid )
  81 {
  82     ddjvu_message_wait( ctx );
  83     const ddjvu_message_t *msg;
  84     while ( ( msg = ddjvu_message_peek( ctx ) ) && msg && ( msg->m_any.tag != mid ) )
  85     {
  86         which_ddjvu_message( msg );
  87         ddjvu_message_pop( ctx );
  88     }
  89 }
  90
  91 /**
  92  * Convert a clockwise coefficient \p r for a rotation to a counter-clockwise
  93  * and vice versa.
  94  */
  95 static int flipRotation( int r )
  96 {
  97     return ( 4 - r ) % 4;
  98 }
  99
 100 static miniexp_t find_second_in_pair( miniexp_t theexp, const char* which )
 101 {
 102     miniexp_t exp = theexp;
 103     while ( exp )
 104     {
 105         miniexp_t cur = miniexp_car( exp );
 106         if ( !miniexp_consp( cur ) || !miniexp_symbolp( miniexp_car( cur ) ) )
 107         {
 108             exp = miniexp_cdr( exp );
 109             continue;
 110         }
 111
 112         const QString id = QString::fromUtf8( miniexp_to_name( miniexp_car( cur ) ) );
 113         if ( id == QLatin1String( which ) )
 114             return miniexp_cadr( cur );
 115         exp = miniexp_cdr( exp );
 116     }
 117     return miniexp_nil;
 118 }
 119
 120 static bool find_replace_or_add_second_in_pair( miniexp_t theexp, const char* which, miniexp_t replacement )
 121 {
 122     miniexp_t exp = miniexp_cdddr( theexp );
 123     while ( exp )
 124     {
 125         miniexp_t cur = miniexp_car( exp );
 126         if ( !miniexp_consp( cur ) || !miniexp_symbolp( miniexp_car( cur ) ) )
 127         {
 128             exp = miniexp_cdr( exp );
 129             continue;
 130         }
 131
 132         const QString id = QString::fromUtf8( miniexp_to_name( miniexp_car( cur ) ) );
 133         if ( id == QLatin1String( which ) )
 134         {
 135             miniexp_t reversed = miniexp_reverse( cur );
 136             miniexp_rplaca( reversed, replacement );
 137             cur = miniexp_reverse( reversed );
 138             return true;
 139         }
 140         exp = miniexp_cdr( exp );
 141     }
 142     // TODO add the new replacement ad the end of the list
 143     return false;
 144 }
 145
 146 // ImageCacheItem
 147
 148 class ImageCacheItem
 149 {
 150     public:
 151         ImageCacheItem( int p, int w, int h, const QImage& i )
 152           : page( p ), width( w ), height( h ), img( i ) { }
 153
 154         int page;
 155         int width;
 156         int height;
 157         QImage img;
 158 };
 159
 160
 161 // KdjVu::Page
 162
 163 KDjVu::Page::Page()
 164 {
 165 }
 166
 167 KDjVu::Page::~Page()
 168 {
 169 }
 170
 171 int KDjVu::Page::width() const
 172 {
 173     return m_width;
 174 }
 175
 176 int KDjVu::Page::height() const
 177 {
 178     return m_height;
 179 }
 180
 181 int KDjVu::Page::dpi() const
 182 {
 183     return m_dpi;
 184 }
 185
 186 int KDjVu::Page::orientation() const
 187 {
 188     return m_orientation;
 189 }
 190
 191 // KDjVu::Link
 192
 193 KDjVu::Link::~Link()
 194 {
 195 }
 196
 197 KDjVu::Link::LinkArea KDjVu::Link::areaType() const
 198 {
 199     return m_area;
 200 }
 201
 202 QPoint KDjVu::Link::point() const
 203 {
 204     return m_point;
 205 }
 206
 207 QSize KDjVu::Link::size() const
 208 {
 209     return m_size;
 210 }
 211
 212 QPolygon KDjVu::Link::polygon() const
 213 {
 214     return m_poly;
 215 }
 216
 217 // KDjVu::PageLink
 218
 219 KDjVu::PageLink::PageLink()
 220 {
 221 }
 222
 223 int KDjVu::PageLink::type() const
 224 {
 225     return KDjVu::Link::PageLink;
 226 }
 227
 228 QString KDjVu::PageLink::page() const
 229 {
 230     return m_page;
 231 }
 232
 233 // KDjVu::UrlLink
 234
 235 KDjVu::UrlLink::UrlLink()
 236 {
 237 }
 238
 239 int KDjVu::UrlLink::type() const
 240 {
 241     return KDjVu::Link::UrlLink;
 242 }
 243
 244 QString KDjVu::UrlLink::url() const
 245 {
 246     return m_url;
 247 }
 248
 249 // KDjVu::Annotation
 250
 251 KDjVu::Annotation::Annotation( miniexp_t anno )
 252     : m_anno( anno )
 253 {
 254 }
 255
 256 KDjVu::Annotation::~Annotation()
 257 {
 258 }
 259
 260 QPoint KDjVu::Annotation::point() const
 261 {
 262     miniexp_t area = miniexp_nth( 3, m_anno );
 263     int a = miniexp_to_int( miniexp_nth( 1, area ) );
 264     int b = miniexp_to_int( miniexp_nth( 2, area ) );
 265     return QPoint( a, b );
 266 }
 267
 268 QString KDjVu::Annotation::comment() const
 269 {
 270     return QString::fromUtf8( miniexp_to_str( miniexp_nth( 2, m_anno ) ) );
 271 }
 272
 273 void KDjVu::Annotation::setComment( const QString &comment )
 274 {
 275     miniexp_t exp = m_anno;
 276     exp = miniexp_cdr( exp );
 277     exp = miniexp_cdr( exp );
 278     miniexp_rplaca( exp, miniexp_string( comment.toUtf8() ) );
 279 }
 280
 281 QColor KDjVu::Annotation::color() const
 282 {
 283     return QColor();
 284 }
 285
 286 void KDjVu::Annotation::setColor( const QColor & )
 287 {
 288 }
 289
 290 // KDjVu::TextAnnotation
 291
 292 KDjVu::TextAnnotation::TextAnnotation( miniexp_t anno )
 293   : Annotation( anno ), m_inlineText( true )
 294 {
 295     const int num = miniexp_length( m_anno );
 296     for ( int j = 4; j < num; ++j )
 297     {
 298         miniexp_t curelem = miniexp_nth( j, m_anno );
 299         if ( !miniexp_listp( curelem ) )
 300             continue;
 301
 302         QString id = QString::fromUtf8( miniexp_to_name( miniexp_nth( 0, curelem ) ) );
 303         if ( id == QLatin1String( "pushpin" ) )
 304             m_inlineText = false;
 305     }
 306 }
 307
 308 QSize KDjVu::TextAnnotation::size() const
 309 {
 310     miniexp_t area = miniexp_nth( 3, m_anno );
 311     int c = miniexp_to_int( miniexp_nth( 3, area ) );
 312     int d = miniexp_to_int( miniexp_nth( 4, area ) );
 313     return QSize( c, d );
 314 }
 315
 316 int KDjVu::TextAnnotation::type() const
 317 {
 318     return KDjVu::Annotation::TextAnnotation;
 319 }
 320
 321 QColor KDjVu::TextAnnotation::color() const
 322 {
 323     miniexp_t col = find_second_in_pair( m_anno, "backclr" );
 324     if ( !miniexp_symbolp( col ) )
 325         return Qt::transparent;
 326
 327     return QColor( QString::fromUtf8( miniexp_to_name( col ) ) );
 328 }
 329
 330 void KDjVu::TextAnnotation::setColor( const QColor &color )
 331 {
 332     const QByteArray col = color.name().toLatin1();
 333     find_replace_or_add_second_in_pair( m_anno, "backclr", miniexp_symbol( col ) );
 334 }
 335
 336 bool KDjVu::TextAnnotation::inlineText() const
 337 {
 338     return m_inlineText;
 339 }
 340
 341 // KDjVu::LineAnnotation
 342
 343 KDjVu::LineAnnotation::LineAnnotation( miniexp_t anno )
 344   : Annotation( anno ), m_isArrow( false ), m_width( miniexp_nil )
 345 {
 346     const int num = miniexp_length( m_anno );
 347     for ( int j = 4; j < num; ++j )
 348     {
 349         miniexp_t curelem = miniexp_nth( j, m_anno );
 350         if ( !miniexp_listp( curelem ) )
 351             continue;
 352
 353         QString id = QString::fromUtf8( miniexp_to_name( miniexp_nth( 0, curelem ) ) );
 354         if ( id == QLatin1String( "arrow" ) )
 355             m_isArrow = true;
 356         else if ( id == QLatin1String( "width" ) )
 357             m_width = curelem;
 358     }
 359 }
 360
 361 int KDjVu::LineAnnotation::type() const
 362 {
 363     return KDjVu::Annotation::LineAnnotation;
 364 }
 365
 366 QColor KDjVu::LineAnnotation::color() const
 367 {
 368     miniexp_t col = find_second_in_pair( m_anno, "lineclr" );
 369     if ( !miniexp_symbolp( col ) )
 370         return Qt::black;
 371
 372     return QColor( QString::fromUtf8( miniexp_to_name( col ) ) );
 373 }
 374
 375 void KDjVu::LineAnnotation::setColor( const QColor &color )
 376 {
 377     const QByteArray col = color.name().toLatin1();
 378     find_replace_or_add_second_in_pair( m_anno, "lineclr", miniexp_symbol( col ) );
 379 }
 380
 381 QPoint KDjVu::LineAnnotation::point2() const
 382 {
 383     miniexp_t area = miniexp_nth( 3, m_anno );
 384     int c = miniexp_to_int( miniexp_nth( 3, area ) );
 385     int d = miniexp_to_int( miniexp_nth( 4, area ) );
 386     return QPoint( c, d );
 387 }
 388
 389 bool KDjVu::LineAnnotation::isArrow() const
 390 {
 391     return m_isArrow;
 392 }
 393
 394 int KDjVu::LineAnnotation::width() const
 395 {
 396     if ( m_width == miniexp_nil )
 397         return 1;
 398
 399     return miniexp_to_int( miniexp_cadr( m_width ) );
 400 }
 401
 402 void KDjVu::LineAnnotation::setWidth( int width )
 403 {
 404     find_replace_or_add_second_in_pair( m_anno, "width", miniexp_number( width ) );
 405 }
 406
 407 // KDjVu::TextEntity
 408
 409 KDjVu::TextEntity::TextEntity()
 410 {
 411 }
 412
 413 KDjVu::TextEntity::~TextEntity()
 414 {
 415 }
 416
 417 QString KDjVu::TextEntity::text() const
 418 {
 419     return m_text;
 420 }
 421
 422 QRect KDjVu::TextEntity::rect() const
 423 {
 424     return m_rect;
 425 }
 426
 427
 428 class KDjVu::Private
 429 {
 430     public:
 431         Private()
 432           : m_djvu_cxt( 0 ), m_djvu_document( 0 ), m_format( 0 ), m_docBookmarks( 0 ),
 433             m_cacheEnabled( true )
 434         {
 435         }
 436
 437         QImage generateImageTile( ddjvu_page_t *djvupage, int& res,
 438             int width, int row, int xdelta, int height, int col, int ydelta );
 439
 440         void readBookmarks();
 441         void fillBookmarksRecurse( QDomDocument& maindoc, QDomNode& curnode,
 442             miniexp_t exp, int offset = -1 );
 443
 444         void readMetaData( int page );
 445
 446         int pageWithName( const QString & name );
 447
 448         ddjvu_context_t *m_djvu_cxt;
 449         ddjvu_document_t *m_djvu_document;
 450         ddjvu_format_t *m_format;
 451
 452         QVector<KDjVu::Page*> m_pages;
 453         QVector<ddjvu_page_t *> m_pages_cache;
 454
 455         QList<ImageCacheItem*> mImgCache;
 456
 457         QHash<QString, QVariant> m_metaData;
 458         QDomDocument * m_docBookmarks;
 459
 460         QHash<QString, int> m_pageNamesCache;
 461
 462         bool m_cacheEnabled;
 463
 464         static unsigned int s_formatmask[4];
 465 };
 466
 467 unsigned int KDjVu::Private::s_formatmask[4] = { 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };
 468
 469 QImage KDjVu::Private::generateImageTile( ddjvu_page_t *djvupage, int& res,
 470     int width, int row, int xdelta, int height, int col, int ydelta )
 471 {
 472     ddjvu_rect_t renderrect;
 473     renderrect.x = row * xdelta;
 474     renderrect.y = col * ydelta;
 475     int realwidth = qMin( width - renderrect.x, xdelta );
 476     int realheight = qMin( height - renderrect.y, ydelta );
 477     renderrect.w = realwidth;
 478     renderrect.h = realheight;
 479 #ifdef KDJVU_DEBUG
 480     kDebug() << "renderrect:" << renderrect;
 481 #endif
 482     ddjvu_rect_t pagerect;
 483     pagerect.x = 0;
 484     pagerect.y = 0;
 485     pagerect.w = width;
 486     pagerect.h = height;
 487 #ifdef KDJVU_DEBUG
 488     kDebug() << "pagerect:" << pagerect;
 489 #endif
 490     handle_ddjvu_messages( m_djvu_cxt, false );
 491     QImage res_img( realwidth, realheight, QImage::Format_RGB32 );
 492     // the following line workarounds a rare crash in djvulibre;
 493     // it should be fixed with >= 3.5.21
 494     ddjvu_page_get_width( djvupage );
 495     res = ddjvu_page_render( djvupage, DDJVU_RENDER_COLOR,
 496                   &pagerect, &renderrect, m_format, res_img.bytesPerLine(), (char *)res_img.bits() );
 497 #ifdef KDJVU_DEBUG
 498     kDebug() << "rendering result:" << res;
 499 #endif
 500     handle_ddjvu_messages( m_djvu_cxt, false );
 501
 502     return res_img;
 503 }
 504
 505 void KDjVu::Private::readBookmarks()
 506 {
 507     if ( !m_djvu_document )
 508         return;
 509
 510     miniexp_t outline;
 511     while ( ( outline = ddjvu_document_get_outline( m_djvu_document ) ) == miniexp_dummy )
 512         handle_ddjvu_messages( m_djvu_cxt, true );
 513
 514     if ( miniexp_listp( outline ) &&
 515          ( miniexp_length( outline ) > 0 ) &&
 516          miniexp_symbolp( miniexp_nth( 0, outline ) ) &&
 517          ( QString::fromUtf8( miniexp_to_name( miniexp_nth( 0, outline ) ) ) == QLatin1String( "bookmarks" ) ) )
 518     {
 519         m_docBookmarks = new QDomDocument( "KDjVuBookmarks" );
 520         fillBookmarksRecurse( *m_docBookmarks, *m_docBookmarks, outline, 1 );
 521         ddjvu_miniexp_release( m_djvu_document, outline );
 522     }
 523 }
 524
 525 void KDjVu::Private::fillBookmarksRecurse( QDomDocument& maindoc, QDomNode& curnode,
 526     miniexp_t exp, int offset )
 527 {
 528     if ( !miniexp_listp( exp ) )
 529         return;
 530
 531     int l = miniexp_length( exp );
 532     for ( int i = qMax( offset, 0 ); i < l; ++i )
 533     {
 534         miniexp_t cur = miniexp_nth( i, exp );
 535
 536         if ( miniexp_consp( cur ) && ( miniexp_length( cur ) > 0 ) &&
 537              miniexp_stringp( miniexp_nth( 0, cur ) ) && miniexp_stringp( miniexp_nth( 1, cur ) ) )
 538         {
 539             QString title = QString::fromUtf8( miniexp_to_str( miniexp_nth( 0, cur ) ) );
 540             QString dest = QString::fromUtf8( miniexp_to_str( miniexp_nth( 1, cur ) ) );
 541             QDomElement el = maindoc.createElement( "item" );
 542             el.setAttribute( "title", title );
 543             if ( !dest.isEmpty() )
 544             {
 545                 if ( dest.at( 0 ) == QLatin1Char( '#' ) )
 546                 {
 547                     dest.remove( 0, 1 );
 548                     bool isNumber = false;
 549                     dest.toInt( &isNumber );
 550                     if ( isNumber )
 551                     {
 552                        el.setAttribute( "PageNumber", dest );
 553                     }
 554                     else
 555                     {
 556                        el.setAttribute( "PageName", dest );
 557                     }
 558                 }
 559                 else
 560                 {
 561                     el.setAttribute( "URL", dest );
 562                 }
 563             }
 564             curnode.appendChild( el );
 565             if ( !el.isNull() && ( miniexp_length( cur ) > 2 ) )
 566             {
 567                 fillBookmarksRecurse( maindoc, el, cur, 2 );
 568             }
 569         }
 570     }
 571 }
 572
 573 void KDjVu::Private::readMetaData( int page )
 574 {
 575     if ( !m_djvu_document )
 576         return;
 577
 578     miniexp_t annots;
 579     while ( ( annots = ddjvu_document_get_pageanno( m_djvu_document, page ) ) == miniexp_dummy )
 580         handle_ddjvu_messages( m_djvu_cxt, true );
 581
 582     if ( !miniexp_listp( annots ) || miniexp_length( annots ) == 0 )
 583         return;
 584
 585     miniexp_t exp = miniexp_nth( 0, annots );
 586     int size = miniexp_length( exp );
 587     if ( size <= 1 ||
 588          qstrncmp( miniexp_to_name( miniexp_nth( 0, exp ) ), "metadata", 8 ) )
 589         return;
 590
 591     for ( int i = 1; i < size; ++i )
 592     {
 593         miniexp_t cur = miniexp_nth( i, exp );
 594         if ( miniexp_length( cur ) != 2 )
 595             continue;
 596
 597         QString id = QString::fromUtf8( miniexp_to_name( miniexp_nth( 0, cur ) ) );
 598         QString value = QString::fromUtf8( miniexp_to_str( miniexp_nth( 1, cur ) ) );
 599         m_metaData[ id.toLower() ] = value;
 600     }
 601 }
 602
 603 int KDjVu::Private::pageWithName( const QString & name )
 604 {
 605     const QByteArray utfName = name.toUtf8();
 606     const int fileNum = ddjvu_document_get_filenum( m_djvu_document );
 607     ddjvu_fileinfo_t info;
 608     for ( int i = 0; i < fileNum; ++i )
 609     {
 610         if ( DDJVU_JOB_OK != ddjvu_document_get_fileinfo( m_djvu_document, i, &info ) )
 611             continue;
 612         if ( info.type != 'P' )
 613             continue;
 614         if ( ( utfName == info.id ) || ( utfName == info.name ) || ( utfName == info.title ) )
 615             return info.pageno;
 616     }
 617     return -1;
 618 }
 619
 620
 621 KDjVu::KDjVu() : d( new Private )
 622 {
 623     // creating the djvu context
 624     d->m_djvu_cxt = ddjvu_context_create( "KDjVu" );
 625     // creating the rendering format
 626 #if DDJVUAPI_VERSION >= 18
 627     d->m_format = ddjvu_format_create( DDJVU_FORMAT_RGBMASK32, 4, Private::s_formatmask );
 628 #else
 629     d->m_format = ddjvu_format_create( DDJVU_FORMAT_RGBMASK32, 3, Private::s_formatmask );
 630 #endif
 631     ddjvu_format_set_row_order( d->m_format, 1 );
 632     ddjvu_format_set_y_direction( d->m_format, 1 );
 633 }
 634
 635
 636 KDjVu::~KDjVu()
 637 {
 638     closeFile();
 639
 640     ddjvu_format_release( d->m_format );
 641     ddjvu_context_release( d->m_djvu_cxt );
 642
 643     delete d;
 644 }
 645
 646 bool KDjVu::openFile( const QString & fileName )
 647 {
 648     // first, close the old file
 649     if ( d->m_djvu_document )
 650         closeFile();
 651
 652     // load the document...
 653     d->m_djvu_document = ddjvu_document_create_by_filename( d->m_djvu_cxt, QFile::encodeName( fileName ), true );
 654     if ( !d->m_djvu_document ) return false;
 655     // ...and wait for its loading
 656     wait_for_ddjvu_message( d->m_djvu_cxt, DDJVU_DOCINFO );
 657
 658     kDebug() << "# of pages:" << ddjvu_document_get_pagenum( d->m_djvu_document );
 659     int numofpages = ddjvu_document_get_pagenum( d->m_djvu_document );
 660     d->m_pages.clear();
 661     d->m_pages.resize( numofpages );
 662     d->m_pages_cache.clear();
 663     d->m_pages_cache.resize( numofpages );
 664
 665     // get the document type
 666     QString doctype;
 667     switch ( ddjvu_document_get_type( d->m_djvu_document ) )
 668     {
 669         case DDJVU_DOCTYPE_UNKNOWN:
 670             doctype = i18nc( "Type of DjVu document", "Unknown" );
 671             break;
 672         case DDJVU_DOCTYPE_SINGLEPAGE:
 673             doctype = i18nc( "Type of DjVu document", "Single Page" );
 674             break;
 675         case DDJVU_DOCTYPE_BUNDLED:
 676             doctype = i18nc( "Type of DjVu document", "Bundled" );
 677             break;
 678         case DDJVU_DOCTYPE_INDIRECT:
 679             doctype = i18nc( "Type of DjVu document", "Indirect" );
 680             break;
 681         case DDJVU_DOCTYPE_OLD_BUNDLED:
 682             doctype = i18nc( "Type of DjVu document", "Bundled (old)" );
 683             break;
 684         case DDJVU_DOCTYPE_OLD_INDEXED:
 685             doctype = i18nc( "Type of DjVu document", "Indexed (old)" );
 686             break;
 687     }
 688     if ( !doctype.isEmpty() )
 689         d->m_metaData[ "documentType" ] = doctype;
 690     // get the number of components
 691     d->m_metaData[ "componentFile" ] = ddjvu_document_get_filenum( d->m_djvu_document );
 692
 693     // read the pages
 694     for ( int i = 0; i < numofpages; ++i )
 695     {
 696         ddjvu_status_t sts;
 697         ddjvu_pageinfo_t info;
 698         while ( ( sts = ddjvu_document_get_pageinfo( d->m_djvu_document, i, &info ) ) < DDJVU_JOB_OK )
 699             handle_ddjvu_messages( d->m_djvu_cxt, true );
 700         if ( sts >= DDJVU_JOB_FAILED )
 701         {
 702             kDebug().nospace() << "\t>>> page " << i << " failed: " << sts;
 703             return false;
 704         }
 705
 706         KDjVu::Page *p = new KDjVu::Page();
 707         p->m_width = info.width;
 708         p->m_height = info.height;
 709         p->m_dpi = info.dpi;
 710 #if DDJVUAPI_VERSION >= 18
 711         p->m_orientation = flipRotation( info.rotation );
 712 #else
 713         p->m_orientation = 0;
 714 #endif
 715         d->m_pages[i] = p;
 716     }
 717
 718     // reading the metadata from the first page only should be enough
 719     if ( numofpages > 0 )
 720         d->readMetaData( 0 );
 721
 722     return true;
 723 }
 724
 725 void KDjVu::closeFile()
 726 {
 727     // deleting the old TOC
 728     delete d->m_docBookmarks;
 729     d->m_docBookmarks = 0;
 730     // deleting the pages
 731     qDeleteAll( d->m_pages );
 732     d->m_pages.clear();
 733     // releasing the djvu pages
 734     QVector<ddjvu_page_t *>::Iterator it = d->m_pages_cache.begin(), itEnd = d->m_pages_cache.end();
 735     for ( ; it != itEnd; ++it )
 736         ddjvu_page_release( *it );
 737     d->m_pages_cache.clear();
 738     // clearing the image cache
 739     qDeleteAll( d->mImgCache );
 740     d->mImgCache.clear();
 741     // clearing the old metadata
 742     d->m_metaData.clear();
 743     // cleaing the page names mapping
 744     d->m_pageNamesCache.clear();
 745     // releasing the old document
 746     if ( d->m_djvu_document )
 747         ddjvu_document_release( d->m_djvu_document );
 748     d->m_djvu_document = 0;
 749 }
 750
 751 QVariant KDjVu::metaData( const QString & key ) const
 752 {
 753     QHash<QString, QVariant>::ConstIterator it = d->m_metaData.constFind( key );
 754     return it != d->m_metaData.constEnd() ? it.value() : QVariant();
 755 }
 756
 757 const QDomDocument * KDjVu::documentBookmarks() const
 758 {
 759     if ( !d->m_docBookmarks )
 760         d->readBookmarks();
 761     return d->m_docBookmarks;
 762 }
 763
 764 void KDjVu::linksAndAnnotationsForPage( int pageNum, QList<KDjVu::Link*> *links, QList<KDjVu::Annotation*> *annotations ) const
 765 {
 766     if ( ( pageNum < 0 ) || ( pageNum >= d->m_pages.count() ) || ( !links && !annotations ) )
 767         return;
 768
 769     miniexp_t annots;
 770     while ( ( annots = ddjvu_document_get_pageanno( d->m_djvu_document, pageNum ) ) == miniexp_dummy )
 771         handle_ddjvu_messages( d->m_djvu_cxt, true );
 772
 773     if ( !miniexp_listp( annots ) )
 774         return;
 775
 776     if ( links )
 777         links->clear();
 778     if ( annotations )
 779         annotations->clear();
 780
 781     int l = miniexp_length( annots );
 782     for ( int i = 0; i < l; ++i )
 783     {
 784         miniexp_t cur = miniexp_nth( i, annots );
 785         int num = miniexp_length( cur );
 786         if ( ( num < 4 ) || !miniexp_symbolp( miniexp_nth( 0, cur ) ) ||
 787              ( qstrncmp( miniexp_to_name( miniexp_nth( 0, cur ) ), "maparea", 7 ) != 0 ) )
 788             continue;
 789
 790         QString target;
 791         QString type;
 792         if ( miniexp_symbolp( miniexp_nth( 0, miniexp_nth( 3, cur ) ) ) )
 793             type = QString::fromUtf8( miniexp_to_name( miniexp_nth( 0, miniexp_nth( 3, cur ) ) ) );
 794         KDjVu::Link* link = 0;
 795         KDjVu::Annotation* ann = 0;
 796         miniexp_t urlexp = miniexp_nth( 1, cur );
 797         if ( links &&
 798              ( type == QLatin1String( "rect" ) ||
 799                type == QLatin1String( "oval" ) ||
 800                type == QLatin1String( "poly" ) ) )
 801         {
 802             if ( miniexp_stringp( urlexp ) )
 803             {
 804                 target = QString::fromUtf8( miniexp_to_str( miniexp_nth( 1, cur ) ) );
 805             }
 806             else if ( miniexp_listp( urlexp ) && ( miniexp_length( urlexp ) == 3 ) &&
 807                       miniexp_symbolp( miniexp_nth( 0, urlexp ) ) &&
 808                       ( qstrncmp( miniexp_to_name( miniexp_nth( 0, urlexp ) ), "url", 3 ) == 0 ) )
 809             {
 810                 target = QString::fromUtf8( miniexp_to_str( miniexp_nth( 1, urlexp ) ) );
 811             }
 812             if ( target.isEmpty() || ( ( target.length() > 0 ) && target.at(0) == QLatin1Char( '#' ) ) )
 813             {
 814                 KDjVu::PageLink* plink = new KDjVu::PageLink();
 815                 plink->m_page = target;
 816                 link = plink;
 817             }
 818             else
 819             {
 820                 KDjVu::UrlLink* ulink = new KDjVu::UrlLink();
 821                 ulink->m_url = target;
 822                 link = ulink;
 823             }
 824         }
 825         else if ( annotations &&
 826                   ( type == QLatin1String( "text" ) ||
 827                     type == QLatin1String( "line" ) ) )
 828         {
 829             if ( type == QLatin1String( "text" ) )
 830             {
 831                 KDjVu::TextAnnotation * textann = new KDjVu::TextAnnotation( cur );
 832                 ann = textann;
 833             }
 834             else if ( type == QLatin1String( "line" ) )
 835             {
 836                 KDjVu::LineAnnotation * lineann = new KDjVu::LineAnnotation( cur );
 837                 ann = lineann;
 838             }
 839         }
 840         if ( link /* safety check */ && links )
 841         {
 842             link->m_area = KDjVu::Link::UnknownArea;
 843             miniexp_t area = miniexp_nth( 3, cur );
 844             int arealength = miniexp_length( area );
 845             if ( ( arealength == 5 ) && ( type == QLatin1String( "rect" ) || type == QLatin1String( "oval" ) ) )
 846             {
 847                 link->m_point = QPoint( miniexp_to_int( miniexp_nth( 1, area ) ), miniexp_to_int( miniexp_nth( 2, area ) ) );
 848                 link->m_size = QSize( miniexp_to_int( miniexp_nth( 3, area ) ), miniexp_to_int( miniexp_nth( 4, area ) ) );
 849                 if ( type == QLatin1String( "rect" ) )
 850                 {
 851                     link->m_area = KDjVu::Link::RectArea;
 852                 }
 853                 else
 854                 {
 855                     link->m_area = KDjVu::Link::EllipseArea;
 856                 }
 857             }
 858             else if ( ( arealength > 0 ) && ( arealength % 2 == 1 ) &&
 859                       type == QLatin1String( "poly" ) )
 860             {
 861                 link->m_area = KDjVu::Link::PolygonArea;
 862                 QPolygon poly;
 863                 for ( int j = 1; j < arealength; j += 2 )
 864                 {
 865                     poly << QPoint( miniexp_to_int( miniexp_nth( j, area ) ), miniexp_to_int( miniexp_nth( j + 1, area ) ) );
 866                 }
 867                 link->m_poly = poly;
 868             }
 869
 870             if ( link->m_area != KDjVu::Link::UnknownArea )
 871                 links->append( link );
 872         }
 873         else if ( ann /* safety check */ && annotations )
 874         {
 875             annotations->append( ann );
 876         }
 877     }
 878 }
 879
 880 const QVector<KDjVu::Page*> &KDjVu::pages() const
 881 {
 882     return d->m_pages;
 883 }
 884
 885 QImage KDjVu::image( int page, int width, int height, int rotation )
 886 {
 887     if ( d->m_cacheEnabled )
 888     {
 889     bool found = false;
 890     QList<ImageCacheItem*>::Iterator it = d->mImgCache.begin(), itEnd = d->mImgCache.end();
 891     for ( ; ( it != itEnd ) && !found; ++it )
 892     {
 893         ImageCacheItem* cur = *it;
 894         if ( ( cur->page == page ) &&
 895              ( rotation % 2 == 0
 896                ? cur->width == width && cur->height == height
 897                : cur->width == height && cur->height == width ) )
 898             found = true;
 899     }
 900     if ( found )
 901     {
 902         // taking the element and pushing to the top of the list
 903         --it;
 904         ImageCacheItem* cur2 = *it;
 905         d->mImgCache.erase( it );
 906         d->mImgCache.push_front( cur2 );
 907
 908         return cur2->img;
 909     }
 910     }
 911
 912     if ( !d->m_pages_cache.at( page ) )
 913     {
 914         ddjvu_page_t *newpage = ddjvu_page_create_by_pageno( d->m_djvu_document, page );
 915         // wait for the new page to be loaded
 916         ddjvu_status_t sts;
 917         while ( ( sts = ddjvu_page_decoding_status( newpage ) ) < DDJVU_JOB_OK )
 918             handle_ddjvu_messages( d->m_djvu_cxt, true );
 919         d->m_pages_cache[page] = newpage;
 920     }
 921     ddjvu_page_t *djvupage = d->m_pages_cache[page];
 922
 923 /*
 924     if ( ddjvu_page_get_rotation( djvupage ) != flipRotation( rotation ) )
 925     {
 926 // TODO: test documents with initial rotation != 0
 927 //        ddjvu_page_set_rotation( djvupage, m_pages.at( page )->orientation() );
 928         ddjvu_page_set_rotation( djvupage, (ddjvu_page_rotation_t)flipRotation( rotation ) );
 929     }
 930 */
 931
 932     static const int xdelta = 1500;
 933     static const int ydelta = 1500;
 934
 935     int xparts = width / xdelta + 1;
 936     int yparts = height / ydelta + 1;
 937
 938     QImage newimg;
 939
 940     int res = 10000;
 941     if ( ( xparts == 1 ) && ( yparts == 1 ) )
 942     {
 943          // only one part -- render at once with no need to auxiliary image
 944          newimg = d->generateImageTile( djvupage, res,
 945                  width, 0, xdelta, height, 0, ydelta );
 946     }
 947     else
 948     {
 949         // more than one part -- need to render piece-by-piece and to compose
 950         // the results
 951         newimg = QImage( width, height, QImage::Format_RGB32 );
 952         QPainter p;
 953         p.begin( &newimg );
 954         int parts = xparts * yparts;
 955         for ( int i = 0; i < parts; ++i )
 956         {
 957             int row = i % xparts;
 958             int col = i / xparts;
 959             int tmpres = 0;
 960             QImage tempp = d->generateImageTile( djvupage, tmpres,
 961                     width, row, xdelta, height, col, ydelta );
 962             if ( tmpres )
 963             {
 964                 p.drawImage( row * xdelta, col * ydelta, tempp );
 965             }
 966             res = qMin( tmpres, res );
 967         }
 968         p.end();
 969     }
 970
 971     if ( res && d->m_cacheEnabled )
 972     {
 973         // delete all the cached pixmaps for the current page with a size that
 974         // differs no more than 35% of the new pixmap size
 975         int imgsize = newimg.width() * newimg.height();
 976         if ( imgsize > 0 )
 977         {
 978             for( int i = 0; i < d->mImgCache.count(); )
 979             {
 980                 ImageCacheItem* cur = d->mImgCache.at(i);
 981                 if ( ( cur->page == page ) &&
 982                      ( abs( cur->img.width() * cur->img.height() - imgsize ) < imgsize * 0.35 ) )
 983                 {
 984                     d->mImgCache.removeAt( i );
 985                     delete cur;
 986                 }
 987                 else
 988                     ++i;
 989             }
 990         }
 991
 992         // the image cache has too many elements, remove the last
 993         if ( d->mImgCache.size() >= 10 )
 994         {
 995             delete d->mImgCache.last();
 996             d->mImgCache.removeLast();
 997         }
 998         ImageCacheItem* ich = new ImageCacheItem( page, width, height, newimg );
 999         d->mImgCache.push_front( ich );
1000     }
1001
1002     return newimg;
1003 }
1004
1005 bool KDjVu::exportAsPostScript( const QString & fileName, const QList<int>& pageList ) const
1006 {
1007     if ( !d->m_djvu_document || fileName.trimmed().isEmpty() || pageList.isEmpty() )
1008         return false;
1009
1010     QFile f( fileName );
1011     f.open( QIODevice::ReadWrite );
1012     bool ret = exportAsPostScript( &f, pageList );
1013     if ( ret )
1014     {
1015         f.close();
1016     }
1017     return ret;
1018 }
1019
1020 bool KDjVu::exportAsPostScript( QFile* file, const QList<int>& pageList ) const
1021 {
1022     if ( !d->m_djvu_document || !file || pageList.isEmpty() )
1023         return false;
1024
1025     FILE* f = fdopen( file->handle(), "w+" );
1026     if ( !f )
1027     {
1028         kDebug() << "error while getting the FILE*";
1029         return false;
1030     }
1031
1032     QString pl;
1033     foreach ( int p, pageList )
1034     {
1035         if ( !pl.isEmpty() )
1036             pl += QString::fromLatin1( "," );
1037         pl += QString::number( p );
1038     }
1039     pl.prepend( "-page=" );
1040
1041     // setting the options
1042     static const int optc = 1;
1043     const char ** optv = (const char**)malloc( 1 * sizeof( char* ) );
1044     QByteArray plb = pl.toAscii();
1045     optv[0] = plb.constData();
1046
1047     ddjvu_job_t *printjob = ddjvu_document_print( d->m_djvu_document, f, optc, optv );
1048     while ( !ddjvu_job_done( printjob ) )
1049        handle_ddjvu_messages( d->m_djvu_cxt, true );
1050
1051     free( optv );
1052
1053     return fclose( f ) == 0;
1054 }
1055
1056 QList<KDjVu::TextEntity> KDjVu::textEntities( int page, const QString & granularity ) const
1057 {
1058     if ( ( page < 0 ) || ( page >= d->m_pages.count() ) )
1059         return QList<KDjVu::TextEntity>();
1060
1061     miniexp_t r;
1062     while ( ( r = ddjvu_document_get_pagetext( d->m_djvu_document, page, 0 ) ) == miniexp_dummy )
1063         handle_ddjvu_messages( d->m_djvu_cxt, true );
1064
1065     if ( r == miniexp_nil )
1066         return QList<KDjVu::TextEntity>();
1067
1068     QList<KDjVu::TextEntity> ret;
1069
1070     int height = d->m_pages.at( page )->height();
1071
1072     QQueue<miniexp_t> queue;
1073     queue.enqueue( r );
1074
1075     while ( !queue.isEmpty() )
1076     {
1077         miniexp_t cur = queue.dequeue();
1078
1079         if ( miniexp_listp( cur )
1080              && ( miniexp_length( cur ) > 0 )
1081              && miniexp_symbolp( miniexp_nth( 0, cur ) ) )
1082         {
1083             int size = miniexp_length( cur );
1084             QString sym = QString::fromUtf8( miniexp_to_name( miniexp_nth( 0, cur ) ) );
1085             if ( sym == granularity )
1086             {
1087                 if ( size >= 6 )
1088                 {
1089                     int xmin = miniexp_to_int( miniexp_nth( 1, cur ) );
1090                     int ymin = miniexp_to_int( miniexp_nth( 2, cur ) );
1091                     int xmax = miniexp_to_int( miniexp_nth( 3, cur ) );
1092                     int ymax = miniexp_to_int( miniexp_nth( 4, cur ) );
1093                     QRect rect( xmin, height - ymax, xmax - xmin, ymax - ymin );
1094                     KDjVu::TextEntity entity;
1095                     entity.m_rect = rect;
1096                     entity.m_text = QString::fromUtf8( miniexp_to_str( miniexp_nth( 5, cur ) ) );
1097                     ret.append( entity );
1098                 }
1099             }
1100             else
1101             {
1102                 for ( int i = 5; i < size; ++i )
1103                     queue.enqueue( miniexp_nth( i, cur ) );
1104             }
1105         }
1106     }
1107
1108     return ret;
1109 }
1110
1111 void KDjVu::setCacheEnabled( bool enable )
1112 {
1113     if ( enable == d->m_cacheEnabled )
1114         return;
1115
1116     d->m_cacheEnabled = enable;
1117     if ( !d->m_cacheEnabled )
1118     {
1119         qDeleteAll( d->mImgCache );
1120         d->mImgCache.clear();
1121     }
1122 }
1123
1124 bool KDjVu::isCacheEnabled() const
1125 {
1126     return d->m_cacheEnabled;
1127 }
1128
1129 int KDjVu::pageNumber( const QString & name ) const
1130 {
1131     if ( !d->m_djvu_document )
1132         return -1;
1133
1134     QHash< QString, int >::iterator it = d->m_pageNamesCache.find( name );
1135     if ( it == d->m_pageNamesCache.end() )
1136     {
1137         it = d->m_pageNamesCache.insert( name, d->pageWithName( name ) );
1138     }
1139     return it.value();
1140 }