usr/src/local/ditroff/ditroff.old.okeeffe/sunsrc/gremlin/db.c

/*
 * @(#)db.c     1.1     %G%
 *
 * This file contains routines for database manipulation for the
 * SUN Gremlin picture editor.
 *
 * Mark Opperman (opcode@monet.BERKELEY)
 *
 */

#include "gremlin.h"
#include <ctype.h>

/* imports from undodb */

extern UNRembAdd();
extern UNRembDelete();
extern UNRembMod();

/* imports from C */

extern char *malloc();

/* imports from point.c */

extern PTModifyTextPoints();
extern POINT *PTMakePoint();

/* imports from text.c  */

extern TxPutMsg();
extern TxMsgOK();

/* imports from main */

extern SEARCH;                  /* Search the path for filename */
extern TOOLINSTALLED;

/* cset is a pointer to the current set available to the outside world. */

ELT *cset;

#ifdef oldway
/*
 * This routine returns a pointer to an initialized database element
 * which would be the only element in an empty list.
 */
ELT *
DBInit()
{
    return((ELT *) NULL);
}
#endif


/*
 * This routine creates a new element with the specified attributes and
 * links it into database db.
 */
ELT *
DBCreateElt(type, pointlist, brush, size, text, db)
int type, brush, size;
POINT *pointlist;
char *text;
ELT *(*db);
{
    register ELT *temp;

    temp = (ELT *) malloc(sizeof(ELT));
    temp->nextelt = *db;
    temp->type = type;
    temp->ptlist = pointlist;
    temp->brushf = brush;
    temp->size = size;
    temp->textpt = text;
    *db = temp;
    UNRembAdd(temp, db);
    return(temp);
} /* end DBCreateElt */


/*
 * This routine deletes the specified element by searching the database
 * for its predecessor and deleting the pointer to the element.
 * Flag indicates whether or not the element was in the current set
 * and is passed along for use by the undo routines.
 */
DBDelete(elt, db)
register ELT *elt, *(*db);
{
    register ELT *(*temp);

    temp = db;

    while (*temp != elt) {
        if (DBNullelt(*temp)) {
            error("no such element");
            return;
        }
        temp = &(DBNextElt((*temp)));
    }

    UNRembDelete(*temp, db);
    *temp = DBNextElt(elt);
}  /* end DBDelete */


#define highval 100000                  /* arbitrary value greater than any
                                         * expected distance */


/*
 * This routine searches the database for the point closest to
 * (Euclidean distance) point1.  This point is returned as point2
 * and the element which contained the point is also returned.
 * The point must be closer than some predefined maximum distance
 * in order to be gravitated.
 * If setonly == TRUE the element's "setnext" pointer is used to
 * find the elements in the list, otherwise "nextelt" is used.
 */
DBGravitate(x1, y1, x2, y2, point, elt, db, setonly)
float x1, y1, *x2, *y2;
POINT *(*point);
ELT *(*elt), *db;
int setonly;
{
    register POINT *holdpt;
    register ELT *temp;
    register t, t1, t2;
    register distance = highval;

    temp = db;
    *elt = DBInit();
    *x2 = x1;
    *y2 = y1;
    while (!DBNullelt(temp)) {
        holdpt = temp->ptlist;
        while (!Nullpoint(holdpt)) {
            /* Calculate the distance between the point in the data
               base and the specified point.  Use Euclidean distance
               except that, since we only need relative distance and
               not an absolute number, it is not necessary to take the
               square root.  The equation for the distance was broken up
               as below in order to allow integer arithmetic wherever
               possible to increase efficiency when it was discovered
               that this routine was too slow. */
            t1 = holdpt->x - x1;
            t1 *= t1;
            t2 = holdpt->y - y1;
            t2 *= t2;
            t = t1 + t2;

            if ((t < distance) && (t < MAXGDIST)) {
                distance = t;
                *x2 = holdpt->x;
                *y2 = holdpt->y;
                *point = holdpt;
                *elt = temp;
            }

            holdpt = holdpt->nextpt;
        }
        temp = setonly ? DBNextofSet(temp) : DBNextElt(temp);
    }
}  /* end DBGravitate */


/*
 * This routine returns all storage associated with the element to
 * free storage.
 */
