graphic.c

Linux下VB解释器

      error (ERROR, "Got no window to draw");
      return;
    }
#ifdef UNIX
  if (clear)
    {
      XDrawPoint (display, window, rgc, x, y);
      XDrawPoint (display, backbit, rgc, x, y);
    }
  else
    {
      XDrawPoint (display, window, gc, x, y);
      XDrawPoint (display, backbit, gc, x, y);
    }
  XFlush (display);
  if (printerfile)
    {
      fprintf (printerfile, "%g %g (%c) DO\n",
	       (x - 0.5) * psscale, (winheight - y + 0.5) * psscale,
	       clear ? 'y' : 'n');
    }
#elif WINDOWS
  startdraw (clear);
  if (clear)
    {
      SetPixelV (devcon, (int) x, (int) y, backpixel);
      SetPixelV (bitcon, (int) x, (int) y, backpixel);
      if (printer)
	{
	  MoveToEx (printer, (int) (x * prnscale + prnoffx),
		    (int) (y * prnscale + prnoffy), NULL);
	  LineTo (printer, (int) (x * prnscale + prnoffx),
		  (int) (y * prnscale + prnoffy));
	}
    }
  else
    {
      SetPixelV (devcon, (int) x, (int) y, forepixel);
      SetPixelV (bitcon, (int) x, (int) y, forepixel);
      if (printer)
	{
	  MoveToEx (printer, (int) (x * prnscale + prnoffx),
		    (int) (y * prnscale + prnoffy), NULL);
	  LineTo (printer, (int) (x * prnscale + prnoffx),
		  (int) (y * prnscale + prnoffy));
	}
    }
  enddraw ();
#endif
}


void
create_line (int numpoints)
{				/* create Command 'line' */
  struct command *cmd;

  cmd = add_command (cLINE, FALSE);
  cmd->args = numpoints;
  cmd->tag = dmNORMAL;
}


void
line (struct command *cmd)
{				/* draw a line */
  double x1, y1, x2, y2;
  static double lastx, lasty;
  static int lastvalid = FALSE;
  static double initialx, initialy;
  static int initialvalid = FALSE;
  int numpoints;
  int clear;

  if (!winopened)
    {
      error (ERROR, "Got no window to draw");
      return;
    }

  clear = cmd->tag & dmCLEAR;
  numpoints = cmd->args;
  if (numpoints == -1)
    {				/* new curve */
      lastvalid = FALSE;
      initialvalid = FALSE;
      return;
    }
  else if (numpoints == 0)
    {				/* close curve */
      if (!lastvalid || !initialvalid)
	return;
      lastvalid = FALSE;
      initialvalid = FALSE;
      x1 = lastx;
      y1 = lasty;
      x2 = initialx;
      y2 = initialy;
    }
  else
    {				/* line to x2,y2 */
      y2 = pop (stNUMBER)->value;
      x2 = pop (stNUMBER)->value;
      if (numpoints == 1)
	{
	  if (!lastvalid)
	    {
	      initialx = lastx = x2;
	      initialy = lasty = y2;
	      initialvalid = lastvalid = TRUE;
	      return;
	    }
	  y1 = lasty;
	  x1 = lastx;
	}
      else
	{			/* line x1,y1 to x2,y2 */
	  y1 = pop (stNUMBER)->value;
	  x1 = pop (stNUMBER)->value;
	}
    }
  lastx = x2;
  lasty = y2;
  if (!initialvalid)
    {
      initialx = x1;
      initialy = y2;
      initialvalid = TRUE;
    }
  transform (&x1, &y1);
  transform (&x2, &y2);

#ifdef UNIX
  if (clear)
    {
      XDrawLine (display, window, rgc, x1, y1, x2, y2);
      XDrawLine (display, backbit, rgc, x1, y1, x2, y2);
    }
  else
    {
      XDrawLine (display, window, gc, x1, y1, x2, y2);
      XDrawLine (display, backbit, gc, x1, y1, x2, y2);
    }
  XFlush (display);
  if (printerfile)
    {
      fprintf (printerfile, "%g %g %g %g (%c) LI\n",
	       x1 * psscale, (winheight - y1) * psscale,
	       x2 * psscale, (winheight - y2) * psscale,
	       clear ? 'y' : 'n');
    }
  fflush (printerfile);
#elif WINDOWS
  startdraw (clear);
  MoveToEx (devcon, (int) x1, (int) y1, NULL);
  LineTo (devcon, (int) x2, (int) y2);
  if (clear)
    SetPixelV (devcon, (int) x2, (int) y2, backpixel);
  else
    SetPixelV (devcon, (int) x2, (int) y2, forepixel);
  MoveToEx (bitcon, (int) x1, (int) y1, NULL);
  LineTo (bitcon, (int) x2, (int) y2);
  if (clear)
    SetPixelV (bitcon, (int) x2, (int) y2, backpixel);
  else
    SetPixelV (bitcon, (int) x2, (int) y2, forepixel);

  if (printer)
    {
      MoveToEx (printer, (int) (x1 * prnscale + prnoffx),
		(int) (y1 * prnscale + prnoffy), NULL);
      LineTo (printer, (int) (x2 * prnscale + prnoffx),
	      (int) (y2 * prnscale + prnoffy));
    }
  enddraw ();
#endif
}


