Logo Search packages:      
Sourcecode: x11-apps version File versions  Download package

draw.c

/*
 * $XConsortium: draw.c,v 1.8 94/04/17 20:43:35 gildea Exp $
 * $XFree86: xc/programs/xditview/draw.c,v 1.4 2001/08/01 00:45:03 tsi Exp $
 *
Copyright (c) 1991  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
 *
 */

/*
 * draw.c
 *
 * accept dvi function calls and translate to X
 */

/*
  Support for ditroff drawing commands added: lines, circles, ellipses,
  arcs and splines.  Splines are approximated as short lines by iterating
  a simple approximation algorithm.  This seems good enough for previewing.

  David Evans <dre@cs.nott.ac.uk>, 14th March, 1990
*/

#include <X11/Xos.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include "DviP.h"
#include <stdlib.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846264338327950
#endif

/*    the following are for use in the spline approximation algorithm */

typedef struct    Point {
    double  x;
    double  y;
    struct Point  *next;
} Point;

#define     ITERATIONS  10    /* iterations to approximate spline */

#define     midx(p,q)   ((p->x + q->x) / 2)     /* mid x point on pq */
#define     midy(p,q)   ((p->y + q->y) / 2)     /* mid y point on pq */

#define     length(p,q) sqrt(((q->x - p->x)*(q->x - p->x)) \
                       + ((q->y - p->y)*(q->y - p->y))) /* length of pq */

Point *spline = (Point *)NULL;      /* head of spline linked list */

static void ApproxSpline(int n);
static void DeletePoint(Point *p);
static void DrawSplineSegments(DviWidget dw);
static int  GetSpline(char *s);
static void InsertPoint(Point *p, Point *q);
static void LineApprox(Point *p1, Point *p2, Point *p3);
static Point *    MakePoint(double x, double y);

void
HorizontalMove(dw, delta)
      DviWidget   dw;
      int         delta;
{
    dw->dvi.state->x += delta;
}

void
HorizontalGoto(dw, NewPosition)
      DviWidget   dw;
      int         NewPosition;
{
    dw->dvi.state->x = NewPosition;
}

void
VerticalMove(dw, delta)
      DviWidget   dw;
      int         delta;
{
    dw->dvi.state->y += delta;
}

void
VerticalGoto(dw, NewPosition)
      DviWidget   dw;
      int         NewPosition;
{
    dw->dvi.state->y = NewPosition;
}

#ifdef USE_XFT
static void
DrawText (DviWidget dw)
{
    int         i;
    XftFont *font;

    font = dw->dvi.cache.font;
    for (i = 0; i <= dw->dvi.cache.index; i++)
    {
      if (dw->dvi.cache.cache[i].font)
          font = dw->dvi.cache.cache[i].font;
      XftDrawString8 (dw->dvi.draw, &dw->dvi.black,
                  font,
                  dw->dvi.cache.cache[i].x,
                  dw->dvi.cache.start_y,
                  (unsigned char *) dw->dvi.cache.cache[i].chars,
                  dw->dvi.cache.cache[i].nchars);
    }
}
#endif

void
FlushCharCache (dw)
      DviWidget   dw;
{
    int         xx, yx;

    xx = ToX(dw, dw->dvi.state->x);
    yx = ToX(dw, dw->dvi.state->y);
    if (dw->dvi.cache.char_index != 0)
    {
#ifdef USE_XFT
      DrawText (dw);
#else
      XDrawText (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
                dw->dvi.cache.start_x, dw->dvi.cache.start_y,
                dw->dvi.cache.cache, dw->dvi.cache.index + 1);
#endif
    }
    dw->dvi.cache.index = 0;
    dw->dvi.cache.max = DVI_TEXT_CACHE_SIZE;
    if (dw->dvi.noPolyText)
      dw->dvi.cache.max = 1;
    dw->dvi.cache.char_index = 0;
    dw->dvi.cache.cache[0].nchars = 0;
    dw->dvi.cache.start_x = dw->dvi.cache.x = xx;
    dw->dvi.cache.start_y = dw->dvi.cache.y = yx;
}

#if 0
void
ClearPage (DviWidget dw)
{
    if (dw->dvi.display_enable)
      XClearWindow (XtDisplay (dw), XtWindow (dw));
}
#endif

