void undo_move(void)
{
int dx, dy;
int xmin1, ymin1, xmax1, ymax1;
int xmin2, ymin2, xmax2, ymax2;
int dum;
dx = last_position.x - new_position.x;
dy = last_position.y - new_position.y;
switch (last_object) {
case O_POLYLINE:
line_bound(saved_objects.lines, &xmin1, &ymin1, &xmax1, &ymax1);
translate_line(saved_objects.lines, dx, dy);
line_bound(saved_objects.lines, &xmin2, &ymin2, &xmax2, &ymax2);
adjust_links(last_linkmode, last_links, dx, dy, 0, 0, 1.0, 1.0, False);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
break;
case O_ELLIPSE:
ellipse_bound(saved_objects.ellipses, &xmin1, &ymin1, &xmax1, &ymax1);
translate_ellipse(saved_objects.ellipses, dx, dy);
ellipse_bound(saved_objects.ellipses, &xmin2, &ymin2, &xmax2, &ymax2);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
break;
case O_TXT:
text_bound(saved_objects.texts, &xmin1, &ymin1, &xmax1, &ymax1,
&dum,&dum,&dum,&dum,&dum,&dum,&dum,&dum);
translate_text(saved_objects.texts, dx, dy);
text_bound(saved_objects.texts, &xmin2, &ymin2, &xmax2, &ymax2,
&dum,&dum,&dum,&dum,&dum,&dum,&dum,&dum);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
break;
case O_SPLINE:
spline_bound(saved_objects.splines, &xmin1, &ymin1, &xmax1, &ymax1);
translate_spline(saved_objects.splines, dx, dy);
spline_bound(saved_objects.splines, &xmin2, &ymin2, &xmax2, &ymax2);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
break;
case O_ARC:
arc_bound(saved_objects.arcs, &xmin1, &ymin1, &xmax1, &ymax1);
translate_arc(saved_objects.arcs, dx, dy);
arc_bound(saved_objects.arcs, &xmin2, &ymin2, &xmax2, &ymax2);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
break;
case O_COMPOUND:
compound_bound(saved_objects.compounds, &xmin1, &ymin1, &xmax1, &ymax1);
translate_compound(saved_objects.compounds, dx, dy);
compound_bound(saved_objects.compounds, &xmin2, &ymin2, &xmax2, &ymax2);
adjust_links(last_linkmode, last_links, dx, dy, 0, 0, 1.0, 1.0, False);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
break;
}
swap_newp_lastp();
}
void undo_scale(void)
{
float scalex, scaley;
int xmin1, ymin1, xmax1, ymax1;
int xmin2, ymin2, xmax2, ymax2;
compound_bound(saved_objects.compounds, &xmin1, &ymin1, &xmax1, &ymax1);
scalex = ((float) (last_position.x - fix_x)) / (new_position.x - fix_x);
scaley = ((float) (last_position.y - fix_y)) / (new_position.y - fix_y);
scale_compound(saved_objects.compounds, scalex, scaley, fix_x, fix_y);
compound_bound(saved_objects.compounds, &xmin2, &ymin2, &xmax2, &ymax2);
redisplay_regions(xmin1, ymin1, xmax1, ymax1,
xmin2, ymin2, xmax2, ymax2);
swap_newp_lastp();
}
static Boolean
search_text_in_compound(F_compound *com, char *pattern, void (*proc) (/* ??? */))
{
F_compound *c;
F_text *t;
Boolean match, processed;
int pat_len, i;
processed = False;
for (c = com->compounds; c != NULL; c = c->next) {
if (search_text_in_compound(c, pattern, proc))
processed = True;
}
pat_len = strlen(pattern);
for (t = com->texts; t != NULL; t = t->next) {
match = False;
if (pat_len == 0) {
match = True;
} else if (pat_len <= strlen(t->cstring)) {
for (i = 0; !match && i <= strlen(t->cstring) - pat_len; i++) {
if (compare_string(&t->cstring[i], pattern))
match = True;
}
}
if (match) {
(*proc)(t);
if (proc != show_text_object)
processed = True;
}
}
if (processed)
compound_bound(com, &com->nwcorner.x, &com->nwcorner.y,
&com->secorner.x, &com->secorner.y);
return processed;
}
/*
* pos_compound: If the position of the given compound is less
* than passed in and the compound hasn't already been distributed, adjust the
* value of the passed in parameter. Also set the width/height if smaller.
* If dir == 0, handle horizontal, otherwise vertical.
*/
static Boolean
pos_compound (F_compound *c, int *min, int *size, int dir)
{
int center;
compound_bound (c, &llx, &lly, &urx, &ury);
if (dir == 0) {
if (cur_halign == ALIGN_DISTRIB_C)
center = (urx + llx)/2;
else
center = min2(urx, llx);
} else {
if (cur_valign == ALIGN_DISTRIB_C)
center = (ury + lly)/2;
else
center = min2(ury, lly);
}
if ( (center < *min) && (c->distrib == 0) ) {
*min = center;
if (dir == 0)
*size = abs(urx - llx);
else
*size = abs(ury - lly);
return True;
} else
return False;
} /* pos_compound */
static void
init_align(F_line *p, int type, int x, int y, int px, int py)
{
if (type != O_COMPOUND)
return;
cur_c = (F_compound *) p;
toggle_compoundmarker(cur_c);
draw_compoundelements(cur_c, ERASE);
old_c = copy_compound(cur_c);
compound_bound(cur_c, &xcmin, &ycmin, &xcmax, &ycmax);
align_ellipse();
align_arc();
align_line();
align_spline();
align_compound();
align_text();
/*
* Perform the distribution of the objects in the compound
*/
if ( (cur_halign == ALIGN_DISTRIB_C) || (cur_halign == ALIGN_DISTRIB_E)
|| (cur_halign == ALIGN_ABUT) )
distribute_horizontally();
if ( (cur_valign == ALIGN_DISTRIB_C) || (cur_valign == ALIGN_DISTRIB_E)
|| (cur_valign == ALIGN_ABUT) )
distribute_vertically();
/*
* recompute the compound's bounding box
*/
compound_bound(cur_c, &cur_c->nwcorner.x, &cur_c->nwcorner.y,
&cur_c->secorner.x, &cur_c->secorner.y);
draw_compoundelements(cur_c, PAINT);
toggle_compoundmarker(cur_c);
clean_up();
old_c->next = cur_c;
set_latestcompound(old_c);
set_action_object(F_EDIT, O_COMPOUND);
set_modifiedflag();
}
static void
align_compound(void)
{
F_compound *c;
for (c = cur_c->compounds; c != NULL; c = c->next) {
if (!any_active_in_compound(c))
continue;
compound_bound(c, &llx, &lly, &urx, &ury);
get_dx_dy();
translate_compound(c, dx, dy);
}
}
void write_fig_header(FILE *fp)
{
char str[40], *com;
int i, len;
if (appres.write_v40) {
fprintf(fp, "#FIG 4.0 Produced by xfig version %s.%s\n",FIG_VERSION,PATCHLEVEL);
compound_bound(&objects, &objects.nwcorner.x, &objects.nwcorner.y,
&objects.secorner.x, &objects.secorner.y);
fprintf(fp, "Header {\n");
fprintf(fp, " Resolution %d\n", appres.INCHES? PIX_PER_INCH: PIX_PER_CM);
fprintf(fp, " Bounds %d %d %d %d\n",
objects.nwcorner.x, objects.nwcorner.y,
objects.secorner.x, objects.secorner.y);
fprintf(fp, " Orient %s\n", appres.landscape? "Landscape": "Portrait");
fprintf(fp, " Units %s\n", appres.INCHES? "Inches": "Metric");
fprintf(fp, " Uscale %.3f%s=1%s\n", appres.userscale, appres.INCHES? "in":"cm", cur_fig_units);
fprintf(fp, " Pagejust %s\n", appres.flushleft? "Flush left": "Center");
fprintf(fp, " Pagesize %s\n", paper_sizes[appres.papersize].sname);
fprintf(fp, " Pages %s\n", appres.multiple? "Multiple": "Single");
fprintf(fp, " Mag %.2f\n", appres.magnification);
get_grid_spec(str, export_grid_minor_text, export_grid_major_text);
fprintf(fp, " PGrid %s\n", str);
fprintf(fp, " SGrid %d\n", cur_gridmode);
fprintf(fp, " Smoothing %d\n", appres.smooth_factor);
fprintf(fp, " ExportBgColor %d\n", export_background_color);
fprintf(fp, " Transp %d\n", appres.transparent);
fprintf(fp, " Margin %d\n", appres.export_margin);
#ifdef DONT_SHOW_DEPTHS
if (dont_show_depths) {
fprintf(fp, " DontShowDepths {%s}\n", ......);
}
#endif /* DONT_SHOW_DEPTHS */
if (objects.comments) {
fprintf(fp, " Description {\n");
/* escape any '{' we may find in the comments */
com = objects.comments;
len = strlen(com);
for (i=0; i<len; i++) {
if (com[i] == '{')
fputc('\\', fp);
fputc(com[i], fp);
}
fprintf(fp, "\n }\n");
}
fprintf(fp, "}\n");
} else {
static void
create_compoundobject(int x, int y)
{
F_compound *c;
if ((c = create_compound()) == NULL)
return;
if (compose_compound(c) == 0) {
free((char *) c);
compound_selected();
draw_mousefun_canvas();
put_msg("Empty compound, ignored");
return;
}
/*
* Make the bounding box exactly match the dimensions of the compound.
*/
compound_bound(c, &c->nwcorner.x, &c->nwcorner.y,
&c->secorner.x, &c->secorner.y);
/* if zero width or height in the compound, adjust to next positioning
grid point or a few pixels if positioning grid is "ANY" */
if (c->nwcorner.x == c->secorner.x) {
if (cur_pointposn != P_ANY) {
c->secorner.x += posn_rnd[cur_gridunit][cur_pointposn];
c->secorner.x = ceil_coords_x(c->secorner.x,c->secorner.y);
}
}
if (c->nwcorner.y == c->secorner.y) {
if (cur_pointposn != P_ANY) {
c->secorner.y += posn_rnd[cur_gridunit][cur_pointposn];
c->secorner.y = ceil_coords_y(c->secorner.x,c->secorner.y);
}
}
c->next = NULL;
clean_up();
set_action(F_GLUE);
toggle_markers_in_compound(c);
list_add_compound(&objects.compounds, c);
mask_toggle_compoundmarker(c);
set_latestcompound(c);
set_modifiedflag();
compound_selected();
draw_mousefun_canvas();
}
static void
fit_page(void)
{
int lx,ly,ux,uy;
float wd,ht,pwd,pht;
char buf[60];
/* get current size of figure */
compound_bound(&objects, &lx, &ly, &ux, &uy);
wd = ux-lx;
ht = uy-ly;
/* if there is no figure, return now */
if (wd == 0 || ht == 0)
return;
/* get paper size minus a half inch margin all around */
pwd = paper_sizes[appres.papersize].width - PIX_PER_INCH;
pht = paper_sizes[appres.papersize].height - PIX_PER_INCH;
/* swap height and width if landscape */
if (appres.landscape) {
ux = pwd;
pwd = pht;
pht = ux;
}
/* make magnification lesser of ratio of:
page height / figure height or
page width/figure width
*/
if (pwd/wd < pht/ht)
appres.magnification = 100.0*pwd/wd;
else
appres.magnification = 100.0*pht/ht;
/* adjust for difference in real metric vs "xfig metric" */
if(!appres.INCHES)
appres.magnification *= PIX_PER_CM * 2.54/PIX_PER_INCH;
/* update the magnification widget */
sprintf(buf,"%.1f",appres.magnification);
FirstArg(XtNstring, buf);
SetValues(print_mag_text);
/* and figure size */
update_figure_size();
}
void undo_delete(void)
{
int xmin, ymin, xmax, ymax;
char ctemp[PATH_MAX];
switch (last_object) {
case O_POLYLINE:
list_add_line(&objects.lines, saved_objects.lines);
redisplay_line(saved_objects.lines);
break;
case O_ELLIPSE:
list_add_ellipse(&objects.ellipses, saved_objects.ellipses);
redisplay_ellipse(saved_objects.ellipses);
break;
case O_TXT:
list_add_text(&objects.texts, saved_objects.texts);
redisplay_text(saved_objects.texts);
break;
case O_SPLINE:
list_add_spline(&objects.splines, saved_objects.splines);
redisplay_spline(saved_objects.splines);
break;
case O_ARC:
list_add_arc(&objects.arcs, saved_objects.arcs);
redisplay_arc(saved_objects.arcs);
break;
case O_COMPOUND:
list_add_compound(&objects.compounds, saved_objects.compounds);
redisplay_compound(saved_objects.compounds);
break;
case O_ALL_OBJECT:
saved_objects.next = NULL;
compound_bound(&saved_objects, &xmin, &ymin, &xmax, &ymax);
tail(&objects, &object_tails);
append_objects(&objects, &saved_objects, &object_tails);
redisplay_zoomed_region(xmin, ymin, xmax, ymax);
}
last_action = F_ADD;
}
void create_print_panel(Widget w)
{
Widget image;
Widget entry,mag_spinner, below, fitpage;
Pixmap p;
unsigned long fg, bg;
char *printer_val;
char buf[100];
char *unit;
int ux,uy,lx,ly;
int i,len,maxl;
float mult;
XtTranslateCoords(tool, (Position) 0, (Position) 0, &xposn, &yposn);
FirstArg(XtNx, xposn+50);
NextArg(XtNy, yposn+50);
NextArg(XtNtitle, "Xfig: Print menu");
NextArg(XtNcolormap, tool_cm);
print_popup = XtCreatePopupShell("print_popup",
transientShellWidgetClass,
tool, Args, ArgCount);
XtOverrideTranslations(print_popup,
XtParseTranslationTable(prn_translations));
XtAppAddActions(tool_app, prn_actions, XtNumber(prn_actions));
print_panel = XtCreateManagedWidget("print_panel", formWidgetClass,
print_popup, NULL, ZERO);
/* start with the picture of the printer */
FirstArg(XtNlabel, " ");
NextArg(XtNwidth, printer_ic.width);
NextArg(XtNheight, printer_ic.height);
NextArg(XtNborderWidth, 0);
NextArg(XtNinternalWidth, 0);
NextArg(XtNinternalHeight, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
image = XtCreateManagedWidget("printer_image", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNforeground, &fg);
NextArg(XtNbackground, &bg);
GetValues(image);
p = XCreatePixmapFromBitmapData(tool_d, XtWindow(canvas_sw),
printer_ic.bits, printer_ic.width, printer_ic.height,
fg, bg, tool_dpth);
FirstArg(XtNbitmap, p);
SetValues(image);
FirstArg(XtNlabel, "Print to PostScript Printer");
NextArg(XtNfromHoriz, image);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
(void) XtCreateManagedWidget("print_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNlabel, " Magnification %");
NextArg(XtNfromVert, image);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("mag_label", labelWidgetClass,
print_panel, Args, ArgCount);
/* make a spinner entry for the mag */
/* note: this was called "magnification" */
sprintf(buf, "%.1f", appres.magnification);
mag_spinner = MakeFloatSpinnerEntry(print_panel, &print_mag_text, "magnification",
image, beside, update_mag, buf, 0.0, 10000.0, 1.0, 45);
/* we want to track typing here to update figure size label */
XtOverrideTranslations(print_mag_text,
XtParseTranslationTable(print_translations));
/* Fit Page to the right of the magnification window */
FirstArg(XtNlabel, "Fit to Page");
NextArg(XtNfromVert, image);
NextArg(XtNfromHoriz, mag_spinner);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
fitpage = XtCreateManagedWidget("fitpage", commandWidgetClass,
print_panel, Args, ArgCount);
XtAddEventHandler(fitpage, ButtonReleaseMask, False,
(XtEventHandler)fit_page, (XtPointer) NULL);
/* Figure Size to the right of the fit page window */
mult = appres.INCHES? PIX_PER_INCH : PIX_PER_CM;
unit = appres.INCHES? "in": "cm";
/* get the size of the figure */
compound_bound(&objects, &lx, &ly, &ux, &uy);
sprintf(buf, "Fig Size: %.1f%s x %.1f%s ",
(float)(ux-lx)/mult*appres.magnification/100.0,unit,
(float)(uy-ly)/mult*appres.magnification/100.0,unit);
FirstArg(XtNlabel, buf);
NextArg(XtNfromVert, image);
NextArg(XtNfromHoriz, fitpage);
NextArg(XtNhorizDistance, 5);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
size_lab = XtCreateManagedWidget("size_label", labelWidgetClass,
print_panel, Args, ArgCount);
/* paper size */
FirstArg(XtNlabel, " Paper Size");
NextArg(XtNborderWidth, 0);
NextArg(XtNfromVert, fitpage);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("papersize_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNlabel, paper_sizes[appres.papersize].fname);
NextArg(XtNfromHoriz, beside);
NextArg(XtNfromVert, fitpage);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNresizable, True);
NextArg(XtNrightBitmap, menu_arrow); /* use menu arrow for pull-down */
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_papersize_panel = XtCreateManagedWidget("papersize",
menuButtonWidgetClass,
print_panel, Args, ArgCount);
papersize_menu = XtCreatePopupShell("menu", simpleMenuWidgetClass,
print_papersize_panel, NULL, ZERO);
/* make the menu items */
for (i = 0; i < XtNumber(paper_sizes); i++) {
entry = XtCreateManagedWidget(paper_sizes[i].fname, smeBSBObjectClass,
papersize_menu, NULL, ZERO);
XtAddCallback(entry, XtNcallback, papersize_select, (XtPointer) i);
}
/* Orientation */
FirstArg(XtNlabel, " Orientation");
NextArg(XtNborderWidth, 0);
NextArg(XtNfromVert, print_papersize_panel);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("orient_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNfromHoriz, beside);
NextArg(XtNfromVert, print_papersize_panel);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_orient_panel = XtCreateManagedWidget(orient_items[appres.landscape],
menuButtonWidgetClass,
print_panel, Args, ArgCount);
make_pulldown_menu(orient_items, XtNumber(orient_items), -1, "",
print_orient_panel, orient_select);
FirstArg(XtNlabel, "Justification");
NextArg(XtNborderWidth, 0);
NextArg(XtNfromHoriz, print_orient_panel);
NextArg(XtNfromVert, print_papersize_panel);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
just_lab = XtCreateManagedWidget("just_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNlabel, just_items[appres.flushleft? 1 : 0]);
NextArg(XtNfromHoriz, just_lab);
NextArg(XtNfromVert, print_papersize_panel);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_just_panel = XtCreateManagedWidget("justify",
menuButtonWidgetClass,
print_panel, Args, ArgCount);
make_pulldown_menu(just_items, XtNumber(just_items), -1, "",
print_just_panel, just_select);
/* multiple/single page */
FirstArg(XtNlabel, " Pages");
NextArg(XtNborderWidth, 0);
NextArg(XtNfromVert, print_just_panel);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("multiple_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNlabel, multiple_pages[appres.multiple? 1:0]);
NextArg(XtNfromHoriz, beside);
NextArg(XtNfromVert, print_just_panel);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_multiple_panel = XtCreateManagedWidget("multiple_pages",
menuButtonWidgetClass,
print_panel, Args, ArgCount);
make_pulldown_menu(multiple_pages, XtNumber(multiple_pages), -1, "",
print_multiple_panel, multiple_select);
FirstArg(XtNlabel, overlap_pages[appres.overlap? 1:0]);
NextArg(XtNfromHoriz, print_multiple_panel);
NextArg(XtNfromVert, print_just_panel);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_overlap_panel = XtCreateManagedWidget("overlap_pages",
menuButtonWidgetClass,
print_panel, Args, ArgCount);
make_pulldown_menu(overlap_pages, XtNumber(overlap_pages), -1, "",
print_overlap_panel, overlap_select);
/* background color */
FirstArg(XtNlabel, "Background");
NextArg(XtNfromHoriz, print_overlap_panel);
NextArg(XtNfromVert, print_just_panel);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("background_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNfromHoriz, beside);
NextArg(XtNfromVert, print_just_panel);
NextArg(XtNresize, False);
NextArg(XtNwidth, 80);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_background_panel = XtCreateManagedWidget("background",
menuButtonWidgetClass,
print_panel, Args, ArgCount);
/* now set the color and name in the background button */
set_but_col(print_background_panel, export_background_color);
/* make color menu */
background_menu = make_color_popup_menu(print_background_panel,
"Background Color", background_select,
NO_TRANSP, INCL_BACKG);
/* grid options */
FirstArg(XtNlabel, " Grid");
NextArg(XtNfromVert, print_background_panel);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("grid_label", labelWidgetClass,
print_panel, Args, ArgCount);
below = make_grid_options(print_panel, print_background_panel, beside, minor_grid, major_grid,
&print_grid_minor_menu_button, &print_grid_major_menu_button,
&print_grid_minor_menu, &print_grid_major_menu,
&print_grid_minor_text, &print_grid_major_text,
&print_grid_unit_label,
print_grid_major_select, print_grid_minor_select);
/* printer name */
FirstArg(XtNlabel, " Printer");
NextArg(XtNfromVert, below);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("printer_label", labelWidgetClass,
print_panel, Args, ArgCount);
/*
* don't SetValue the XtNstring so the user may specify the default
* printer in a resource, e.g.: *printer*string: at6
*/
FirstArg(XtNwidth, 200);
NextArg(XtNleftMargin, 4);
NextArg(XtNfromVert, below);
NextArg(XtNfromHoriz, beside);
NextArg(XtNeditType, XawtextEdit);
NextArg(XtNinsertPosition, 0);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
printer_text = XtCreateManagedWidget("printer", asciiTextWidgetClass,
print_panel, Args, ArgCount);
XtOverrideTranslations(printer_text,
XtParseTranslationTable(print_translations));
/* put the printer name in the label if resource isn't set */
FirstArg(XtNstring, &printer_val);
GetValues(printer_text);
/* no printer name specified in resources, get PRINTER environment
var and put it into the widget */
if (emptyname(printer_val)) {
printer_val=getenv("PRINTER");
if ((printer_val!=NULL) && strchr(printer_val,'\\')) {
buf[0]='\0';
len=0;
for (i=0; i<strlen(printer_val); i++) {
buf[len++] = printer_val[i];
if (printer_val[i]=='\\')
buf[len++]='\\';
}
buf[len++]='\0';
printer_val = buf;
}
if (printer_val == NULL) {
printer_val = "";
} else {
FirstArg(XtNstring, printer_val);
SetValues(printer_text);
}
}
/* parse /etc/printcap for printernames for the pull-down menu */
numprinters = parse_printcap(printer_names);
/* find longest name */
maxl = 0;
for (i=0; i<numprinters; i++) {
len=strlen(printer_names[i]);
if (len > maxl) {
maxl = len;
}
}
/* make string of blanks the length of the longest printer name */
buf[0] = '\0';
for (i=0; i<maxl; i++)
strcat(buf," ");
if (numprinters > 0) {
FirstArg(XtNlabel, buf);
NextArg(XtNfromHoriz, printer_text);
NextArg(XtNfromVert, below);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNleftBitmap, menu_arrow); /* use menu arrow for pull-down */
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
printer_menu_button = XtCreateManagedWidget("printer_names",
menuButtonWidgetClass,
print_panel, Args, ArgCount);
make_pulldown_menu(printer_names, numprinters, -1, "",
printer_menu_button, printer_select);
}
FirstArg(XtNlabel, "Print Job Params");
NextArg(XtNfromVert, printer_text);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("job_params_label", labelWidgetClass,
print_panel, Args, ArgCount);
/*
* don't SetValue the XtNstring so the user may specify the default
* job parameters in a resource, e.g.: *param*string: -K2
*/
FirstArg(XtNwidth, 200);
NextArg(XtNfromVert, printer_text);
NextArg(XtNfromHoriz, beside);
NextArg(XtNeditType, XawtextEdit);
NextArg(XtNinsertPosition, 0);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
param_text = XtCreateManagedWidget("job_params", asciiTextWidgetClass,
print_panel, Args, ArgCount);
XtOverrideTranslations(param_text,
XtParseTranslationTable(print_translations));
FirstArg(XtNlabel, "Figures in batch");
NextArg(XtNfromVert, param_text);
NextArg(XtNborderWidth, 0);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
beside = XtCreateManagedWidget("num_batch_label", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNwidth, 30);
NextArg(XtNlabel, " 0");
NextArg(XtNfromVert, param_text);
NextArg(XtNfromHoriz, beside);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
num_batch = XtCreateManagedWidget("num_batch", labelWidgetClass,
print_panel, Args, ArgCount);
FirstArg(XtNlabel, "Dismiss");
NextArg(XtNfromVert, num_batch);
NextArg(XtNvertDistance, 10);
NextArg(XtNhorizDistance, 6);
NextArg(XtNheight, 35);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
dismiss = XtCreateManagedWidget("dismiss", commandWidgetClass,
print_panel, Args, ArgCount);
XtAddEventHandler(dismiss, ButtonReleaseMask, False,
(XtEventHandler)print_panel_dismiss, (XtPointer) NULL);
/* radio for printing all layers */
beside = make_layer_choice("Print all layers ", "Print only active",
print_panel, num_batch, dismiss, 6, 6);
/* print buttons */
FirstArg(XtNlabel, "Print FIGURE\nto Printer");
NextArg(XtNfromVert, num_batch);
NextArg(XtNfromHoriz, beside);
NextArg(XtNresize, False); /* must not allow resize because the label changes */
NextArg(XtNheight, 35);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNvertDistance, 10);
NextArg(XtNhorizDistance, 6);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print = XtCreateManagedWidget("print", commandWidgetClass,
print_panel, Args, ArgCount);
XtAddEventHandler(print, ButtonReleaseMask, False,
(XtEventHandler)do_print, (XtPointer) NULL);
FirstArg(XtNlabel, "Print FIGURE\nto Batch");
NextArg(XtNfromVert, num_batch);
NextArg(XtNfromHoriz, print);
NextArg(XtNheight, 35);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNvertDistance, 10);
NextArg(XtNhorizDistance, 6);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
print_batch = XtCreateManagedWidget("print_batch", commandWidgetClass,
print_panel, Args, ArgCount);
XtAddEventHandler(print_batch, ButtonReleaseMask, False,
(XtEventHandler)do_print_batch, (XtPointer) NULL);
FirstArg(XtNlabel, "Clear\nBatch");
NextArg(XtNfromVert, num_batch);
NextArg(XtNfromHoriz, print_batch);
NextArg(XtNheight, 35);
NextArg(XtNborderWidth, INTERNAL_BW);
NextArg(XtNvertDistance, 10);
NextArg(XtNhorizDistance, 6);
NextArg(XtNtop, XtChainTop);
NextArg(XtNbottom, XtChainTop);
NextArg(XtNleft, XtChainLeft);
NextArg(XtNright, XtChainLeft);
clear_batch = XtCreateManagedWidget("clear_batch", commandWidgetClass,
print_panel, Args, ArgCount);
XtAddEventHandler(clear_batch, ButtonReleaseMask, False,
(XtEventHandler)do_clear_batch, (XtPointer) NULL);
/* install accelerators for the following functions */
XtInstallAccelerators(print_panel, dismiss);
XtInstallAccelerators(print_panel, print_batch);
XtInstallAccelerators(print_panel, clear_batch);
XtInstallAccelerators(print_panel, print);
update_batch_count();
/* if multiple pages is on, desensitive justification panels */
if (appres.multiple) {
XtSetSensitive(just_lab, False);
XtSetSensitive(print_just_panel, False);
if (export_just_panel) {
XtSetSensitive(just_lab, False);
XtSetSensitive(export_just_panel, False);
}
} else {
XtSetSensitive(just_lab, True);
XtSetSensitive(print_just_panel, True);
if (export_just_panel) {
XtSetSensitive(just_lab, True);
XtSetSensitive(export_just_panel, True);
}
}
}
static Boolean
replace_text_in_compound(F_compound *com, char *pattern, char *dst)
{
F_compound *c;
F_text *t;
PR_SIZE size;
Boolean replaced, processed;
int pat_len, i, j;
char str[300];
pat_len = strlen(pattern);
if (pat_len == 0)
return False;
processed = False;
for (c = com->compounds; c != NULL; c = c->next) {
if (replace_text_in_compound(c, pattern, dst))
processed = True;
}
for (t = com->texts; t != NULL; t = t->next) {
replaced = False;
if (pat_len <= strlen(t->cstring)) {
str[0] = '\0';
j = 0;
for (i = 0; i <= strlen(t->cstring) - pat_len; i++) {
if (compare_string(&t->cstring[i], pattern)) {
if (strlen(str) + strlen(dst) < sizeof(str)) {
strncat(str, &t->cstring[j], i - j);
strcat(str, dst);
i += pat_len - 1;
j = i + 1;
replaced = True;
} else { /* string becomes too long; don't replace it */
replaced = False;
}
}
}
if (replaced && j < strlen(t->cstring)) {
if (strlen(str) + strlen(&t->cstring[j]) < sizeof(str)) {
strcat(str, &t->cstring[j]);
} else {
replaced = False;
}
}
if (replaced) { /* replace the text object */
if (strlen(t->cstring) != strlen(str)) {
free(t->cstring);
t->cstring = new_string(strlen(str));
}
strcpy(t->cstring, str);
size = textsize(lookfont(x_fontnum(psfont_text(t), t->font),
t->size), strlen(t->cstring), t->cstring);
t->ascent = size.ascent;
t->descent = size.descent;
t->length = size.length;
processed = True;
}
}
}
if (processed)
compound_bound(com, &com->nwcorner.x, &com->nwcorner.y,
&com->secorner.x, &com->secorner.y);
return processed;
}
/*
* Determine:
* - the number of objects,
* - the sum of the widths/heights of all objects,
* - the left/top most left/top object edge,
* - the right/bottom most right/bottom object edge,
* - mark all objects as not distributed.
*
* dir = 0 for horizontal, 1 for vertical.
*/
static int
init_distrib_edges (int *min, int *max, int *sum, int dir)
{
F_ellipse *e;
F_arc *a;
F_line *l;
F_spline *s;
F_compound *c;
F_text *t;
int num_objects = 0;
*min = INT_MAX;
*max = INT_MIN;
*sum = 0;
for (e = cur_c->ellipses; e != NULL; e = e->next) {
num_objects++;
e->distrib = 0;
ellipse_bound (e, &llx, &lly, &urx, &ury);
if (dir == 0) {
*sum += abs(urx - llx);
if (llx < *min) *min = llx;
if (urx > *max) *max = urx;
} else {
*sum += abs(ury - lly);
if (lly < *min) *min = lly;
if (ury > *max) *max = ury;
}
}
for (a = cur_c->arcs; a != NULL; a = a->next) {
num_objects++;
a->distrib = 0;
arc_bound (a, &llx, &lly, &urx, &ury);
if (dir == 0) {
*sum += abs(urx - llx);
if (llx < *min) *min = llx;
if (urx > *max) *max = urx;
} else {
*sum += abs(ury - lly);
if (lly < *min) *min = lly;
if (ury > *max) *max = ury;
}
}
for (l = cur_c->lines; l != NULL; l = l->next) {
num_objects++;
l->distrib = 0;
line_bound (l, &llx, &lly, &urx, &ury);
if (dir == 0) {
*sum += abs(urx - llx);
if (llx < *min) *min = llx;
if (urx > *max) *max = urx;
} else {
*sum += abs(ury - lly);
if (lly < *min) *min = lly;
if (ury > *max) *max = ury;
}
}
for (s = cur_c->splines; s != NULL; s = s->next) {
num_objects++;
s->distrib = 0;
spline_bound (s, &llx, &lly, &urx, &ury);
if (dir == 0) {
*sum += abs(urx - llx);
if (llx < *min) *min = llx;
if (urx > *max) *max = urx;
} else {
*sum += abs(ury - lly);
if (lly < *min) *min = lly;
if (ury > *max) *max = ury;
}
}
for (c = cur_c->compounds; c != NULL; c = c->next) {
num_objects++;
c->distrib = 0;
compound_bound (c, &llx, &lly, &urx, &ury);
if (dir == 0) {
*sum += abs(urx - llx);
if (llx < *min) *min = llx;
if (urx > *max) *max = urx;
} else {
*sum += abs(ury - lly);
if (lly < *min) *min = lly;
if (ury > *max) *max = ury;
}
}
for (t = cur_c->texts; t != NULL; t = t->next) {
int dum;
num_objects++;
t->distrib = 0;
text_bound (t, &llx, &lly, &urx, &ury,
&dum,&dum,&dum,&dum,&dum,&dum,&dum,&dum);
if (dir == 0) {
*sum += abs(urx - llx);
if (llx < *min) *min = llx;
if (urx > *max) *max = urx;
} else {
*sum += abs(ury - lly);
if (lly < *min) *min = lly;
if (ury > *max) *max = ury;
}
}
return (num_objects);
} /* init_distrib_edges */
/*
* Determine:
* - the number of objects,
* - the left/top most centre and the right/bottom most centre,
* - mark all objects as not distributed.
*
* dir = 0 for horizontal, 1 for vertical.
*/
static int
init_distrib_centres (int *min, int *max, int dir)
{
F_ellipse *e;
F_arc *a;
F_line *l;
F_spline *s;
F_compound *c;
F_text *t;
int num_objects = 0;
*min = INT_MAX;
*max = INT_MIN;
for (e = cur_c->ellipses; e != NULL; e = e->next) {
num_objects++;
e->distrib = 0;
ellipse_bound (e, &llx, &lly, &urx, &ury);
if (dir == 0)
MIN_MAX_CENTRE(llx, urx, *min, *max)
else
MIN_MAX_CENTRE(lly, ury, *min, *max)
}
for (a = cur_c->arcs; a != NULL; a = a->next) {
num_objects++;
a->distrib = 0;
arc_bound (a, &llx, &lly, &urx, &ury);
if (dir == 0)
MIN_MAX_CENTRE(llx, urx, *min, *max)
else
MIN_MAX_CENTRE(lly, ury, *min, *max)
}
for (l = cur_c->lines; l != NULL; l = l->next) {
num_objects++;
l->distrib = 0;
line_bound (l, &llx, &lly, &urx, &ury);
if (dir == 0)
MIN_MAX_CENTRE(llx, urx, *min, *max)
else
MIN_MAX_CENTRE(lly, ury, *min, *max)
}
for (s = cur_c->splines; s != NULL; s = s->next) {
num_objects++;
s->distrib = 0;
spline_bound (s, &llx, &lly, &urx, &ury);
if (dir == 0)
MIN_MAX_CENTRE(llx, urx, *min, *max)
else
MIN_MAX_CENTRE(lly, ury, *min, *max)
}
for (c = cur_c->compounds; c != NULL; c = c->next) {
num_objects++;
c->distrib = 0;
compound_bound (c, &llx, &lly, &urx, &ury);
if (dir == 0)
MIN_MAX_CENTRE(llx, urx, *min, *max)
else
MIN_MAX_CENTRE(lly, ury, *min, *max)
}
for (t = cur_c->texts; t != NULL; t = t->next) {
int dum;
num_objects++;
t->distrib = 0;
text_bound (t, &llx, &lly, &urx, &ury,
&dum,&dum,&dum,&dum,&dum,&dum,&dum,&dum);
if (dir == 0)
MIN_MAX_CENTRE(llx, urx, *min, *max)
else
MIN_MAX_CENTRE(lly, ury, *min, *max)
}
return (num_objects);
} /* init_distrib_centres */