menucalls.c

   1 /*----------------------------------------------------------------------*/
   2 /* menucalls.c --- callback routines from the menu buttons, and         */
   3 /*                 associated routines (either Tcl/Tk routines or       */
   4 /*                 non-specific;  Xt routines split off in file         */
   5 /*                 xtfuncs.c 3/28/06)                                   */
   6 /* Copyright (c) 2002  Tim Edwards, Johns Hopkins University            */
   7 /*----------------------------------------------------------------------*/
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13 #include <sys/types.h>
  14 #include <errno.h>
  15 #include <limits.h>
  16
  17 #ifndef XC_WIN32
  18 #include <X11/Intrinsic.h>
  19 #include <X11/StringDefs.h>
  20 #include <X11/Xutil.h>
  21 #endif
  22
  23 #ifdef TCL_WRAPPER
  24 #include <tk.h>
  25 #endif
  26
  27 /*----------------------------------------------------------------------*/
  28 /* Local includes                                                       */
  29 /*----------------------------------------------------------------------*/
  30
  31 #include "colordefs.h"
  32 #include "xcircuit.h"
  33
  34 /*----------------------------------------------------------------------*/
  35 /* Function prototype declarations                                      */
  36 /*----------------------------------------------------------------------*/
  37 #include "prototypes.h"
  38
  39 /*----------------------------------------------------------------------*/
  40 /* External Variable definitions                                        */
  41 /*----------------------------------------------------------------------*/
  42
  43 extern char      _STR2[250];
  44 extern char      _STR[150];          /* Generic multipurpose string */
  45 extern xcWidget  top;
  46 extern Display   *dpy;
  47 extern Globaldata xobjs;
  48 extern XCWindowData *areawin;
  49 extern int        number_colors;
  50 extern colorindex *colorlist;
  51 extern ApplicationData appdata;
  52 extern Cursor     appcursors[NUM_CURSORS];
  53 extern fontinfo *fonts;
  54 extern short fontcount;
  55
  56 #ifdef TCL_WRAPPER
  57 extern Tcl_Interp *xcinterp;
  58 #endif
  59
  60 /*----------------------------------------------------------------------*/
  61 /* Local Variable definitions                                           */
  62 /*----------------------------------------------------------------------*/
  63
  64 u_short *fontnumbers;
  65 u_char nfontnumbers;
  66
  67 /*----------------------------------------------*/
  68 /* Set Poly and Arc line styles and fill styles */
  69 /*----------------------------------------------*/
  70
  71 #define BORDERS  (NOBORDER | DOTTED | DASHED)
  72 #define ALLFILLS (FILLSOLID | FILLED)
  73
  74 /*----------------------------------------------------------------*/
  75 /* setgrid, getgridspace are for grid and snap spacing sizes;     */
  76 /* include routines to parse fractions                            */
  77 /*----------------------------------------------------------------*/
  78
  79 void setgrid(xcWidget w, float *dataptr)
  80 {
  81    float oldvalue = *dataptr;
  82    float oscale, iscale = (float)xobjs.pagelist[areawin->page]->drawingscale.y /
  83         (float)xobjs.pagelist[areawin->page]->drawingscale.x;
  84    float fval;
  85
  86    /* For now, assume that the value is in the current display style. */
  87    /* Might be nice in the future to make it accept any input. . .    */
  88
  89    switch (xobjs.pagelist[areawin->page]->coordstyle) {
  90       case INTERNAL:
  91          if (sscanf(_STR2, "%f", &fval) == 0) {
  92             *dataptr = oldvalue;
  93             Wprintf("Illegal value");
  94          }
  95          else *dataptr = fval / iscale;
  96          break;
  97       case CM:
  98          oscale = xobjs.pagelist[areawin->page]->outscale * CMSCALE;
  99          if (sscanf(_STR2, "%f", &fval) == 0) {
 100             *dataptr = oldvalue;
 101             Wprintf("Illegal value");
 102          }
 103          else *dataptr = fval * IN_CM_CONVERT / (iscale * oscale);
 104          break;
 105       case DEC_INCH: case FRAC_INCH: {
 106          short parts;
 107          char *sptr;
 108          int f2, f3;
 109
 110          oscale = xobjs.pagelist[areawin->page]->outscale * INCHSCALE;
 111          for (sptr = _STR2; *sptr != '\0'; sptr++)
 112             if (*sptr == '/') *sptr = ' ';
 113          parts = sscanf(_STR2, "%f %d %d", &fval, &f2, &f3);
 114          if ((parts == 0) || (parts != 1 && (fval != (float)((int)fval)))) {
 115             *dataptr = oldvalue;
 116             Wprintf("Illegal value");
 117             break;
 118          }
 119          if (parts == 2) fval /= (float)f2;
 120          else if (parts == 3) fval += ((float)f2 / (float)f3);
 121          *dataptr = fval * 72.0 / (iscale * oscale);
 122          } break;
 123    }
 124    if (oldvalue != *dataptr) drawarea(NULL, NULL, NULL);
 125 }
 126
 127 /*----------------------------------------------------------------*/
 128 /* Write a measurement value into string "buffer" dependant on    */
 129 /* the current default units of measure (centimeters or inches).  */
 130 /*----------------------------------------------------------------*/
 131
 132 void measurestr(float value, char *buffer)
 133 {
 134    float oscale, iscale;
 135    iscale = (float)(xobjs.pagelist[areawin->page]->drawingscale.y) /
 136         (float)(xobjs.pagelist[areawin->page]->drawingscale.x);
 137
 138    switch (xobjs.pagelist[areawin->page]->coordstyle) {
 139       case INTERNAL:
 140          sprintf(buffer, "%5.3f", value * iscale);
 141          break;
 142       case CM:
 143          oscale = xobjs.pagelist[areawin->page]->outscale * CMSCALE;
 144          sprintf(buffer, "%5.3f cm", value * iscale * oscale / IN_CM_CONVERT);
 145          break;
 146       case DEC_INCH:
 147          oscale = xobjs.pagelist[areawin->page]->outscale * INCHSCALE;
 148          sprintf(buffer, "%5.3f in", value * iscale * oscale / 72.0);
 149          break;
 150       case FRAC_INCH:
 151          oscale = xobjs.pagelist[areawin->page]->outscale * INCHSCALE;
 152          fraccalc(((value * iscale * oscale) / 72.0), buffer);
 153          strcat(buffer, " in");
 154          break;
 155    }
 156 }
 157
 158 /*----------------------------------------------------------------*/
 159 /* set the global default line width.  The unit used internally   */
 160 /* is twice the value passed through pointer "dataptr".           */
 161 /*----------------------------------------------------------------*/
 162
 163 void setwidth(xcWidget w, float *dataptr)
 164 {
 165    float oldvalue = *dataptr;
 166    if (sscanf(_STR2, "%f", dataptr) == 0) {
 167       *dataptr = oldvalue;
 168       Wprintf("Illegal value");
 169       return;
 170    }
 171    (*dataptr) *= 2.0;
 172    if (oldvalue != *dataptr) drawarea(NULL, NULL, NULL);
 173 }
 174
 175 /*--------------------------------------------------------------*/
 176 /* Set text scale.                                              */
 177 /*--------------------------------------------------------------*/
 178
 179 void changetextscale(float newscale)
 180 {
 181    short *osel;
 182    labelptr settext;
 183    stringpart *strptr, *nextptr;
 184
 185    /* In edit mode, add font scale change. */
 186
 187    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
 188       settext = *((labelptr *)EDITPART);
 189       if (areawin->textpos > 0 || areawin->textpos < stringlength(settext->string, True,
 190                 areawin->topinstance)) {
 191          undrawtext(settext);
 192          strptr = findstringpart(areawin->textpos - 1, NULL, settext->string,
 193                         areawin->topinstance);
 194          nextptr = findstringpart(areawin->textpos, NULL, settext->string,
 195                         areawin->topinstance);
 196          if (strptr->type == FONT_SCALE)
 197             strptr->data.scale = newscale;
 198          else if (nextptr && nextptr->type == FONT_SCALE)
 199             nextptr->data.scale = newscale;
 200          else
 201             labeltext(FONT_SCALE, (char *)&newscale);
 202          redrawtext(settext);
 203       }
 204       else if (stringlength(settext->string, True, areawin->topinstance) > 0)
 205          labeltext(FONT_SCALE, (char *)&newscale);
 206       else (settext->scale = newscale);
 207    }
 208
 209    /* Change scale on all selected text objects */
 210
 211    else if (areawin->selects > 0) {
 212       float oldscale;
 213       Boolean waschanged = FALSE;
 214       for (osel = areawin->selectlist; osel < areawin->selectlist +
 215              areawin->selects; osel++) {
 216          if (SELECTTYPE(osel) == LABEL) {
 217             settext = SELTOLABEL(osel);
 218             oldscale = settext->scale;
 219             if (oldscale != newscale) {
 220                undrawtext(settext);
 221                settext->scale = newscale;
 222                redrawtext(settext);
 223                register_for_undo(XCF_Rescale, UNDO_MORE, areawin->topinstance,
 224                         (genericptr)settext, (double)oldscale);
 225                waschanged = TRUE;
 226             }
 227          }
 228       }
 229       if (waschanged) undo_finish_series();
 230    }
 231 }
 232
 233 /*--------------------------------------------------------------*/
 234 /* Auto-scale the drawing to fit the declared page size.        */
 235 /*                                                              */
 236 /* If the page is declared encapsulated, then do nothing.       */
 237 /* If a frame box is on the page, then scale to fit the frame   */
 238 /* to the declared page size, not the whole object.             */
 239 /*--------------------------------------------------------------*/
 240
 241 void autoscale(int page)
 242 {
 243    float newxscale, newyscale;
 244    float scalefudge = (xobjs.pagelist[page]->coordstyle
 245         == CM) ? CMSCALE : INCHSCALE;
 246    int width, height;
 247    polyptr framebox;
 248
 249    /* Check if auto-fit flag is selected */
 250    if (!(xobjs.pagelist[page]->pmode & 2)) return;
 251    /* Ignore auto-fit flag in EPS mode */
 252    if (!(xobjs.pagelist[page]->pmode & 1)) return;
 253
 254    else if (topobject->bbox.width == 0 || topobject->bbox.height == 0) {
 255       // Wprintf("Cannot auto-fit empty page");
 256       return;
 257    }
 258
 259    newxscale = (xobjs.pagelist[page]->pagesize.x -
 260         (2 * xobjs.pagelist[page]->margins.x)) / scalefudge;
 261    newyscale = (xobjs.pagelist[page]->pagesize.y -
 262         (2 * xobjs.pagelist[page]->margins.y)) / scalefudge;
 263
 264    if ((framebox = checkforbbox(topobject)) != NULL) {
 265       int i, minx, miny, maxx, maxy;
 266
 267       minx = maxx = framebox->points[0].x;
 268       miny = maxy = framebox->points[0].y;
 269       for (i = 1; i < framebox->number; i++) {
 270          if (framebox->points[i].x < minx) minx = framebox->points[i].x;
 271          else if (framebox->points[i].x > maxx) maxx = framebox->points[i].x;
 272          if (framebox->points[i].y < miny) miny = framebox->points[i].y;
 273          else if (framebox->points[i].y > maxy) maxy = framebox->points[i].y;
 274       }
 275       width = (maxx - minx);
 276       height = (maxy - miny);
 277    }
 278    else {
 279
 280       width = toplevelwidth(areawin->topinstance, NULL);
 281       height = toplevelheight(areawin->topinstance, NULL);
 282    }
 283
 284    if (xobjs.pagelist[page]->orient == 0) {     /* Portrait */
 285       newxscale /= width;
 286       newyscale /= height;
 287    }
 288    else {
 289       newxscale /= height;
 290       newyscale /= width;
 291    }
 292    xobjs.pagelist[page]->outscale = min(newxscale, newyscale);
 293 }
 294
 295 /*--------------------------------------------------------------*/
 296 /* Parse a string for possible units of measure.  Convert to    */
 297 /* current units of measure, if necessary.  Return the value    */
 298 /* in current units, as a type float.                           */
 299 /*--------------------------------------------------------------*/
 300
 301 float parseunits(char *strptr)
 302 {
 303    short curtype;
 304    Boolean inchunits = True;
 305    float pv;
 306    char units[12];
 307
 308    curtype = xobjs.pagelist[areawin->page]->coordstyle;
 309
 310    if (sscanf(strptr, "%f %11s", &pv, units) < 2)
 311       return pv;
 312    else {
 313       if (!strncmp(units, "cm", 2) || !strncmp(units, "centimeters", 11))
 314          inchunits = False;
 315       switch(curtype) {
 316          case CM:
 317             return ((inchunits) ? (pv * 2.54) : pv);
 318          default:
 319             return ((inchunits) ? pv : (pv / 2.54));
 320       }
 321    }
 322 }
 323
 324 /*--------------------------------------------------------------*/
 325 /* Set the output page size, in the current unit of measure     */
 326 /* Return value:  TRUE if _STR2 values were in inches, FALSE    */
 327 /* if in centimeters.                                           */
 328 /* XXX This API gives no good way to signal errors.             */
 329 /*--------------------------------------------------------------*/
 330
 331 Boolean setoutputpagesize(XPoint *dataptr)
 332 {
 333    float px, py;
 334    char units[10], *expos;
 335 #ifndef TCL_WRAPPER
 336    Arg wargs[1];
 337 #endif
 338
 339    strcpy(units, "in");
 340
 341    if (sscanf(_STR2, "%f %*c %f %9s", &px, &py, units) < 4) {
 342       if (sscanf(_STR2, "%f %*c %f", &px, &py) < 3) {
 343          if ((expos = strchr(_STR2, 'x')) == NULL) {
 344             Wprintf("Illegal Form for page size.");
 345             return FALSE;
 346          }
 347          else {
 348             *expos = '\0';
 349             if (sscanf(_STR2, "%f", &px) == 0 ||
 350                   sscanf(expos + 1, "%f %9s", &py, units) == 0) {
 351                Wprintf("Illegal Form for page size.");
 352                return FALSE;
 353             }
 354          }
 355       }
 356    }
 357
 358    /* Don't reduce page to less than the margins (1") or negative       */
 359    /* scales result.                                                    */
 360
 361    if ((px <= 2.0) || (py <= 2.0)) {
 362       Wprintf("Page size too small for margins.");
 363       return FALSE;
 364    }
 365
 366    dataptr->x = (short)(px * 72.0);
 367    dataptr->y = (short)(py * 72.0);
 368
 369    if (!strcmp(units, "cm")) {
 370       dataptr->x /= 2.54;
 371       dataptr->y /= 2.54;
 372       return FALSE;
 373    }
 374    return TRUE;
 375 }
 376
 377 /*--------------------------------------------------------------*/
 378 /* Get the text size (global or selected, depending on mode     */
 379 /*--------------------------------------------------------------*/
 380
 381 labelptr gettextsize(float **floatptr)
 382 {
 383    labelptr settext = NULL;
 384    short    *osel;
 385    stringpart *strptr, *nextptr;
 386    const float f_one = 1.00;
 387
 388    if (floatptr) *floatptr = &areawin->textscale;
 389
 390    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
 391       if (areawin->textpos > 0 || areawin->textpos < stringlength(settext->string,
 392                 True, areawin->topinstance)) {
 393          settext = *((labelptr *)EDITPART);
 394          strptr = findstringpart(areawin->textpos - 1, NULL, settext->string,
 395                         areawin->topinstance);
 396          nextptr = findstringpart(areawin->textpos, NULL, settext->string,
 397                         areawin->topinstance);
 398          if (strptr->type == FONT_SCALE) {
 399             if (floatptr) *floatptr = &strptr->data.scale;
 400          }
 401          else if (nextptr && nextptr->type == FONT_SCALE) {
 402             if (floatptr) *floatptr = &nextptr->data.scale;
 403          }
 404          else if (floatptr) *floatptr = (float *)(&f_one);
 405       }
 406       else {
 407          settext = *((labelptr *)EDITPART);
 408          if (floatptr) *floatptr = &(settext->scale);
 409       }
 410    }
 411    else if (areawin->selects > 0) {
 412       for (osel = areawin->selectlist; osel < areawin->selectlist +
 413                 areawin->selects; osel++) {
 414          if (SELECTTYPE(osel) == LABEL) {
 415             settext = SELTOLABEL(osel);
 416             if (floatptr) *floatptr = &(settext->scale);
 417             break;
 418          }
 419       }
 420    }
 421    return settext;
 422 }
 423
 424 /*--------------------------------------------------------------*/
 425 /* Set a character kern value                                   */
 426 /*--------------------------------------------------------------*/
 427
 428 void setkern(xcWidget w, stringpart *kpart)
 429 {
 430    char *sptr;
 431    short kd[2];
 432
 433    kd[0] = kd[1] = 0;
 434
 435    if ((sptr = strchr(_STR2, ',')) == NULL)
 436       Wprintf("Use notation X,Y");
 437    else {
 438       *sptr = '\0';
 439       sscanf(_STR2, "%hd", &kd[0]);
 440       sscanf(sptr + 1, "%hd", &kd[1]);
 441       if (kpart == NULL)
 442          labeltext(KERN, (char *)kd);
 443       else {
 444          labelptr curlabel = TOLABEL(EDITPART);
 445          undrawtext(curlabel);
 446          kpart->data.kern[0] = kd[0];
 447          kpart->data.kern[1] = kd[1];
 448          redrawtext(curlabel);
 449       }
 450    }
 451 }
 452
 453 /*----------------------------------------------------------------*/
 454 /* Set the drawing scale (specified as ratio X:Y)                 */
 455 /*----------------------------------------------------------------*/
 456
 457 void setdscale(xcWidget w, XPoint *dataptr)
 458 {
 459    char *sptr;
 460
 461    if ((sptr = strchr(_STR2, ':')) == NULL)
 462       Wprintf("Use ratio X:Y");
 463    else {
 464       *sptr = '\0';
 465       sscanf(_STR2, "%hd", &(dataptr->x));
 466       sscanf(sptr + 1, "%hd", &(dataptr->y));
 467       Wprintf("New scale is %hd:%hd", dataptr->x, dataptr->y);
 468       W1printf(" ");
 469    }
 470 }
 471
 472 /*----------------------------------------------------------------*/
 473 /* Set the scale of an object or group of selected objects        */
 474 /*----------------------------------------------------------------*/
 475
 476 void setosize(xcWidget w, objinstptr dataptr)
 477 {
 478    float tmpres, oldsize;
 479    Boolean waschanged = FALSE;
 480    short *osel;
 481    objinstptr nsobj;
 482    int res = sscanf(_STR2, "%f", &tmpres);
 483
 484    // Negative values are flips---deal with them independently
 485
 486    if (tmpres < 0)
 487       tmpres = -tmpres;
 488
 489    if (res == 0 || tmpres == 0) {
 490       Wprintf("Illegal value");
 491       return;
 492    }
 493    for (osel = areawin->selectlist; osel < areawin->selectlist +
 494              areawin->selects; osel++) {
 495       if (SELECTTYPE(osel) == OBJINST) {
 496          nsobj = SELTOOBJINST(osel);
 497          oldsize = nsobj->scale;
 498          nsobj->scale = (oldsize < 0) ? -tmpres : tmpres;
 499
 500          if (oldsize != tmpres) {
 501             register_for_undo(XCF_Rescale, UNDO_MORE, areawin->topinstance,
 502                         SELTOGENERIC(osel), (double)oldsize);
 503             waschanged = TRUE;
 504          }
 505       }
 506    }
 507    if (waschanged) undo_finish_series();
 508    pwriteback(areawin->topinstance);
 509    drawarea(NULL, NULL, NULL);
 510 }
 511
 512 /*----------------------------------------------------------------*/
 513 /* Set the linewidth of all selected arcs, polygons, splines, and */
 514 /* paths.                                                         */
 515 /*----------------------------------------------------------------*/
 516
 517 void setwwidth(xcWidget w, void *dataptr)
 518 {
 519    float     tmpres, oldwidth;
 520    short     *osel;
 521    arcptr    nsarc;
 522    polyptr   nspoly;
 523    splineptr nsspline;
 524    pathptr   nspath;
 525
 526    if (sscanf(_STR2, "%f", &tmpres) == 0) {
 527       Wprintf("Illegal value");
 528       return;
 529    }
 530    else if (areawin->selects == 0) {
 531       areawin->linewidth = tmpres;
 532    }
 533    else {
 534       for (osel = areawin->selectlist; osel < areawin->selectlist +
 535              areawin->selects; osel++) {
 536          if (SELECTTYPE(osel) == ARC) {
 537             nsarc = SELTOARC(osel);
 538             oldwidth = nsarc->width;
 539             nsarc->width = tmpres;
 540          }
 541          else if (SELECTTYPE(osel) == POLYGON) {
 542             nspoly = SELTOPOLY(osel);
 543             oldwidth = nspoly->width;
 544             nspoly->width = tmpres;
 545          }
 546          else if (SELECTTYPE(osel) == SPLINE) {
 547             nsspline = SELTOSPLINE(osel);
 548             oldwidth = nsspline->width;
 549             nsspline->width = tmpres;
 550          }
 551          else if (SELECTTYPE(osel) == PATH) {
 552             nspath = SELTOPATH(osel);
 553             oldwidth = nspath->width;
 554             nspath->width = tmpres;
 555          }
 556
 557          if (oldwidth != tmpres)
 558             register_for_undo(XCF_Rescale, UNDO_MORE, areawin->topinstance,
 559                         SELTOGENERIC(osel), (double)oldwidth);
 560       }
 561       unselect_all();
 562       pwriteback(areawin->topinstance);
 563       drawarea(NULL, NULL, NULL);
 564    }
 565 }
 566
 567 /*--------------------------------------------------------------*/
 568 /* Add a new font name to the list of known fonts               */
 569 /* Register the font number for the Alt-F cycling mechanism     */
 570 /* Tcl: depends on command tag mechanism for GUI menu update.   */
 571 /*--------------------------------------------------------------*/
 572
 573 #ifdef TCL_WRAPPER
 574
 575 void makenewfontbutton()
 576 {
 577    nfontnumbers++;
 578    if (nfontnumbers == 1)
 579       fontnumbers = (u_short *)malloc(sizeof(u_short));
 580    else
 581       fontnumbers = (u_short *)realloc(fontnumbers, nfontnumbers
 582                 * sizeof(u_short));
 583    fontnumbers[nfontnumbers - 1] = fontcount - 1;
 584 }
 585
 586 #endif /* TCL_WRAPPER */
 587
 588 /*---------------------------------------------------------------*/
 589 /* Some Xcircuit routines using toggle and toggleexcl,           */
 590 /* put here because they reference the menu structures directly. */
 591 /*                                                               */
 592 /* Note that by bypassing addnewcolorentry(), the new colors in  */
 593 /* colorlist are NOT added to the GUI list of colors.            */
 594 /*---------------------------------------------------------------*/
 595
 596 void setcolorscheme(Boolean boolvalue)
 597 {
 598    int i;
 599
 600    if (boolvalue) {
 601       colorlist[PARAMCOLOR].color.pixel = appdata.parampix;
 602       colorlist[AUXCOLOR].color.pixel = appdata.auxpix;
 603       colorlist[OFFBUTTONCOLOR].color.pixel = appdata.buttonpix;
 604       colorlist[SELECTCOLOR].color.pixel = appdata.selectpix;
 605       colorlist[GRIDCOLOR].color.pixel = appdata.gridpix;
 606       colorlist[SNAPCOLOR].color.pixel = appdata.snappix;
 607       colorlist[AXESCOLOR].color.pixel = appdata.axespix;
 608       colorlist[BACKGROUND].color.pixel = appdata.bg;
 609       colorlist[FOREGROUND].color.pixel = appdata.fg;
 610    }
 611    else {
 612       colorlist[PARAMCOLOR].color.pixel = appdata.parampix2;
 613       colorlist[AUXCOLOR].color.pixel = appdata.auxpix2;
 614       colorlist[OFFBUTTONCOLOR].color.pixel = appdata.buttonpix2;
 615       colorlist[SELECTCOLOR].color.pixel = appdata.selectpix2;
 616       colorlist[GRIDCOLOR].color.pixel = appdata.gridpix2;
 617       colorlist[SNAPCOLOR].color.pixel = appdata.snappix2;
 618       colorlist[AXESCOLOR].color.pixel = appdata.axespix2;
 619       colorlist[BACKGROUND].color.pixel = appdata.bg2;
 620       colorlist[FOREGROUND].color.pixel = appdata.fg2;
 621    }
 622
 623    colorlist[BARCOLOR].color.pixel = appdata.barpix;
 624    colorlist[FILTERCOLOR].color.pixel = appdata.filterpix;
 625
 626    colorlist[LOCALPINCOLOR].color.pixel = appdata.localcolor;
 627    colorlist[GLOBALPINCOLOR].color.pixel = appdata.globalcolor;
 628    colorlist[INFOLABELCOLOR].color.pixel = appdata.infocolor;
 629    colorlist[RATSNESTCOLOR].color.pixel = appdata.ratsnestcolor;
 630    colorlist[BBOXCOLOR].color.pixel = appdata.bboxpix;
 631    colorlist[CLIPMASKCOLOR].color.pixel = appdata.clipcolor;
 632    colorlist[FIXEDBBOXCOLOR].color.pixel = appdata.fixedbboxpix;
 633
 634    /* Fill in pixel information */
 635
 636    for (i = 0; i < NUMBER_OF_COLORS; i++) {
 637       unsigned short r, g, b;
 638
 639       /* Get the color the hard way by querying the X server colormap */
 640       xc_get_color_rgb(colorlist[i].color.pixel, &r, &g, &b);
 641
 642       /* Store this information locally so we don't have to do  */
 643       /* the lookup the hard way in the future.                 */
 644
 645       colorlist[i].color.red = r;
 646       colorlist[i].color.green = g;
 647       colorlist[i].color.blue = b;
 648    }
 649    areawin->redraw_needed = True;
 650    drawarea(NULL, NULL, NULL);
 651 }
 652
 653 /*----------------------------------------------------------------*/
 654 /* Change menu selection for reported measurement units           */
 655 /*----------------------------------------------------------------*/
 656
 657 #ifdef TCL_WRAPPER
 658
 659 void togglegrid(u_short type)
 660 {
 661    static char *stylenames[] = {
 662       "decimal inches",
 663       "fractional inches",
 664       "centimeters",
 665       "internal units", NULL
 666    };
 667
 668    XcInternalTagCall(xcinterp, 3, "config", "coordstyle", stylenames[type]);
 669 }
 670
 671 #endif /* TCL_WRAPPER */
 672
 673 /*----------------------------------------------------------------*/
 674 /* Called by setgridtype() to complete setting the reported       */
 675 /* measurement units                                              */
 676 /*----------------------------------------------------------------*/
 677
 678 void getgridtype(xcWidget button, pointertype value, caddr_t calldata)
 679 {
 680    short oldtype = xobjs.pagelist[areawin->page]->coordstyle;
 681    float scalefac = getpsscale(1.0, areawin->page) / INCHSCALE;
 682
 683 #ifndef TCL_WRAPPER
 684    togglegridstyles(button);
 685 #endif
 686    xobjs.pagelist[areawin->page]->coordstyle = (short)value;
 687
 688    switch(value) {
 689       case FRAC_INCH: case DEC_INCH: case INTERNAL:
 690          if (oldtype == CM) {
 691             xobjs.pagelist[areawin->page]->outscale *= scalefac;
 692 #ifndef TCL_WRAPPER
 693             /* Note:  Tcl defines a method for selecting standard  */
 694             /* page sizes.  We really DON'T want to reset the size */
 695             /* just because we switched measurement formats!       */
 696
 697             xobjs.pagelist[areawin->page]->pagesize.x = 612;
 698             xobjs.pagelist[areawin->page]->pagesize.y = 792; /* letter */
 699 #endif
 700          }
 701          break;
 702       case CM:
 703          if (oldtype != CM) {
 704             xobjs.pagelist[areawin->page]->outscale *= scalefac;
 705 #ifndef TCL_WRAPPER
 706             xobjs.pagelist[areawin->page]->pagesize.x = 595;
 707             xobjs.pagelist[areawin->page]->pagesize.y = 842; /* A4 */
 708 #endif
 709          }
 710          break;
 711    }
 712    if (oldtype != xobjs.pagelist[areawin->page]->coordstyle) {
 713       drawarea(NULL, NULL, NULL);
 714       W1printf(" ");
 715    }
 716 }
 717
 718 /*------------------------------------------------------*/
 719 /* Make new library, add new button to the "Libraries"  */
 720 /* cascaded menu, compose the library page, update the  */
 721 /* library directory, and go to that library page.      */
 722 /*------------------------------------------------------*/
 723
 724 void newlibrary(xcWidget w, caddr_t clientdata, caddr_t calldata)
 725 {
 726    int libnum = createlibrary(FALSE);
 727    startcatalog(w, libnum, NULL);
 728 }
 729
 730 /*----------------------------------------------*/
 731 /* Find an empty library, and return its page   */
 732 /* number if it exists.  Otherwise, return -1.  */
 733 /* This search does not include the so-called   */
 734 /* "User Library" (last library in list).       */
 735 /*----------------------------------------------*/
 736
 737 int findemptylib()
 738 {
 739   int i;
 740
 741   for (i = 0; i < xobjs.numlibs - 1; i++) {
 742      if (xobjs.userlibs[i].number == 0)
 743         return i;
 744   }
 745   return -1;
 746 }
 747
 748 /*----------------------------------------------*/
 749 /* Make new page; goto that page                */
 750 /* (wrapper for routine events.c:newpage())     */
 751 /*----------------------------------------------*/
 752
 753 void newpagemenu(xcWidget w, pointertype value, caddr_t nulldata)
 754 {
 755    newpage((short)value);
 756 }
 757
 758 #ifdef TCL_WRAPPER
 759
 760 /*----------------------------------------------*/
 761 /* Make new library and add a new button to the */
 762 /* "Libraries" cascaded menu.                   */
 763 /*----------------------------------------------*/
 764
 765 int createlibrary(Boolean force)
 766 {
 767   /* xcWidget libmenu, newbutton, oldbutton; (jdk) */
 768 #ifndef TCL_WRAPPER
 769    Arg wargs[2];
 770 #endif
 771    /* char libstring[20]; (jdk) */
 772    int libnum;
 773    objectptr newlibobj;
 774
 775    /* If there's an empty library, return its number */
 776    if ((!force) && (libnum = findemptylib()) >= 0) return (libnum + LIBRARY);
 777    libnum = (xobjs.numlibs++) + LIBRARY;
 778    xobjs.libtop = (objinstptr *)realloc(xobjs.libtop,
 779                 (libnum + 1) * sizeof(objinstptr));
 780    xobjs.libtop[libnum] = xobjs.libtop[libnum - 1];
 781    libnum--;
 782
 783    newlibobj = (objectptr) malloc(sizeof(object));
 784    initmem(newlibobj);
 785    xobjs.libtop[libnum] = newpageinst(newlibobj);
 786
 787    sprintf(newlibobj->name, "Library %d", libnum - LIBRARY + 1);
 788
 789    /* Create the library */
 790
 791    xobjs.userlibs = (Library *) realloc(xobjs.userlibs, xobjs.numlibs
 792         * sizeof(Library));
 793    xobjs.userlibs[libnum + 1 - LIBRARY] = xobjs.userlibs[libnum - LIBRARY];
 794    xobjs.userlibs[libnum - LIBRARY].library = (objectptr *) malloc(sizeof(objectptr));
 795    xobjs.userlibs[libnum - LIBRARY].number = 0;
 796    xobjs.userlibs[libnum - LIBRARY].instlist = NULL;
 797
 798    sprintf(_STR2, "xcircuit::newlibrarybutton \"%s\"", newlibobj->name);
 799    Tcl_Eval(xcinterp, _STR2);
 800
 801    /* Update the library directory to include the new page */
 802
 803    composelib(LIBLIB);
 804
 805    return libnum;
 806 }
 807
 808 /*--------------------------------------------------------------*/
 809 /* Routine called by newpage() if new button needs to be made   */
 810 /* to add to the "Pages" cascaded menu.                         */
 811 /*--------------------------------------------------------------*/
 812
 813 void makepagebutton()
 814 {
 815   /* xcWidget pagemenu, newbutton; (jdk) */
 816   /* char pagestring[10]; (jdk) */
 817
 818    /* make new entry in the menu */
 819
 820    sprintf(_STR2, "newpagebutton \"Page %d\"", xobjs.pages);
 821    Tcl_Eval(xcinterp, _STR2);
 822
 823    /* Update the page directory */
 824
 825    composelib(PAGELIB);
 826 }
 827
 828 /*----------------------------------------------------------------*/
 829 /* Find the Page menu button associated with the page number      */
 830 /* (passed parameter) and set the label of that button to the     */
 831 /* object name (= page label)                                     */
 832 /*----------------------------------------------------------------*/
 833
 834 void renamepage(short pagenumber)
 835 {
 836    objinstptr thisinst = xobjs.pagelist[pagenumber]->pageinst;
 837    char *pname, *plabel;
 838
 839    if ((pagenumber >= 0) && (pagenumber < xobjs.pages - 1) &&
 840             (thisinst != NULL)) {
 841       plabel = thisinst->thisobject->name;
 842       pname = (char *)malloc(36 + strlen(plabel));
 843       sprintf(pname, "catch {xcircuit::renamepage %d {%s}}", pagenumber + 1, plabel);
 844       Tcl_Eval(xcinterp, pname);
 845       free(pname);
 846    }
 847 }
 848
 849 /*--------------------------------------------------------------*/
 850 /* Same routine as above, for Library page menu buttons         */
 851 /*--------------------------------------------------------------*/
 852
 853 void renamelib(short libnumber)
 854 {
 855    if (libnumber <= xobjs.numlibs) return;
 856
 857    sprintf(_STR2, "xcircuit::renamelib %d \"%s\"", libnumber - LIBRARY + 1,
 858         xobjs.libtop[libnumber]->thisobject->name);
 859    Tcl_Eval(xcinterp, _STR2);
 860 }
 861
 862 /*--------------------------------------------------------------*/
 863 /* Set the menu checkmarks on the color menu                    */
 864 /*--------------------------------------------------------------*/
 865
 866 void setcolormark(int colorval)
 867 {
 868    /* Set GUI variables and execute any command tags associated */
 869    /* with the "color" command */
 870
 871 #ifdef TCL_WRAPPER
 872    char cstr[6];
 873
 874    if (colorval != DEFAULTCOLOR)
 875       sprintf(cstr, "%5d", colorval);
 876
 877    XcInternalTagCall(xcinterp, 3, "color", "set", (colorval == DEFAULTCOLOR) ?
 878         "inherit" : cstr);
 879 #endif
 880 }
 881
 882 /*----------------------------------------------------------------*/
 883 /* Set the checkmarks on the element styles menu                  */
 884 /*----------------------------------------------------------------*/
 885
 886 void setallstylemarks(u_short styleval)
 887 {
 888    /* Execute any command tags associated       */
 889    /* with the "fill" and "border" commands.    */
 890
 891    char fstr[10];
 892    int fillfactor;
 893    const char *bptr;
 894
 895    const char *borders[] = {"solid", "unbordered", "dashed", "dotted", NULL};
 896    enum BorderIdx { SolidIdx, UnborderedIdx, DashedIdx, DottedIdx };
 897
 898    if (styleval & FILLED) {
 899       fillfactor = (int)(12.5 * (float)(1 + ((styleval & FILLSOLID) >> 5)));
 900       if (fillfactor < 100)
 901          sprintf(fstr, "%d", fillfactor);
 902       else
 903          strcpy(fstr, "solid");
 904    }
 905    else
 906       strcpy(fstr, "unfilled");
 907
 908    switch (styleval & BORDERS) {
 909       case DASHED:
 910          bptr = borders[DashedIdx];
 911          break;
 912       case DOTTED:
 913          bptr = borders[DottedIdx];
 914          break;
 915       case NOBORDER:
 916          bptr = borders[UnborderedIdx];
 917          break;
 918       default:
 919          bptr = borders[SolidIdx];
 920          break;
 921    }
 922
 923    XcInternalTagCall(xcinterp, 3, "fill", fstr,
 924                 (styleval & OPAQUE) ? "opaque" : "transparent");
 925    XcInternalTagCall(xcinterp, 3, "border", "bbox", (styleval & BBOX) ? "true" :
 926                 "false");
 927    XcInternalTagCall(xcinterp, 3, "border", "clipmask", (styleval & CLIPMASK) ?
 928                 "true" : "false");
 929    XcInternalTagCall(xcinterp, 2, "border", (styleval & UNCLOSED) ? "unclosed" :
 930                 "closed");
 931    XcInternalTagCall(xcinterp, 2, "border", bptr);
 932 }
 933
 934 #endif /* TCL_WRAPPER */
 935
 936 /*--------------------------------------------------------------*/
 937 /* Check for a bounding box polygon                             */
 938 /*--------------------------------------------------------------*/
 939
 940 polyptr checkforbbox(objectptr localdata)
 941 {
 942    polyptr *cbbox;
 943
 944    for (cbbox = (polyptr *)localdata->plist; cbbox <
 945         (polyptr *)localdata->plist + localdata->parts; cbbox++)
 946       if (IS_POLYGON(*cbbox))
 947          if ((*cbbox)->style & BBOX) return *cbbox;
 948
 949    return NULL;
 950 }
 951
 952 /*--------------------------------------------------------------*/
 953 /* Set a value for element style.  "Mask" determines the bits   */
 954 /* to be affected, so that "value" may turn bits either on or   */
 955 /* off.                                                         */
 956 /*--------------------------------------------------------------*/
 957
 958 int setelementstyle(xcWidget w, u_short value, u_short mask)
 959 {
 960    Boolean preselected, selected = False;
 961    short *sstyle;
 962    u_short newstyle, oldstyle;
 963
 964    if (areawin->selects == 0) {
 965       preselected = FALSE;
 966       if (value & BBOX)
 967          checkselect(POLYGON);
 968       else
 969          checkselect(ARC | SPLINE | POLYGON | PATH);
 970    }
 971    else preselected = TRUE;
 972
 973    if (areawin->selects > 0) {
 974       if (value & BBOX) {
 975          polyptr ckp;
 976          if (areawin->selects != 1) {
 977             Wprintf("Choose only one polygon to be the bounding box");
 978             return -1;
 979          }
 980          else if (SELECTTYPE(areawin->selectlist) != POLYGON) {
 981             Wprintf("Bounding box can only be a polygon");
 982             return -1;
 983          }
 984          else if (((ckp = checkforbbox(topobject)) != NULL) &&
 985                 (ckp != SELTOPOLY(areawin->selectlist))) {
 986             Wprintf("Only one bounding box allowed per page");
 987             return -1;
 988          }
 989       }
 990
 991       for (sstyle = areawin->selectlist; sstyle < areawin->selectlist
 992            + areawin->selects; sstyle++) {
 993          short stype = SELECTTYPE(sstyle);
 994          if (stype & (ARC | POLYGON | SPLINE | PATH)) {
 995             short *estyle;
 996             switch (stype) {
 997                case ARC:
 998                   estyle = &((SELTOARC(sstyle))->style);
 999                   break;
1000                case SPLINE:
1001                   estyle = &((SELTOSPLINE(sstyle))->style);
1002                   break;
1003                case POLYGON:
1004                   estyle = &((SELTOPOLY(sstyle))->style);
1005                   break;
1006                case PATH:
1007                   estyle = &((SELTOPATH(sstyle))->style);
1008                   break;
1009             }
1010             oldstyle = newstyle = *estyle;
1011             newstyle &= ~(mask);
1012             newstyle |= value;
1013
1014             if (oldstyle != newstyle) {
1015                if ((newstyle & NOBORDER) && !(newstyle & FILLED)) {
1016                   Wprintf("Must have either a border or filler");
1017                   continue;
1018                }
1019
1020                SetForeground(dpy, areawin->gc, BACKGROUND);
1021                easydraw(*sstyle, DOFORALL);
1022
1023                *estyle = newstyle;
1024                if (mask & BBOX)
1025                   (SELTOPOLY(sstyle))->color = (value & BBOX) ? BBOXCOLOR
1026                                 : DEFAULTCOLOR;
1027
1028                SetForeground(dpy, areawin->gc, SELECTCOLOR);
1029                easydraw(*sstyle, DOFORALL);
1030
1031 #ifdef TCL_WRAPPER
1032                register_for_undo(XCF_ChangeStyle,
1033                         (sstyle == areawin->selectlist + areawin->selects - 1) ?
1034                         UNDO_DONE : UNDO_MORE, areawin->topinstance,
1035                         SELTOGENERIC(sstyle), (int)oldstyle);
1036 #else
1037                /* Tcl version differs in that the element is not deselected after */
1038
1039                register_for_undo(XCF_ChangeStyle, UNDO_MORE, areawin->topinstance,
1040                         SELTOGENERIC(sstyle), (int)oldstyle);
1041 #endif
1042             }
1043             selected = True;
1044          }
1045       }
1046    }
1047    if (selected)
1048       pwriteback(areawin->topinstance);
1049    else {
1050       newstyle = areawin->style;
1051       if (value & BBOX) {
1052          Wprintf("Cannot set default style to Bounding Box");
1053          newstyle &= ~(BBOX);
1054          return -1;
1055       }
1056       else if (value & CLIPMASK) {
1057          Wprintf("Cannot set default style to Clip Mask");
1058          newstyle &= ~(CLIPMASK);
1059          return -1;
1060       }
1061       else {
1062          newstyle &= ~mask;
1063          newstyle |= value;
1064       }
1065
1066       if ((newstyle & NOBORDER) && !(newstyle & FILLED)) {
1067          Wprintf("Must have either a border or filler");
1068          return -1;
1069       }
1070       areawin->style = newstyle;
1071 #ifndef TCL_WRAPPER
1072       overdrawpixmap(w);
1073 #endif
1074    }
1075 #ifndef TCL_WRAPPER
1076    setallstylemarks(newstyle);
1077 #endif
1078    if (!preselected)
1079       unselect_all();
1080
1081    return (int)newstyle;
1082 }
1083
1084 /*-----------------------------------------------*/
1085 /* Set the color value for all selected elements */
1086 /*-----------------------------------------------*/
1087
1088 #ifdef TCL_WRAPPER
1089
1090 void setcolor(xcWidget w, int cindex)
1091 {
1092    short *scolor;
1093    int *ecolor, oldcolor;
1094    Boolean selected = False;
1095    stringpart *strptr, *nextptr;
1096
1097    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1098       labelptr curlabel = TOLABEL(EDITPART);
1099       strptr = findstringpart(areawin->textpos - 1, NULL, curlabel->string,
1100                         areawin->topinstance);
1101       nextptr = findstringpart(areawin->textpos, NULL, curlabel->string,
1102                         areawin->topinstance);
1103       if (strptr && strptr->type == FONT_COLOR) {
1104          undrawtext(curlabel);
1105          strptr->data.color = cindex;
1106          redrawtext(curlabel);
1107       }
1108       else if (nextptr && nextptr->type == FONT_COLOR) {
1109             undrawtext(curlabel);
1110             nextptr->data.color = cindex;
1111             redrawtext(curlabel);
1112       }
1113       else {
1114          sprintf(_STR2, "%d", cindex);
1115          labeltext(FONT_COLOR, (char *)&cindex);
1116       }
1117    }
1118
1119    else if (areawin->selects > 0) {
1120       for (scolor = areawin->selectlist; scolor < areawin->selectlist
1121            + areawin->selects; scolor++) {
1122          ecolor = &(SELTOCOLOR(scolor));
1123          oldcolor = *ecolor;
1124          *ecolor = cindex;
1125          selected = True;
1126
1127          register_for_undo(XCF_Color, (scolor == areawin->selectlist
1128                         + areawin->selects - 1) ?  UNDO_DONE : UNDO_MORE,
1129                         areawin->topinstance,
1130                         SELTOGENERIC(scolor), (int)oldcolor);
1131       }
1132    }
1133
1134    setcolormark(cindex);
1135    if (!selected) {
1136       if (eventmode != TEXT_MODE && eventmode != ETEXT_MODE)
1137          areawin->color = cindex;
1138    }
1139    else pwriteback(areawin->topinstance);
1140 }
1141
1142 /*--------------------------------------------------------------*/
1143 /* Set the menu checkmarks on the font menu                     */
1144 /*--------------------------------------------------------------*/
1145
1146 void togglefontmark(int fontval)
1147 {
1148    if (fonts[fontval].family != NULL)
1149       XcInternalTagCall(xcinterp, 3, "label", "family", fonts[fontval].family);
1150 }
1151
1152 /*------------------------------------------------------*/
1153 /* Set checkmarks on label style menu                   */
1154 /* fvalue is for font, jvalue is for anchoring          */
1155 /*------------------------------------------------------*/
1156
1157 void togglestylemark(int styleval)
1158 {
1159    char *cstyle = translatestyle(styleval);
1160    if (cstyle != NULL)
1161       XcInternalTagCall(xcinterp, 3, "label", "style", cstyle);
1162 }
1163
1164 /*------------------------------------------------------*/
1165 /* Set checkmarks on label encoding menu                */
1166 /*------------------------------------------------------*/
1167
1168 void toggleencodingmark(int encodingval)
1169 {
1170    char *cenc = translateencoding(encodingval);
1171    if (cenc != NULL)
1172       XcInternalTagCall(xcinterp, 3, "label", "encoding", cenc);
1173 }
1174
1175 /*------------------------------------------------------*/
1176 /* Set checkmarks on label anchoring & flags menu       */
1177 /*------------------------------------------------------*/
1178
1179 void toggleanchormarks(int anchorvalue)
1180 {
1181    XcInternalTagCall(xcinterp, 4, "label", "anchor", (anchorvalue & RIGHT) ? "right" :
1182         (anchorvalue & NOTLEFT) ? "center" : "left",
1183         (anchorvalue & TOP) ? "top" : (anchorvalue & NOTBOTTOM) ? "middle" : "bottom");
1184    XcInternalTagCall(xcinterp, 3, "label", "justify", (anchorvalue & JUSTIFYRIGHT) ?
1185         "right" : (anchorvalue & TEXTCENTERED) ? "center" : (anchorvalue & JUSTIFYBOTH)
1186         ? "both" : "left");
1187    XcInternalTagCall(xcinterp, 3, "label", "flipinvariant", (anchorvalue & FLIPINV) ?
1188         "true" : "false");
1189    XcInternalTagCall(xcinterp, 3, "label", "latex", (anchorvalue & LATEXLABEL) ?
1190         "true" : "false");
1191    XcInternalTagCall(xcinterp, 3, "label", "visible", (anchorvalue & PINVISIBLE) ?
1192         "true" : "false");
1193 }
1194
1195 /*-------------------------------------------------------------*/
1196 /* Simultaneously set all relevant checkmarks for a text label */
1197 /*-------------------------------------------------------------*/
1198
1199 void setfontmarks(short fvalue, short jvalue)
1200 {
1201    if ((fvalue >= 0) && (fvalue < fontcount)) {
1202       toggleencodingmark(fvalue);
1203       togglestylemark(fvalue);
1204       togglefontmark(fvalue);
1205    }
1206    toggleanchormarks(jvalue);
1207 }
1208
1209 #endif /* TCL_WRAPPER */
1210
1211 /*--------------------------------------------------------------*/
1212 /* Parameterize a label string (wrapper for parameterize()).    */
1213 /* Assumes that the name has been generated by the popup prompt */
1214 /* and is therefore held in variable _STR2                      */
1215 /*--------------------------------------------------------------*/
1216
1217 void stringparam(xcWidget w, caddr_t clientdata, caddr_t calldata)
1218 {
1219    genericptr *settext;
1220
1221    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1222       settext = (genericptr *)EDITPART;
1223       makeparam(TOLABEL(settext), _STR2);
1224       if (eventmode == ETEXT_MODE)
1225          unselect_all();
1226       else
1227          /* Move cursor position to account for the parameter   */
1228          /* start and end markers that have been added to the   */
1229          /* string.                                             */
1230          areawin->textpos += 2;
1231       setparammarks(NULL);
1232    }
1233    else if (checkselect(LABEL)) parameterize(P_SUBSTRING, _STR2, -1);
1234 }
1235
1236 /*--------------------------------------------------------------*/
1237 /* Numerical parameterization (wrapper for parameterize()).     */
1238 /*--------------------------------------------------------------*/
1239
1240 void startparam(xcWidget w, pointertype value, caddr_t calldata)
1241 {
1242    if (value == (pointertype)P_SUBSTRING) {
1243       strcpy(_STR2, (calldata != NULL) ? (char *)calldata : "substring");
1244       stringparam(w, NULL, NULL);
1245    }
1246    else if ((eventmode != NORMAL_MODE) || (areawin->selects > 0))
1247          parameterize((int)value, (char *)calldata, -1);
1248 }
1249
1250 /*---------------------------------------------------------------*/
1251 /* Unparameterize a label string (wrapper for unparameterize()). */
1252 /*---------------------------------------------------------------*/
1253
1254 void startunparam(xcWidget w, pointertype value, caddr_t calldata)
1255 {
1256    if (areawin->selects > 0)
1257       unparameterize((int)value);
1258    unselect_all();
1259    setparammarks(NULL);
1260 }
1261
1262 /*----------------------------------------------------------------*/
1263 /* Set checkmarks on font menu according to the global defaults   */
1264 /*----------------------------------------------------------------*/
1265
1266 void setdefaultfontmarks()
1267 {
1268    setfontmarks(areawin->psfont, areawin->anchor);
1269 }
1270
1271 /*----------------------------------------------------------------*/
1272 /* Pick up font name from _STR2 and pass it to loadfontfile()     */
1273 /*----------------------------------------------------------------*/
1274
1275 void locloadfont(xcWidget w, char *value)
1276 {
1277    loadfontfile(_STR2);
1278    free(value);
1279 }
1280
1281 /*----------------------------------------------------------------*/
1282 /* Find the best matching font given new font, style, or encoding */
1283 /*----------------------------------------------------------------*/
1284 /* newfont, style, or encoding = -1 when not applicable           */
1285 /* Return the number of the best matching font.                   */
1286 /*----------------------------------------------------------------*/
1287
1288 short findbestfont(short curfont, short newfont, short style, short encoding) {
1289
1290    char *newfamily;
1291    short i, newstyle, newenc;
1292
1293    if (fontcount == 0) return -1;
1294    if (curfont < 0) curfont = 0;
1295
1296    if (newfont < 0)
1297       newfamily = fonts[curfont].family;
1298    else if (newfont >= fontcount) {     /* move to next font family */
1299       short newidx;
1300       newfont = 0;
1301       while (strcmp(fonts[fontnumbers[newfont]].family, fonts[curfont].family))
1302          newfont++;
1303       newidx = (newfont + 1) % nfontnumbers;
1304       while (!strcmp(fonts[curfont].family, fonts[fontnumbers[newidx]].family) &&
1305                 newfont != newidx)
1306          newidx = (newidx + 1) % nfontnumbers;
1307       newfamily = fonts[fontnumbers[newidx]].family;
1308       newfont = fontnumbers[newidx];
1309    }
1310    else
1311       newfamily = fonts[newfont].family;
1312
1313    if (style < 0)
1314       newstyle = fonts[curfont].flags & 0x03;
1315    else
1316       newstyle = style & 0x03;
1317
1318    if (encoding < 0)
1319       newenc = fonts[curfont].flags & 0xf80;
1320    else
1321       newenc = encoding << 7;
1322
1323    /* Best position is a match on all conditions */
1324
1325    for (i = 0; i < fontcount; i++)
1326       if ((!strcmp(fonts[i].family, newfamily)) &&
1327                 ((fonts[i].flags & 0x03) == newstyle) &&
1328                 ((fonts[i].flags & 0xf80) == newenc))
1329          return i;
1330
1331    /* Fallback position 1:  Match requested property and one other.     */
1332    /* order of preference:                                              */
1333    /*   Requested property      Priority 1      Priority 2              */
1334    /*           Font              Style           Encoding              */
1335    /*           Style             Font            (none)                */
1336    /*           Encoding          Font            (none)                */
1337
1338    for (i = 0; i < fontcount; i++) {
1339       if (newfont >= 0) {
1340          if ((!strcmp(fonts[i].family, newfamily)) &&
1341                 (fonts[i].flags & 0x03) == newstyle) return i;
1342       }
1343       else if (style >= 0) {
1344          if (((fonts[i].flags & 0x03) == newstyle) &&
1345                 (!strcmp(fonts[i].family, newfamily))) return i;
1346       }
1347       else if (encoding >= 0) {
1348          if (((fonts[i].flags & 0xf80) == newenc) &&
1349                 (!strcmp(fonts[i].family, newfamily))) return i;
1350       }
1351    }
1352
1353    for (i = 0; i < fontcount; i++) {
1354       if (newfont >= 0) {
1355          if ((!strcmp(fonts[i].family, newfamily)) &&
1356             ((fonts[i].flags & 0xf80) >> 7) == newenc) return i;
1357       }
1358    }
1359
1360    /* Fallback position 2:  Match only the requested property.  */
1361    /* For font selection only:  Don't want to select a new font */
1362    /* just because a certain style or encoding wasn't available.*/
1363
1364    for (i = 0; i < fontcount; i++) {
1365       if (newfont >= 0) {
1366          if (!strcmp(fonts[i].family, newfamily)) return i;
1367       }
1368    }
1369
1370    /* Failure to find matching font property */
1371
1372    if (style >= 0) {
1373       Wprintf("Font %s not available in this style", newfamily);
1374    }
1375    else {
1376       Wprintf("Font %s not available in this encoding", newfamily);
1377    }
1378    return (-1);
1379 }
1380
1381 /*----------------------------------------------------------------*/
1382 /* Set the font.  This depends on the system state as to whether  */
1383 /* font is set at current position in label, for an entire label, */
1384 /* or as the default font to begin new labels.                    */
1385 /*----------------------------------------------------------------*/
1386
1387 void setfontval(xcWidget w, pointertype value, labelptr settext)
1388 {
1389    int newfont;
1390    short i, tc;
1391    stringpart *strptr;
1392
1393    if (settext != NULL) {
1394
1395       /* if last byte was a font designator, use it */
1396
1397       if (areawin->textpos > 0 || areawin->textpos < stringlength(settext->string,
1398                         True, areawin->topinstance)) {
1399          strptr = findstringpart(areawin->textpos - 1, NULL, settext->string,
1400                         areawin->topinstance);
1401          if (strptr->type == FONT_NAME) {
1402             tc = strptr->data.font;
1403             i = findbestfont(tc, (short)value, -1, -1);
1404             if (i >= 0) {
1405                undrawtext(settext);
1406                strptr->data.font = i;
1407                redrawtext(settext);
1408                if (w != NULL) {
1409                   charreport(settext);
1410                   togglefontmark(i);
1411                }
1412             }
1413             return;
1414          }
1415       }
1416
1417       /* otherwise, look for the last style used in the string */
1418       tc = findcurfont(areawin->textpos, settext->string, areawin->topinstance);
1419    }
1420    else tc = areawin->psfont;
1421
1422    /* Font change command will always find a value since at least one   */
1423    /* font has to exist for the font menu button to exist.              */
1424
1425    if ((newfont = (int)findbestfont(tc, (short)value, -1, -1)) < 0) return;
1426
1427    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1428       Wprintf("Font is now %s", fonts[newfont].psname);
1429       sprintf(_STR2, "%d", newfont);
1430       labeltext(FONT_NAME, (char *)&newfont);
1431    }
1432    else {
1433       Wprintf("Default font is now %s", fonts[newfont].psname);
1434       areawin->psfont = newfont;
1435    }
1436
1437    if (w != NULL) togglefontmark(newfont);
1438 }
1439
1440 /*----------------------------------------------------------------*/
1441 /* Wrapper for routine setfontval()                               */
1442 /*----------------------------------------------------------------*/
1443
1444 void setfont(xcWidget w, pointertype value, caddr_t calldata)
1445 {
1446    short *fselect;
1447    labelptr settext;
1448    short labelcount = 0;
1449    Boolean preselected;
1450
1451    if (eventmode == CATALOG_MODE || eventmode == FONTCAT_MODE ||
1452                 eventmode == EFONTCAT_MODE) return;
1453
1454    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1455       settext = *((labelptr *)EDITPART);
1456       setfontval(w, value, settext);
1457       charreport(settext);
1458    }
1459    else {
1460       if (areawin->selects == 0) {
1461          checkselect(LABEL);
1462          preselected = FALSE;
1463       }
1464       else preselected = TRUE;
1465       areawin->textpos = 1;
1466       for (fselect = areawin->selectlist; fselect < areawin->selectlist +
1467             areawin->selects; fselect++) {
1468          if (SELECTTYPE(fselect) == LABEL) {
1469             labelcount++;
1470             settext = SELTOLABEL(fselect);
1471             setfontval(NULL, value, settext);
1472          }
1473       }
1474       if (labelcount == 0) setfontval(w, value, NULL);
1475       else if (!preselected) unselect_all();
1476    }
1477 }
1478
1479 /*----------------------------------------------------------------*/
1480 /* Set the style (bold, italic, normal) for the font, similarly   */
1481 /* to the above routine setfontval().                             */
1482 /*----------------------------------------------------------------*/
1483
1484 void setfontstyle(xcWidget w, pointertype value, labelptr settext)
1485 {
1486    int newfont;
1487    short i, tc;
1488    stringpart *strptr;
1489
1490    if (settext != NULL) {
1491
1492       /* if last byte was a font designator, use it */
1493
1494       if (areawin->textpos > 0 || areawin->textpos < stringlength(settext->string,
1495                         True, areawin->topinstance)) {
1496          strptr = findstringpart(areawin->textpos - 1, NULL, settext->string,
1497                         areawin->topinstance);
1498          if (strptr->type == FONT_NAME) {
1499             tc = strptr->data.font;
1500
1501             /* find font which matches family and style, if available */
1502
1503             i = findbestfont(tc, -1, (short)value, -1);
1504             if (i >= 0) {
1505                undrawtext(settext);
1506                strptr->data.font = i;
1507                redrawtext(settext);
1508                if (w != NULL) {
1509                   charreport(settext);
1510 #ifndef TCL_WRAPPER
1511                   togglefontstyles(w);
1512 #endif
1513                }
1514             }
1515             return;
1516          }
1517       }
1518
1519       /* Otherwise, look for the last font used in the string */
1520       /* Fix by Dimitri Princen.  Was areawin->textpos - 2; was there a */
1521       /* reason for that?                                               */
1522
1523       tc = findcurfont(areawin->textpos, settext->string, areawin->topinstance);
1524    }
1525    else tc = areawin->psfont;
1526
1527    if ((newfont = (int)findbestfont(tc, -1, (short)value, -1)) < 0) return;
1528
1529    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1530       Wprintf("Font is now %s", fonts[newfont].psname);
1531       sprintf(_STR2, "%d", newfont);
1532       labeltext(FONT_NAME, (char *)&newfont);
1533    }
1534    else {
1535       Wprintf("Default font is now %s", fonts[newfont].psname);
1536       areawin->psfont = newfont;
1537    }
1538 #ifdef TCL_WRAPPER
1539    toggleencodingmark(value);
1540 #else
1541    togglefontstyles(w);
1542 #endif
1543 }
1544
1545 /*----------------------------------------------------------------*/
1546 /* Wrapper for routine setfontstyle()                             */
1547 /*----------------------------------------------------------------*/
1548
1549 void fontstyle(xcWidget w, pointertype value, caddr_t nulldata)
1550 {
1551    short *fselect;
1552    labelptr settext;
1553    short labelcount = 0;
1554    Boolean preselected;
1555
1556    if (eventmode == CATALOG_MODE || eventmode == FONTCAT_MODE ||
1557                 eventmode == EFONTCAT_MODE) return;
1558
1559    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1560       settext = *((labelptr *)EDITPART);
1561       setfontstyle(w, value, settext);
1562       charreport(settext);
1563    }
1564    else {
1565       if (areawin->selects == 0) {
1566          checkselect(LABEL);
1567          preselected = FALSE;
1568       }
1569       else preselected = TRUE;
1570       areawin->textpos = 1;
1571       for (fselect = areawin->selectlist; fselect < areawin->selectlist +
1572             areawin->selects; fselect++) {
1573          if (SELECTTYPE(fselect) == LABEL) {
1574             labelcount++;
1575             settext = SELTOLABEL(fselect);
1576             setfontstyle(NULL, value, settext);
1577          }
1578       }
1579       if (labelcount == 0) setfontstyle(w, value, NULL);
1580       else if (!preselected) unselect_all();
1581    }
1582 }
1583
1584 /*----------------------------------------------------------------*/
1585 /* Set the encoding (standard, ISO-Latin1, special) for the font, */
1586 /* similarly to the above routine setfontval().                   */
1587 /*----------------------------------------------------------------*/
1588
1589 void setfontencoding(xcWidget w, pointertype value, labelptr settext)
1590 {
1591    int newfont;
1592    short i, tc;
1593    stringpart *strptr;
1594
1595    if (settext != NULL) {
1596
1597       /* if last byte was a font designator, use it */
1598
1599       if (areawin->textpos > 0 || areawin->textpos < stringlength(settext->string,
1600                 True, areawin->topinstance)) {
1601          strptr = findstringpart(areawin->textpos - 1, NULL, settext->string,
1602                         areawin->topinstance);
1603          if (strptr->type == FONT_NAME) {
1604             tc = strptr->data.font;
1605
1606             i = findbestfont(tc, -1, -1, (short)value);
1607             if (i >= 0) {
1608                undrawtext(settext);
1609                strptr->data.font = i;
1610                redrawtext(settext);
1611                if (w != NULL) {
1612                   charreport(settext);
1613 #ifdef TCL_WRAPPER
1614                   toggleencodingmark(value);
1615 #else
1616                   toggleencodings(w);
1617 #endif
1618                }
1619             }
1620             return;
1621          }
1622       }
1623
1624       /* otherwise, look for the last style used in the string */
1625       tc = findcurfont(areawin->textpos - 2, settext->string, areawin->topinstance);
1626    }
1627    else tc = areawin->psfont;
1628
1629    if ((newfont = (int)findbestfont(tc, -1, -1, (short)value)) < 0) return;
1630
1631    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1632       Wprintf("Font is now %s", fonts[newfont].psname);
1633       sprintf(_STR2, "%d", newfont);
1634       labeltext(FONT_NAME, (char *)&newfont);
1635    }
1636    else {
1637       Wprintf("Default font is now %s", fonts[newfont].psname);
1638       areawin->psfont = newfont;
1639    }
1640
1641 #ifndef TCL_WRAPPER
1642    toggleencodings(w);
1643 #endif
1644 }
1645
1646 /*----------------------------------------------------------------*/
1647 /* Wrapper for routine setfontencoding()                          */
1648 /*----------------------------------------------------------------*/
1649
1650 void fontencoding(xcWidget w, pointertype value, caddr_t nulldata)
1651 {
1652    short *fselect;
1653    labelptr settext;
1654    short labelcount = 0;
1655    Boolean preselected;
1656
1657    if (eventmode == CATALOG_MODE || eventmode == FONTCAT_MODE ||
1658                 eventmode == EFONTCAT_MODE) return;
1659
1660    if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE) {
1661       settext = *((labelptr *)EDITPART);
1662       setfontencoding(w, value, settext);
1663       charreport(settext);
1664    }
1665    else {
1666       if (areawin->selects == 0) {
1667          checkselect(LABEL);
1668          preselected = FALSE;
1669       }
1670       else preselected = TRUE;
1671       areawin->textpos = 1;
1672       for (fselect = areawin->selectlist; fselect < areawin->selectlist +
1673             areawin->selects; fselect++) {
1674          if (SELECTTYPE(fselect) == LABEL) {
1675             labelcount++;
1676             settext = SELTOLABEL(fselect);
1677             setfontencoding(NULL, value, settext);
1678          }
1679       }
1680       if (labelcount == 0) setfontencoding(w, value, NULL);
1681       else if (!preselected) unselect_all();
1682    }
1683 }
1684
1685 /*----------------------------------------------*/
1686 /* Generate the table of special characters     */
1687 /*                                              */
1688 /* Return FALSE if the edited label is LaTeX-   */
1689 /* compatible, since LaTeX text does not        */
1690 /* usually contain special characters, but it   */
1691 /* does contain a lot of backslashes.           */
1692 /*----------------------------------------------*/
1693
1694 Boolean dospecial()
1695 {
1696    labelptr curlabel;
1697    int cfont;
1698
1699    curlabel = TOLABEL(EDITPART);
1700    if (curlabel->anchor & LATEXLABEL) return False;
1701
1702    cfont = findcurfont(areawin->textpos, curlabel->string, areawin->topinstance);
1703    composefontlib(cfont);
1704    startcatalog(NULL, FONTLIB, NULL);
1705    return True;
1706 }
1707
1708 /*-------------------------------------------------------------------------*/