ZBase.H

// ZBase.H
// $Id: ZBase.H,v 1.21 2005/06/14 12:31:03 vlad Exp $

#if !defined __ZBase_H

#define __ZBase_H

#include <stdio.h>
#include <string.h>
#include <malloc.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#ifndef NO_XTOOLKIT
#include <X11/Intrinsic.h>
#endif /* NO_XTOOLKIT */

#include <mix/Exceptions.h>
#include <zm/ZTypes.h>
#include <zm/Zm.h>


/* Forward definitions */
class ZSize;


/*************************************************************
 * Pixel point, place
 *************************************************************/
class ZPoint
{
public:

  int   x;  /* x coord */
  int   y;  /* y coord */

  ZPoint ();
  ZPoint (int x_coord, int y_coord);
  ZPoint (const ZPoint& zpoint);

  operator XPoint () const;

  void  add_offset (const ZSize& zsize);
  void  sub_offset (const ZSize& zsize);

  void  print (const char* szEnd = "\n") const;

  bool  operator== (const ZPoint& zpoint) const;
  bool  operator!= (const ZPoint& zpoint) const;

};


/*************************************************************
 * Pixel size, box with undefined place.  Conversion to
 * XRectangle means: [0,0], [w-1,0], [w-1,h-1], [0,h-1].
 *************************************************************/
class ZSize
{
public:

  int   w;  /* width */
  int   h;  /* height */

  ZSize ();
  ZSize (int width, int height);
  ZSize (const ZSize& zsize);

  virtual Logic inside (const ZPoint& zpoint) const;
  virtual   operator XRectangle () const;

  void  difference (const ZPoint& zpoint1, const ZPoint& zpoint2);

  void  print (const char* szEnd = "\n") const;

  bool  operator== (const ZSize& zsize) const;
  bool  operator!= (const ZSize& zsize) const;

};


/*************************************************************
 * Real box, rectangle.  Corners has the next coords: [x,y],
 * [x+w-1,y], [x+w-1,y+h-1], [x,y+h-1].
 *************************************************************/

class ZRect : public ZPoint, public ZSize
{
public:

  ZRect ();
  ZRect (const ZPoint& zpoint1, const ZPoint& zpoint2);
  ZRect (const ZPoint& zpoint, const ZSize& zsize,
     ZCorner zcorner = zcLeftTop);
  ZRect (const ZRect& zrect);

  /* Changes coords of rectangle to place zpoint, where
     zpoint in zcorner of virtual box */
  virtual void  move (const ZPoint& zpoint,
              ZCorner zcorner = zcLeftTop);

  /* Returns TRUE if zpoint is inside rectangle or on its border */
  virtual Logic inside (const ZPoint& zpoint) const;

  virtual   operator XRectangle () const;

  void  print (const char* szEnd = "\n") const;

  bool  operator== (const ZRect& zrect) const;
  bool  operator!= (const ZRect& zrect) const;

};


/*************************************************************
 * Link with X server
 *************************************************************/
class ZConnect
{
public:

  Display   *dpy;       /* Display connection */
  ScreenNo  scr_no;     /* Screen on display */

  ZConnect (Display* display);
  ZConnect (const ZConnect& zconnect);

  void  flush ();       /* Performs XFlush(dpy) */

  /* X Errors handler and exeption generator */
  void  x_error (int code) const;

  /* Returns ZRect of drawable */
  ZRect     rect (Drawable drawable) const;

  /* Returns ZRect of root window */
  virtual ZRect rect () const;

  /* Returns depth of pointed drawable */
  int       depth (Drawable drawable) const;

  /* Returns window id of root window */
  Window    root_wid () const;

  /* Color functions */
  ColorPixel    white () const;
  ColorPixel    black () const;
  ColorPixel    color (const char* szColorName) const;

};


/*************************************************************
 * X Graphics Environment: newly created GC.
 *************************************************************/
class ZGEnv : virtual public ZConnect
{
private:

  char      *font_name; /* name of current font */
  char      *fg_name;   /* name of current foreground color */
  char      *bg_name;   /* name of current background color */

protected:

  // Draw text in some drawable attached to some point.
  void  draw_text (Drawable id, int x, int y, int attachment,
           const char* szText) const;

  // Draw aligned text in pointed rectange.
  void  draw_text (Drawable id, const ZRect& box, int alignment,
           const char* szText) const;

public:

  GC        gc;     /* Graphics context */
  XFontStruct   *font;      /* Font info for current font */

  ZGEnv (const ZConnect& zconnect);
  ZGEnv (const ZGEnv& zgenv);
  virtual ~ZGEnv ();

  virtual void  expose ();

  /* GC operations */
  void      set_foreground (const char* szColorName);
  void      set_foreground (ColorPixel cp);
  ColorPixel    get_foreground () const;
  const char*   get_foreground_name () const;

