mi32/pdf.h

Go to the documentation of this file.

/*****************************************************************************
 * mi32/pdf.h
 *
 * PDF class
 *
 * $Log: pdf.h_v $
 * Revision 1.18  2011/12/02 19:14:31  ldyas
 * dont use pointer for m_target
 *
 * Revision 1.17  2011/12/02 15:55:46  mju
 * Don't use pointer for m_title.
 * Add forward decl so compiles in isolation.
 *
 * Revision 1.16  2011/10/05 20:22:32  mju
 * Remove obsolete fn.
 *
 * Revision 1.15  2011/05/20 17:10:43  ldyas
 * removed body to pdf.c
 *
 * Revision 1.14  2009/01/13 17:33:28  ldyas
 * changed default on embedding fonts.
 *
 * Revision 1.13  2009/01/09 19:57:04  ldyas
 * Create method called automatically if you write layout.
 *
 * Revision 1.10  2009/01/09 16:54:21  ldyas
 * do not set embed fonts to the inverse of renderfonts.
 *
 * Revision 1.9  2009/01/08 23:11:15  ldyas
 * giving embedfonts and renderfonts defaults .
 *
 * Revision 1.8  2009/01/08 22:15:40  ldyas
 * new restructuring enables multi use of device...
 *
 * Revision 1.7  2008/11/21 20:53:25  bcolombe
 * Class member variables need to be initialized in the constructor !!11
 *
 * Revision 1.6  2008/06/30 19:37:00  ldyas
 * scale zero width lines control
 *
 * Revision 1.5  2008/05/13 20:44:56  ldyas
 * added layer visibility flag.
 *
 * Revision 1.2  2008/04/23 21:53:55  ldyas
 * added font controls
 *
 * Revision 1.1  2008/04/10 16:25:19  ldyas
 * Initial revision
 *
**/

#ifndef INC_PDF_H
#define INC_PDF_H

#ifndef  INC_GRE_BASE_H
#include <gre/base.h>
#endif

#ifndef  INC_FILEPATH_H
#include <mi32/filepath.h>
#endif

#ifndef  INC_MI32_ELEMSTYL_H
#include <mi32/elemstyl.h>
#endif

#ifndef  INC_MI32_ELEMTYPE_H
#include <mi32/elemtype.h>
#endif

#ifndef  INC_MI32_STRUTF8_H
#include <mi32/strutf8.h>
#endif

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class XMLNODE;
namespace MGD {
   class DEVICE_PDF;
   class DEVICE_PDF2;
   }
namespace RVC {
   class OBJITEM;
   }
#endif


class PDF {
   public:

      // Constructor.  Constructs an empty object
      PDF () :
         m_zoom(1.0),
         m_bZoomDefined(false),
         m_bUsingFirstView(false),
         m_bSuppressResultTime(false),
         m_bViewCenterSet(false),
         m_JPEGQuality(100),
         m_Color(255*255,255*255,255*255), 
         m_Margin(0,0),
         m_compress(9),
         m_bEmbedFonts(false),
         m_bSubstituteCourier(true),
         m_bRenderFonts(false),
         m_bScaleZeroWidth(false),
         m_width(8.5),
         m_height(0),
         m_dpi(0),
         m_accuracy(0),
         m_reference(0),
         m_bIsCreated(false)
         { }

      //constructs a pdf document based on a layout.
      PDF ( 
         const GRE::LAYOUT& layout
         );

      // Copy constructor. 
      // Note, copy constructor is expensive.  It has to copy the whole
      // document tree in memory.
      PDF (
         const PDF&
         );
         
      ~PDF ();
      
      void Clear();

      ERRVALUE CreateStyle (
         const XMLNODE* node,
         POINTSTYLE& pointstyle,
         POLYSTYLE& polygonstyle,
         LINESTYLE& linestyle
         );

      ERRVALUE Create (); 

      void Finish();

      int GetResolution (
         ) { return m_dpi; }

      void SetHighlightColor (
         const COLOR& color
         ) { m_HighlightColor = color;}

      void GetHighlightColor (
         COLOR& color
         ) {
         color = m_Color;
         }

      void SetBackgroundColor (
         COLOR color
         ) { m_Color = color; }

      void SetResolution (
         int dpi
         ) { m_dpi = dpi; }

      void SetAccuracy (
         double accuracy
         ) { m_accuracy = accuracy; }

      void SetSupressResultTime (
         bool suppress
         ) {m_bSuppressResultTime = suppress; }

      // Import --> not yet implemented---------------
      ERRVALUE Read (
         const FILEPATH& filepath
         );
      ERRVALUE Read (
         const MIUNICODE* filename
         ) {
         return (Read(FILEPATH(filename)));
         }

      void SetCenter (
         const DPOINT2D center
         ) {
         m_centerpoint = center;
         m_bViewCenterSet = true;
         }

      void SetHeight (
         DOUBLE height
         ) { m_height = height; }
 

      DOUBLE GetHeight (
         ) { return(m_height); }

