rvclegnd.h

Go to the documentation of this file.

/**
 * \file rvclegnd.h <mi32/rvclegnd.h>
 * \brief Definitions for RVC LEGEND object structures
 *
 * \if NODOC
 * $Id: rvclegnd.h_v 1.8 2003/09/15 13:49:56 fileserver!dwilliss Exp $
 *
 * $Log: rvclegnd.h_v $
 * Revision 1.8  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.7  2002/08/20 15:06:39  mju
 * Use prevent_memfunc().
 *
 * Revision 1.6  2002/03/08 18:16:24  scowan
 * Added clear and set methods for info structure.
 *
 * Revision 1.5  2000/12/15 16:33:26  msmith
 * Genitor documentation.
 *
 * Revision 1.4  2000/09/01 14:47:44  dwilliss
 * Changed SpareDouble to SampleOffset
 *
 * Revision 1.3  2000/08/11 16:44:37  scowan
 * More const.
 *
 * Revision 1.2  1999/10/05 22:47:16  scowan
 * Changed header to use inheritance.
 *
 * Revision 1.1  1999/05/06 22:15:27  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_RVCLEGND_H
#define  INC_MI32_RVCLEGND_H

#ifndef  INC_MI32_RVCDEFNS_H
   #include <mi32/rvcdefns.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

//! Legend text style structure.
struct RVCLEGENDTEXTSTYLE {
   UINT32 StyleFlags;                  //!< STYLEFLAG_????
   INT32 FontNumber;                   //!< Font
   COLOR FGColor;                      //!< Foreground color
   COLOR BGColor;                      //!< Background color
   FLOAT GlyphRotation;                //!< Rotation of each glyph individually
   FLOAT GlyphAspect;                  //!< Height to width aspect ratio
   FLOAT Shear;                        //!< Italics angle
   FLOAT Height;                       //!< Height of glyph in "HeightUnits"
   FLOAT LineSpace;                    //!< Line spacing in "SpaceUnits"
   UINT32 FontFlags;                   //!< FONTSTYLE_???? or'ed together
   DOUBLE MapScale;                    //!< Map scale
   UNICODE fontname[32];               //!< font name (eg: "SYSTEM.OF")
   UINT16 HeightUnits;                 //!< Units for height (SCREENUNIT_...)
   UINT16 SpaceUnits;                  //!< Units for line spacing (SCREENUNIT_...)
   UINT16 Predefined;                  //!< Predefined label styles
   UINT8 spare[2];
   };

//! Legend Header.
struct RVCLEGENDINFO : public RVCGENLISTINFO {
   DOUBLE MapScale;                    //!< Map scale
   DOUBLE ColSpace;                    //!< Column spacing
   DOUBLE ColWidth;                    //!< Column width
   DOUBLE SampleSpace;                 //!< Sample spacing
   DOUBLE SampleHeight;                //!< Sample height
   DOUBLE SampleWidth;                 //!< Sample width
   DOUBLE LineSpace;                   //!< Line spacing
   DOUBLE SATableNum;                  //!< Table number - Yes, its a double -- don't ask 
   DOUBLE SampleOffset;                //!< Sample offset
   INT32 ContrastType;                 //!< Contrast type
   INT32 SpareLong;                    //!< Reserved
   COLOR BackgroundColor;              //!< Background color
   RVCLEGENDTEXTSTYLE Style[4];        //!< Text style structures
   UINT16 ElementType;                 //!< Element type
   UINT16 version;                     //!< Version
   UINT32 units;                       //!< Units
   UINT32 numcols;                     //!< Number of columns
   UINT32 DispFlags;                   //!< Flags
   COLOR SampleBorderColor;            //!< Sample border color
   COLOR LegendBorderColor;            //!< Legend border color
   DOUBLE SampleBorderWidth;           //!< Sample border width in mm at given MapScale
   DOUBLE LegendBorderWidth;           //!< Legend border width in mm at given MapScale
   DOUBLE MarginWidth;                 //!< Margin width
   DOUBLE MinL;                        //!< Left minimum
   DOUBLE MaxL;                        //!< Left maximum
   DOUBLE MinR;                        //!< Right minimum
   DOUBLE MaxR;                        //!< Right maximum
   UINT32   UMinIndex;                 //!< Minimum index - used to be named MinIndex
   UINT32   UMaxIndex;                 //!< Maximum index - used to be named MaxIndex
   UINT32   NumTicksL;                 //!< Number of ticks left
   UINT32   NumTicksR;                 //!< Number of ticks right
   DOUBLE MinIndex;                    //!< Because MinIndex was unsigned
   DOUBLE MaxIndex;                    //!< Because MaxIndex was unsigned
   
   RVCLEGENDINFO (
      ) {Clear();}
   
   RVCLEGENDINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   //! Assignment operator.
   RVCLEGENDINFO& operator= (
      const RVCGENINFO& ginfo          //!< RVCGENINFO structure to copy from
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}
      
   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
      
   };

PREVENT_MEMFUNC(RVCLEGENDINFO)

//! All list entries in a legend object are a series of UWORDs
//! This structure is used in-memory only
struct RVCLEGENDLINE {
   UINT16 type;                        //!< 1 == normal legend data
   UINT16 flags;                       //!< Flags
   UNICODE *style;                     //!< Style
   UNICODE *heading;                   //!< Heading
   UNICODE *desc;                      //!< Description
   };

#define LEGENDFLAG_Selected      0x01  //!< Draw an entry for this style
#define LEGENDFLAG_DescFromField 0x02  //!< Description just gives table.field
#define LEGENDFLAG_DescQuery     0x04  //!< Description is a string query
#define LEGENDFLAG_DescDQuery    0x08  //!< Get description from default query
#define LEGENDFLAG_DescFromTheme 0x10  //!< Get description from a theme

//! Read legend header.
inline int MfReadLegendHeader (
   int fhandle,                        //!< Open file handle
   RVCINODENUM inode,                  //!< Legend object inode
   RVCLEGENDINFO* info                 //!< Legend header passed / returned
   ) {
   return (_MfReadHeader(fhandle,inode,info,sizeof(RVCLEGENDINFO),RVCCONV_LegendInfo));
   }

//! Write legend header.
inline int MfWriteLegendHeader (
   int fhandle,                        //!< Open file handle
   RVCINODENUM inode,                  //!< Legend object inode
   RVCLEGENDINFO* info                 //!< Legend header to write
   ) {
   return (_MfWriteHeader(fhandle,inode,info,sizeof(RVCLEGENDINFO),RVCCONV_LegendInfo));
   }

#if defined(__cplusplus)
extern "C" {
#endif

//! Legend functions

#ifndef GENERATING_DOXYGEN_OUTPUT

RVCAPPLIBEXPORT int _MfLegendClose (
   int id, 
   RVCLEGENDINFO *info,
   int HeaderSize
   );

RVCAPPLIBEXPORT void _MfLegendFreeLine (
   RVCLEGENDLINE *llp, 
   int LegendSize
   );

RVCAPPLIBEXPORT int _MfLegendMake (
   int fid, 
   RVCLEGENDINFO *info,
   int HeaderSize,
   UINT32 flags
   );

RVCAPPLIBEXPORT int _MfLegendOpen (
   int fid, 
   INT32 inode, 
   RVCLEGENDINFO *info, 
   int HeaderSize, 
   UINT32 flags
   );

RVCAPPLIBEXPORT int _MfLegendRead (
   int id, 
   INT32 num, 
   RVCLEGENDLINE *inllp, 
   int LegendSize
   );

RVCAPPLIBEXPORT int _MfLegendWrite (
   int id, 
   INT32 num, 
   RVCLEGENDLINE *inllp,
   int LegendSize
   );

#endif //!< GENERATING_DOXYGEN_OUTPUT

//! Read a legend into a buffer.
RVCAPPLIBEXPORT int MfReadLegendBuf (
   int id,                             //!< Legend object handle
   INT32 num,                          //!< Item number
   void *buf                           //!< Buffer to read to
   );

//! Write a legend from a buffer.
RVCAPPLIBEXPORT int MfWriteLegendBuf (
   int id,                             //!< Legend object handle
   INT32 num,                          //!< Item number
   INT32 size,                         //!< Size of buffer
   const void *buf                     //!< Buffer to write from
   );

//! Close a legend.
inline int MfCloseLegend (
   int id,                             //!< Legend object handle
   RVCLEGENDINFO *info                 //!< Legend object to close
   ) {
   return _MfLegendClose(id, info, sizeof(RVCLEGENDINFO));
   }

//! Make a legend.
inline int MfMakeLegend (
   int fid,                            //!< Open file handle
   RVCLEGENDINFO *info,                //!< Legend structure passed / returned
   UINT32 flags                        //!< Flags
   ) {
   return _MfLegendMake(fid, info, sizeof(RVCLEGENDINFO), flags);
   }

//! Open a legend.
inline int MfOpenLegend (
   int fid,                            //!< Open file handle
   INT32 inode,                        //!< Legend object inode
   RVCLEGENDINFO *info,                //!< Legend structure passed / returned
   UINT32 flags                        //!< Flags
   ) {
   return _MfLegendOpen(fid, inode, info, sizeof(RVCLEGENDINFO), flags);
   }

//! Read a legend.
inline int MfReadLegend (
   int id,                             //!< Legend object handle
   INT32 num,                          //!< Item number
   RVCLEGENDLINE *inllp                //!< Legend line structure returned
   ) {
   return _MfLegendRead(id, num, inllp, sizeof(RVCLEGENDLINE));
   }

//! Write a legend.
inline int MfWriteLegend (
   int id,                             //!< Legend object handle
   INT32 num,                          //!< Item number
   RVCLEGENDLINE *inllp                //!< Legend line structure to write from
   ) {
   return _MfLegendWrite(id, num, inllp, sizeof(RVCLEGENDLINE));
   }

//! Free a legend.
inline void MfFreeLegendLine (
   RVCLEGENDLINE *llp                  //!< Legend line structure to free
   ) {
   _MfLegendFreeLine(llp, sizeof(RVCLEGENDLINE));
   }

#if defined(__cplusplus)
}
#endif

#endif   //!< INC_MI32_RVCLEGND_H

---