void
SetGCForDraw (dw)
    DviWidget     dw;
{
    int     lw;
    if (dw->dvi.state->line_style != dw->dvi.line_style ||
      dw->dvi.state->line_width != dw->dvi.line_width)
    {
      lw = ToX(dw, dw->dvi.state->line_width);
      if (lw <= 1)
          lw = 0;
      XSetLineAttributes (XtDisplay (dw), dw->dvi.normal_GC,
                      lw, LineSolid, CapButt, JoinMiter);
      dw->dvi.line_style = dw->dvi.state->line_style;
      dw->dvi.line_width = dw->dvi.state->line_width;
    }
}

void
DrawLine (dw, x, y)
    DviWidget     dw;
    int           x, y;
{
    if (dw->dvi.display_enable)
      XDrawLine (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
               ToX(dw, dw->dvi.state->x), ToX(dw, dw->dvi.state->y),
               ToX(dw, dw->dvi.state->x + x), ToX(dw,dw->dvi.state->y + y));
    dw->dvi.state->x += x;
    dw->dvi.state->y += y;
}

void
DrawCircle (dw, diameter)
      DviWidget   dw;
      int         diameter;
{
    if (dw->dvi.display_enable)
      XDrawArc (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
                    ToX(dw, dw->dvi.state->x),
                    ToX(dw, dw->dvi.state->y - (diameter / 2)),
                    ToX(dw, diameter), ToX(dw, diameter), 0, 360 * 64);
    dw->dvi.state->x += diameter;
}

void
DrawEllipse (dw, a, b)
      DviWidget   dw;
      int         a, b;
{
    if (dw->dvi.display_enable)
      XDrawArc (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
              ToX(dw, dw->dvi.state->x), ToX(dw, dw->dvi.state->y - (b / 2)),
              ToX(dw,a), ToX(dw,b), 0, 360 * 64);
    dw->dvi.state->x += a;
}


/*    Convert angle in degrees to 64ths of a degree */

static int
ConvertAngle(int theta)
{
    return(theta * 64);
}

void
DrawArc (dw, x0, y0, x1, y1)
      DviWidget   dw;
      int         x0, y0, x1, y1;
{
    int     xc, yc, x2, y2, r;
    int     angle1, angle2;

    /* centre */
    xc = dw->dvi.state->x + x0;
    yc = dw->dvi.state->y + y0;

    /* to */
    x2 = xc + x1;
    y2 = yc + y1;

    dw->dvi.state->x = x2;
    dw->dvi.state->y = y2;

    if (dw->dvi.display_enable) {

      /* radius */
      r = (int)sqrt((float) x1 * x1 + (float) y1 * y1);

      /* start and finish angles */
      if (x0 == 0) {
            if (y0 >= 0)
                  angle1 = 90;
            else
                  angle1 = 270;
      }
      else {
            angle1 = (int) (atan((double)(y0) / (double)(x0)) * 180 / M_PI);
            if (x0 > 0)
                  angle1 = 180 - angle1;
            else
                  angle1 = -angle1;
      }

      if (x1 == 0) {
            if (y1 <= 0)
                  angle2 = 90;
            else
                  angle2 = 270;
      }
      else {
            angle2 = (int) (atan((double)(y1) / (double)(x1)) * 180 / M_PI);
            if (x1 < 0)
                  angle2 = 180 - angle2;
            else
                  angle2 = -angle2;
      }

      if (angle1 < 0)
            angle1 += 360;
      if (angle2 < 0)
            angle2 += 360;

      if (angle2 < angle1)
            angle1 -= 360;
      angle2 = angle2 - angle1;

      angle1 = ConvertAngle(angle1);
      angle2 = ConvertAngle(angle2);

      XDrawArc (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
              ToX(dw, xc - r), ToX(dw, yc - r),
              ToX(dw, 2 * r), ToX(dw, 2 * r),
              angle1, angle2);
    }
}

/* copy next non-blank string from p to temp, update p */

static char *
getstr(char *p, char *temp)
{
    while (*p == ' ' || *p == '\t' || *p == '\n')
      p++;
    if (*p == '\0') {
      temp[0] = 0;
      return((char *)NULL);
    }
    while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0')
      *temp++ = *p++;
    *temp = '\0';
    return(p);
}


/*    Draw a spline by approximating with short lines.      */

/*ARGSUSED*/
void
DrawSpline (dw, s, len)
      DviWidget   dw;
      char        *s;
      int         len;
{
    int           n;

    /* get coordinate pairs into spline linked list */
    if ((n = GetSpline(s)) <= 0)
      return;

    ApproxSpline(n);

    DrawSplineSegments(dw);
}


/*    Parse string s to create a linked list of Point's with spline */
/*    as its head.  Return the number of coordinate pairs found.    */

