Logo Search packages:      
Sourcecode: djvulibre version File versions

GMapAreas.h

//C-  -*- C++ -*-
//C- -------------------------------------------------------------------
//C- DjVuLibre-3.5
//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
//C- Copyright (c) 2001  AT&T
//C-
//C- This software is subject to, and may be distributed under, the
//C- GNU General Public License, Version 2. The license should have
//C- accompanied the software or you may obtain a copy of the license
//C- from the Free Software Foundation at http://www.fsf.org .
//C-
//C- This program is distributed in the hope that it will be useful,
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//C- GNU General Public License for more details.
//C- 
//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library
//C- distributed by Lizardtech Software.  On July 19th 2002, Lizardtech 
//C- Software authorized us to replace the original DjVu(r) Reference 
//C- Library notice by the following text (see doc/lizard2002.djvu):
//C-
//C-  ------------------------------------------------------------------
//C- | DjVu (r) Reference Library (v. 3.5)
//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
//C- | The DjVu Reference Library is protected by U.S. Pat. No.
//C- | 6,058,214 and patents pending.
//C- |
//C- | This software is subject to, and may be distributed under, the
//C- | GNU General Public License, Version 2. The license should have
//C- | accompanied the software or you may obtain a copy of the license
//C- | from the Free Software Foundation at http://www.fsf.org .
//C- |
//C- | The computer code originally released by LizardTech under this
//C- | license and unmodified by other parties is deemed "the LIZARDTECH
//C- | ORIGINAL CODE."  Subject to any third party intellectual property
//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 
//C- | non-exclusive license to make, use, sell, or otherwise dispose of 
//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 
//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 
//C- | General Public License.   This grant only confers the right to 
//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 
//C- | the extent such infringement is reasonably necessary to enable 
//C- | recipient to make, have made, practice, sell, or otherwise dispose 
//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 
//C- | any greater extent that may be necessary to utilize further 
//C- | modifications or combinations.
//C- |
//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//C- +------------------------------------------------------------------
// 
// $Id: GMapAreas.h,v 1.8 2003/11/07 22:08:21 leonb Exp $
// $Name: release_3_5_14 $

#ifndef _GMAPAREAS_H
#define _GMAPAREAS_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma interface
#endif


#include "GSmartPointer.h"
#include "GContainer.h"
#include "GString.h"
#include "GRect.h"
#include "GURL.h"

#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif


/** @name GMapAreas.h

    Files #"GMapAreas.h"# and #"GMapAreas.cpp"# implement base objects
    used by the plugin to display and manage hyperlinks and highlighted
    areas inside a \Ref{DjVuImage} page.

    The currently supported areas can be rectangular (\Ref{GMapRect}),
    elliptical (\Ref{GMapOval}) and polygonal (\Ref{GMapPoly}). Every
    map area besides the definition of its shape contains information
    about display style and optional {\bf URL}, which it may refer to.
    If this {\bf URL} is not empty then the map area will work like a
    hyperlink.

    The classes also implement some useful functions to ease geometry
    manipulations

    @memo Definition of base map area classes
    @author Andrei Erofeev <eaf@geocities.com>
    @version
    #$Id: GMapAreas.h,v 1.8 2003/11/07 22:08:21 leonb Exp $# */
//@{


// ---------- GMAPAREA ---------

/** This is the base object for all map areas. It defines some standard
    interface to access the geometrical properties of the areas and
    describes the area itsef:
    \begin{itemize}
       \item #url# If the optional #URL# is specified, the map area will
             also work as a hyperlink meaning that if you click it with
           your mouse pointer, the browser will be advised to load
           the page referenced by the #URL#.
       \item #target# Defines where the specified #URL# should be loaded
       \item #comment# This is a string displayed in a status line or in
             a popup window when the mouse pointer moves over the hyperlink
           area
       \item #border_type#, #border_color# and #border_width# describes
             how the area border should be drawn
       \item #area_color# describes how the area should be highlighted.
    \end{itemize}

    The map areas can be displayed using two different techniques, which
    can be combined together:
    \begin{itemize}
       \item Visible border. The border of a map area can be drawn in several
             different ways (like #XOR_BORDER# or #SHADOW_IN_BORDER#).
           It can be made always visible, or appearing only when the
           mouse pointer moves over the map area.
       \item Highlighted contents. Contents of rectangular map areas can
             also be highlighted with some given color.
    \end{itemize}
*/

00135 class GMapArea : public GPEnabled
{
protected:
   GMapArea(void);
public:
//      // Default creator.
//   static GP<GMapArea> create(void) {return new GMapArea();}

      /// Virtual destructor.
   virtual ~GMapArea();

   static const char MAPAREA_TAG [];
   static const char RECT_TAG [];
   static const char POLY_TAG [];
   static const char OVAL_TAG [];
   static const char NO_BORDER_TAG [];
   static const char XOR_BORDER_TAG [];
   static const char SOLID_BORDER_TAG [];
   static const char SHADOW_IN_BORDER_TAG [];
   static const char SHADOW_OUT_BORDER_TAG [];
   static const char SHADOW_EIN_BORDER_TAG [];
   static const char SHADOW_EOUT_BORDER_TAG [];
   static const char BORDER_AVIS_TAG [];
   static const char HILITE_TAG [];
   static const char URL_TAG [];
   static const char TARGET_SELF [];

   enum BorderType { NO_BORDER=0, XOR_BORDER=1, SOLID_BORDER=2,
                 SHADOW_IN_BORDER=3, SHADOW_OUT_BORDER=4,
                 SHADOW_EIN_BORDER=5, SHADOW_EOUT_BORDER=6 };

   enum Special_Hilite_Color{ NO_HILITE=0xFFFFFFFF, XOR_HILITE=0xFF000000};

   // Enumeration for reporting the type of map area. "MapUnknown" is reported
   // for objects of type GMapArea (there shouldn't be any).
   enum MapAreaType { UNKNOWN, RECT, OVAL, POLY };

      /** Optional URL which this map area can be associated with.
        If it's not empty then clicking this map area with the mouse
        will make the browser load the HTML page referenced by
        this #url#.  Note: This may also be a relative URL, so the
          GURL class is not used. */
00177    GUTF8String    url;
      /** The target for the #URL#. Standard targets are:
        \begin{itemize}
           \item #_blank# - Load the link in a new blank window
           \item #_self# - Load the link into the plugin window
           \item #_top# - Load the link into the top-level frame
        \end{itemize} */
00184    GUTF8String    target;
      /** Comment (displayed in a status line or as a popup hint when
        the mouse pointer moves over the map area */
00187    GUTF8String    comment;
      /** Border type. Defines how the map area border should be drawn
        \begin{itemize}
           \item #NO_BORDER# - No border drawn
           \item #XOR_BORDER# - The border is drawn using XOR method.
           \item #SOLID_BORDER# - The border is drawn as a solid line
                 of a given color.
           \item #SHADOW_IN_BORDER# - Supported for \Ref{GMapRect} only.
               The map area area looks as if it was "pushed-in".
           \item #SHADOW_OUT_BORDER# - The opposite of #SHADOW_OUT_BORDER#
           \item #SHADOW_EIN_BORDER# - Also for \Ref{GMapRect} only.
               Is translated as "shadow etched in"
           \item #SHADOW_EOUT_BORDER# - The opposite of #SHADOW_EIN_BORDER#.
        \end{itemize} */
00201    BorderType     border_type;
      /** If #TRUE#, the border will be made always visible. Otherwise
        it will be drawn when the mouse moves over the map area. */
00204    bool           border_always_visible;
      /// Border color (when relevant) in #0x00RRGGBB# format
00206    unsigned long int    border_color;
      /// Border width in pixels
00208    int            border_width;
      /** Specified a color for highlighting the internal area of the map
        area. Will work with rectangular map areas only. The color is
        specified in \#00RRGGBB format. A special value of \#FFFFFFFF disables
          highlighting and \#FF000000 is for XOR highlighting. */
00213    unsigned long int    hilite_color;

      /// Returns 1 if the given point is inside the hyperlink area
   bool           is_point_inside(int x, int y) const;

      /// Returns xmin of the bounding rectangle
   int            get_xmin(void) const;
      /// Returns ymin of the bounding rectangle
   int            get_ymin(void) const;
      /** Returns xmax of the bounding rectangle. In other words, if #X# is
        a coordinate of the last point in the right direction, the
        function will return #X+1# */
   int            get_xmax(void) const;
      /** Returns xmax of the bounding rectangle. In other words, if #Y# is
        a coordinate of the last point in the top direction, the
        function will return #Y+1# */
   int            get_ymax(void) const;
      /// Returns the hyperlink bounding rectangle
   GRect    get_bound_rect(void) const;
      /** Moves the hyperlink along the given vector. Is used by the
        hyperlinks editor. */
   void           move(int dx, int dy);
      /** Resizes the hyperlink to fit new bounding rectangle while
        keeping the (xmin, ymin) points at rest. */
   void           resize(int new_width, int new_height);
      /** Transforms the hyperlink to be within the specified rectangle */
   void           transform(const GRect & grect);
      /** Checks if the object is OK. Especially useful with \Ref{GMapPoly}
        where edges may intersect. If there is a problem it returns a
        string describing it. */
   char const *   const check_object(void);
      /** Stores the contents of the hyperlink object in a lisp-like format
        for saving into #ANTa# chunk (see \Ref{DjVuAnno}) */
   GUTF8String    print(void);

   virtual GUTF8String get_xmltag(const int height) const=0;

      /// Virtual function returning the shape type.
00251    virtual MapAreaType const get_shape_type( void ) const { return UNKNOWN; };
      /// Virtual function returning the shape name.
   virtual char const * const get_shape_name(void) const=0;
      /// Virtual function generating a copy of this object
   virtual GP<GMapArea> get_copy(void) const=0;
      /// Virtual function generating a list of defining coordinates
      /// (default are the opposite corners of the enclosing rectangle)
   virtual void get_coords( GList<int> & CoordList ) const;
   /// Virtual function maps maparea from one area to another using mapper
   virtual void map(GRectMapper &mapper)=0;
   /// Virtual function unmaps maparea from one area to another using mapper
   virtual void unmap(GRectMapper &mapper)=0;

protected:
   virtual int          gma_get_xmin(void) const=0;
   virtual int          gma_get_ymin(void) const=0;
   virtual int          gma_get_xmax(void) const=0;
   virtual int          gma_get_ymax(void) const=0;
   virtual void         gma_move(int dx, int dy)=0;
   virtual void         gma_resize(int new_width, int new_height)=0;
   virtual void         gma_transform(const GRect & grect)=0;
   virtual bool         gma_is_point_inside(const int x, const int y) const=0;
   virtual char const * const gma_check_object(void) const=0;
   virtual GUTF8String  gma_print(void)=0;
   
   void           clear_bounds(void) { bounds_initialized=0; }
private:
   int            xmin, xmax, ymin, ymax;
   bool           bounds_initialized;

   void           initialize_bounds(void);
};

