A number of updates supporting batch mode, for colors and fonts,

[xcircuit.git] / functions.c

/*-------------------------------------------------------------------------*/
/* functions.c                                                             */
/* Copyright (c) 2002  Tim Edwards, Johns Hopkins University               */
/*-------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------*/
/*      written by Tim Edwards, 8/13/93                                    */
/*-------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>

#ifndef _MSC_VER
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#endif

/*-------------------------------------------------------------------------*/
/* Local includes                                                          */
/*-------------------------------------------------------------------------*/

#ifdef TCL_WRAPPER 
#include <tk.h>
#endif

#include "colordefs.h"
#include "xcircuit.h"

/*----------------------------------------------------------------------*/
/* Function prototype declarations                                      */
/*----------------------------------------------------------------------*/
#include "prototypes.h"

/*-------------------------------------------------------------------------*/
/* External Variable definitions                                           */
/*-------------------------------------------------------------------------*/

extern Display *dpy;
extern Pixmap STIPPLE[8];
extern XCWindowData *areawin;
extern Globaldata xobjs;
extern int number_colors;
extern colorindex *colorlist;

/*------------------------------------------------------------------------*/
/* find the squared length of a wire (or distance between two points in   */
/* user space).                                                           */
/*------------------------------------------------------------------------*/

long sqwirelen(XPoint *userpt1, XPoint *userpt2)
{
  long xdist, ydist;

  xdist = (long)userpt2->x - (long)userpt1->x;
  ydist = (long)userpt2->y - (long)userpt1->y;
  return (xdist * xdist + ydist * ydist);
}

/*------------------------------------------------------------------------*/
/* floating-point version of the above                                    */
/*------------------------------------------------------------------------*/

float fsqwirelen(XfPoint *userpt1, XfPoint *userpt2)
{
  float xdist, ydist;

  xdist = userpt2->x - userpt1->x;
  ydist = userpt2->y - userpt1->y;
  return (xdist * xdist + ydist * ydist);
}

/*------------------------------------------------------------------------*/
/* Find absolute distance between two points in user space                */
/*------------------------------------------------------------------------*/

int wirelength(XPoint *userpt1, XPoint *userpt2)
{
  u_long xdist, ydist;

  xdist = (long)(userpt2->x) - (long)(userpt1->x);
  ydist = (long)(userpt2->y) - (long)(userpt1->y);
  return (int)sqrt((double)(xdist * xdist + ydist * ydist));
}

/*------------------------------------------------------------------------*/
/* Find the closest (squared) distance from a point to a line             */
/*------------------------------------------------------------------------*/

long finddist(XPoint *linept1, XPoint *linept2, XPoint *userpt)
{
   long a, b, c, frac;
   float protod;

   c = sqwirelen(linept1, linept2);
   a = sqwirelen(linept1, userpt);
   b = sqwirelen(linept2, userpt);
   frac = a - b;
   if (frac >= c) return b;       /* "=" is important if c = 0 ! */
   else if (-frac >= c) return a;
   else {
      protod = (float)(c + a - b);
      return (a - (long)((protod * protod) / (float)(c << 2)));
   }
}

/*----------------------------------------------------------------------*/
/* Decompose an arc segment into one to four bezier curves according    */
/* the approximation algorithm lifted from the paper by  L. Maisonobe   */
/* (spaceroots.org).  This decomposition is done when an arc in a path  */
/* is read from an (older) xcircuit file, or when an arc is a selected  */
/* item when a path is created.  Because arcs are decomposed when       */
/* encountered, we assume that the arc is the last element of the path. */
/*----------------------------------------------------------------------*/

void decomposearc(pathptr thepath)
{
   float fnc, ang1, ang2;
   short ncurves, i;
   arcptr thearc;
   genericptr *pgen;
   splineptr *newspline;
   double nu1, nu2, lambda1, lambda2, alpha, tansq;
   XfPoint E1, E2, Ep1, Ep2;
   Boolean reverse = FALSE;

   pgen = thepath->plist + thepath->parts - 1;
   if (ELEMENTTYPE(*pgen) != ARC) return;
   thearc = TOARC(pgen);

   if (thearc->radius < 0) {
      reverse = TRUE;
      thearc->radius = -thearc->radius;
   }

   fnc = (thearc->angle2 - thearc->angle1) / 90.0;
   ncurves = (short)fnc;
   if (fnc - (float)((int)fnc) > 0.01) ncurves++;

   thepath->parts--;  /* Forget the arc */

   for (i = 0; i < ncurves; i++) {
      if (reverse) {                    /* arc path is reverse direction */
         if (i == 0)
            ang1 = thearc->angle2;
         else
            ang1 -= 90;

         if (i == ncurves - 1)
            ang2 = thearc->angle1;
         else
            ang2 = ang1 - 90;
      }
      else {                            /* arc path is forward direction */
         if (i == 0)
            ang1 = thearc->angle1;
         else
            ang1 += 90;

         if (i == ncurves - 1)
            ang2 = thearc->angle2;
         else
            ang2 = ang1 + 90;
      }

      lambda1 = (double)ang1 * RADFAC;
      lambda2 = (double)ang2 * RADFAC;

      nu1 = atan2(sin(lambda1) / (double)thearc->yaxis,
                cos(lambda1) / (double)thearc->radius);
      nu2 = atan2(sin(lambda2) / (double)thearc->yaxis,
                cos(lambda2) / (double)thearc->radius);
      E1.x = (float)thearc->position.x + 
                (float)thearc->radius * (float)cos(nu1);
      E1.y = (float)thearc->position.y +
                (float)thearc->yaxis * (float)sin(nu1);
      E2.x = (float)thearc->position.x + 
                (float)thearc->radius * (float)cos(nu2);
      E2.y = (float)thearc->position.y +
                (float)thearc->yaxis * (float)sin(nu2);
      Ep1.x = -(float)thearc->radius * (float)sin(nu1);
      Ep1.y = (float)thearc->yaxis * (float)cos(nu1);
      Ep2.x = -(float)thearc->radius * (float)sin(nu2);
      Ep2.y = (float)thearc->yaxis * (float)cos(nu2);

      tansq = tan((nu2 - nu1) / 2.0);
      tansq *= tansq;
      alpha = sin(nu2 - nu1) * 0.33333 * (sqrt(4 + (3 * tansq)) - 1);

      NEW_SPLINE(newspline, thepath);
      splinedefaults(*newspline, 0, 0);
      (*newspline)->style = thearc->style;
      (*newspline)->color = thearc->color;
      (*newspline)->width = thearc->width;

      (*newspline)->ctrl[0].x = E1.x;
      (*newspline)->ctrl[0].y = E1.y;

      (*newspline)->ctrl[1].x = E1.x + alpha * Ep1.x;
      (*newspline)->ctrl[1].y = E1.y + alpha * Ep1.y;

      (*newspline)->ctrl[2].x = E2.x - alpha * Ep2.x;
      (*newspline)->ctrl[2].y = E2.y - alpha * Ep2.y;

      (*newspline)->ctrl[3].x = E2.x;
      (*newspline)->ctrl[3].y = E2.y;

      calcspline(*newspline);
   }

   /* Delete the arc */
   free_single((genericptr)thearc);
}

/*----------------------------------------------------------------------*/
/* Calculate points for an arc                                          */
/*----------------------------------------------------------------------*/

void calcarc(arcptr thearc)
{
   short idx;
   int sarc;
   float theta, delta;

   /* assume that angle2 > angle1 always: must be guaranteed by other routines */

   sarc = (int)(thearc->angle2 - thearc->angle1) * RSTEPS;
   thearc->number = (sarc / 360) + 1;
   if (sarc % 360 != 0) thearc->number++;
           
   delta = RADFAC * ((float)(thearc->angle2 - thearc->angle1) / (thearc->number - 1));
   theta = thearc->angle1 * RADFAC;

   for (idx = 0; idx < thearc->number - 1; idx++) {
      thearc->points[idx].x = (float)thearc->position.x + 
           fabs((float)thearc->radius) * cos(theta);
      thearc->points[idx].y = (float)thearc->position.y +
           (float)thearc->yaxis * sin(theta);
      theta += delta;
   }

   /* place last point exactly to avoid roundoff error */

   theta = thearc->angle2 * RADFAC;
   thearc->points[thearc->number - 1].x = (float)thearc->position.x + 
           fabs((float)thearc->radius) * cos(theta);
   thearc->points[thearc->number - 1].y = (float)thearc->position.y +
           (float)thearc->yaxis * sin(theta);

   if (thearc->radius < 0) reversefpoints(thearc->points, thearc->number);
}

/*------------------------------------------------------------------------*/
/* Create a Bezier curve approximation from control points                */
/* (using PostScript formula for Bezier cubic curve)                      */
/*------------------------------------------------------------------------*/

float par[INTSEGS];
float parsq[INTSEGS];
float parcb[INTSEGS];

void initsplines()
{
   float t;
   short idx;

   for (idx = 0; idx < INTSEGS; idx++) {
      t = (float)(idx + 1) / (INTSEGS + 1);
      par[idx] = t;
      parsq[idx] = t * t;
      parcb[idx] = parsq[idx] * t;
   }
}

/*------------------------------------------------------------------------*/
/* Compute spline coefficients                                            */
/*------------------------------------------------------------------------*/

void computecoeffs(splineptr thespline, float *ax, float *bx, float *cx,
        float *ay, float *by, float *cy)
{
   *cx = 3.0 * (float)(thespline->ctrl[1].x - thespline->ctrl[0].x);
   *bx = 3.0 * (float)(thespline->ctrl[2].x - thespline->ctrl[1].x) - *cx;
   *ax = (float)(thespline->ctrl[3].x - thespline->ctrl[0].x) - *cx - *bx;

   *cy = 3.0 * (float)(thespline->ctrl[1].y - thespline->ctrl[0].y);
   *by = 3.0 * (float)(thespline->ctrl[2].y - thespline->ctrl[1].y) - *cy;
   *ay = (float)(thespline->ctrl[3].y - thespline->ctrl[0].y) - *cy - *by;   
}

/*------------------------------------------------------------------------*/

void calcspline(splineptr thespline)
{
   float ax, bx, cx, ay, by, cy;
   short idx;

   computecoeffs(thespline, &ax, &bx, &cx, &ay, &by, &cy);
   for (idx = 0; idx < INTSEGS; idx++) {
      thespline->points[idx].x = ax * parcb[idx] + bx * parsq[idx] +
         cx * par[idx] + (float)thespline->ctrl[0].x;
      thespline->points[idx].y = ay * parcb[idx] + by * parsq[idx] +
         cy * par[idx] + (float)thespline->ctrl[0].y;
   }
}

/*------------------------------------------------------------------------*/
/* Find the (x,y) position and tangent rotation of a point on a spline    */
/*------------------------------------------------------------------------*/

void findsplinepos(splineptr thespline, float t, XPoint *retpoint, float *retrot)
{
   float ax, bx, cx, ay, by, cy;
   float tsq = t * t;
   float tcb = tsq * t;
   double dxdt, dydt;

   computecoeffs(thespline, &ax, &bx, &cx, &ay, &by, &cy);
   retpoint->x = (short)(ax * tcb + bx * tsq + cx * t + (float)thespline->ctrl[0].x);
   retpoint->y = (short)(ay * tcb + by * tsq + cy * t + (float)thespline->ctrl[0].y);

   if (retrot != NULL) {
      dxdt = (double)(3 * ax * tsq + 2 * bx * t + cx);
      dydt = (double)(3 * ay * tsq + 2 * by * t + cy);
      *retrot = INVRFAC * atan2(dxdt, dydt);  /* reversed y, x */
      if (*retrot < 0) *retrot += 360;
   }
}

/*------------------------------------------------------------------------*/
/* floating-point version of the above                                    */
/*------------------------------------------------------------------------*/

void ffindsplinepos(splineptr thespline, float t, XfPoint *retpoint)
{
   float ax, bx, cx, ay, by, cy;
   float tsq = t * t;
   float tcb = tsq * t;

   computecoeffs(thespline, &ax, &bx, &cx, &ay, &by, &cy);
   retpoint->x = ax * tcb + bx * tsq + cx * t + (float)thespline->ctrl[0].x;
   retpoint->y = ay * tcb + by * tsq + cy * t + (float)thespline->ctrl[0].y;
}

/*------------------------------------------------------------------------*/
/* Find the closest distance between a point and a spline and return the  */
/* fractional distance along the spline of this point.                    */
/*------------------------------------------------------------------------*/

float findsplinemin(splineptr thespline, XPoint *upoint)
{
   XfPoint      *spt, flpt, newspt;
   float        minval = 1000000, tval, hval, ndist;
   short        j, ival;

   flpt.x = (float)(upoint->x);
   flpt.y = (float)(upoint->y);

   /* get estimate from precalculated spline points */

   for (spt = thespline->points; spt < thespline->points + INTSEGS;
        spt++) {
      ndist = fsqwirelen(spt, &flpt);
      if (ndist < minval) {
         minval = ndist;
         ival = (short)(spt - thespline->points);
      }
   }
   tval = (float)(ival + 1) / (INTSEGS + 1);
   hval = 0.5 / (INTSEGS + 1);

   /* short fixed iterative loop to converge on minimum t */

   for (j = 0; j < 5; j++) {
      tval += hval;
      ffindsplinepos(thespline, tval, &newspt);
      ndist = fsqwirelen(&newspt, &flpt);
      if (ndist < minval) minval = ndist;
      else {
         tval -= hval * 2;
         ffindsplinepos(thespline, tval, &newspt);
         ndist = fsqwirelen(&newspt, &flpt);
         if (ndist < minval) minval = ndist;
         else tval += hval;
      }
      hval /= 2;
   }

   if (tval < 0.1) {
      if ((float)sqwirelen(&(thespline->ctrl[0]), upoint) < minval) tval = 0;
   }
   else if (tval > 0.9) {
      if ((float)sqwirelen(&(thespline->ctrl[3]), upoint) < minval) tval = 1;
   }
   return tval;
}

