include/sgp.h

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **      Name:         sgp.h
   5 **      Purpose:      Header file for Simple Graphics Package
   6 **      Author:       Kevin Rosenberg
   7 **      Date Started: 1984
   8 **
   9 **  This is part of the CTSim program
  10 **  Copyright (C) 1983-2000 Kevin Rosenberg
  11 **
  12 **  $Id: sgp.h,v 1.22 2000/12/16 06:12:47 kevin Exp $
  13 **
  14 **  This program is free software; you can redistribute it and/or modify
  15 **  it under the terms of the GNU General Public License (version 2) as
  16 **  published by the Free Software Foundation.
  17 **
  18 **  This program is distributed in the hope that it will be useful,
  19 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 **  GNU General Public License for more details.
  22 **
  23 **  You should have received a copy of the GNU General Public License
  24 **  along with this program; if not, write to the Free Software
  25 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26 ******************************************************************************/
  27
  28 #ifndef __H_SGP
  29 #define __H_SGP
  30
  31 #if HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #include "transformmatrix.h"
  36
  37 #ifdef HAVE_WXWINDOWS
  38 #include <wx/wx.h>
  39 #include <wx/font.h>
  40 #endif
  41
  42 #if HAVE_G2_H
  43 extern "C" {
  44 #include "g2.h"
  45 #include "g2_X11.h"
  46 }
  47 #endif
  48
  49 #include <string>
  50
  51 class SGPDriver {
  52 private:
  53   int m_iPhysicalXSize;
  54   int m_iPhysicalYSize;
  55   std::string m_sWindowTitle;
  56   int m_idDriver;
  57
  58 #ifdef HAVE_WXWINDOWS
  59   wxDC* m_pDC;
  60 #endif
  61   int m_idG2;
  62
  63 public:
  64   enum {
  65     SGPDRIVER_WXWINDOWS = 1,
  66     SGPDRIVER_G2 = 2,
  67     SGPDRIVER_OPENGL = 4,
  68   };
  69
  70 #ifdef HAVE_WXWINDOWS
  71   SGPDriver (wxDC* pDC, int xsize = 640, int ysize = 480);
  72 #endif
  73
  74   SGPDriver (const char* szWinTitle = "", int xsize = 640, int ysize = 480);
  75
  76   ~SGPDriver ();
  77
  78   int getPhysicalXSize () const
  79     { return m_iPhysicalXSize; }
  80
  81   int getPhysicalYSize () const
  82     { return m_iPhysicalYSize; }
  83
  84   const std::string& getWindowTitle () const
  85     { return m_sWindowTitle; }
  86
  87   bool isWX () const
  88   { return (m_idDriver & SGPDRIVER_WXWINDOWS ? true : false); }
  89
  90   bool isG2 () const
  91   { return (m_idDriver & SGPDRIVER_G2 ? true : false); }
  92
  93   int idG2 () const
  94     { return m_idG2; }
  95
  96 #ifdef HAVE_WXWINDOWS
  97   wxDC* idWX () const
  98     { return m_pDC; }
  99
 100   void setDC (wxDC* dc)
 101       { m_pDC = dc; }
 102 #endif
 103 };
 104
 105
 106 class RGBColor;
 107 class SGP {
 108 private:
 109   int m_iPhysicalXSize;   // Physical Window size
 110   int m_iPhysicalYSize;
 111   SGPDriver m_driver;
 112
 113   double xw_min;    // Window extents
 114   double yw_min;
 115   double xw_max;
 116   double yw_max;
 117   double xv_min;    // Viewport extents
 118   double yv_min;
 119   double xv_max;
 120   double yv_max;
 121   double viewNDC[4];   // Viewport array for clip_rect()
 122
 123   int m_iCurrentPhysicalX;
 124   int m_iCurrentPhysicalY;
 125   double m_dCurrentWorldX;
 126   double m_dCurrentWorldY;
 127   double m_dTextAngle;
 128   bool m_bRecalcTransform;
 129   double m_dPointsPerPixel;  // points (72pt/in) per screen pixel;
 130
 131   // Master coordinates are coordinates before CTM transformation
 132   // World coordinates are coordinates defined by setWindow()
 133   // Normalized device coordinates range from 0. to 1. in both axes
 134   TransformationMatrix2D wc_to_ndc;     // World coord to NDC matrix
 135   TransformationMatrix2D mc_to_ndc;     // Master to NDC
 136   TransformationMatrix2D ndc_to_mc;     // NDC to Master
 137   TransformationMatrix2D m_ctm;         // Current transfromation matrix
 138
 139   void calc_transform ();
 140
 141   static RGBColor s_aRGBColor[];
 142   static int s_iRGBColorCount;
 143
 144 #if HAVE_WXWINDOWS
 145   wxPen m_pen;
 146   wxFont m_font;
 147 #endif
 148
 149 public:
 150   enum {                  // linestyles
 151       LS_NOLINE = 0,
 152       LS_SOLID = 0xffff,
 153       LS_DASH1 = 0xff00,
 154       LS_DASH2 = 0xf0f0,
 155       LS_DASH3 = 0xcccc,
 156       LS_DASH4 = 0xff3e,
 157       LS_DOTTED = 0xaaaa,
 158   };
 159
 160   enum {            // Codes for marker symbols
 161       MARK_POINT = 0,   // small dot
 162       MARK_SQUARE = 1,  // empty square
 163       MARK_FSQUARE = 2, // filled square
 164       MARK_DIAMOND = 3, // empty diamond
 165       MARK_FDIAMOND = 4,        // filled diamond
 166       MARK_CROSS =  5,  // cross
 167       MARK_XCROSS = 6,  // x
 168       MARK_CIRCLE = 7,    // open circle
 169       MARK_FCIRCLE = 8, // filled circle
 170       MARK_BSQUARE = 9, // big open square
 171       MARK_BDIAMOND = 10,       // big open diamond
 172   };
 173   enum  { MARK_COUNT = 11, };
 174   static const unsigned char MARKER_BITMAP[MARK_COUNT][5];
 175
 176   SGP (const SGPDriver& driver);
 177
 178   void drawCircle (const double r);
 179   void drawArc (const double r, double start, double stop);
 180   void drawRect (double xmin, double ymin, double xmax, double ymax);
 181   void lineAbs(double x, double y);
 182   void moveAbs(double x, double y);
 183   void lineRel(double x, double y);
 184   void moveRel(double x, double y);
 185   void drawText(const char *szMessage);
 186   void drawText(const std::string& rsMessage);
 187   void polylineAbs(double x[], double y[], int n);
 188   void markerAbs (double x, double y);
 189   void markerRel(double x, double y);
 190   void pointAbs(double x, double y);
 191   void pointRel(double x, double y);
 192
 193   void eraseWindow ();
 194   void setWindow (double xmin, double ymin, double xmax, double ymax);
 195   void setViewport (double xmin, double ymin, double xmax, double ymax);
 196   void frameViewport();
 197
 198   void setColor (int icol);
 199   void setLineStyle (int style);
 200   void setTextSize (double height);
 201   void setTextNDCSize (double height);
 202   void setTextPointSize (double height);
 203   void setTextAngle (double angle);
 204   void setTextColor (int iFGcolor, int iBGcolor);
 205   void setPenWidth (int width);
 206   void setMarker (int idMarker, int color);
 207   void setRasterOp (int ro);
 208
 209   void getWindow (double& xmin, double& ymin, double& xmax, double& ymax);
 210   void getViewport (double& xmin, double& ymin, double& xmax, double& ymax);
 211   void getTextExtent (const char *szText, double* x, double* y);
 212   double getCharHeight ();
 213   double getCharWidth ();
 214   SGPDriver& getDriver() {return m_driver;}
 215   const SGPDriver& getDriver() const {return m_driver;}
 216
 217   void ctmClear ();
 218   void ctmSet (const TransformationMatrix2D& m);
 219   void preTranslate (double x, double y);
 220   void postTranslate (double x, double y);
 221   void preScale (double sx, double sy);
 222   void postScale (double sx, double sy);
 223   void preRotate (double theta);
 224   void postRotate (double theta);
 225   void preShear (double shrx, double shry);
 226   void postShear (double shrx, double shry);
 227   void transformNDCtoMC (double* x, double* y);
 228   void transformMCtoNDC (double* x, double* y);
 229   void transformMCtoNDC (double xIn, double yIn, double* xOut, double* yOut);
 230
 231   void stylusNDC (double x, double y, bool beam);
 232   void pointNDC (double x, double y);
 233   void markerNDC (double x, double y);
 234
 235 #if HAVE_WXWINDOWS
 236   void setDC (wxDC* pDC);
 237 #endif
 238 };
 239
 240
 241 enum {
 242     C_BLACK     = 0,     // color codes
 243     C_BLUE      = 1,
 244     C_GREEN     = 2,
 245     C_CYAN      = 3,
 246     C_RED       = 4,
 247     C_MAGENTA   = 5,
 248     C_BROWN     = 6,
 249     C_GRAY      = 7,
 250     C_LTGRAY    = 8,
 251     C_LTBLUE    = 9,
 252     C_LTGREEN   = 10,
 253     C_LTCYAN    = 11,
 254     C_LTRED     = 12,
 255     C_LTMAGENTA = 13,
 256     C_YELLOW    = 14,
 257     C_WHITE     = 15,
 258 };
 259
 260 enum RasterOp {
 261     RO_AND = 1,
 262     RO_AND_INVERT,
 263     RO_AND_REVERSE,
 264     RO_CLEAR,
 265     RO_COPY,
 266     RO_EQUIV,
 267     RO_INVERT,
 268     RO_NAND,
 269     RO_NOR,
 270     RO_NO_OP,
 271     RO_OR,
 272     RO_OR_INVERT,
 273     RO_OR_REVERSE,
 274     RO_SET,
 275     RO_SRC_INVERT,
 276     RO_XOR,
 277 };
 278
 279
 280 class RGBColor {
 281  private:
 282   short int r;
 283   short int g;
 284   short int b;
 285
 286  public:
 287   RGBColor (int r, int g, int b)
 288     : r(r), g(g), b(b)
 289     {}
 290
 291   int getRed () const
 292     { return r; }
 293
 294   int getGreen () const
 295     { return g; }
 296
 297   int getBlue () const
 298     { return b; }
 299
 300 };
 301
 302 #endif