      void SetPosn (
         const DPOINT2D& CenterPoint,
         double zoom
         ) {
         m_bViewCenterSet = true;
         m_centerpoint = CenterPoint;
         m_zoom = zoom;
         }

      void SetPath (
         FILEPATH* name
         ) { if (name != 0) m_target = *name; else m_target.Clear(); }

      void GetPath (
         FILEPATH& filepath
         ) { filepath = m_target; }
      
      void SetUsingFirstView (
         bool useview
         ) {
         m_bUsingFirstView = useview;
         }

      bool GetUsingFirstView (
         ) {
         return(m_bUsingFirstView);
         }

      void SetViewIndex (
         int viewnum
         ) {
         m_reference = viewnum;
         }


      void SetWidth (
         DOUBLE width
         ) { m_width = width; }

      DOUBLE GetWidth (
         ) { return(m_width); }

      void SetZoom (
         DPOINT2D zoom
         ) { m_zoom = MIN(zoom.x,zoom.y) ; }

      void SetZoom (
         DOUBLE zoom
         ) { m_zoom = zoom; }

      void SetTitle (
         const MISTRING* name
         ) { if (name != 0) m_title = *name; else m_title.Clear(); }

      void GetTitle (
         MISTRING& name
         ) { name = m_title; }

      void GetMargin (
         DPOINT2D& margin
         ) {
         margin = m_Margin; }

      void EmbedFonts (
         bool embed = true
         ) { 
         m_bEmbedFonts = embed; 
         m_bRenderFonts = false; 
         }

      void SubstituteCourier (
         bool subcourier
         ) {
         m_bSubstituteCourier = subcourier;
         }
            
      void SetScaleZeroWidth (
         bool scalezero
         ) {
         m_bScaleZeroWidth = scalezero;
         }

      void RenderFonts (
         bool render = true
         ) {
         m_bRenderFonts = render;
         m_bEmbedFonts = false;
         }
      
      ERRVALUE Compare( // not implemented yet
         const STRUTF8& str,
         const FILEPATH& file
         );

      //Write from and rvc layout object to an PDF
      //PDF must have already been created.
      ERRVALUE Write (
         FILEPATH* filepath
         );

      ERRVALUE WriteToFile( 
         const FILEPATH& filepath,
         const STRUTF8& str
         );

      ERRVALUE WriteToFile( 
         const FILEPATH& filepath,
         STRUTF8 *str
         );

      ERRVALUE Write ( 
         );

      ERRVALUE Write (
         const MIUNICODE* filename
         ) {
         FILEPATH path(filename);
         return (Write(&path));
         } 
      
      //write pdf from already open layout
      ERRVALUE WriteFrom (
         GRE::LAYOUT *layout
         );

      ERRVALUE CreateFromLayoutObject (
         const RVC::OBJITEM& ObjItem
         );

      ERRVALUE RenderGroup (
         GRE::GROUP *group
         );

      ERRVALUE WriteFrom ( 
         GRE::GROUP *group
         );

      ERRVALUE MatchExtents ( 
         const DRECT2D extents
         );

      ERRVALUE MatchView(
         const GRE::VIEW *view,
         const GRE::GROUP *GeoRefGroup
         );

      void SetSourceLayout (
         GRE::LAYOUT  *layout
         ) { m_Layout = layout; }

      void SetReferenceViewIndex (
         int index
         ) { m_reference = index; }

      void SetIncludeLayerVisibility(
         bool include
         ) {
         m_bIncludeLayerVisibility = include;
         }

      void SetCompression(
         int val = 9
         ) { m_compress = val; }

      int GetCompression(
         ) { return(m_compress); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      MISTRING m_title;
      MGD::DEVICE_PDF2* m_DevicePDF;
      MGD::DEVICE* Device;
      DOUBLE m_height, m_width; //associated with image size * resolution.
      int m_dpi;
      DOUBLE m_accuracy; //geometric elements.
      FILEPATH m_path;
      int m_JPEGQuality;
      //used when writing based on saved rvc layout
      //when writing from an already opened layout use
      FILEPATH m_src;
      int m_reference;
      int m_compress;
      double m_zoom;
      DPOINT2D m_centerpoint, m_zoomfactor;
      DPOINT2D m_Margin;
      GRE::LAYOUT *m_Layout;

   //writing parameters
      FILEPATH m_target;
      bool m_bZoomDefined;
      bool m_bIncludeLayerVisibility;
      bool m_bSuppressResultTime;
      bool m_bPosnSet;
      bool m_bUsingLayoutObject;
      bool m_bUsingFirstView;
      bool m_bViewCenterSet;
      bool m_bUsingLayoutInode;
      bool m_bUsingLayoutPath;
      bool m_bEmbedFonts;
      bool m_bRenderFonts;
      bool m_bSubstituteCourier;
      bool m_bScaleZeroWidth;
      bool m_bIsCreated;

   //backgroundcolor
      COLOR m_Color;
      COLOR m_HighlightColor;

      ERRVALUE CreateFromLayoutText (
         const FILEPATH& filepath
         );

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

   
#endif

---