• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

kviewshell

GMapAreas.h

Go to the documentation of this file.

//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_15 $

#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




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

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

   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 };

   GUTF8String  url;
   GUTF8String  target;
   GUTF8String  comment;
   BorderType   border_type;
   bool     border_always_visible;
   unsigned long int    border_color;
   int      border_width;
   unsigned long int    hilite_color;

   bool     is_point_inside(int x, int y) const;

   int      get_xmin(void) const;
   int      get_ymin(void) const;
   int      get_xmax(void) const;
   int      get_ymax(void) const;
   GRect    get_bound_rect(void) const;
   void     move(int dx, int dy);
   void     resize(int new_width, int new_height);
   void     transform(const GRect & grect);
   char const * const check_object(void);
   GUTF8String  print(void);

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

   virtual MapAreaType const get_shape_type( void ) const { return UNKNOWN; };
   virtual char const * const   get_shape_name(void) const=0;
   virtual GP<GMapArea> get_copy(void) const=0;
   virtual void get_coords( GList<int> & CoordList ) const;
   virtual void map(GRectMapper &mapper)=0;
   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 ---------

class GMapRect: public GMapArea
{
protected:
   GMapRect(void);
   GMapRect(const GRect & rect);
public:
   static GP<GMapRect> create(void) {return new GMapRect();}
   static GP<GMapRect> create(const GRect &rect) {return new GMapRect(rect);}

   virtual ~GMapRect();

   int      get_width(void) const { return xmax-xmin; }
   int      get_height(void) const { return ymax-ymin; }

   GMapRect & operator=(const GRect & rect);

   operator GRect(void);
   
   virtual GUTF8String get_xmltag(const int height) const;
   virtual MapAreaType const get_shape_type( void ) const { return RECT; };
   virtual char const * const   get_shape_name(void) const;
   virtual GP<GMapArea> get_copy(void) const;
   virtual void map(GRectMapper &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 ---------

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

   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 ~GMapPoly();

   bool     does_side_cross_rect(const GRect & grect, int side);

   int      get_points_num(void) const;

   int      get_sides_num(void) const;

   int      get_x(int i) const;
   
   int      get_y(int i) const;

   void     move_vertex(int i, int x, int y);

   int      add_vertex(int x, int y);

   void     close_poly();
   void     optimize_data(void);
   char const * const   check_data(void);

   virtual GUTF8String get_xmltag(const int height) const;
   virtual MapAreaType const get_shape_type( void ) const { return POLY; };
   virtual char const * const   get_shape_name(void) const;
   virtual GP<GMapArea> get_copy(void) const;
   void get_coords( GList<int> & CoordList ) const;
   virtual void map(GRectMapper &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 ---------

class GMapOval: public GMapArea
{
protected:
   GMapOval(void);
   GMapOval(const GRect & rect);
public:
   static GP<GMapOval> create(void) {return new GMapOval();}

   static GP<GMapOval> create(const GRect &rect) {return new GMapOval(rect);}

   virtual ~GMapOval();

   int      get_a(void) const;
   int      get_b(void) const;
   int      get_rmin(void) const;
   int      get_rmax(void) const;

   virtual GUTF8String get_xmltag(const int height) const;
   virtual MapAreaType const get_shape_type( void ) const { return OVAL; };
   virtual char const * const get_shape_name(void) const;
   virtual GP<GMapArea> get_copy(void) const;
   virtual void map(GRectMapper &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

kviewshell

Skip menu "kviewshell"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members

API Reference

Skip menu "API Reference"

• kviewshell

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal