?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Modified the UGetCursor() routine to return a valid response if the
[xcircuit.git] / xtgui.c
blob72d6e7ee4e2c04356b07e64decb6c621ba0a809d
1 /*----------------------------------------------------------------------*/
2 /* xtgui.c --- */
3 /* XCircuit's graphical user interface using the Xw widget set */
4 /* (see directory Xw) (non-Tcl/Tk GUI) */
5 /* Copyright (c) 2002 R. Timothy Edwards */
6 /*----------------------------------------------------------------------*/
7
8 #ifndef TCL_WRAPPER
9
10 #include <stdio.h>
11 #include <stdarg.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <signal.h>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <errno.h>
18 #include <limits.h>
19 #include <locale.h>
20 #ifndef XC_WIN32
21 #include <unistd.h> /* for unlink() */
22
23 #include <X11/Intrinsic.h>
24 #include <X11/StringDefs.h>
25 #include <X11/Shell.h>
26 #include <X11/Xutil.h>
27 #include <X11/cursorfont.h>
28 #include <X11/Xproto.h>
29 #include <X11/Xatom.h>
30
31 #include "Xw/Xw.h"
32 #include "Xw/Form.h"
33 #include "Xw/WorkSpace.h"
34 #include "Xw/PButton.h"
35 #include "Xw/SText.h"
36 #include "Xw/Cascade.h"
37 #include "Xw/PopupMgr.h"
38 #include "Xw/MenuBtn.h"
39 #include "Xw/BBoard.h"
40 #include "Xw/TextEdit.h"
41 #include "Xw/Toggle.h"
42 #endif
43
44 #ifdef HAVE_CAIRO
45 #include <cairo/cairo-xlib.h>
46 #endif
47 /*----------------------------------------------------------------------*/
48 /* Local includes */
49 /*----------------------------------------------------------------------*/
50
51 #include "xcircuit.h"
52 #include "cursors.h"
53 #include "colordefs.h"
54 #include "menudep.h"
55
56 /*----------------------------------------------------------------------*/
57 /* Function prototype declarations */
58 /*----------------------------------------------------------------------*/
59 #include "prototypes.h"
60
61 #ifdef HAVE_XPM
62 #ifndef XC_WIN32
63 #include <X11/xpm.h>
64 #endif
65 #include "lib/pixmaps/xcircuit.xpm"
66 #endif
67
68 /*----------------------------------------------------------------------*/
69 /* Global Variable definitions */
70 /*----------------------------------------------------------------------*/
71
72 extern short popups; /* total number of popup widgets on the screen */
73 extern int pressmode; /* Whether we are in a press & hold state */
74
75 xcWidget top;
76 xcWidget message1, message2, message3, toolbar, overlay = NULL;
77 xcWidget menuwidgets[MaxMenuWidgets];
78 xcWidget wschema, wsymb, netbutton;
79 XtAppContext app;
80 Atom wprot, wmprop[2];
81
82 extern char _STR2[250]; /* Specifically for text returned from the popup prompt */
83 extern char _STR[150]; /* Generic multipurpose string */
84 extern Display *dpy;
85 extern Colormap cmap;
86 extern Pixmap STIPPLE[STIPPLES];
87 extern Cursor appcursors[NUM_CURSORS];
88 extern ApplicationData appdata;
89 extern XCWindowData *areawin;
90 extern Globaldata xobjs;
91 extern int number_colors;
92 extern colorindex *colorlist;
93 extern short menusize;
94 extern xcIntervalId printtime_id;
95 extern short beeper;
96 extern short fontcount;
97 extern fontinfo *fonts;
98 extern short help_up;
99 extern menustruct TopButtons[];
100 #ifdef HAVE_XPM
101 extern toolbarstruct ToolBar[];
102 extern short toolbuttons;
103 #endif
104 extern short maxbuttons;
105 extern Pixmap helppix;
106 extern aliasptr aliastop;
107 extern float version;
108
109 static char STIPDATA[STIPPLES][4] = {
110 "\000\004\000\001",
111 "\000\005\000\012",
112 "\001\012\005\010",
113 "\005\012\005\012",
114 "\016\005\012\007",
115 "\017\012\017\005",
116 "\017\012\017\016",
117 "\000\000\000\000"
118 };
119
120 extern Pixmap dbuf;
121
122 /* Bad hack for problems with the DECstation. . . don't know why */
123 #ifdef UniqueContextProblem
124 #undef XUniqueContext
125 XContext XUniqueContext()
126 {
127 return XrmUniqueQuark();
128 }
129 #endif
130 /* End of bad hack. . . */
131
132 /*----------------------------------------------------------------------*/
133 /* Initial Resource Management */
134 /*----------------------------------------------------------------------*/
135
136 #ifndef XC_WIN32
137
138 static XtResource resources[] = {
139
140 /* schematic layout colors */
141
142 { "globalpincolor", "GlobalPinColor", XtRPixel, sizeof(Pixel),
143 XtOffset(ApplicationDataPtr, globalcolor), XtRString, "Orange2"},
144 { "localpincolor", "LocalPinColor", XtRPixel, sizeof(Pixel),
145 XtOffset(ApplicationDataPtr, localcolor), XtRString, "Red"},
146 { "infolabelcolor", "InfoLabelColor", XtRPixel, sizeof(Pixel),
147 XtOffset(ApplicationDataPtr, infocolor), XtRString, "SeaGreen"},
148 { "ratsnestcolor", "RatsNestColor", XtRPixel, sizeof(Pixel),
149 XtOffset(ApplicationDataPtr, ratsnestcolor), XtRString, "Tan4"},
150
151 /* non-schematic layout colors */
152
153 { "bboxcolor", "BBoxColor", XtRPixel, sizeof(Pixel),
154 XtOffset(ApplicationDataPtr, bboxpix), XtRString, "greenyellow"},
155 { "fixedbboxcolor", "FixedBBoxColor", XtRPixel, sizeof(Pixel),
156 XtOffset(ApplicationDataPtr, fixedbboxpix), XtRString, "Pink"},
157 { "clipcolor", "ClipColor", XtRPixel, sizeof(Pixel),
158 XtOffset(ApplicationDataPtr, clipcolor), XtRString, "powderblue"},
159
160 /* GUI Color scheme 1 */
161
162 { XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
163 XtOffset(ApplicationDataPtr, fg), XtRString, "Black"},
164 { XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
165 XtOffset(ApplicationDataPtr, bg), XtRString, "White"},
166 { "gridcolor", "GridColor", XtRPixel, sizeof(Pixel),
167 XtOffset(ApplicationDataPtr, gridpix), XtRString, "Gray95"},
168 { "snapcolor", "SnapColor", XtRPixel, sizeof(Pixel),
169 XtOffset(ApplicationDataPtr, snappix), XtRString, "Red"},
170 { "selectcolor", "SelectColor", XtRPixel, sizeof(Pixel),
171 XtOffset(ApplicationDataPtr, selectpix), XtRString, "Gold3"},
172 { "filtercolor", "FilterColor", XtRPixel, sizeof(Pixel),
173 XtOffset(ApplicationDataPtr, filterpix), XtRString, "SteelBlue3"},
174 { "axescolor", "AxesColor", XtRPixel, sizeof(Pixel),
175 XtOffset(ApplicationDataPtr, axespix), XtRString, "Antique White"},
176 { "offbuttoncolor", "OffButtonColor", XtRPixel, sizeof(Pixel),
177 XtOffset(ApplicationDataPtr, buttonpix), XtRString, "Gray85"},
178 { "auxiliarycolor", "AuxiliaryColor", XtRPixel, sizeof(Pixel),
179 XtOffset(ApplicationDataPtr, auxpix), XtRString, "Green3"},
180 { "barcolor", "BarColor", XtRPixel, sizeof(Pixel),
181 XtOffset(ApplicationDataPtr, barpix), XtRString, "Tan"},
182 { "paramcolor", "ParamColor", XtRPixel, sizeof(Pixel),
183 XtOffset(ApplicationDataPtr, parampix), XtRString, "Plum3"},
184
185 /* GUI Color scheme 2 */
186
187 { "foreground2", XtCForeground, XtRPixel, sizeof(Pixel),
188 XtOffset(ApplicationDataPtr, fg2), XtRString, "White"},
189 { "background2", XtCBackground, XtRPixel, sizeof(Pixel),
190 XtOffset(ApplicationDataPtr, bg2), XtRString, "DarkSlateGray"},
191 { "gridcolor2", "GridColor", XtRPixel, sizeof(Pixel),
192 XtOffset(ApplicationDataPtr, gridpix2), XtRString, "Gray40"},
193 { "snapcolor2", "SnapColor", XtRPixel, sizeof(Pixel),
194 XtOffset(ApplicationDataPtr, snappix2), XtRString, "Red"},
195 { "selectcolor2", "SelectColor", XtRPixel, sizeof(Pixel),
196 XtOffset(ApplicationDataPtr, selectpix2), XtRString, "Gold"},
197 { "axescolor2", "AxesColor", XtRPixel, sizeof(Pixel),
198 XtOffset(ApplicationDataPtr, axespix2), XtRString, "NavajoWhite4"},
199 { "offbuttoncolor2", "OffButtonColor", XtRPixel, sizeof(Pixel),
200 XtOffset(ApplicationDataPtr, buttonpix2), XtRString, "Gray50"},
201 { "auxiliarycolor2", "AuxiliaryColor", XtRPixel, sizeof(Pixel),
202 XtOffset(ApplicationDataPtr, auxpix2), XtRString, "Green"},
203 { "paramcolor2", "ParamColor", XtRPixel, sizeof(Pixel),
204 XtOffset(ApplicationDataPtr, parampix2), XtRString, "Plum3"},
205
206 /* Other XDefaults-set properties */
207
208 { XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
209 XtOffset(ApplicationDataPtr, xcfont), XtRString,
210 "-*-times-bold-r-normal--14-*"},
211 { "helpfont", XtCFont, XtRFontStruct, sizeof(XFontStruct *),
212 XtOffset(ApplicationDataPtr, helpfont), XtRString,
213 "-*-helvetica-medium-r-normal--10-*"},
214 { "filelistfont", XtCFont, XtRFontStruct, sizeof(XFontStruct *),
215 XtOffset(ApplicationDataPtr, filefont), XtRString,
216 "-*-helvetica-medium-r-normal--14-*"},
217 { "textfont", XtCFont, XtRFontStruct, sizeof(XFontStruct *),
218 XtOffset(ApplicationDataPtr, textfont), XtRString,
219 "-*-courier-medium-r-normal--14-*"},
220 { "titlefont", XtCFont, XtRFontStruct, sizeof(XFontStruct *),
221 XtOffset(ApplicationDataPtr, titlefont), XtRString,
222 "-*-times-bold-i-normal--14-*"},
223 { XtNwidth, XtCWidth, XtRInt, sizeof(int),
224 XtOffset(ApplicationDataPtr, width), XtRString, "950"},
225 { XtNheight, XtCHeight, XtRInt, sizeof(int),
226 XtOffset(ApplicationDataPtr, height), XtRString, "760"},
227 { "timeout", "TimeOut", XtRInt, sizeof(int),
228 XtOffset(ApplicationDataPtr, timeout), XtRString, "10"}
229 };
230
231 #endif
232
233 /*----------------------------------------------------------------------*/
234 /* Add a new color button to the color menu */
235 /* called if new color button needs to be made */
236 /*----------------------------------------------------------------------*/
237
238 int addnewcolorentry(int ccolor)
239 {
240 xcWidget colormenu, newbutton;
241 Arg wargs[2];
242 int i, n = 0;
243
244 /* check to see if entry is already in the color list */
245
246 for (i = NUMBER_OF_COLORS; i < number_colors; i++)
247 if (colorlist[i].color.pixel == ccolor) break;
248
249 /* make new entry in the menu */
250
251 if (i == number_colors) {
252
253 colormenu = xcParent(ColorAddNewColorButton);
254 XtnSetArg(XtNlabelType, XwRECT);
255 XtnSetArg(XtNrectColor, ccolor);
256
257 newbutton = XtCreateWidget("NewColor", XwmenubuttonWidgetClass,
258 colormenu, wargs, n);
259 XtAddCallback (newbutton, XtNselect, (XtCallbackProc)setcolor, NULL);
260 XtManageChild(newbutton);
261
262 addtocolorlist(newbutton, ccolor);
263 }
264 return i;
265 }
266
267 /*----------------------------------------------------------------------*/
268 /* This recursive function looks down the button menu hierarchy and */
269 /* creates the necessary buttons and submenus. */
270 /* Menu entries are marked if the corresponding "size" entry in the */
271 /* menu structure is > 0. */
272 /*----------------------------------------------------------------------*/
273
274 void makesubmenu(char *menuname, char *attachname, menuptr buttonmenu,
275 int arraysize, xcWidget manager)
276 {
277 short i, n = 0;
278 int cval;
279 xcWidget popupshell, cascade;
280 Arg wargs[6];
281 menuptr p;
282 char popupname[30];
283
284 sprintf(popupname, "popup%s", menuname);
285 popupshell = XtCreatePopupShell (popupname, transientShellWidgetClass,
286 manager, NULL, 0);
287
288 XtnSetArg(XtNattachTo, attachname);
289 XtnSetArg(XtNfont, appdata.titlefont);
290 cascade = XtCreateManagedWidget (menuname, XwcascadeWidgetClass,
291 popupshell, wargs, n);
292
293 for (p = buttonmenu, i = 0; p < buttonmenu + arraysize; p++, i++) {
294 n = 0;
295 if (p->size > 0 && p->submenu == NULL) { /* This denotes a marked entry */
296 XtnSetArg(XtNsetMark, True);
297 }
298 XtnSetArg(XtNfont, appdata.xcfont);
299
300 if (p->submenu != NULL) {
301 xcWidget newbutton = XtCreateWidget(p->name, XwmenubuttonWidgetClass,
302 cascade, wargs, n);
303 makesubmenu(p->name, p->name, p->submenu, p->size, manager);
304 XtManageChild (newbutton);
305 }
306 else if (p->name[0] == ' ') {
307 /* This is a separator, made from a PushButton widget */
308
309 xcWidget newbutton = XtCreateWidget(p->name, XwmenuButtonWidgetClass,
310 cascade, wargs, n); n = 0;
311 XtManageChild (newbutton);
312
313 XtnSetArg(XtNheight, 5);
314 XtnSetArg(XtNsensitive, False);
315 XtSetValues(newbutton, wargs, n);
316 }
317 else {
318 if (p->name[0] == '_') { /* Color button */
319 cval = xc_alloccolor(p->name + 1);
320 XtnSetArg(XtNlabelType, XwRECT);
321 XtnSetArg(XtNrectColor, cval);
322 }
323 else if (p->name[0] == ':') { /* Stipple button */
324 XtnSetArg(XtNlabelType, XwRECT);
325 if (((pointertype)(p->passeddata) == (OPAQUE | FILLED | FILLSOLID))) {
326 XtnSetArg(XtNrectColor, BlackPixel(dpy,DefaultScreen(dpy)));
327 }
328 else {
329 XtnSetArg(XtNrectStipple, STIPPLE[((pointertype)(p->passeddata) &
330 FILLSOLID) >> 5]);
331 }
332 }
333 menuwidgets[++menusize] = XtCreateWidget(p->name, XwmenubuttonWidgetClass,
334 cascade, wargs, n);
335 XtAddCallback (menuwidgets[menusize], XtNselect, (XtCallbackProc)p->func,
336 p->passeddata);
337 if (p->name[0] == '_') {
338 /* For color buttons, maintain a list of Widgets and color values */
339 addtocolorlist(menuwidgets[menusize], cval);
340 }
341
342 XtManageChild (menuwidgets[menusize]);
343 }
344 }
345 }
346
347 #ifdef HAVE_XPM
348
349 /*----------------------------------------------------------------------*/
350 /* Toolbar Creator */
351 /*----------------------------------------------------------------------*/
352
353 #ifndef XC_WIN32
354
355 void createtoolbar (xcWidget abform, Widget aform)
356 {
357 int i, n = 0;
358 Arg wargs[12];
359 XImage *iret;
360 XpmAttributes attr;
361
362 XtnSetArg(XtNxRefWidget, aform);
363 XtnSetArg(XtNxAddWidth, True);
364 XtnSetArg(XtNxAttachRight, True);
365 XtnSetArg(XtNyAttachBottom, True);
366 XtnSetArg(XtNborderWidth, 0);
367 XtnSetArg(XtNxOffset, 2);
368 XtnSetArg(XtNyOffset, 2);
369 XtnSetArg(XtNxResizable, False);
370 XtnSetArg(XtNyResizable, True);
371
372 XtnSetArg(XtNlayout, XwIGNORE);
373 toolbar = XtCreateManagedWidget("ToolBar", XwbulletinWidgetClass, abform,
374 wargs, n); n = 0;
375
376 /* Fix for limited-color capability video. Thanks to */
377 /* Frankie Liu <frankliu@stanford.edu> */
378
379 attr.valuemask = XpmSize | XpmCloseness;
380 attr.closeness = 65536;
381
382 for (i = 0; i < toolbuttons; i++) {
383 XpmCreateImageFromData(dpy, ToolBar[i].icon_data, &iret, NULL, &attr);
384 XtnSetArg(XtNlabelType, XwIMAGE);
385 XtnSetArg(XtNlabelImage, iret);
386 XtnSetArg(XtNwidth, attr.width + 4);
387 XtnSetArg(XtNheight, attr.height + 4);
388 XtnSetArg(XtNborderWidth, TBBORDER);
389 XtnSetArg(XtNnoPad, True);
390 XtnSetArg(XtNhint, ToolBar[i].hint);
391 XtnSetArg(XtNhintProc, Wprintf);
392
393 menuwidgets[++menusize] = XtCreateManagedWidget(ToolBar[i].name,
394 XwmenuButtonWidgetClass, toolbar, wargs, n); n = 0;
395 XtAddCallback(menuwidgets[menusize], XtNselect,
396 (XtCallbackProc)ToolBar[i].func, ToolBar[i].passeddata);
397 }
398 }
399
400 #endif
401
402 /*----------------------------------------------------------------------*/
403 /* Toolbar Resize */
404 /*----------------------------------------------------------------------*/
405
406 void resizetoolbar()
407 {
408 int i, n = 0, bcol = 0;
409 int max_width = 0, max_height = 0, tot_width = 0;
410 Arg wargs[5];
411 xcWidget bwptr, lbwptr, bmax, lbmax;
412 Dimension t_height, bheight, bwidth;
413 xcWidget *tool_list = NULL;
414 int pytools = 0;
415
416 if (!xcIsRealized(toolbar)) return;
417
418 /* Avoid recursive calls to self and extra calls to the main draw routine */
419
420 XtRemoveCallback(areawin->area, XtNresize, (XtCallbackProc)resizetoolbar, NULL);
421 XtRemoveCallback(areawin->area, XtNresize, (XtCallbackProc)resizearea, NULL);
422
423 /* Find the height of the toolbar from the parent widget */
424
425 XtnSetArg(XtNheight, &t_height);
426 XtGetValues(xcParent(toolbar), wargs, n); n = 0;
427
428 #ifdef HAVE_PYTHON
429 tool_list = pytoolbuttons(&pytools);
430 #endif
431
432 /* Realign the tool buttons inside the fixed space */
433
434 for (i = 0; i < toolbuttons + pytools; i++) {
435 #ifdef HAVE_PYTHON
436 if (i >= toolbuttons)
437 bwptr = tool_list[i - toolbuttons];
438 else
439 #endif
440 bwptr = XtNameToWidget(toolbar, ToolBar[i].name);
441 if (bwptr == (Widget)NULL) break;
442
443 XtnSetArg(XtNheight, &bheight);
444 XtnSetArg(XtNwidth, &bwidth);
445 XtGetValues(bwptr, wargs, n); n = 0;
446 bheight += (TBBORDER << 1);
447 max_height += bheight;
448 if (max_height > t_height) {
449 bcol++;
450 lbmax = bmax;
451 tot_width += max_width;
452 max_width = 0;
453 max_height = (int)bheight;
454 }
455 if (bwidth > max_width) {
456 max_width = (int)bwidth;
457 bmax = bwptr;
458 }
459
460 XtnSetArg(XtNx, tot_width);
461 XtnSetArg(XtNy, max_height - bheight);
462 XtSetValues(bwptr, wargs, n); n = 0;
463 lbwptr = bwptr;
464 }
465
466 XtnSetArg(XtNwidth, tot_width + max_width);
467 XtSetValues(toolbar, wargs, n); n = 0;
468
469 /* Reinstate callbacks */
470 XtAddCallback(areawin->area, XtNresize, (XtCallbackProc)resizetoolbar, NULL);
471 XtAddCallback(areawin->area, XtNresize, (XtCallbackProc)resizearea, NULL);
472
473 #ifdef HAVE_PYTHON
474 if (tool_list != NULL) free(tool_list);
475 #endif
476 }
477
478 #endif /* HAVE_XPM */
479
480 /*----------------------------------------------------------------------*/
481 /* Hierarchical Menu Creator */
482 /* This function creates the top level of buttons which are arranged */
483 /* across the top starting at the left edge. For each button */
484 /* that has a submenu, a Popup manager is created, and then menu */
485 /* panes are attached to the manager in a hierarchical fashion. */
486 /* Note: Returns widget for last button on top level */
487 /*----------------------------------------------------------------------*/
488
489 void createmenus (xcWidget form, xcWidget *firstbutton, xcWidget *lastbutton)
490 {
491 int i, maxmgrs = 0, n = 0, j = 0;
492 WidgetList buttonw, mgr_shell, menu_mgr;
493 Arg wargs[6];
494
495 menusize = -1;
496
497 for (i = 0; i < maxbuttons; i++)
498 if (TopButtons[i].submenu != NULL) maxmgrs++;
499
500 buttonw = (WidgetList) XtMalloc(maxbuttons * sizeof(Widget));
501 mgr_shell = (WidgetList) XtMalloc(maxmgrs * sizeof(Widget));
502 menu_mgr = (WidgetList) XtMalloc(maxmgrs * sizeof(Widget));
503
504 for (i = 0; i < maxbuttons; i++) {
505
506 XtnSetArg(XtNheight, ROWHEIGHT);
507 XtnSetArg(XtNlabel, TopButtons[i].name);
508 XtnSetArg(XtNfont, appdata.xcfont);
509 if (i > 0) {
510 XtnSetArg(XtNxRefWidget, buttonw[i - 1]);
511 XtnSetArg(XtNxAddWidth, True);
512 }
513 buttonw[i] = XtCreateWidget(TopButtons[i].name,
514 XwmenuButtonWidgetClass, form, wargs, n); n = 0;
515
516 if (!strcmp(TopButtons[i].name, "Netlist")) {
517 netbutton = buttonw[i];
518 XtManageChild(buttonw[i]);
519 }
520 else
521 XtManageChild(buttonw[i]);
522
523 if(TopButtons[i].submenu == NULL)
524 XtAddCallback(buttonw[i], XtNselect,
525 (XtCallbackProc)TopButtons[i].func, NULL);
526 else {
527 mgr_shell[j] = XtCreatePopupShell("mgr_shell", shellWidgetClass,
528 buttonw[i], NULL, 0);
529 menu_mgr[j] = XtCreateManagedWidget("menu_mgr", XwpopupmgrWidgetClass,
530 mgr_shell[j], NULL, 0);
531 makesubmenu(TopButtons[i].name, "menu_mgr", TopButtons[i].submenu,
532 TopButtons[i].size, menu_mgr[j]);
533 j++;
534 }
535 }
536 *firstbutton = buttonw[0];
537 *lastbutton = buttonw[i - 1];
538 }
539
540 /*----------------------------------------------*/
541 /* Check for conditions to approve program exit */
542 /*----------------------------------------------*/
543
544 int quitcheck(xcWidget w, caddr_t clientdata, caddr_t calldata)
545 {
546 char *promptstr;
547 Boolean doprompt = False;
548 buttonsave *savebutton;
549
550 /* enable default interrupt signal handler during this time, so that */
551 /* a double Control-C will ALWAYS exit. */
552
553 signal(SIGINT, SIG_DFL);
554 promptstr = (char *)malloc(22);
555 strcpy(promptstr, "Unsaved changes in: ");
556
557 /* Check all page objects for unsaved changes */
558
559 doprompt = (countchanges(&promptstr) > 0) ? True : False;
560
561 /* If any changes have not been saved, generate a prompt */
562
563 if (doprompt) {
564 promptstr = (char *)realloc(promptstr, strlen(promptstr) + 15);
565 strcat(promptstr, "\nQuit anyway?");
566 savebutton = getgeneric(w, quitcheck, NULL);
567 popupprompt(w, promptstr, NULL, quit, savebutton, NULL);
568 free(promptstr);
569 return 0;
570 }
571 else {
572 free(promptstr);
573 quit(areawin->area, NULL);
574 return 1;
575 }
576 }
577
578 /*-------------------------------------------------------------------------*/
579 /* Popup dialog box routines */
580 /*-------------------------------------------------------------------------*/
581 /* Propogate any key event from the dialog box into the textedit widget */
582 /*-------------------------------------------------------------------------*/
583
584 #ifndef XC_WIN32
585
586 void propevent(xcWidget w, xcWidget editwidget, XEvent *event)
587 {
588 Window ewin = xcWindow(editwidget);
589
590 event->xany.window = ewin;
591 XSendEvent(dpy, ewin, False, KeyPressMask, event);
592 }
593
594 #endif
595
596 /*-------------------------------------------------------------------------*/
597 /* Destroy an interactive text-editing popup box */
598 /*-------------------------------------------------------------------------*/
599
600 void destroypopup(xcWidget button, popupstruct *callstruct, caddr_t calldata)
601 {
602 Arg wargs[1];
603
604 if(XtNameToWidget(callstruct->popup, "help2") != NULL) {
605 help_up = False;
606 XFreePixmap(dpy, helppix);
607 helppix = (Pixmap)NULL;
608 }
609
610 if (callstruct->buttonptr->button != NULL) {
611
612 /* return the button to its normal state */
613
614 XtSetArg(wargs[0], XtNforeground, callstruct->buttonptr->foreground);
615 XtSetValues(callstruct->buttonptr->button, wargs, 1);
616
617 XtAddCallback(callstruct->buttonptr->button, XtNselect,
618 (XtCallbackProc)callstruct->buttonptr->buttoncall,
619 callstruct->buttonptr->dataptr);
620 }
621
622 XtDestroyWidget(callstruct->popup);
623 popups--;
624
625 /* free the allocated structure space */
626
627 free(callstruct->buttonptr);
628 if (callstruct->filter != NULL) free(callstruct->filter);
629 free(callstruct);
630
631 /* in the case of "quitcheck", we want to make sure that the signal */
632 /* handler is reset to default behavior if the quit command is */
633 /* canceled from inside the popup prompt window. */
634
635 signal(SIGINT, dointr);
636 }
637
638 /*----------------------------------------------------------------------*/
639 /* Toggle button showing number of pages of output. */
640 /* Erase the filename and set everything accordingly. */
641 /*----------------------------------------------------------------------*/
642
643 void linkset(xcWidget button, propstruct *callstruct, caddr_t calldata)
644 {
645 Arg wargs[1];
646
647 free(xobjs.pagelist[areawin->page]->filename);
648 xobjs.pagelist[areawin->page]->filename = (char *)malloc(1);
649 xobjs.pagelist[areawin->page]->filename[0] = '\0';
650
651 XwTextClearBuffer(callstruct->textw);
652 getproptext(button, callstruct, calldata);
653
654 /* Change the select button back to "Apply" */
655 XtSetArg(wargs[0], XtNlabel, "Apply");
656 XtSetValues(callstruct->buttonw, wargs, 1);
657
658 /* Pop down the toggle button */
659 XtUnmanageChild(button);
660 }
661
662 /*----------------------------------------------------------------------*/
663 /* Pull text from the popup prompt buffer into a global string variable */
664 /*----------------------------------------------------------------------*/
665
666 #ifndef XC_WIN32
667
668 void xcgettext(xcWidget button, popupstruct *callstruct, caddr_t calldata)
669 {
670 if (callstruct->textw != NULL) {
671 sprintf(_STR2, "%.249s", XwTextCopyBuffer(callstruct->textw));
672
673 /* functions which use the file selector should look for directory name */
674 /* in string rather than a file name, and take appropriate action. */
675
676 if (callstruct->filew != NULL) {
677 if (lookdirectory(_STR2, 249)) {
678 newfilelist(callstruct->filew, callstruct);
679 return;
680 }
681 }
682 }
683
684 /* Pop down the widget now (for functions like execscript() which */
685 /* may want to interactively control the window contents), but do */
686 /* not destroy it until the function has returned. */
687
688 XtPopdown(callstruct->popup);
689
690 /* call the function which sets the variable according to type */
691 /* This is in format (function)(calling-widget, ptr-to-data) */
692
693 (*(callstruct->setvalue))(callstruct->buttonptr->button,
694 callstruct->buttonptr->dataptr);
695
696 if (callstruct->filew != NULL)
697 newfilelist(callstruct->filew, callstruct);
698
699 destroypopup(button, callstruct, calldata);
700 }
701
702 #endif
703
704 /*-------------------------------------------------------------------------*/
705 /* Grab text from the "output properties" window */
706 /*-------------------------------------------------------------------------*/
707
708 void getproptext(xcWidget button, propstruct *callstruct, caddr_t calldata)
709 {
710 /* xobjs.pagelist[areawin->page]->filename can be realloc'd by the */
711 /* call to *(callstruct->setvalue), so callstruct->dataptr may no */
712 /* longer be pointing to the data. */
713
714 Arg wargs[1];
715 short file_yes = (callstruct->setvalue == setfilename);
716
717 sprintf(_STR2, "%.249s", XwTextCopyBuffer(callstruct->textw));
718 (*(callstruct->setvalue))(button, callstruct->dataptr);
719
720 /* special stuff for filename changes */
721
722 if (file_yes) {
723 char blabel[1024];
724 short num_linked;
725 xcWidget wrbutton, ltoggle;
726 struct stat statbuf;
727
728 /* get updated file information */
729
730 if (strstr(xobjs.pagelist[areawin->page]->filename, ".") == NULL)
731 sprintf(blabel, "%s.ps", xobjs.pagelist[areawin->page]->filename);
732 else sprintf(blabel, "%s", xobjs.pagelist[areawin->page]->filename);
733 if (stat(blabel, &statbuf) == 0) {
734 sprintf(blabel, " Overwrite File ");
735 if (beeper) XBell(dpy, 100);
736 Wprintf(" Warning: File exists");
737 }
738 else {
739 sprintf(blabel, " Write File ");
740 if (errno == ENOTDIR)
741 Wprintf("Error: Incorrect pathname");
742 else if (errno == EACCES)
743 Wprintf("Error: Path not readable");
744 W3printf(" ");
745 }
746
747 wrbutton = XtNameToWidget(xcParent(button), "Write File");
748 XtSetArg(wargs[0], XtNlabel, blabel);
749 XtSetValues(wrbutton, wargs, 1);
750
751 num_linked = pagelinks(areawin->page);
752 if (num_linked > 1) {
753 ltoggle = XtNameToWidget(xcParent(button), "LToggle");
754 sprintf(blabel, "%d Pages", num_linked);
755 XtSetArg(wargs[0], XtNlabel, blabel);
756 XtSetValues(ltoggle, wargs, 1);
757 XtManageChild(ltoggle);
758 }
759 }
760
761 /* topobject->name is not malloc'd, so is not changed by call to */
762 /* *(callstruct->setvalue). */
763
764 else if (callstruct->dataptr == topobject->name) {
765 printname(topobject);
766 renamepage(areawin->page);
767 }
768
769 /* Button title changes from "Apply" to "Okay" */
770
771 XtSetArg(wargs[0], XtNlabel, "Okay");
772 XtSetValues(callstruct->buttonw, wargs, 1);
773 }
774
775 /*----------------------------------------------------------------------*/
776 /* Update scale, width, and height in response to change of one of them */
777 /*----------------------------------------------------------------------*/
778
779 void updatetext(xcWidget button, xcWidgetList callstruct, caddr_t calldata)
780 {
781 float oscale, psscale;
782 char edit[3][50];
783 short i, n, posit;
784 char *pdptr;
785 Arg wargs[2];
786 int width, height;
787
788 /* auto-fit may override any changes to the scale */
789
790 autoscale(areawin->page);
791 writescalevalues(edit[0], edit[1], edit[2]);
792 for (i = 0; i < 3; i++) {
793 n = 0;
794 XtnSetArg(XtNstring, edit[i]);
795 pdptr = strchr(edit[i], '.');
796 posit = (pdptr != NULL) ? (short)(pdptr - edit[i]) : strlen(edit[i]);
797 XtnSetArg(XtNinsertPosition, posit);
798 XtSetValues(callstruct[i + 2], wargs, n);
799 }
800 }
801
802 /*-------------------------------------------------------------------------*/
803 /* Update the object name in response to a change in filename */
804 /*-------------------------------------------------------------------------*/
805
806 void updatename(xcWidget button, xcWidgetList callstruct, caddr_t calldata)
807 {
808 short n, posit;
809 char *rootptr;
810 Arg wargs[2];
811
812 if (strstr(topobject->name, "Page ") != NULL || strstr(topobject->name,
813 "Page_") != NULL || topobject->name[0] == '\0') {
814
815 rootptr = strrchr(xobjs.pagelist[areawin->page]->filename, '/');
816 if (rootptr == NULL) rootptr = xobjs.pagelist[areawin->page]->filename;
817 else rootptr++;
818
819 sprintf(topobject->name, "%.79s", rootptr);
820
821 n = 0;
822 posit = strlen(topobject->name);
823 XtnSetArg(XtNstring, topobject->name);
824 XtnSetArg(XtNinsertPosition, posit);
825 XtSetValues(callstruct[1], wargs, n);
826 printname(topobject);
827 renamepage(areawin->page);
828 }
829 }
830
831 /*-------------------------------------------------------------------------*/
832 /* Create a popup window with "OK" and "Cancel" buttons, */
833 /* and text and label fields. */
834 /*-------------------------------------------------------------------------*/
835
836 #ifndef XC_WIN32
837
838 void popupprompt(xcWidget button, char *request, char *current, void (*function)(),
839 buttonsave *datastruct, const char *filter)
840 {
841 Arg wargs[9];
842 xcWidget popup, dialog, okbutton, cancelbutton, entertext;
843 xcWidget staticarea;
844 XWMHints *wmhints; /* for proper input focus */
845 Position xpos, ypos;
846 short n = 0;
847 Dimension height, width, areawidth, areaheight, bwidth, owidth;
848 static char defaultTranslations[] = "<Key>Return: execute()";
849 popupstruct *okaystruct;
850
851 height = (current == NULL) ? ROWHEIGHT * 4 : ROWHEIGHT * 5;
852 if (filter) height += LISTHEIGHT;
853
854 width = XTextWidth(appdata.xcfont, request, strlen(request)) + 20;
855 bwidth = XTextWidth(appdata.xcfont, "Cancel", strlen("Cancel")) + 50;
856 owidth = XTextWidth(appdata.xcfont, "Okay", strlen("Okay")) + 50;
857 if (width < 400) width = 400;
858
859 XtnSetArg(XtNwidth, &areawidth);
860 XtnSetArg(XtNheight, &areaheight);
861 XtGetValues(areawin->area, wargs, n); n = 0;
862 XtTranslateCoords(areawin->area, (Position) (areawidth / 2 - width
863 / 2 + popups * 20), (Position) (areaheight / 2 - height / 2 +
864 popups * 20), &xpos, &ypos);
865 XtnSetArg(XtNx, xpos);
866 XtnSetArg(XtNy, ypos);
867 popup = XtCreatePopupShell("prompt", transientShellWidgetClass,
868 button == NULL ? areawin->area : button, wargs, n); n = 0;
869 popups++;
870
871 XtnSetArg(XtNlayout, XwIGNORE);
872 XtnSetArg(XtNwidth, width);
873 XtnSetArg(XtNheight, height);
874 dialog = XtCreateManagedWidget("dialog", XwbulletinWidgetClass,
875 popup, wargs, n); n = 0;
876
877 XtnSetArg(XtNx, 20);
878 XtnSetArg(XtNy, ROWHEIGHT - 10 + (filter ? LISTHEIGHT : 0));
879 XtnSetArg(XtNstring, request);
880 XtnSetArg(XtNborderWidth, 0);
881 XtnSetArg(XtNgravity, WestGravity);
882 XtnSetArg(XtNfont, appdata.xcfont);
883 staticarea = XtCreateManagedWidget("static", XwstaticTextWidgetClass,
884 dialog, wargs, n); n = 0;
885
886 XtnSetArg(XtNx, 20);
887 XtnSetArg(XtNy, height - ROWHEIGHT - 10);
888 XtnSetArg(XtNwidth, owidth);
889 XtnSetArg(XtNfont, appdata.xcfont);
890 okbutton = XtCreateManagedWidget("Okay", XwmenuButtonWidgetClass,
891 dialog, wargs, n); n = 0;
892
893 okaystruct = (popupstruct *) malloc(sizeof(popupstruct));
894 okaystruct->buttonptr = datastruct;
895 okaystruct->popup = popup;
896 okaystruct->filter = (filter == NULL) ? NULL : strdup(filter);
897 okaystruct->setvalue = function;
898 okaystruct->textw = NULL;
899 okaystruct->filew = NULL;
900
901 XtnSetArg(XtNx, width - bwidth - 20);
902 XtnSetArg(XtNy, height - ROWHEIGHT - 10);
903 XtnSetArg(XtNwidth, bwidth);
904 XtnSetArg(XtNfont, appdata.xcfont);
905 cancelbutton = XtCreateManagedWidget("Cancel", XwmenuButtonWidgetClass,
906 dialog, wargs, n); n = 0;
907
908 XtAddCallback(cancelbutton, XtNselect, (XtCallbackProc)destroypopup, okaystruct);
909
910 /* Event handler for WM_DELETE_WINDOW message. */
911 XtAddEventHandler(popup, NoEventMask, True, (XtEventHandler)delwin, okaystruct);
912
913 if (current != NULL) { /* A Text Edit widget is required */
914 char *pdptr;
915 short posit;
916
917 XtnSetArg(XtNx, 20);
918 XtnSetArg(XtNy, ROWHEIGHT + 10 + (filter ? LISTHEIGHT : 0));
919 XtnSetArg(XtNheight, ROWHEIGHT + 5);
920 XtnSetArg(XtNwidth, width - 40);
921 XtnSetArg(XtNstring, current);
922 pdptr = strchr(current, '.');
923 posit = (pdptr != NULL) ? (short)(pdptr - current) : strlen(current);
924 XtnSetArg(XtNinsertPosition, posit);
925 XtnSetArg(XtNscroll, XwAutoScrollHorizontal);
926 XtnSetArg(XtNwrap, XwWrapOff);
927 XtnSetArg(XtNfont, appdata.textfont);
928 entertext = XtCreateManagedWidget("Edit", XwtextEditWidgetClass,
929 dialog, wargs, n); n = 0;
930
931 okaystruct->textw = entertext;
932
933 XtAddEventHandler(dialog, KeyPressMask, False,
934 (XtEventHandler)propevent, entertext);
935 XtAddEventHandler(staticarea, KeyPressMask, False,
936 (XtEventHandler)propevent, entertext);
937 XtOverrideTranslations(entertext, XtParseTranslationTable
938 (defaultTranslations));
939 XtAddCallback(entertext, XtNexecute, (XtCallbackProc)xcgettext, okaystruct);
940
941 /* Generate file prompting widget */
942
943 if (filter) genfilelist(dialog, okaystruct, width);
944 }
945 XtAddCallback(okbutton, XtNselect, (XtCallbackProc)xcgettext, okaystruct);
946
947 XtPopup(popup, XtGrabNone);
948
949 /* set the input focus for the window */
950
951 wmhints = XGetWMHints(dpy, xcWindow(popup));
952 wmhints->flags |= InputHint;
953 wmhints->input = True;
954 XSetWMHints(dpy, xcWindow(popup), wmhints);
955 XSetTransientForHint(dpy, xcWindow(popup), xcWindow(top));
956 XFree(wmhints);
957
958 if (current != NULL) XDefineCursor(dpy, xcWindow(entertext),
959 TEXTPTR);
960 }
961
962 #endif
963
964 /*-------------------------------------------------------------------------*/
965 /* Create a popup window for property changes */
966 /*-------------------------------------------------------------------------*/
967
968 #define MAXPROPS 7
969 #define MARGIN 15
970
971 propstruct okstruct[MAXPROPS], fpokstruct;
972
973 #ifndef XC_WIN32
974
975 void outputpopup(xcWidget button, caddr_t clientdata, caddr_t calldata)
976 {
977 buttonsave *savebutton;
978 Arg wargs[9];
979 xcWidget popup, dialog, okbutton, titlearea, wrbutton;
980 xcWidget fpentertext, fpokay, autobutton, allpages;
981 xcWidgetList staticarea, entertext, okays;
982 XWMHints *wmhints; /* for proper input focus */
983 short num_linked;
984 Position xpos, ypos;
985 short n = 0;
986 Dimension height, width, areawidth, areaheight, bwidth, owidth, wwidth;
987 Pagedata *curpage;
988 char *pdptr;
989 short posit, i;
990 popupstruct *donestruct;
991 void (*function[MAXPROPS])();
992 void (*update[MAXPROPS])();
993 char statics[MAXPROPS][50], edit[MAXPROPS][75], request[150];
994 char fpedit[75], outname[75], pstr[20];
995 void *data[MAXPROPS];
996 struct stat statbuf;
997 static char defaultTranslations[] = "<Key>Return: execute()";
998
999 if (is_page(topobject) == -1) {
1000 Wprintf("Can only save a top-level page!");
1001 return;
1002 }
1003 if (button == NULL) button = FileWriteXcircuitPSButton;
1004 savebutton = getgeneric(button, outputpopup, NULL);
1005
1006 curpage = xobjs.pagelist[areawin->page];
1007
1008 sprintf(request, "PostScript output properties (Page %d):",
1009 areawin->page + 1);
1010 sprintf(statics[0], "Filename:");
1011 sprintf(statics[1], "Page label:");
1012 sprintf(statics[2], "Scale:");
1013 if (curpage->coordstyle == CM) {
1014 sprintf(statics[3], "X Size (cm):");
1015 sprintf(statics[4], "Y Size (cm):");
1016 }
1017 else {
1018 sprintf(statics[3], "X Size (in):");
1019 sprintf(statics[4], "Y Size (in):");
1020 }
1021 sprintf(statics[5], "Orientation:");
1022 sprintf(statics[6], "Mode:");
1023
1024 if (curpage->filename)
1025 sprintf(edit[0], "%s", curpage->filename);
1026 else
1027 sprintf(edit[0], "Page %d", areawin->page + 1);
1028 sprintf(edit[1], "%s", topobject->name);
1029
1030 /* recompute bounding box and auto-scale, if set */
1031 calcbbox(areawin->topinstance);
1032 if (curpage->pmode & 2) autoscale(areawin->page);
1033 writescalevalues(edit[2], edit[3], edit[4]);
1034 sprintf(edit[5], "%s", (curpage->orient == 0) ? "Portrait" : "Landscape");
1035 sprintf(edit[6], "%s", (curpage->pmode & 1)
1036 ? "Full page" : "Embedded (EPS)");
1037 function[0] = setfilename;
1038 function[1] = setpagelabel;
1039 function[2] = setfloat;
1040 function[3] = setscalex;
1041 function[4] = setscaley;
1042 function[5] = setorient;
1043 function[6] = setpmode;
1044 update[0] = updatename;
1045 update[1] = update[6] = NULL;
1046 update[2] = updatetext;
1047 update[3] = updatetext;
1048 update[4] = updatetext;
1049 update[5] = updatetext;
1050 data[0] = &(curpage->filename);
1051 data[1] = topobject->name;
1052 data[2] = data[3] = data[4] = &(curpage->outscale);
1053 data[5] = &(curpage->orient);
1054 data[6] = &(curpage->pmode);
1055
1056 entertext = (xcWidgetList) XtMalloc (7 * sizeof (xcWidget));
1057 staticarea = (xcWidgetList) XtMalloc (7 * sizeof (xcWidget));
1058 okays = (xcWidgetList) XtMalloc (6 * sizeof (xcWidget));
1059
1060 /* get file information */
1061
1062 if (strstr(edit[0], ".") == NULL)
1063 sprintf(outname, "%s.ps", edit[0]);
1064 else sprintf(outname, "%s", edit[0]);
1065 if (stat(outname, &statbuf) == 0) {
1066 sprintf(outname, "Overwrite File");
1067 Wprintf(" Warning: File exists");
1068 }
1069 else {
1070 sprintf(outname, "Write File");
1071 if (errno == ENOTDIR)
1072 Wprintf("Error: Incorrect pathname");
1073 else if (errno == EACCES)
1074 Wprintf("Error: Path not readable");
1075 else
1076 W3printf(" ");
1077 }
1078
1079 height = ROWHEIGHT * 17; /* 3 + (2 * MAXPROPS) */
1080 width = XTextWidth(appdata.xcfont, request, strlen(request)) + 20;
1081 bwidth = XTextWidth(appdata.xcfont, "Close", strlen("Close")) + 50;
1082 owidth = XTextWidth(appdata.xcfont, "Apply", strlen("Apply")) + 50;
1083 wwidth = XTextWidth(appdata.xcfont, outname, strlen(outname)) + 80;
1084 if (width < 500) width = 500;
1085
1086 XtnSetArg(XtNwidth, &areawidth);
1087 XtnSetArg(XtNheight, &areaheight);
1088 XtGetValues(areawin->area, wargs, n); n = 0;
1089 XtTranslateCoords(areawin->area, (Position) (areawidth / 2 - width
1090 / 2 + popups * 20), (Position) (areaheight / 2 - height / 2 +
1091 popups * 20), &xpos, &ypos);
1092 XtnSetArg(XtNx, xpos);
1093 XtnSetArg(XtNy, ypos);
1094 popup = XtCreatePopupShell("prompt", transientShellWidgetClass,
1095 areawin->area, wargs, n); n = 0;
1096 popups++;
1097
1098 XtnSetArg(XtNlayout, XwIGNORE);
1099 XtnSetArg(XtNwidth, width);
1100 XtnSetArg(XtNheight, height);
1101 dialog = XtCreateManagedWidget("dialog", XwbulletinWidgetClass,
1102 popup, wargs, n); n = 0;
1103
1104 XtnSetArg(XtNx, 20);
1105 XtnSetArg(XtNy, ROWHEIGHT - 10);
1106 XtnSetArg(XtNstring, request);
1107 XtnSetArg(XtNborderWidth, 0);
1108 XtnSetArg(XtNgravity, WestGravity);
1109 XtnSetArg(XtNbackground, colorlist[BARCOLOR].color.pixel);
1110 XtnSetArg(XtNfont, appdata.xcfont);
1111 titlearea = XtCreateManagedWidget("title", XwstaticTextWidgetClass,
1112 dialog, wargs, n); n = 0;
1113
1114 XtnSetArg(XtNx, 20);
1115 XtnSetArg(XtNy, height - ROWHEIGHT - 10);
1116 XtnSetArg(XtNwidth, owidth);
1117 XtnSetArg(XtNfont, appdata.xcfont);
1118 okbutton = XtCreateManagedWidget("Close", XwmenuButtonWidgetClass,
1119 dialog, wargs, n); n = 0;
1120
1121 XtnSetArg(XtNx, width - wwidth - 20);
1122 XtnSetArg(XtNy, height - ROWHEIGHT - 10);
1123 XtnSetArg(XtNwidth, wwidth);
1124 XtnSetArg(XtNfont, appdata.xcfont);
1125 XtnSetArg(XtNlabel, outname);
1126 wrbutton = XtCreateManagedWidget("Write File", XwmenuButtonWidgetClass,
1127 dialog, wargs, n); n = 0;
1128
1129 for (i = 0; i < MAXPROPS; i++) {
1130 XtnSetArg(XtNx, 20);
1131 XtnSetArg(XtNy, ROWHEIGHT + MARGIN + 5 + (i * 2 * ROWHEIGHT));
1132 XtnSetArg(XtNstring, statics[i]);
1133 XtnSetArg(XtNborderWidth, 0);
1134 XtnSetArg(XtNgravity, WestGravity);
1135 XtnSetArg(XtNfont, appdata.xcfont);
1136 staticarea[i] = XtCreateManagedWidget("static", XwstaticTextWidgetClass,
1137 dialog, wargs, n); n = 0;
1138
1139 XtnSetArg(XtNx, 150);
1140 XtnSetArg(XtNy, ROWHEIGHT + MARGIN + (i * 2 * ROWHEIGHT));
1141 if (i < 5) {
1142 XtnSetArg(XtNheight, ROWHEIGHT + 5);
1143 XtnSetArg(XtNstring, edit[i]);
1144 XtnSetArg(XtNwidth, width - owidth - 190);
1145 pdptr = strchr(edit[i], '.');
1146 posit = (pdptr != NULL) ? (short)(pdptr - edit[i]) : strlen(edit[i]);
1147 XtnSetArg(XtNinsertPosition, posit);
1148 XtnSetArg(XtNscroll, XwAutoScrollHorizontal);
1149 XtnSetArg(XtNwrap, XwWrapOff);
1150 XtnSetArg(XtNfont, appdata.textfont);
1151 entertext[i] = XtCreateManagedWidget("Edit", XwtextEditWidgetClass,
1152 dialog, wargs, n); n = 0;
1153
1154 XtnSetArg(XtNx, width - owidth - 20);
1155 XtnSetArg(XtNy, ROWHEIGHT + MARGIN + (i * 2 * ROWHEIGHT));
1156 XtnSetArg(XtNwidth, owidth);
1157 XtnSetArg(XtNfont, appdata.xcfont);
1158 okays[i] = XtCreateManagedWidget("Apply", XwmenuButtonWidgetClass,
1159 dialog, wargs, n); n = 0;
1160
1161 okstruct[i].textw = entertext[i];
1162 okstruct[i].buttonw = okays[i];
1163 okstruct[i].setvalue = function[i];
1164 okstruct[i].dataptr = data[i];
1165
1166 XtAddCallback(okays[i], XtNselect, (XtCallbackProc)getproptext, &okstruct[i]);
1167 if (update[i] != NULL)
1168 XtAddCallback(okays[i], XtNselect, (XtCallbackProc)update[i], entertext);
1169 XtOverrideTranslations(entertext[i], XtParseTranslationTable
1170 (defaultTranslations));
1171 XtAddCallback(entertext[i], XtNexecute, (XtCallbackProc)getproptext,
1172 &okstruct[i]);
1173 if (update[i] != NULL) XtAddCallback(entertext[i], XtNexecute,
1174 (XtCallbackProc)update[i], entertext);
1175
1176 }
1177 else {
1178 XtnSetArg(XtNlabel, edit[i]);
1179 XtnSetArg(XtNfont, appdata.xcfont);
1180 entertext[i] = XtCreateManagedWidget("Toggle", XwpushButtonWidgetClass,
1181 dialog, wargs, n); n = 0;
1182 XtAddCallback(entertext[i], XtNselect, (XtCallbackProc)function[i], data[i]);
1183 if (update[i] != NULL)
1184 XtAddCallback(entertext[i], XtNselect, (XtCallbackProc)update[i], entertext);
1185 }
1186 }
1187
1188 /* If this filename is linked to other pages (multi-page output), add a button */
1189 /* which will unlink the page name from the other pages when toggled. */
1190
1191 num_linked = pagelinks(areawin->page);
1192 XtnSetArg(XtNx, width - wwidth - 20);
1193 XtnSetArg(XtNy, ROWHEIGHT - 10);
1194 XtnSetArg(XtNset, True);
1195 XtnSetArg(XtNsquare, True);
1196 XtnSetArg(XtNborderWidth, 0);
1197 XtnSetArg(XtNfont, appdata.xcfont);
1198 sprintf(pstr, "%d Pages", num_linked);
1199 XtnSetArg(XtNlabel, pstr);
1200 allpages = XtCreateWidget("LToggle", XwtoggleWidgetClass, dialog, wargs, n); n = 0;
1201 XtAddCallback(allpages, XtNrelease, (XtCallbackProc)linkset, &okstruct[0]);
1202
1203 /* If full-page pmode is chosen, there is an additional text structure.
1204 Make this text structure always but allow it to be managed and
1205 unmanaged as necessary. */
1206
1207 XtnSetArg(XtNx, 240);
1208 XtnSetArg(XtNy, ROWHEIGHT + MARGIN + (10 * ROWHEIGHT));
1209 XtnSetArg(XtNset, (curpage->pmode & 2) ? True : False);
1210 XtnSetArg(XtNsquare, True);
1211 XtnSetArg(XtNborderWidth, 0);
1212 XtnSetArg(XtNfont, appdata.xcfont);
1213 autobutton = XtCreateWidget("Auto-fit", XwtoggleWidgetClass,
1214 dialog, wargs, n); n = 0;
1215
1216 if (curpage->coordstyle == CM) {
1217 sprintf(fpedit, "%3.2f x %3.2f cm",
1218 (float)curpage->pagesize.x / IN_CM_CONVERT,
1219 (float)curpage->pagesize.y / IN_CM_CONVERT);
1220 }
1221 else {
1222 sprintf(fpedit, "%3.2f x %3.2f in",
1223 (float)curpage->pagesize.x / 72.0,
1224 (float)curpage->pagesize.y / 72.0);
1225 }
1226 XtnSetArg(XtNx, 240);
1227 XtnSetArg(XtNy, ROWHEIGHT + MARGIN + (12 * ROWHEIGHT));
1228 XtnSetArg(XtNheight, ROWHEIGHT + 5);
1229 XtnSetArg(XtNstring, fpedit);
1230 XtnSetArg(XtNwidth, width - owidth - 280);
1231 pdptr = strchr(fpedit, '.');
1232 posit = (pdptr != NULL) ? (short)(pdptr - fpedit) : strlen(fpedit);
1233 XtnSetArg(XtNscroll, XwAutoScrollHorizontal);
1234 XtnSetArg(XtNwrap, XwWrapOff);
1235 XtnSetArg(XtNfont, appdata.textfont);
1236 XtnSetArg(XtNinsertPosition, posit);
1237 fpentertext = XtCreateWidget("fpedit", XwtextEditWidgetClass,
1238 dialog, wargs, n); n = 0;
1239
1240 XtnSetArg(XtNx, width - owidth - 20);
1241 XtnSetArg(XtNy, ROWHEIGHT + MARGIN + (12 * ROWHEIGHT));
1242 XtnSetArg(XtNwidth, owidth);
1243 XtnSetArg(XtNfont, appdata.xcfont);
1244 XtnSetArg(XtNlabel, "Apply");
1245 fpokay = XtCreateWidget("fpokay", XwmenuButtonWidgetClass,
1246 dialog, wargs, n); n = 0;
1247
1248 fpokstruct.textw = fpentertext;
1249 fpokstruct.buttonw = fpokay;
1250 fpokstruct.setvalue = setpagesize;
1251 fpokstruct.dataptr = &(curpage->pagesize);
1252
1253 XtAddCallback(fpokay, XtNselect, (XtCallbackProc)getproptext, &fpokstruct);
1254 XtAddCallback(fpokay, XtNselect, (XtCallbackProc)updatetext, entertext);
1255 XtOverrideTranslations(fpentertext, XtParseTranslationTable
1256 (defaultTranslations));
1257 XtAddCallback(fpentertext, XtNexecute, (XtCallbackProc)getproptext, &fpokstruct);
1258 XtAddCallback(fpentertext, XtNexecute, (XtCallbackProc)updatetext, entertext);
1259 XtAddCallback(autobutton, XtNselect, (XtCallbackProc)autoset, entertext);
1260 XtAddCallback(autobutton, XtNrelease, (XtCallbackProc)autostop, NULL);
1261
1262 if (curpage->pmode & 1) {
1263 XtManageChild(fpentertext);
1264 XtManageChild(fpokay);
1265 XtManageChild(autobutton);
1266 }
1267
1268 if (num_linked > 1) {
1269 XtManageChild(allpages);
1270 }
1271
1272 /* end of pagesize extra Widget definitions */
1273
1274 donestruct = (popupstruct *) malloc(sizeof(popupstruct));
1275 donestruct->popup = popup;
1276 donestruct->buttonptr = savebutton;
1277 donestruct->filter = NULL;
1278 XtAddCallback(okbutton, XtNselect, (XtCallbackProc)destroypopup, donestruct);
1279
1280 /* Send setfile() the widget entertext[0] in case because user sometimes
1281 forgets to type "okay" but buffer contains the expected filename */
1282
1283 XtAddCallback(wrbutton, XtNselect, (XtCallbackProc)setfile, entertext[0]);
1284
1285 /* Begin Popup */
1286
1287 XtPopup(popup, XtGrabNone);
1288
1289 /* set the input focus for the window */
1290
1291 wmhints = XGetWMHints(dpy, xcWindow(popup));
1292 wmhints->flags |= InputHint;
1293 wmhints->input = True;
1294 XSetWMHints(dpy, xcWindow(popup), wmhints);
1295 XSetTransientForHint(dpy, xcWindow(popup), xcWindow(top));
1296 XFree(wmhints);
1297
1298 for (i = 0; i < 5; i++)
1299 XDefineCursor(dpy, xcWindow(entertext[i]), TEXTPTR);
1300 }
1301
1302 #endif
1303
1304 /*-------------------------------------------------*/
1305 /* Print a string to the message widget. */
1306 /* Note: Widget message must be a global variable. */
1307 /* For formatted strings, format first into _STR */
1308 /*-------------------------------------------------*/
1309
1310 void clrmessage(XtPointer clientdata, xcIntervalId *id)
1311 {
1312 char buf1[50], buf2[50];
1313
1314 /* Don't write over the report of the edit string contents, */
1315 /* if we're in one of the label edit modes */
1316
1317 if (eventmode == TEXT_MODE || eventmode == ETEXT_MODE)
1318 charreport(TOLABEL(EDITPART));
1319 else {
1320 measurestr(xobjs.pagelist[areawin->page]->gridspace, buf1);
1321 measurestr(xobjs.pagelist[areawin->page]->snapspace, buf2);
1322 Wprintf("Grid %.50s : Snap %.50s", buf1, buf2);
1323 }
1324 }
1325
1326 /*----------------------------------------------------------------------*/
1327 /* This is the non-Tcl version of tcl_vprintf() */
1328 /*----------------------------------------------------------------------*/
1329
1330 void xc_vprintf(xcWidget widget, const char *fmt, va_list args_in)
1331 {
1332 va_list args;
1333 static char outstr[128];
1334 char *outptr, *bigstr = NULL;
1335 int nchars;
1336 Arg wargs[1];
1337
1338 outstr[0] = '\0';
1339 outptr = outstr;
1340
1341 /* This mess circumvents problems with systems which do not have */
1342 /* va_copy() defined. Some define __va_copy(); otherwise we must */
1343 /* assume that args = args_in is valid. */
1344
1345 va_copy(args, args_in);
1346 nchars = vsnprintf(outptr, 127, fmt, args);
1347 va_end(args);
1348
1349 if (nchars >= 127) {
1350 va_copy(args, args_in);
1351 bigstr = (char *)malloc(nchars + 2);
1352 bigstr[0] = '\0';
1353 outptr = bigstr;
1354 vsnprintf(outptr, nchars + 2, fmt, args);
1355 va_end(args);
1356 }
1357 else if (nchars == -1) nchars = 126;
1358
1359 XtSetArg(wargs[0], XtNstring, outptr);
1360 XtSetValues(widget, wargs, 1);
1361 XtSetArg(wargs[0], XtNheight, ROWHEIGHT);
1362 XtSetValues(widget, wargs, 1);
1363
1364 if (bigstr != NULL) free(bigstr);
1365
1366 if (widget == message3) {
1367 if (printtime_id != 0) {
1368 xcRemoveTimeOut(printtime_id);
1369 printtime_id = 0;
1370 }
1371 }
1372
1373 /* 10 second timeout */
1374 if (widget == message3) {
1375 printtime_id = xcAddTimeOut(app, 10000, clrmessage, NULL);
1376 }
1377 }
1378
1379 /*------------------------------------------------------------------------------*/
1380 /* W3printf is the same as Wprintf because the non-Tcl based version does not */
1381 /* duplicate output to stdout/stderr. */
1382 /*------------------------------------------------------------------------------*/
1383
1384 void W3printf(char *format, ...)
1385 {
1386 va_list ap;
1387
1388 va_start(ap, format);
1389 xc_vprintf(message3, format, ap);
1390 va_end(ap);
1391 }
1392
1393 /*------------------------------------------------------------------------------*/
1394
1395 void Wprintf(char *format, ...)
1396 {
1397 va_list ap;
1398
1399 va_start(ap, format);
1400 xc_vprintf(message3, format, ap);
1401 va_end(ap);
1402 }
1403
1404 /*------------------------------------------------------------------------------*/
1405
1406 void W1printf(char *format, ...)
1407 {
1408 va_list ap;
1409
1410 va_start(ap, format);
1411 xc_vprintf(message1, format, ap);
1412 va_end(ap);
1413 }
1414
1415 /*------------------------------------------------------------------------------*/
1416
1417 void W2printf(char *format, ...)
1418 {
1419 va_list ap;
1420
1421 va_start(ap, format);
1422 xc_vprintf(message2, format, ap);
1423 va_end(ap);
1424 }
1425
1426 /*------------------------------------------------------------------------------*/
1427
1428 #ifndef XC_WIN32
1429
1430 void getcommand(xcWidget cmdw, caddr_t clientdata, caddr_t calldata)
1431 {
1432 sprintf(_STR2, "%.249s", XwTextCopyBuffer(cmdw));
1433 #ifdef HAVE_PYTHON
1434 execcommand(0, _STR2 + 4);
1435 #else
1436 execcommand(0, _STR2 + 2);
1437 #endif
1438 XtRemoveEventHandler(areawin->area, KeyPressMask, False,
1439 (XtEventHandler)propevent, cmdw);
1440 XtAddCallback(areawin->area, XtNkeyDown, (XtCallbackProc)keyhandler, NULL);
1441 XtAddCallback(areawin->area, XtNkeyUp, (XtCallbackProc)keyhandler, NULL);
1442 XtUnmanageChild(cmdw);
1443 }
1444
1445 /*------------------------------------------------------------------------------*/
1446 /* "docommand" overlays the message3 widget temporarily with a TextEdit widget. */
1447 /*------------------------------------------------------------------------------*/
1448
1449 void docommand()
1450 {
1451 Arg wargs[12];
1452 int n = 0;
1453 Dimension w;
1454 Position x, y;
1455 static char defaultTranslations[] = "<Key>Return: execute()";
1456
1457 if (overlay == NULL) {
1458 XtnSetArg(XtNy, &y);
1459 XtnSetArg(XtNx, &x);
1460 XtnSetArg(XtNwidth, &w);
1461 XtGetValues(message3, wargs, n); n = 0;
1462
1463 XtnSetArg(XtNy, y);
1464 XtnSetArg(XtNx, x);
1465 XtnSetArg(XtNheight, ROWHEIGHT);
1466 XtnSetArg(XtNwidth, w);
1467
1468 XtnSetArg(XtNfont, appdata.xcfont);
1469 XtnSetArg(XtNwrap, XwWrapOff);
1470 overlay = XtCreateManagedWidget("Command", XwtextEditWidgetClass,
1471 top, wargs, n); n = 0;
1472
1473 XtOverrideTranslations(overlay, XtParseTranslationTable(defaultTranslations));
1474 XtAddCallback(overlay, XtNexecute, (XtCallbackProc)getcommand, NULL);
1475 }
1476 else {
1477 XtManageChild(overlay);
1478 }
1479
1480 XwTextClearBuffer(overlay);
1481 #ifdef HAVE_PYTHON
1482 XwTextInsert(overlay, ">>> ");
1483 #else
1484 XwTextInsert(overlay, "? ");
1485 #endif
1486
1487 /* temporarily redirect all text into the overlay widget */
1488
1489 XtRemoveCallback(areawin->area, XtNkeyDown, (XtCallbackProc)keyhandler, NULL);
1490 XtRemoveCallback(areawin->area, XtNkeyUp, (XtCallbackProc)keyhandler, NULL);
1491 XtAddEventHandler(areawin->area, KeyPressMask, False,
1492 (XtEventHandler)propevent, overlay);
1493 }
1494
1495 /*------------------------------------------------------------------------------*/
1496 /* When all else fails, install your own colormap */
1497 /*------------------------------------------------------------------------------*/
1498
1499 int installowncmap()
1500 {
1501 Colormap newcmap;
1502
1503 Fprintf(stdout, "Installing my own colormap\n");
1504
1505 /* allocate a new colormap */
1506
1507 newcmap = XCopyColormapAndFree(dpy, cmap);
1508 if (newcmap == (Colormap)NULL) return (-1);
1509 cmap = newcmap;
1510
1511 if (areawin->area != (xcWidget)NULL) {
1512 if (xcIsRealized(areawin->area)) {
1513 xcWidget colormenu = xcParent(ColorAddNewColorButton);
1514
1515 XSetWindowColormap(dpy, xcWindow(top), cmap);
1516 XSetWindowColormap(dpy, areawin->window, cmap);
1517 if (colormenu != (xcWidget)NULL)
1518 XSetWindowColormap(dpy, xcWindow(colormenu), cmap);
1519 }
1520 }
1521 return(1);
1522 }
1523
1524 #endif
1525
1526 /*----------------------------------------------------------------------*/
1527 /* Event handler for input focus */
1528 /*----------------------------------------------------------------------*/
1529
1530 #ifdef INPUT_FOCUS
1531
1532 void mappinghandler(xcWidget w, caddr_t clientdata, XEvent *event)
1533 {
1534 if (!xcIsRealized(w)) return;
1535 switch(event->type) {
1536 case MapNotify:
1537 /* Fprintf(stderr, "Window top was mapped. Setting input focus\n"); */
1538 areawin->mapped = True;
1539 XSetInputFocus(dpy, xcWindow(w), RevertToPointerRoot, CurrentTime);
1540 break;
1541 case UnmapNotify:
1542 /* Fprintf(stderr, "Window top was unmapped\n"); */
1543 areawin->mapped = False;
1544 break;
1545 }
1546 }
1547
1548 #endif
1549
1550 /*----------------------------------------------------------------------*/
1551
1552 void clientmessagehandler(xcWidget w, caddr_t clientdata, XEvent *event)
1553 {
1554 if (!xcIsRealized(w)) return;
1555
1556 if (event->type == ClientMessage) {
1557 if (render_client(event) == False)
1558 return;
1559
1560 #ifdef INPUT_FOCUS
1561 if (areawin->mapped == True) {
1562 /* Fprintf(stderr, "Forcing input focus\n"); */
1563 XSetInputFocus(dpy, xcWindow(w), RevertToPointerRoot, CurrentTime);
1564 }
1565 #endif
1566 }
1567 }
1568
1569 /*----------------------------------------------------------------------*/
1570 /* Event handler for WM_DELETE_WINDOW message. */
1571 /*----------------------------------------------------------------------*/
1572
1573 void delwin(xcWidget w, popupstruct *bstruct, XClientMessageEvent *event)
1574 {
1575 if (event->type != ClientMessage)
1576 return;
1577
1578 if((event->message_type == wprot) && (event->data.l[0] == wmprop[0])) {
1579 if (w == top)
1580 quitcheck(w, NULL, NULL);
1581 else
1582 destroypopup(w, bstruct, NULL);
1583 }
1584 }
1585
1586 /*----------------------------------------------------------------------*/
1587 /* GUI_init() --- generate the widget structures, allocate colormaps */
1588 /* and graphics contexts, generate menus and toolbar, and assign */
1589 /* callback functions and event handlers. */
1590 /*----------------------------------------------------------------------*/
1591
1592 #ifdef XC_WIN32
1593
1594 XCWindowData* GUI_init(int argc, char *argv[]);
1595
1596 #else
1597
1598 XCWindowData *GUI_init(int argc, char *argv[])
1599 {
1600
1601 #ifdef HAVE_XPM
1602 xcWidget abform;
1603 #endif
1604 xcWidget form, aform, firstbutton, lastbutton, corner;
1605 XGCValues values;
1606 XWMHints *wmhints; /* for proper input focus */
1607 Arg wargs[12];
1608 Pixmap icon;
1609 Window win;
1610 XCWindowData *newwin;
1611 short i, n = 0;
1612
1613 /* Things to do the first time around */
1614 if (dpy == NULL) {
1615
1616 char *argfb[] = { /* Fallback resources */
1617 "xcircuit*foreground : brown4", /* These are the values that */
1618 "xcircuit*background : beige", /* not or cannot be explicitly */
1619 "xcircuit.foreground : black", /* initialized by */
1620 "xcircuit.background : white", /* XtGetApplicationResources() */
1621 "xcircuit*borderWidth : 2", /* below. */
1622 "xcircuit*borderColor : Red",
1623 NULL /* Sentinel */
1624 };
1625
1626 XtSetLanguageProc(NULL, NULL, NULL);
1627
1628 /*-------------------------------------------------------------------*/
1629 /* Set pointer to own XDefaults file, but allow an external override */
1630 /*-------------------------------------------------------------------*/
1631
1632 #ifdef HAVE_PUTENV
1633 if (getenv("XAPPLRESDIR") == NULL)
1634 putenv("XAPPLRESDIR=" RESOURCES_DIR);
1635 #else
1636 setenv("XAPPLRESDIR", RESOURCES_DIR, 0);
1637 #endif
1638
1639 /*-----------------------------*/
1640 /* Create the widget hierarchy */
1641 /*-----------------------------*/
1642
1643 top = XtOpenApplication(&app, "XCircuit", NULL, 0, &argc, argv,
1644 argfb, applicationShellWidgetClass, NULL, 0);
1645
1646 dpy = XtDisplay(top);
1647 win = DefaultRootWindow(dpy);
1648 cmap = DefaultColormap(dpy, DefaultScreen(dpy));
1649
1650 /*-------------------------*/
1651 /* Create stipple patterns */
1652 /*-------------------------*/
1653
1654 for (i = 0; i < STIPPLES; i++)
1655 STIPPLE[i] = XCreateBitmapFromData(dpy, win, STIPDATA[i], 4, 4);
1656
1657 /*----------------------------------------*/
1658 /* Allocate space for the basic color map */
1659 /*----------------------------------------*/
1660
1661 number_colors = NUMBER_OF_COLORS;
1662 colorlist = (colorindex *)malloc(NUMBER_OF_COLORS * sizeof(colorindex));
1663
1664 /*-----------------------------------------------------------*/
1665 /* Xw must add these translations for the popup manager */
1666 /*-----------------------------------------------------------*/
1667 XwAppInitialize(app);
1668
1669 /*-------------------------------*/
1670 /* Get the application resources */
1671 /*-------------------------------*/
1672
1673 XtAppAddConverter(app, XtRString, XtRPixel, (XtConverter)CvtStringToPixel,
1674 NULL, 0);
1675 XtGetApplicationResources(top, &appdata, resources, XtNumber(resources),
1676 NULL, 0);
1677 }
1678 else { /* Not the first time---display has already been opened */
1679
1680 top = XtAppCreateShell("XCircuit", "XCircuit", applicationShellWidgetClass,
1681 dpy, NULL, 0);
1682 }
1683
1684 n = 0;
1685 XtnSetArg(XtNwidth, appdata.width);
1686 XtnSetArg(XtNheight, appdata.height);
1687 XtnSetArg(XtNforeground, appdata.fg);
1688 XtnSetArg(XtNbackground, appdata.bg);
1689 XtnSetArg(XtNcolormap, cmap);
1690 XtSetValues(top, wargs, n); n = 0;
1691
1692 form = XtCreateManagedWidget("Form", XwformWidgetClass, top, NULL, 0);
1693
1694 /* Generate a new window data structure */
1695
1696 newwin = create_new_window();
1697
1698 /* Set up the buttons and Graphics drawing area */
1699
1700 createmenus(form, &firstbutton, &lastbutton);
1701
1702 XtnSetArg(XtNxRefWidget, lastbutton);
1703 XtnSetArg(XtNyRefWidget, form);
1704 XtnSetArg(XtNxAddWidth, True);
1705 XtnSetArg(XtNxAttachRight, True);
1706 XtnSetArg(XtNheight, ROWHEIGHT);
1707 sprintf(_STR, " Welcome to Xcircuit Version %s", PROG_VERSION);
1708 XtnSetArg(XtNstring, _STR);
1709 XtnSetArg(XtNxResizable, True);
1710 XtnSetArg(XtNgravity, WestGravity);
1711 XtnSetArg(XtNfont, appdata.xcfont);
1712 XtnSetArg(XtNwrap, False);
1713 XtnSetArg(XtNstrip, False);
1714 message1 = XtCreateManagedWidget("Message1", XwstaticTextWidgetClass,
1715 form, wargs, n); n = 0;
1716
1717 #ifdef HAVE_XPM
1718 /*-------------------------------------------------------------------*/
1719 /* An extra form divides the main window from the toolbar */
1720 /*-------------------------------------------------------------------*/
1721
1722 XtnSetArg(XtNyRefWidget, firstbutton);
1723 XtnSetArg(XtNyAddHeight, True);
1724 XtnSetArg(XtNyOffset, 2);
1725 XtnSetArg(XtNxAttachRight, True);
1726 XtnSetArg(XtNyResizable, True);
1727 XtnSetArg(XtNxResizable, True);
1728 XtnSetArg(XtNborderWidth, 0);
1729 abform = XtCreateManagedWidget("ABForm", XwformWidgetClass, form, wargs, n);
1730 n = 0;
1731
1732 /*-------------------------------------------------------------------*/
1733 /* The main window and its scrollbars rest in a separate form window */
1734 /*-------------------------------------------------------------------*/
1735
1736 XtnSetArg(XtNyResizable, True);
1737 XtnSetArg(XtNxResizable, True);
1738 XtnSetArg(XtNyAttachBottom, True);
1739 aform = XtCreateManagedWidget("AForm", XwformWidgetClass, abform, wargs, n);
1740 n = 0;
1741 #else
1742 #define abform aform
1743
1744 /*-------------------------------------------------------------------*/
1745 /* The main window and its scrollbars rest in a separate form window */
1746 /*-------------------------------------------------------------------*/
1747
1748 XtnSetArg(XtNyRefWidget, firstbutton);
1749 XtnSetArg(XtNyAddHeight, True);
1750 XtnSetArg(XtNxAttachRight, True);
1751 XtnSetArg(XtNyResizable, True);
1752 XtnSetArg(XtNxResizable, True);
1753 aform = XtCreateManagedWidget("AForm", XwformWidgetClass, form, wargs, n);
1754 n = 0;
1755
1756 #endif
1757
1758 /*------------------------*/
1759 /* add scrollbar widget */
1760 /*------------------------*/
1761
1762 XtnSetArg(XtNxResizable, False);
1763 XtnSetArg(XtNyResizable, True);
1764 XtnSetArg(XtNwidth, SBARSIZE);
1765 XtnSetArg(XtNborderWidth, 1);
1766 newwin->scrollbarv = XtCreateManagedWidget("SBV", XwworkSpaceWidgetClass,
1767 aform, wargs, n); n = 0;
1768
1769 /*----------------------------------------------------------*/
1770 /* A button in the scrollbar corner for the sake of beauty. */
1771 /*----------------------------------------------------------*/
1772
1773 XtnSetArg(XtNyRefWidget, newwin->scrollbarv);
1774 XtnSetArg(XtNyAddHeight, True);
1775 XtnSetArg(XtNyAttachBottom, True);
1776 XtnSetArg(XtNheight, SBARSIZE);
1777 XtnSetArg(XtNwidth, SBARSIZE);
1778 XtnSetArg(XtNborderWidth, 1);
1779 XtnSetArg(XtNlabel, "");
1780 corner = XtCreateManagedWidget("corner", XwpushButtonWidgetClass,
1781 aform, wargs, n); n = 0;
1782
1783 /*-------------------------*/
1784 /* The main drawing window */
1785 /*-------------------------*/
1786
1787 XtnSetArg(XtNxOffset, SBARSIZE);
1788 XtnSetArg(XtNxResizable, True);
1789 XtnSetArg(XtNyResizable, True);
1790 XtnSetArg(XtNxAttachRight, True);
1791 newwin->area = XtCreateManagedWidget("Area", XwworkSpaceWidgetClass,
1792 aform, wargs, n); n = 0;
1793
1794 /*-------------------------*/
1795 /* and the other scrollbar */
1796 /*-------------------------*/
1797
1798 XtnSetArg(XtNyRefWidget, newwin->area);
1799 XtnSetArg(XtNyAddHeight, True);
1800 XtnSetArg(XtNxRefWidget, newwin->scrollbarv);
1801 XtnSetArg(XtNxAddWidth, True);
1802 XtnSetArg(XtNxAttachRight, True);
1803 XtnSetArg(XtNheight, SBARSIZE);
1804 XtnSetArg(XtNyResizable, False);
1805 XtnSetArg(XtNxResizable, True);
1806 XtnSetArg(XtNborderWidth, 1);
1807 newwin->scrollbarh = XtCreateManagedWidget("SBH", XwworkSpaceWidgetClass,
1808 aform, wargs, n); n = 0;
1809
1810 /*------------------------------------------------*/
1811 /* Supplementary message widgets go at the bottom */
1812 /*------------------------------------------------*/
1813
1814 XtnSetArg(XtNxResizable, False);
1815 XtnSetArg(XtNyRefWidget, abform);
1816 XtnSetArg(XtNyAddHeight, True);
1817 XtnSetArg(XtNyOffset, -5);
1818 XtnSetArg(XtNheight, ROWHEIGHT);
1819 XtnSetArg(XtNfont, appdata.xcfont);
1820 XtnSetArg(XtNforeground, appdata.buttonpix);
1821 XtnSetArg(XtNbackground, appdata.buttonpix);
1822 wsymb = XtCreateWidget("Symbol", XwpushButtonWidgetClass,
1823 form, wargs, n); n = 0;
1824 XtManageChild(wsymb);
1825
1826 XtnSetArg(XtNxRefWidget, wsymb);
1827 XtnSetArg(XtNxAddWidth, True);
1828 XtnSetArg(XtNxResizable, False);
1829 XtnSetArg(XtNyRefWidget, abform);
1830 XtnSetArg(XtNyAddHeight, True);
1831 XtnSetArg(XtNyOffset, -5);
1832 XtnSetArg(XtNheight, ROWHEIGHT);
1833 XtnSetArg(XtNfont, appdata.xcfont);
1834 XtnSetArg(XtNforeground, appdata.bg);
1835 XtnSetArg(XtNbackground, appdata.snappix);
1836 wschema = XtCreateWidget("Schematic", XwpushButtonWidgetClass,
1837 form, wargs, n); n = 0;
1838 XtManageChild(wschema);
1839
1840
1841 XtnSetArg(XtNxRefWidget, wschema);
1842 XtnSetArg(XtNxAddWidth, True);
1843
1844 XtnSetArg(XtNyRefWidget, abform);
1845 XtnSetArg(XtNyAddHeight, True);
1846 XtnSetArg(XtNyOffset, -5);
1847 XtnSetArg(XtNheight, ROWHEIGHT);
1848 XtnSetArg(XtNstring, "Editing: Page 1");
1849 XtnSetArg(XtNxResizable, False);
1850 XtnSetArg(XtNgravity, WestGravity);
1851 XtnSetArg(XtNfont, appdata.xcfont);
1852 XtnSetArg(XtNwrap, False);
1853 message2 = XtCreateManagedWidget("Message2", XwstaticTextWidgetClass,
1854 form, wargs, n); n = 0;
1855
1856 XtnSetArg(XtNyRefWidget, abform);
1857 XtnSetArg(XtNyAddHeight, True);
1858 XtnSetArg(XtNyOffset, -5);
1859 XtnSetArg(XtNxAttachRight, True);
1860 XtnSetArg(XtNxRefWidget, message2);
1861 XtnSetArg(XtNxAddWidth, True);
1862 XtnSetArg(XtNheight, ROWHEIGHT);
1863 XtnSetArg(XtNxResizable, True);
1864 XtnSetArg(XtNfont, appdata.xcfont);
1865 XtnSetArg(XtNwrap, False);
1866 XtnSetArg(XtNgravity, WestGravity);
1867 XtnSetArg(XtNstring, "Don't Panic");
1868 message3 = XtCreateManagedWidget("Message3", XwstaticTextWidgetClass,
1869 form, wargs, n); n = 0;
1870
1871 /*-------------------------------*/
1872 /* optional Toolbar on the right */
1873 /*-------------------------------*/
1874
1875 #ifdef HAVE_XPM
1876 createtoolbar(abform, aform);
1877 XtAddCallback(newwin->area, XtNresize, (XtCallbackProc)resizetoolbar, NULL);
1878 #endif
1879
1880 /* Setup callback routines for the area widget */
1881 /* Use Button1Press event to add the callback which tracks motion; this */
1882 /* will reduce the number of calls serviced during normal operation */
1883
1884 XtAddCallback(newwin->area, XtNexpose, (XtCallbackProc)drawarea, NULL);
1885 XtAddCallback(newwin->area, XtNresize, (XtCallbackProc)resizearea, NULL);
1886
1887 XtAddCallback(newwin->area, XtNselect, (XtCallbackProc)buttonhandler, NULL);
1888 XtAddCallback(newwin->area, XtNrelease, (XtCallbackProc)buttonhandler, NULL);
1889 XtAddCallback(newwin->area, XtNkeyDown, (XtCallbackProc)keyhandler, NULL);
1890 XtAddCallback(newwin->area, XtNkeyUp, (XtCallbackProc)keyhandler, NULL);
1891
1892 XtAddEventHandler(newwin->area, Button1MotionMask | Button2MotionMask,
1893 False, (XtEventHandler)xlib_drag, NULL);
1894
1895 /* Setup callback routines for the scrollbar widgets */
1896
1897 XtAddEventHandler(newwin->scrollbarh, ButtonMotionMask, False,
1898 (XtEventHandler)panhbar, NULL);
1899 XtAddEventHandler(newwin->scrollbarv, ButtonMotionMask, False,
1900 (XtEventHandler)panvbar, NULL);
1901
1902 XtAddCallback(newwin->scrollbarh, XtNrelease, (XtCallbackProc)endhbar, NULL);
1903 XtAddCallback(newwin->scrollbarv, XtNrelease, (XtCallbackProc)endvbar, NULL);
1904
1905 XtAddCallback(newwin->scrollbarh, XtNexpose, (XtCallbackProc)drawhbar, NULL);
1906 XtAddCallback(newwin->scrollbarv, XtNexpose, (XtCallbackProc)drawvbar, NULL);
1907 XtAddCallback(newwin->scrollbarh, XtNresize, (XtCallbackProc)drawhbar, NULL);
1908 XtAddCallback(newwin->scrollbarv, XtNresize, (XtCallbackProc)drawvbar, NULL);
1909
1910 /* Event handler for WM_DELETE_WINDOW message. */
1911 XtAddEventHandler(top, NoEventMask, True, (XtEventHandler)delwin, NULL);
1912
1913 XtAddCallback(corner, XtNselect, (XtCallbackProc)zoomview, Number(1));
1914 XtAddCallback (wsymb, XtNselect, (XtCallbackProc)xlib_swapschem, Number(0));
1915 XtAddCallback (wschema, XtNselect, (XtCallbackProc)xlib_swapschem, Number(0));
1916
1917 /*--------------------*/
1918 /* Realize the Widget */
1919 /*--------------------*/
1920
1921 areawin = newwin;
1922 XtRealizeWidget(top);
1923
1924 wprot = XInternAtom(dpy, "WM_PROTOCOLS", False);
1925 wmprop[0] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
1926 wmprop[1] = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
1927 XSetWMProtocols(dpy, xcWindow(top), wmprop, 2);
1928
1929 /*----------------------------------------------------*/
1930 /* Let the window manager set the input focus for the */
1931 /* window and inform the window manager of the icon */
1932 /* pixmap (which may or may not be useful, depending */
1933 /* on the particular window manager). */
1934 /*----------------------------------------------------*/
1935
1936 wmhints = XGetWMHints(dpy, xcWindow(top));
1937 wmhints->input = True;
1938
1939 #ifdef HAVE_XPM
1940 /* Create the xcircuit icon pixmap */
1941 XpmCreatePixmapFromData(dpy, win, xcircuit_xpm, &icon, NULL, NULL);
1942
1943 wmhints->flags |= InputHint | IconPixmapHint;
1944 wmhints->icon_pixmap = icon;
1945 #else
1946 wmhints->flags |= InputHint;
1947 #endif
1948
1949 XSetWMHints(dpy, xcWindow(top), wmhints);
1950 XFree(wmhints);
1951
1952 /* Don't know why this is necessary, but otherwise keyboard input focus */
1953 /* is screwed up under the WindowMaker window manager and possibly others. */
1954
1955 #ifdef INPUT_FOCUS
1956 XtAddEventHandler(top, SubstructureNotifyMask,
1957 TRUE, (XtEventHandler)mappinghandler, NULL);
1958 #endif
1959
1960 XtAddEventHandler(top, NoEventMask, TRUE,
1961 (XtEventHandler)clientmessagehandler, NULL);
1962
1963 /* Set the area widget width and height, center userspace (0, 0) on screen */
1964 XtSetArg(wargs[0], XtNwidth, &newwin->width);
1965 XtSetArg(wargs[1], XtNheight, &newwin->height);
1966 XtGetValues(newwin->area, wargs, 2);
1967
1968 /*---------------------------------------------------*/
1969 /* Define basic display variables */
1970 /* Redefine win to be just the drawing area window */
1971 /*---------------------------------------------------*/
1972
1973 newwin->window = xcWindow(newwin->area);
1974
1975 /*-----------------------------*/
1976 /* Create the Graphics Context */
1977 /*-----------------------------*/
1978
1979 values.foreground = BlackPixel(dpy, DefaultScreen(dpy));
1980 values.background = WhitePixel(dpy, DefaultScreen(dpy));
1981 values.font = appdata.xcfont->fid;
1982
1983 newwin->gc = XCreateGC(dpy, newwin->window,
1984 GCForeground | GCBackground | GCFont, &values);
1985
1986 #ifdef HAVE_CAIRO
1987 newwin->surface = cairo_xlib_surface_create(dpy, newwin->window,
1988 DefaultVisual(dpy, 0), newwin->width, newwin->height);
1989 newwin->cr = cairo_create(newwin->surface);
1990 #else
1991 newwin->clipmask = XCreatePixmap(dpy, newwin->window, newwin->width,
1992 newwin->height, 1);
1993
1994 values.foreground = 0;
1995 values.background = 0;
1996 newwin->cmgc = XCreateGC(dpy, newwin->clipmask, GCForeground
1997 | GCBackground, &values);
1998 #endif /* HAVE_CAIRO */
1999
2000 return newwin;
2001 }
2002
2003 #endif
2004
2005 /*----------------------------------------------------------------------*/
2006 /* When not using ToolScript, this is the standard X loop (XtMainLoop())*/
2007 /*----------------------------------------------------------------------*/
2008
2009 int local_xloop()
2010 {
2011 XtAppMainLoop(app);
2012 return EXIT_SUCCESS;
2013 }
2014
2015 /*----------------------------------------------------------------------*/
2016 /* Main entry point when used as a standalone program */
2017 /*----------------------------------------------------------------------*/
2018
2019 int main(int argc, char **argv)
2020 {
2021 char *argv0; /* find root of argv[0] */
2022 short initargc = argc; /* because XtInitialize() absorbs the */
2023 /* -schem flag and renumbers argc! (bug?) */
2024 short k = 0;
2025
2026 /*-----------------------------------------------------------*/
2027 /* Find the root of the command called from the command line */
2028 /*-----------------------------------------------------------*/
2029
2030 argv0 = strrchr(argv[0], '/');
2031 if (argv0 == NULL)
2032 argv0 = argv[0];
2033 else
2034 argv0++;
2035
2036 pre_initialize();
2037
2038 /*---------------------------*/
2039 /* Check for schematic flag */
2040 /*---------------------------*/
2041
2042 for (k = argc - 1; k > 0; k--) {
2043 if (!strncmp(argv[k], "-2", 2)) {
2044 pressmode = 1; /* 2-button mouse indicator */
2045 break;
2046 }
2047 }
2048
2049 areawin = GUI_init(argc, argv);
2050 post_initialize();
2051
2052 /*-------------------------------------*/
2053 /* Initialize the ghostscript renderer */
2054 /*-------------------------------------*/
2055
2056 ghostinit();
2057
2058 /*----------------------------------------------------------*/
2059 /* Check home directory for initial settings & other loads; */
2060 /* Load the (default) built-in set of objects */
2061 /*----------------------------------------------------------*/
2062
2063 #ifdef HAVE_PYTHON
2064 init_interpreter();
2065 #endif
2066
2067 loadrcfile();
2068 pressmode = 0; /* Done using this to mark 2-button mouse mode */
2069
2070 composelib(PAGELIB); /* make sure we have a valid page list */
2071 composelib(LIBLIB); /* and library directory */
2072
2073 /*----------------------------------------------------*/
2074 /* Parse the command line for initial file to load. */
2075 /* Otherwise, look for possible crash-recovery files. */
2076 /*----------------------------------------------------*/
2077
2078 if (argc == 2 + (k != 0) || initargc == 2 + (k != 0)) {
2079 strcpy(_STR2, argv[(k == 1) ? 2 : 1]);
2080 startloadfile(-1); /* change the argument to load into library other
2081 than the User Library */
2082 }
2083 else {
2084 findcrashfiles();
2085 }
2086
2087 xobjs.suspend = -1;
2088 return local_xloop(); /* No return---exit through quit() callback */
2089 }
2090
2091 /*----------------------------------------------------------------------*/
2092 #endif /* !TCL_WRAPPER */
XCircuit is a program for drawing publishable-quality electrical circuit schematic diagrams and related figures, and produce circuit netlists through schematic capture.