1 /*
2 * FIG : Facility for Interactive Generation of figures
3 * Copyright (c) 1985-1988 by Supoj Sutanthavibul
4 * Parts Copyright (c) 1989-2015 by Brian V. Smith
5 * Parts Copyright (c) 1991 by Paul King
6 * Parts Copyright (c) 2016-2018 by Thomas Loimer
7 *
8 * Any party obtaining a copy of these files is granted, free of charge, a
9 * full and unrestricted irrevocable, world-wide, paid up, royalty-free,
10 * nonexclusive right and license to deal in this software and documentation
11 * files (the "Software"), including without limitation the rights to use,
12 * copy, modify, merge, publish, distribute, sublicense and/or sell copies of
13 * the Software, and to permit persons who receive copies from any such
14 * party to do so, with the only requirement being that the above copyright
15 * and this permission notice remain intact.
16 *
17 */
18
19 #include "fig.h"
20 #include "figx.h"
21 #include "resources.h"
22 #include "object.h"
23 #include "mode.h"
24 #include "e_edit.h"
25 #include "f_util.h"
26 #include "u_print.h"
27 #include "w_dir.h"
28 #include "w_drawprim.h" /* for max_char_height */
29 #include "w_export.h"
30 #include "w_file.h"
31 #include "w_indpanel.h"
32 #include "w_msgpanel.h"
33 #include "w_print.h"
34 #include "w_setup.h"
35 #include "w_util.h"
36 #include "w_icons.h"
37
38 #include "u_bound.h"
39 #include "u_redraw.h"
40 #include "w_canvas.h"
41 #include "w_cmdpanel.h"
42 #include "w_color.h"
43 #include "w_cursor.h"
44
45 /* EXPORTS */
46
47 Boolean export_up = False;
48 char default_export_file[PATH_MAX];
49
50 Widget export_popup; /* the main export popup */
51 Widget export_panel; /* the form it's in */
52 Widget exp_selfile; /* output (selected) file widget */
53 Widget exp_mask; /* mask widget */
54 Widget exp_dir; /* current directory widget */
55 Widget exp_flist; /* file list widget */
56 Widget exp_dlist; /* dir list widget */
57
58 Widget top_section, bottom_section, postscript_form, bitmap_form;
59 Widget ps_form_label;
60 Widget export_orient_panel;
61 Widget export_just_panel;
62 Widget export_papersize_panel;
63 Widget export_multiple_panel;
64 Widget export_overlap_panel;
65 Widget export_mag_text;
66 Widget mag_spinner;
67 Widget export_transp_panel;
68 Widget export_background_panel;
69 Widget export_grid_minor_text, export_grid_major_text;
70 Widget export_grid_minor_menu_button, export_grid_minor_menu;
71 Widget export_grid_major_menu_button, export_grid_major_menu;
72 Widget export_grid_unit_label;
73
74 void export_update_figure_size(void);
75 void do_export(Widget w);
76
77 /* LOCAL */
78
79 static char save_export_dir[PATH_MAX];
80 /* these are in fig2dev print units (1/72 inch) */
81 static float offset_unit_conv[] = { 72.0, 72.0/2.54, 72.0/PIX_PER_INCH };
82 /* the bounding box of the figure when the export panel was popped up */
83 static int ux,uy,lx,ly;
84 static String file_list_translations =
85 "<Btn1Down>,<Btn1Up>: Set()Notify()\n\
86 <Btn1Up>(2): Export()\n\
87 <Key>Return: ExportFile()";
88 static String file_name_translations =
89 "<Key>Return: ExportFile()\n\
90 <Key>Escape: CancelExport()";
91 static XtActionsRec file_name_actions[] = {
92 {"ExportFile", (XtActionProc) do_export},
93 };
94
95 String exp_translations =
96 "<Message>WM_PROTOCOLS: DismissExport()";
97
98 String export_translations =
99 "<Key>Return: UpdateMag()\n\
100 Ctrl<Key>J: UpdateMag()\n\
101 Ctrl<Key>M: UpdateMag()\n\
102 Ctrl<Key>X: EmptyTextKey()\n\
103 Ctrl<Key>U: multiply(4)\n\
104 <Key>F18: PastePanelKey()";
105
106 static void export_panel_cancel(Widget w, XButtonEvent *ev);
107 static void update_mag(Widget widget, Widget *item, int *event);
108 static XtActionsRec export_actions[] = {
109 {"DismissExport", (XtActionProc) export_panel_cancel},
110 {"CancelExport", (XtActionProc) export_panel_cancel},
111 {"Export", (XtActionProc) do_export},
112 {"UpdateMag", (XtActionProc) update_mag},
113 };
114 static char *smooth_choices[] = {
115 " No smoothing ",
116 "Some smoothing",
117 "More smoothing"
118 };
119 static char *preview_items[] = {
120 " None ",
121 " ASCII (EPSI) ",
122 " Color TIFF ",
123 "Monochrome TIFF"
124 };
125
126 static char named_file[60];
127 static intptr_t xoff_unit_setting, yoff_unit_setting;
128
129 static Widget export_grid_label;
130 static Widget lang_panel, lang_lab;
131 static Widget layer_choice;
132 static Widget border_lab, border_text, border_spinner;
133 static Widget transp_lab, transp_menu;
134 static Widget background_lab, background_menu;
135 static Widget just_lab;
136 static Widget papersize_lab;
137 static Widget fitpage;
138 static Widget multiple_lab;
139 static Widget quality_lab, quality_text, quality_spinner;
140 static Widget smooth_menu_button;
141 static Widget smooth_lab;
142 static Widget orient_lab;
143 static Widget cancel_but, export_but;
144 static Widget dfile_lab, dfile_text, nfile_lab;
145 static Widget mag_lab;
146 static Widget size_lab;
147 static Widget exp_off_lab, exp_xoff_lab, exp_yoff_lab;
148 static Widget export_offset_x, export_offset_y;
149 static Widget exp_xoff_unit_panel;
150 static Widget exp_yoff_unit_panel;
151 static Widget pcl_cmd_label;
152 static Widget pcl_cmd_checkbox;
153 static Widget hpgl_font_label;
154 static Widget hpgl_font_checkbox;
155 static Widget pdf_lab, pdf_pagemode_label, pdf_pagemode_checkbox;
156 static Widget preview_lab, preview_panel;
157
158 /* callbacks */
159 static void lang_select(Widget w, XtPointer new_lang, XtPointer call_data);
160 static void orient_select(Widget, XtPointer client_dat, XtPointer call_dat);
161 static void preview_select(Widget, XtPointer, XtPointer);
162 static void just_select(Widget, XtPointer client_data, XtPointer call_data);
163 static void transp_select(Widget, XtPointer, XtPointer);
164 static void background_select(Widget, XtPointer, XtPointer);
165 static void papersize_select(Widget w, XtPointer, XtPointer);
166 static void multiple_select(Widget w, XtPointer, XtPointer);
167 static void overlap_select(Widget w, XtPointer, XtPointer);
168
169 static void get_magnif(void);
170 static void get_quality(void);
171 static void update_figure_size(void);
172 static void fit_page(void);
173 static void create_export_panel(Widget w);
174 static void manage_optional(void);
175 static void set_export_mask(int lang);
176
177 DeclareStaticArgs(15);
178
179
180 static void
export_panel_dismiss(void)181 export_panel_dismiss(void)
182 {
183 /* first get magnification from the widget into appres.magnification
184 in case it changed */
185 /* the other things like paper size, justification, etc. are already
186 updated because they are from menus */
187 get_magnif();
188 if (save_export_dir[0] != '\0')
189 strcpy(cur_export_dir, save_export_dir);
190
191 /* get the image quality value too */
192 get_quality();
193
194 FirstArg(XtNstring, "\0");
195 SetValues(exp_selfile); /* clear ascii widget string */
196 XtPopdown(export_popup);
197 export_up = popup_up = False;
198 }
199
200 static void
export_panel_cancel(Widget w,XButtonEvent * ev)201 export_panel_cancel(Widget w, XButtonEvent *ev)
202 {
203 export_panel_dismiss();
204 }
205
206 /* get x/y offsets from panel and convert to 1/72 inch for fig2dev */
207
exp_getxyoff(int * ixoff,int * iyoff)208 void exp_getxyoff(int *ixoff, int *iyoff)
209 {
210 float xoff, yoff;
211 *ixoff = *iyoff = 0;
212 /* if no file panel yet, use 0, 0 for offsets */
213 if (export_offset_x == (Widget) 0 ||
214 export_offset_y == (Widget) 0)
215 return;
216
217 sscanf(panel_get_value(export_offset_x),"%f",&xoff);
218 *ixoff = round(xoff*offset_unit_conv[xoff_unit_setting]);
219 sscanf(panel_get_value(export_offset_y),"%f",&yoff);
220 *iyoff = round(yoff*offset_unit_conv[yoff_unit_setting]);
221 }
222
223
224 static char export_msg[] = "EXPORT";
225 static char exp_msg[] =
226 "The current figure is modified.\nDo you want to save it before exporting?";
227
228 void
do_export(Widget w)229 do_export(Widget w)
230 {
231 char *fval;
232 int xoff, yoff;
233 F_line *l;
234 char transparent[10], backgrnd[10], grid[80];
235 char msg[200];
236 int transp;
237 int border;
238 Boolean use_transp_backg;
239
240 /* don't export if in the middle of drawing/editing */
241 if (check_action_on())
242 return;
243
244 /* if the popup has been created, get magnification and jpeg quality
245 here to fix any bad values */
246 if (export_popup) {
247 /* get the magnification into appres.magnification */
248 get_magnif();
249
250 /* get the image quality value too */
251 get_quality();
252 }
253
254 if (emptyfigure_msg(export_msg))
255 return;
256
257 /* update figure size window */
258 export_update_figure_size();
259
260 /* if modified (and non-empty) ask to save first */
261 if (!query_save(exp_msg))
262 return; /* cancel, do not export */
263
264 if (!export_popup)
265 create_export_panel(w);
266
267 /* if there is no default export name (e.g. if user has done "New" and
268 not entered a name) then make one up */
269 if (default_export_file[0] == '\0') {
270 /* for tiff and jpeg use three-letter suffixes */
271 if (cur_exp_lang==LANG_TIFF)
272 sprintf(default_export_file,"NoName.tif");
273 else if (cur_exp_lang==LANG_JPEG)
274 sprintf(default_export_file,"NoName.jpg");
275 else if (cur_exp_lang==LANG_PDFTEX)
276 /* for pdftex, just use .pdf */
277 sprintf(default_export_file,"NoName.pdf");
278 else
279 sprintf(default_export_file, "NoName.%s",
280 lang_items[cur_exp_lang]);
281 }
282
283 fval = panel_get_value(exp_selfile);
284 if (emptyname(fval)) { /* output filename is empty, use default */
285 fval = default_export_file;
286 warnexist = False; /* don't warn if this file exists */
287 } else if (strcmp(fval,default_export_file) != 0) {
288 warnexist = True; /* warn if the file exists and is diff. from default */
289 }
290
291 /* get the magnification into appres.magnification */
292 get_magnif();
293
294 /* get the image quality value too */
295 get_quality();
296
297 /* get any grid spec */
298 get_grid_spec(grid, export_grid_minor_text, export_grid_major_text);
299
300 /* make sure that the export file isn't one
301 of the picture files (e.g. xxx.eps) */
302 for (l = objects.lines; l != NULL; l = l->next) {
303 if (l->type == T_PICTURE && l->pic->pic_cache) {
304 if (strcmp(fval,l->pic->pic_cache->file) == 0) {
305 beep();
306 sprintf(msg, "\"%s\" is an input file.\nExport aborted", fval);
307 (void) popup_query(QUERY_OK, msg);
308 return;
309 }
310 }
311 }
312
313 /* if not absolute path, change directory */
314 if (*fval != '/') {
315 if (change_directory(cur_export_dir) != 0)
316 return;
317 strcpy(save_export_dir, cur_export_dir);
318 }
319
320 /* make the export button insensitive during the export */
321 XtSetSensitive(export_but, False);
322 app_flush();
323
324 exp_getxyoff(&xoff,&yoff); /* get x/y offsets from panel */
325
326 use_transp_backg = False;
327 /* convert the transparent color to an RGB hex value */
328 if (cur_exp_lang == LANG_GIF) {
329 /* use the mapped color for the transparent color */
330 /* the color was mapped from Fig.color -> X.color -> mapped.color */
331 transp = appres.transparent;
332 /* make background transparent */
333 if (transp == TRANSP_BACKGROUND) {
334 use_transp_backg = True;
335 sprintf(transparent,"#%02x%02x%02x",
336 x_bg_color.red>>8,
337 x_bg_color.green>>8,
338 x_bg_color.blue>>8);
339 /* make other color transp */
340 } else {
341 XColor col;
342 col.pixel = x_color(transp);
343 XQueryColor(tool_d, tool_cm, &col);
344 sprintf(transparent,"#%02x%02x%02x",
345 col.red>>8, col.green>>8, col.blue>>8);
346 use_transp_backg = False;
347 }
348 }
349 /* make a #rrggbb string from the background color */
350 make_rgb_string(export_background_color, backgrnd);
351
352 /* get margin width from the panel */
353 sscanf(panel_get_value(border_text), "%d", &border);
354 /* update appres */
355 appres.export_margin = border;
356
357 /* call fig2dev to export the file */
358 if (print_to_file(fval, xoff, yoff, backgrnd,
359 transp == TRANSP_NONE? NULL: transparent,
360 use_transp_backg, border, grid) == 0) {
361 FirstArg(XtNlabel, fval);
362 SetValues(dfile_text); /* set the default filename */
363 if (strcmp(fval,default_export_file) != 0)
364 /* and copy to default */
365 strcpy(default_export_file,fval);
366 export_panel_dismiss();
367 }
368
369 XtSetSensitive(export_but, True);
370 }
371
372 static void
preview_select(Widget w,XtPointer client_data,XtPointer call_data)373 preview_select(Widget w, XtPointer client_data, XtPointer call_data)
374 {
375 ptr_int data = {client_data};
376
377 if (preview_type != data.val) {
378 FirstArg(XtNlabel, XtName(w));
379 SetValues(preview_panel);
380 preview_type = data.val;
381 }
382 }
383
384 static void
orient_select(Widget w,XtPointer client_data,XtPointer call_data)385 orient_select(Widget w, XtPointer client_data, XtPointer call_data)
386 {
387 ptr_int data = {client_data};
388
389 if (appres.landscape != data.val) {
390 change_orient();
391 appres.landscape = data.val;
392 /* make sure that paper size is appropriate */
393 papersize_select(export_papersize_panel,
394 data.ptr, (XtPointer) 0);
395 }
396 }
397
398 static void
just_select(Widget w,XtPointer client_data,XtPointer call_data)399 just_select(Widget w, XtPointer client_data, XtPointer call_data)
400 {
401 FirstArg(XtNlabel, XtName(w));
402 SetValues(export_just_panel);
403 /* change print justification if it exists */
404 if (print_just_panel)
405 SetValues(print_just_panel);
406 appres.flushleft = (client_data? True: False);
407 }
408
409 static void
papersize_select(Widget w,XtPointer client_data,XtPointer call_data)410 papersize_select(Widget w, XtPointer client_data, XtPointer call_data)
411 {
412 intptr_t papersize = (intptr_t) client_data;
413
414 FirstArg(XtNlabel, paper_sizes[papersize].fname);
415 SetValues(export_papersize_panel);
416 /* change print papersize if it exists */
417 if (print_papersize_panel)
418 SetValues(print_papersize_panel);
419 appres.papersize = papersize;
420 /* update the red line showing the new page size */
421 update_pageborder();
422 }
423
424 static void
multiple_select(Widget w,XtPointer client_data,XtPointer call_data)425 multiple_select(Widget w, XtPointer client_data, XtPointer call_data)
426 {
427 intptr_t multiple = (intptr_t) client_data;
428
429 FirstArg(XtNlabel, multiple_pages[multiple]);
430 SetValues(export_multiple_panel);
431 /* change print multiple if it exists */
432 if (print_multiple_panel)
433 SetValues(print_multiple_panel);
434 appres.multiple = (multiple? True : False);
435 /* if multiple pages, disable justification (must be flush left) */
436 if (appres.multiple) {
437 XtSetSensitive(just_lab, False);
438 XtSetSensitive(export_just_panel, False);
439 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_PDF)
440 XtSetSensitive(export_overlap_panel, True);
441 if (print_just_panel) {
442 XtSetSensitive(just_lab, False);
443 XtSetSensitive(print_just_panel, False);
444 XtSetSensitive(print_overlap_panel, True);
445 }
446 } else {
447 XtSetSensitive(just_lab, True);
448 XtSetSensitive(export_just_panel, True);
449 XtSetSensitive(export_overlap_panel, False);
450 if (print_just_panel) {
451 XtSetSensitive(just_lab, True);
452 XtSetSensitive(print_just_panel, True);
453 XtSetSensitive(print_overlap_panel, False);
454 }
455 }
456 }
457
458 static void
overlap_select(Widget w,XtPointer client_data,XtPointer call_data)459 overlap_select(Widget w, XtPointer client_data, XtPointer call_data)
460 {
461 intptr_t overlap = (intptr_t) client_data;
462
463 FirstArg(XtNlabel, overlap_pages[overlap]);
464 SetValues(export_overlap_panel);
465 /* change print overlap if it exists */
466 if (print_overlap_panel)
467 SetValues(print_overlap_panel);
468 appres.overlap = (overlap? True : False);
469 }
470
471 static void
set_postscript_pdf_options(void)472 set_postscript_pdf_options(void)
473 {
474 /* enable or disable features available for PostScript */
475
476 if (cur_exp_lang == LANG_PDF && !pdf_pagemode) {
477 XtSetSensitive(postscript_form, False);
478 return;
479 } else {
480 XtSetSensitive(postscript_form, True);
481 }
482 /* if multiple pages, enable overlap and
483 disable justification (must be flush left) */
484 if (appres.multiple) {
485 XtSetSensitive(export_overlap_panel, True);
486 XtSetSensitive(just_lab, False);
487 XtSetSensitive(export_just_panel, False);
488 if (print_just_panel) {
489 XtSetSensitive(just_lab, False);
490 XtSetSensitive(print_just_panel, False);
491 }
492 } else {
493 XtSetSensitive(export_overlap_panel, False);
494 XtSetSensitive(just_lab, True);
495 XtSetSensitive(export_just_panel, True);
496 if (print_just_panel) {
497 XtSetSensitive(just_lab, True);
498 XtSetSensitive(print_just_panel, True);
499 }
500 }
501 }
502
503 static void
lang_select(Widget w,XtPointer client_data,XtPointer call_data)504 lang_select(Widget w, XtPointer client_data, XtPointer call_data)
505 {
506 ptr_int new_lang = {client_data};
507
508 FirstArg(XtNlabel, XtName(w));
509 SetValues(lang_panel);
510 cur_exp_lang = new_lang.val;
511
512 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_PDF)
513 set_postscript_pdf_options();
514
515 /* manage optional buttons/menus etc */
516 manage_optional();
517
518 update_def_filename();
519 FirstArg(XtNlabel, default_export_file);
520 SetValues(dfile_text);
521
522 /* set the new wildcard mask based on the current export language */
523 set_export_mask(cur_exp_lang);
524 }
525
526 /***
527 set the new export mask based on the language passed.
528 e.g. make *.jpg for jpeg output
529 ***/
530
531 static void
set_export_mask(int lang)532 set_export_mask(int lang)
533 {
534 char mask[100];
535
536 /* make wildcard mask based on filename suffix for output language */
537 /* for tiff and jpeg use three-letter suffixes */
538 if (cur_exp_lang==LANG_TIFF)
539 strcpy(mask, "*.tif");
540 else if (cur_exp_lang==LANG_JPEG)
541 strcpy(mask, "*.jpg");
542 else if (cur_exp_lang==LANG_PDFTEX)
543 /* for pdftex, just use .pdf */
544 strcpy(mask, "*.pdf");
545 else if (cur_exp_lang == LANG_EPS)
546 strcpy(mask, "*.eps");
547 else
548 sprintf(mask,"*.%s",lang_items[lang]);
549 FirstArg(XtNstring, mask);
550 SetValues(exp_mask);
551
552 /* rescan current directory */
553 Rescan(0, 0, 0, 0);
554 }
555
556 /* user has chosen a smooth factor from the pulldown menu */
557
558 static void
smooth_select(Widget w,XtPointer client_data,XtPointer call_data)559 smooth_select(Widget w, XtPointer client_data, XtPointer call_data)
560 {
561 intptr_t new_smooth = (intptr_t) client_data;
562 appres.smooth_factor = new_smooth == 0 ? 1 : new_smooth*2;
563 FirstArg(XtNlabel, smooth_choices[new_smooth]);
564 SetValues(smooth_menu_button);
565 }
566
567 /* user selected a background color from the menu */
568
569 static void
background_select(Widget w,XtPointer client_data,XtPointer call_data)570 background_select(Widget w, XtPointer client_data, XtPointer call_data)
571 {
572 ptr_int data = {client_data};
573 Pixel bgcolor, fgcolor;
574
575 /* get the colors from the color button just pressed */
576 FirstArg(XtNbackground, &bgcolor);
577 NextArg(XtNforeground, &fgcolor);
578 GetValues(w);
579
580 /* get the colorname from the color button and put it and the colors
581 in the menu button */
582 FirstArg(XtNlabel, XtName(w));
583 NextArg(XtNbackground, bgcolor);
584 NextArg(XtNforeground, fgcolor);
585 SetValues(export_background_panel);
586 /* update the print panel too if it exists */
587 if (print_background_panel)
588 SetValues(print_background_panel);
589 export_background_color = data.val;
590
591 XtPopdown(background_menu);
592 }
593
594 /* user selected a transparent color from the menu */
595
596 static void
transp_select(Widget w,XtPointer client_data,XtPointer call_data)597 transp_select(Widget w, XtPointer client_data, XtPointer call_data)
598 {
599 Pixel bgcolor, fgcolor;
600 ptr_int data = {client_data};
601
602 /* get the colors from the color button just pressed */
603 FirstArg(XtNbackground, &bgcolor);
604 NextArg(XtNforeground, &fgcolor);
605 GetValues(w);
606
607 /* get the colorname from the color button and put it and the colors
608 in the menu button */
609 FirstArg(XtNlabel, XtName(w));
610 NextArg(XtNbackground, bgcolor);
611 NextArg(XtNforeground, fgcolor);
612 SetValues(export_transp_panel);
613 appres.transparent = data.val;
614
615 XtPopdown(transp_menu);
616 }
617
618 /* come here when user chooses minor grid interval from menu */
619
620 void
export_grid_minor_select(Widget w,XtPointer new_grid_choice,XtPointer call_data)621 export_grid_minor_select(Widget w,
622 XtPointer new_grid_choice, XtPointer call_data)
623 {
624 char buf[MAX_GRID_STRLEN];
625 char *val;
626 ptr_int grid = {new_grid_choice};
627
628 grid_minor = grid.val;
629
630 /* put selected grid value in the text area */
631 /* first get rid of any "mm" following the value */
632 if (strlen(grid_choices[grid_minor]) >= MAX_GRID_STRLEN) {
633 file_msg("Cannot apply new minor grid size '%s'. "
634 "Please report this bug.\n", grid_choices[grid_minor]);
635 return;
636 }
637 val = strtok(strcpy(buf, grid_choices[grid_minor]), " ");
638 FirstArg(XtNstring, val);
639 SetValues(export_grid_minor_text);
640 }
641
642 /* come here when user chooses major grid interval from menu */
643
644 void
export_grid_major_select(Widget w,XtPointer new_grid_choice,XtPointer call_data)645 export_grid_major_select(Widget w,
646 XtPointer new_grid_choice, XtPointer call_data)
647 {
648 char buf[MAX_GRID_STRLEN];
649 char *val;
650 ptr_int grid = {new_grid_choice};
651
652 grid_major = grid.val;
653
654 /* put selected grid value in the text area */
655 /* first get rid of any "mm" following the value */
656 if (strlen(grid_choices[grid_major]) >= MAX_GRID_STRLEN) {
657 file_msg("Cannot apply new major grid size '%s'. "
658 "Please report this bug.\n", grid_choices[grid_major]);
659 return;
660 }
661 val = strtok(strcpy(buf, grid_choices[grid_major]), " ");
662 FirstArg(XtNstring, val);
663 SetValues(export_grid_major_text);
664 }
665
666
667 /* enable/disable optional buttons etc depending on export language */
668
669 static void
manage_optional(void)670 manage_optional(void)
671 {
672 Widget below;
673
674 /* if language is GIF, enable the transparent color choices */
675 if (cur_exp_lang == LANG_GIF) {
676 XtManageChild(transp_lab);
677 XtManageChild(export_transp_panel);
678 } else {
679 XtUnmanageChild(transp_lab);
680 XtUnmanageChild(export_transp_panel);
681 }
682
683 /* if the export language is JPEG, manage the image quality choices */
684 if (cur_exp_lang == LANG_JPEG) {
685 XtManageChild(quality_lab);
686 XtManageChild(quality_spinner);
687 } else {
688 XtUnmanageChild(quality_lab);
689 XtUnmanageChild(quality_spinner);
690 }
691
692 /* if language is a bitmap format or PS/EPS/PDF/PSTEX/PSPDF or MAP,
693 manage the border margin stuff */
694 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_EPS ||
695 cur_exp_lang == LANG_PDF || cur_exp_lang == LANG_PSTEX ||
696 cur_exp_lang == LANG_PSPDF || cur_exp_lang == LANG_PICT2E ||
697 cur_exp_lang == LANG_TIKZ || cur_exp_lang == LANG_MAP ||
698 cur_exp_lang >= FIRST_BITMAP_LANG) {
699 XtManageChild(border_lab);
700 XtManageChild(border_spinner);
701 } else {
702 XtUnmanageChild(border_lab);
703 XtUnmanageChild(border_spinner);
704 }
705
706 /* if language is a bitmap format, tk or PS/EPS/PDF/PSTEX/PSPDF manage the background color and grid */
707 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_EPS ||
708 cur_exp_lang == LANG_PDF || cur_exp_lang ==LANG_PSTEX ||
709 cur_exp_lang == LANG_TK || cur_exp_lang == LANG_PSPDF ||
710 cur_exp_lang >= FIRST_BITMAP_LANG) {
711 XtManageChild(background_lab);
712 XtManageChild(export_background_panel);
713 } else {
714 XtUnmanageChild(background_lab);
715 XtUnmanageChild(export_background_panel);
716 }
717 /* for all of the above *EXCEPT* tk, manage grid options */
718 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_EPS ||
719 cur_exp_lang == LANG_PDF || cur_exp_lang ==LANG_PSTEX ||
720 cur_exp_lang == LANG_PSPDF ||
721 cur_exp_lang >= FIRST_BITMAP_LANG) {
722 XtManageChild(export_grid_label);
723 XtManageChild(export_grid_minor_menu_button);
724 XtManageChild(export_grid_minor_text);
725 XtManageChild(export_grid_major_menu_button);
726 XtManageChild(export_grid_major_text);
727 XtManageChild(export_grid_unit_label);
728 } else {
729 XtUnmanageChild(export_grid_label);
730 XtUnmanageChild(export_grid_minor_menu_button);
731 XtUnmanageChild(export_grid_minor_text);
732 XtUnmanageChild(export_grid_major_menu_button);
733 XtUnmanageChild(export_grid_major_text);
734 XtUnmanageChild(export_grid_unit_label);
735 }
736
737 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_EPS) {
738 XtUnmanageChild(pdf_lab);
739 XtUnmanageChild(pdf_pagemode_checkbox);
740 XtUnmanageChild(pdf_pagemode_label);
741 XtManageChild(preview_lab);
742 XtManageChild(preview_panel);
743 } else if (cur_exp_lang == LANG_PDF) {
744 XtUnmanageChild(preview_lab);
745 XtUnmanageChild(preview_panel);
746 XtManageChild(pdf_lab);
747 XtManageChild(pdf_pagemode_checkbox);
748 XtManageChild(pdf_pagemode_label);
749 } else {
750 XtUnmanageChild(pdf_lab);
751 XtUnmanageChild(pdf_pagemode_checkbox);
752 XtUnmanageChild(pdf_pagemode_label);
753 XtUnmanageChild(preview_lab);
754 XtUnmanageChild(preview_panel);
755 }
756
757 /* now manage either the PostScript form, the Bitmap form or neither */
758 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_PDF) {
759 XtUnmanageChild(postscript_form);
760 if (cur_exp_lang == LANG_PDF && !pdf_pagemode)
761 XtSetSensitive(postscript_form, False);
762 else
763 XtSetSensitive(postscript_form, True);
764 XtManageChild(multiple_lab);
765 XtManageChild(export_multiple_panel);
766 XtManageChild(export_overlap_panel);
767 FirstArg(XtNfromVert, export_multiple_panel);
768 SetValues(exp_off_lab);
769 SetValues(exp_xoff_lab);
770 SetValues(export_offset_x);
771 SetValues(exp_xoff_unit_panel);
772 SetValues(exp_yoff_lab);
773 SetValues(export_offset_y);
774 SetValues(exp_yoff_unit_panel);
775 XtUnmanageChild(pcl_cmd_label);
776 XtUnmanageChild(pcl_cmd_checkbox);
777 XtUnmanageChild(hpgl_font_label);
778 XtUnmanageChild(hpgl_font_checkbox);
779
780 XtManageChild(postscript_form);
781 XtUnmanageChild(bitmap_form);
782 below = postscript_form;
783 } else if (cur_exp_lang == LANG_IBMGL) {
784 /* Use all of the Postscript form except the multiple page,
785 the pagemode and the preview options */
786 XtUnmanageChild(postscript_form);
787 XtSetSensitive(postscript_form, True);
788 XtUnmanageChild(multiple_lab);
789 XtUnmanageChild(export_multiple_panel);
790 XtUnmanageChild(export_overlap_panel);
791 FirstArg(XtNfromVert, export_orient_panel);
792 SetValues(exp_off_lab);
793 SetValues(exp_xoff_lab);
794 SetValues(export_offset_x);
795 SetValues(exp_xoff_unit_panel);
796 SetValues(exp_yoff_lab);
797 SetValues(export_offset_y);
798 SetValues(exp_yoff_unit_panel);
799 XtManageChild(pcl_cmd_label);
800 XtManageChild(pcl_cmd_checkbox);
801 XtManageChild(hpgl_font_label);
802 XtManageChild(hpgl_font_checkbox);
803
804 XtManageChild(postscript_form);
805 XtUnmanageChild(bitmap_form);
806 below = postscript_form;
807 } else if (cur_exp_lang >= FIRST_BITMAP_LANG) {
808 XtManageChild(bitmap_form);
809 XtUnmanageChild(postscript_form);
810 below = bitmap_form;
811 } else {
812 XtUnmanageChild(postscript_form);
813 XtUnmanageChild(bitmap_form);
814 below = top_section;
815 }
816
817 /* reposition bottom section */
818 FirstArg(XtNfromVert, below);
819 NextArg(XtNtop, XtChainTop);
820 NextArg(XtNbottom, XtChainBottom);
821 NextArg(XtNleft, XtChainLeft);
822 NextArg(XtNright, XtChainRight);
823 SetValues(bottom_section);
824 XtManageChild(bottom_section);
825 }
826
827 /* update the figure size window */
828
829 void
export_update_figure_size(void)830 export_update_figure_size(void)
831 {
832 float mult;
833 char *unit;
834 char buf[40];
835
836 if (!export_popup)
837 return;
838 active_compound_bound(&objects, &lx, &ly, &ux, &uy, bound_active_layers && !print_all_layers);
839 mult = appres.INCHES? PIX_PER_INCH : PIX_PER_CM;
840 unit = appres.INCHES? "in": "cm";
841 sprintf(buf, "Figure size: %.1f%s x %.1f%s",
842 (float)(ux-lx)/mult*appres.magnification/100.0,unit,
843 (float)(uy-ly)/mult*appres.magnification/100.0,unit);
844 FirstArg(XtNlabel, buf);
845 SetValues(size_lab);
846 }
847
848 /* calculate the magnification needed to fit the figure to the page size */
849
850 static void
fit_page(void)851 fit_page(void)
852 {
853 int lx,ly,ux,uy;
854 float wd,ht,pwd,pht;
855 char buf[60];
856
857 /* get current size of figure */
858 compound_bound(&objects, &lx, &ly, &ux, &uy);
859 wd = ux-lx;
860 ht = uy-ly;
861
862 /* if there is no figure, return now */
863 if (wd == 0 || ht == 0)
864 return;
865
866 /* get paper size minus a half inch margin all around */
867 pwd = paper_sizes[appres.papersize].width - PIX_PER_INCH;
868 pht = paper_sizes[appres.papersize].height - PIX_PER_INCH;
869 /* swap height and width if landscape */
870 if (appres.landscape) {
871 ux = pwd;
872 pwd = pht;
873 pht = ux;
874 }
875 /* make magnification lesser of ratio of:
876 page height / figure height or
877 page width/figure width
878 */
879 if (pwd/wd < pht/ht)
880 appres.magnification = 100.0*pwd/wd;
881 else
882 appres.magnification = 100.0*pht/ht;
883 /* adjust for difference in real metric vs "xfig metric" */
884 if(!appres.INCHES)
885 appres.magnification *= PIX_PER_CM * 2.54/PIX_PER_INCH;
886
887 /* update the magnification widget */
888 sprintf(buf,"%.1f",appres.magnification);
889 FirstArg(XtNstring, buf);
890 SetValues(export_mag_text);
891
892 /* and figure size */
893 update_figure_size();
894 }
895
896 /* get the magnification from the widget and make it reasonable if not */
897
898 static void
get_magnif(void)899 get_magnif(void)
900 {
901 char buf[60];
902
903 appres.magnification = (float) atof(panel_get_value(export_mag_text));
904 if (appres.magnification <= 0.0)
905 appres.magnification = 100.0;
906 /* write it back to the widget in case it had a bad value */
907 sprintf(buf,"%.1f",appres.magnification);
908 FirstArg(XtNstring, buf);
909 SetValues(export_mag_text);
910 }
911
912 /* as the user types in a magnification, update the figure size */
913
914 static void
update_mag(Widget widget,Widget * item,int * event)915 update_mag(Widget widget, Widget *item, int *event)
916 {
917 char *buf;
918
919 buf = panel_get_value(export_mag_text);
920 appres.magnification = (float) atof(buf);
921 update_figure_size();
922 }
923
924 static void
update_figure_size(void)925 update_figure_size(void)
926 {
927 char buf[60];
928
929 export_update_figure_size();
930 /* update the print panel's indicators too */
931 if (print_popup) {
932 print_update_figure_size();
933 sprintf(buf,"%.1f",appres.magnification);
934 FirstArg(XtNstring, buf);
935 SetValues(print_mag_text);
936 }
937 }
938
939 /* get the quality from the widget and make it reasonable if not */
940
941 static void
get_quality(void)942 get_quality(void)
943 {
944 char buf[60];
945
946 appres.jpeg_quality = (int) atof(panel_get_value(quality_text));
947 if (appres.jpeg_quality <= 0 || appres.jpeg_quality > 100)
948 appres.jpeg_quality = 100;
949 /* write it back to the widget in case it had a bad value */
950 sprintf(buf,"%d",appres.jpeg_quality);
951 FirstArg(XtNstring, buf);
952 SetValues(quality_text);
953 }
954
955 /* create (if necessary) and popup the export panel */
956
957 void
popup_export_panel(Widget w)958 popup_export_panel(Widget w)
959 {
960 char buf[60];
961
962 /* turn off Compose key LED */
963 setCompLED(0);
964
965 set_temp_cursor(wait_cursor);
966 /* if the file panel is up now, get rid of it */
967 if (file_up) {
968 file_up = False;
969 XtPopdown(file_popup);
970 }
971 /* already up? */
972 if (export_up) {
973 /* yes, just raise to top */
974 XRaiseWindow(tool_d, XtWindow(export_popup));
975 return;
976 }
977
978 export_up = popup_up = True;
979
980 if (export_popup) {
981 /* the export panel has already been created, but the number of colors
982 may be different than before. Re-create the transparent color menu */
983 XtDestroyWidget(transp_menu);
984 transp_menu = make_color_popup_menu(export_transp_panel,
985 "Transparent Color", transp_select,
986 INCL_TRANSP, NO_BACKG);
987 /* and the background color menu */
988 XtDestroyWidget(background_menu);
989 background_menu = make_color_popup_menu(export_background_panel,
990 "Background Color", background_select,
991 NO_TRANSP, INCL_BACKG);
992 /* now set the color and name in the background button */
993 set_but_col(export_background_panel, export_background_color);
994 /* now set the color and name in the transparent button */
995 set_but_col(export_transp_panel, appres.transparent);
996
997 /* also the magnification may have been changed in the print popup */
998 sprintf(buf,"%.1f",appres.magnification);
999 FirstArg(XtNstring, buf);
1000 SetValues(export_mag_text);
1001 /* also the figure size (magnification * bounding_box) */
1002 /* get the bounding box of the figure just once */
1003 compound_bound(&objects, &lx, &ly, &ux, &uy);
1004 export_update_figure_size();
1005 } else {
1006 create_export_panel(w);
1007 }
1008
1009 /* set the directory widget to the current export directory */
1010 FirstArg(XtNstring, cur_export_dir);
1011 SetValues(exp_dir);
1012
1013 Rescan(0, 0, 0, 0);
1014
1015 /* put the default export file name */
1016 FirstArg(XtNlabel, default_export_file);
1017 NextArg(XtNwidth, E_FILE_WIDTH);
1018 SetValues(dfile_text);
1019
1020 /* manage/unmanage optional buttons etc depending on export language */
1021 manage_optional();
1022
1023 /* finally, popup the export panel */
1024 XtPopup(export_popup, XtGrabNone);
1025
1026 /* insure that the most recent colormap is installed */
1027 set_cmap(XtWindow(export_popup));
1028 XSetWMProtocols(tool_d, XtWindow(export_popup), &wm_delete_window, 1);
1029 reset_cursor();
1030
1031 /* this will install the wheel accelerators on the scrollbars
1032 now that the panel is realized */
1033 Rescan(0, 0, 0, 0);
1034 }
1035
1036 static void
exp_xoff_unit_select(Widget w,XtPointer client_data,XtPointer call_data)1037 exp_xoff_unit_select(Widget w, XtPointer client_data, XtPointer call_data)
1038 {
1039 FirstArg(XtNlabel, XtName(w));
1040 SetValues(exp_xoff_unit_panel);
1041 xoff_unit_setting = (intptr_t) client_data;
1042 }
1043
1044 static void
exp_yoff_unit_select(Widget w,XtPointer client_data,XtPointer call_data)1045 exp_yoff_unit_select(Widget w, XtPointer client_data, XtPointer call_data)
1046 {
1047 FirstArg(XtNlabel, XtName(w));
1048 SetValues(exp_yoff_unit_panel);
1049 yoff_unit_setting = (intptr_t) client_data;
1050 }
1051
1052 /* when the user checks PCL command option. */
1053 static void /* XtCallbackProc */
toggle_hpgl_pcl_switch(Widget w,XtPointer closure,XtPointer call_data)1054 toggle_hpgl_pcl_switch(Widget w, XtPointer closure, XtPointer call_data)
1055 {
1056 Boolean state;
1057
1058 /* check state of the toggle and set/remove checkmark */
1059 FirstArg(XtNstate, &state);
1060 GetValues(w);
1061
1062 if (state )
1063 FirstArg(XtNbitmap, sm_check_pm);
1064 else
1065 FirstArg(XtNbitmap, sm_null_check_pm);
1066 SetValues(w);
1067
1068 /* set global state */
1069 print_hpgl_pcl_switch = state;
1070
1071 return;
1072 }
1073
1074 static void /* XtCallbackProc */
toggle_hpgl_font(Widget w,XtPointer closure,XtPointer call_data)1075 toggle_hpgl_font(Widget w, XtPointer closure, XtPointer call_data)
1076 {
1077 Boolean state;
1078
1079 /* check state of the toggle and set/remove checkmark */
1080 FirstArg(XtNstate, &state);
1081 GetValues(w);
1082
1083 if (state )
1084 FirstArg(XtNbitmap, sm_check_pm);
1085 else
1086 FirstArg(XtNbitmap, sm_null_check_pm);
1087 SetValues(w);
1088
1089 /* set global state */
1090 hpgl_specified_font = state;
1091
1092 return;
1093 }
1094
1095 static void /* XtCallbackProc */
toggle_pdf_pagemode(Widget w,XtPointer closure,XtPointer call_data)1096 toggle_pdf_pagemode(Widget w, XtPointer closure, XtPointer call_data)
1097 {
1098 Boolean state;
1099
1100 /* check state of the toggle and set/remove checkmark */
1101 FirstArg(XtNstate, &state);
1102 GetValues(w);
1103 if (state) {
1104 FirstArg(XtNbitmap, sm_null_check_pm);
1105 XtSetSensitive(postscript_form, True);
1106 } else {
1107 FirstArg(XtNbitmap, sm_check_pm);
1108 XtSetSensitive(postscript_form, False);
1109 }
1110 SetValues(w);
1111 /* set global state */
1112 pdf_pagemode = state;
1113 return;
1114 }
1115
create_export_panel(Widget w)1116 void create_export_panel(Widget w)
1117 {
1118 Widget beside, below;
1119 Widget entry, papersize_menu;
1120 XFontStruct *temp_font;
1121 char buf[50];
1122 char *unit;
1123 float mult;
1124 intptr_t i;
1125 Position xposn, yposn;
1126 xoff_unit_setting = yoff_unit_setting = (int) appres.INCHES? 0: 1;
1127
1128 XtTranslateCoords(tool, (Position) 0, (Position) 0, &xposn, &yposn);
1129
1130 FirstArg(XtNx, xposn+50);
1131 NextArg(XtNy, yposn+50);
1132 NextArg(XtNtitle, "Xfig: Export menu");
1133 NextArg(XtNcolormap, tool_cm);
1134 NextArg(XtNallowShellResize, True);
1135 export_popup = XtCreatePopupShell("export_popup",
1136 transientShellWidgetClass,
1137 tool, Args, ArgCount);
1138 XtOverrideTranslations(export_popup,
1139 XtParseTranslationTable(exp_translations));
1140 XtAppAddActions(tool_app, export_actions, XtNumber(export_actions));
1141
1142 export_panel = XtCreateManagedWidget("export_panel", formWidgetClass,
1143 export_popup, NULL, ZERO);
1144
1145 /* The export language is first */
1146
1147 FirstArg(XtNlabel, " Language");
1148 NextArg(XtNborderWidth, 0);
1149 NextArg(XtNtop, XtChainTop);
1150 NextArg(XtNbottom, XtChainTop);
1151 NextArg(XtNleft, XtChainLeft);
1152 NextArg(XtNright, XtChainLeft);
1153 lang_lab = XtCreateManagedWidget("lang_label", labelWidgetClass,
1154 export_panel, Args, ArgCount);
1155
1156 FirstArg(XtNlabel, lang_texts[cur_exp_lang]);
1157 NextArg(XtNfromHoriz, lang_lab);
1158 NextArg(XtNborderWidth, INTERNAL_BW);
1159 NextArg(XtNtop, XtChainTop);
1160 NextArg(XtNbottom, XtChainTop);
1161 NextArg(XtNleft, XtChainLeft);
1162 NextArg(XtNright, XtChainLeft);
1163 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1164 lang_panel = XtCreateManagedWidget("language",
1165 menuButtonWidgetClass,
1166 export_panel, Args, ArgCount);
1167 /* make a dividing line for the Bitmap items */
1168 make_pulldown_menu(lang_texts, XtNumber(lang_texts),
1169 FIRST_BITMAP_LANG, "Bitmap Formats",
1170 lang_panel, lang_select);
1171
1172 /* Magnification */
1173
1174 FirstArg(XtNlabel, "Magnification %");
1175 NextArg(XtNfromVert, lang_panel);
1176 NextArg(XtNborderWidth, 0);
1177 NextArg(XtNtop, XtChainTop);
1178 NextArg(XtNbottom, XtChainTop);
1179 NextArg(XtNleft, XtChainLeft);
1180 NextArg(XtNright, XtChainLeft);
1181 mag_lab = XtCreateManagedWidget("mag_label", labelWidgetClass,
1182 export_panel, Args, ArgCount);
1183
1184 /* make a spinner entry for the mag */
1185 /* note: this was called "magnification" */
1186 sprintf(buf, "%.1f", appres.magnification);
1187 /* we want to track typing here to update figure size label */
1188 mag_spinner = MakeFloatSpinnerEntry(export_panel, &export_mag_text, "magnification",
1189 (Widget) NULL, mag_lab, (XtCallbackProc)update_mag, buf, 0.0, 10000.0, 1.0, 45);
1190 FirstArg(XtNfromVert, lang_panel);
1191 NextArg(XtNtop, XtChainTop);
1192 NextArg(XtNbottom, XtChainTop);
1193 NextArg(XtNleft, XtChainLeft);
1194 NextArg(XtNright, XtChainLeft);
1195 SetValues(mag_spinner);
1196
1197 XtOverrideTranslations(export_mag_text,
1198 XtParseTranslationTable(export_translations));
1199
1200 /* Figure Size to the right of the magnification window */
1201
1202 mult = appres.INCHES? PIX_PER_INCH : PIX_PER_CM;
1203 unit = appres.INCHES? "in": "cm";
1204 /* get the size of the figure */
1205 compound_bound(&objects, &lx, &ly, &ux, &uy);
1206 sprintf(buf, "Figure size: %.1f%s x %.1f%s",
1207 (float)(ux-lx)/mult*appres.magnification/100.0,unit,
1208 (float)(uy-ly)/mult*appres.magnification/100.0,unit);
1209 /* fill out label with blanks or when it becomes longer later it won't show it all */
1210 if ((i = strlen(buf)) < 39)
1211 strncat(buf, " ",39-i);
1212
1213 FirstArg(XtNlabel, buf);
1214 NextArg(XtNfromVert, lang_panel);
1215 NextArg(XtNfromHoriz, mag_spinner);
1216 NextArg(XtNhorizDistance, 5);
1217 NextArg(XtNborderWidth, 0);
1218 NextArg(XtNtop, XtChainTop);
1219 NextArg(XtNbottom, XtChainTop);
1220 NextArg(XtNleft, XtChainLeft);
1221 NextArg(XtNright, XtChainLeft);
1222 size_lab = XtCreateManagedWidget("size_label", labelWidgetClass,
1223 export_panel, Args, ArgCount);
1224
1225 /* make radiobuttons to all user to export all or only active layers */
1226
1227 layer_choice = make_layer_choice("Export all layers ", "Export only active",
1228 export_panel, mag_spinner, NULL, 2, 0);
1229
1230 /* the border margin and background color will appear depending on the export language */
1231
1232 FirstArg(XtNlabel, "Border Margin");
1233 NextArg(XtNfromVert, layer_choice);
1234 NextArg(XtNborderWidth, 0);
1235 NextArg(XtNtop, XtChainTop);
1236 NextArg(XtNbottom, XtChainTop);
1237 NextArg(XtNleft, XtChainLeft);
1238 NextArg(XtNright, XtChainLeft);
1239 border_lab = XtCreateManagedWidget("border_label", labelWidgetClass,
1240 export_panel, Args, ArgCount);
1241
1242 /* spinner entry for border margin */
1243 sprintf(buf,"%d",appres.export_margin);
1244
1245 border_spinner = MakeIntSpinnerEntry(export_panel, &border_text, "border_text",
1246 layer_choice, border_lab, (XtCallbackProc) 0, buf, 0, 1000, 1, 35);
1247 FirstArg(XtNtop, XtChainTop);
1248 NextArg(XtNbottom, XtChainTop);
1249 NextArg(XtNleft, XtChainLeft);
1250 NextArg(XtNright, XtChainLeft);
1251 SetValues(border_spinner);
1252
1253 /* background color option for all bitmap export and PS/EPS */
1254
1255 FirstArg(XtNlabel, "Background");
1256 NextArg(XtNfromVert, layer_choice);
1257 NextArg(XtNfromHoriz, border_spinner);
1258 NextArg(XtNhorizDistance, 8);
1259 NextArg(XtNborderWidth, 0);
1260 NextArg(XtNtop, XtChainTop);
1261 NextArg(XtNbottom, XtChainTop);
1262 NextArg(XtNleft, XtChainLeft);
1263 NextArg(XtNright, XtChainLeft);
1264 background_lab = XtCreateManagedWidget("background_label", labelWidgetClass,
1265 export_panel, Args, ArgCount);
1266
1267 FirstArg(XtNfromVert, layer_choice);
1268 NextArg(XtNfromHoriz, background_lab);
1269 NextArg(XtNresize, False);
1270 NextArg(XtNwidth, 80);
1271 NextArg(XtNborderWidth, INTERNAL_BW);
1272 NextArg(XtNtop, XtChainTop);
1273 NextArg(XtNbottom, XtChainTop);
1274 NextArg(XtNleft, XtChainLeft);
1275 NextArg(XtNright, XtChainLeft);
1276 export_background_panel = XtCreateManagedWidget("background",
1277 menuButtonWidgetClass,
1278 export_panel, Args, ArgCount);
1279 /* now set the color and name in the button */
1280 set_but_col(export_background_panel, export_background_color);
1281
1282 /* make color menu */
1283 background_menu = make_color_popup_menu(export_background_panel,
1284 "Background Color", background_select,
1285 NO_TRANSP, INCL_BACKG);
1286
1287 /* grid options */
1288 FirstArg(XtNlabel, "Grid");
1289 NextArg(XtNfromVert, border_lab);
1290 NextArg(XtNborderWidth, 0);
1291 NextArg(XtNtop, XtChainTop);
1292 NextArg(XtNbottom, XtChainTop);
1293 NextArg(XtNleft, XtChainLeft);
1294 NextArg(XtNright, XtChainLeft);
1295 export_grid_label = XtCreateManagedWidget("grid_label", labelWidgetClass,
1296 export_panel, Args, ArgCount);
1297 make_grid_options(export_panel, border_lab,
1298 export_grid_label, minor_grid, major_grid,
1299 &export_grid_minor_menu_button, &export_grid_major_menu_button,
1300 &export_grid_minor_menu, &export_grid_major_menu,
1301 &export_grid_minor_text, &export_grid_major_text,
1302 &export_grid_unit_label,
1303 export_grid_major_select, export_grid_minor_select);
1304
1305 /*
1306 * last row, alternatively for PDF / EPS / PS:
1307 * for PDF a checkbox whether pagemode or cropped to bounding box,
1308 * for EPS/PS drop-down menu to choose embedded preview
1309 */
1310
1311 /* label pagemode */
1312 FirstArg(XtNlabel, " Page mode");
1313 NextArg(XtNfromVert, export_grid_label);
1314 NextArg(XtNborderWidth, 0);
1315 NextArg(XtNtop, XtChainTop);
1316 NextArg(XtNbottom, XtChainTop);
1317 NextArg(XtNleft, XtChainLeft);
1318 NextArg(XtNright, XtChainLeft);
1319 top_section = pdf_lab = XtCreateManagedWidget("pdf_label",
1320 labelWidgetClass, export_panel, Args, ArgCount);
1321
1322 /* checkbox pagemode */
1323 FirstArg(XtNbitmap, pdf_pagemode ? sm_null_check_pm : sm_check_pm);
1324 NextArg(XtNfromVert, export_grid_label);
1325 NextArg(XtNfromHoriz, pdf_lab);
1326 NextArg(XtNtop, XtChainTop);
1327 NextArg(XtNbottom, XtChainTop);
1328 NextArg(XtNleft, XtChainLeft);
1329 NextArg(XtNright, XtChainLeft);
1330 NextArg(XtNinternalWidth, 1);
1331 NextArg(XtNinternalHeight, 1);
1332 NextArg(XtNstate, pdf_pagemode);
1333 pdf_pagemode_checkbox = XtCreateManagedWidget("pdf_pagemode_checkbox",
1334 toggleWidgetClass, export_panel, Args, ArgCount);
1335 XtAddCallback(pdf_pagemode_checkbox, XtNcallback,
1336 (XtCallbackProc)toggle_pdf_pagemode, (XtPointer) NULL);
1337
1338 /* description to the right of the checkbox pagemode */
1339 FirstArg(XtNlabel, "Crop to Bounding Box");
1340 NextArg(XtNfromVert, export_grid_label);
1341 NextArg(XtNfromHoriz, pdf_pagemode_checkbox);
1342 NextArg(XtNborderWidth, 0);
1343 NextArg(XtNtop, XtChainTop);
1344 NextArg(XtNbottom, XtChainTop);
1345 NextArg(XtNleft, XtChainLeft);
1346 NextArg(XtNright, XtChainLeft);
1347 pdf_pagemode_label = XtCreateManagedWidget("pdf_pagemode_label",
1348 labelWidgetClass, export_panel, Args, ArgCount);
1349 /* end pagemode */
1350
1351 /* choose a preview: none, ASCII, color tiff or monochrome tiff */
1352 /* label preview*/
1353 FirstArg(XtNlabel, "Add Preview");
1354 NextArg(XtNfromVert, export_grid_label);
1355 NextArg(XtNborderWidth, 0);
1356 NextArg(XtNtop, XtChainTop);
1357 NextArg(XtNbottom, XtChainTop);
1358 NextArg(XtNleft, XtChainLeft);
1359 NextArg(XtNright, XtChainLeft);
1360 preview_lab = XtCreateManagedWidget("preview_label",
1361 labelWidgetClass, export_panel, Args, ArgCount);
1362
1363 /* drop-down menu preview */
1364 FirstArg(XtNlabel, preview_items[preview_type]);
1365 NextArg(XtNfromVert, export_grid_label);
1366 NextArg(XtNfromHoriz, preview_lab);
1367 NextArg(XtNborderWidth, INTERNAL_BW);
1368 NextArg(XtNtop, XtChainTop);
1369 NextArg(XtNbottom, XtChainTop);
1370 NextArg(XtNleft, XtChainLeft);
1371 NextArg(XtNright, XtChainLeft);
1372 NextArg(XtNleftBitmap, menu_arrow);
1373 preview_panel = XtCreateManagedWidget("preview", menuButtonWidgetClass,
1374 export_panel, Args, ArgCount);
1375 make_pulldown_menu(preview_items, XtNumber(preview_items), -1, "",
1376 preview_panel, preview_select);
1377 /* end preview */
1378
1379 /*************************************************************/
1380 /* Put the Bitmap export options in their own frame. */
1381 /* Don't manage it unless the export language is bitmap type */
1382 /*************************************************************/
1383
1384 FirstArg(XtNborderWidth, 0);
1385 NextArg(XtNfromVert, top_section);
1386 NextArg(XtNtop, XtChainTop);
1387 NextArg(XtNbottom, XtChainTop);
1388 NextArg(XtNleft, XtChainLeft);
1389 NextArg(XtNright, XtChainLeft);
1390 bitmap_form = XtCreateWidget("bitmap_form", formWidgetClass,
1391 export_panel, Args, ArgCount);
1392 /* now a label */
1393 FirstArg(XtNlabel, "Bitmap Options");
1394 NextArg(XtNborderWidth, 0);
1395 NextArg(XtNtop, XtChainTop);
1396 NextArg(XtNbottom, XtChainTop);
1397 NextArg(XtNleft, XtChainLeft);
1398 NextArg(XtNright, XtChainLeft);
1399 below = XtCreateManagedWidget("bitmap_label", labelWidgetClass,
1400 bitmap_form, Args, ArgCount);
1401
1402 /* Label for smoothing options */
1403 FirstArg(XtNlabel, "Smoothing");
1404 NextArg(XtNfromVert, below);
1405 NextArg(XtNborderWidth, 0);
1406 NextArg(XtNtop, XtChainTop);
1407 NextArg(XtNbottom, XtChainTop);
1408 NextArg(XtNleft, XtChainLeft);
1409 NextArg(XtNright, XtChainLeft);
1410 smooth_lab = XtCreateManagedWidget("smooth_label", labelWidgetClass,
1411 bitmap_form, Args, ArgCount);
1412
1413 /* make a pulldown menu for smooth (No smoothing=1, Some=2, More=4) */
1414 FirstArg(XtNlabel, smooth_choices[appres.smooth_factor==1? 0: appres.smooth_factor/2]);
1415 NextArg(XtNfromVert, below);
1416 NextArg(XtNfromHoriz, smooth_lab);
1417 NextArg(XtNborderWidth, INTERNAL_BW);
1418 NextArg(XtNtop, XtChainTop);
1419 NextArg(XtNbottom, XtChainTop);
1420 NextArg(XtNleft, XtChainLeft);
1421 NextArg(XtNright, XtChainLeft);
1422 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1423 smooth_menu_button = XtCreateManagedWidget("smooth_factor",
1424 menuButtonWidgetClass,
1425 bitmap_form, Args, ArgCount);
1426 make_pulldown_menu(smooth_choices, XtNumber(smooth_choices),
1427 -1, "", smooth_menu_button, smooth_select);
1428
1429 /* transparent color option for GIF export */
1430
1431 FirstArg(XtNlabel, "GIF Transparent color");
1432 NextArg(XtNfromVert, below);
1433 NextArg(XtNfromHoriz, smooth_menu_button);
1434 NextArg(XtNborderWidth, 0);
1435 NextArg(XtNtop, XtChainTop);
1436 NextArg(XtNbottom, XtChainTop);
1437 NextArg(XtNleft, XtChainLeft);
1438 NextArg(XtNright, XtChainLeft);
1439 transp_lab = XtCreateManagedWidget("transp_label", labelWidgetClass,
1440 bitmap_form, Args, ArgCount);
1441
1442 FirstArg(XtNfromVert, below);
1443 NextArg(XtNfromHoriz, transp_lab);
1444 NextArg(XtNresize, False);
1445 NextArg(XtNwidth, 80);
1446 NextArg(XtNborderWidth, INTERNAL_BW);
1447 NextArg(XtNtop, XtChainTop);
1448 NextArg(XtNbottom, XtChainTop);
1449 NextArg(XtNleft, XtChainLeft);
1450 export_transp_panel = XtCreateManagedWidget("transparent",
1451 menuButtonWidgetClass,
1452 bitmap_form, Args, ArgCount);
1453 /* now set the color and name in the button */
1454 set_but_col(export_transp_panel, appres.transparent);
1455
1456 transp_menu = make_color_popup_menu(export_transp_panel,
1457 "Transparent Color", transp_select,
1458 INCL_TRANSP, NO_BACKG);
1459
1460 /* image quality option for JPEG export */
1461
1462 /* first label */
1463 FirstArg(XtNlabel, "JPEG Image quality (%)");
1464 NextArg(XtNfromVert, below);
1465 NextArg(XtNfromHoriz, smooth_menu_button);
1466 NextArg(XtNborderWidth, 0);
1467 NextArg(XtNtop, XtChainTop);
1468 NextArg(XtNbottom, XtChainTop);
1469 NextArg(XtNleft, XtChainLeft);
1470 NextArg(XtNright, XtChainLeft);
1471 quality_lab = XtCreateManagedWidget("quality_label", labelWidgetClass,
1472 bitmap_form, Args, ArgCount);
1473
1474 /* spinner entry for quality */
1475 sprintf(buf,"%d",appres.jpeg_quality);
1476 quality_spinner = MakeIntSpinnerEntry(bitmap_form, &quality_text, "quality_text",
1477 below, quality_lab, (XtCallbackProc) 0, buf, 0, 100, 1, 30);
1478 FirstArg(XtNtop, XtChainTop);
1479 NextArg(XtNbottom, XtChainTop);
1480 NextArg(XtNleft, XtChainLeft);
1481 NextArg(XtNright, XtChainLeft);
1482 SetValues(quality_spinner);
1483
1484 /***** End of Bitmap Option form *****/
1485
1486 /**************************************************************/
1487 /* Put the PostScript/HPGL options in their own frame (form). */
1488 /* Don't manage it unless the export language is PS/HPGL type */
1489 /**************************************************************/
1490
1491 FirstArg(XtNborderWidth, 0);
1492 NextArg(XtNfromVert, top_section);
1493 NextArg(XtNtop, XtChainTop);
1494 NextArg(XtNbottom, XtChainTop);
1495 NextArg(XtNleft, XtChainLeft);
1496 NextArg(XtNright, XtChainLeft);
1497 postscript_form = XtCreateWidget("postscript_form", formWidgetClass,
1498 export_panel, Args, ArgCount);
1499 /* now a label */
1500 /* FirstArg(XtNlabel, "PostScript Options");
1501 NextArg(XtNborderWidth, 0);
1502 NextArg(XtNtop, XtChainTop);
1503 NextArg(XtNbottom, XtChainTop);
1504 NextArg(XtNleft, XtChainLeft);
1505 NextArg(XtNright, XtChainLeft);
1506 below = ps_form_label = XtCreateManagedWidget("postscript_label", labelWidgetClass,
1507 postscript_form, Args, ArgCount);
1508 */
1509 /* paper size */
1510 FirstArg(XtNlabel, " Paper Size");
1511 // NextArg(XtNfromVert, below);
1512 NextArg(XtNborderWidth, 0);
1513 NextArg(XtNtop, XtChainTop);
1514 NextArg(XtNbottom, XtChainTop);
1515 NextArg(XtNleft, XtChainLeft);
1516 NextArg(XtNright, XtChainLeft);
1517 papersize_lab = XtCreateManagedWidget("papersize_label", labelWidgetClass,
1518 postscript_form, Args, ArgCount);
1519
1520 FirstArg(XtNlabel, paper_sizes[appres.papersize].fname);
1521 // NextArg(XtNfromVert, below);
1522 NextArg(XtNfromHoriz, papersize_lab);
1523 NextArg(XtNborderWidth, INTERNAL_BW);
1524 NextArg(XtNresizable, True);
1525 NextArg(XtNtop, XtChainTop);
1526 NextArg(XtNbottom, XtChainTop);
1527 NextArg(XtNleft, XtChainLeft);
1528 NextArg(XtNright, XtChainLeft);
1529 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1530 export_papersize_panel = XtCreateManagedWidget("papersize",
1531 menuButtonWidgetClass,
1532 postscript_form, Args, ArgCount);
1533
1534 /* make the menu items */
1535 papersize_menu = XtCreatePopupShell("menu", simpleMenuWidgetClass,
1536 export_papersize_panel, NULL, ZERO);
1537 for (i = 0; i < XtNumber(paper_sizes); i++) {
1538 entry = XtCreateManagedWidget(paper_sizes[i].fname, smeBSBObjectClass,
1539 papersize_menu, NULL, ZERO);
1540 XtAddCallback(entry, XtNcallback, papersize_select, (XtPointer) i);
1541 }
1542
1543 /* Fit Page */
1544
1545 FirstArg(XtNlabel, "Fit to Page");
1546 // NextArg(XtNfromVert, below);
1547 NextArg(XtNfromHoriz, export_papersize_panel);
1548 NextArg(XtNhorizDistance, 9);
1549 NextArg(XtNborderWidth, INTERNAL_BW);
1550 NextArg(XtNtop, XtChainTop);
1551 NextArg(XtNbottom, XtChainTop);
1552 NextArg(XtNleft, XtChainLeft);
1553 NextArg(XtNright, XtChainLeft);
1554 fitpage = XtCreateManagedWidget("fitpage", commandWidgetClass,
1555 postscript_form, Args, ArgCount);
1556 XtAddEventHandler(fitpage, ButtonReleaseMask, False,
1557 (XtEventHandler)fit_page, (XtPointer) NULL);
1558
1559 /* Landscape/Portrait Orientation */
1560
1561 FirstArg(XtNlabel, "Orientation");
1562 NextArg(XtNfromVert, export_papersize_panel);
1563 NextArg(XtNborderWidth, 0);
1564 NextArg(XtNtop, XtChainTop);
1565 NextArg(XtNbottom, XtChainTop);
1566 NextArg(XtNleft, XtChainLeft);
1567 NextArg(XtNright, XtChainLeft);
1568 orient_lab = XtCreateManagedWidget("orient_label", labelWidgetClass,
1569 postscript_form, Args, ArgCount);
1570
1571 FirstArg(XtNlabel, orient_items[appres.landscape]);
1572 NextArg(XtNfromVert, export_papersize_panel);
1573 NextArg(XtNfromHoriz, orient_lab);
1574 NextArg(XtNborderWidth, INTERNAL_BW);
1575 NextArg(XtNtop, XtChainTop);
1576 NextArg(XtNbottom, XtChainTop);
1577 NextArg(XtNleft, XtChainLeft);
1578 NextArg(XtNright, XtChainLeft);
1579 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1580 export_orient_panel = XtCreateManagedWidget("orientation",
1581 menuButtonWidgetClass,
1582 postscript_form, Args, ArgCount);
1583 make_pulldown_menu(orient_items, XtNumber(orient_items), -1, "",
1584 export_orient_panel, orient_select);
1585 /* Justification */
1586
1587 FirstArg(XtNlabel, "Justification");
1588 NextArg(XtNfromVert, export_papersize_panel);
1589 NextArg(XtNfromHoriz, export_orient_panel);
1590 NextArg(XtNborderWidth, 0);
1591 NextArg(XtNtop, XtChainTop);
1592 NextArg(XtNbottom, XtChainTop);
1593 NextArg(XtNleft, XtChainLeft);
1594 NextArg(XtNright, XtChainLeft);
1595 just_lab = XtCreateManagedWidget("just_label", labelWidgetClass,
1596 postscript_form, Args, ArgCount);
1597
1598 FirstArg(XtNlabel, just_items[appres.flushleft? 1 : 0]);
1599 NextArg(XtNfromVert, export_papersize_panel);
1600 NextArg(XtNfromHoriz, just_lab);
1601 NextArg(XtNborderWidth, INTERNAL_BW);
1602 NextArg(XtNtop, XtChainTop);
1603 NextArg(XtNbottom, XtChainTop);
1604 NextArg(XtNleft, XtChainLeft);
1605 NextArg(XtNright, XtChainLeft);
1606 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1607 export_just_panel = XtCreateManagedWidget("justify",
1608 menuButtonWidgetClass,
1609 postscript_form, Args, ArgCount);
1610 make_pulldown_menu(just_items, XtNumber(just_items), -1, "",
1611 export_just_panel, just_select);
1612
1613 /* multiple/single page */
1614
1615 FirstArg(XtNlabel, " Pages");
1616 NextArg(XtNfromVert, export_orient_panel);
1617 NextArg(XtNborderWidth, 0);
1618 NextArg(XtNtop, XtChainTop);
1619 NextArg(XtNbottom, XtChainTop);
1620 NextArg(XtNleft, XtChainLeft);
1621 NextArg(XtNright, XtChainLeft);
1622 multiple_lab = XtCreateManagedWidget("multiple_label", labelWidgetClass,
1623 postscript_form, Args, ArgCount);
1624
1625 FirstArg(XtNlabel, multiple_pages[appres.multiple? 1:0]);
1626 NextArg(XtNfromVert, export_orient_panel);
1627 NextArg(XtNfromHoriz, multiple_lab);
1628 NextArg(XtNborderWidth, INTERNAL_BW);
1629 NextArg(XtNtop, XtChainTop);
1630 NextArg(XtNbottom, XtChainTop);
1631 NextArg(XtNleft, XtChainLeft);
1632 NextArg(XtNright, XtChainLeft);
1633 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1634 export_multiple_panel = XtCreateManagedWidget("multiple_pages",
1635 menuButtonWidgetClass,
1636 postscript_form, Args, ArgCount);
1637 make_pulldown_menu(multiple_pages, XtNumber(multiple_pages),
1638 -1, "", export_multiple_panel, multiple_select);
1639
1640 /* overlap/no-overlap for multiple page selection */
1641
1642 FirstArg(XtNlabel, overlap_pages[appres.overlap? 1:0]);
1643 NextArg(XtNfromVert, export_orient_panel);
1644 NextArg(XtNfromHoriz, export_multiple_panel);
1645 NextArg(XtNborderWidth, INTERNAL_BW);
1646 NextArg(XtNtop, XtChainTop);
1647 NextArg(XtNbottom, XtChainTop);
1648 NextArg(XtNleft, XtChainLeft);
1649 NextArg(XtNright, XtChainLeft);
1650 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1651 export_overlap_panel = XtCreateManagedWidget("overlap_pages",
1652 menuButtonWidgetClass,
1653 postscript_form, Args, ArgCount);
1654 make_pulldown_menu(overlap_pages, XtNumber(overlap_pages),
1655 -1, "", export_overlap_panel, overlap_select);
1656
1657 /* X/Y offset choices */
1658
1659 FirstArg(XtNlabel, " Offset");
1660 NextArg(XtNfromVert, export_multiple_panel);
1661 NextArg(XtNborderWidth, 0);
1662 NextArg(XtNtop, XtChainTop);
1663 NextArg(XtNbottom, XtChainTop);
1664 NextArg(XtNleft, XtChainLeft);
1665 NextArg(XtNright, XtChainLeft);
1666 exp_off_lab = XtCreateManagedWidget("export_offset_label", labelWidgetClass,
1667 postscript_form, Args, ArgCount);
1668 FirstArg(XtNlabel, "X");
1669 NextArg(XtNfromVert, export_multiple_panel);
1670 NextArg(XtNfromHoriz, exp_off_lab);
1671 NextArg(XtNhorizDistance, 5);
1672 NextArg(XtNborderWidth, 1);
1673 NextArg(XtNtop, XtChainTop);
1674 NextArg(XtNbottom, XtChainTop);
1675 NextArg(XtNleft, XtChainLeft);
1676 NextArg(XtNright, XtChainLeft);
1677 exp_xoff_lab = XtCreateManagedWidget("export_offset_lbl_x", labelWidgetClass,
1678 postscript_form, Args, ArgCount);
1679 FirstArg(XtNwidth, 50);
1680 NextArg(XtNleftMargin, 4);
1681 NextArg(XtNeditType, XawtextEdit);
1682 NextArg(XtNstring, "0.0");
1683 NextArg(XtNinsertPosition, 0);
1684 NextArg(XtNfromHoriz, exp_xoff_lab);
1685 NextArg(XtNfromVert, export_multiple_panel);
1686 NextArg(XtNborderWidth, INTERNAL_BW);
1687 NextArg(XtNscrollHorizontal, XawtextScrollWhenNeeded);
1688 NextArg(XtNtop, XtChainTop);
1689 NextArg(XtNbottom, XtChainTop);
1690 NextArg(XtNleft, XtChainLeft);
1691 NextArg(XtNright, XtChainLeft);
1692 export_offset_x = XtCreateManagedWidget("export_offset_x", asciiTextWidgetClass,
1693 postscript_form, Args, ArgCount);
1694 FirstArg(XtNfromHoriz, export_offset_x);
1695 NextArg(XtNfromVert, export_multiple_panel);
1696 NextArg(XtNborderWidth, INTERNAL_BW);
1697 NextArg(XtNtop, XtChainTop);
1698 NextArg(XtNbottom, XtChainTop);
1699 NextArg(XtNleft, XtChainLeft);
1700 NextArg(XtNright, XtChainLeft);
1701 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1702 exp_xoff_unit_panel = XtCreateManagedWidget(offset_unit_items[appres.INCHES? 0: 1],
1703 menuButtonWidgetClass, postscript_form, Args, ArgCount);
1704 make_pulldown_menu(offset_unit_items, XtNumber(offset_unit_items),
1705 -1, "", exp_xoff_unit_panel, exp_xoff_unit_select);
1706
1707 FirstArg(XtNlabel, "Y");
1708 NextArg(XtNfromHoriz, exp_xoff_unit_panel);
1709 NextArg(XtNhorizDistance, 10);
1710 NextArg(XtNfromVert, export_multiple_panel);
1711 NextArg(XtNborderWidth, 1);
1712 NextArg(XtNtop, XtChainTop);
1713 NextArg(XtNbottom, XtChainTop);
1714 NextArg(XtNleft, XtChainLeft);
1715 NextArg(XtNright, XtChainLeft);
1716 exp_yoff_lab = XtCreateManagedWidget("export_offset_lbl_y", labelWidgetClass,
1717 postscript_form, Args, ArgCount);
1718 FirstArg(XtNwidth, 50);
1719 NextArg(XtNleftMargin, 4);
1720 NextArg(XtNeditType, XawtextEdit);
1721 NextArg(XtNstring, "0.0");
1722 NextArg(XtNinsertPosition, 0);
1723 NextArg(XtNfromHoriz, exp_yoff_lab);
1724 NextArg(XtNfromVert, export_multiple_panel);
1725 NextArg(XtNborderWidth, INTERNAL_BW);
1726 NextArg(XtNscrollHorizontal, XawtextScrollWhenNeeded);
1727 NextArg(XtNtop, XtChainTop);
1728 NextArg(XtNbottom, XtChainTop);
1729 NextArg(XtNleft, XtChainLeft);
1730 NextArg(XtNright, XtChainLeft);
1731 export_offset_y = XtCreateManagedWidget("export_offset_y", asciiTextWidgetClass,
1732 postscript_form, Args, ArgCount);
1733 FirstArg(XtNfromHoriz, export_offset_y);
1734 NextArg(XtNfromVert, export_multiple_panel);
1735 NextArg(XtNborderWidth, INTERNAL_BW);
1736 NextArg(XtNtop, XtChainTop);
1737 NextArg(XtNbottom, XtChainTop);
1738 NextArg(XtNleft, XtChainLeft);
1739 NextArg(XtNright, XtChainLeft);
1740 NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
1741 exp_yoff_unit_panel = XtCreateManagedWidget(offset_unit_items[appres.INCHES? 0: 1],
1742 menuButtonWidgetClass, postscript_form, Args, ArgCount);
1743 make_pulldown_menu(offset_unit_items, XtNumber(offset_unit_items),
1744 -1, "", exp_yoff_unit_panel, exp_yoff_unit_select);
1745
1746
1747 /* (HPGL) PCL output option */
1748 FirstArg(XtNlabel, "Issue PCL Command to use HPGL"); /* Label */
1749 NextArg(XtNborderWidth, 0);
1750 NextArg(XtNfromVert, exp_off_lab);
1751 NextArg(XtNtop, XtChainTop);
1752 NextArg(XtNbottom, XtChainTop);
1753 NextArg(XtNleft, XtChainLeft);
1754 NextArg(XtNright, XtChainLeft);
1755 pcl_cmd_label = XtCreateManagedWidget("pcl_cmd_label",
1756 labelWidgetClass,
1757 postscript_form, Args, ArgCount);
1758
1759 /* (HPGL) checkbox for including PCL switch */
1760 FirstArg(XtNbitmap, (print_hpgl_pcl_switch
1761 ? sm_check_pm : sm_null_check_pm));
1762 NextArg(XtNfromVert, exp_off_lab);
1763 NextArg(XtNfromHoriz, pcl_cmd_label);
1764 NextArg(XtNtop, XtChainTop);
1765 NextArg(XtNbottom, XtChainTop);
1766 NextArg(XtNleft, XtChainLeft);
1767 NextArg(XtNright, XtChainLeft);
1768 NextArg(XtNinternalWidth, 1);
1769 NextArg(XtNinternalHeight, 1);
1770 NextArg(XtNlabel, " ");
1771 NextArg(XtNstate, print_hpgl_pcl_switch); /* initial state */
1772 pcl_cmd_checkbox = XtCreateManagedWidget("pcl_cmd_checkbox",
1773 toggleWidgetClass, postscript_form, Args, ArgCount);
1774 XtAddCallback(pcl_cmd_checkbox, XtNcallback,
1775 (XtCallbackProc)toggle_hpgl_pcl_switch, (XtPointer) NULL);
1776
1777 /* (HPGL) Use 'SD' font command */
1778 FirstArg(XtNlabel, "Use Specified Font"); /* Label */
1779 NextArg(XtNborderWidth, 0);
1780 NextArg(XtNfromVert, exp_off_lab);
1781 NextArg(XtNfromHoriz, pcl_cmd_checkbox);
1782 NextArg(XtNtop, XtChainTop);
1783 NextArg(XtNbottom, XtChainTop);
1784 NextArg(XtNleft, XtChainLeft);
1785 NextArg(XtNright, XtChainLeft);
1786 hpgl_font_label = XtCreateManagedWidget("hpgl_font_label",
1787 labelWidgetClass, postscript_form, Args, ArgCount);
1788
1789 /* (HPGL) checkbox to use 'SD' font command */
1790 FirstArg(XtNbitmap, (hpgl_specified_font
1791 ? sm_check_pm : sm_null_check_pm));
1792 NextArg(XtNfromVert, exp_off_lab);
1793 NextArg(XtNfromHoriz, hpgl_font_label);
1794 NextArg(XtNtop, XtChainTop);
1795 NextArg(XtNbottom, XtChainTop);
1796 NextArg(XtNleft, XtChainLeft);
1797 NextArg(XtNright, XtChainLeft);
1798 NextArg(XtNinternalWidth, 1);
1799 NextArg(XtNinternalHeight, 1);
1800 NextArg(XtNlabel, " ");
1801 NextArg(XtNstate, hpgl_specified_font); /* initial state */
1802 hpgl_font_checkbox = XtCreateManagedWidget("hpgl_font_checkbox",
1803 toggleWidgetClass, postscript_form, Args, ArgCount);
1804 XtAddCallback(hpgl_font_checkbox, XtNcallback,
1805 (XtCallbackProc)toggle_hpgl_font, (XtPointer) NULL);
1806
1807
1808 /***** End of PostScript/HPGL Option form *****/
1809
1810 /* now manage either the PostScript form, the Bitmap form or neither */
1811 if (cur_exp_lang == LANG_PS || cur_exp_lang == LANG_PDF) {
1812 XtManageChild(postscript_form);
1813 below = postscript_form;
1814 if (pdf_pagemode || cur_exp_lang == LANG_PS)
1815 XtSetSensitive(postscript_form, True);
1816 else
1817 XtSetSensitive(postscript_form, False);
1818 } else if (cur_exp_lang >= FIRST_BITMAP_LANG) {
1819 XtManageChild(bitmap_form);
1820 below = bitmap_form;
1821 } else {
1822 below = top_section;
1823 }
1824
1825
1826 /* now make a lower section form so we can manage/unmanage it when
1827 * the middle section (options) changes */
1828
1829 FirstArg(XtNborderWidth, 0);
1830 NextArg(XtNfromVert, below);
1831 NextArg(XtNtop, XtChainTop);
1832 NextArg(XtNbottom, XtChainBottom);
1833 NextArg(XtNleft, XtChainLeft);
1834 NextArg(XtNright, XtChainRight);
1835 bottom_section = XtCreateWidget("bottom_section",
1836 formWidgetClass,
1837 export_panel, Args, ArgCount);
1838 /* next the default file name */
1839
1840 FirstArg(XtNlabel, " Default File");
1841 NextArg(XtNborderWidth, 0);
1842 NextArg(XtNtop, XtChainTop);
1843 NextArg(XtNbottom, XtChainTop);
1844 NextArg(XtNleft, XtChainLeft);
1845 NextArg(XtNright, XtChainLeft);
1846 dfile_lab = XtCreateManagedWidget("def_file_label", labelWidgetClass,
1847 bottom_section, Args, ArgCount);
1848
1849 FirstArg(XtNlabel, default_export_file);
1850 NextArg(XtNfromHoriz, dfile_lab);
1851 NextArg(XtNborderWidth, 0);
1852 NextArg(XtNtop, XtChainTop);
1853 NextArg(XtNbottom, XtChainTop);
1854 NextArg(XtNleft, XtChainLeft);
1855 NextArg(XtNright, XtChainRight);
1856 dfile_text = XtCreateManagedWidget("def_file_name", labelWidgetClass,
1857 bottom_section, Args, ArgCount);
1858
1859 FirstArg(XtNlabel, " Output File");
1860 NextArg(XtNfromVert, dfile_text);
1861 NextArg(XtNborderWidth, 0);
1862 NextArg(XtNtop, XtChainTop);
1863 NextArg(XtNbottom, XtChainTop);
1864 NextArg(XtNleft, XtChainLeft);
1865 NextArg(XtNright, XtChainLeft);
1866 nfile_lab = XtCreateManagedWidget("out_file_name", labelWidgetClass,
1867 bottom_section, Args, ArgCount);
1868
1869 FirstArg(XtNfont, &temp_font);
1870 GetValues(nfile_lab);
1871
1872 FirstArg(XtNwidth, E_FILE_WIDTH);
1873 NextArg(XtNleftMargin, 4);
1874 NextArg(XtNheight, max_char_height(temp_font) * 2 + 4);
1875 NextArg(XtNfromHoriz, nfile_lab);
1876 NextArg(XtNfromVert, dfile_text);
1877 NextArg(XtNeditType, XawtextEdit);
1878 NextArg(XtNborderWidth, INTERNAL_BW);
1879 NextArg(XtNstring, named_file);
1880 NextArg(XtNinsertPosition, strlen(named_file));
1881 NextArg(XtNscrollHorizontal, XawtextScrollWhenNeeded);
1882 NextArg(XtNtop, XtChainTop);
1883 NextArg(XtNbottom, XtChainTop);
1884 NextArg(XtNleft, XtChainLeft);
1885 NextArg(XtNright, XtChainRight);
1886 exp_selfile = XtCreateManagedWidget("file", asciiTextWidgetClass,
1887 bottom_section, Args, ArgCount);
1888 XtOverrideTranslations(exp_selfile,
1889 XtParseTranslationTable(export_translations));
1890
1891 /* add action to export file for following translation */
1892 XtAppAddActions(tool_app, file_name_actions, XtNumber(file_name_actions));
1893
1894 /* make <return> in the filename window export the file */
1895 XtOverrideTranslations(exp_selfile,
1896 XtParseTranslationTable(file_name_translations));
1897
1898 /* create the directory widgets */
1899 change_directory(cur_export_dir);
1900 strcpy(save_export_dir, cur_file_dir);
1901 create_dirinfo(False, bottom_section, exp_selfile, &beside, &below,
1902 &exp_mask, &exp_dir, &exp_flist, &exp_dlist, E_FILE_WIDTH, False);
1903 /* make <return> or double click in the file list window export the file */
1904 XtOverrideTranslations(exp_flist,
1905 XtParseTranslationTable(file_list_translations));
1906
1907 /* cancel button */
1908 FirstArg(XtNlabel, "Cancel");
1909 NextArg(XtNfromHoriz, beside);
1910 NextArg(XtNhorizDistance, 25);
1911 NextArg(XtNfromVert, below);
1912 NextArg(XtNvertDistance, 15);
1913 NextArg(XtNheight, 25);
1914 NextArg(XtNborderWidth, INTERNAL_BW);
1915 NextArg(XtNtop, XtChainBottom);
1916 NextArg(XtNbottom, XtChainBottom);
1917 NextArg(XtNleft, XtChainLeft);
1918 NextArg(XtNright, XtChainLeft);
1919 cancel_but = XtCreateManagedWidget("cancel", commandWidgetClass,
1920 bottom_section, Args, ArgCount);
1921 XtAddEventHandler(cancel_but, ButtonReleaseMask, False,
1922 (XtEventHandler) export_panel_cancel, (XtPointer) NULL);
1923
1924 FirstArg(XtNlabel, "Export");
1925 NextArg(XtNfromHoriz, cancel_but);
1926 NextArg(XtNhorizDistance, 25);
1927 NextArg(XtNfromVert, below);
1928 NextArg(XtNvertDistance, 15);
1929 NextArg(XtNheight, 25);
1930 NextArg(XtNborderWidth, INTERNAL_BW);
1931 NextArg(XtNtop, XtChainBottom);
1932 NextArg(XtNbottom, XtChainBottom);
1933 NextArg(XtNleft, XtChainLeft);
1934 NextArg(XtNright, XtChainLeft);
1935 export_but = XtCreateManagedWidget("export", commandWidgetClass,
1936 bottom_section, Args, ArgCount);
1937 XtAddEventHandler(export_but, ButtonReleaseMask, False,
1938 (XtEventHandler)do_export, (XtPointer) NULL);
1939
1940 /* install accelerators for cancel, and export in the main panel */
1941 XtInstallAccelerators(export_panel, cancel_but);
1942 XtInstallAccelerators(export_panel, export_but);
1943
1944 update_def_filename();
1945 /* set the initial wildcard mask based on the current export language */
1946 set_export_mask(cur_exp_lang);
1947 }
1948
1949 /* update the default export filename using the Fig file name */
1950
update_def_filename(void)1951 void update_def_filename(void)
1952 {
1953 int i;
1954
1955 /* copy Fig filename to export filename without path */
1956 strcpy(default_export_file, xf_basename(cur_filename));
1957 if (default_export_file[0] != '\0') {
1958 i = strlen(default_export_file);
1959 if (i >= 4 && strcmp(&default_export_file[i - 4], ".fig") == 0)
1960 default_export_file[i - 4] = '\0';
1961
1962 /* for tiff and jpeg use three-letter suffixes */
1963 if (cur_exp_lang == LANG_TIFF)
1964 strcat(default_export_file, ".tif");
1965 else if (cur_exp_lang == LANG_JPEG)
1966 strcat(default_export_file, ".jpg");
1967 else if (cur_exp_lang==LANG_PDFTEX)
1968 /* for pdftex, just use .pdf */
1969 strcat(default_export_file, ".pdf");
1970 else if (cur_exp_lang==LANG_PSPDF)
1971 /* for pspdf, start with just .eps */
1972 strcat(default_export_file, ".eps");
1973 else {
1974 strcat(default_export_file, ".");
1975 strcat(default_export_file, lang_items[cur_exp_lang]);
1976 }
1977 }
1978 /* remove trailing blanks */
1979 for (i = strlen(default_export_file) - 1; i >= 0; i--)
1980 if (default_export_file[i] == ' ')
1981 default_export_file[i] = '\0';
1982 else
1983 i = 0;
1984 }
1985