ZBaseInline.H

/* ZBaseInline.H */
/* $Id: ZBaseInline.H,v 1.7 2005/06/14 12:31:13 vlad Exp $ */
#ifndef __ZBaseInline_H
#define __ZBaseInline_H

#include <malloc.h>
#include <stdlib.h>

/*************************************************************
 *                     << Class ZPoint >>
 * Pixel point, place
 *************************************************************/

/*************************************************************/
INLINE ZPoint::ZPoint ()
{
  x = y = 0;
}


/*************************************************************/
INLINE ZPoint::ZPoint (int x_coord, int y_coord)
{
  x = x_coord;
  y = y_coord;
}


/*************************************************************/
INLINE ZPoint::ZPoint (const ZPoint& zpoint)
{
  x = zpoint.x;
  y = zpoint.y;
}


/*************************************************************/
INLINE ZPoint::operator XPoint () const
{
  XPoint xpoint;
  xpoint.x = (short)x;
  xpoint.y = (short)y;

  return xpoint;
}


/*************************************************************/
INLINE void
ZPoint::add_offset (const ZSize& zsize)
{
  x += zsize.w;
  y += zsize.h;
}


/*************************************************************/
INLINE void
ZPoint::sub_offset (const ZSize& zsize)
{
  x -= zsize.w;
  y -= zsize.h;
}


/*************************************************************/
INLINE void
ZPoint::print (const char* szEnd) const
{
  printf("ZPoint:: x=%d, y=%d %s", x, y, szEnd);
}


/*************************************************************/
INLINE bool
ZPoint::operator== (const ZPoint& zpoint) const
{
  return x == zpoint.x && y == zpoint.y;
}


/*************************************************************/
INLINE bool
ZPoint::operator!= (const ZPoint& zpoint) const
{
  return !operator==(zpoint);
}


/*************************************************************
 *                    << Class ZSize >>
 * Pixel size, box with undefined place
 *************************************************************/

/*************************************************************/
INLINE ZSize::ZSize ()
{
  w = h = 0;
}


/*************************************************************/
INLINE ZSize::ZSize (int width, int height)
{
  w = width;
  h = height;
}


/*************************************************************/
INLINE ZSize::ZSize (const ZSize& zsize)
{
  w = zsize.w;
  h = zsize.h;
}


/*************************************************************/
INLINE void
ZSize::difference (const ZPoint& zpoint1, const ZPoint& zpoint2)
{
  w = zpoint1.x - zpoint2.x;
  h = zpoint1.y - zpoint2.y;
}


/*************************************************************/
INLINE void
ZSize::print (const char* szEnd) const
{
  printf("ZSize:: w=%d, h=%d %s", w, h, szEnd);
}


/*************************************************************/
INLINE bool
ZSize::operator== (const ZSize& zsize) const
{
  return w == zsize.w && h == zsize.h;
}


/*************************************************************/
INLINE bool
ZSize::operator!= (const ZSize& zsize) const
{
  return !operator==(zsize);
}


/*************************************************************
 *                   << Class ZRect >>
 * Real box, rectangle
 *************************************************************/

/*************************************************************/
INLINE ZRect::ZRect ()
{
}

/*************************************************************/
INLINE ZRect::ZRect (const ZPoint& zpoint1,
             const ZPoint& zpoint2)
: ZPoint(MIN(zpoint1.x, zpoint2.x), MIN(zpoint1.y, zpoint2.y)),
  ZSize(ABS(zpoint1.x - zpoint2.x), ABS(zpoint1.y - zpoint2.y))
{
}


/*************************************************************/
INLINE ZRect::ZRect (const ZPoint& zpoint,
             const ZSize& zsize, ZCorner zcorner)
: ZPoint(0, 0), ZSize(zsize)
{
  move(zpoint, zcorner);
}


/*************************************************************/
INLINE ZRect::ZRect (const ZRect& zrect)
: ZPoint(zrect), ZSize(zrect)
{
}


