//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, either Version 2 of the license,
//C- or (at your option) any later version. 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 from
//C- Lizardtech Software. Lizardtech Software has authorized us to
//C- replace the original DjVu(r) Reference Library notice by the following
//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.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, either Version 2 of the license,
//C- | or (at your option) any later version. 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- +------------------------------------------------------------------
#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>
*/
//@{
// ---------- 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}
*/
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. */
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} */
GUTF8String target;
/** Comment (displayed in a status line or as a popup hint when
the mouse pointer moves over the map area */
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} */
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. */
bool border_always_visible;
/// Border color (when relevant) in #0x00RRGGBB# format
unsigned long int border_color;
/// Border width in pixels
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. */
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.
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. */
class GMapRect: public GMapArea
{
protected:
GMapRect(void);
GMapRect(const GRect & rect);
public:
/// Default creator.
static GP<GMapRect> create(void) {return new GMapRect();}
/// Create with the specified GRect.
static GP<GMapRect> create(const GRect &rect) {return new GMapRect(rect);}
virtual ~GMapRect();
/// Returns the width of the rectangle
int get_width(void) const { return xmax-xmin; }
/// Returns the height of the rectangle
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
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. */
class GMapPoly : public GMapArea
{
protected:
GMapPoly(void);
GMapPoly(const int * xx, const int * yy, int points, bool open=false);
public:
/// Default creator
static GP<GMapPoly> create(void) {return new GMapPoly();}
/// Create from specified coordinates.
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
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. */
class GMapOval: public GMapArea
{
protected:
GMapOval(void);
GMapOval(const GRect & rect);
public:
/// Default creator.
static GP<GMapOval> create(void) {return new GMapOval();}
/// Create from the specified GRect.
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
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
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
GMapRect::get_shape_name(void) const { return RECT_TAG; }
inline int
GMapPoly::get_points_num(void) const { return points; }
inline int
GMapPoly::get_sides_num(void) const { return sides; }
inline int
GMapPoly::get_x(int i) const { return xx[i]; }
inline int
GMapPoly::get_y(int i) const { return yy[i]; }
inline char const * const
GMapPoly::get_shape_name(void) const { return POLY_TAG; }
inline int
GMapOval::get_a(void) const { return a; }
inline int
GMapOval::get_b(void) const { return b; }
inline int
GMapOval::get_rmin(void) const { return rmin; }
inline int
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
GMapOval::get_shape_name(void) const { return OVAL_TAG; }
//@}
#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
#endif