okular/core/area.h

   1 /***************************************************************************
   2  *   Copyright (C) 2004-05 by Enrico Ros <eros.kde@email.it>               *
   3  *   Copyright (C) 2005 by Piotr Szymanski <niedakh@gmail.com>             *
   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 #ifndef _OKULAR_AREA_H_
  11 #define _OKULAR_AREA_H_
  12
  13 #include <QtCore/QList>
  14 #include <QtGui/QColor>
  15 #include <QtGui/QPainterPath>
  16 #include <kdebug.h>
  17
  18 #include <okular/core/global.h>
  19 #include <okular/core/okular_export.h>
  20
  21 class QPolygonF;
  22 class QRect;
  23
  24 namespace Okular {
  25
  26 class Annotation;
  27 class Action;
  28 class NormalizedShape;
  29
  30 /**
  31  * NormalizedPoint is a helper class which stores the coordinates
  32  * of a normalized point. Normalized means that the coordinates are
  33  * between 0 and 1 so that it is page size independent.
  34  *
  35  * Example:
  36  *    The normalized point is (0.5, 0.3)
  37  *
  38  *    If you want to draw it on a 800x600 page, just multiply the x coordinate (0.5) with
  39  *    the page width (800) and the y coordinate (0.3) with the page height (600), so
  40  *    the point will be drawn on the page at (400, 180).
  41  *
  42  *    That allows you to zoom the page by just multiplying the normalized points with the
  43  *    zoomed page size.
  44  */
  45 class OKULAR_EXPORT NormalizedPoint
  46 {
  47     public:
  48         /**
  49          * Creates a new empty normalized point.
  50          */
  51         NormalizedPoint();
  52
  53         /**
  54          * Creates a new normalized point with the normalized coordinates (@p x, @p y ).
  55          */
  56         NormalizedPoint( double x, double y );
  57
  58         /**
  59          * Creates a new normalized point with the coordinates (@p x, @p y) which are normalized
  60          * by the scaling factors @p xScale and @p yScale.
  61          */
  62         NormalizedPoint( int x, int y, int xScale, int yScale );
  63
  64         /**
  65          * @internal
  66          */
  67         NormalizedPoint& operator=( const NormalizedPoint& );
  68
  69         /**
  70          * Transforms the normalized point with the operations defined by @p matrix.
  71          */
  72         void transform( const QMatrix &matrix );
  73
  74         /**
  75          * The normalized x coordinate.
  76          */
  77         double x;
  78
  79         /**
  80          * The normalized y coordinate.
  81          */
  82         double y;
  83 };
  84
  85 /**
  86  * NormalizedRect is a helper class which stores the coordinates
  87  * of a normalized rect, which is a rectangle of @see NormalizedPoints.
  88  */
  89 class OKULAR_EXPORT NormalizedRect
  90 {
  91     public:
  92         /**
  93          * Creates a null normalized rectangle.
  94          * @see isNull()
  95          */
  96         NormalizedRect();
  97
  98         /**
  99          * Creates a normalized rectangle with the normalized coordinates
 100          * @p left, @p top, @p right, @p bottom.
 101          *
 102          * If you need the x, y, width and height coordinates use the
 103          * following formulas:
 104          *
 105          * @li x = left
 106          * @li y = top
 107          * @li width = right - left
 108          * @li height = bottom - top
 109          */
 110         NormalizedRect( double left, double top, double right, double bottom );
 111
 112         /**
 113          * Creates a normalized rectangle of the given @p rectangle which is normalized
 114          * by the scaling factors @p xScale and @p yScale.
 115          */
 116         NormalizedRect( const QRect &rectangle, double xScale, double yScale );
 117
 118         /**
 119          * @internal
 120          */
 121         NormalizedRect( const NormalizedRect& );
 122
 123         /**
 124          * @internal
 125          */
 126         NormalizedRect& operator=( const NormalizedRect &other );
 127
 128         /**
 129          * Build a normalized rect from a QRectF.
 130          */
 131         static NormalizedRect fromQRectF( const QRectF &rect );
 132
 133         /**
 134          * Returns whether this normalized rectangle is a null normalized rect.
 135          */
 136         bool isNull() const;
 137
 138         /**
 139          * Returns whether the normalized rectangle contains the normalized coordinates
 140          * @p x and @p y.
 141          */
 142         bool contains( double x, double y ) const;
 143
 144         /**
 145          * Returns whether the normalized rectangle intersects the @p other normalized
 146          * rectangle.
 147          */
 148         bool intersects( const NormalizedRect &other ) const;
 149
 150         /**
 151          * This is an overloaded member function, provided for convenience. It behaves essentially
 152          * like the above function.
 153          */
 154         bool intersects( const NormalizedRect *other ) const;
 155
 156         /**
 157          * Returns whether the normalized rectangle intersects an other normalized
 158          * rectangle, which is defined by @p left, @p top, @p right and @p bottom.
 159          */
 160         bool intersects( double left, double top, double right, double bottom ) const;
 161
 162         /**
 163          * Returns the rectangle that accrues when the normalized rectangle is multiplyed
 164          * with the scaling @p xScale and @p yScale.
 165          */
 166         QRect geometry( int xScale, int yScale ) const;
 167
 168         /**
 169          * Returns the normalized bounding rectangle of the normalized rectangle
 170          * combined with the @p other normalized rectangle.
 171          */
 172         NormalizedRect operator|( const NormalizedRect &other ) const;
 173
 174         /**
 175          * Sets the normalized rectangle to the normalized bounding rectangle
 176          * of itself combined with the @p other normalized rectangle.
 177          */
 178         NormalizedRect& operator|=( const NormalizedRect &other );
 179
 180         /**
 181          * Returns the intersection of this normalized rectangle with the specified
 182          * @p other. If the rects do not intersect then the result is null.
 183          *
 184          * @since 0.7 (KDE 4.1)
 185          */
 186         NormalizedRect operator&( const NormalizedRect &other ) const;
 187
 188         /**
 189          * Returns whether the normalized rectangle is equal to the @p other
 190          * normalized rectangle.
 191          */
 192         bool operator==( const NormalizedRect &other ) const;
 193
 194         /**
 195          * Transforms the normalized rectangle with the operations defined by @p matrix.
 196          */
 197         void transform( const QMatrix &matrix );
 198
 199         /**
 200          * The normalized left coordinate.
 201          */
 202         double left;
 203
 204         /**
 205          * The normalized top coordinate.
 206          */
 207         double top;
 208
 209         /**
 210          * The normalized right coordinate.
 211          */
 212         double right;
 213
 214         /**
 215          * The normalized bottom coordinate.
 216          */
 217         double bottom;
 218 };
 219 KDE_DUMMY_QHASH_FUNCTION(NormalizedRect)
 220
 221 /**
 222  * @short NormalizedRect that contains a reference to an object.
 223  *
 224  * These rects contains a pointer to a okular object (such as an action or something
 225  * like that). The pointer is read and stored as 'void pointer' so cast is
 226  * performed by accessors based on the value returned by objectType(). Objects
 227  * are reparented to this class.
 228  *
 229  * Type / Class correspondency tab:
 230  *  - Action    : class Action: description of an action
 231  *  - Image     : class Image : description of an image (n/a)
 232  *  - Annotation: class Annotation: description of an annotation
 233  */
 234 class OKULAR_EXPORT ObjectRect
 235 {
 236     public:
 237         /**
 238          * Describes the type of storable object.
 239          */
 240         enum ObjectType
 241         {
 242             Action,      ///< An action
 243             Image,       ///< An image
 244             OAnnotation, ///< An annotation
 245             SourceRef    ///< A source reference
 246         };
 247
 248         /**
 249          * Creates a new object rectangle.
 250          *
 251          * @param left The left coordinate of the rectangle.
 252          * @param top The top coordinate of the rectangle.
 253          * @param right The right coordinate of the rectangle.
 254          * @param bottom The bottom coordinate of the rectangle.
 255          * @param ellipse If true the rectangle describes an ellipse.
 256          * @param type The type of the storable object @see ObjectType.
 257          * @param object The pointer to the storable object.
 258          */
 259         ObjectRect( double left, double top, double right, double bottom, bool ellipse, ObjectType type, void *object );
 260
 261         /**
 262          * This is an overloaded member function, provided for convenience.
 263          */
 264         ObjectRect( const NormalizedRect &rect, bool ellipse, ObjectType type, void *object );
 265
 266         /**
 267          * This is an overloaded member function, provided for convenience.
 268          */
 269         ObjectRect( const QPolygonF &poly, ObjectType type, void *object );
 270
 271         /**
 272          * Destroys the object rectangle.
 273          */
 274         virtual ~ObjectRect();
 275
 276         /**
 277          * Returns the object type of the object rectangle.
 278          * @see ObjectType
 279          */
 280         ObjectType objectType() const;
 281
 282         /**
 283          * Returns the storable object of the object rectangle.
 284          */
 285         const void *object() const;
 286
 287         /**
 288          * Returns the region that is covered by the object rectangle.
 289          */
 290         const QPainterPath &region() const;
 291
 292         /**
 293          * Returns the bounding rect of the object rectangle for the
 294          * scaling factor @p xScale and @p yScale.
 295          */
 296         virtual QRect boundingRect( double xScale, double yScale ) const;
 297
 298         /**
 299          * Returns whether the object rectangle contains the point @p x, @p y for the
 300          * scaling factor @p xScale and @p yScale.
 301          */
 302         virtual bool contains( double x, double y, double xScale, double yScale ) const;
 303
 304         /**
 305          * Transforms the object rectangle with the operations defined by @p matrix.
 306          */
 307         virtual void transform( const QMatrix &matrix );
 308
 309     protected:
 310         ObjectType m_objectType;
 311         void * m_object;
 312         QPainterPath m_path;
 313         QPainterPath m_transformedPath;
 314 };
 315
 316 /**
 317  * This class describes the object rectangle for an annotation.
 318  */
 319 class OKULAR_EXPORT AnnotationObjectRect : public ObjectRect
 320 {
 321     public:
 322         /**
 323          * Creates a new annotation object rectangle with the
 324          * given @p annotation.
 325          */
 326         AnnotationObjectRect( Annotation *annotation );
 327
 328         /**
 329          * Destroys the annotation object rectangle.
 330          */
 331         virtual ~AnnotationObjectRect();
 332
 333         /**
 334          * Returns the annotation object of the annotation object rectangle.
 335          */
 336         Annotation *annotation() const;
 337
 338         /**
 339          * Returns the bounding rect of the annotation object rectangle for the
 340          * scaling factor @p xScale and @p yScale.
 341          */
 342         virtual QRect boundingRect( double xScale, double yScale ) const;
 343
 344         /**
 345          * Returns whether the annotation object rectangle contains the point @p x, @p y for the
 346          * scaling factor @p xScale and @p yScale.
 347          */
 348         virtual bool contains( double x, double y, double xScale, double yScale ) const;
 349
 350         /**
 351          * Transforms the annotation object rectangle with the operations defined by @p matrix.
 352          */
 353         virtual void transform( const QMatrix &matrix );
 354
 355     private:
 356         Annotation * m_annotation;
 357 };
 358
 359 /**
 360  * This class describes the object rectangle for a source reference.
 361  */
 362 class OKULAR_EXPORT SourceRefObjectRect : public ObjectRect
 363 {
 364     public:
 365         /**
 366          * Creates a new source reference object rectangle.
 367          *
 368          * @param point The point of the source reference.
 369          * @param reference The storable source reference object.
 370          */
 371         SourceRefObjectRect( const NormalizedPoint& point, void *reference );
 372
 373         /**
 374          * Returns the bounding rect of the source reference object rectangle for the
 375          * scaling factor @p xScale and @p yScale.
 376          */
 377         virtual QRect boundingRect( double xScale, double yScale ) const;
 378
 379         /**
 380          * Returns whether the source reference object rectangle contains the point @p x, @p y for the
 381          * scaling factor @p xScale and @p yScale.
 382          */
 383         virtual bool contains( double x, double y, double xScale, double yScale ) const;
 384
 385     private:
 386         NormalizedPoint m_point;
 387 };
 388
 389 /// @cond PRIVATE
 390 /** @internal */
 391 template <typename T>
 392 void doDelete( T& t )
 393 {
 394     (void)t;
 395 }
 396
 397 /** @internal */
 398 template <typename T>
 399 T* givePtr( T& t )
 400 {
 401     return &t;
 402 }
 403
 404 /** @internal */
 405 template <typename T>
 406 T& deref( T& t )
 407 {
 408     return t;
 409 }
 410
 411 /** @internal */
 412 template <typename T>
 413 static void doDelete( T* t )
 414 {
 415     delete t;
 416 }
 417
 418 /** @internal */
 419 template <typename T>
 420 static T* givePtr( T* t )
 421 {
 422     return t;
 423 }
 424
 425 /** @internal */
 426 template <typename T>
 427 static T& deref( T* t )
 428 {
 429     return *t;
 430 }
 431 /// @endcond
 432
 433 /**
 434  * @short A regular area of NormalizedShape which normalizes a Shape
 435  *
 436  * Class NormalizedShape \b must have the following functions/operators defined:
 437  * - bool contains( double, double )
 438  * - bool intersects( NormalizedShape )
 439  * - bool isNull()
 440  * - Shape geometry( int, int )
 441  * - operator|=( NormalizedShape ) which unite two NormalizedShape's
 442  */
 443 template <class NormalizedShape, class Shape> class RegularArea : public  QList<NormalizedShape>
 444 {
 445     public:
 446         /**
 447          * Destroys a regular area.
 448          */
 449         ~RegularArea();
 450
 451         /**
 452          * Returns whether the regular area contains the
 453          * normalized point @p x, @p y.
 454          */
 455         bool contains( double x, double y ) const;
 456
 457         /**
 458          * Returns whether the regular area contains the
 459          * given @p shape.
 460          */
 461         bool contains( const NormalizedShape& shape ) const;
 462
 463         /**
 464          * Returns whether the regular area intersects with the given @p area.
 465          */
 466         bool intersects( const RegularArea<NormalizedShape,Shape> *area ) const;
 467
 468         /**
 469          * Returns whether the regular area intersects with the given @p shape.
 470          */
 471         bool intersects( const NormalizedShape& shape ) const;
 472
 473         /**
 474          * Appends the given @p area to the regular area.
 475          */
 476         void appendArea( const RegularArea<NormalizedShape,Shape> *area );
 477
 478         /**
 479          * Appends the given @p shape to the regular area.
 480          */
 481         void appendShape( const NormalizedShape& shape, MergeSide side = MergeAll );
 482
 483         /**
 484          * Simplifies the regular area by merging its intersecting subareas.
 485          */
 486         void simplify();
 487
 488         /**
 489          * Returns whether the regular area is a null area.
 490          */
 491         bool isNull() const;
 492
 493         /**
 494          * Returns the subareas of the regular areas as shapes for the given scaling factor
 495          * @p xScale and @p yScale, translated by @p dx and @p dy.
 496          */
 497         QList<Shape> geometry( int xScale, int yScale, int dx = 0, int dy = 0 ) const;
 498
 499         /**
 500          * Transforms the regular area with the operations defined by @p matrix.
 501          */
 502         void transform( const QMatrix &matrix );
 503 };
 504
 505 template <class NormalizedShape, class Shape>
 506 RegularArea<NormalizedShape, Shape>::~RegularArea()
 507 {
 508     int size = this->count();
 509     for ( int i = 0; i < size; ++i )
 510         doDelete( (*this)[i] );
 511 }
 512
 513 template <class NormalizedShape, class Shape>
 514 void RegularArea<NormalizedShape, Shape>::simplify()
 515 {
 516 #ifdef DEBUG_REGULARAREA
 517             int prev_end = this->count();
 518 #endif
 519             int end = this->count() - 1, x = 0;
 520             for ( int i = 0; i < end; ++i )
 521             {
 522                     if ( givePtr( (*this)[x] )->intersects( deref( (*this)[i+1] ) ) )
 523                     {
 524                         deref((*this)[x]) |= deref((*this)[i+1]);
 525                         NormalizedShape& tobedeleted = (*this)[i+1];
 526                         this->removeAt( i + 1 );
 527                         doDelete( tobedeleted );
 528                         --end;
 529                         --i;
 530                     }
 531                     else
 532                     {
 533                         x=i+1;
 534                    }
 535             }
 536 #ifdef DEBUG_REGULARAREA
 537     kDebug() << "from" << prev_end << "to" << this->count();
 538 #endif
 539 }
 540
 541 template <class NormalizedShape, class Shape>
 542 bool RegularArea<NormalizedShape, Shape>::isNull() const
 543 {
 544     if ( !this )
 545         return false;
 546
 547     if ( this->isEmpty() )
 548         return false;
 549
 550     typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
 551     for ( ; it != itEnd; ++it )
 552         if ( !givePtr( *it )->isNull() )
 553             return false;
 554
 555     return true;
 556 }
 557
 558 template <class NormalizedShape, class Shape>
 559 bool RegularArea<NormalizedShape, Shape>::intersects( const NormalizedShape& rect ) const
 560 {
 561     if ( !this )
 562         return false;
 563
 564     if ( this->isEmpty() )
 565         return false;
 566
 567     typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
 568     for ( ; it != itEnd; ++it )
 569         if ( !givePtr( *it )->isNull() && givePtr( *it )->intersects( rect ) )
 570             return true;
 571
 572     return false;
 573 }
 574
 575 template <class NormalizedShape, class Shape>
 576 bool RegularArea<NormalizedShape, Shape>::intersects( const RegularArea<NormalizedShape,Shape> *area ) const
 577 {
 578     if ( !this )
 579         return false;
 580
 581     if ( this->isEmpty() )
 582         return false;
 583
 584     typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
 585     for ( ; it != itEnd; ++it )
 586     {
 587         typename QList<NormalizedShape>::const_iterator areaIt = area->begin(), areaItEnd = area->end();
 588         for ( ; areaIt != areaItEnd; ++areaIt )
 589         {
 590             if ( !( *it ).isNull() && ( *it ).intersects( *areaIt ) )
 591                 return true;
 592         }
 593     }
 594
 595     return false;
 596 }
 597
 598 template <class NormalizedShape, class Shape>
 599 void RegularArea<NormalizedShape, Shape>::appendArea( const RegularArea<NormalizedShape, Shape> *area )
 600 {
 601     if ( !this )
 602         return;
 603
 604     typename QList<NormalizedShape>::const_iterator areaIt = area->begin(), areaItEnd = area->end();
 605     for ( ; areaIt != areaItEnd; ++areaIt )
 606         this->append( *areaIt );
 607 }
 608
 609
 610 template <class NormalizedShape, class Shape>
 611 void RegularArea<NormalizedShape, Shape>::appendShape( const NormalizedShape& shape, MergeSide side )
 612 {
 613     if ( !this )
 614         return;
 615
 616     int size = this->count();
 617     // if the list is empty, adds the shape normally
 618     if ( size == 0 )
 619     {
 620         this->append( shape );
 621     }
 622     else
 623     {
 624         bool intersection = false;
 625         NormalizedShape& last = (*this)[size - 1];
 626 #define O_LAST givePtr( last )
 627 #  define O_LAST_R O_LAST->right
 628 #  define O_LAST_L O_LAST->left
 629 #  define O_LAST_T O_LAST->top
 630 #  define O_LAST_B O_LAST->bottom
 631 #define O_NEW givePtr( shape )
 632 #  define O_NEW_R O_NEW->right
 633 #  define O_NEW_L O_NEW->left
 634 #  define O_NEW_T O_NEW->top
 635 #  define O_NEW_B O_NEW->bottom
 636         switch ( side )
 637         {
 638             case MergeRight:
 639                 intersection = ( O_LAST_R >= O_NEW_L ) && ( O_LAST_L <= O_NEW_R )
 640                                && ( ( O_LAST_T <= O_NEW_T && O_LAST_B >= O_NEW_B )
 641                                   || ( O_LAST_T >= O_NEW_T && O_LAST_B <= O_NEW_B ) );
 642                 break;
 643             case MergeBottom:
 644                 intersection = ( O_LAST_B >= O_NEW_T ) && ( O_LAST_T <= O_NEW_B )
 645                                && ( ( O_LAST_R <= O_NEW_R && O_LAST_L >= O_NEW_L )
 646                                   || ( O_LAST_R >= O_NEW_R && O_LAST_L <= O_NEW_L ) );
 647                 break;
 648             case MergeLeft:
 649                 intersection = ( O_LAST_L <= O_NEW_R ) && ( O_LAST_R >= O_NEW_L )
 650                                && ( ( O_LAST_T <= O_NEW_T && O_LAST_B >= O_NEW_B )
 651                                   || ( O_LAST_T >= O_NEW_T && O_LAST_B <= O_NEW_B ) );
 652                 break;
 653             case MergeTop:
 654                 intersection = ( O_LAST_T <= O_NEW_B ) && ( O_LAST_B >= O_NEW_T )
 655                                && ( ( O_LAST_R <= O_NEW_R && O_LAST_L >= O_NEW_L )
 656                                   || ( O_LAST_R >= O_NEW_R && O_LAST_L <= O_NEW_L ) );
 657                 break;
 658             case MergeAll:
 659                 intersection = O_LAST->intersects( shape );
 660                 break;
 661         }
 662 #undef O_LAST
 663 #  undef O_LAST_R
 664 #  undef O_LAST_L
 665 #  undef O_LAST_T
 666 #  undef O_LAST_B
 667 #undef O_NEW
 668 #  undef O_NEW_R
 669 #  undef O_NEW_L
 670 #  undef O_NEW_T
 671 #  undef O_NEW_B
 672         // if the new shape intersects with the last shape in the list, then
 673         // merge it with that and delete the shape
 674         if ( intersection )
 675         {
 676             deref((*this)[size - 1]) |= deref( shape );
 677             doDelete( const_cast<NormalizedShape&>( shape ) );
 678         }
 679         else
 680             this->append( shape );
 681     }
 682 }
 683
 684
 685 template <class NormalizedShape, class Shape>
 686 bool RegularArea<NormalizedShape, Shape>::contains( double x, double y ) const
 687 {
 688     if ( !this )
 689         return false;
 690
 691     if ( this->isEmpty() )
 692         return false;
 693
 694     typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
 695     for ( ; it != itEnd; ++it )
 696         if ( ( *it ).contains( x, y ) )
 697             return true;
 698
 699     return false;
 700 }
 701
 702 template <class NormalizedShape, class Shape>
 703 bool RegularArea<NormalizedShape, Shape>::contains( const NormalizedShape& shape ) const
 704 {
 705     if ( !this )
 706         return false;
 707
 708     if ( this->isEmpty() )
 709         return false;
 710
 711     return QList<NormalizedShape>::contains( shape );
 712 }
 713
 714 template <class NormalizedShape, class Shape>
 715 QList<Shape> RegularArea<NormalizedShape, Shape>::geometry( int xScale, int yScale, int dx, int dy ) const
 716 {
 717     if ( !this || this->isEmpty() )
 718         return QList<Shape>();
 719
 720     QList<Shape> ret;
 721     Shape t;
 722     typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
 723     for ( ; it != itEnd; ++it )
 724     {
 725         t = givePtr( *it )->geometry( xScale, yScale );
 726         t.translate( dx, dy );
 727         ret.append( t );
 728     }
 729
 730     return ret;
 731 }
 732
 733 template <class NormalizedShape, class Shape>
 734 void RegularArea<NormalizedShape, Shape>::transform( const QMatrix &matrix )
 735 {
 736     if ( !this )
 737         return;
 738
 739     if ( this->isEmpty() )
 740         return;
 741
 742     for ( int i = 0; i < this->count(); ++i )
 743         givePtr( (*this)[i] )->transform( matrix );
 744 }
 745
 746 class OKULAR_EXPORT RegularAreaRect : public RegularArea< NormalizedRect, QRect >
 747 {
 748     public:
 749         RegularAreaRect();
 750         RegularAreaRect( const RegularAreaRect& rar );
 751         ~RegularAreaRect();
 752
 753         RegularAreaRect& operator=( const RegularAreaRect& rar );
 754
 755     private:
 756         class Private;
 757         Private * const d;
 758 };
 759
 760 /**
 761  * This class stores the coordinates of a highlighting area
 762  * together with the id of the highlight owner and the color.
 763  */
 764 class HighlightAreaRect : public RegularAreaRect
 765 {
 766     public:
 767         /**
 768          * Creates a new highlight area rect with the coordinates of
 769          * the given @p area.
 770          */
 771         HighlightAreaRect( const RegularAreaRect *area = 0 );
 772
 773         /**
 774          * The search ID of the highlight owner.
 775          */
 776         int s_id;
 777
 778         /**
 779          * The color of the highlight.
 780          */
 781         QColor color;
 782 };
 783
 784 }
 785
 786 #ifndef QT_NO_DEBUG_STREAM
 787 /**
 788  * Debug operator for normalized @p point.
 789  */
 790 OKULAR_EXPORT QDebug operator<<( QDebug str, const Okular::NormalizedPoint &point );
 791
 792 /**
 793  * Debug operator for normalized @p rect.
 794  */
 795 OKULAR_EXPORT QDebug operator<<( QDebug str, const Okular::NormalizedRect &rect );
 796 #endif
 797
 798 #endif