void
change_colour (struct command *cmd)
{				/* change colour for graphics */
  int r, g, b;
#ifdef UNIX
  int pixel;
  int ret;
  char xerr[200];
#else
#endif

  if (cmd->type == cGCOLOUR || cmd->type == cGBACKCOLOUR)
    {
      b = (int) pop (stNUMBER)->value;
      g = (int) pop (stNUMBER)->value;
      r = (int) pop (stNUMBER)->value;
      if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255)
	{
	  sprintf (string,
		   "arguments to command colour must be between 0 and 255 (not %d,%d,%d)",
		   r, g, b);
	  error (ERROR, string);
	  return;
	}
    }
  else
    {
      char *h;
      h = (char *) (pop (stSTRING)->pointer);
      if (sscanf (h, "%d,%d,%d", &r, &g, &b) != 3 || r < 0 || r > 255
	  || g < 0 || g > 255 || b < 0 || b > 255)
	{
	  sprintf (string,
		   "string argument to command colour must be three numbers between 0 and 255, seperated by commas (not '%s')",
		   h);
	  error (ERROR, string);
	  return;
	}
    }
#ifdef UNIX
  pixel = rgb_to_pixel (r, g, b);
  forepixel = pixel;
  if (cmd->type == cGCOLOUR || cmd->type == cGCOLOUR2)
    {
      XSetForeground (display, gc, pixel);
      XSetBackground (display, gc, pixel);
      if (printerfile)
	{
	  fprintf (printerfile, "rgb /r %g put\n", ((double) r) / 255);
	  fprintf (printerfile, "rgb /g %g put\n", ((double) g) / 255);
	  fprintf (printerfile, "rgb /b %g put\n", ((double) b) / 255);
	  fprintf (printerfile, "(n) CLYN\n");
	  fflush (printerfile);
	}
    }
  else
    {
      XSetForeground (display, rgc, pixel);
      XSetBackground (display, rgc, pixel);
    }
#else /*  */
  if (cmd->type == cGCOLOUR || cmd->type == cGCOLOUR2)
    {
      forepixel = RGB (r, g, b);
      DeleteObject (forebrush);
      forebrush = CreateSolidBrush (forepixel);
      SelectObject (devcon, forebrush);
      SelectObject (bitcon, forebrush);
      DeleteObject (forepen);
      forepen = CreatePen (PS_SOLID, 0, forepixel);
      SelectObject (devcon, forepen);
      SelectObject (bitcon, forepen);
    }
  else
    {
      backpixel = RGB (r, g, b);
      DeleteObject (backbrush);
      backbrush = CreateSolidBrush (backpixel);
      SelectObject (devcon, backbrush);
      SelectObject (bitcon, backbrush);
      DeleteObject (backpen);
      backpen = CreatePen (PS_SOLID, 0, backpixel);
      SelectObject (devcon, backpen);
      SelectObject (bitcon, backpen);
    }