  void      set_background (const char* szColorName);
  void      set_background (ColorPixel cp);
  ColorPixel    get_background () const;
  const char*   get_background_name () const;

  void      swap_ground (); /* swap foreground and background */
  void      assign (const ZGEnv& zgenv);

  void      set_line_width (int new_width);
  int       get_line_width () const;

  void      set_line_style (int new_style, int dash = 3, int hole = 3);
  int       get_line_style () const;

  void      set_font (const char* szFontName);
  void      set_font_as (const ZGEnv& zgenv);
  Font      get_font () const;
  const char*   get_font_name () const;

  /* Text and font characteristics */
  int       text_width (const char* szText) const;
  int       text_width (int n) const;
  int       text_height () const;   /* ascent + descent */
  int       text_ascent () const;
  int       text_descent () const;

  /* Get screen margin of text's rectangle */
  ZRect     text_rect (int x, int y, int attachment,
               const char* szText) const;

  /* Method that is called when some changes of internal state
     of object take place */
  virtual void  changed_state (int mask_of_changes);

  ZGEnv&    operator= (const ZGEnv& zgenv);

};


/*************************************************************
 * Link with some window
 *************************************************************/
class ZWindow : public ZGEnv
{
public:

  Window    wid;        /* Window identifier */

  ZWindow (const ZConnect& zconnect, Window window);
  ZWindow (const ZWindow& zwindow);

  /* Returns ZRect of this window */
  virtual ZRect rect () const;

  /* Draw attached text */
  void  draw_text (int x, int y, int attachment,
           const char* szText) const;

  /* Draw aligned text */
  void  draw_text (const ZRect& box, int alignment,
           const char* szText) const;
};


/*************************************************************
 * Link with some drawable
 *************************************************************/
class ZDrawable : public ZGEnv
{
public:

  Drawable  did;        /* Drawable identifier */

  ZDrawable (const ZConnect& zconnect, Drawable drawable);
  ZDrawable (const ZDrawable& zdrawable);

  /* Returns ZRect of this drawable */
  virtual ZRect rect () const;

  /* Draw attached text */
  void  draw_text (int x, int y, int attachment,
           const char* szText) const;

  /* Draw aligned text */
  void  draw_text (const ZRect& box, int alignment,
           const char* szText) const;

  void  write_tiff (const char* path, ZmImageRemarks* remarks = NULL);

  void  write_png (const char* path, ZmImageRemarks* remarks = NULL);

};


/*************************************************************
 * Newly created pixmap with default depth
 *************************************************************/
class ZArea : public ZDrawable
{
public:

  ZArea (const ZConnect& zconnect, const ZSize& zsize);
  ZArea (const ZArea& zarea);
  virtual ~ZArea ();

  void  resize (const ZSize& zsize);
};


/* Dynamic array of XSegments */
#define AnyType     XSegment
#define AnyAr       XSegmentAr
#define AnyFormatSpec   "\n%d: (%d,%d)-(%d,%d)"
#define AnyPrintList    i, item.x1, item.y1, item.x2, item.y2
#include <mix/AnyAr.H>


#ifndef NO_XTOOLKIT

/*************************************************************
 * Widget based object.
 *************************************************************/
class ZWidget : virtual public ZConnect
{
public:/* methods */

  ZWidget (Widget w = NULL);
  virtual ~ZWidget ();

  virtual Widget    widget () const;

protected:/* data */

  Widget    wptr;

};

#endif /* NO_XTOOLKIT */

/*************************************************************
 * The function performs convertion of a segment into the one
 * with ends inside rectangle area. Returns indication if part
 * of segment inside area. Needed conditions: (wr>=0)&&(hr>=0)
 * Input:
 *   (x1p,y1p)-(x2p,y2p) -- any source line;
 *   (xr,yr)-(xr+wr,yr+hr) -- bounds of rectangle;
 * Output:
 *   (x1p,y1p)-(x2p,y2p) -- part of source line inside pointed
 *        rectangle;
 * Return:
 *   TRUE if source line has a part inside pointed rectangle;
 *   FALSE if source line does not have even a point inside
 *        pointed rectangle.
 *************************************************************/
extern "C" Logic    RectMask (float* x1p, float* y1p,
                  float* x2p, float* y2p,
                  float xr, float yr, float wr, float hr);


/***********************************************************************
 * Compute distance from given point (x,y) to line (x1,y1)-(x2,y2).
 ***********************************************************************/
extern "C" float    DistanceToLine (int x, int y,
                    int x1, int y1, int x2, int y2);


#ifndef NO_XTOOLKIT
#endif /* NO_XTOOLKIT */
//#define INLINE    inline
//#include "ZBaseInline.H"


#endif  // ZBase.H