/*----------------------------------------------------------------------*/
/* Convert a polygon to a Bezier curve path                             */
/* Curve must be selected and there must be only one selection.         */
/*                                                                      */
/* Note that this routine will draw inside the perimeter of a convex    */
/* hull.  A routine that places spline endpoints on the polygon         */
/* vertices will draw outside the perimeter of a convex hull.  An       */
/* optimal algorithm presumably zeros the total area between the curve  */
/* and the polygon (positive and negative), but I haven't worked out    */
/* what that solution is.  The algorithm below seems good enough for    */
/* most purposes.                                                       */
/*----------------------------------------------------------------------*/

void converttocurve()
{
   genericptr *ggen;
   splineptr *newspline;
   polyptr thispoly;
   pathptr *newpath;
   short *newselect;
   XPoint firstpoint, lastpoint, initpoint;
   int i, numpoints;

   if (areawin->selects != 1) return;

   thispoly = TOPOLY(topobject->plist + (*areawin->selectlist));
   if (ELEMENTTYPE(thispoly) != POLYGON) return;
   if (thispoly->number < 3) return;    /* Will not convert */

   standard_element_delete(ERASE);
   if ((thispoly->style & UNCLOSED) && (thispoly->number == 3)) {
      NEW_SPLINE(newspline, topobject);
      splinedefaults(*newspline, 0, 0);
      (*newspline)->ctrl[0] = thispoly->points[0];
      (*newspline)->ctrl[1] = thispoly->points[1];
      (*newspline)->ctrl[2] = thispoly->points[1];
      (*newspline)->ctrl[3] = thispoly->points[2];
   }
   else {
      numpoints = thispoly->number;

      /* If the polygon is closed but the first and last points */
      /* overlap, treat the last point as if it doesn't exist.  */

      if (!(thispoly->style & UNCLOSED))
         if ((thispoly->points[0].x == thispoly->points[thispoly->number - 1].x)
                && (thispoly->points[0].y ==
                thispoly->points[thispoly->number - 1].y))
            numpoints--;

      NEW_PATH(newpath, topobject);
      pathdefaults(*newpath, 0, 0);
      (*newpath)->style = thispoly->style;

      if (!(thispoly->style & UNCLOSED)) {
         lastpoint = thispoly->points[numpoints - 1];
         initpoint.x = (lastpoint.x + thispoly->points[0].x) / 2;
         initpoint.y = (lastpoint.y + thispoly->points[0].y) / 2;
         firstpoint.x = (thispoly->points[0].x
                + thispoly->points[1].x) / 2;
         firstpoint.y = (thispoly->points[0].y
                        + thispoly->points[1].y) / 2;

         NEW_SPLINE(newspline, (*newpath));
         splinedefaults(*newspline, 0, 0);
         (*newspline)->ctrl[0] = initpoint;
         (*newspline)->ctrl[1] = thispoly->points[0];
         (*newspline)->ctrl[2] = thispoly->points[0];
         (*newspline)->ctrl[3] = firstpoint;
         calcspline(*newspline);
      }
      else
         firstpoint = thispoly->points[0];

      for (i = 0; i < numpoints - ((!(thispoly->style & UNCLOSED)) ?
                2 : 3); i++) {
         lastpoint.x = (thispoly->points[i + 1].x
                + thispoly->points[i + 2].x) / 2;
         lastpoint.y = (thispoly->points[i + 1].y
                        + thispoly->points[i + 2].y) / 2;

         NEW_SPLINE(newspline, (*newpath));
         splinedefaults(*newspline, 0, 0);
         (*newspline)->ctrl[0] = firstpoint;
         (*newspline)->ctrl[1] = thispoly->points[i + 1];
         (*newspline)->ctrl[2] = thispoly->points[i + 1];
         (*newspline)->ctrl[3] = lastpoint;
         firstpoint = lastpoint;
         calcspline(*newspline);
      }
      if (!(thispoly->style & UNCLOSED))
         lastpoint = initpoint;
      else
         lastpoint = thispoly->points[i + 2];

      NEW_SPLINE(newspline, (*newpath));
      splinedefaults(*newspline, 0, 0);
      (*newspline)->ctrl[0] = firstpoint;
      (*newspline)->ctrl[1] = thispoly->points[i + 1];
      (*newspline)->ctrl[2] = thispoly->points[i + 1];
      (*newspline)->ctrl[3] = lastpoint;
   }
   calcspline(*newspline);
   calcbbox(areawin->topinstance);
   setoptionmenu();
   drawarea(NULL, NULL, NULL);
}

/*----------------------------------------------------------------------*/
/* Find closest point of a polygon to the cursor                        */
/*----------------------------------------------------------------------*/

short closepointdistance(polyptr curpoly, XPoint *cursloc, short *mindist)
{
   short curdist;
   XPoint *curpt, *savept; 

   curpt = savept = curpoly->points;
   *mindist = wirelength(curpt, cursloc);
   while (++curpt < curpoly->points + curpoly->number) {
      curdist = wirelength(curpt, cursloc);
      if (curdist < *mindist) {
         *mindist = curdist;
         savept = curpt;
      }
   }
   return (short)(savept - curpoly->points);
}

/*----------------------------------------------------------------------------*/
/* Find closest point of a polygon to the cursor                              */
/*----------------------------------------------------------------------------*/

short closepoint(polyptr curpoly, XPoint *cursloc)
{
   short mindist;
   return closepointdistance(curpoly, cursloc, &mindist);
}

/*----------------------------------------------------------------------------*/
/* Find the distance to the closest point of a polygon to the cursor          */
/*----------------------------------------------------------------------------*/

short closedistance(polyptr curpoly, XPoint *cursloc)
{
   short mindist;
   closepointdistance(curpoly, cursloc, &mindist);
   return mindist;
}

/*----------------------------------------------------------------------------*/
/* Coordinate system transformations                                          */
/*----------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------*/
/*  Check screen bounds:  minimum, maximum scale and translation is determined  */
/*  by values which fit in an X11 type XPoint (short int).  If the window       */
/*  extremes exceed type short when mapped to user space, or if the page        */
/*  bounds exceed type short when mapped to X11 window space, return error.     */ 
/*------------------------------------------------------------------------------*/

short checkbounds()
{
   long lval;

   /* check window-to-user space */

   lval = 2 * (long)((float) (areawin->width) / areawin->vscale) +
        (long)areawin->pcorner.x;
   if (lval != (long)((short)lval)) return -1;
   lval = 2 * (long)((float) (areawin->height) / areawin->vscale) +
        (long)areawin->pcorner.y;
   if (lval != (long)((short)lval)) return -1;

   /* check user-to-window space */

   lval = (long)((float)(topobject->bbox.lowerleft.x - areawin->pcorner.x) *
        areawin->vscale);
   if (lval != (long)((short)lval)) return -1;
   lval = (long)areawin->height - (long)((float)(topobject->bbox.lowerleft.y -
        areawin->pcorner.y) * areawin->vscale); 
   if (lval != (long)((short)lval)) return -1;

   lval = (long)((float)(topobject->bbox.lowerleft.x + topobject->bbox.width -
        areawin->pcorner.x) * areawin->vscale);
   if (lval != (long)((short)lval)) return -1;
   lval = (long)areawin->height - (long)((float)(topobject->bbox.lowerleft.y +
        topobject->bbox.height - areawin->pcorner.y) * areawin->vscale); 
   if (lval != (long)((short)lval)) return -1;

   return 0;
}

/*------------------------------------------------------------------------*/
/* Transform X-window coordinate to xcircuit coordinate system            */
/*------------------------------------------------------------------------*/

void window_to_user(short xw, short yw, XPoint *upt)
{
  float tmpx, tmpy;

  tmpx = (float)xw / areawin->vscale + (float)areawin->pcorner.x;
  tmpy = (float)(areawin->height - yw) / areawin->vscale + 
        (float)areawin->pcorner.y;

  tmpx += (tmpx > 0) ? 0.5 : -0.5;
  tmpy += (tmpy > 0) ? 0.5 : -0.5;

  upt->x = (short)tmpx;
  upt->y = (short)tmpy;
}

/*------------------------------------------------------------------------*/
/* Transform xcircuit coordinate back to X-window coordinate system       */
/*------------------------------------------------------------------------*/

void user_to_window(XPoint upt, XPoint *wpt)
{
  float tmpx, tmpy;

  tmpx = (float)(upt.x - areawin->pcorner.x) * areawin->vscale;
  tmpy = (float)areawin->height - (float)(upt.y - areawin->pcorner.y)
        * areawin->vscale; 

  tmpx += (tmpx > 0) ? 0.5 : -0.5;
  tmpy += (tmpy > 0) ? 0.5 : -0.5;

  wpt->x = (short)tmpx;
  wpt->y = (short)tmpy;
}

/*----------------------------------------------------------------------*/
/* Transformations in the object hierarchy                              */
/*----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*/
/* Return rotation relative to a specific CTM                           */
/*----------------------------------------------------------------------*/

float UGetCTMRotation(Matrix *ctm)
{
   float rads = (float)atan2((double)(ctm->d), (double)(ctm->a));
   return rads / RADFAC;
}

/*----------------------------------------------------------------------*/
/* Return rotation relative to the top level                            */
/* Note that UTopRotation() is also the rotation relative to the window */
/* since the top-level drawing page is always upright relative to the   */
/* window.  Thus, there is no routine UTopDrawingRotation().            */
/*----------------------------------------------------------------------*/

float UTopRotation()
{
   return UGetCTMRotation(DCTM);
}

/*----------------------------------------------------------------------*/
/* Return scale relative to a specific CTM                              */
/*----------------------------------------------------------------------*/

float UGetCTMScale(Matrix *ctm)
{
   return (float)(sqrt((double)(ctm->a * ctm->a + ctm->d * ctm->d)));
}

/*----------------------------------------------------------------------*/
/* Return scale relative to window                                      */
/*----------------------------------------------------------------------*/

float UTopScale()
{
   return UGetCTMScale(DCTM);
}

/*----------------------------------------------------------------------*/
/* Return scale multiplied by length                                    */
/*----------------------------------------------------------------------*/

float UTopTransScale(float length)
{
   return (float)(length * UTopScale());
}

/*----------------------------------------------------------------------*/
/* Return scale relative to the top-level schematic (not the window)    */
/*----------------------------------------------------------------------*/

float UTopDrawingScale()
{
   Matrix lctm, wctm;
   UCopyCTM(DCTM, &lctm);
   UResetCTM(&wctm);
   UMakeWCTM(&wctm);
   InvertCTM(&wctm);
   UPreMultCTMbyMat(&wctm, &lctm);
   return UGetCTMScale(&wctm);
}

/*----------------------------------------------------------------------*/
/* Return position offset relative to a specific CTM                    */
/*----------------------------------------------------------------------*/

void UGetCTMOffset(Matrix *ctm, int *offx, int *offy)
{
   if (offx) *offx = (int)ctm->c;
   if (offy) *offy = (int)ctm->f;
}

/*----------------------------------------------------------------------*/
/* Return position offset relative to top-level                         */
/*----------------------------------------------------------------------*/

void UTopOffset(int *offx, int *offy)
{
   UGetCTMOffset(DCTM, offx, offy);
}

/*----------------------------------------------------------------------*/
/* Return postion relative to the top-level schematic (not the window)  */
/*----------------------------------------------------------------------*/

void UTopDrawingOffset(int *offx, int *offy)
{
   Matrix lctm, wctm;
   UCopyCTM(DCTM, &lctm);
   UResetCTM(&wctm);
   UMakeWCTM(&wctm);
   InvertCTM(&wctm);
   UPreMultCTMbyMat(&wctm, &lctm);
   UGetCTMOffset(&wctm, offx, offy);
}

/*----------------------------------------------------------------------*/
/* Get the cursor position                                              */
/*----------------------------------------------------------------------*/

XPoint UGetCursor()
{
   Window nullwin;
   int    nullint, xpos, ypos;
   u_int   nullui;
   XPoint newpos;
 
#ifdef TCL_WRAPPER
   /* Don't use areawin->window;  if called from inside an object       */
   /* (e.g., "here" in a Tcl expression), areawin->window will be       */
   /* an off-screen pixmap, and cause a crash.                          */
#ifndef _MSC_VER
   XQueryPointer(dpy, Tk_WindowId(areawin->area), &nullwin, &nullwin,
        &nullint, &nullint, &xpos, &ypos, &nullui);
#else
   XQueryPointer_TkW32(dpy, Tk_WindowId(areawin->area), &nullwin, &nullwin,
        &nullint, &nullint, &xpos, &ypos, &nullui);
#endif
#else
   XQueryPointer(dpy, areawin->window, &nullwin, &nullwin, &nullint,
        &nullint, &xpos, &ypos, &nullui);
#endif

   newpos.x = xpos;
   newpos.y = ypos;

   return newpos;
}

