/****************************************************************
...
*****************************************************************/
void popup_rates_dialog(void)
{
Position x, y;
Dimension width, height;
char buf[64];
if (!can_client_issue_orders()) {
return;
}
XtSetSensitive(main_form, FALSE);
create_rates_dialog();
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(rates_dialog_shell, XtNx, x, XtNy, y, NULL);
my_snprintf(buf, sizeof(buf), _("%s max rate: %d%%"),
government_name_for_player(client.conn.playing),
get_player_bonus(client.conn.playing, EFT_MAX_RATES));
xaw_set_label(rates_gov_label, buf);
XtPopup(rates_dialog_shell, XtGrabNone);
}
void
continue_prompt (int interrupt_seen)
{
Widget dialog;
Arg args[10];
Position x, y;
char msg[256];
if (continue_popup != NULL)
XtDestroyWidget (continue_popup);
XtTranslateCoords (breakpointButton, (Position) 0, (Position) 0, &x, &y);
XtSetArg (args[0], XtNx, x);
XtSetArg (args[1], XtNy, y);
continue_popup = XtCreatePopupShell ("prompt", transientShellWidgetClass,
breakpointButton, args, TWO);
XtAddCallback (continue_popup, XtNdestroyCallback,
continue_prompt_destroyed, (XtPointer) 0);
if (interrupt_seen)
sprintf (msg, "execution interrupt at 0x%08x", PC);
else
sprintf (msg, "breakpoint encountered at 0x%08x", PC);
XtSetArg (args[0], XtNlabel, msg);
dialog = XtCreateManagedWidget ("continue", dialogWidgetClass,
continue_popup, args, ONE);
XawDialogAddButton (dialog, "continue", continue_action,
(XtPointer) dialog);
XawDialogAddButton (dialog, "abort command", destroy_popup_prompt,
(XtPointer) dialog);
confirmAction = continue_action;
XtPopup (continue_popup, XtGrabNone);
}
/****************************************************************
...
*****************************************************************/
static void spy_steal_popup(Widget w, XtPointer client_data,
XtPointer call_data)
{
struct city *pvcity = game_city_by_number(diplomat_target_id);
struct player *pvictim = NULL;
if(pvcity)
pvictim = city_owner(pvcity);
/* it is concievable that pvcity will not be found, because something
has happened to the city during latency. Therefore we must initialize
pvictim to NULL and account for !pvictim in create_advances_list. -- Syela */
destroy_message_dialog(w);
diplomat_dialog = NULL;
if(!spy_tech_shell){
Position x, y;
Dimension width, height;
spy_tech_shell_is_modal=1;
create_advances_list(client.conn.playing, pvictim, spy_tech_shell_is_modal);
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(spy_tech_shell, XtNx, x, XtNy, y, NULL);
XtPopup(spy_tech_shell, XtGrabNone);
}
}
void
fontpane_popup(int *psfont_adr, int *latexfont_adr, int *psflag_adr, void (*showfont_fn) (/* ??? */), Widget show_widget)
{
DeclareArgs(2);
Position xposn, yposn;
Widget widg;
font_ps_sel = psfont_adr;
font_latex_sel = latexfont_adr;
flag_sel = psflag_adr;
font_setimage = showfont_fn;
font_widget = show_widget;
if (first_fontmenu) {
first_fontmenu = False; /* don't reposition it if user has already popped it */
XtTranslateCoords(tool, CANVAS_WD/4, CANVAS_HT/4, &xposn, &yposn);
FirstArg(XtNx, xposn); /* position about 1/4 from upper-left corner of canvas */
NextArg(XtNy, yposn);
SetValues(ps_fontmenu);
SetValues(latex_fontmenu);
}
widg = *flag_sel ? ps_fontmenu : latex_fontmenu;
XtPopup(widg, XtGrabExclusive);
/* if the file message window is up add it to the grab */
file_msg_add_grab();
/* insure that the most recent colormap is installed */
set_cmap(XtWindow(widg));
XSetWMProtocols(tool_d, XtWindow(widg), &wm_delete_window, 1);
}
/**************************************************************************
...
**************************************************************************/
void main_show_info_popup(XEvent *event)
{
XButtonEvent *ev = (XButtonEvent *)event;
if (ev->button == Button1) {
Widget p;
Position x, y;
Dimension w, h;
p = XtCreatePopupShell("popupinfo",
overrideShellWidgetClass,
info_command, NULL, 0);
XtAddCallback(p, XtNpopdownCallback, destroy_me_callback, NULL);
XtVaCreateManagedWidget("fullinfopopuplabel",
labelWidgetClass,
p,
XtNlabel, get_info_label_text_popup(),
NULL);
XtRealizeWidget(p);
XtVaGetValues(p, XtNwidth, &w, XtNheight, &h, NULL);
XtTranslateCoords(info_command, ev->x, ev->y, &x, &y);
XtVaSetValues(p, XtNx, MAX(0, x - w / 2), XtNy, MAX(0, y - h / 2), NULL);
XtPopupSpringLoaded(p);
}
}
/* This makes sure the submenu is fully visible. */
static void position_submenu(Widget w, Widget parent)
{
Position parent_x, parent_y, my_x, my_y;
Dimension parent_width, my_width, my_height;
int foo;
unsigned int root_width, root_height, ufoo;
Window foowin;
/* Make sure the widget is realized--otherwise, we get 0 as width and
height. */
XtRealizeWidget(w);
XtVaGetValues(parent, XtNx, &parent_x, XtNy, &parent_y, XtNwidth, &parent_width, NULL);
XtVaGetValues(w, XtNwidth, &my_width, XtNheight, &my_height, NULL);
XtTranslateCoords(XtParent(parent), parent_x, parent_y, &parent_x, &parent_y);
my_x = parent_x + parent_width - 2;
my_y = parent_y + 1;
XGetGeometry(my_display, RootWindow(my_display, my_screen), &foowin, &foo, &foo, &root_width, &root_height, &ufoo, &ufoo);
if (my_x + my_width > (int)root_width) {
my_x -= my_width + parent_width - 2;
}
if (my_y + my_height > (int) root_height) {
my_y = root_height - my_height;
}
XtVaSetValues(w, XtNx, my_x, XtNy, my_y, NULL);
XtPopup(w, XtGrabNonexclusive);
}
static void
quit_prompt (Widget button, XtPointer client_data, XtPointer call_data)
{
Widget parent, dialog;
Arg args[10];
Position x, y;
if (quit_popup == NULL)
{
parent = XtParent (button);
XtTranslateCoords (button, (Position) 0, (Position) 0, &x, &y);
XtSetArg (args[0], XtNx, x);
XtSetArg (args[1], XtNy, y);
quit_popup = XtCreatePopupShell ("prompt", transientShellWidgetClass,
parent, args, TWO);
XtAddCallback (quit_popup, XtNdestroyCallback, quit_prompt_destroyed,
(XtPointer) 0);
XtSetArg (args[0], XtNlabel, "quit?");
dialog = XtCreateManagedWidget ("quit", dialogWidgetClass, quit_popup,
args, ONE);
XawDialogAddButton (dialog, "quit", quit_action, (XtPointer) dialog);
XawDialogAddButton (dialog, "abort command", destroy_popup_prompt,
(XtPointer) dialog);
}
confirmAction = quit_action;
XtPopup (quit_popup, XtGrabNone);
}
EIF_INTEGER xt_real_y (EIF_POINTER a_widget)
{
/* Y screen-relative coordinates of a widget */
Position root_x, root_y;
XtTranslateCoords ((Widget) a_widget, 0, 0, &root_x, &root_y);
return (EIF_INTEGER) root_y;
}
void
launch_about(Widget w, XtPointer closure, XtPointer call_data)
{
DeclareArgs(10);
Widget form, icon, ok;
Position x, y;
char info[400];
/* turn off Compose key LED */
setCompLED(0);
/* don't make more than one */
if (!help_popup) {
/* get the position of the help button */
XtTranslateCoords(w, (Position) 0, (Position) 0, &x, &y);
FirstArg(XtNx, x);
NextArg(XtNy, y);
help_popup = XtCreatePopupShell("About Xfig",transientShellWidgetClass,
tool, Args, ArgCount);
XtOverrideTranslations(help_popup,
XtParseTranslationTable(about_translations));
XtAppAddActions(tool_app, about_actions, XtNumber(about_actions));
FirstArg(XtNborderWidth, 0);
form = XtCreateManagedWidget("help_form", formWidgetClass, help_popup,
Args, ArgCount);
/* put the xfig icon in a label and another label saying which version this is */
FirstArg(XtNbitmap, fig_icon);
NextArg(XtNinternalHeight, 0);
NextArg(XtNinternalWidth, 0);
NextArg(XtNborderWidth, 0);
icon = XtCreateManagedWidget("xfig_icon", labelWidgetClass, form, Args, ArgCount);
/* make up some information */
strcpy(info,xfig_version);
strcat(info,"\n Parts Copyright \251 1989-2013 by Brian V. Smith ([email protected])");
strcat(info,"\n Parts Copyright \251 1991 by Paul King");
strcat(info,"\n Copyright \251 1985-1988 by Supoj Sutanthavibul");
strcat(info,"\n See source files and man pages for other copyrights");
FirstArg(XtNlabel, info);
NextArg(XtNfromHoriz, icon);
NextArg(XtNhorizDistance, 20);
NextArg(XtNborderWidth, 0);
XtCreateManagedWidget("xfig_icon", labelWidgetClass, form, Args, ArgCount);
FirstArg(XtNlabel, " Ok ");
NextArg(XtNwidth, 50);
NextArg(XtNheight, 30);
NextArg(XtNfromVert, icon);
NextArg(XtNvertDistance, 20);
ok = XtCreateManagedWidget("help_ok", commandWidgetClass, form, Args, ArgCount);
XtAddCallback(ok, XtNcallback, help_ok, (XtPointer) NULL);
}
XtPopup(help_popup,XtGrabNone);
(void) XSetWMProtocols(tool_d, XtWindow(help_popup), &wm_delete_window, 1);
}
/**************************************************************************
...
**************************************************************************/
void xaw_set_relative_position(Widget ref, Widget w, int px, int py)
{
Position x, y;
Dimension width, height;
XtVaGetValues(ref, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(ref, (Position) px*width/100, (Position) py*height/100, &x, &y);
XtVaSetValues(w, XtNx, x, XtNy, y, NULL);
}
static void
MakePrompt(Widget centerw, const char *prompt,
MakePromptFunc func, const char *def)
{
static Arg dialogArgs[] = {
{XtNlabel, 0},
{XtNvalue, 0},
};
Arg valueArgs[1];
Arg centerArgs[2];
Position source_x, source_y;
Position dest_x, dest_y;
Dimension center_width, center_height;
Dimension prompt_width, prompt_height;
Widget valueWidget;
CancelAction ((Widget)NULL, (XEvent *) 0, (String *) 0, (Cardinal *) 0);
promptShell = XtCreatePopupShell ("promptShell", transientShellWidgetClass,
toplevel, NULL, (Cardinal) 0);
dialogArgs[0].value = (XtArgVal)prompt;
dialogArgs[1].value = (XtArgVal)def;
promptDialog = XtCreateManagedWidget( "promptDialog", dialogWidgetClass,
promptShell, dialogArgs, XtNumber (dialogArgs));
XawDialogAddButton(promptDialog, "accept", NULL, (XtPointer) 0);
XawDialogAddButton(promptDialog, "cancel", NULL, (XtPointer) 0);
valueWidget = XtNameToWidget (promptDialog, "value");
if (valueWidget) {
XtSetArg (valueArgs[0], (String)XtNresizable, TRUE);
XtSetValues (valueWidget, valueArgs, 1);
/*
* as resizable isn't set until just above, the
* default value will be displayed incorrectly.
* rectify the situation by resetting the values
*/
XtSetValues (promptDialog, dialogArgs, XtNumber (dialogArgs));
}
XtSetKeyboardFocus (promptDialog, valueWidget);
XtSetKeyboardFocus (toplevel, valueWidget);
XtRealizeWidget (promptShell);
/*
* place the widget in the center of the "parent"
*/
XtSetArg (centerArgs[0], XtNwidth, ¢er_width);
XtSetArg (centerArgs[1], XtNheight, ¢er_height);
XtGetValues (centerw, centerArgs, 2);
XtSetArg (centerArgs[0], XtNwidth, &prompt_width);
XtSetArg (centerArgs[1], XtNheight, &prompt_height);
XtGetValues (promptShell, centerArgs, 2);
source_x = (center_width - prompt_width) / 2;
source_y = (center_height - prompt_height) / 3;
XtTranslateCoords (centerw, source_x, source_y, &dest_x, &dest_y);
XtSetArg (centerArgs[0], XtNx, dest_x);
XtSetArg (centerArgs[1], XtNy, dest_y);
XtSetValues (promptShell, centerArgs, 2);
XtMapWidget(promptShell);
promptfunction = func;
}
/***********************************************************************
* Event Handler to forward ConfigureNotify events to the client windows
***********************************************************************/
static void
StructureNotifyHandler (
Widget widget,
XtPointer client_data,
XEvent* event,
Boolean* cont)
{
PluginInstance* This = (PluginInstance*) client_data;
#ifdef PLUGIN_TRACE
fprintf (stderr, "%s\n", "StructureNotifyHandler");
#endif
switch (event->type) {
/*
* For the testplugin, which uses a ScrolledWindow, the clipped
* window, i.e. This->plugin, is "configured" when the user pans
* around the ScrolledWindow. The Netscape scrolled-window is
* different. It moves-and-resizes the clip window, causing the
* child, i.e. This->plugin, to be "dragged" up by win-gravity.
*/
case ConfigureNotify:
case GravityNotify:
if (This->plugin_widget == NULL)
return;
{
int i;
Position x, y;
XConfigureEvent sendev;
XtTranslateCoords (This->plugin_widget, 0, 0, &x, &y);
for (i = 0; i < This->nclient_windows; i++) {
sendev.type = ConfigureNotify;
sendev.send_event = True;
sendev.event = sendev.window = This->client_windows[i].win;
sendev.x = x + This->client_windows[i].x;
sendev.y = y + This->client_windows[i].y;
sendev.width = This->client_windows[i].width;
sendev.height = This->client_windows[i].height;
sendev.border_width = This->client_windows[i].border_width;
sendev.above = None;
sendev.override_redirect = False;
if (!XSendEvent (RxGlobal.dpy, This->client_windows[i].win,
False, StructureNotifyMask,
(XEvent*) &sendev))
(void) fprintf (stderr, "%s\n", "XSendEvent Failed");
}
}
break;
default:
break;
}
}
/****************************************************************
Parameters after named parameters should be in triplets:
- callback, callback_data, fixed_width
*****************************************************************/
Widget popup_message_dialog(Widget parent, const char *dialogname,
const char *text, ...)
{
va_list args;
Widget dshell, dform, button;
Position x, y;
Dimension width, height;
void (*fcb)(Widget, XtPointer, XtPointer);
XtPointer client_data;
char button_name[512];
int i, fixed_width;
XtSetSensitive(parent, FALSE);
I_T(dshell=XtCreatePopupShell(dialogname, transientShellWidgetClass,
parent, NULL, 0));
dform=XtVaCreateManagedWidget("dform", formWidgetClass, dshell, NULL);
/* caller should i18n text as desired */
XtVaCreateManagedWidget("dlabel", labelWidgetClass, dform,
XtNlabel, (XtArgVal)text,
NULL);
i=0;
va_start(args, text);
while((fcb=((void(*)(Widget, XtPointer, XtPointer))(va_arg(args, void *))))) {
client_data=va_arg(args, XtPointer);
fixed_width=va_arg(args, int);
fc_snprintf(button_name, sizeof(button_name), "button%d", i++);
button=XtVaCreateManagedWidget(button_name, commandWidgetClass,
dform, NULL);
if (fixed_width) {
I_LW(button);
} else {
I_L(button);
}
XtAddCallback(button, XtNcallback, fcb, client_data);
}
va_end(args);
XtVaGetValues(parent, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(parent, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(dshell, XtNx, x, XtNy, y, NULL);
XtPopup(dshell, XtGrabNone);
return dshell;
}
void wxToolBarTimer::Notify()
{
Position x, y;
/************************************************************/
/* Create shell without window decorations */
/************************************************************/
help_popup = XtVaCreatePopupShell ("shell",
overrideShellWidgetClass, (Widget) wxTheApp->GetTopLevelWidget(),
NULL);
/************************************************************/
/* Get absolute position on display of toolbar button */
/************************************************************/
XtTranslateCoords (buttonWidget,
(Position) 0,
(Position) 0,
&x, &y);
// Move the tooltip more or less above the button
int yOffset = 20; // TODO: What should be really?
y = (Position)(y - yOffset);
if (y < yOffset) y = 0;
/************************************************************/
/* Set the position of the help popup */
/************************************************************/
XtVaSetValues (help_popup,
XmNx, (Position) x,
XmNy, (Position) y,
NULL);
/************************************************************/
/* Create help label */
/************************************************************/
XmString text = XmStringCreateSimple ((char*) (const char*) helpString);
XtVaCreateManagedWidget ("help_label",
xmLabelWidgetClass, help_popup,
XmNlabelString, text,
XtVaTypedArg,
XmNforeground, XtRString, "black",
strlen("black")+1,
XtVaTypedArg,
XmNbackground, XtRString, "LightGoldenrod",
strlen("LightGoldenrod")+1,
NULL);
XmStringFree (text);
/************************************************************/
/* Popup help label */
/************************************************************/
XtPopup (help_popup, XtGrabNone);
}
static void
CenterWidgetOnWidget(Widget w, Widget wT)
{
Position rootX, rootY;
Dimension width, height;
Arg args[2];
XtSetArg (args[0], XtNwidth, &width);
XtSetArg (args[1], XtNheight, &height);
XtGetValues (wT, args, 2);
XtTranslateCoords (wT, (Position) width/2, (Position) height/2, &rootX, &rootY);
CenterWidgetAtPoint (w, (int) rootX, (int) rootY);
}
/****************************************************************
popup the dialog 10% inside the main-window
*****************************************************************/
void popup_diplomacy_dialog(struct player *plr0, struct player *plr1)
{
Position x, y;
Dimension width, height;
struct Diplomacy_dialog *pdialog;
if(!(pdialog=find_diplomacy_dialog(plr0, plr1))) {
pdialog=create_diplomacy_dialog(plr0, plr1);
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(pdialog->dip_dialog_shell, XtNx, x, XtNy, y, NULL);
}
XtPopup(pdialog->dip_dialog_shell, XtGrabNone);
}
/*----------------------------------------------------------------------*/
/* extern */ Position
XfeRootY(Widget w)
{
Position root_y;
assert( _XfeIsAlive(w) );
if (!_XfeIsAlive(w))
{
return 0;
}
XtTranslateCoords(w,0,0,NULL,&root_y);
return root_y;
}
/****************************************************************
...
*****************************************************************/
void popup_rates_dialog(void)
{
Position x, y;
Dimension width, height;
XtSetSensitive(main_form, FALSE);
create_rates_dialog();
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(rates_dialog_shell, XtNx, x, XtNy, y, NULL);
XtPopup(rates_dialog_shell, XtGrabNone);
}
void
x_message (Widget parent, string s, ArgList args, Cardinal n_args)
{
Dimension parent_height;
Position popup_x, popup_y;
Widget popup;
XtAppContext app_con = XtWidgetToApplicationContext (parent);
Arg parent_args[]
= { { XtNheight, (XtArgVal) &parent_height },
};
Arg popup_args[]
= { { XtNx, 0 }, /* We assign to the position below. */
{ XtNy, 0 },
{ XtNgeometry, NULL }, /* Don't use the parent's geometry. */
};
Arg default_args[] = { { XtNlabel, (XtArgVal) s } };
ArgList all_args
= XtMergeArgLists (args, n_args, default_args, XtNumber (default_args));
/* Put the message at the left edge of and about halfway down PARENT's
window. We pass the address of true Position variables rather
than the address of the Arg values; in the latter case, the
endianness of the computer determines which half of the word the
answers get stored in, which is clearly bad. */
XtGetValues (parent, parent_args, XtNumber (parent_args));
XtTranslateCoords (parent, 0, parent_height / 2, &popup_x, &popup_y);
popup_args[0].value = popup_x;
popup_args[1].value = popup_y;
popup = XtCreatePopupShell ("message shell", transientShellWidgetClass,
parent, popup_args, XtNumber (popup_args));
/* We can't use XtNumber on `all_args', since it's a pointer. */
(void)
XtCreateManagedWidget ("message", labelWidgetClass, popup, all_args,
n_args + XtNumber (default_args));
/* XtPopup realizes the window, etc. */
XtPopup (popup, XtGrabNone);
/* Leave the message there for five seconds. */
(void) XtAppAddTimeOut (app_con, 5000, message_over, popup);
}
/**************************************************************************
Pops-up the Spy sabotage dialog, upon return of list of
available improvements requested by the above function.
**************************************************************************/
void popup_sabotage_dialog(struct city *pcity)
{
if(!spy_sabotage_shell){
Position x, y;
Dimension width, height;
spy_sabotage_shell_is_modal=1;
create_improvements_list(client.conn.playing, pcity, spy_sabotage_shell_is_modal);
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(spy_sabotage_shell, XtNx, x, XtNy, y, NULL);
XtPopup(spy_sabotage_shell, XtGrabNone);
}
}
AjusterPositionForme(Widget w, Widget wp)
{
Position i,x,y,wWidth,wHeight, wpWidth, wpHeight;
Position displayWidth, displayHeight;
Arg args[4];
displayHeight = DisplayHeight(XtDisplay(w), DefaultScreen(XtDisplay(w)));
displayWidth = DisplayWidth(XtDisplay(w), DefaultScreen(XtDisplay(w)));
XtTranslateCoords(wp, 0, 0, &x, &y);
i = 0;
XtSetArg(args[i], XmNwidth, &wpWidth); i++;
XtSetArg(args[i], XmNheight,&wpHeight); i++;
XtGetValues(wp, args, i);
i = 0;
XtSetArg(args[i], XmNwidth, &wWidth); i++;
XtSetArg(args[i], XmNheight,&wHeight); i++;
XtGetValues(w, args, i);
x += (int)(wpWidth * 0.5);
y += (int)(wpHeight * 0.5);
x -= (int)(wWidth * 0.5);
y -= (int)(wHeight * 0.5);
if (x < 0)
x = 0;
if (y < 0)
y = 0;
if ((x + wWidth) > displayWidth)
x = displayWidth - wWidth;
if ((y + wHeight) > displayHeight)
y = displayHeight - wHeight;
i = 0;
XtSetArg(args[i], XmNx, x); i++;
XtSetArg(args[i], XmNy, y); i++;
XtSetValues(w, args, i);
}
/****************************************************************
popup the dialog 5% inside the main-window
*****************************************************************/
void popup_races_dialog(struct player *pplayer)
{
Position x, y;
Dimension width, height;
XtSetSensitive(main_form, FALSE);
if (!races_dialog_shell) {
create_races_dialog(pplayer);
}
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/20, (Position) height/20,
&x, &y);
XtVaSetValues(races_dialog_shell, XtNx, x, XtNy, y, NULL);
XtPopup(races_dialog_shell, XtGrabNone);
XtSetKeyboardFocus(toplevel, races_dialog_shell);
}
/*
Part fix for bug id 4017222. Return the widget at the given screen coords
by searching the widget tree beginning at root. This function will return
null if the pointer is not over the root widget or child of the root widget.
Additionally, this function will only return a Widget with non-nil XmNuserData.
In 1.2.1, when the mouse was dragged over a Choice component, this function
returned the GadgetButton associated with the Choice. This GadgetButton had
nil as its XmNuserData. This lead to a crash when the nil XmNuserData was
extracted and used as a reference to a peer. Ooops.
Now the GadgetButton is not returned and the function goes on to find a widget
which contains the correct peer reference in XmNuserData.
*/
Widget
awt_WidgetAtXY(Widget root, Position pointerx, Position pointery) {
Widget answer = NULL;
if(!root) return NULL;
if(XtIsComposite(root)) {
int32_t i=0;
WidgetList wl=NULL;
Cardinal wlen=0;
XtVaGetValues(root, XmNchildren, &wl, XmNnumChildren, &wlen, NULL);
if(wlen>0) {
for(i=0; i<wlen && !answer; i++) {
answer = awt_WidgetAtXY(wl[i], pointerx, pointery);
}
}
}
if(!answer) {
Position wx=0, wy=0;
Dimension width=0, height=0;
int32_t lastx=0, lasty=0;
XtPointer widgetUserData=NULL;
XtVaGetValues(root, XmNwidth, &width, XmNheight, &height,
XmNuserData, &widgetUserData,
NULL);
XtTranslateCoords(root, 0, 0, &wx, &wy);
lastx = wx + width;
lasty = wy + height;
if(pointerx>=wx && pointerx<=lastx && pointery>=wy && pointery<=lasty &&
widgetUserData)
answer = root;
}
return answer;
}
static void
breakpoint_prompt (Widget button, XtPointer client_data, XtPointer call_data)
{
Widget parent, dialog;
Arg args[10];
Position x, y;
if (bkpt_popup == NULL)
{
parent = XtParent (button);
XtTranslateCoords (button, (Position) 0, (Position) 0, &x, &y);
XtSetArg (args[0], XtNx, x);
XtSetArg (args[1], XtNy, y);
bkpt_popup = XtCreatePopupShell ("popup", transientShellWidgetClass,
parent, args, TWO);
if (breakpoint_addr == NULL)
breakpoint_addr = str_copy ("");
XtSetArg (args[0], XtNlabel, "address:");
XtSetArg (args[1], XtNvalue, breakpoint_addr);
dialog = XtCreateManagedWidget ("dialog", dialogWidgetClass,
bkpt_popup,
args, TWO);
XtAddCallback (bkpt_popup, XtNdestroyCallback,
breakpoint_prompt_destroyed, (XtPointer) 0);
XawDialogAddButton (dialog, "add",
add_breakpoint_action, (XtPointer) dialog);
XawDialogAddButton (dialog, "delete",
delete_breakpoint_action, (XtPointer) dialog);
XawDialogAddButton (dialog, "list",
list_breakpoint_action, (XtPointer) dialog);
XawDialogAddButton (dialog, "abort command", destroy_popup_prompt,
(XtPointer) dialog);
}
confirmAction = add_breakpoint_action;
XtPopup (bkpt_popup, XtGrabNone);
}
static void
load_prompt (Widget button, XtPointer client_data, XtPointer call_data)
{
Widget parent, dialog;
Arg args[10];
Position x, y;
if (load_popup == NULL)
{
parent = XtParent (button);
XtTranslateCoords (button, (Position) 0, (Position) 0, &x, &y);
XtSetArg (args[0], XtNx, x);
XtSetArg (args[1], XtNy, y);
load_popup = XtCreatePopupShell ("popup", transientShellWidgetClass,
parent, args, TWO);
XtAddCallback (load_popup, XtNdestroyCallback, load_prompt_destroyed,
(XtPointer) 0);
if (program_file_name == NULL)
{
program_file_name = str_copy ("");
command_line = program_file_name;
}
XtSetArg (args[0], XtNlabel, "input filename:");
XtSetArg (args[1], XtNvalue, program_file_name);
dialog = XtCreateManagedWidget ("dialog", dialogWidgetClass, load_popup,
args, TWO);
XawDialogAddButton (dialog, "assembly file", read_assm_file_action,
(XtPointer) dialog);
XawDialogAddButton (dialog, "abort command", destroy_popup_prompt,
(XtPointer) dialog);
}
confirmAction = read_assm_file_action;
XtPopup (load_popup, XtGrabNone);
}
static void
GetDefaultPosition(
Widget child,
Widget parent,
Position *xRtn,
Position *yRtn )
{
Display *disp;
int max_w, max_h;
Position x, y;
x = HALFDIFF(XtWidth(parent), XtWidth(child));
y = HALFDIFF(XtHeight(parent), XtHeight(child));
/*
* find root co-ords of the parent's center
*/
if (XtIsRealized (parent))
XtTranslateCoords(parent, x, y, &x, &y);
/*
* try to keep the popup from dribbling off the display
*/
disp = XtDisplay (child);
max_w = DisplayWidth (disp, DefaultScreen (disp));
max_h = DisplayHeight (disp, DefaultScreen (disp));
if ((x + (int)TotalWidth (child)) > max_w)
x = max_w - TotalWidth (child);
if ((y + (int)TotalHeight (child)) > max_h)
y = max_h - TotalHeight (child);
if (x < 0) x = 0;
if (y < 0) y = 0;
*xRtn = x;
*yRtn = y;
}
/****************************************************************
popup the dialog 10% inside the main-window
*****************************************************************/
void popup_goto_dialog(void)
{
Position x, y;
Dimension width, height;
Boolean no_player_cities;
if (!can_client_issue_orders() || get_num_units_in_focus() == 0) {
return;
}
no_player_cities = !(city_list_size(client.conn.playing->cities));
original_tile = get_center_tile_mapcanvas();
XtSetSensitive(main_form, FALSE);
goto_dialog_shell =
I_T(XtCreatePopupShell("gotodialog", transientShellWidgetClass,
toplevel, NULL, 0));
goto_form = XtVaCreateManagedWidget("gotoform",
formWidgetClass,
goto_dialog_shell, NULL);
goto_label =
I_L(XtVaCreateManagedWidget("gotolabel", labelWidgetClass,
goto_form, NULL));
goto_viewport = XtVaCreateManagedWidget("gotoviewport",
viewportWidgetClass,
goto_form,
NULL);
goto_list = XtVaCreateManagedWidget("gotolist",
listWidgetClass,
goto_viewport,
XtNlist,
(XtArgVal)dummy_city_list,
NULL);
goto_center_command =
I_L(XtVaCreateManagedWidget("gotocentercommand", commandWidgetClass,
goto_form, NULL));
goto_airlift_command =
I_L(XtVaCreateManagedWidget("gotoairliftcommand", commandWidgetClass,
goto_form, NULL));
goto_all_toggle =
I_L(XtVaCreateManagedWidget("gotoalltoggle", toggleWidgetClass,
goto_form,
XtNstate, no_player_cities,
XtNsensitive, !no_player_cities,
NULL));
goto_cancel_command =
I_L(XtVaCreateManagedWidget("gotocancelcommand", commandWidgetClass,
goto_form, NULL));
XtAddCallback(goto_list, XtNcallback, goto_list_callback, NULL);
XtAddCallback(goto_center_command, XtNcallback,
goto_goto_command_callback, NULL);
XtAddCallback(goto_airlift_command, XtNcallback,
goto_airlift_command_callback, NULL);
XtAddCallback(goto_all_toggle, XtNcallback,
goto_all_toggle_callback, NULL);
XtAddCallback(goto_cancel_command, XtNcallback,
goto_cancel_command_callback, NULL);
XtRealizeWidget(goto_dialog_shell);
update_goto_dialog(goto_list);
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(goto_dialog_shell, XtNx, x, XtNy, y, NULL);
XtPopup(goto_dialog_shell, XtGrabNone);
/* force refresh of viewport so the scrollbar is added.
* Buggy sun athena requires this */
XtVaSetValues(goto_viewport, XtNforceBars, True, NULL);
}
/****************************************************************
popup the dialog 10% inside the main-window
*****************************************************************/
void popup_find_dialog(void)
{
Position x, y;
Dimension width, height;
XtSetSensitive(main_form, FALSE);
find_dialog_shell = XtCreatePopupShell("finddialog",
transientShellWidgetClass,
toplevel, NULL, 0);
find_form = XtVaCreateManagedWidget("findform",
formWidgetClass,
find_dialog_shell, NULL);
find_label = XtVaCreateManagedWidget("findlabel",
labelWidgetClass,
find_form,
NULL);
find_viewport = XtVaCreateManagedWidget("findviewport",
viewportWidgetClass,
find_form,
NULL);
find_list = XtVaCreateManagedWidget("findlist",
listWidgetClass,
find_viewport,
XtNlist,
(XtArgVal)dummy_city_list,
NULL);
find_center_command = XtVaCreateManagedWidget("findcentercommand",
commandWidgetClass,
find_form,
NULL);
find_cancel_command = XtVaCreateManagedWidget("findcancelcommand",
commandWidgetClass,
find_form,
NULL);
XtAddCallback(find_center_command, XtNcallback,
find_center_command_callback, NULL);
XtAddCallback(find_cancel_command, XtNcallback,
find_cancel_command_callback, NULL);
XtRealizeWidget(find_dialog_shell);
update_find_dialog(find_list);
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(find_dialog_shell, XtNx, x, XtNy, y, NULL);
XtPopup(find_dialog_shell, XtGrabNone);
/* force refresh of viewport so the scrollbar is added.
* Buggy sun athena requires this */
XtVaSetValues(find_viewport, XtNforceBars, True, NULL);
}
/**************************************************************************
...
**************************************************************************/
static void popit(int xin, int yin, struct tile *ptile)
{
Position x, y;
int dw, dh;
Dimension w, h, b;
static struct tile *cross_list[2+1];
struct tile **cross_head = cross_list;
int i;
struct unit *punit;
char *content;
static bool is_orders;
if (TILE_UNKNOWN != client_tile_get_known(ptile)) {
Widget p=XtCreatePopupShell("popupinfo", simpleMenuWidgetClass,
map_canvas, NULL, 0);
content = (char *) popup_info_text(ptile);
/* content is provided to us as a single string with multiple lines,
but xaw doens't support multi-line labels. So we break it up.
We mangle it in the process, but who cares? It's never going to be
used again anyway. */
while (1) {
char *end = strchr(content, '\n');
if (end) {
*end='\0';
}
XtCreateManagedWidget(content, smeBSBObjectClass, p, NULL, 0);
if (end) {
content = end+1;
} else {
break;
}
}
punit = find_visible_unit(ptile);
is_orders = show_unit_orders(punit);
if (punit && punit->goto_tile) {
*cross_head = punit->goto_tile;
cross_head++;
}
*cross_head = ptile;
cross_head++;
xin /= tileset_tile_width(tileset);
xin *= tileset_tile_width(tileset);
yin /= tileset_tile_height(tileset);
yin *= tileset_tile_height(tileset);
xin += (tileset_tile_width(tileset) / 2);
XtTranslateCoords(map_canvas, xin, yin, &x, &y);
dw = XDisplayWidth (display, screen_number);
dh = XDisplayHeight (display, screen_number);
XtRealizeWidget(p);
XtVaGetValues(p, XtNwidth, &w, XtNheight, &h, XtNborderWidth, &b, NULL);
w += (2 * b);
h += (2 * b);
x -= (w / 2);
y -= h;
if ((x + w) > dw) x = dw - w;
if (x < 0) x = 0;
if ((y + h) > dh) y = dh - h;
if (y < 0) y = 0;
XtVaSetValues(p, XtNx, x, XtNy, y, NULL);
*cross_head = NULL;
for (i = 0; cross_list[i]; i++) {
put_cross_overlay_tile(cross_list[i]);
}
XtAddCallback(p,XtNpopdownCallback,popupinfo_popdown_callback,
(XtPointer)&is_orders);
XtPopupSpringLoaded(p);
}
}
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);
}
}
}