DBClearElt(elt)
register ELT *elt;
{
    register POINT *pt, *pt2;

    pt = elt->ptlist;

    while (!Nullpoint(pt)) {
        pt2 = PTNextPoint(pt);
        free ((char *) pt);
        pt = pt2;
    }

    free(elt->textpt);
    free((char *) elt);
}  /* end DBClearElt */


/*
 * This routine reads the specified file into a database and
 * returns a pointer to that database.  Orient and pos are also set
 * from the file.
 *
 * The format of a file written by gremlin is:
 * the string: "gremlinfile" followed by a carriage return.
 * the orientation (integer) and the x and y coordinates of a positioning
 * point (float) followed by another carriage return.
 * The output of 0 or more elements (see below).
 * a -1 (integer) indicating end of data.
 *
 * The format of each element is:
 * The element type (integer) followed by a carriage return.
 * a list of 0 or more pairs of point coordinates (float) each on separate
 * lines and terminated by the coordinates -1.0 -1.0.
 * the brush (font) and size (integer) the element was defined with then <cr>
 * the length (integer) of the string followed by the string terminated with
 * a carriage return.
 *
 * All numbers are printed using standard C output conversion (ascii).
 *
 * +++ NEW FORMAT FOR SUN +++
 *
 * "sungremlinfile" is keyword in place of "gremlinfile"
 *
 * Point lists are terminated by a line containing a single asterik ('*')
 * to allow the legal point (-1.00 -1.00) in the point list.  All negative
 * coordinates are now legal.  Element types are indicated by ascii text,
 * eg, POLYGON, VECTOR, ARC, BOTLEFT, TOPCENT, etc.
 */
ELT *
DBRead(filename, orient, pos)
char *filename;
int *orient;
POINT *pos;
{
    FILE *fp, *POpen();
    ELT *elt, *elist;
    POINT *plist;
    char string[128], *txt, *prealname;
    float x, y;
    int len, type, i, brush, size, done, lastpoint, sunfile;

    sunfile = FALSE;
    elist = DBInit();
    fp = POpen(filename, &prealname, SEARCH);

    if (fp == NULL) {
        (void) sprintf(string, "can't open %s",filename);
        error(string);
        return(elist);
    }

    if (TOOLINSTALLED)          /* no message if reading startup edit file */
        TxPutMsg("reading file...");
    (void) fscanf(fp, "%s\n", string);

    if (strcmp(string, "gremlinfile")) {
        if (strcmp(string, "sungremlinfile")) {
            error("not gremlin file");
            return(elist);
        }
        sunfile = TRUE;
    }

    (void) fscanf(fp, "%d%f%f\n", orient, &x, &y);
    pos->x = x;
    pos->y = y;

    done = FALSE;
    while (!done) {
        if (fscanf(fp,"%s\n", string) == EOF) {         /* element type */
            error("error in file format");
            fclose(fp);
            return(elist);
        }

        if ((type = DBGetType(string)) < 0) {           /* no more data */
            done = TRUE;
        }
        else {
            plist = PTInit();
            (void) fscanf(fp, "%f%f\n", &x, &y);        /* read first point */

            /* Files created on the SUN have point lists terminated
             * by a line containing only an asterik ('*').  Files
             * created on the AED have point lists terminated by the
             * coordinate pair (-1.00 -1.00).
             */
            lastpoint = FALSE;
            do {
                (void) PTMakePoint(x, y, &plist);
                fgets(string, 127, fp);
                if (string[0] == '*') {     /* SUN gremlin file */
                    lastpoint = TRUE;
                }
                else {
                    (void) sscanf(string, "%f%f", &x, &y);
                    if ((x == -1.00 && y == -1.00) && (!sunfile))
                        lastpoint = TRUE;
                }
            } while (!lastpoint);
#ifdef oldway
            while ((x != -1) && (y != -1)) { /* plist terminated by -1, -1 */
                (void) PTMakePoint(x, y, &plist);
                (void) fscanf(fp, "%f%f\n", &x, &y);
            }
#endif

            (void) fscanf(fp, "%d%d\n", &brush, &size);
            (void) fscanf(fp, "%d", &len);
            (void) getc(fp);    /* eat blank */
            txt = malloc((unsigned) len + 1);
            for (i=0; i<len; ++i)
                txt[i] = getc(fp);
            txt[len] = '\0';
            elt = DBCreateElt(type, plist, brush, size, txt, &elist);
            if (TEXT(elt->type))        /* recompute text reference points */
                PTModifyTextPoints(elt);
        }
    }

    TxMsgOK();
    fclose(fp);
    return(elist);
} /* end DBRead */


/*
 * Interpret element type in string s.
 * Old file format consisted of integer element types.
 * New file format has literal names for element types.
 */
DBGetType(s)
register char *s;
{
    if (isdigit(s[0]) || (s[0] == '-'))         /* old element format or EOF */
        return(atoi(s));

    switch (s[0]) {
        case 'P':
            return(POLYGON);
        case 'V':
            return(VECTOR);
        case 'A':
            return(ARC);
        case 'C':
            if (s[1] == 'U')
                return(CURVE);
            switch (s[4]) {
                case 'L':
                    return(CENTLEFT);
                case 'C':
                    return(CENTCENT);
                case 'R':
                    return(CENTRIGHT);
                default:
                    error("unknown element type");
                    return(-1);
            }
        case 'B':
            switch (s[3]) {
                case 'L':
                    return(BOTLEFT);
                case 'C':
                    return(BOTCENT);
                case 'R':
                    return(BOTRIGHT);
                default:
                    error("unknown element type");
                    return(-1);
            }
        case 'T':
            switch (s[3]) {
                case 'L':
                    return(TOPLEFT);
                case 'C':
                    return(TOPCENT);
                case 'R':
                    return(TOPRIGHT);
                default:
                    error("unknown element type");
                    return(-1);
            }
        default:
            error("unknown element type");
            return(-1);
    }
}  /* end DBGetType */


/*
 * This routine returns true if all points in elt are bounded by
 * the rectangle who diagonal is formed by (x1, y1) and (x2, y2).
 */
DBBounded(elt, x1, y1, x2, y2)
register ELT *elt;
register float x1, y1, x2, y2;
{
    register POINT *p1;
    register float lox, loy, hix, hiy;  /* OK to compare register floats */

    lox = (x1 < x2) ? x1 : x2;
    loy = (y1 < y2) ? y1 : y2;
    hix = (x1 > x2) ? x1 : x2;
    hiy = (y1 > y2) ? y1 : y2;
    p1 = elt->ptlist;

    while (!Nullpoint(p1)) {
        if ((p1->x < lox) || (p1->x > hix) || (p1->y < loy) || (p1->y > hiy))
            return(FALSE);
        p1 = PTNextPoint(p1);
    }

    return(TRUE);
}  /* end DBBounded */


/*
 * This routine creates a copy of the the element transformed by
 * the transformation matrix and adds the new copy to the database.
 */
ELT *
DBCopy(elt, transform, db)
register ELT *elt;
ELT *(*db);
float transform[3][2];
{
    register POINT *pt;
    POINT *newlist;
    char *newtext;

    newlist = PTInit();
    pt = elt->ptlist;

    while (!Nullpoint(pt)) { /* matrix multiply */
        (void) PTMakePoint((((pt->x) * transform[0][0]) +
                            ((pt->y) * transform[1][0]) +
                                       transform[2][0]),
                           (((pt->x) * transform[0][1]) +
                            ((pt->y) * transform[1][1]) +
                                       transform[2][1]), &newlist);
        pt = pt->nextpt;
    }

    newtext = malloc((unsigned) strlen(elt->textpt) + 1);
    (void) strcpy(newtext, elt->textpt);
    return( DBCreateElt(elt->type, newlist, elt->brushf,
                        elt->size, newtext, db) );
}  /* end DBCopy */


/*
 * This routine transforms the element by multiplying the
 * coordinates of each of the points in the element by the
 * transformation matrix.
 */
