xref: /xsrc/external/mit/xditview/dist/draw.c

/*
 *
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
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#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 */

static 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(const 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);

#ifdef USE_XFT
static void
DrawText(DviWidget dw)
{
    XftFont *font = dw->dvi.cache.font;

    for (int 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(DviWidget dw)
{
    int xx = ToX(dw, dw->dvi.state->x);
    int 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;
}

void
SetGCForDraw(DviWidget dw)
{
    if (dw->dvi.state->line_style != dw->dvi.line_style ||
        dw->dvi.state->line_width != dw->dvi.line_width) {
        int 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(DviWidget dw, int x, int 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(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(DviWidget dw, int a, int 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(DviWidget dw, int x0, int y0, int x1, int y1)
{
    /* centre */
    int xc = dw->dvi.state->x + x0;
    int yc = dw->dvi.state->y + y0;

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

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

    if (dw->dvi.display_enable) {
        int angle1, angle2;

        /* radius */
        int 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 const char *
getstr(const char *p, char *temp, size_t temp_size)
{
    while (*p == ' ' || *p == '\t' || *p == '\n')
        p++;
    if (*p == '\0') {
        temp[0] = 0;
        return ((char *) NULL);
    }
    while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0') {
        /* leave room for trailing NIL byte */
        if (temp_size > 1) {
            *temp++ = *p++;
            temp_size--;
        }
    }
    *temp = '\0';
    return (p);
}

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

/*ARGSUSED*/
void
DrawSpline(DviWidget dw, const 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(const char *s)
{
    double x, y;
    int n = 0;
    Point *pt;
    const char *p = s;
    char d[10];

    if (!*p)
        return (n);

    pt = spline = MakePoint(0.0, 0.0);
    n = 1;
    x = y = 0.0;
    p = s;
    while (p && *p) {
        double x1, y1;

        if ((p = getstr(p, d, sizeof(d))) == (const char *) NULL)
            break;
        x1 = x + atof(d);
        if ((p = getstr(p, d, sizeof(d))) == (const 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(int n)
{
    int mid;
    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) {
        int j;

        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(Point *p1, Point *p2, Point *p3)
{
    int reps = ITERATIONS;

    while (reps) {
        for (Point *p = p1; p != (Point *) NULL && p != p3;) {
            Point *p4 = MakePoint(midx(p, p->next), midy(p, p->next));

            InsertPoint(p, p4);
            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(DviWidget dw)
{
    Point *p = spline;

    /* save the start position */
    double xpos = dw->dvi.state->x;
    double ypos = dw->dvi.state->y;

    double x1 = 0.0, y1 = 0.0;

    while (p != (Point *) NULL) {
        int dx = p->x - x1 + 0.5;
        int 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;

        Point *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(double x, double y)
{
    Point *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(Point *p, Point *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(Point *p)
{
    Point *tmp = p->next;

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