/*************************************************************/
INLINE void
ZRect::print (const char* szEnd) const
{
  printf("ZRect:: x=%d, y=%d, w=%d, h=%d %s", x, y, w, h, szEnd);
}


/*************************************************************/
INLINE bool
ZRect::operator== (const ZRect& zrect) const
{
  return ZPoint::operator==(zrect) && ZSize::operator==(zrect);
}


/*************************************************************/
INLINE bool
ZRect::operator!= (const ZRect& zrect) const
{
  return !operator==(zrect);
}



/*************************************************************
 *                    << Class ZConnect >>
 * Link to the X server
 *************************************************************/


/*************************************************************
 *                    << Class ZWindow >>
 * X Window determination
 *************************************************************/

/*************************************************************
 * Returns window id of root window
 *************************************************************/
INLINE Window
ZConnect::root_wid () const
{
  register Window wid = RootWindow(dpy, scr_no);
  x_error((int)wid);

  return wid;
}


/*************************************************************
 * Performs XFlush(dpy)
 *************************************************************/
INLINE void
ZConnect::flush ()
{
  XFlush(dpy);
}


/*************************************************************
 * Returns ZRect of root window
 *************************************************************/
INLINE ZRect
ZConnect::rect () const
{
  return rect(root_wid());
}


/*************************************************************
 * Recturn depth of pointed drawable
 *************************************************************/
INLINE int
ZConnect::depth (Drawable drawable) const
{
  Window root_wid;
  unsigned int dummy;
  unsigned int d;

  XGetGeometry(dpy, drawable, &root_wid, (int*)&dummy,
           (int*)&dummy, &dummy, &dummy, &dummy, &d);

  return d;
}


/*************************************************************
 * Returns white color handle of screen
 *************************************************************/
INLINE ColorPixel
ZConnect::white () const
{
  return WhitePixel(dpy, scr_no);
}


/*************************************************************
 * Returns black color handle of screen
 *************************************************************/
INLINE ColorPixel
ZConnect::black () const
{
  return BlackPixel(dpy, scr_no);
}


/*************************************************************
 * Returns handle of needed color
 *************************************************************/
INLINE ColorPixel
ZConnect::color (const char* szColorName) const
{
  return zcp_color_pixel(szColorName);
}


/*************************************************************
 *                     << Class ZGEnv >>
 * X Graphics Environment: newly created GC.
 *************************************************************/


/*************************************************************
 *                     Text information
 *************************************************************/

/*************************************************************
 * Return width of pointed text (in pixel) on screen
 *************************************************************/
INLINE int
ZGEnv::text_width (const char* szText) const
{
  if(szText == NULL)  Throw(ERROR__NULL);

  if(szText[0] == '\0')
    return 0;

  return XTextWidth(font, szText, strlen(szText));
}


/*************************************************************
 * Return width of some text with n chars (in pixel) on screen
 *************************************************************/
INLINE int
ZGEnv::text_width (int n) const
{
  return n * font->max_bounds.width;
}


/*************************************************************
 * Return ascent of text (in pixel) on screen
 *************************************************************/
INLINE int
ZGEnv::text_ascent () const
{
  return font->ascent;
}


/*************************************************************
 * Return descent of text (in pixel) on screen
 *************************************************************/
INLINE int
ZGEnv::text_descent () const
{
  return font->descent;
}


/*************************************************************
 * Return height of text (in pixel) on screen
 *************************************************************/
INLINE int
ZGEnv::text_height () const
{
  return text_ascent() + text_descent();
}


/*************************************************************
 * Draw text in some drawable attached to some point.
 *************************************************************/
INLINE void
ZGEnv::draw_text (Drawable id, int x, int y, int attachment,
          const char* szText) const
{
  if(szText == NULL)  Throw(ERROR__NULL);

  ZRect r = text_rect(x, y, attachment, szText);
  XDrawString(dpy, id, gc, r.x, r.y + r.h - 1 - text_descent(),
          szText, strlen(szText));
}


