area.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-05 by Enrico Ros <eros.kde@email.it>               *
 *   Copyright (C) 2005 by Piotr Szymanski <niedakh@gmail.com>             *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef _OKULAR_AREA_H_
#define _OKULAR_AREA_H_

#include <QtCore/QList>
#include <QtGui/QColor>
#include <QtGui/QPainterPath>
#include <QtGui/QTransform>
#include <kdebug.h>
#include <math.h>

#include "global.h"
#include "okular_export.h"

class QPolygonF;
class QRect;

namespace Okular {

class Annotation;
class Action;
class NormalizedShape;

class OKULAR_EXPORT NormalizedPoint
{
    public:
        NormalizedPoint();

        NormalizedPoint( double x, double y );

        NormalizedPoint( int x, int y, int xScale, int yScale );

        NormalizedPoint& operator=( const NormalizedPoint& );

        void transform( const QTransform &matrix );

        double distanceSqr( double x, double y, double xScale, double yScale ) const;


        static double distanceSqr( double x, double y, double xScale, double yScale, const NormalizedPoint& start, const NormalizedPoint& end );

        double x;

        double y;
};


class OKULAR_EXPORT NormalizedRect
{
    public:
        NormalizedRect();

        NormalizedRect( double left, double top, double right, double bottom );

        NormalizedRect( const QRect &rectangle, double xScale, double yScale );

        NormalizedRect( const NormalizedRect& );

        NormalizedRect& operator=( const NormalizedRect &other );

        static NormalizedRect fromQRectF( const QRectF &rect );

        bool isNull() const;

        bool contains( double x, double y ) const;

        bool intersects( const NormalizedRect &other ) const;

        bool intersects( const NormalizedRect *other ) const;

        bool intersects( double left, double top, double right, double bottom ) const;

        QRect geometry( int xScale, int yScale ) const;

        QRect roundedGeometry( int xScale, int yScale ) const;

        NormalizedRect operator|( const NormalizedRect &other ) const;

        NormalizedRect& operator|=( const NormalizedRect &other );

        NormalizedRect operator&( const NormalizedRect &other ) const;

        bool operator==( const NormalizedRect &other ) const;

        NormalizedPoint center() const;

        void transform( const QTransform &matrix );

        bool isBottom(const NormalizedPoint& pt) const
        {
            return bottom < pt.y;
        }

        bool isTop(const NormalizedPoint& pt) const
        {
            return top > pt.y;
        }

        bool isBottomOrLevel(const NormalizedPoint& pt) const
        {
            return top < pt.y;
        }

        bool isTopOrLevel(const NormalizedPoint& pt) const
        {
            return bottom > pt.y;
        }

        bool isLeft(const NormalizedPoint& pt) const
        {
            return left < pt.x;
        }

        bool isRight(const NormalizedPoint& pt) const
        {
            return right > pt.x;
        }

        double distanceSqr(double x, double y, double xScale, double yScale) const
        {
            double distX = 0;
            if ( x < left )
                distX = left - x;
            else if ( x > right )
                distX = x - right;

            double distY = 0;
            if ( top > y )
                distY = top - y;
            else if (bottom < y)
                distY = y - bottom;
            return pow( distX * xScale, 2 ) + pow( distY * yScale, 2 );
        }

        double left;

        double top;

        double right;

        double bottom;
};
KDE_DUMMY_QHASH_FUNCTION(NormalizedRect)


class OKULAR_EXPORT ObjectRect
{
    public:
        enum ObjectType
        {
            Action,      
            Image,       
            OAnnotation, 
            SourceRef    
        };

        ObjectRect( double left, double top, double right, double bottom, bool ellipse, ObjectType type, void *object );

        ObjectRect( const NormalizedRect &rect, bool ellipse, ObjectType type, void *object );

        ObjectRect( const QPolygonF &poly, ObjectType type, void *object );

        virtual ~ObjectRect();

        ObjectType objectType() const;

        const void *object() const;

        const QPainterPath &region() const;

        virtual QRect boundingRect( double xScale, double yScale ) const;

        virtual bool contains( double x, double y, double xScale, double yScale ) const;

        virtual void transform( const QTransform &matrix );

        // FIXME this should most probably be a virtual method
        double distanceSqr( double x, double y, double xScale, double yScale ) const;

    protected:
        ObjectType m_objectType;
        void * m_object;
        QPainterPath m_path;
        QPainterPath m_transformedPath;
};

class OKULAR_EXPORT AnnotationObjectRect : public ObjectRect
{
    public:
        AnnotationObjectRect( Annotation *annotation );

        virtual ~AnnotationObjectRect();

        Annotation *annotation() const;

        virtual QRect boundingRect( double xScale, double yScale ) const;

        virtual bool contains( double x, double y, double xScale, double yScale ) const;

        virtual void transform( const QTransform &matrix );