DBXform(elt, transform, db)
register ELT *elt;
float transform[3][2];
ELT *(*db);
{
    register POINT *pt;
    float px, py;

    UNRembMod(elt, db);
    pt = elt->ptlist;

    while (!Nullpoint(pt)) {
        px =  ((pt->x) * transform[0][0]) +
              ((pt->y) * transform[1][0]) + transform[2][0];
        py =  ((pt->x) * transform[0][1]) +
              ((pt->y) * transform[1][1]) + transform[2][1];
        pt->x = px;
        pt->y = py;
        pt = pt->nextpt;
    }
}  /* end DBXform */


/*
 * This routine changes the brush attribute of the element.
 */
DBChangeBrush(elt, brush, db)
ELT *elt, *(*db);
int brush;
{
    UNRembMod(elt, db);
    elt->brushf = brush;
}  /* end DBChangeBrush */


/*
 * This routine changes the justify attribute of the element.
 */
DBChangeJustify(elt, justmode, db)
ELT *elt, *(*db);
int justmode;
{
    register length;
    register POINT *pos, *point;

    UNRembMod(elt, db);
    elt->type = justmode;
    PTModifyTextPoints(elt);
}  /* end DBChangeJustify */


/*
 * This routine changes the font attribute of the given element.
 */
DBChangeFont(elt, font, db)
ELT *elt, *(*db);
int font;
{
    UNRembMod(elt, db);
    elt->brushf = font;
    PTModifyTextPoints(elt);
}  /* end DBChangeFont */


/*
 * This routine changes the size attribute of the given element.
 */
DBChangeSize(elt, size, db)
ELT *elt, *(*db);
int size;
{
    UNRembMod(elt, db);
    elt->size = size;
    PTModifyTextPoints(elt);
}  /* end DBChangeSize */


/*
 * This routine changes the stipple attribute of the given element.
 */
DBChangeStipple(elt, stipple, db)
ELT *elt, *(*db);
int stipple;
{
    UNRembMod(elt, db);
    elt->size = stipple;
}  /* end DBChangeStipple */


/*
 * This routine changes the text attribute of the given element.
 */
DBChangeText(elt, text, db)
ELT *elt, *(*db);
char *text;
{
    char *new;

    UNRembMod(elt, db);
    free(elt->textpt);
    new = malloc((unsigned) strlen(text) + 1);
    (void) strcpy(new, text);
    elt->textpt = new;
    PTModifyTextPoints(elt);
}  /* end DBChangeText */


/*
 * This routine changes the type attribute of the given element.
 */
DBChangeType(elt, newtype, db)
ELT *elt, *(*db);
int newtype;
{
    UNRembMod(elt, db);
    elt->type = newtype;
}  /* end DBChangeType */


/*
 * This routine changes the type and stipple attributes of the given element.
 */
DBChangeTypeStipple(elt, newtype, newstipple, db)
ELT *elt, *(*db);
int newtype, newstipple;
{
    UNRembMod(elt, db);
    elt->type = newtype;
    elt->size = newstipple;
}  /* end DBChangeType */


/*
 * This routine changes the type, brush and stipple attributes
 * of the given element.
 */
DBChangeTypeBrushStipple(elt, newtype, newbrush, newstipple, db)
ELT *elt, *(*db);
int newtype, newbrush, newstipple;
{
    UNRembMod(elt, db);
    elt->type = newtype;
    elt->brushf = newbrush;
    elt->size = newstipple;
}  /* end DBChangeType */


/*
 * This routine adds the element to the current set database.
 */
DBAddSet(elt)
register ELT *elt;
{
    register ELT *elist;

    elist = cset;

    while (!DBNullelt(elist)) { /* makes sure element not already in list */
        if (elist == elt)
            return;
        elist = DBNextofSet(elist);
    }

    elt->setnext = cset;
    cset = elt;
}  /* end DBAddSet */


/*
 *  Return TRUE if element in current set, else FALSE.
 */
DBInCset(elt)
register ELT *elt;
{
    register ELT *elist;

    elist = cset;

    while (!DBNullelt(elist)) { /* makes sure element not already in list */
        if (elist == elt)
            return(TRUE);
        elist = DBNextofSet(elist);
    }
    return(FALSE);
}  /* end DBInCset */


/*
 * This routine clears the current set by setting the pointer
 * to a null element.
 */
DBClearSet()
{
    while (!DBNullelt(cset))
        cset = DBNextofSet(cset);
}  /* end DBClearSet */