/*************************************************************
 *                      GC operations
 *************************************************************/

/*************************************************************/
INLINE void
ZGEnv::set_foreground (ColorPixel cp)
{
  XSetForeground(dpy, gc, cp);
  changed_state(ChangedForeground);

  if(NULL != fg_name)
    {
      if(!strcmp(fg_name, "black"))
    return;
      free(fg_name);
    }
  fg_name = strdup("black");
}


/*************************************************************/
INLINE void
ZGEnv::set_foreground (const char* szColorName)
{
  set_foreground(color(szColorName));

  if(NULL != fg_name)
    {
      if(!strcmp(fg_name, szColorName))
    return;
      free(fg_name);
    }
  fg_name = strdup(szColorName);
}


/*************************************************************/
INLINE ColorPixel
ZGEnv::get_foreground () const
{
  XGCValues gc_val;
  Status rc = XGetGCValues(dpy, gc, GCForeground, &gc_val);
  if(0 == rc)
    x_error(ERROR__X_GET_GC_VALUES);
  return gc_val.foreground;
}


/*************************************************************/
INLINE const char*
ZGEnv::get_foreground_name () const
{
  return fg_name;
}


/*************************************************************/
INLINE void
ZGEnv::set_background (ColorPixel cp)
{
  XSetBackground(dpy, gc, cp);
  changed_state(ChangedBackground);

  if(NULL != bg_name)
    {
      if(!strcmp(bg_name, "white"))
    return;
      free(bg_name);
    }
  bg_name = strdup("white");
}


/*************************************************************/
INLINE void
ZGEnv::set_background (const char* szColorName)
{
  set_background(color(szColorName));

  if(NULL != bg_name)
    {
      if(!strcmp(bg_name, szColorName))
    return;
      free(bg_name);
    }
  bg_name = strdup(szColorName);
}


/*************************************************************/
INLINE ColorPixel
ZGEnv::get_background () const
{
  XGCValues gc_val;
  Status rc = XGetGCValues(dpy, gc, GCBackground, &gc_val);
  if(0 == rc)
    x_error(ERROR__X_GET_GC_VALUES);
  return gc_val.background;
}


/*************************************************************/
INLINE const char*
ZGEnv::get_background_name () const
{
  return bg_name;
}


/*************************************************************/
INLINE void
ZGEnv::set_line_width (int new_width)
{
  XGCValues gc_val;
  gc_val.line_width = new_width;
  XChangeGC(dpy, gc, GCLineWidth, &gc_val);

  changed_state(ChangedLineWidth);
}


/*************************************************************/
INLINE int
ZGEnv::get_line_width () const
{
  XGCValues gc_val;
  Status rc = XGetGCValues(dpy, gc, GCLineWidth, &gc_val);
  if(0 == rc)
    x_error(ERROR__X_GET_GC_VALUES);
  return gc_val.line_width;
}


/*************************************************************/
INLINE void
ZGEnv::set_line_style (int new_style, int dash, int hole)
{
  XGCValues gc_val;
  gc_val.line_style = new_style;
  XChangeGC(dpy, gc, GCLineStyle, &gc_val);

  char  dash_hole[2];
  dash_hole[0] = dash;
  dash_hole[1] = hole;
  XSetDashes(dpy, gc, 0, dash_hole, NUMBER(dash_hole));

  changed_state(ChangedLineStyle);
}


/*************************************************************/
INLINE int
ZGEnv::get_line_style () const
{
  XGCValues gc_val;
  Status rc = XGetGCValues(dpy, gc, GCLineStyle, &gc_val);
  if(0 == rc)
    x_error(ERROR__X_GET_GC_VALUES);
  return gc_val.line_style;
}


/*************************************************************/
INLINE const char*
ZGEnv::get_font_name () const
{
  return font_name;
}


/*************************************************************/
INLINE void
ZGEnv::set_font_as (const ZGEnv& zgenv)
{
  set_font(zgenv.get_font_name());
}


