Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 565 insertions, 0 deletions

diff --git a/kviewshell/plugins/djvu/libdjvu/GMapAreas.h b/kviewshell/plugins/djvu/libdjvu/GMapAreas.h
new file mode 100644
index 00000000..251427ed
--- /dev/null
+++ b/kviewshell/plugins/djvu/libdjvu/GMapAreas.h
@@ -0,0 +1,565 @@
+//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
+
+
+/** @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}
+*/
+
+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