    private:
        Annotation * m_annotation;
};

class OKULAR_EXPORT SourceRefObjectRect : public ObjectRect
{
    friend class ObjectRect;

    public:
        SourceRefObjectRect( const NormalizedPoint& point, void *reference );

        virtual QRect boundingRect( double xScale, double yScale ) const;

        virtual bool contains( double x, double y, double xScale, double yScale ) const;

    private:
        NormalizedPoint m_point;
};


template <typename T>
void doDelete( T& t )
{
    (void)t;
}

template <typename T>
T* givePtr( T& t )
{
    return &t;
}

template <typename T>
T& deref( T& t )
{
    return t;
}

template <typename T>
static void doDelete( T* t )
{
    delete t;
}

template <typename T>
static T* givePtr( T* t )
{
    return t;
}

template <typename T>
static T& deref( T* t )
{
    return *t;
}

template <class NormalizedShape, class Shape> class RegularArea : public  QList<NormalizedShape>
{
    public:
        ~RegularArea();

        bool contains( double x, double y ) const;

        bool contains( const NormalizedShape& shape ) const;

        bool intersects( const RegularArea<NormalizedShape,Shape> *area ) const;

        bool intersects( const NormalizedShape& shape ) const;

        void appendArea( const RegularArea<NormalizedShape,Shape> *area );

        void appendShape( const NormalizedShape& shape, MergeSide side = MergeAll );

        void simplify();

        bool isNull() const;

        QList<Shape> geometry( int xScale, int yScale, int dx = 0, int dy = 0 ) const;

        void transform( const QTransform &matrix );
};

template <class NormalizedShape, class Shape>
RegularArea<NormalizedShape, Shape>::~RegularArea()
{
    int size = this->count();
    for ( int i = 0; i < size; ++i )
        doDelete( (*this)[i] );
}

template <class NormalizedShape, class Shape>
void RegularArea<NormalizedShape, Shape>::simplify()
{
#ifdef DEBUG_REGULARAREA
            int prev_end = this->count();
#endif
            int end = this->count() - 1, x = 0;
            for ( int i = 0; i < end; ++i )
            {
                    if ( givePtr( (*this)[x] )->intersects( deref( (*this)[i+1] ) ) )
                    {
                        deref((*this)[x]) |= deref((*this)[i+1]);
                        NormalizedShape& tobedeleted = (*this)[i+1];
                        this->removeAt( i + 1 );
                        doDelete( tobedeleted );
                        --end;
                        --i;
                    }
                    else
                    {
                        x=i+1;
                   }
            }
#ifdef DEBUG_REGULARAREA
    kDebug() << "from" << prev_end << "to" << this->count();
#endif
}

template <class NormalizedShape, class Shape>
bool RegularArea<NormalizedShape, Shape>::isNull() const
{
    if ( !this )
        return false;

    if ( this->isEmpty() )
        return false;

    typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
    for ( ; it != itEnd; ++it )
        if ( !givePtr( *it )->isNull() )
            return false;

    return true;
}

template <class NormalizedShape, class Shape>
bool RegularArea<NormalizedShape, Shape>::intersects( const NormalizedShape& rect ) const
{
    if ( !this )
        return false;

    if ( this->isEmpty() )
        return false;

    typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
    for ( ; it != itEnd; ++it )
        if ( !givePtr( *it )->isNull() && givePtr( *it )->intersects( rect ) )
            return true;

    return false;
}

template <class NormalizedShape, class Shape>
bool RegularArea<NormalizedShape, Shape>::intersects( const RegularArea<NormalizedShape,Shape> *area ) const
{
    if ( !this )
        return false;

    if ( this->isEmpty() )
        return false;

    typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
    for ( ; it != itEnd; ++it )
    {
        typename QList<NormalizedShape>::const_iterator areaIt = area->begin(), areaItEnd = area->end();
        for ( ; areaIt != areaItEnd; ++areaIt )
        {
            if ( !( *it ).isNull() && ( *it ).intersects( *areaIt ) )
                return true;
        }
    }

    return false;
}

template <class NormalizedShape, class Shape>
void RegularArea<NormalizedShape, Shape>::appendArea( const RegularArea<NormalizedShape, Shape> *area )
{
    if ( !this )
        return;

    typename QList<NormalizedShape>::const_iterator areaIt = area->begin(), areaItEnd = area->end();
    for ( ; areaIt != areaItEnd; ++areaIt )
        this->append( *areaIt );
}


template <class NormalizedShape, class Shape>
void RegularArea<NormalizedShape, Shape>::appendShape( const NormalizedShape& shape, MergeSide side )
{
    if ( !this )
        return;

    int size = this->count();
    // if the list is empty, adds the shape normally
    if ( size == 0 )
    {
        this->append( shape );
    }
    else
    {
        bool intersection = false;
        NormalizedShape& last = (*this)[size - 1];
#define O_LAST givePtr( last )
#  define O_LAST_R O_LAST->right
#  define O_LAST_L O_LAST->left
#  define O_LAST_T O_LAST->top
#  define O_LAST_B O_LAST->bottom
#define O_NEW givePtr( shape )
#  define O_NEW_R O_NEW->right
#  define O_NEW_L O_NEW->left
#  define O_NEW_T O_NEW->top
#  define O_NEW_B O_NEW->bottom
        switch ( side )
        {
            case MergeRight:
                intersection = ( O_LAST_R >= O_NEW_L ) && ( O_LAST_L <= O_NEW_R )
                               && ( ( O_LAST_T <= O_NEW_T && O_LAST_B >= O_NEW_B )
                                  || ( O_LAST_T >= O_NEW_T && O_LAST_B <= O_NEW_B ) );
                break;
            case MergeBottom:
                intersection = ( O_LAST_B >= O_NEW_T ) && ( O_LAST_T <= O_NEW_B )
                               && ( ( O_LAST_R <= O_NEW_R && O_LAST_L >= O_NEW_L )
                                  || ( O_LAST_R >= O_NEW_R && O_LAST_L <= O_NEW_L ) );
                break;
            case MergeLeft:
                intersection = ( O_LAST_L <= O_NEW_R ) && ( O_LAST_R >= O_NEW_L )
                               && ( ( O_LAST_T <= O_NEW_T && O_LAST_B >= O_NEW_B )
                                  || ( O_LAST_T >= O_NEW_T && O_LAST_B <= O_NEW_B ) );
                break;
            case MergeTop:
                intersection = ( O_LAST_T <= O_NEW_B ) && ( O_LAST_B >= O_NEW_T )
                               && ( ( O_LAST_R <= O_NEW_R && O_LAST_L >= O_NEW_L )
                                  || ( O_LAST_R >= O_NEW_R && O_LAST_L <= O_NEW_L ) );
                break;
            case MergeAll:
                intersection = O_LAST->intersects( shape );
                break;
        }
#undef O_LAST
#  undef O_LAST_R
#  undef O_LAST_L
#  undef O_LAST_T
#  undef O_LAST_B
#undef O_NEW
#  undef O_NEW_R
#  undef O_NEW_L
#  undef O_NEW_T
#  undef O_NEW_B
        // if the new shape intersects with the last shape in the list, then
        // merge it with that and delete the shape
        if ( intersection )
        {
            deref((*this)[size - 1]) |= deref( shape );
            doDelete( const_cast<NormalizedShape&>( shape ) );
        }
        else
            this->append( shape );
    }
}


template <class NormalizedShape, class Shape>
bool RegularArea<NormalizedShape, Shape>::contains( double x, double y ) const
{
    if ( !this )
        return false;

    if ( this->isEmpty() )
        return false;

    typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
    for ( ; it != itEnd; ++it )
        if ( ( *it ).contains( x, y ) )
            return true;

    return false;
}

template <class NormalizedShape, class Shape>
bool RegularArea<NormalizedShape, Shape>::contains( const NormalizedShape& shape ) const
{
    if ( !this )
        return false;

    if ( this->isEmpty() )
        return false;

    return QList<NormalizedShape>::contains( shape );
}

template <class NormalizedShape, class Shape>
QList<Shape> RegularArea<NormalizedShape, Shape>::geometry( int xScale, int yScale, int dx, int dy ) const
{
    if ( !this || this->isEmpty() )
        return QList<Shape>();

    QList<Shape> ret;
    Shape t;
    typename QList<NormalizedShape>::const_iterator it = this->begin(), itEnd = this->end();
    for ( ; it != itEnd; ++it )
    {
        t = givePtr( *it )->geometry( xScale, yScale );
        t.translate( dx, dy );
        ret.append( t );
    }

    return ret;
}

template <class NormalizedShape, class Shape>
void RegularArea<NormalizedShape, Shape>::transform( const QTransform &matrix )
{
    if ( !this )
        return;

    if ( this->isEmpty() )
        return;

    for ( int i = 0; i < this->count(); ++i )
        givePtr( (*this)[i] )->transform( matrix );
}

class OKULAR_EXPORT RegularAreaRect : public RegularArea< NormalizedRect, QRect >
{
    public:
        RegularAreaRect();
        RegularAreaRect( const RegularAreaRect& rar );
        ~RegularAreaRect();

        RegularAreaRect& operator=( const RegularAreaRect& rar );

    private:
        class Private;
        Private * const d;
};

class HighlightAreaRect : public RegularAreaRect
{
    public:
        HighlightAreaRect( const RegularAreaRect *area = 0 );

        int s_id;

        QColor color;
};

}

#ifndef QT_NO_DEBUG_STREAM

OKULAR_EXPORT QDebug operator<<( QDebug str, const Okular::NormalizedPoint &point );

OKULAR_EXPORT QDebug operator<<( QDebug str, const Okular::NormalizedRect &rect );
#endif

#endif