#endif
}


int
rgb_to_pixel (int r, int g, int b)
{				/* create a pixel value from rgb values */
  long pixel;

#ifdef UNIX
  pixel =
      (visualinfo.
       red_mask & ((long) (r * rbits_max / 255) << rbits_shift)) +
      (visualinfo.
       green_mask & ((long) (g * gbits_max / 255) << gbits_shift)) +
      (visualinfo.
       blue_mask & ((long) (b * bbits_max / 255) << bbits_shift));

#else /*  */
  pixel = RGB (r, g, b);

#endif
  return pixel;
}


static int
pixel_to_rgb (int *r, int *g, int *b, int pixel)
{				/* create an rgb value from pixel */
#ifdef UNIX
  *r = (int) (((pixel >> rbits_shift) & rbits_max) * 255 / rbits_max);
  *g = (int) (((pixel >> gbits_shift) & gbits_max) * 255 / gbits_max);
  *b = (int) (((pixel >> bbits_shift) & bbits_max) * 255 / bbits_max);

#else /*  */
  *r = GetRValue (pixel);
  *g = GetGValue (pixel);
  *b = GetBValue (pixel);

#endif
}


void
circle (struct command *cmd)
{				/* draw a circle */
  double x, y, r;
  int fill, clear;

  fill = cmd->tag & dmFILL;
  clear = cmd->tag & dmCLEAR;
  r = pop (stNUMBER)->value;
  y = pop (stNUMBER)->value;
  x = pop (stNUMBER)->value;
  transform (&x, &y);
  if (!winopened)
    {
      error (ERROR, "Got no window to draw");
      return;
    }
#ifdef UNIX
  if (clear)
    {
      if (fill)
	{
	  XFillArc (display, window, rgc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	  XFillArc (display, backbit, rgc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	}
      else
	{
	  XDrawArc (display, window, rgc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	  XDrawArc (display, backbit, rgc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	}
    }
  else
    {
      if (fill)
	{
	  XFillArc (display, window, gc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	  XFillArc (display, backbit, gc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	}
      else
	{
	  XDrawArc (display, window, gc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	  XDrawArc (display, backbit, gc, x - r, y - r, 2 * r, 2 * r,
		    0 * 64, 360 * 64);
	}
    }

  XFlush (display);
  if (printerfile)
    {
      fprintf (printerfile, "N\n");
      fprintf (printerfile, "%g %g %g (%c) (%c) CI\n",
	       (winheight - y) * psscale, x * psscale, r * psscale,
	       clear ? 'y' : 'n', fill ? 'y' : 'n');
      fflush (printerfile);
    }
#else /* WINDOWS */
  startdraw (clear);
  if (fill)
    {
      Ellipse (devcon, (int) (x - r), (int) (y - r), (int) (x + r),
	       (int) (y + r));
      Ellipse (bitcon, (int) (x - r), (int) (y - r), (int) (x + r),
	       (int) (y + r));
      if (printer)
	{
	  Ellipse (printer, (int) ((x - r) * prnscale + prnoffx),
		   (int) ((y - r) * prnscale + prnoffy),
		   (int) ((x + r) * prnscale + prnoffx),
		   (int) ((y + r) * prnscale + prnoffy));
	}
    }
  else
    {
      Arc (devcon, (int) (x - r), (int) (y - r), (int) (x + r),
	   (int) (y + r), 0, 0, 0, 0);
      Arc (bitcon, (int) (x - r), (int) (y - r), (int) (x + r),
	   (int) (y + r), 0, 0, 0, 0);
      if (printer)
	{
	  Arc (printer, (int) ((x - r) * prnscale + prnoffx),
	       (int) ((y - r) * prnscale + prnoffy),
	       (int) ((x + r) * prnscale + prnoffx),
	       (int) ((y + r) * prnscale + prnoffy), 0, 0, 0, 0);
	}
    }
  enddraw ();
#endif
}


void
triangle (struct command *cmd)
{				/* draw a triangle */
  double x0, y0, x1, y1, x2, y2;
#ifdef UNIX
  XPoint points[4];

#else /*  */
  POINT points[4];
  POINT prpoints[4];
#endif
  int fill, clear;

  fill = cmd->tag & dmFILL;
  clear = cmd->tag & dmCLEAR;
  y2 = pop (stNUMBER)->value;
  x2 = pop (stNUMBER)->value;
  y1 = pop (stNUMBER)->value;
  x1 = pop (stNUMBER)->value;
  y0 = pop (stNUMBER)->value;
  x0 = pop (stNUMBER)->value;
  transform (&x0, &y0);
  transform (&x1, &y1);
  transform (&x2, &y2);
  points[2].y = (long) y2;
  points[2].x = (long) x2;
  points[1].y = (long) y1;
  points[1].x = (long) x1;
  points[0].y = (long) y0;
  points[0].x = (long) x0;
  points[3].y = (long) y0;
  points[3].x = (long) x0;
  if (!winopened)
    {
      error (ERROR, "Got no window to draw");
      return;
    }
#ifdef UNIX
  if (clear)
    {
      if (fill)
	{
	  XFillPolygon (display, window, rgc, points, 4, Convex,
			CoordModeOrigin);
	  XFillPolygon (display, backbit, rgc, points, 4, Convex,
			CoordModeOrigin);
	}
      else
	{
	  XDrawLines (display, window, rgc, points, 4, CoordModeOrigin);
	  XDrawLines (display, backbit, rgc, points, 4, CoordModeOrigin);
	}
    }
  else
    {
      if (fill)
	{
	  XFillPolygon (display, window, gc, points, 4, Convex,
			CoordModeOrigin);
	  XFillPolygon (display, backbit, gc, points, 4, Convex,
			CoordModeOrigin);
	}
      else
	{
	  XDrawLines (display, window, gc, points, 4, CoordModeOrigin);
	  XDrawLines (display, backbit, gc, points, 4, CoordModeOrigin);
	}
    }

  XFlush (display);
  if (printerfile)
    {
      fprintf (printerfile, "N\n");
      fprintf (printerfile, "%g %g %g %g %g %g (%c) (%c) TRI\n",
	       x0 * psscale, (winheight - y0) * psscale,
	       x1 * psscale, (winheight - y1) * psscale,
	       x2 * psscale, (winheight - y2) * psscale,
	       clear ? 'y' : 'n', fill ? 'y' : 'n');
      fflush (printerfile);
    }
#else /* WINDOWS */
  startdraw (clear);
  if (printer)
    {
      int i;
      for (i = 0; i < 3; i++)
	{
	  prpoints[i].x = (long) (points[i].x * prnscale + prnoffx);
	  prpoints[i].y = (long) (points[i].y * prnscale + prnoffy);
    }}
  if (fill)
    {
      Polygon (devcon, points, 3);
      Polygon (bitcon, points, 3);
      if (printer)
	{
	  Polygon (printer, prpoints, 3);
	}
    }
  else
    {
      Polyline (devcon, points, 4);
      Polyline (bitcon, points, 4);
      if (printer)
	{
	  Polyline (printer, prpoints, 3);
	}
    }
  enddraw ();
#endif
}


void
text (struct command *cmd)
{				/* write a text */
  double x, y;
  char *text;
  char *arg1 = NULL;
  char *arg2 = NULL;
  char *align = NULL;
  char *fontname = NULL;
  int xoff, yoff, len;
#ifdef UNIX