djv_mapareas.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2005-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _djv_mapareas_h_
#define _djv_mapareas_h_

#include "cel_string.h"
#include "cel_geom.h"
#include "djv_common.h"
#include "djv_links.h"
#include "djv_utils.h"

namespace Celartem
{
    namespace DjVu
    {
        enum BorderType
        {
            btNone = 0, 
            btXor = 1, 
            btSolid = 2, 
            btShadowIn = 3, 
            btShadowOut = 4, 
            btShadowEIn = 5, 
            btShadowEOut = 6 
        };
        
        enum MapAreaType
        {
            matRect = 0, 
            matOval = 1, 
            matPoly = 2, 
            matLine = 3, 
            matText = 4, 
        };
        
        //--------------------------------------------------------------------
        class MapArea : public Referable
        {
        public:
            Link link; 
        
            String target; 

            String text; 
            
            BorderType borderType; 
            
            Color lineColor; 

            size_t lineWidth; 

            bool borderAlwaysVisible; 
            
            virtual MapAreaType getType() const = 0;
            
            virtual Rect getRect() const = 0;
            
            virtual bool isPointInsideArea(const Point& inPoint) const = 0;
            
            virtual size_t isPointOnLine(
                const Point& inPoint, size_t inRadius = 1) const = 0;
            
            virtual String getANTString(
                const PageInfo& inPageInfo,
                Rotation inCurrentRotation) const = 0;
            
            virtual AutoPtr<MapArea> duplicate() const = 0;

        protected:
            MapArea() :
                borderType(btNone),
                lineWidth(1),
                borderAlwaysVisible(false)
            {
            }
        };

        //--------------------------------------------------------------------
        class MapRect : public MapArea
        {
        public:
            static AutoPtr<MapRect> create()
            {
                return new MapRect();
            }
            
            Rect rect;

            Color bgColor;
            
            size_t opacity;
        
            virtual MapAreaType getType() const {return matRect;}
            virtual Rect getRect() const {return rect;}

            virtual bool isPointInsideArea(const Point& inPoint) const
            {
                return inPoint.isInside(rect);
            }

            virtual size_t isPointOnLine(
                const Point& inPoint, size_t inRadius = 1) const;
            
            virtual String getANTString(
                const PageInfo& inPageInfo, Rotation inCurrentRotation) const;

            virtual AutoPtr<MapArea> duplicate() const;
        
        private:
            MapRect() : opacity(50) {}
            MapRect(const MapRect&);
            MapRect& operator=(const MapRect&);
        };
        
        //--------------------------------------------------------------------
        class MapOval : public MapArea
        {
        public:
            static AutoPtr<MapOval> create()
            {
                return new MapOval();
            }
            
            Rect rect;

            virtual MapAreaType getType() const {return matOval;}
            virtual Rect getRect() const {return rect;}
            
            virtual bool isPointInsideArea(const Point& inPoint) const;
            
            virtual size_t isPointOnLine(
                const Point& inPoint, size_t inRadius = 1) const;
            
            virtual String getANTString(
                const PageInfo& inPageInfo, Rotation inCurrentRotation) const;

            virtual AutoPtr<MapArea> duplicate() const;
        
        private:
            MapOval() {}
            MapOval(const MapOval&);
            MapOval& operator=(const MapOval&);
        };
        
        //--------------------------------------------------------------------
        class MapPoly : public MapArea
        {
        public:
            static AutoPtr<MapPoly> create()
            {
                return new MapPoly();
            }
            
            SimpleArray<Point> points;
        
            virtual MapAreaType getType() const {return matPoly;}
            
            virtual Rect getRect() const
            {
                ssize_t l = SSIZE_MAX, t = SSIZE_MAX;
                ssize_t r = SSIZE_MIN, b = SSIZE_MIN;
                const size_t count = points.getSize();
                for(size_t i = 0; i < count; i++)
                {
                    const Point& pt = points[i];
                    if(pt.x < l) l = pt.x; else if(pt.x > r) r = pt.x;
                    if(pt.y < t) t = pt.y; else if(pt.y > b) b = pt.y;
                }
                return Rect(l, t, r - l, b - t);
            }
            
            virtual bool isPointInsideArea(const Point& inPoint) const;

            virtual size_t isPointOnLine(
                const Point& inPoint, size_t inRadius = 1) const;
            
            virtual String getANTString(
                const PageInfo& inPageInfo, Rotation inCurrentRotation) const;

            virtual AutoPtr<MapArea> duplicate() const;
        
        private:
            MapPoly() {}
            MapPoly(const MapPoly&);
            MapPoly& operator=(const MapPoly&);
        };
        
        //--------------------------------------------------------------------
        class MapLine : public MapArea
        {
        public:
            static AutoPtr<MapLine> create()
            {
                return new MapLine();
            }
            
            Point p0;
            
            Point p1;
            
            bool isArrow;
        
            virtual MapAreaType getType() const {return matLine;}
            
            virtual Rect getRect() const
            {
                size_t l, t, r, b;
                if(p0.x < p1.x)
                {
                    l = p0.x;
                    r = p1.x;
                }
                else
                {
                    l = p1.x;
                    r = p0.x;
                }
                if(p0.y < p1.y)
                {
                    t = p0.y;
                    b = p1.y;
                }
                else
                {
                    t = p1.y;
                    b = p0.y;
                }
                return Rect(l, t, r - l, b - t);
            }
            
            virtual bool isPointInsideArea(const Point& inPoint) const
            {
                return isPointOnLine(inPoint) ? true : false;
            }
            
            virtual size_t isPointOnLine(
                const Point& inPoint, size_t inRadius = 1) const;
            
            virtual String getANTString(
                const PageInfo& inPageInfo, Rotation inCurrentRotation) const;

            virtual AutoPtr<MapArea> duplicate() const;
        
        private:
            MapLine() : isArrow(false)
            {
                lineColor = 0;
            }
            
            MapLine(const MapLine&);
            MapLine& operator=(const MapLine&);
        };

        //--------------------------------------------------------------------
        class MapText : public MapArea
        {
        public:
            static AutoPtr<MapText> create()
            {
                return new MapText();
            }
            
            Rect rect;

            bool pushpin;
            
            Color textColor;

            Color bgColor;
        
            virtual MapAreaType getType() const {return matText;}
            virtual Rect getRect() const {return rect;}
            
            virtual bool isPointInsideArea(const Point& inPoint) const
            {
                return inPoint.isInside(rect);
            }

            virtual size_t isPointOnLine(
                const Point& inPoint, size_t inRadius = 1) const;
            
            virtual String getANTString(
                const PageInfo& inPageInfo, Rotation inCurrentRotation) const;

            virtual AutoPtr<MapArea> duplicate() const;

        private:
            MapText() : pushpin(false), textColor(0) {}
            MapText(const MapText&);
            MapText& operator=(const MapText&);
        };
    }
}

#endif // _djv_mapareas_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:55 2008.