/*----------------------------------------------------------------------*/
/* Get the cursor position and translate to user coordinates            */
/*----------------------------------------------------------------------*/

XPoint UGetCursorPos()
{
   XPoint winpos, userpos;
 
   winpos = UGetCursor();

   window_to_user(winpos.x, winpos.y, &userpos);  

   return userpos;
}

/*----------------------------------------------------------------------*/
/* Translate a point to the nearest snap-to grid point                  */
/*----------------------------------------------------------------------*/
/* user coordinates to user coordinates version                         */

void u2u_snap(XPoint *uvalue)
{
   float tmpx, tmpy;
   float tmpix, tmpiy;

   if (areawin->snapto) {
      tmpx = (float)uvalue->x / xobjs.pagelist[areawin->page]->snapspace;
      if (tmpx > 0)
         tmpix = (float)((int)(tmpx + 0.5));
      else
         tmpix = (float)((int)(tmpx - 0.5));

      tmpy = (float)uvalue->y / xobjs.pagelist[areawin->page]->snapspace;
      if (tmpy > 0)
         tmpiy = (float)((int)(tmpy + 0.5));
      else
         tmpiy = (float)((int)(tmpy - 0.5));

      tmpix *= xobjs.pagelist[areawin->page]->snapspace;
      tmpix += (tmpix > 0) ? 0.5 : -0.5;
      tmpiy *= xobjs.pagelist[areawin->page]->snapspace;
      tmpiy += (tmpiy > 0) ? 0.5 : -0.5;

      uvalue->x = (int)tmpix;
      uvalue->y = (int)tmpiy;
   }
}

/*------------------------------------------------------------------------*/
/* window coordinates to user coordinates version                         */
/*------------------------------------------------------------------------*/

void snap(short valuex, short valuey, XPoint *returnpt)
{
   window_to_user(valuex, valuey, returnpt);  
   u2u_snap(returnpt);
}

/*------------------------------------------------------------------------*/
/* Transform object coordinates through scale, translation, and rotation  */
/* This routine attempts to match the PostScript definition of trans-     */
/*    formation matrices.                                                 */
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Current transformation matrix manipulation routines                    */
/*------------------------------------------------------------------------*/