static int
GetSpline(s)
    char *s;
{
    double  x, y, x1, y1;
    int           n = 0;
    Point   *pt;
    char    *p = s, d[10];

    if (!*p)
      return(n);

    pt = spline = MakePoint(0.0, 0.0);
    n = 1;
    x = y = 0.0;
    p = s;
    while (p && *p) {
      if ((p = getstr(p, d)) == (char *)NULL)
          break;
      x1 = x + atof(d);
      if ((p = getstr(p, d)) == (char *)NULL)
          break;
      y1 = y + atof(d);
      pt->next = MakePoint(x1, y1);
      pt = pt->next;
      x = pt->x;
      y = pt->y;
      n++;
    }

    /* number of pairs of points */

    return(n);
}

/*    Approximate a spline by lines generated by iterations of the        */
/*    approximation algorithm from the original n points in the spline. */

static void
ApproxSpline(n)
int n;
{
    int           mid, j;
    Point   *p1, *p2, *p3, *p;

    if (n < 3)
      return;

    /* number of mid-points to calculate */
    mid = n - 3;

    /* remember original points are stored as an array of n points */
    /* so I can index it directly to calculate mid-points only.      */
    if (mid > 0) {
      p = spline->next;
      j = 1;
      while (j < n-2) {
          p1 = p;
          p = p->next;
          p2 = p;
          InsertPoint(p1, MakePoint(midx(p1, p2), midy(p1, p2)));
          j++;
      }
    }

    /* Now approximate curve by line segments.           */
    /* There *should* be the correct number of points now! */

    p = spline;
    while (p != (Point *)NULL) {
      p1 = p;
      if ((p = p->next) == (Point *)NULL)
          break;
      p2 = p;
      if ((p = p->next) == (Point *)NULL)
          break;
      p3 = p;           /* This point becomes first point of next curve */

      LineApprox(p1, p2, p3);
    }
}


/*    p1, p2, and p3 are initially 3 *consecutive* points on the curve. */
/*    For each adjacent pair of points find the mid-point, insert this  */
/*    in the linked list, delete the first of the two used (unless it   */
/*    is the first for this curve).  Repeat this ITERATIONS times.        */

/*ARGSUSED*/
static void
LineApprox(p1, p2, p3)
Point *p1, *p2, *p3;
{
    Point   *p4, *p;
    int           reps = ITERATIONS;

    while (reps) {
      for (p = p1; p != (Point *)NULL && p != p3; ) {
          InsertPoint(p, p4 = MakePoint( midx(p,p->next), midy(p,p->next) ));
          if (p != p1)
            DeletePoint(p);
          p = p4->next;       /* skip inserted point! */
      }
      reps--;
    }
}


/*    Traverse the linked list, calling DrawLine to approximate the */
/*    spline curve.  Rounding errors are taken into account so that */
/*    the "curve" is continuous, and ends up where expected.            */

static void
DrawSplineSegments(dw)
DviWidget dw;
{
    Point   *p, *q;
    double  x1, y1;
    int           dx, dy;
    double  xpos, ypos;

    p = spline;
    dx = dy = 0;

    /* save the start position */

    xpos = dw->dvi.state->x;
    ypos = dw->dvi.state->y;

    x1 = y1 = 0.0;

    while (p != (Point *)NULL) {
      dx = p->x - x1 + 0.5;
      dy = p->y - y1 + 0.5;
      DrawLine (dw, dx, dy);

      x1 = p->x;
      y1 = p->y;
      dw->dvi.state->x = xpos + x1;
      dw->dvi.state->y = ypos + y1;

      q = p;
      p = p->next;
      XtFree((char *)q);
    }
    spline = (Point *)NULL;
}


/*    Malloc memory for a Point, and initialise the elements to x, y, NULL */
/*    Return a pointer to the new Point.                         */

static Point *
MakePoint(x, y)
double x, y;
{
    Point   *p;

    p = (Point *) XtMalloc (sizeof (Point));
    p->x = x;
    p->y = y;
    p->next = (Point *)NULL;

    return(p);
}


/*    Insert point q in linked list after point p. */

static void
InsertPoint(p, q)
Point *p, *q;
{
    /* point q to the next point */
    q->next = p->next;

    /* point p to new inserted one */
    p->next = q;
}

/*    Delete point p from the linked list. */

static void
DeletePoint(p)
Point *p;
{
    Point   *tmp;

    tmp = p->next;
    p->x = p->next->x;
    p->y = p->next->y;
    p->next = p->next->next;
    XtFree((char *)tmp);
}

Generated by  Doxygen 1.6.0   Back to index