// ---------- GMAPRECT ---------

/** Implements rectangular map areas. This is the only kind of map areas
    supporting #SHADOW_IN_BORDER#, #SHADOW_OUT_BORDER#, #SHADOW_EIN_BORDER#
    and #SHADOW_EOUT_BORDER# types of border and area highlighting. */

00290 class GMapRect: public GMapArea
{
protected:
   GMapRect(void);
   GMapRect(const GRect & rect);
public:
   /// Default creator.
00297    static GP<GMapRect> create(void) {return new GMapRect();}
   /// Create with the specified GRect.
00299    static GP<GMapRect> create(const GRect &rect) {return new GMapRect(rect);}

   virtual ~GMapRect();

      /// Returns the width of the rectangle
00304    int            get_width(void) const { return xmax-xmin; }
      /// Returns the height of the rectangle
00306    int            get_height(void) const { return ymax-ymin; }

      /// Changes the #GMapRect#'s geometry
   GMapRect & operator=(const GRect & rect);

      /// Returns \Ref{GRect} describing the map area's rectangle
   operator GRect(void);
   
   virtual GUTF8String get_xmltag(const int height) const;
      /// Returns MapRect
00316    virtual MapAreaType const get_shape_type( void ) const { return RECT; };
      /// Returns #"rect"#
   virtual char const * const get_shape_name(void) const;
      /// Returns a copy of the rectangle
   virtual GP<GMapArea> get_copy(void) const;
      /// Virtual function maps rectangle from one area to another using mapper
   virtual void map(GRectMapper &mapper);
      /// Virtual function unmaps rectangle from one area to another using mapper
   virtual void unmap(GRectMapper &mapper);
protected:
   int                  xmin, ymin, xmax, ymax;
   virtual int          gma_get_xmin(void) const;
   virtual int          gma_get_ymin(void) const;
   virtual int          gma_get_xmax(void) const;
   virtual int          gma_get_ymax(void) const;
   virtual void         gma_move(int dx, int dy);
   virtual void         gma_resize(int new_width, int new_height);
   virtual void         gma_transform(const GRect & grect);
   virtual bool         gma_is_point_inside(const int x, const int y) const;
   virtual char const * const gma_check_object(void) const;
   virtual GUTF8String  gma_print(void);
};