void UResetCTM(Matrix *ctm)
{
   ctm->a = ctm->e = 1;
   ctm->b = ctm->d = 0;
   ctm->c = ctm->f = 0;  /* 0.5 for nearest-int real->int conversion? */

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*------------------------------------------------------------------------*/

void InvertCTM(Matrix *ctm)
{
   float det = ctm->a * ctm->e - ctm->b * ctm->d;
   float tx = ctm->b * ctm->f - ctm->c * ctm->e;
   float ty = ctm->d * ctm->c - ctm->a * ctm->f;

   float tmpa = ctm->a;

   ctm->b = -ctm->b / det;
   ctm->d = -ctm->d / det;

   ctm->a = ctm->e / det;
   ctm->e = tmpa / det;
   ctm->c = tx / det;
   ctm->f = ty / det;

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*------------------------------------------------------------------------*/

void UCopyCTM(fctm, tctm)
   Matrix *fctm, *tctm;
{
   tctm->a = fctm->a;
   tctm->b = fctm->b;
   tctm->c = fctm->c;
   tctm->d = fctm->d;
   tctm->e = fctm->e;
   tctm->f = fctm->f;

#ifdef HAVE_CAIRO
   if (tctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(tctm);
#endif /* HAVE_CAIRO */
}

/*-------------------------------------------------------------------------*/
/* Multiply CTM by current screen position and scale to get transformation */
/* matrix from a user point to the X11 window                              */
/*-------------------------------------------------------------------------*/

void UMakeWCTM(Matrix *ctm)
{
   ctm->a *= areawin->vscale;
   ctm->b *= areawin->vscale;
   ctm->c = (ctm->c - (float)areawin->pcorner.x) * areawin->vscale
         + areawin->panx;
   
   ctm->d *= -areawin->vscale;
   ctm->e *= -areawin->vscale;
   ctm->f = (float)areawin->height + ((float)areawin->pcorner.y - ctm->f) *
         areawin->vscale + areawin->pany;

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*------------------------------------------------------------------------*/

void UMultCTM(Matrix *ctm, XPoint position, float scale, float rotate)
{
   float tmpa, tmpb, tmpd, tmpe, yscale;
   float mata, matb, matc;
   double drot = (double)rotate * RADFAC;

   yscale = abs(scale);  /* -scale implies flip in x direction only */ 
   
   tmpa =  scale * cos(drot);
   tmpb = yscale * sin(drot);
   tmpd = -scale * sin(drot);
   tmpe = yscale * cos(drot);

   mata = ctm->a * tmpa + ctm->d * tmpb;
   matb = ctm->b * tmpa + ctm->e * tmpb;
   matc = ctm->c * tmpa + ctm->f * tmpb + position.x;

   ctm->d = ctm->d * tmpe + ctm->a * tmpd;
   ctm->e = ctm->e * tmpe + ctm->b * tmpd;
   ctm->f = ctm->f * tmpe + ctm->c * tmpd + position.y; 

   ctm->a = mata;
   ctm->b = matb;
   ctm->c = matc;

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*----------------------------------------------------------------------*/
/* Slanting function x' = x + beta * y, y' = y                          */
/*----------------------------------------------------------------------*/

void USlantCTM(Matrix *ctm, float beta)
{
   ctm->b += ctm->a * beta;
   ctm->e += ctm->d * beta;

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

#define EPS 1e-9
/*----------------------------------------------------------------------*/
/* Transform text to make it right-side up within 90 degrees of page    */
/* NOTE:  This is not yet resolved, as xcircuit does not agree with     */
/* PostScript in a few cases!                                           */
/*----------------------------------------------------------------------*/

void UPreScaleCTM(Matrix *ctm)
{
   /* negative X scale (-1, +1) */
   if ((ctm->a < -EPS) || ((ctm->a < EPS) && (ctm->a > -EPS) &&
                ((ctm->d * ctm->b) < 0))) {
      ctm->a = -ctm->a;
      ctm->d = -ctm->d;
   }

   /* negative Y scale (+1, -1) */
   if (ctm->e > EPS) {
      ctm->e = -ctm->e;
      ctm->b = -ctm->b;
   }

   /* At 90, 270 degrees need special attention to avoid discrepencies  */
   /* with the PostScript output due to roundoff error.  This code      */
   /* matches what PostScript produces.                                 */

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*----------------------------------------------------------------------*/
/* Adjust anchoring and CTM as necessary for flip invariance            */
/*----------------------------------------------------------------------*/

short flipadjust(short anchor)
{
   short tmpanchor = anchor & (~FLIPINV);

   if (anchor & FLIPINV) {
      if (((DCTM)->a < -EPS) || (((DCTM)->a < EPS) && ((DCTM)->a > -EPS) &&
                (((DCTM)->d * (DCTM)->b) < 0))) {
         if ((tmpanchor & (RIGHT | NOTLEFT)) != NOTLEFT)
            tmpanchor ^= (RIGHT | NOTLEFT);

         /* NOTE:  Justification does not change under flip invariance. */
      }   
      if ((DCTM)->e > EPS) {
         if ((tmpanchor & (TOP | NOTBOTTOM)) != NOTBOTTOM) 
            tmpanchor ^= (TOP | NOTBOTTOM);
      }
      UPreScaleCTM(DCTM);
   }      
   return tmpanchor;
}

/*------------------------------------------------------------------------*/

void UPreMultCTM(Matrix *ctm, XPoint position, float scale, float rotate)
{
   float tmpa, tmpb, tmpd, tmpe, yscale;
   float mata, matd;
   double drot = (double)rotate * RADFAC;

   yscale = abs(scale);         /* negative scale value implies flip in x only */
   
   tmpa =  scale * cos(drot);
   tmpb = yscale * sin(drot);
   tmpd = -scale * sin(drot);
   tmpe = yscale * cos(drot);
   
   ctm->c += ctm->a * position.x + ctm->b * position.y;
   ctm->f += ctm->d * position.x + ctm->e * position.y;

   mata = ctm->a * tmpa + ctm->b * tmpd;
   ctm->b = ctm->a * tmpb + ctm->b * tmpe;

   matd = ctm->d * tmpa + ctm->e * tmpd;
   ctm->e = ctm->d * tmpb + ctm->e * tmpe;

   ctm->a = mata;
   ctm->d = matd;

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*----------------------------------------------------------------------*/
/* Direct Matrix-Matrix multiplication                                  */
/*----------------------------------------------------------------------*/

void UPreMultCTMbyMat(Matrix *ctm, Matrix *pre)
{
   float mata, matd;

   mata = pre->a * ctm->a + pre->d * ctm->b;
   ctm->c += pre->c * ctm->a + pre->f * ctm->b;
   ctm->b = pre->b * ctm->a + pre->e * ctm->b;
   ctm->a = mata;

   matd = pre->a * ctm->d + pre->d * ctm->e;
   ctm->f += pre->c * ctm->d + pre->f * ctm->e;
   ctm->e = pre->b * ctm->d + pre->e * ctm->e;
   ctm->d = matd;

#ifdef HAVE_CAIRO
   if (ctm == DCTM && areawin->redraw_ongoing)
      xc_cairo_set_matrix(ctm);
#endif /* HAVE_CAIRO */
}

/*------------------------------------------------------------------------*/

void UTransformbyCTM(Matrix *ctm, XPoint *ipoints, XPoint *points, short number)
{
   pointlist current, ptptr = points;
   float fx, fy;
   /* short tmpx; (jdk) */

   for (current = ipoints; current < ipoints + number; current++, ptptr++) {
      fx = ctm->a * (float)current->x + ctm->b * (float)current->y + ctm->c;
      fy = ctm->d * (float)current->x + ctm->e * (float)current->y + ctm->f;
        
      ptptr->x = (fx >= 0) ? (short)(fx + 0.5) : (short)(fx - 0.5);
      ptptr->y = (fy >= 0) ? (short)(fy + 0.5) : (short)(fy - 0.5);
   }
}
  
/*------------------------------------------------------------------------*/
/* (same as above routine but using type (float) for point values;  this  */
/* is for calculation of Bezier curve internal points.                    */
/*------------------------------------------------------------------------*/

void UfTransformbyCTM(Matrix *ctm, XfPoint *fpoints, XPoint *points, short number)
{
   fpointlist current;
   pointlist new = points;
   float fx, fy;

   for (current = fpoints; current < fpoints + number; current++, new++) {
      fx = ctm->a * current->x + ctm->b * current->y + ctm->c;
      fy = ctm->d * current->x + ctm->e * current->y + ctm->f;
      new->x = (fx >= 0) ? (short)(fx + 0.5) : (short)(fx - 0.5);
      new->y = (fy >= 0) ? (short)(fy + 0.5) : (short)(fy - 0.5);
   }
}

/*------------------------------------------------------------------------*/

void UPopCTM()
{
   Matrixptr lastmatrix;

   if (areawin->MatStack == NULL) {
      Wprintf("Matrix stack pop error");
      return;
   }
   lastmatrix = areawin->MatStack->nextmatrix;
   free(areawin->MatStack);
   areawin->MatStack = lastmatrix;

#ifdef HAVE_CAIRO
   if (areawin->area) {
      xc_cairo_set_matrix(lastmatrix);
   }
#endif /* HAVE_CAIRO */
}

/*------------------------------------------------------------------------*/

void UPushCTM()
{
   Matrixptr nmatrix;

   nmatrix = (Matrixptr)malloc(sizeof(Matrix));
   if (areawin->MatStack == NULL)
      UResetCTM(nmatrix);
   else
      UCopyCTM(areawin->MatStack, nmatrix); 
   nmatrix->nextmatrix = areawin->MatStack;
   areawin->MatStack = nmatrix;
}

/*------------------------------------------------------------------------*/

void UTransformPoints(XPoint *points, XPoint *newpoints, short number,
        XPoint atpt, float scale, float rotate)
{
   Matrix LCTM;
 
   UResetCTM(&LCTM);
   UMultCTM(&LCTM, atpt, scale, rotate);
   UTransformbyCTM(&LCTM, points, newpoints, number);
}

/*----------------------------------------------------*/
/* Transform points inward to next hierarchical level */
/*----------------------------------------------------*/

void InvTransformPoints(XPoint *points, XPoint *newpoints, short number,
        XPoint atpt, float scale, float rotate)
{
   Matrix LCTM;
 
   UResetCTM(&LCTM);
   UPreMultCTM(&LCTM, atpt, scale, rotate);
   InvertCTM(&LCTM);
   UTransformbyCTM(&LCTM, points, newpoints, number);
}

/*----------------------------------------------------------------------*/
/* Adjust wire coords to force a wire to a horizontal or vertical       */
/* position.                                                            */
/* "pospt" is the target position for the point of interest.            */
/* "cycle" is the point number in the polygon of the point of interest. */
/* cycle == -1 is equivalent to the last point of the polygon.          */
/* If "strict" is TRUE then single-segment wires are forced manhattan   */
/* even if that means that the endpoint drifts from the target point.   */
/* If "strict" is FALSE then single-segment wires will become non-      */
/* manhattan so that the target point is reached.                       */
/* NOTE:  It might be preferable to add a segment to maintain a         */
/* manhattan layout, except that we want to avoid merging nets          */
/* together. . .                                                        */
/*----------------------------------------------------------------------*/

void manhattanize(XPoint *pospt, polyptr newpoly, short cycle, Boolean strict)
{
   XPoint *curpt, *bpt, *bbpt, *fpt, *ffpt;
   int deltax, deltay;

   if (newpoly->number == 1) return;    /* sanity check */

   if (cycle == -1 || cycle == newpoly->number - 1) {
      curpt = newpoly->points + newpoly->number - 1;
      bpt = newpoly->points + newpoly->number - 2;
      fpt = NULL;
      ffpt = NULL;
      if (newpoly->number > 2)
         bbpt = newpoly->points + newpoly->number - 3;
      else
         bbpt = NULL;
   } 
   else if (cycle == 0) {
      curpt = newpoly->points;
      fpt = newpoly->points + 1;
      bpt = NULL;
      bbpt = NULL;
      if (newpoly->number > 2)
         ffpt = newpoly->points + 2;
      else
         ffpt = NULL;
   }
   else {
      curpt = newpoly->points + cycle;
      fpt = newpoly->points + cycle + 1;
      bpt = newpoly->points + cycle - 1;
      if (cycle > 1)
         bbpt = newpoly->points + cycle - 2;
      else
         bbpt = NULL;

      if (cycle < newpoly->number - 2)
         ffpt = newpoly->points + cycle + 2;
      else
         ffpt = NULL;
   }

   /* enforce constraints on point behind cycle position */

   if (bpt != NULL) {
      if (bbpt != NULL) {
         if (bpt->x == bbpt->x) bpt->y = pospt->y;
         if (bpt->y == bbpt->y) bpt->x = pospt->x;
      }
      else if (strict) {
         deltax = abs(bpt->x - pospt->x);
         deltay = abs(bpt->y - pospt->y);

         /* Only one segment---just make sure it's horizontal or vertical */
         if (deltay > deltax) pospt->x = bpt->x;
         else pospt->y = bpt->y;
      }
   }

   /* enforce constraints on point forward of cycle position */

   if (fpt != NULL) {
      if (ffpt != NULL) {
         if (fpt->x == ffpt->x) fpt->y = pospt->y;
         if (fpt->y == ffpt->y) fpt->x = pospt->x;
      }
      else if (strict) {
         deltax = abs(fpt->x - pospt->x);
         deltay = abs(fpt->y - pospt->y);

         /* Only one segment---just make sure it's horizontal or vertical */
         if (deltay > deltax) pospt->x = fpt->x;
         else pospt->y = fpt->y;
      }
   }
}

/*----------------------------------------------------------------------*/
/* Bounding box calculation routines                                    */
/*----------------------------------------------------------------------*/

void bboxcalc(short testval, short *lowerval, short *upperval)
{
   if (testval < *lowerval) *lowerval = testval;
   if (testval > *upperval) *upperval = testval;
}

/*----------------------------------------------------------------------*/
/* Bounding box calculation for elements which can be part of a path    */
/*----------------------------------------------------------------------*/

void calcextents(genericptr *bboxgen, short *llx, short *lly, 
        short *urx, short *ury)
{
   switch (ELEMENTTYPE(*bboxgen)) {
      case(POLYGON): {
         pointlist bboxpts;
         for (bboxpts = TOPOLY(bboxgen)->points; bboxpts < TOPOLY(bboxgen)->points
                 + TOPOLY(bboxgen)->number; bboxpts++) {
            bboxcalc(bboxpts->x, llx, urx);
            bboxcalc(bboxpts->y, lly, ury);
         }
         } break;

      case(SPLINE): {
         fpointlist bboxpts;
         bboxcalc(TOSPLINE(bboxgen)->ctrl[0].x, llx, urx);
         bboxcalc(TOSPLINE(bboxgen)->ctrl[0].y, lly, ury);
         bboxcalc(TOSPLINE(bboxgen)->ctrl[3].x, llx, urx);
         bboxcalc(TOSPLINE(bboxgen)->ctrl[3].y, lly, ury);
         for (bboxpts = TOSPLINE(bboxgen)->points; bboxpts < 
                 TOSPLINE(bboxgen)->points + INTSEGS; bboxpts++) {
            bboxcalc((short)(bboxpts->x), llx, urx);
            bboxcalc((short)(bboxpts->y), lly, ury);
         }
         } break;

      case (ARC): {
         fpointlist bboxpts;
         for (bboxpts = TOARC(bboxgen)->points; bboxpts < TOARC(bboxgen)->points +
                 TOARC(bboxgen)->number; bboxpts++) {
            bboxcalc((short)(bboxpts->x), llx, urx);
            bboxcalc((short)(bboxpts->y), lly, ury);
         }
         } break;
   }
}

/*----------------------------------------------------------------------*/
/* Calculate the bounding box of an object instance                     */
/*----------------------------------------------------------------------*/

void objinstbbox(objinstptr obbox, XPoint *npoints, int extend)
{
   XPoint points[4];

   points[0].x = points[1].x = obbox->bbox.lowerleft.x - extend;
   points[1].y = points[2].y = obbox->bbox.lowerleft.y + obbox->bbox.height
                + extend;
   points[2].x = points[3].x = obbox->bbox.lowerleft.x + obbox->bbox.width
                + extend;
   points[0].y = points[3].y = obbox->bbox.lowerleft.y - extend;

   UTransformPoints(points, npoints, 4, obbox->position,
                 obbox->scale, obbox->rotation); 
}

/*----------------------------------------------------------------------*/
/* Calculate the bounding box of a label                                */
/*----------------------------------------------------------------------*/

void labelbbox(labelptr labox, XPoint *npoints, objinstptr callinst)
{
   XPoint points[4];
   TextExtents tmpext;
   short j;

   tmpext = ULength(labox, callinst, NULL);
   points[0].x = points[1].x = (labox->anchor & NOTLEFT ? 
               (labox->anchor & RIGHT ? -tmpext.maxwidth :
                -tmpext.maxwidth / 2) : 0);
   points[2].x = points[3].x = points[0].x + tmpext.maxwidth;
   points[0].y = points[3].y = (labox->anchor & NOTBOTTOM ?
               (labox->anchor & TOP ? -tmpext.ascent :
                -(tmpext.ascent + tmpext.base) / 2) : -tmpext.base)
                + tmpext.descent;
   points[1].y = points[2].y = points[0].y + tmpext.ascent - tmpext.descent;

   /* separate bounding box for pinlabels and infolabels */

   if (labox->pin)
      for (j = 0; j < 4; j++)
         pinadjust(labox->anchor, &points[j].x, &points[j].y, 1);

   UTransformPoints(points, npoints, 4, labox->position,
                labox->scale, labox->rotation); 
}

/*----------------------------------------------------------------------*/
/* Calculate the bounding box of a graphic image                        */
/*----------------------------------------------------------------------*/

void graphicbbox(graphicptr gp, XPoint *npoints)
{
   XPoint points[4];
   int hw = xcImageGetWidth(gp->source) >> 1;
   int hh = xcImageGetHeight(gp->source) >> 1;

   points[1].x = points[2].x = hw;
   points[0].x = points[3].x = -hw;

   points[0].y = points[1].y = -hh;
   points[2].y = points[3].y = hh;

   UTransformPoints(points, npoints, 4, gp->position,
                gp->scale, gp->rotation); 
}

/*--------------------------------------------------------------*/
/* Wrapper for single call to calcbboxsingle() in the netlister */
/*--------------------------------------------------------------*/

void calcinstbbox(genericptr *bboxgen, short *llx, short *lly, short *urx,
                short *ury)
{
   *llx = *lly = 32767;
   *urx = *ury = -32768;

   calcbboxsingle(bboxgen, areawin->topinstance, llx, lly, urx, ury);
}

/*----------------------------------------------------------------------*/
/* Bounding box calculation for a single generic element                */
/*----------------------------------------------------------------------*/

void calcbboxsingle(genericptr *bboxgen, objinstptr thisinst, 
                short *llx, short *lly, short *urx, short *ury)
{
   XPoint npoints[4];
   short j;

   /* For each screen element, compute the extents and revise bounding  */
   /* box points, if necessary.                                         */

   switch(ELEMENTTYPE(*bboxgen)) {

      case(OBJINST):
         objinstbbox(TOOBJINST(bboxgen), npoints, 0);

         for (j = 0; j < 4; j++) {
            bboxcalc(npoints[j].x, llx, urx);
            bboxcalc(npoints[j].y, lly, ury);
         }
         break;

      case(LABEL):
         /* because a pin is offset from its position point, include */
         /* that point in the bounding box.                             */

         if (TOLABEL(bboxgen)->pin) {
            bboxcalc(TOLABEL(bboxgen)->position.x, llx, urx);
            bboxcalc(TOLABEL(bboxgen)->position.y, lly, ury);
         }
         labelbbox(TOLABEL(bboxgen), npoints, thisinst);

         for (j = 0; j < 4; j++) {
            bboxcalc(npoints[j].x, llx, urx);
            bboxcalc(npoints[j].y, lly, ury);
         }
         break;

      case(GRAPHIC):
         graphicbbox(TOGRAPHIC(bboxgen), npoints);
         for (j = 0; j < 4; j++) {
            bboxcalc(npoints[j].x, llx, urx);
            bboxcalc(npoints[j].y, lly, ury);
         }
         break;

      case(PATH): {
         genericptr *pathc;
         for (pathc = TOPATH(bboxgen)->plist; pathc < TOPATH(bboxgen)->plist
                  + TOPATH(bboxgen)->parts; pathc++)
               calcextents(pathc, llx, lly, urx, ury);
         } break;

      default:
         calcextents(bboxgen, llx, lly, urx, ury);
   }
}

/*------------------------------------------------------*/
/* Find if an object is in the specified library        */
/*------------------------------------------------------*/

Boolean object_in_library(short libnum, objectptr thisobject)
{
   short i;

   for (i = 0; i < xobjs.userlibs[libnum].number; i++) {
      if (*(xobjs.userlibs[libnum].library + i) == thisobject)
         return True;
   }
   return False;
}

/*-----------------------------------------------------------*/
/* Find if an object is in the hierarchy of the given object */
/* Returns the number (position in plist) or -1 if not found */
/*-----------------------------------------------------------*/

short find_object(objectptr pageobj, objectptr thisobject)
{
   short i, j;
   genericptr *pelem;

   for (i = 0; i < pageobj->parts; i++) {
      pelem = pageobj->plist + i;
      if (IS_OBJINST(*pelem)) {
         if ((TOOBJINST(pelem))->thisobject == thisobject)
            return i;
         else if ((j = find_object((TOOBJINST(pelem))->thisobject, thisobject)) >= 0)
            return i;  /* was j---is this the right fix? */
      }
   }
   return -1;
}

/*------------------------------------------------------*/
/* Find all pages and libraries containing this object  */
/* and update accordingly.  If this object is a page,   */
/* just update the page directory.                      */
/*------------------------------------------------------*/

void updatepagebounds(objectptr thisobject)
{
   short i, j;
   objectptr pageobj;

   if ((i = is_page(thisobject)) >= 0) {
      if (xobjs.pagelist[i]->background.name != (char *)NULL)
         backgroundbbox(i);
      updatepagelib(PAGELIB, i);
   }
   else {
      for (i = 0; i < xobjs.pages; i++) {
         if (xobjs.pagelist[i]->pageinst != NULL) {
            pageobj = xobjs.pagelist[i]->pageinst->thisobject;
            if ((j = find_object(pageobj, thisobject)) >= 0) {
               calcbboxvalues(xobjs.pagelist[i]->pageinst,
                        (genericptr *)(pageobj->plist + j));
               updatepagelib(PAGELIB, i);
            }
         }
      }
      for (i = 0; i < xobjs.numlibs; i++)
         if (object_in_library(i, thisobject))
            composelib(i + LIBRARY);
   }
}

/*--------------------------------------------------------------*/
/* Free memory for the schematic bounding box                   */
/*--------------------------------------------------------------*/

void invalidateschembbox(objinstptr thisinst)
{
   if (thisinst->schembbox != NULL) {
      free(thisinst->schembbox);
      thisinst->schembbox = NULL;
   }
}

/*--------------------------------------------------------------*/
/* Calculate the bounding box for an object instance.  Use the  */
/* existing bbox and finish calculation on all the elements     */
/* which have parameters not taking default values.             */
/* This finishes the calculation partially done by              */
/* calcbboxvalues().                                            */
/*--------------------------------------------------------------*/

void calcbboxinst(objinstptr thisinst)
{
   objectptr thisobj;
   genericptr *gelem;
   short llx, lly, urx, ury;

   short pllx, plly, purx, pury;
   Boolean hasschembbox = FALSE;
   Boolean didparamsubs = FALSE;

   if (thisinst == NULL) return;

   thisobj = thisinst->thisobject;

   llx = thisobj->bbox.lowerleft.x;
   lly = thisobj->bbox.lowerleft.y;
   urx = llx + thisobj->bbox.width;
   ury = lly + thisobj->bbox.height;

   pllx = plly = 32767;
   purx = pury = -32768;

   for (gelem = thisobj->plist; gelem < thisobj->plist + thisobj->parts;
                gelem++) {
      /* pins which do not appear outside of the object */
      /* contribute to the objects "schembbox".         */

      if (IS_LABEL(*gelem)) {
         labelptr btext = TOLABEL(gelem);
         if (btext->pin && !(btext->anchor & PINVISIBLE)) {
            hasschembbox = TRUE;
            calcbboxsingle(gelem, thisinst, &pllx, &plly, &purx, &pury);
            continue;
         }
      }

      if (has_param(*gelem)) {
         if (didparamsubs == FALSE) {
            psubstitute(thisinst);
            didparamsubs = TRUE;
         }
         calcbboxsingle(gelem, thisinst, &llx, &lly, &urx, &ury);
      }

      /* If we have a clipmask, the clipmask is used to calculate the   */
      /* bounding box, not the element it is masking.                   */

      switch(ELEMENTTYPE(*gelem)) {
         case POLYGON: case SPLINE: case ARC: case PATH:
            if (TOPOLY(gelem)->style & CLIPMASK) gelem++;
            break;
      }
   }

   thisinst->bbox.lowerleft.x = llx;
   thisinst->bbox.lowerleft.y = lly;
   thisinst->bbox.width = urx - llx;
   thisinst->bbox.height = ury - lly;

   if (hasschembbox) {
      if (thisinst->schembbox == NULL)
         thisinst->schembbox = (BBox *)malloc(sizeof(BBox));

      thisinst->schembbox->lowerleft.x = pllx;
      thisinst->schembbox->lowerleft.y = plly;
      thisinst->schembbox->width = purx - pllx;
      thisinst->schembbox->height = pury - plly;
   }
   else
      invalidateschembbox(thisinst);
}

/*--------------------------------------------------------------*/
/* Update things based on a changed instance bounding box.      */
/* If the parameter was a single-instance                       */
/* substitution, only the page should be updated.  If the       */
/* parameter was a default value, the library should be updated */
/* and any pages containing the object where the parameter      */
/* takes the default value.                                     */
/*--------------------------------------------------------------*/

void updateinstparam(objectptr bobj)
{
   short i, j;
   objectptr pageobj;

   /* change bounds on pagelib and all pages                    */
   /* containing this *object* if and only if the object        */
   /* instance takes the default value.  Also update the        */
   /* library page.                                             */

   for (i = 0; i < xobjs.pages; i++)
      if (xobjs.pagelist[i]->pageinst != NULL) {
         pageobj = xobjs.pagelist[i]->pageinst->thisobject;
         if ((j = find_object(pageobj, topobject)) >= 0) {

            /* Really, we'd like to recalculate the bounding box only if the */
            /* parameter value is the default value which was just changed.     */
            /* However, then any non-default values may contain the wrong       */
            /* substitutions.                                           */

            objinstptr cinst = TOOBJINST(pageobj->plist + j);
            if (cinst->thisobject->params == NULL) {
               calcbboxvalues(xobjs.pagelist[i]->pageinst, pageobj->plist + j);
               updatepagelib(PAGELIB, i);
            }
         }
      }

   for (i = 0; i < xobjs.numlibs; i++)
      if (object_in_library(i, topobject))
         composelib(i + LIBRARY);
}

/*--------------------------------------------------------------*/
/* Calculate bbox on all elements of the given object           */
/*--------------------------------------------------------------*/

void calcbbox(objinstptr binst)
{
   calcbboxvalues(binst, (genericptr *)NULL);
   if (binst == areawin->topinstance) {
      updatepagebounds(topobject);
   }
}

/*--------------------------------------------------------------*/
/* Calculate bbox on the given element of the specified object. */
/* This is a wrapper for calcbboxvalues() assuming that we're   */
/* on the top-level, and that page bounds need to be updated.   */
/*--------------------------------------------------------------*/

void singlebbox(genericptr *gelem)
{
   calcbboxvalues(areawin->topinstance, (genericptr *)gelem);
   updatepagebounds(topobject);
}

/*----------------------------------------------------------------------*/
/* Extend bounding box based on selected elements only                  */
/*----------------------------------------------------------------------*/

void calcbboxselect()
{
   short *bsel;
   for (bsel = areawin->selectlist; bsel < areawin->selectlist +
                areawin->selects; bsel++)
      calcbboxvalues(areawin->topinstance, topobject->plist + *bsel);
  
   updatepagebounds(topobject);
}

/*--------------------------------------------------------------*/
/* Update Bounding box for an object.                           */
/* If newelement == NULL, calculate bounding box from scratch.  */
/* Otherwise, expand bounding box to enclose newelement.        */
/*--------------------------------------------------------------*/

void calcbboxvalues(objinstptr thisinst, genericptr *newelement)
{
   genericptr *bboxgen;
   short llx, lly, urx, ury;
   objectptr thisobj = thisinst->thisobject;

   /* no action if there are no elements */
   if (thisobj->parts == 0) return;

   /* If this object has parameters, then we will do a separate         */
   /* bounding box calculation on parameterized parts.  This            */
   /* calculation ignores them, and the result is a base that the       */
   /* instance bounding-box computation can use as a starting point.    */

   /* set starting bounds as maximum bounds of screen */
   llx = lly = 32767;
   urx = ury = -32768;

   for (bboxgen = thisobj->plist; bboxgen < thisobj->plist +
                thisobj->parts; bboxgen++) {

      /* override the "for" loop if we're doing a single element */
      if (newelement != NULL) bboxgen = newelement;

      if ((thisobj->params == NULL) || (!has_param(*bboxgen))) {
         /* pins which do not appear outside of the object      */
         /* are ignored now---will be computed per instance.    */

         if (IS_LABEL(*bboxgen)) {
            labelptr btext = TOLABEL(bboxgen);
            if (btext->pin && !(btext->anchor & PINVISIBLE)) {
               goto nextgen;
            }
         }
         calcbboxsingle(bboxgen, thisinst, &llx, &lly, &urx, &ury);

         if (newelement == NULL)
            switch(ELEMENTTYPE(*bboxgen)) {
               case POLYGON: case SPLINE: case ARC: case PATH:
                  if (TOPOLY(bboxgen)->style & CLIPMASK)
                     bboxgen++;
                  break;
            }
      }
nextgen:
      if (newelement != NULL) break;
   }

   /* if this is a single-element calculation and its bounding box      */
   /* turned out to be smaller than the object's, then we need to       */
   /* recompute the entire object's bounding box in case it got         */
   /* smaller.  This is not recursive, in spite of looks.               */

   if (newelement != NULL) {
      if (llx > thisobj->bbox.lowerleft.x &&
                lly > thisobj->bbox.lowerleft.y &&
                urx < (thisobj->bbox.lowerleft.x + thisobj->bbox.width) &&
                ury < (thisobj->bbox.lowerleft.y + thisobj->bbox.height)) {
         calcbboxvalues(thisinst, NULL);
         return;
      }
      else {
         bboxcalc(thisobj->bbox.lowerleft.x, &llx, &urx);
         bboxcalc(thisobj->bbox.lowerleft.y, &lly, &ury);
         bboxcalc(thisobj->bbox.lowerleft.x + thisobj->bbox.width, &llx, &urx);
         bboxcalc(thisobj->bbox.lowerleft.y + thisobj->bbox.height, &lly, &ury);
      }
   }

   /* Set the new bounding box.  In pathological cases, such as a page  */
   /* with only pin labels, the bounds may not have been changed from   */
   /* their initial values.  If so, then don't touch the bounding box.  */

   if ((llx <= urx) && (lly <= ury)) {
      thisobj->bbox.lowerleft.x = llx;
      thisobj->bbox.lowerleft.y = lly;
      thisobj->bbox.width = urx - llx;
      thisobj->bbox.height = ury - lly;
   }

   /* calculate instance-specific values */
   calcbboxinst(thisinst);
}

/*------------------------------------------------------*/
/* Center an object in the viewing window               */
/*------------------------------------------------------*/

void centerview(objinstptr tinst)
{
   XPoint origin, corner;
   Dimension width, height;
   float fitwidth, fitheight;
   objectptr tobj = tinst->thisobject;

   origin = tinst->bbox.lowerleft;
   corner.x = origin.x + tinst->bbox.width;
   corner.y = origin.y + tinst->bbox.height;

   extendschembbox(tinst, &origin, &corner);

   width = corner.x - origin.x;
   height = corner.y - origin.y;

   fitwidth = (float)areawin->width / ((float)width + 2 * DEFAULTGRIDSPACE);
   fitheight = (float)areawin->height / ((float)height + 2 * DEFAULTGRIDSPACE);

   tobj->viewscale = (fitwidth < fitheight) ?
                 min(MINAUTOSCALE, fitwidth) : min(MINAUTOSCALE, fitheight);

   tobj->pcorner.x = origin.x - (areawin->width
               / tobj->viewscale - width) / 2;
   tobj->pcorner.y = origin.y - (areawin->height
               / tobj->viewscale - height) / 2;

   /* Copy new position values to the current window */

   if ((areawin->topinstance != NULL) && (tobj == topobject)) {
      areawin->pcorner = tobj->pcorner;
      areawin->vscale = tobj->viewscale;
   }
}

/*-----------------------------------------------------------*/
/* Refresh the window and scrollbars and write the page name */
/*-----------------------------------------------------------*/

void refresh(xcWidget bw, caddr_t clientdata, caddr_t calldata)
{
   areawin->redraw_needed = True;
   drawarea(NULL, NULL, NULL);
   if (areawin->scrollbarh)
      drawhbar(areawin->scrollbarh, NULL, NULL);
   if (areawin->scrollbarv)
      drawvbar(areawin->scrollbarv, NULL, NULL);
   printname(topobject);
}

/*------------------------------------------------------*/
/* Center the current page in the viewing window        */
/*------------------------------------------------------*/

void zoomview(xcWidget w, caddr_t clientdata, caddr_t calldata)
{
   if (eventmode == NORMAL_MODE || eventmode == COPY_MODE ||
         eventmode == MOVE_MODE || eventmode == CATALOG_MODE ||
        eventmode == FONTCAT_MODE || eventmode == EFONTCAT_MODE ||
        eventmode == CATMOVE_MODE) {

      if (areawin->topinstance)
         centerview(areawin->topinstance);
      areawin->lastbackground = NULL;
      renderbackground();
      refresh(NULL, NULL, NULL);
   }
}

/*---------------------------------------------------------*/
/* Basic X Graphics Routines in the User coordinate system */
/*---------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawSimpleLine(XPoint *pt1, XPoint *pt2)
{
   XPoint newpt1, newpt2;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   UTransformbyCTM(DCTM, pt1, &newpt1, 1);
   UTransformbyCTM(DCTM, pt2, &newpt2, 1);

   DrawLine(dpy, areawin->window, areawin->gc,
                newpt1.x, newpt1.y, newpt2.x, newpt2.y); 
} 
#endif /* !HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawLine(XPoint *pt1, XPoint *pt2)
{
   float tmpwidth = UTopTransScale(xobjs.pagelist[areawin->page]->wirewidth);

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   SetLineAttributes(dpy, areawin->gc, tmpwidth, LineSolid, CapRound, JoinBevel);
   UDrawSimpleLine(pt1, pt2); 
} 
#endif /* !HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Add circle at given point to indicate that the point is a parameter. */
/* The circle is divided into quarters.  For parameterized y-coordinate */
/* the top and bottom quarters are drawn.  For parameterized x-         */
/* coordinate, the left and right quarters are drawn.  A full circle    */
/* indicates either both x- and y-coordinates are parameterized, or     */
/* else any other kind of parameterization (presently, not used).       */
/*                                                                      */
/* (note that the two angles in XDrawArc() are 1) the start angle,      */
/* measured in absolute 64th degrees from 0 (3 o'clock), and 2) the     */
/* path length, in relative 64th degrees (positive = counterclockwise,  */
/* negative = clockwise)).                                              */
/*----------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawCircle(XPoint *upt, u_char which)
{
   XPoint wpt;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   user_to_window(*upt, &wpt);
   SetThinLineAttributes(dpy, areawin->gc, 0, LineSolid, CapButt, JoinMiter);

   switch(which) {
      case P_POSITION_X:
         XDrawArc(dpy, areawin->window, areawin->gc, wpt.x - 4,
                wpt.y - 4, 8, 8, -(45 * 64), (90 * 64));
         XDrawArc(dpy, areawin->window, areawin->gc, wpt.x - 4,
                wpt.y - 4, 8, 8, (135 * 64), (90 * 64));
         break;
      case P_POSITION_Y:
         XDrawArc(dpy, areawin->window, areawin->gc, wpt.x - 4,
                wpt.y - 4, 8, 8, (45 * 64), (90 * 64));
         XDrawArc(dpy, areawin->window, areawin->gc, wpt.x - 4,
                wpt.y - 4, 8, 8, (225 * 64), (90 * 64));
         break;
      default:
         XDrawArc(dpy, areawin->window, areawin->gc, wpt.x - 4,
                wpt.y - 4, 8, 8, 0, (360 * 64));
         break;
   }
}
#endif /* !HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Add "X" at string origin                                             */
/*----------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawXAt(XPoint *wpt)
{
   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   SetThinLineAttributes(dpy, areawin->gc, 0, LineSolid, CapButt, JoinMiter);
   DrawLine(dpy, areawin->window, areawin->gc, wpt->x - 3,
                wpt->y - 3, wpt->x + 3, wpt->y + 3);
   DrawLine(dpy, areawin->window, areawin->gc, wpt->x + 3,
                wpt->y - 3, wpt->x - 3, wpt->y + 3);
}
#endif /* !HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Draw "X" on current level                                            */
/*----------------------------------------------------------------------*/

void UDrawX(labelptr curlabel)
{
   XPoint wpt;

   user_to_window(curlabel->position, &wpt);
   UDrawXAt(&wpt);
}

/*----------------------------------------------------------------------*/
/* Draw "X" on top level (only for LOCAL and GLOBAL pin labels)         */
/*----------------------------------------------------------------------*/

void UDrawXDown(labelptr curlabel)
{
   XPoint wpt;

   UTransformbyCTM(DCTM, &curlabel->position, &wpt, 1);
   UDrawXAt(&wpt);
}

/*----------------------------------------------------------------------*/
/* Find the "real" width, height, and origin of an object including pin */
/* labels and so forth that only show up on a schematic when it is the  */
/* top-level object.                                                    */
/*----------------------------------------------------------------------*/

int toplevelwidth(objinstptr bbinst, short *rllx)
{
   short llx, urx;
   short origin, corner;

   if (bbinst->schembbox == NULL) {
      if (rllx) *rllx = bbinst->bbox.lowerleft.x;
      return bbinst->bbox.width;
   }

   origin = bbinst->bbox.lowerleft.x;
   corner = origin + bbinst->bbox.width;

   llx = bbinst->schembbox->lowerleft.x;
   urx = llx + bbinst->schembbox->width;

   bboxcalc(llx, &origin, &corner);
   bboxcalc(urx, &origin, &corner);

   if (rllx) *rllx = origin;
   return(corner - origin);
}

/*----------------------------------------------------------------------*/

int toplevelheight(objinstptr bbinst, short *rlly)
{
   short lly, ury;
   short origin, corner;

   if (bbinst->schembbox == NULL) {
      if (rlly) *rlly = bbinst->bbox.lowerleft.y;
      return bbinst->bbox.height;
   }

   origin = bbinst->bbox.lowerleft.y;
   corner = origin + bbinst->bbox.height;

   lly = bbinst->schembbox->lowerleft.y;
   ury = lly + bbinst->schembbox->height;

   bboxcalc(lly, &origin, &corner);
   bboxcalc(ury, &origin, &corner);

   if (rlly) *rlly = origin;
   return(corner - origin);
}

/*----------------------------------------------------------------------*/
/* Add dimensions of schematic pins to an object's bounding box         */
/*----------------------------------------------------------------------*/

void extendschembbox(objinstptr bbinst, XPoint *origin, XPoint *corner)
{
   short llx, lly, urx, ury;

   if ((bbinst == NULL) || (bbinst->schembbox == NULL)) return;

   llx = bbinst->schembbox->lowerleft.x;
   lly = bbinst->schembbox->lowerleft.y;
   urx = llx + bbinst->schembbox->width;
   ury = lly + bbinst->schembbox->height;

   bboxcalc(llx, &(origin->x), &(corner->x));
   bboxcalc(lly, &(origin->y), &(corner->y));
   bboxcalc(urx, &(origin->x), &(corner->x));
   bboxcalc(ury, &(origin->y), &(corner->y));
}

/*----------------------------------------------------------------------*/
/* Adjust a pinlabel position to account for pad spacing                */
/*----------------------------------------------------------------------*/

void pinadjust (short anchor, short *xpoint, short *ypoint, short dir)
{
   int delx, dely;

   dely = (anchor & NOTBOTTOM) ?
            ((anchor & TOP) ? -PADSPACE : 0) : PADSPACE;
   delx = (anchor & NOTLEFT) ?
            ((anchor & RIGHT) ? -PADSPACE : 0) : PADSPACE;

   if (xpoint != NULL) *xpoint += (dir > 0) ? delx : -delx;
   if (ypoint != NULL) *ypoint += (dir > 0) ? dely : -dely;
}

/*----------------------------------------------------------------------*/
/* Draw line for editing text (position of cursor in string is given by */
/*   tpos (2nd parameter)                                               */
/*----------------------------------------------------------------------*/

void UDrawTextLine(labelptr curlabel, short tpos)
{
   XPoint  points[2]; /* top and bottom of text cursor line */
   short   tmpanchor, xbase;
   int     maxwidth;
   TextExtents tmpext;
   TextLinesInfo tlinfo;
   
   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   /* correct for position, rotation, scale, and flip invariance of text */

   UPushCTM();
   UPreMultCTM(DCTM, curlabel->position, curlabel->scale, curlabel->rotation);
   tmpanchor = flipadjust(curlabel->anchor);

   SetForeground(dpy, areawin->gc, AUXCOLOR);

   tlinfo.dostop = 0;
   tlinfo.tbreak = NULL;
   tlinfo.padding = NULL;

   tmpext = ULength(curlabel, areawin->topinstance, &tlinfo);
   maxwidth = tmpext.maxwidth;
   xbase = tmpext.base;
   tlinfo.dostop = tpos;
   tmpext = ULength(curlabel, areawin->topinstance, &tlinfo);

   points[0].x = (tmpanchor & NOTLEFT ?
        (tmpanchor & RIGHT ? -maxwidth : -maxwidth >> 1) : 0) + tmpext.width;
   if ((tmpanchor & JUSTIFYRIGHT) && tlinfo.padding)
      points[0].x += tlinfo.padding[tlinfo.line];
   else if ((tmpanchor & TEXTCENTERED) && tlinfo.padding)
      points[0].x += 0.5 * tlinfo.padding[tlinfo.line];
   points[0].y = (tmpanchor & NOTBOTTOM ?
        (tmpanchor & TOP ? -tmpext.ascent : -(tmpext.ascent + xbase) / 2)
        : -xbase) + tmpext.base - 3;
   points[1].x = points[0].x;
   points[1].y = points[0].y + TEXTHEIGHT + 6;

   if (curlabel->pin) {
      pinadjust(tmpanchor, &(points[0].x), &(points[0].y), 1);
      pinadjust(tmpanchor, &(points[1].x), &(points[1].y), 1);
   }
   if (tlinfo.padding != NULL) free(tlinfo.padding);

   /* draw the line */

   UDrawLine(&points[0], &points[1]);
   UPopCTM();

   UDrawX(curlabel);
}

/*-----------------------------------------------------------------*/
/* Draw lines for editing text when multiple characters are chosen */
/*-----------------------------------------------------------------*/

void UDrawTLine(labelptr curlabel)
{
   UDrawTextLine(curlabel, areawin->textpos);
   if ((areawin->textend > 0) && (areawin->textend < areawin->textpos)) {
      UDrawTextLine(curlabel, areawin->textend);
   }
}

/*----------------------*/
/* Draw an X            */
/*----------------------*/

#ifndef HAVE_CAIRO
void UDrawXLine(XPoint opt, XPoint cpt)
{
   XPoint upt, vpt;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   SetForeground(dpy, areawin->gc, AUXCOLOR);

   user_to_window(cpt, &upt);
   user_to_window(opt, &vpt);

   SetThinLineAttributes(dpy, areawin->gc, 0, LineOnOffDash, CapButt, JoinMiter);
   DrawLine(dpy, areawin->window, areawin->gc, vpt.x, vpt.y, upt.x, upt.y);

   SetThinLineAttributes(dpy, areawin->gc, 0, LineSolid, CapButt, JoinMiter);
   DrawLine(dpy, areawin->window, areawin->gc, upt.x - 3, upt.y - 3,
                upt.x + 3, upt.y + 3);
   DrawLine(dpy, areawin->window, areawin->gc, upt.x + 3, upt.y - 3,
                upt.x - 3, upt.y + 3);

   SetForeground(dpy, areawin->gc, areawin->gccolor);
}
#endif /* HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawBox(XPoint origin, XPoint corner)
{
   XPoint       worig, wcorn;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   user_to_window(origin, &worig);
   user_to_window(corner, &wcorn);

   SetForeground(dpy, areawin->gc, AUXCOLOR);
   SetThinLineAttributes(dpy, areawin->gc, 0, LineSolid, CapRound, JoinBevel);
   DrawLine(dpy, areawin->window, areawin->gc, worig.x, worig.y,
                worig.x, wcorn.y);
   DrawLine(dpy, areawin->window, areawin->gc, worig.x, wcorn.y,
                wcorn.x, wcorn.y);
   DrawLine(dpy, areawin->window, areawin->gc, wcorn.x, wcorn.y,
                wcorn.x, worig.y);
   DrawLine(dpy, areawin->window, areawin->gc, wcorn.x, worig.y,
                worig.x, worig.y);
}
#endif /* HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Get a box indicating the dimensions of the edit element that most    */
/* closely reach the position "corner".                                 */
/*----------------------------------------------------------------------*/

float UGetRescaleBox(XPoint *corner, XPoint *newpoints)
{
   genericptr   rgen;
   float        savescale, newscale;
   long         mindist, testdist, refdist;
   labelptr     rlab;
   graphicptr   rgraph;
   objinstptr   rinst;
   int          i;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      // return 0.0;
   }

   if (areawin->selects == 0) return 0.0;

   /* Use only the 1st selection as a reference to set the scale */

   rgen = SELTOGENERIC(areawin->selectlist);

   switch(ELEMENTTYPE(rgen)) {
      case LABEL:
         rlab = (labelptr)rgen;
         labelbbox(rlab, newpoints, areawin->topinstance);
         newpoints[4] = newpoints[0];
         mindist = LONG_MAX;
         for (i = 0; i < 4; i++) {
            testdist = finddist(&newpoints[i], &newpoints[i+1], corner);
            if (testdist < mindist)
               mindist = testdist;
         }
         refdist = wirelength(corner, &(rlab->position));
         mindist = (int)sqrt(abs((double)mindist));
         savescale = rlab->scale;
         if (!test_insideness((int)corner->x, (int)corner->y, newpoints))
            mindist = -mindist;
         if (refdist == mindist) refdist = 1 - mindist;
         if (rlab->scale < 0) rlab->scale = -rlab->scale;
         newscale = fabs(rlab->scale * (float)refdist / (float)(refdist + mindist));
         if (newscale > 10 * rlab->scale) newscale = 10 * rlab->scale;
         if (areawin->snapto) {
            float snapstep = 2 * (float)xobjs.pagelist[areawin->page]->gridspace
                        / (float)xobjs.pagelist[areawin->page]->snapspace;
            newscale = (float)((int)(newscale * snapstep)) / snapstep;
            if (newscale < (1.0 / snapstep)) newscale = (1.0 / snapstep);
         }
         else if (newscale < 0.1 * rlab->scale) newscale = 0.1 * rlab->scale;
         rlab->scale = (savescale < 0) ? -newscale : newscale;
         labelbbox(rlab, newpoints, areawin->topinstance);
         rlab->scale = savescale;
         if (savescale < 0) newscale = -newscale;
         break;

      case GRAPHIC:
         rgraph = (graphicptr)rgen;
         graphicbbox(rgraph, newpoints);
         newpoints[4] = newpoints[0];
         mindist = LONG_MAX;
         for (i = 0; i < 4; i++) {
            testdist = finddist(&newpoints[i], &newpoints[i+1], corner);
            if (testdist < mindist)
               mindist = testdist;
         }
         refdist = wirelength(corner, &(rgraph->position));
         mindist = (int)sqrt(abs((double)mindist));
         savescale = rgraph->scale;
         if (!test_insideness((int)corner->x, (int)corner->y, newpoints))
            mindist = -mindist;
         if (refdist == mindist) refdist = 1 - mindist;  /* avoid inf result */
         if (rgraph->scale < 0) rgraph->scale = -rgraph->scale;
         newscale = fabs(rgraph->scale * (float)refdist / (float)(refdist + mindist));
         if (newscale > 10 * rgraph->scale) newscale = 10 * rgraph->scale;
         if (areawin->snapto) {
            float snapstep = 2 * (float)xobjs.pagelist[areawin->page]->gridspace
                        / (float)xobjs.pagelist[areawin->page]->snapspace;
            newscale = (float)((int)(newscale * snapstep)) / snapstep;
            if (newscale < (1.0 / snapstep)) newscale = (1.0 / snapstep);
         }
         else if (newscale < 0.1 * rgraph->scale) newscale = 0.1 * rgraph->scale;
         rgraph->scale = (savescale < 0) ? -newscale : newscale;
         graphicbbox(rgraph, newpoints);
         rgraph->scale = savescale;
         if (savescale < 0) newscale = -newscale;
         break;

      case OBJINST:
         rinst = (objinstptr)rgen;
         objinstbbox(rinst, newpoints, 0);
         newpoints[4] = newpoints[0];
         mindist = LONG_MAX;
         for (i = 0; i < 4; i++) {
            testdist = finddist(&newpoints[i], &newpoints[i+1], corner);
            if (testdist < mindist)
               mindist = testdist;
         }
         refdist = wirelength(corner, &(rinst->position));
         mindist = (int)sqrt(abs((double)mindist));
         savescale = rinst->scale;
         if (!test_insideness((int)corner->x, (int)corner->y, newpoints))
            mindist = -mindist;
         if (refdist == mindist) refdist = 1 - mindist;  /* avoid inf result */
         if (rinst->scale < 0) rinst->scale = -rinst->scale;
         newscale = fabs(rinst->scale * (float)refdist / (float)(refdist + mindist));
         if (newscale > 10 * rinst->scale) newscale = 10 * rinst->scale;
         if (areawin->snapto) {
            float snapstep = 2 * (float)xobjs.pagelist[areawin->page]->gridspace
                        / (float)xobjs.pagelist[areawin->page]->snapspace;
            newscale = (float)((int)(newscale * snapstep)) / snapstep;
            if (newscale < (1.0 / snapstep)) newscale = (1.0 / snapstep);
         }
         else if (newscale < 0.1 * rinst->scale) newscale = 0.1 * rinst->scale;
         rinst->scale = (savescale < 0) ? -newscale : newscale;
         objinstbbox(rinst, newpoints, 0);
         rinst->scale = savescale;
         if (savescale < 0) newscale = -newscale;
         break;
   }

   return newscale;
}

/*----------------------------------------------------------------------*/
/* Draw a box indicating the dimensions of the edit element that most   */
/* closely reach the position "corner".                                 */
/*----------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawRescaleBox(XPoint *corner)
{
   XPoint origpoints[5], newpoints[5];

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   if (areawin->selects == 0)
      return;

   UGetRescaleBox(corner, newpoints);

   SetForeground(dpy, areawin->gc, AUXCOLOR);
   SetThinLineAttributes(dpy, areawin->gc, 0, LineSolid, CapRound, JoinBevel);
   
   UTransformbyCTM(DCTM, newpoints, origpoints, 4);
   strokepath(origpoints, 4, 0, 1);
}
#endif /* HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawBBox()
{
   XPoint       origin;
   XPoint       worig, wcorn, corner;
   objinstptr   bbinst = areawin->topinstance;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   if ((!areawin->bboxon) || (checkforbbox(topobject) != NULL)) return;

   origin = bbinst->bbox.lowerleft;
   corner.x = origin.x + bbinst->bbox.width;
   corner.y = origin.y + bbinst->bbox.height;

   /* Include any schematic labels in the bounding box. */
   extendschembbox(bbinst, &origin, &corner);

   user_to_window(origin, &worig);
   user_to_window(corner, &wcorn);

   SetForeground(dpy, areawin->gc, BBOXCOLOR);
   DrawLine(dpy, areawin->window, areawin->gc, worig.x, worig.y,
                worig.x, wcorn.y);
   DrawLine(dpy, areawin->window, areawin->gc, worig.x, wcorn.y,
                wcorn.x, wcorn.y);
   DrawLine(dpy, areawin->window, areawin->gc, wcorn.x, wcorn.y,
                wcorn.x, worig.y);
   DrawLine(dpy, areawin->window, areawin->gc, wcorn.x, worig.y,
                worig.x, worig.y);
}
#endif /* !HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Fill and/or draw a border around the stroking path                   */
/*----------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void strokepath(XPoint *pathlist, short number, short style, float width)
{
   float        tmpwidth;

   tmpwidth = UTopTransScale(width);

   if (!(style & CLIPMASK) || (areawin->showclipmasks == TRUE) ||
                (areawin->clipped < 0)) {
      if (style & FILLED || (!(style & FILLED) && style & OPAQUE)) {
         if ((style & FILLSOLID) == FILLSOLID)
            SetFillStyle(dpy, areawin->gc, FillSolid);
         else if (!(style & FILLED)) {
            SetFillStyle(dpy, areawin->gc, FillOpaqueStippled); 
            SetStipple(dpy, areawin->gc, 7);
         }
         else {
            if (style & OPAQUE)
               SetFillStyle(dpy, areawin->gc, FillOpaqueStippled);
            else
               SetFillStyle(dpy, areawin->gc, FillStippled);
            SetStipple(dpy, areawin->gc, ((style & FILLSOLID) >> 5));
         }
         FillPolygon(dpy, areawin->window, areawin->gc, pathlist, number, Nonconvex,
                CoordModeOrigin);
         /* return to original state */
         SetFillStyle(dpy, areawin->gc, FillSolid);
      }
      if (!(style & NOBORDER)) {
         if (style & (DASHED | DOTTED)) {
            /* Set up dots or dashes */
            char dashstring[2];
            /* prevent values greater than 255 from folding back into   */
            /* type char.  Limit to 63 (=255/4) to keep at least the    */
            /* dot/gap ratio to scale when 'gap' is at its maximum      */
            /* value.                                                   */
            unsigned char dotsize = min(63, max(1, (short)tmpwidth));
            if (style & DASHED)
               dashstring[0] = 4 * dotsize;
            else if (style & DOTTED)
               dashstring[0] = dotsize;
            dashstring[1] = 4 * dotsize;
            SetDashes(dpy, areawin->gc, 0, dashstring, 2);
            SetLineAttributes(dpy, areawin->gc, tmpwidth, LineOnOffDash,
                CapButt, (style & SQUARECAP) ? JoinMiter : JoinBevel);
         }
         else
            SetLineAttributes(dpy, areawin->gc, tmpwidth, LineSolid,
                (style & SQUARECAP) ? CapProjecting : CapRound,
                (style & SQUARECAP) ? JoinMiter : JoinBevel);

         /* draw the spline and close off if so specified */
         DrawLines(dpy, areawin->window, areawin->gc, pathlist,
                number, CoordModeOrigin);
         if (!(style & UNCLOSED))
            DrawLine(dpy, areawin->window, areawin->gc, pathlist[0].x,
                pathlist[0].y, pathlist[number - 1].x, pathlist[number - 1].y);
      }
   }

   if (style & CLIPMASK) {
      if (areawin->clipped == 0) {
         XSetForeground(dpy, areawin->cmgc, 0);
         XFillRectangle(dpy, areawin->clipmask, areawin->cmgc, 0, 0,
                areawin->width, areawin->height);
         XSetForeground(dpy, areawin->cmgc, 1);
         FillPolygon(dpy, areawin->clipmask, areawin->cmgc, pathlist,
                number, Nonconvex, CoordModeOrigin);
         XSetClipMask(dpy, areawin->gc, areawin->clipmask);
         // printf("level 0: Clip to clipmask\n");      // Diagnostic
         areawin->clipped++;
      }
      else if ((areawin->clipped > 0) && (areawin->clipped & 1) == 0) {
         if (areawin->pbuf == (Pixmap)NULL) {
            areawin->pbuf = XCreatePixmap (dpy, areawin->window,
                        areawin->width, areawin->height, 1);
         }
         XCopyArea(dpy, areawin->clipmask, areawin->pbuf, areawin->cmgc,
                0, 0, areawin->width, areawin->height, 0, 0);
         XSetForeground(dpy, areawin->cmgc, 0);
         XFillRectangle(dpy, areawin->clipmask, areawin->cmgc, 0, 0,
                areawin->width, areawin->height);
         XSetForeground(dpy, areawin->cmgc, 1);
         FillPolygon(dpy, areawin->clipmask, areawin->cmgc, pathlist,
                number, Nonconvex, CoordModeOrigin);
         XSetFunction(dpy, areawin->cmgc, GXand);
         XCopyArea(dpy, areawin->pbuf, areawin->clipmask, areawin->cmgc,
                0, 0, areawin->width, areawin->height, 0, 0);
         XSetFunction(dpy, areawin->cmgc, GXcopy);
         XSetClipMask(dpy, areawin->gc, areawin->clipmask);
         // printf("level X: Clip to clipmask\n");      // Diagnostic
         areawin->clipped++;
      }
   }
}
#endif /* !HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

void makesplinepath(splineptr thespline, XPoint *pathlist)
{
   XPoint *tmpptr = pathlist;

   UTransformbyCTM(DCTM, &(thespline->ctrl[0]), tmpptr, 1);
   UfTransformbyCTM(DCTM, thespline->points, ++tmpptr, INTSEGS);
   UTransformbyCTM(DCTM, &(thespline->ctrl[3]), tmpptr + INTSEGS, 1);
}

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawSpline(splineptr thespline, float passwidth)
{
   XPoint       tmppoints[SPLINESEGS];
   float        scaledwidth;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   scaledwidth = thespline->width * passwidth;

   makesplinepath(thespline, tmppoints);
   strokepath(tmppoints, SPLINESEGS, thespline->style, scaledwidth);
}
#endif /* HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawPolygon(polyptr thepoly, float passwidth)
{
   XPoint *tmppoints = (pointlist) malloc(thepoly->number * sizeof(XPoint));
   float scaledwidth;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   scaledwidth = thepoly->width * passwidth;

   UTransformbyCTM(DCTM, thepoly->points, tmppoints, thepoly->number);
   strokepath(tmppoints, thepoly->number, thepoly->style, scaledwidth);
   free(tmppoints);
}
#endif /* HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawArc(arcptr thearc, float passwidth)
{
   XPoint  tmppoints[RSTEPS + 2];
   float scaledwidth;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   scaledwidth = thearc->width * passwidth;

   UfTransformbyCTM(DCTM, thearc->points, tmppoints, thearc->number);
   strokepath(tmppoints, thearc->number, thearc->style, scaledwidth);
}
#endif /* HAVE_CAIRO */

/*-------------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawPath(pathptr thepath, float passwidth)
{
   XPoint       *tmppoints = (pointlist) malloc(sizeof(XPoint));
   genericptr   *genpath;
   polyptr      thepoly;
   splineptr    thespline;
   int          pathsegs = 0, curseg = 0;
   float        scaledwidth;
   
   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   for (genpath = thepath->plist; genpath < thepath->plist + thepath->parts;
          genpath++) {
      switch(ELEMENTTYPE(*genpath)) {
         case POLYGON:
            thepoly = TOPOLY(genpath);
            pathsegs += thepoly->number;
            tmppoints = (pointlist) realloc(tmppoints, pathsegs * sizeof(XPoint));
            UTransformbyCTM(DCTM, thepoly->points, tmppoints + curseg, thepoly->number);
            curseg = pathsegs;
            break;
         case SPLINE:
            thespline = TOSPLINE(genpath);
            pathsegs += SPLINESEGS;
            tmppoints = (pointlist) realloc(tmppoints, pathsegs * sizeof(XPoint));
            makesplinepath(thespline, tmppoints + curseg);
            curseg = pathsegs;
            break;
      }
   } 
   scaledwidth = thepath->width * passwidth;

   strokepath(tmppoints, pathsegs, thepath->style, scaledwidth);
   free(tmppoints);
}
#endif /* HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Main recursive object instance drawing routine.                      */
/*    context is the instance information passed down from above        */
/*    theinstance is the object instance to be drawn                    */
/*    level is the level of recursion                                   */
/*    passcolor is the inherited color value passed to object           */
/*    passwidth is the inherited linewidth value passed to the object   */
/*    stack contains graphics context information                       */
/*----------------------------------------------------------------------*/

#ifndef HAVE_CAIRO
void UDrawObject(objinstptr theinstance, short level, int passcolor,
                float passwidth, pushlistptr *stack)
{
   genericptr   *areagen;
   float        tmpwidth;
   int          defaultcolor = passcolor;
   int          curcolor = passcolor;
   int          thispart;
   short        savesel;
   XPoint       bboxin[2], bboxout[2];
   u_char       xm, ym;
   objectptr    theobject = theinstance->thisobject;

   if (!areawin->redraw_ongoing) {
      areawin->redraw_needed = True;
      return;
   }

   /* Save the number of selections and set it to zero while we do the  */
   /* object drawing.                                                   */

   savesel = areawin->selects;
   areawin->selects = 0;

   /* All parts are given in the coordinate system of the object, unless */
   /* this is the top-level object, in which they will be interpreted as */
   /* relative to the screen.                                            */

   UPushCTM();

   if (stack) {
      /* Save the current clipping mask and push it on the stack */
      if (areawin->clipped > 0) {
         push_stack((pushlistptr *)stack, theinstance, (char *)areawin->clipmask);
         areawin->clipmask = XCreatePixmap(dpy, areawin->window, areawin->width,
                areawin->height, 1);
         XCopyArea(dpy, (Pixmap)(*stack)->clientdata, areawin->clipmask, areawin->cmgc,
                0, 0, areawin->width, areawin->height, 0, 0);
      }
      else
         push_stack((pushlistptr *)stack, theinstance, (char *)NULL);
   }
   if (level != 0)
       UPreMultCTM(DCTM, theinstance->position, theinstance->scale,
                        theinstance->rotation);

   if (theinstance->style & LINE_INVARIANT)
      passwidth /= fabs(theinstance->scale);

   /* do a quick test for intersection with the display window */

   bboxin[0].x = theobject->bbox.lowerleft.x;
   bboxin[0].y = theobject->bbox.lowerleft.y;
   bboxin[1].x = theobject->bbox.lowerleft.x + theobject->bbox.width;
   bboxin[1].y = theobject->bbox.lowerleft.y + theobject->bbox.height; 
   if (level == 0)
      extendschembbox(theinstance, &(bboxin[0]), &(bboxin[1]));
   UTransformbyCTM(DCTM, bboxin, bboxout, 2);

   xm = (bboxout[0].x < bboxout[1].x) ? 0 : 1;  
   ym = (bboxout[0].y < bboxout[1].y) ? 0 : 1;  

   if (bboxout[xm].x < areawin->width && bboxout[ym].y < areawin->height &&
       bboxout[1 - xm].x > 0 && bboxout[1 - ym].y > 0) {       

     /* make parameter substitutions */
     psubstitute(theinstance);

     /* draw all of the elements */
   
     tmpwidth = UTopTransScale(passwidth);
     SetLineAttributes(dpy, areawin->gc, tmpwidth, LineSolid, CapRound,
                JoinBevel);

     /* guard against plist being regenerated during a redraw by the    */
     /* expression parameter mechanism (should that be prohibited?)     */

     for (thispart = 0; thispart < theobject->parts; thispart++) {
       areagen = theobject->plist + thispart;
       if ((*areagen)->type & DRAW_HIDE) continue;

       if (defaultcolor != DOFORALL) {
          Boolean clipcolor = FALSE;
          switch(ELEMENTTYPE(*areagen)) {
             case(POLYGON): case(SPLINE): case(ARC): case(PATH):
                if (TOPOLY(areagen)->style & CLIPMASK)
                   clipcolor = TRUE;
                break;
          }
          if (((*areagen)->color != curcolor) || (clipcolor == TRUE)) {
             if (clipcolor)
                curcolor = CLIPMASKCOLOR;
             else if ((*areagen)->color == DEFAULTCOLOR)
                curcolor = defaultcolor;
             else
                curcolor = (*areagen)->color;

             XcTopSetForeground(curcolor);
          }
       }

       switch(ELEMENTTYPE(*areagen)) {
          case(POLYGON):
             if (level == 0 || !((TOPOLY(areagen))->style & BBOX))
                UDrawPolygon(TOPOLY(areagen), passwidth);
             break;
   
          case(SPLINE):
             UDrawSpline(TOSPLINE(areagen), passwidth);
             break;
   
          case(ARC):
             UDrawArc(TOARC(areagen), passwidth);
             break;

          case(PATH):
             UDrawPath(TOPATH(areagen), passwidth);
             break;

          case(GRAPHIC):
             UDrawGraphic(TOGRAPHIC(areagen));
             break;
   
          case(OBJINST):
             if (areawin->editinplace && stack && (TOOBJINST(areagen)
                        == areawin->topinstance)) {
                /* If stack matches areawin->stack, then don't draw */
                /* because it would be redundant.                */
                pushlistptr alist = *stack, blist = areawin->stack;
                while (alist && blist) {
                   if (alist->thisinst != blist->thisinst) break;
                   alist = alist->next;
                   blist = blist->next;
                }
                if ((!alist) || (!blist)) break;
             }
             if (areawin->clipped > 0) areawin->clipped += 2;
             UDrawObject(TOOBJINST(areagen), level + 1, curcolor, passwidth, stack);
             if (areawin->clipped > 0) areawin->clipped -= 2;
             break;
   
          case(LABEL): 
             if (level == 0 || TOLABEL(areagen)->pin == False)
                UDrawString(TOLABEL(areagen), curcolor, theinstance);
             else if ((TOLABEL(areagen)->anchor & PINVISIBLE) && areawin->pinpointon)
                UDrawString(TOLABEL(areagen), curcolor, theinstance);
             else if (TOLABEL(areagen)->anchor & PINVISIBLE)
                UDrawStringNoX(TOLABEL(areagen), curcolor, theinstance);
             else if (level == 1 && TOLABEL(areagen)->pin &&
                        TOLABEL(areagen)->pin != INFO && areawin->pinpointon)
                UDrawXDown(TOLABEL(areagen));
             break;
       }
       if (areawin->clipped > 0) {
          if ((areawin->clipped & 3) == 1) {
             areawin->clipped++;
          }
          else if ((areawin->clipped & 3) == 2) {
             areawin->clipped -= 2;
             if ((!stack) || ((*stack)->clientdata == (char *)NULL)) {
                XSetClipMask(dpy, areawin->gc, None);
                // printf("1: Clear clipmask\n");       // Diagnostic
             }
             else {
                XSetClipMask(dpy, areawin->gc, (Pixmap)((*stack)->clientdata));
                // printf("1: Set to pushed clipmask\n");       // Diagnostic
             }
          }
       }
     }

     /* restore the color passed to the object, if different from current color */

     if ((defaultcolor != DOFORALL) && (passcolor != curcolor)) {
        XTopSetForeground(passcolor);
     }
     if (areawin->clipped > 0) {
        if ((areawin->clipped & 3) != 3) {
           if ((!stack) || ((*stack)->clientdata == (char *)NULL)) {
              XSetClipMask(dpy, areawin->gc, None);
              // printf("2: Clear clipmask\n"); // Diagnostic
           }
           else {
              XSetClipMask(dpy, areawin->gc, (Pixmap)((*stack)->clientdata));
              // printf("2: Set to pushed clipmask\n"); // Diagnostic
           }
        }
        areawin->clipped &= ~3;
     }
   }

   /* restore the selection list (if any) */
   areawin->selects = savesel;
   UPopCTM();
   if (stack) {
      if ((*stack) != NULL) {
         if ((*stack)->clientdata != (char *)NULL) {
            XFreePixmap(dpy, areawin->clipmask);
            areawin->clipmask = (Pixmap)(*stack)->clientdata;
            // printf("3: Restore clipmask\n"); // Diagnostic
         }
      }
      pop_stack(stack);
   }
}
#endif /* HAVE_CAIRO */

/*----------------------------------------------------------------------*/
/* Recursively run through the current page and find any labels which   */
/* are declared to be style LATEX.  If "checkonly" is present, we set   */
/* it to TRUE or FALSE depending on whether or not LATEX labels have    */
/* been encountered.  If NULL, then we write LATEX output appropriately */
/* to a file named with the page filename + suffix ".tex".              */
/*----------------------------------------------------------------------*/

void UDoLatex(objinstptr theinstance, short level, FILE *f,
        float scale, float scale2, int tx, int ty, Boolean *checkonly)
{
   XPoint       lpos, xlpos;
   XfPoint      xfpos;
   labelptr     thislabel;
   genericptr   *areagen;
   objectptr    theobject = theinstance->thisobject;
   char         *ltext;
   int          lranchor, tbanchor;

   UPushCTM();
   if (level != 0)
       UPreMultCTM(DCTM, theinstance->position, theinstance->scale,
                        theinstance->rotation);

   /* make parameter substitutions */
   psubstitute(theinstance);

   /* find all of the elements */
   
   for (areagen = theobject->plist; areagen < theobject->plist +
           theobject->parts; areagen++) {

      switch(ELEMENTTYPE(*areagen)) {
         case(OBJINST):
            UDoLatex(TOOBJINST(areagen), level + 1, f, scale, scale2, tx, ty, checkonly);
            break;
   
         case(LABEL): 
            thislabel = TOLABEL(areagen);
            if (level == 0 || thislabel->pin == False ||
                        (thislabel->anchor & PINVISIBLE))
                if (thislabel->anchor & LATEXLABEL) {
                    if (checkonly) {
                       *checkonly = TRUE;
                       return;
                    }
                    else {
                       lpos.x = thislabel->position.x;
                       lpos.y = thislabel->position.y;
                       UTransformbyCTM(DCTM, &lpos, &xlpos, 1);
                       xlpos.x += tx;
                       xlpos.y += ty;
                       xfpos.x = (float)xlpos.x * scale;
                       xfpos.y = (float)xlpos.y * scale;
                       xfpos.x /= 72.0;
                       xfpos.y /= 72.0;
                       xfpos.x -= 1.0;
                       xfpos.y -= 1.0;
                       xfpos.x += 0.056;
                       xfpos.y += 0.056;
                       xfpos.x /= scale2;
                       xfpos.y /= scale2;
                       ltext = textprinttex(thislabel->string, theinstance);
                       tbanchor = thislabel->anchor & (NOTBOTTOM | TOP);
                       lranchor = thislabel->anchor & (NOTLEFT | RIGHT);

                       /* The 1.2 factor accounts for the difference between     */
                       /* Xcircuit's label scale of "1" and LaTeX's "normalsize" */

                       fprintf(f, "   \\putbox{%3.2fin}{%3.2fin}{%3.2f}{",
                                xfpos.x, xfpos.y, 1.2 * thislabel->scale);
                       if (thislabel->rotation != 0)
                          fprintf(f, "\\rotatebox{-%d}{", thislabel->rotation);
                       if (lranchor == (NOTLEFT | RIGHT)) fprintf(f, "\\rightbox{");
                       else if (lranchor == NOTLEFT) fprintf(f, "\\centbox{");
                       if (tbanchor == (NOTBOTTOM | TOP)) fprintf(f, "\\topbox{");
                       else if (tbanchor == NOTBOTTOM) fprintf(f, "\\midbox{");
                       fprintf(f, "%s", ltext);
                       if (lranchor != NORMAL) fprintf(f, "}");
                       if (tbanchor != NORMAL) fprintf(f, "}");
                       if (thislabel->rotation != 0) fprintf(f, "}");
                       fprintf(f, "}%%\n");
                       free(ltext);
                    }
                }
            break;
       }
   }
   UPopCTM();
}

/*----------------------------------------------------------------------*/
/*  Top level routine for writing LATEX output.                         */
/*----------------------------------------------------------------------*/

void TopDoLatex()
{
   FILE *f;
   float psscale, outscale;
   int tx, ty, width, height;
   polyptr framebox;
   XPoint origin;
   Boolean checklatex = FALSE;
   char filename[100], extend[10], *dotptr;

   UDoLatex(areawin->topinstance, 0, NULL, 1.0, 1.0, 0, 0, &checklatex);

   if (checklatex == FALSE) return;     /* No LaTeX labels to write */

   /* Handle cases where the file might have a ".eps" extension.        */
   /* Thanks to Graham Sheward for pointing this out.                   */

   if (xobjs.pagelist[areawin->page]->filename)
      sprintf(filename, "%s", xobjs.pagelist[areawin->page]->filename);
   else
      sprintf(filename, "%s",
                xobjs.pagelist[areawin->page]->pageinst->thisobject->name);

   if ((dotptr = strchr(filename + strlen(filename) - 4, '.')) == NULL) {
       dotptr = filename + strlen(filename);
       sprintf(dotptr, ".ps");
   }
   strcpy(extend, dotptr);
   strcpy(dotptr, ".tex");

   f = fopen(filename, "w");

   *dotptr = '\0';

   fprintf(f, "%% XCircuit output \"%s.tex\" for LaTeX input from %s%s\n",
                filename, filename, extend);
   fprintf(f, "\\def\\putbox#1#2#3#4{\\makebox[0in][l]{\\makebox[#1][l]{}"
                "\\raisebox{\\baselineskip}[0in][0in]"
                "{\\raisebox{#2}[0in][0in]{\\scalebox{#3}{#4}}}}}\n");
   fprintf(f, "\\def\\rightbox#1{\\makebox[0in][r]{#1}}\n");
   fprintf(f, "\\def\\centbox#1{\\makebox[0in]{#1}}\n");
   fprintf(f, "\\def\\topbox#1{\\raisebox{-0.60\\baselineskip}[0in][0in]{#1}}\n");
   fprintf(f, "\\def\\midbox#1{\\raisebox{-0.20\\baselineskip}[0in][0in]{#1}}\n");

   /* Modified to use \scalebox and \parbox by Alex Tercete, June 2008 */

   // fprintf(f, "\\begin{center}\n");

   outscale = xobjs.pagelist[areawin->page]->outscale;
   psscale = getpsscale(outscale, areawin->page);

   width = toplevelwidth(areawin->topinstance, &origin.x);
   height = toplevelheight(areawin->topinstance, &origin.y);

   /* Added 10/19/10:  If there is a specified bounding box, let it     */
   /* determine the figure origin;  otherwise, the labels will be       */
   /* mismatched to the bounding box.                                   */

   if ((framebox = checkforbbox(topobject)) != NULL) {
      int i, maxx, maxy;

      origin.x = maxx = framebox->points[0].x;
      origin.y = maxy = framebox->points[0].y;
      for (i = 1; i < framebox->number; i++) {
         if (framebox->points[i].x < origin.x) origin.x = framebox->points[i].x;
         if (framebox->points[i].x > maxx) maxx = framebox->points[i].x;
         if (framebox->points[i].y < origin.y) origin.y = framebox->points[i].y;
         if (framebox->points[i].y > maxy) maxy = framebox->points[i].y;
      }
      origin.x -= ((width - maxx + origin.x) / 2);
      origin.y -= ((height - maxy + origin.y) / 2);
   }

   tx = (int)(72 / psscale) - origin.x,
   ty = (int)(72 / psscale) - origin.y;

   fprintf(f, "   \\scalebox{%g}{\n", outscale);
   fprintf(f, "   \\normalsize\n");
   fprintf(f, "   \\parbox{%gin}{\n", (((float)width * psscale) / 72.0) / outscale);
   fprintf(f, "   \\includegraphics[scale=%g]{%s}\\\\\n", 1.0 / outscale,
                        filename);
   fprintf(f, "   %% translate x=%d y=%d scale %3.2f\n", tx, ty, psscale);

   UPushCTM();          /* Save current state */
   UResetCTM(DCTM);     /* Set to identity matrix */
   UDoLatex(areawin->topinstance, 0, f, psscale, outscale, tx, ty, NULL);
   UPopCTM();           /* Restore state */

   fprintf(f, "   } %% close \'parbox\'\n");
   fprintf(f, "   } %% close \'scalebox\'\n");
   fprintf(f, "   \\vspace{-\\baselineskip} %% this is not"
                " necessary, but looks better\n");
   // fprintf(f, "\\end{center}\n");
   fclose(f);

   Wprintf("Wrote auxiliary file %s.tex", filename);
}