/*************************************************************/
INLINE Font
ZGEnv::get_font () const
{
  XGCValues gc_val;
  Status rc = XGetGCValues(dpy, gc, GCFont, &gc_val);
  if(0 == rc)
    x_error(ERROR__X_GET_GC_VALUES);
  return gc_val.font;
}


/*************************************************************
 *                    << Class ZWindow >>
 * X Window determination
 *************************************************************/

/*************************************************************/
INLINE ZWindow::ZWindow (const ZConnect& zconnect, Window window)
: ZConnect(zconnect), ZGEnv(zconnect)
{
  wid = window;
}


/*************************************************************/
INLINE ZWindow::ZWindow (const ZWindow& zwindow)
: ZConnect(zwindow), ZGEnv(zwindow)
{
  wid = zwindow.wid;
}


/*************************************************************
 * Draw attached text
 *************************************************************/
INLINE void
ZWindow::draw_text (int x, int y, int attachment,
            const char* szText) const
{
  ZGEnv::draw_text(wid, x, y, attachment, szText);
}


/*************************************************************
 * Draw aligned text.
 *************************************************************/
INLINE void
ZWindow::draw_text (const ZRect& box, int alignment,
            const char* szText) const
{
  ZGEnv::draw_text(wid, box, alignment, szText);
}


/*************************************************************
 *                    << Class ZDrawable >>
 * X Drawable determination
 *************************************************************/

/*************************************************************/
INLINE ZDrawable::ZDrawable (const ZConnect& zconnect, Drawable drawable)
: ZConnect(zconnect), ZGEnv(zconnect)
{
  did = drawable;
}


/*************************************************************/
INLINE ZDrawable::ZDrawable (const ZDrawable& zdrawable)
: ZConnect(zdrawable), ZGEnv(zdrawable)
{
  did = zdrawable.did;
}


/*************************************************************
 * Draw attached text
 *************************************************************/
INLINE void
ZDrawable::draw_text (int x, int y, int attachment,
              const char* szText) const
{
  ZGEnv::draw_text(did, x, y, attachment, szText);
}


/*************************************************************
 * Draw aligned text.
 *************************************************************/
INLINE void
ZDrawable::draw_text (const ZRect& box, int alignment,
              const char* szText) const
{
  ZGEnv::draw_text(did, box, alignment, szText);
}


/*************************************************************
 *                     << Class ZArea >>
 * Newly created pixmap with default depth
 *************************************************************/

/*************************************************************/
INLINE ZArea::ZArea (const ZConnect& zconnect, const ZSize& zsize)
: ZConnect(zconnect),
  ZDrawable(zconnect,
        (Drawable)XCreatePixmap(zconnect.dpy,
                    zconnect.root_wid(), zsize.w, zsize.h,
                    zconnect.depth(zconnect.root_wid())))
{
  x_error((int)did);
}


/*************************************************************/
INLINE ZArea::ZArea (const ZArea& zarea)
: ZConnect(zarea),
  ZDrawable(zarea,
        (Drawable)XCreatePixmap(zarea.dpy, zarea.root_wid(),
                    zarea.rect().w,
                    zarea.rect().h,
                    zarea.depth(zarea.did)))
{
  x_error((int)did);
  XCopyArea(dpy, zarea.did, did, gc, 0, 0,
        zarea.rect().w, zarea.rect().h, 0, 0);
}


/*************************************************************
 * Create new pixmap with new size
 *************************************************************/
INLINE void
ZArea::resize (const ZSize& zsize)
{
  XFreePixmap(dpy, did);
  did = (Drawable)XCreatePixmap(dpy, root_wid(), zsize.w, zsize.h,
                depth(root_wid()));
  x_error((int)did);
}


/*************************************************************
 *                   << Class ZWidget >>
 * Widget based object.
 *************************************************************/

/*************************************************************/
INLINE ZWidget::ZWidget (Widget w)
: ZConnect(XtDisplay(w)), wptr(w)
{
  // dummy
}


#endif /* ZBaseInline.H */