// ---------- GMAPPOLY ---------

/** Implements polygonal map areas. The only supported types of border
    are #NO_BORDER#, #XOR_BORDER# and #SOLID_BORDER#. Its contents can not
    be highlighted either. It's worth mentioning here that despite its
    name the polygon may be open, which basically makes it a broken line.
    This very specific mode is used by the hyperlink editor when creating
    the polygonal hyperlink. */

00348 class GMapPoly : public GMapArea
{
protected:
   GMapPoly(void);
   GMapPoly(const int * xx, const int * yy, int points, bool open=false);
public:
   /// Default creator
00355    static GP<GMapPoly> create(void) {return new GMapPoly();}

   /// Create from specified coordinates.
00358    static GP<GMapPoly> create(
     const int xx[], const int yy[], const int points, const bool open=false)
   {return new GMapPoly(xx,yy,points,open);}

   /// Virtual destructor.
   virtual ~GMapPoly();

      /// Returns 1 if side #side# crosses the specified rectangle #rect#.
   bool           does_side_cross_rect(const GRect & grect, int side);

      /// Returns the number of vertices in the polygon
   int            get_points_num(void) const;

      /// Returns the number sides in the polygon
   int            get_sides_num(void) const;

      /// Returns x coordinate of vertex number #i#
   int            get_x(int i) const;
   
      /// Returns y coordinate of vertex number #i#
   int            get_y(int i) const;

      /// Moves vertex #i# to position (#x#, #y#)
   void           move_vertex(int i, int x, int y);

      /// Adds a new vertex and returns number of vertices in the polygon
   int      add_vertex(int x, int y);

      /// Closes the polygon if it is not closed
   void     close_poly();
      /// Optimizes the polygon 
   void           optimize_data(void);
      /// Checks validity of the polygon 
   char const * const   check_data(void);

   virtual GUTF8String get_xmltag(const int height) const;
      /// Returns MapPoly
00395    virtual MapAreaType const get_shape_type( void ) const { return POLY; };
      /// Returns #"poly"# all the time
   virtual char const * const       get_shape_name(void) const;
      /// Returns a copy of the polygon
   virtual GP<GMapArea> get_copy(void) const;
      /// Virtual function generating a list of defining coordinates
   void get_coords( GList<int> & CoordList ) const;
      /// Virtual function maps polygon from one area to another using mapper
   virtual void map(GRectMapper &mapper);
   /// Virtual function unmaps polygon from one area to another using mapper
   virtual void unmap(GRectMapper &mapper);
protected:
   virtual int          gma_get_xmin(void) const;
   virtual int          gma_get_ymin(void) const;
   virtual int          gma_get_xmax(void) const;
   virtual int          gma_get_ymax(void) const;
   virtual void         gma_move(int dx, int dy);
   virtual void         gma_resize(int new_width, int new_height);
   virtual void         gma_transform(const GRect & grect);
   virtual bool         gma_is_point_inside(const int x, const int y) const;
   virtual char const * const gma_check_object(void) const;
   virtual GUTF8String  gma_print(void);
private:
   bool           open;
   int            points, sides;
   GTArray<int>   xx, yy;
   static int     sign(int x);
   static bool    is_projection_on_segment(int x, int y, int x1, int y1, int x2, int y2);
   static bool    do_segments_intersect(int x11, int y11, int x12, int y12,
                              int x21, int y21, int x22, int y22);
   static bool    are_segments_parallel(int x11, int y11, int x12, int y12,
                              int x21, int y21, int x22, int y22);
};

// ---------- GMAPOVAL ---------

/** Implements elliptical map areas. The only supported types of border
    are #NO_BORDER#, #XOR_BORDER# and #SOLID_BORDER#. Its contents can not
    be highlighted either. */

00435 class GMapOval: public GMapArea
{
protected:
   GMapOval(void);
   GMapOval(const GRect & rect);
public:
   /// Default creator.
00442    static GP<GMapOval> create(void) {return new GMapOval();}

   /// Create from the specified GRect.
00445    static GP<GMapOval> create(const GRect &rect) {return new GMapOval(rect);}

   /// Virtual destructor. 
   virtual ~GMapOval();

      /// Returns (xmax-xmin)/2
   int            get_a(void) const;
      /// Returns (ymax-ymin)/2
   int            get_b(void) const;
      /// Returns the lesser of \Ref{get_a}() and \Ref{get_b}()
   int            get_rmin(void) const;
      /// Returns the greater of \Ref{get_a}() and \Ref{get_b}()
   int            get_rmax(void) const;

   virtual GUTF8String get_xmltag(const int height) const;
      /// Returns MapOval
00461    virtual MapAreaType const get_shape_type( void ) const { return OVAL; };
      /// Returns #"oval"#
   virtual char const * const get_shape_name(void) const;
      /// Returns a copy of the oval
   virtual GP<GMapArea> get_copy(void) const;
      /// Virtual function maps oval from one area to another using mapper
   virtual void map(GRectMapper &mapper);
      /// Virtual function unmaps oval from one area to another using mapper
   virtual void unmap(GRectMapper &mapper);
protected:
   virtual int          gma_get_xmin(void) const;
   virtual int          gma_get_ymin(void) const;
   virtual int          gma_get_xmax(void) const;
   virtual int          gma_get_ymax(void) const;
   virtual void         gma_move(int dx, int dy);
   virtual void         gma_resize(int new_width, int new_height);
   virtual void         gma_transform(const GRect & grect);
   virtual bool         gma_is_point_inside(const int x, const int y) const;
   virtual char const * const gma_check_object(void) const;
   virtual GUTF8String  gma_print(void);
private:
   int            rmax, rmin;
   int            a, b;
   int            xf1, yf1, xf2, yf2;
   int            xmin, ymin, xmax, ymax;
   
   void           initialize(void);
};

inline
00491 GMapRect::operator GRect(void)
{
  return GRect(xmin, ymin, xmax-xmin, ymax-ymin);
}

inline int
GMapRect::gma_get_xmin(void) const { return xmin; }

inline int
GMapRect::gma_get_ymin(void) const { return ymin; }

inline int
GMapRect::gma_get_xmax(void) const { return xmax; }

inline int
GMapRect::gma_get_ymax(void) const { return ymax; }

inline char const * const
GMapRect::gma_check_object(void)  const{ return ""; }

inline char const * const 
00512 GMapRect::get_shape_name(void) const { return RECT_TAG; }

inline int
00515 GMapPoly::get_points_num(void) const { return points; }

inline int
00518 GMapPoly::get_sides_num(void) const { return sides; }

inline int
00521 GMapPoly::get_x(int i) const { return xx[i]; }

inline int
00524 GMapPoly::get_y(int i) const { return yy[i]; }

inline char const * const
00527 GMapPoly::get_shape_name(void) const { return POLY_TAG; }

inline int
00530 GMapOval::get_a(void) const { return a; }

inline int
00533 GMapOval::get_b(void) const { return b; }

inline int
00536 GMapOval::get_rmin(void) const { return rmin; }

inline int
00539 GMapOval::get_rmax(void) const { return rmax; }

inline int
GMapOval::gma_get_xmin(void) const { return xmin; }

inline int
GMapOval::gma_get_ymin(void) const { return ymin; }

inline int
GMapOval::gma_get_xmax(void) const { return xmax; }

inline int
GMapOval::gma_get_ymax(void) const { return ymax; }

inline char const * const
00554 GMapOval::get_shape_name(void) const { return OVAL_TAG; }

//@}


#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
#endif

Generated by  Doxygen 1.6.0   Back to index