void popup_message_always(char *banner, char *message) {
XmString msg_str;
int j,i;
Atom delw;
if (disable_all_popups)
return;
if (banner == NULL || message == NULL)
return;
i=0;
for (j=0; j<MAX_POPUPS; j++) {
if (!pw[j].popup_message_dialog) {
i=j;
j=MAX_POPUPS+1;
}
}
if(!pw[i].popup_message_dialog) {
if (banner!=NULL && message!=NULL) {
begin_critical_section(&popup_message_dialog_lock, "popup_gui.c:popup_message" );
pw[i].popup_message_dialog = XtVaCreatePopupShell(banner,
xmDialogShellWidgetClass, appshell,
XmNdeleteResponse, XmDESTROY,
XmNdefaultPosition, FALSE,
XmNtitleString,banner,
// An half-hearted attempt at fixing the problem where a popup
// comes up extremely small. Setting a minimum size for the popup.
XmNminWidth, 220,
XmNminHeight, 80,
XmNfontList, fontlist1,
NULL);
pw[i].pane = XtVaCreateWidget("popup_message pane",xmPanedWindowWidgetClass, pw[i].popup_message_dialog,
XmNbackground, colors[0xff],
NULL);
pw[i].form = XtVaCreateWidget("popup_message form",xmFormWidgetClass, pw[i].pane,
XmNfractionBase, 5,
XmNbackground, colors[0xff],
XmNautoUnmanage, FALSE,
XmNshadowThickness, 1,
NULL);
pw[i].popup_message_data = XtVaCreateManagedWidget("popup_message message",xmLabelWidgetClass, pw[i].form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNbackground, colors[0xff],
XmNfontList, fontlist1,
NULL);
pw[i].button_close = XtVaCreateManagedWidget(langcode("UNIOP00003"),xmPushButtonGadgetClass, pw[i].form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, pw[i].popup_message_data,
XmNtopOffset, 10,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 2,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 3,
XmNbackground, colors[0xff],
XmNfontList, fontlist1,
NULL);
sprintf(pw[i].name,"%d",i);
msg_str=XmStringCreateLtoR(message,XmFONTLIST_DEFAULT_TAG);
XtVaSetValues(pw[i].popup_message_data,XmNlabelString,msg_str,NULL);
XmStringFree(msg_str);
XtAddCallback(pw[i].button_close, XmNactivateCallback, popup_message_destroy_shell,(XtPointer)pw[i].name);
delw = XmInternAtom(XtDisplay(pw[i].popup_message_dialog),"WM_DELETE_WINDOW", FALSE);
XmAddWMProtocolCallback(pw[i].popup_message_dialog, delw, popup_message_destroy_shell, (XtPointer)pw[i].name);
pos_dialog(pw[i].popup_message_dialog);
XtManageChild(pw[i].form);
XtManageChild(pw[i].pane);
end_critical_section(&popup_message_dialog_lock, "popup_gui.c:popup_message" );
XtPopup(pw[i].popup_message_dialog,XtGrabNone);
// An half-hearted attempt at fixing the problem where a popup
// comes up extremely small. Commenting out the below so we can
// change the size if necessary to read the message.
// fix_dialog_size(pw[i].popup_message_dialog);
pw[i].sec_opened=sec_now();
}
}
}
void
PopupPopup(Widget parent, Widget popup, Bool transient, Bool first_time,
int offset_x, int offset_y, String delAction)
{
if (!transient && !first_time)
{
/*
* For non-transient windows, if this isn't the first time
* it's being popped up, just pop it up in the old position.
*/
XtPopup (popup, XtGrabNone);
return;
}
else
{
Position parent_x, parent_y;
Position root_x, root_y;
Position popup_x, popup_y;
Dimension parent_width, parent_height, parent_border;
Dimension popup_width, popup_height, popup_border;
char geom[16];
Bool repos = 0;
/*
* The window we pop up must be visible on the screen. We first
* try to position it at the desired location (relative to the
* parent widget). Once we are able to compute the popup's
* geometry (after it's realized), we can determine if we need
* to reposition it.
*/
XtVaGetValues (parent,
XtNx, &parent_x,
XtNy, &parent_y,
XtNwidth, &parent_width,
XtNheight, &parent_height,
XtNborderWidth, &parent_border,
NULL);
XtTranslateCoords (parent, parent_x, parent_y, &root_x, &root_y);
popup_x = root_x + offset_x;
popup_y = root_y + offset_y;
if (transient)
{
XtVaSetValues (popup,
XtNx, popup_x,
XtNy, popup_y,
NULL);
}
else
{
sprintf (geom, "+%d+%d", popup_x, popup_y);
XtVaSetValues (popup,
XtNgeometry, geom,
NULL);
}
if (first_time)
{
/*
* Realize it for the first time
*/
XtRealizeWidget (popup);
/*
* Set support for WM_DELETE_WINDOW
*/
(void) SetWM_DELETE_WINDOW (popup, delAction);
}
/*
* Now make sure it's visible.
*/
XtVaGetValues (popup,
XtNwidth, &popup_width,
XtNheight, &popup_height,
XtNborderWidth, &popup_border,
NULL);
popup_border <<= 1;
if ((int) (popup_x + popup_width + popup_border) >
WidthOfScreen (XtScreen (topLevel)))
{
popup_x = WidthOfScreen (XtScreen (topLevel)) -
popup_width - popup_border - parent_width - parent_border;
repos = 1;
}
if ((int) (popup_y + popup_height + popup_border) >
HeightOfScreen (XtScreen (topLevel)))
{
popup_y = HeightOfScreen (XtScreen (topLevel)) -
popup_height - popup_border - parent_height - parent_border;
repos = 1;
}
if (repos)
{
if (transient)
{
XtVaSetValues (popup,
XtNx, popup_x,
XtNy, popup_y,
NULL);
}
else
{
/*
* The only way we can reposition a non-transient
* is by unrealizing it, setting the position, then
* doing a realize.
*/
XtUnrealizeWidget (popup);
sprintf (geom, "+%d+%d", popup_x, popup_y);
XtVaSetValues (popup,
XtNgeometry, geom,
NULL);
XtRealizeWidget (popup);
(void) SetWM_DELETE_WINDOW (popup, delAction);
}
}
XtPopup (popup, XtGrabNone);
}
}
Widget CreateDialog(Widget parent, char *msg, char *deft,
char **buttons, int buttcnt,
XtCallbackProc dialogCB,
int DialType)
/*-
this routine merely creates a dialog, it dosn't manage it, or wait for a
response. Note: these dialogs are NOT auto-unmanaging.
parent: The parent of the dialog.
msg: message for the dialog to display.
deft: the default return string for prompt dialogs.
buttons: array of null-terminated button names.
the first one is the default button.
buttcnt: the number of elements in buttons.
dialogCB: a callback that is to be called when any button is pressed.
the button number is passed to the routine as client_data.
-1 is passed for the to dialogCB if the cancelCallback of the
dialog is invoked.
DialType: one of
XmDIALOG_ERROR,
XmDIALOG_WARNING,
XmDIALOG_MESSAGE,
XmDIALOG_QUESTION,
XmDIALOG_WORKING.
-*/
{
Arg args[10];
XmString xmstr[5], xmstr2;
Widget dial, button, w, DefaultButton;
int i, n;
/* make the dialog box */
n = 0;
XtSetArg(args[n], XmNautoUnmanage, FALSE); n++;
dial = XmCreateMessageDialog(parent, "GXDialog", args, n);
xmstr[0] = XmStringCreateLtoR(msg, XmFONTLIST_DEFAULT_TAG);
if (deft)
xmstr[1] = XmStringCreateLtoR(deft, XmFONTLIST_DEFAULT_TAG);
else
xmstr[1] = XmStringCreateLtoR("\0", XmFONTLIST_DEFAULT_TAG);
xmstr[2] = XmStringCreateLtoR("test10", XmFONTLIST_DEFAULT_TAG);
/* create buttons */
DefaultButton = NULL;
for (i = 0; i < buttcnt; i++) {
n = 0;
xmstr2 = XmStringCreateLtoR(buttons[i], XmFONTLIST_DEFAULT_TAG);
XtSetArg(args[n], XmNlabelString, xmstr2);
n++;
button = XmCreatePushButton(dial, "button", args, n);
XtAddCallback(button, XmNactivateCallback,
(XtCallbackProc) dialogCB, (XtPointer) i);
XtManageChild(button);
if (!DefaultButton)
DefaultButton = button;
XmStringFree(xmstr2);
}
XtVaSetValues(dial,
XmNmessageString, xmstr[0],
XmNdialogType, DialType,
XmNdialogTitle, xmstr[2],
XmNdefaultButton, DefaultButton,
NULL);
if (dialogCB)
XtAddCallback(dial, XmNcancelCallback, (XtCallbackProc) dialogCB,
(XtPointer) - 1);
/* unmanage default buttons */
w=XmMessageBoxGetChild(dial, XmDIALOG_OK_BUTTON);
if (w)
XtUnmanageChild(w);
w=XmMessageBoxGetChild(dial, XmDIALOG_HELP_BUTTON);
if (w)
XtUnmanageChild(w);
w=XmMessageBoxGetChild(dial, XmDIALOG_CANCEL_BUTTON);
if (w) {
printf("Destroying cancel button %p\n",w);
XtDestroyWidget(w);
}
XtManageChild(dial);
XmStringFree(xmstr[0]);
XmStringFree(xmstr[1]);
XmStringFree(xmstr[2]);
return (dial);
}
/*
** DisplayHistogram
*/
VBoolean
DisplayHistogram(float *histo,VLong nvals,VRepnKind repn,double xmin,double xmax,
double average,double sigma)
{
VImage image;
int nbands = 1;
int i,nrows,ncols;
int r0,c0,xlen,ylen;
int margin = 40;
int right_margin = 40;
int xstep,ystep,modu1,modu2;
int ymax;
int r1,r2,c1;
char str[80];
float nels,imax,u,d;
Widget widget;
imax = 0;
nels = 0;
for (i=0; i<nvals; i++) {
if (histo[i] > imax) imax = i;
nels += histo[i];
}
ymax = 0;
for (i=0; i<nvals; i++) {
histo[i] = (histo[i] * 100.0) / nels;
if (histo[i] > ymax) ymax = (int) histo[i];
}
ymax += 2;
/* get display size */
ncols = 4 * nvals + margin + right_margin;
if (ncols > WIDTH)
ncols = 3 * nvals + margin + right_margin;
if (ncols > WIDTH)
ncols = 2 * nvals + margin + right_margin;
if (ncols > WIDTH)
ncols = nvals + margin + right_margin;
if (ncols < WIDTH) ncols= WIDTH;
nrows = 512;
widget = VXGetApplicationShell();
XtVaSetValues(widget,XmNwidth,ncols + 100,XmNheight,nrows + 50,NULL);
/* Display a white background image: */
image = VCreateImage(nbands,nrows,ncols,VBitRepn);
if (!image) VError("Error creating image");
VFillImage(image,VAllBands,1);
VXClearLines ();
sprintf(str,"mean: %g sigma: %g\n",average,sigma);
VXDisplayMessage (TRUE,str);
VXSetImage (image, 0, 1.0, 0, 0);
/* set style */
VXSetLineColor("black");
VXSetTextColor("black");
/*
VXSetTextFont("times_roman10");
*/
r0 = nrows - margin; /* origin of coordinate axes */
c0 = margin;
xlen = ncols - margin - right_margin; /* length of x axis */
ylen = nrows - margin - right_margin; /* length of y axis */
xstep = xlen / nvals; /* tics on x-axis */
ystep = ylen / ymax; /* tics on y-axis */
/*
** x-axis
*/
VXDrawLine(r0,c0-10,r0,c0 + xlen);
r1 = r0;
c1 = c0;
if (xstep == 2) modu1 = 20;
else if (xstep == 1) modu1 = 50;
else modu1 = 10;
if (xstep >= 3)
modu2 = 1;
else
modu2 = 5;
if (nvals == 256) modu1 = 20;
else modu1 = 20;
d = xmax - xmin;
for (i=0; i<nvals; i++) {
VXDrawLine(r1,c1,r1+8,c1);
u = xmin + (float)i * (xmax - xmin)/(float)(nvals-1);
if (nvals != 256) {
if (d < 0.01) sprintf(str,"%.3f",u);
else if (d < 1) sprintf(str,"%.3f",u);
else if (d < 11) sprintf(str,"%.3f",u);
else if (d < 110) sprintf(str,"%.2f",u);
else if (d < 501) sprintf(str,"%.0f",u);
else if (d < 1010) sprintf(str,"%.0f",u);
else sprintf(str,"%.0f",u);
}
else
sprintf(str,"%.0f",u);
VXDrawLine(r1,c1,r1+4,c1);
if (i%modu1 == 0)
VXDrawText(str,r1+25,c1-5);
c1 += xstep;
}
/*
** y axis
*/
VXDrawLine(r0+10,c0,r0 - ylen,c0);
r1 = r0;
c1 = c0;
if (ymax < 30) {
modu1 = 5;
modu2 = 1;
}
else {
modu1 = 10;
modu2 = 2;
}
for (i=0; i<=ymax; i++) {
if (i % modu1 == 0) {
VXDrawLine(r1,c1-8,r1,c1);
sprintf(str,"%d",i);
VXDrawText(str,r1+5,c1-30);
}
else if (i % modu2 == 0) {
VXDrawLine(r1,c1-4,r1,c1);
}
r1 -= ystep;
}
VXDrawText("% ",r1 + ystep / 2,c1-25);
/*
** draw histogram
*/
VXSetLineWidth((double) 2.0);
r1 = r0;
c1 = c0;
for (i=0; i<nvals; i++) {
r2 = r1 - histo[i] * ystep;
VXDrawLine(r1,c1,r2,c1);
c1 += xstep;
}
return TRUE;
}
int MwDialogInputIcon(Widget pw, char *title,
char *prompt, char *buffr, Pixmap icon)
{
XtAppContext app_context = XtWidgetToApplicationContext(pw);
String string;
static int init_done = 0;
status = MW_WAITING;
if (!init_done) {
XpmAttributes xpm_attr;
static XpmColorSymbol none_color = { NULL, "None", (Pixel)0 };
xpm_attr.valuemask = XpmReturnPixels|XpmColorSymbols;
xpm_attr.colorsymbols = &none_color;
xpm_attr.numsymbols = 1;
XtVaGetValues(pw,
XtNbackground, &none_color.pixel,
(char *)0);
XpmCreatePixmapFromData(XtDisplay(pw),
DefaultRootWindow(XtDisplay(pw)),
unknown_xpm, &default_icon, NULL, &xpm_attr);
XtAppAddActions(app_context, actions, XtNumber(actions));
init_done = 1;
}
pshell = XtVaCreatePopupShell("pshell",
transientShellWidgetClass, pw,
XtNtitle, _("Dialog"),
(char *)0);
dialog = XtVaCreateManagedWidget("dialog",
formWidgetClass, pshell,
(char *)0);
dialogIcon = XtVaCreateManagedWidget("dialogIcon",
labelWidgetClass, dialog,
XtNleft, XtChainLeft,
XtNright, XtChainLeft,
XtNtop, XtChainTop,
XtNright, XtChainTop,
XtNpixmap, default_icon,
(char *)0);
dialogLabel = XtVaCreateManagedWidget("dialogLabel",
labelWidgetClass, dialog,
XtNleft, XtChainLeft,
XtNright, XtChainRight,
XtNtop, XtChainTop,
XtNbottom, XtChainTop,
XtNfromHoriz, dialogIcon,
(char *)0);
dialogText = XtVaCreateManagedWidget("dialogText",
mwTextfieldWidgetClass, dialog,
XtNwidth, 400,
XtNleft, XtChainLeft,
XtNright, XtChainRight,
XtNtop, XtChainTop,
XtNbottom, XtChainTop,
XtNfromHoriz, dialogIcon,
XtNfromVert, dialogLabel,
(char *)0);
wm_delete_window = XInternAtom(XtDisplay(pshell),
"WM_DELETE_WINDOW", False);
XtOverrideTranslations(pshell,
XtParseTranslationTable(
"<Message>WM_PROTOCOLS: dialog-cancel()"));
XtOverrideTranslations(dialogText,
XtParseTranslationTable(
"<Key>Return: dialog-done()\n"
"<Key>Escape: dialog-cancel()"));
dialogDone = add_button(dialog, "dialogDone", "OK",
DialogDone, NULL);
XtVaSetValues(dialogDone,
XtNwidth, 80,
XtNleft, XtChainLeft,
XtNright, XtChainLeft,
XtNtop, XtChainBottom,
XtNbottom, XtChainBottom,
XtNfromVert, dialogText,
(char *)0);
dialogCancel = add_button(dialog, "dialogCancel", "Cancel",
DialogAbort, NULL);
XtVaSetValues(dialogCancel,
XtNwidth, 80,
XtNleft, XtChainLeft,
XtNright, XtChainLeft,
XtNtop, XtChainBottom,
XtNbottom, XtChainBottom,
XtNfromVert, dialogText,
XtNfromHoriz, dialogDone,
(char *)0);
if (icon == None) icon = default_icon;
XtVaSetValues(dialogIcon,
XtNbitmap, icon,
(char *)0);
XtVaSetValues(pshell,
XtNtitle, title,
(char *)0);
MwLabelSet(dialogLabel, prompt);
XtVaSetValues(dialogText,
XtNstring, buffr,
XtNinsertPosition, strlen(buffr),
(char *)0);
MwCenter(pshell);
XtPopup(pshell, XtGrabExclusive);
XSetWMProtocols(XtDisplay(pshell), XtWindow(pshell),
&wm_delete_window, 1);
XtSetKeyboardFocus(pshell, dialogText);
while (status == MW_WAITING) {
XEvent event_return;
XtAppNextEvent(app_context, &event_return);
XtDispatchEvent(&event_return);
}
XtVaGetValues(dialogText,
XtNstring, &string,
(char *)0);
strcpy(buffr, string);
XtDestroyWidget(pshell);
return status;
}
void activateCB_open_FindSet (Widget find_set_button, XtPointer cdata,
XmFileSelectionBoxCallbackStruct *cbstruct)
{
Widget filter;
Boolean use_bm = False;
static char *use_bm_filter = "*.m.bm";
static char *use_pm_filter = "*.m.pm";
char *search_path;
char *filter_field_title = NULL;
int use_filter_field = False;
char *file_filter;
char **directories_list = GetIconSearchPathList();
int numberOfTopButtons = 0;
void *top_button_one_cb = NULL;
void *top_button_two_cb = NULL;
void *top_button_three_cb = NULL;
char *top_button_one_label = NULL;
char *top_button_two_label = NULL;
char *top_button_three_label = NULL;
int use_icon_name_field = True;
int numberOfBottomButtons = 3;
void *bottom_button_one_cb = (void *)load_icons;
void *bottom_button_two_cb = NULL;
void *bottom_button_three_cb = NULL;
void *bottom_button_four_cb = NULL;
char *bottom_button_one_label = NULL; /* use default */
char *bottom_button_two_label = NULL; /* use default */
char *bottom_button_three_label = NULL; /* use default */
char *bottom_button_four_label = NULL; /* use default */
char *name_field_title;
char *container_title;
char *directory_title;
char *dialog_title, *pre, *suf;
name_field_title = XtNewString(GETMESSAGE(11, 12, "Enter Icon Filename"));
container_title = XtNewString(GETMESSAGE(11, 11, "Icon Files"));
directory_title = XtNewString(GETMESSAGE(11, 30, "Icon Folders"));
pre = GETMESSAGE(3, 10, "Create Action");
suf = GETMESSAGE(6, 18, "Find Set");
dialog_title = XtMalloc(strlen(pre) + strlen(suf) + 4);
sprintf(dialog_title, "%s - %s", pre, suf);
#ifdef DEBUG
printf("activate Find Set button; client_data = %p\n", cdata); /* debug */
#endif
XtVaGetValues (COLOR_MONO_OPTION, XmNset, &use_bm, NULL);
if (use_bm) file_filter = use_bm_filter;
else file_filter = use_pm_filter;
#ifndef _ICONSELECTOR_DESTROY_ENABLED
if (!IconSelector) {
#endif /* _ICONSELECTOR_DESTROY_ENABLED */
IconSelector = create_icon_selection_dialog ((swidget) CreateActionAppShell,
(unsigned char *)dialog_title,
(unsigned char *)filter_field_title,
use_filter_field,
(unsigned char *)file_filter,
(unsigned char *)directory_title,
(unsigned char **)directories_list,
(unsigned char *)container_title,
numberOfTopButtons,
(unsigned char *)top_button_one_label,
(void (*)())top_button_one_cb,
(unsigned char *)top_button_two_label,
(void (*)())top_button_two_cb,
(unsigned char *)top_button_three_label,
(void (*)())top_button_three_cb,
use_icon_name_field,
(unsigned char *)name_field_title,
numberOfBottomButtons,
(unsigned char *)bottom_button_one_label,
(void (*)())bottom_button_one_cb,
(unsigned char *)bottom_button_two_label,
(void (*)())bottom_button_two_cb,
(unsigned char *)bottom_button_three_label,
(void (*)())bottom_button_three_cb,
(unsigned char *)bottom_button_four_label,
(void (*)())bottom_button_four_cb);
#ifndef _ICONSELECTOR_DESTROY_ENABLED
}
#endif /* _ICONSELECTOR_DESTROY_ENABLED */
XtFree(name_field_title);
XtFree(container_title);
XtFree(directory_title);
XtFree(dialog_title);
FreeIconSearchPathList(directories_list);
XtVaSetValues (IconSelector, XmNuserData, cdata, NULL);
UxPopupInterface (IconSelector, no_grab);
XmProcessTraversal(ISD_SelectedIconTextField, XmTRAVERSE_CURRENT);
return;
}
Widget CreateTabletControls(
Widget parent)
{
Widget form, form1, label, slider, frame, widget;
/* create a parent form to hold all the tracking controls */
form = XtVaCreateWidget("tablet_controls_form", xmFormWidgetClass,
parent,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
/* create frame, form and label for the tracking parameters */
frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass,
form,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
form1 = XtVaCreateWidget("tablet_form1", xmFormWidgetClass,
frame,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
label = XtVaCreateManagedWidget("tablet_ref_points", xmLabelWidgetClass,
frame,
XmNchildType, XmFRAME_TITLE_CHILD,
XmNborderWidth, 0,
NULL);
/* create sliders for the reference coordinates */
slider = HGU_XmCreateHorizontalSlider("x1", form1,
0.0, -1000.0, 2000.0, 0,
NULL, NULL);
XtVaSetValues(slider,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
widget = slider;
slider = HGU_XmCreateHorizontalSlider("y1", form1,
0.0, -1000.0, 2000.0, 0,
NULL, NULL);
XtVaSetValues(slider,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, widget,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
widget = slider;
slider = HGU_XmCreateHorizontalSlider("x2", form1,
150.0, -1000.0, 2000.0, 0,
NULL, NULL);
XtVaSetValues(slider,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, widget,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
widget = slider;
slider = HGU_XmCreateHorizontalSlider("y2", form1,
100.0, -1000.0, 2000.0, 0,
NULL, NULL);
XtVaSetValues(slider,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, widget,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
widget = slider;
XtManageChild( form1 );
tablet_controls = form;
return( form );
}
Widget SelectionAttrDialog::createValueEditor(Widget mainForm)
{
/////////////////////////////////////////////////////////////
// Create the widgets from left to right and top to bottom.//
/////////////////////////////////////////////////////////////
// XtVaSetValues(mainForm,XmNautoUnmanage, False, NULL);
XtVaSetValues(this->valueList,XmNvisibleItemCount, 10, NULL);
//
// The OK and CANCEL buttons.
//
this->ok = XtVaCreateManagedWidget(
"okButton", xmPushButtonWidgetClass, mainForm,
XmNleftAttachment , XmATTACH_FORM,
XmNleftOffset , 5,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset , 10,
XmNrecomputeSize , False,
XmNwidth , 75,
NULL);
this->cancel = XtVaCreateManagedWidget(
"cancelButton", xmPushButtonWidgetClass, mainForm,
XmNrightAttachment , XmATTACH_FORM,
XmNrightOffset , 5,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset , 10,
XmNrecomputeSize , False,
XmNwidth , 75,
NULL);
Widget separator = XtVaCreateManagedWidget(
"separator", xmSeparatorWidgetClass, mainForm,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget , this->ok,
XmNbottomOffset , 10,
XmNleftAttachment , XmATTACH_FORM,
XmNleftOffset , 2,
XmNrightAttachment , XmATTACH_FORM,
XmNrightOffset , 2,
NULL);
//
// The value text window
//
this->valueText = XtVaCreateManagedWidget("valueText",
xmTextWidgetClass , mainForm,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, separator,
XmNbottomOffset, 10,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNcolumns, 14,
NULL);
this->installValueEditorCallback(this->valueText, XmNactivateCallback);
//
// The label text window
//
this->labelText = XtVaCreateManagedWidget("labelText",
xmTextWidgetClass , mainForm,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, separator,
XmNbottomOffset, 10,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, this->valueText,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
NULL);
this->installValueEditorCallback(this->labelText, XmNactivateCallback);
//
// The Value label
//
Widget valueLabel = XtVaCreateManagedWidget("valueLabel",
xmLabelWidgetClass , mainForm,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, this->valueText,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
NULL);
//
// The Label label
//
Widget labelLabel = XtVaCreateManagedWidget("labelLabel",
xmLabelWidgetClass, mainForm,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, this->valueText,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, this->labelText,
XmNleftOffset, 0,
NULL);
return valueLabel;
}
Widget
MenuBar::createPulldown (
Widget parent,
CmdList *list,
Boolean help ,
unsigned char type)
{
int i;
Widget pulldown, cascade;
Arg args2[2];
char * helpId;
XmString label_str;
if(type != XmMENU_POPUP)
type = XmMENU_BAR;
// Create a pulldown menu pane for this list of commands
if( type == XmMENU_BAR) {
pulldown = XmCreatePulldownMenu( parent,
(char *) list->name(), NULL, 0 );
label_str = XmStringCreateLocalized(list->getLabel());
XtVaSetValues(pulldown,
XmNlabelString, label_str,
NULL);
printHelpId("pulldown", pulldown);
/* install callback */
// XtAddCallback(pulldown, XmNhelpCallback, HelpCB, helpId);
// Each entry in the menu bar must have a cascade button
// from which the user can pull down the pane
XtSetArg(args2[0], XmNsubMenuId, pulldown);
cascade = XtCreateWidget ( list->name(),
xmCascadeButtonWidgetClass,
parent,
args2, 1);
XtVaSetValues(cascade,
XmNlabelString, label_str,
NULL);
if (help) {
XtSetArg (args2[0], XmNmenuHelpWidget, cascade);
XtSetValues (parent, args2, 1);
}
XtManageChild ( cascade );
printHelpId("cascade", cascade);
/* install callback */
// Install callbacks for each of the
// pulldown menus so we can get
// On Item help for them.
helpId = XtName(cascade);
if (helpId == "Mailbox") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILCONTAINERMENUID);
} else if (helpId == "Edit") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILEDITMENUID);
} else if (helpId == "Message") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILMESSAGEMENUID);
} else if (helpId == "Attachments") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILATTACHMENUID);
} else if (helpId == "View") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILVIEWMENUID);
} else if (helpId == "Compose") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILCOMPOSEMENUID);
}
} else
pulldown = _w;
// Loop through the cmdList, creating a menu
// entry for each command.
for ( i = 0; i < list->size(); i++)
{
if(!strcmp((*list)[i]->className(), "CmdList")) {
Widget pane = createPulldown(pulldown,
(CmdList*) (*list)[i], FALSE, XmMENU_BAR);
((CmdList *)(*list)[i])->setPaneWidget(pane);
label_str = XmStringCreateLocalized((*list)[i]->getLabel());
XtVaSetValues(pane,
XmNlabelString, label_str,
NULL);
} else {
if ( !strcmp((*list)[i]->className(),"SeparatorCmd")) {
XtCreateManagedWidget ( (*list)[i]->name(),
xmSeparatorWidgetClass,
pulldown,
NULL, 0);
} else if (!strcmp((*list)[i]->className(),"ToggleButtonCmd")) {
CmdInterface *ci;
ci = new ToggleButtonInterface(pulldown, (*list)[i]);
ci->manage();
} else if(!strcmp((*list)[i]->className(),"LabelCmd")) {
Widget _i18n;
Arg _args[1];
XmString xms;
_i18n = XtCreateManagedWidget(
(*list)[i]->name(),
xmLabelWidgetClass,
pulldown,
NULL, 0
);
xms = XmStringCreateLocalized((char*) (*list)[i]->getLabel());
XtSetArg( _args[0], XmNlabelString, xms );
XtSetValues( _i18n, _args, 1 );
XmStringFree(xms);
} else {
CmdInterface *ci;
ci = new ButtonInterface ( pulldown, (*list)[i] );
ci->manage();
}
}
}
return(pulldown);
}
/* Parse args and go */
int
main(int argc, char *argv[])
{
XtAppContext context;
#ifndef HAVE_XTVAOPENAPPLICATION
Display *display;
#endif
XTickertapeRec rc;
elvin_handle_t handle;
elvin_error_t error;
const char *user;
const char *domain;
const char *ticker_dir;
const char *config_file;
const char *groups_file;
const char *usenet_file;
const char *keys_file;
const char *keys_dir;
Widget top;
const char *names[AN_MAX + 1];
int i;
/* Determine the name of the executable. */
progname = xbasename(argv[0]);
#ifdef HAVE_XTVAOPENAPPLICATION
/* Create the toplevel widget */
top = XtVaOpenApplication(
&context, "XTickertape",
NULL, 0,
&argc, argv, NULL,
applicationShellWidgetClass,
XtNborderWidth, 0,
NULL);
#else
/* Initialize the X Toolkit */
XtToolkitInitialize();
/* Create an application context */
context = XtCreateApplicationContext();
/* Open the display */
display = XtOpenDisplay(context, NULL, NULL, "XTickertape",
NULL, 0, &argc, argv);
if (display == NULL) {
fprintf(stderr, "Error: Can't open display\n");
exit(1);
}
/* Create the toplevel widget */
top = XtAppCreateShell(NULL, "XTickertape", applicationShellWidgetClass,
display, NULL, 0);
#endif
/* Load the application shell resources */
XtGetApplicationResources(top, &rc, resources, XtNumber(resources),
NULL, 0);
/* Make sure our app-defaults file has a version number */
if (rc.version_tag == NULL) {
app_defaults_version_error("app-defaults file not found or "
"out of date");
exit(1);
}
/* Make sure that version number is the one we want */
if (strcmp(rc.version_tag, PACKAGE "-" VERSION) != 0) {
app_defaults_version_error("app-defaults file has the wrong "
"version number");
exit(1);
}
/* Add a calback for when it gets destroyed */
XtAppAddActions(context, actions, XtNumber(actions));
#if !defined(ELVIN_VERSION_AT_LEAST)
/* Initialize the elvin client library */
error = elvin_xt_init(context);
if (error == NULL) {
fprintf(stderr, "*** elvin_xt_init(): failed\n");
exit(1);
}
/* Double-check that the initialization worked */
if (elvin_error_is_error(error)) {
eeprintf(error, "elvin_xt_init failed\n");
exit(1);
}
/* Create a new elvin connection handle */
handle = elvin_handle_alloc(error);
if (handle == NULL) {
eeprintf(error, "elvin_handle_alloc failed\n");
exit(1);
}
#elif ELVIN_VERSION_AT_LEAST(4, 1, -1)
/* Allocate an error context */
error = elvin_error_alloc(NULL, NULL);
if (error == NULL) {
fprintf(stderr, "%s: error: elvin_error_alloc failed\n", progname);
exit(1);
}
/* Initialize the elvin client library */
client = elvin_xt_init_default(context, error);
if (client == NULL) {
eeprintf(error, "elvin_xt_init failed\n");
exit(1);
}
/* Create a new elvin connection handle */
handle = elvin_handle_alloc(client, error);
if (handle == NULL) {
eeprintf(error, "elvin_handle_alloc failed\n");
exit(1);
}
#else /* ELVIN_VERSION_AT_LEAST */
# error "Unsupported Elvin library version"
#endif /* ELVIN_VERSION_AT_LEAST */
/* Scan what's left of the arguments */
parse_args(argc, argv, handle, &user, &domain,
&ticker_dir, &config_file,
&groups_file, &usenet_file,
&keys_file, &keys_dir,
error);
/* Intern a bunch of atoms. We jump through a few hoops in order
* in order to do this in a single RPC to the X server. */
#ifdef USE_ASSERT
memset(names, 0, sizeof(names));
#endif /* USE_ASSERT */
for (i = 0; i <= AN_MAX; i++) {
ASSERT(names[atom_list[i].index] == NULL);
names[atom_list[i].index] = atom_list[i].name;
}
/* Make sure we've specified a name for each atom. */
for (i = 0; i <= AN_MAX; i++) {
ASSERT(names[i] != NULL);
}
/* Intern the atoms. */
if (!XInternAtoms(XtDisplay(top), (char **)names, AN_MAX + 1,
False, atoms)) {
fprintf(stderr, "%s: error: XInternAtoms failed\n", progname);
exit(1);
}
/* Create an Icon for the root shell */
XtVaSetValues(top, XtNiconWindow, create_icon(top), NULL);
/* Create a tickertape */
tickertape = tickertape_alloc(
&rc, handle,
user, domain,
ticker_dir, config_file,
groups_file, usenet_file,
keys_file, keys_dir,
top,
error);
/* Set up SIGHUP to reload the subscriptions */
signal(SIGHUP, reload_subs);
#ifdef USE_VALGRIND
/* Set up SIGUSR1 to invoke valgrind. */
signal(SIGUSR1, count_leaks);
#endif /* USE_VALGRIND */
#ifdef HAVE_LIBXMU
/* Enable editres support */
XtAddEventHandler(top, (EventMask)0, True, _XEditResCheckMessages, NULL);
#endif /* HAVE_LIBXMU */
/* Let 'er rip! */
XtAppMainLoop(context);
/* Keep the compiler happy */
return 0;
}
static Widget _Uxbuild_kuipCommandP()
{
Widget _UxParent;
/* Creation of kuipCommandP */
_UxParent = XtVaCreatePopupShell( "kuipCommandP_shell",
xmDialogShellWidgetClass, UxTopLevel,
XmNallowShellResize, TRUE,
XmNtitle, "kuipCommandP",
NULL );
kuipCommandP = XtVaCreateWidget( "kuipCommandP",
xmFormWidgetClass,
_UxParent,
XmNautoUnmanage, FALSE,
RES_CONVERT( XmNdialogTitle, "Command" ),
XmNdefaultPosition, FALSE,
XmNresizePolicy, XmRESIZE_ANY,
NULL );
UxPutContext( kuipCommandP, (char *) UxKuipCommandPContext );
/* Creation of commandSep */
commandSep = XtVaCreateManagedWidget( "commandSep",
xmSeparatorGadgetClass,
kuipCommandP,
XmNheight, 10,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 45,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 0,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 0,
NULL );
UxPutContext( commandSep, (char *) UxKuipCommandPContext );
/* Creation of km_cmdOK */
km_cmdOK = XtVaCreateManagedWidget( "km_cmdOK",
xmPushButtonGadgetClass,
kuipCommandP,
XmNwidth, 80,
XmNheight, 30,
RES_CONVERT( XmNlabelString, "OK" ),
XmNshowAsDefault, 1,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNtopAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightOffset, 5,
XmNrightPosition, 20,
XmNmnemonicCharSet, "O",
NULL );
UxPutContext( km_cmdOK, (char *) UxKuipCommandPContext );
/* Creation of km_cmdEX */
km_cmdEX = XtVaCreateManagedWidget( "km_cmdEX",
xmPushButtonGadgetClass,
kuipCommandP,
XmNwidth, 80,
XmNheight, 30,
RES_CONVERT( XmNlabelString, "Execute" ),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftOffset, 5,
XmNleftWidget, km_cmdOK,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightOffset, 5,
XmNrightPosition, 40,
RES_CONVERT( XmNmnemonic, "E" ),
NULL );
UxPutContext( km_cmdEX, (char *) UxKuipCommandPContext );
/* Creation of km_cmdRE */
km_cmdRE = XtVaCreateManagedWidget( "km_cmdRE",
xmPushButtonGadgetClass,
kuipCommandP,
XmNwidth, 80,
XmNheight, 30,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftOffset, 5,
XmNleftWidget, km_cmdEX,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightOffset, 5,
XmNrightPosition, 60,
XmNtopAttachment, XmATTACH_NONE,
RES_CONVERT( XmNlabelString, "Reset" ),
RES_CONVERT( XmNmnemonic, "R" ),
NULL );
UxPutContext( km_cmdRE, (char *) UxKuipCommandPContext );
/* Creation of km_cmdCA */
km_cmdCA = XtVaCreateManagedWidget( "km_cmdCA",
xmPushButtonGadgetClass,
kuipCommandP,
XmNwidth, 80,
XmNheight, 30,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftOffset, 5,
XmNleftWidget, km_cmdRE,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightOffset, 5,
XmNrightPosition, 80,
RES_CONVERT( XmNlabelString, "Cancel" ),
RES_CONVERT( XmNmnemonic, "C" ),
NULL );
UxPutContext( km_cmdCA, (char *) UxKuipCommandPContext );
/* Creation of km_cmdHE */
km_cmdHE = XtVaCreateManagedWidget( "km_cmdHE",
xmPushButtonGadgetClass,
kuipCommandP,
XmNwidth, 80,
XmNheight, 30,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightOffset, 5,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftOffset, 5,
XmNleftWidget, km_cmdCA,
XmNrightPosition, 100,
RES_CONVERT( XmNlabelString, "Help" ),
RES_CONVERT( XmNmnemonic, "H" ),
NULL );
UxPutContext( km_cmdHE, (char *) UxKuipCommandPContext );
XtVaSetValues(kuipCommandP,
XmNdefaultButton, km_cmdOK,
NULL );
XtAddCallback( kuipCommandP, XmNdestroyCallback,
(XtCallbackProc) UxDestroyContextCB,
(XtPointer) UxKuipCommandPContext);
return ( kuipCommandP );
}
static void
internal_print_statusline(Boolean error,
statusTimerT timeout,
const char *old_content,
const char *fmt,
va_list argp)
{
if (!XtIsRealized(globals.widgets.top_level)
|| !initialized
|| (resource.expert_mode & XPRT_SHOW_STATUSLINE) == 0) {
/* only print errors to stdout */
if (!error)
return;
if (!resource.hush_stdout && strlen(fmt) > 0) { /* check for strlen since sometimes we clear the statusline
by printing "" to it, and we don't want that on stdout */
fprintf(stdout, "xdvi: ");
if (old_content != NULL)
(void)fputs(old_content, stdout);
(void)vfprintf(stdout, fmt, argp);
fputc('\n', stdout);
fflush(stdout);
}
}
else {
char buf[MAX_LEN + 1];
size_t offset = 0;
if (old_content != NULL && old_content[0] != '\0') {
offset += strlen(old_content);
strncpy(buf, old_content, MAX_LEN);
/* append separating space */
if (strlen(old_content) < MAX_LEN - 1) {
strcat(buf, " ");
offset++;
}
}
VSNPRINTF(buf + offset, MAX_LEN - offset, fmt, argp); /* just throw away strings longer than MAX_LEN */
buf[MAX_LEN] = '\0'; /* terminate buf */
/*
* save current contents of statusline so that toggling the statusline
* on and off will display the same text again
*/
strcpy(g_string_savebuf, buf);
#ifdef MOTIF
XmTextFieldSetString(statusline, buf);
#else
XtVaSetValues(statusline, XtNlabel, buf, NULL);
#endif
/* fprintf(stderr, "timeout: %d, id: %ld\n", timeout, clear_timeout_id); */
if (timeout > 0) {
timeout *= 1000; /* convert to miliseconds */
if (clear_timeout_id) {
/* fprintf(stderr, "clearing!\n"); */
if (globals.debug & DBG_EVENT)
fprintf(stderr, "%s:%d: removing timeout %ld\n", __FILE__, __LINE__, clear_timeout_id);
XtRemoveTimeOut(clear_timeout_id);
}
clear_timeout_id = XtAppAddTimeOut(globals.app, timeout,
clear_statusline_timer_proc, (XtPointer) NULL);
}
}
}
bool wxFrame::XmDoCreateTLW(wxWindow* WXUNUSED(parent),
wxWindowID WXUNUSED(id),
const wxString& WXUNUSED(title),
const wxPoint& WXUNUSED(pos),
const wxSize& WXUNUSED(size),
long style,
const wxString& name)
{
Widget frameShell;
frameShell = XtCreatePopupShell( name, topLevelShellWidgetClass,
(Widget)wxTheApp->GetTopLevelWidget(),
NULL, 0 );
XtVaSetValues(frameShell,
// Allows menu to resize
XmNallowShellResize, True,
XmNdeleteResponse, XmDO_NOTHING,
XmNmappedWhenManaged, False,
XmNiconic, (style & wxICONIZE) ? True : False,
NULL);
m_frameShell = (WXWidget)frameShell;
m_mainWidget = (WXWidget) XtVaCreateManagedWidget("main_window",
xmMainWindowWidgetClass, frameShell,
XmNresizePolicy, XmRESIZE_NONE,
NULL);
m_workArea = (WXWidget) XtVaCreateWidget("form",
xmFormWidgetClass, (Widget) m_mainWidget,
XmNresizePolicy, XmRESIZE_NONE,
NULL);
m_clientArea = (WXWidget) XtVaCreateWidget("client",
xmBulletinBoardWidgetClass, (Widget) m_workArea,
XmNmarginWidth, 0,
XmNmarginHeight, 0,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtVaSetValues((Widget) m_mainWidget,
XmNworkWindow, (Widget) m_workArea,
NULL);
XtManageChild((Widget) m_clientArea);
XtManageChild((Widget) m_workArea);
XtTranslations ptr = XtParseTranslationTable( "<Configure>: resize()" );
XtOverrideTranslations( (Widget) m_workArea, ptr );
XtFree( (char *)ptr );
/* Part of show-&-hide fix */
XtAddEventHandler( frameShell, StructureNotifyMask,
False, (XtEventHandler)wxFrameMapProc,
(XtPointer)this );
XtRealizeWidget(frameShell);
wxAddWindowToTable( (Widget)m_workArea, this);
wxAddWindowToTable( (Widget)m_clientArea, this);
wxModelessWindows.Append( this );
return true;
}
bool wxFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
if( !wxTopLevelWindow::Create( parent, id, title, pos, size, style,
name ) )
return false;
m_backgroundColour =
wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
m_foregroundColour = *wxBLACK;
m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
int x = pos.x, y = pos.y;
int width = size.x, height = size.y;
// Set reasonable values for position and size if defaults have been
// requested
//
// MB TODO: something better than these arbitrary values ?
// VZ should use X resources for this...
if ( width == -1 )
width = 400;
if ( height == -1 )
height = 400;
int displayW, displayH;
wxDisplaySize( &displayW, &displayH );
if ( x == -1 )
{
x = (displayW - width) / 2;
if (x < 10) x = 10;
}
if ( y == -1 )
{
y = (displayH - height) / 2;
if (y < 10) y = 10;
}
SetTitle( title );
wxLogTrace(wxTRACE_Messages,
"Created frame (0x%p) with work area 0x%p and client "
"area 0x%p", m_mainWidget, m_workArea, m_clientArea);
XtAddEventHandler((Widget) m_clientArea, ExposureMask,False,
wxUniversalRepaintProc, (XtPointer) this);
if (x > -1)
XtVaSetValues((Widget) m_frameShell, XmNx, x, NULL);
if (y > -1)
XtVaSetValues((Widget) m_frameShell, XmNy, y, NULL);
if (width > -1)
XtVaSetValues((Widget) m_frameShell, XmNwidth, width, NULL);
if (height > -1)
XtVaSetValues((Widget) m_frameShell, XmNheight, height, NULL);
ChangeFont(false);
ChangeBackgroundColour();
PreResize();
wxSize newSize(width, height);
wxSizeEvent sizeEvent(newSize, GetId());
sizeEvent.SetEventObject(this);
GetEventHandler()->ProcessEvent(sizeEvent);
return true;
}
void grayOut(Widget w)
{
XtVaSetValues(w, XtNsensitive, (XtArgVal) False, NULL);
}
Widget
MenuBar::addCommands(
Widget pulldown,
CmdList *new_list
)
{
// if(isValidMenuPane(pulldown) == FALSE)
// return NULL;
int i, num_children;
WidgetList children;
Boolean haveNoSeparator;
int newItemIndex, numPBUnmanaged, tmpPBUnmanaged;
XtVaGetValues(pulldown,
XmNnumChildren, &num_children,
NULL);
children = (WidgetList)XtMalloc(sizeof(Widget) * num_children);
XtVaGetValues(pulldown,
XmNchildren, &children,
NULL);
// Handle the creation or management of the Separator.
haveNoSeparator = TRUE;
numPBUnmanaged = 0;
for (i=0; (i < num_children); i++) {
Widget wid = (Widget) children[i];
if (XtIsSubclass(wid, xmSeparatorWidgetClass)) {
XtManageChild(wid);
haveNoSeparator = FALSE;
}
else if (XtIsSubclass(wid, xmPushButtonWidgetClass)) {
if (!XtIsManaged(wid)) { // If widget is unmanaged
numPBUnmanaged++;
}
}
}
if (haveNoSeparator) {
XtCreateManagedWidget ("Separator",
xmSeparatorWidgetClass,
pulldown,
NULL, 0);
haveNoSeparator = FALSE;
}
// Now handle the pushButton case
newItemIndex = 0;
tmpPBUnmanaged = 0;
// Loop through the cmdList, creating a menu
// entry for each command.
for (newItemIndex = 0; newItemIndex < new_list->size(); newItemIndex++) {
tmpPBUnmanaged = numPBUnmanaged;
if (numPBUnmanaged > 0) { // If there exists unmanaged PBs
for (i = 0;
(i < num_children) &&
(tmpPBUnmanaged == numPBUnmanaged);
i++) {
Widget wid = (Widget) children[i];
if (XtIsSubclass(wid, xmPushButtonWidgetClass)) {
if (!XtIsManaged(wid)) {
// If widget is unmanaged
// Set its label to be the newItemIndex widget's.
// Manage it.
// Bump up newItemIndex
XtVaSetValues(wid,
XmNlabelString, XmStringCreateLocalized(
(char *) (*new_list)[newItemIndex]->getLabel()),
NULL);
XtManageChild(wid);
numPBUnmanaged--;
}
}
}
}
else { // No unmanaged push buttons available
CmdInterface *ci;
ci = new ButtonInterface (
pulldown, (*new_list)[newItemIndex]
);
ci->manage();
}
}
return(pulldown);
}
void noTick(Widget w)
{
XtVaSetValues(w, XtNleftBitmap, (XtArgVal) bm[NOTICK_BM], NULL);
}
void
MenuBar::rotateLabels(
Widget pulldown,
int startindex,
int endindex
)
{
// if(isValidMenuPane(pulldown) == FALSE)
// return;
int num_managed_wids=0, i, j, num_children, num_to_change;
WidgetList children;
XmString label, endlabel;
Widget prevwid, wid;
if (startindex < 0 || endindex < 0)
return;
XtVaGetValues(pulldown,
XmNnumChildren, &num_children,
NULL);
if (startindex >= num_children || endindex >= num_children)
return;
num_to_change = endindex - startindex;
if (num_children < num_to_change || num_to_change == 0)
return;
children = (WidgetList)XtMalloc(sizeof(Widget) * num_children);
XtVaGetValues(pulldown,
XmNchildren, &children,
NULL);
// Some of the widgets may be unmanaged: find the first managed widget
for (i = startindex; i < num_children; i++) {
if (XtIsManaged(children[i]))
break;
startindex++;
}
if (startindex == num_children)
return;
// Find the real endindex
endindex = startindex+1;
while (endindex < num_children) {
if (XtIsManaged(children[endindex]))
num_managed_wids++;
if (num_managed_wids == num_to_change)
// We have found the endindex at this point
break;
endindex++;
}
if (endindex == num_children)
return;
wid = (Widget) children[endindex];
XtVaGetValues(wid,
XmNlabelString, &label,
NULL);
endlabel = XmStringCopy(label);
j = i = endindex;
while (i > startindex) {
do {
if (--j < startindex) break;
prevwid = (Widget) children[j];
} while (!XtIsManaged(prevwid));
XtVaGetValues(prevwid,
XmNlabelString, &label,
NULL);
XtVaSetValues(wid,
XmNlabelString, label,
NULL);
i = j;
wid = (Widget) children[i];
}
wid = (Widget) children[startindex];
XtVaSetValues(wid,
XmNlabelString, endlabel,
NULL);
XmStringFree(endlabel);
}
void MAPaintTabletInit(
ThreeDViewStruct *view_struct)
{
TabletEvent event;
int quitFlag;
Widget dialog;
XmString text, title;
WlzDVertex2 tabVtxs[2], wlzVtxs[2];
Widget slider;
WlzAffineTransform *trans;
/* ignore if already open */
if( tablet ){
return;
}
/* open the tablet */
if( (tablet = TabletOpen(WACOM_IV_TABLET_TYPE,
"/dev/term/b", NULL)) == NULL ){
HGU_XmUserError(globals.topl,
"Open Wacom Tablet:\n"
" Failed to open the tablet, please check\n"
" the tablet is connected to serial line b\n"
" and switched on, then try again.",
XmDIALOG_FULL_APPLICATION_MODAL);
return;
}
/* set tilt mode and start the tablet */
TabletSetMode(tablet, TABLET_TILTMODE_MASK);
tablet->cntrlMode2 |= TABLET_CORRECT_TILT_MASK;
tablet->cntrlMode2 |= TABLET_TRANSFORM_MASK;
TabletStart(tablet);
/* if the tablet needs the coordinates set then do so here */
if( !view_struct->tablet_initialised ){
/* get first coordinate */
/* put up an application modal dialog to request first
coordinate */
dialog = XmCreateMessageDialog(view_struct->canvas,
"MAPaint Message", NULL, 0);
XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_OK_BUTTON));
XtSetSensitive(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON),
False);
text = XmStringCreateLtoR("Input tablet reference point 1 please",
XmSTRING_DEFAULT_CHARSET);
title = XmStringCreateSimple("MAPaint Tablet Message");
XtVaSetValues(dialog,
XmNmessageString, text,
XmNdialogTitle, title,
XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
NULL);
XmStringFree( text );
XmStringFree( title );
/* popup widget and process events */
XtManageChild( dialog );
XSync(XtDisplay(view_struct->canvas), False);
quitFlag = 0;
while( quitFlag < 100 ){
if((XtAppPending(globals.app_con) > 0) ){
XtAppProcessEvent(globals.app_con, XtIMAll);
}
else {
XSync(XtDisplay(view_struct->canvas), False);
usleep(1000);
quitFlag++;
}
}
quitFlag = 0;
while( !quitFlag ){
if( TabletNextEvent(tablet, &event) == TABLET_ERR_NONE ){
if(event.buttonPressed &&
((event.buttons == 1) || (event.buttons == 3))){
tabVtxs[0].vtX = event.x;
tabVtxs[0].vtY = event.y;
quitFlag = 1;
XBell(XtDisplay(view_struct->canvas), 100);
XFlush(XtDisplay(view_struct->canvas));
}
}
else {
TabletClose(tablet);
tablet = NULL;
XtDestroyWidget(dialog);
return;
}
}
/* get second coordinate */
text = XmStringCreateLtoR("Input tablet reference point 2 please",
XmSTRING_DEFAULT_CHARSET);
XtVaSetValues(dialog,
XmNmessageString, text,
NULL);
XmStringFree( text );
/* popup widget and process events */
XtManageChild( dialog );
XSync(XtDisplay(view_struct->canvas), False);
while( (XtAppPending(globals.app_con) > 0) ){
XtAppProcessEvent(globals.app_con, XtIMAll);
XSync(XtDisplay(view_struct->canvas), False);
}
quitFlag = 0;
sleep(1);
TabletClearEvents(tablet);
while( !quitFlag ){
if( TabletNextEvent(tablet, &event) == TABLET_ERR_NONE ){
if(event.buttonPressed &&
((event.buttons == 1) || (event.buttons == 3))){
tabVtxs[1].vtX = event.x;
tabVtxs[1].vtY = event.y;
quitFlag = 1;
XBell(XtDisplay(view_struct->canvas), 100);
XFlush(XtDisplay(view_struct->canvas));
}
}
else {
TabletClose(tablet);
XtDestroyWidget(dialog);
tablet = NULL;
return;
}
}
TabletStop(tablet);
XtDestroyWidget(dialog);
usleep(10000);
TabletClearEvents(tablet);
/* set the reference coordinates */
view_struct->ref1.vtX = tabVtxs[0].vtX;
view_struct->ref1.vtY = tabVtxs[0].vtY;
view_struct->ref2.vtX = tabVtxs[1].vtX;
view_struct->ref2.vtY = tabVtxs[1].vtY;
}
else {
tabVtxs[0].vtX = view_struct->ref1.vtX;
tabVtxs[0].vtY = view_struct->ref1.vtY;
tabVtxs[1].vtX = view_struct->ref2.vtX;
tabVtxs[1].vtY = view_struct->ref2.vtY;
}
/* set tablet transform parameters */
if((slider = XtNameToWidget(tablet_controls, "*.x1")) )
{
wlzVtxs[0].vtX = HGU_XmGetSliderValue(slider);
}
if((slider = XtNameToWidget(tablet_controls, "*.y1")) )
{
wlzVtxs[0].vtY = HGU_XmGetSliderValue(slider);
}
if((slider = XtNameToWidget(tablet_controls, "*.x2")) )
{
wlzVtxs[1].vtX = HGU_XmGetSliderValue(slider);
}
if( (slider = XtNameToWidget(tablet_controls, "*.y2")))
{
wlzVtxs[1].vtY = HGU_XmGetSliderValue(slider);
}
trans = WlzAffineTransformLSq2D(2, tabVtxs, 2, wlzVtxs, 0, NULL,
WLZ_TRANSFORM_2D_NOSHEAR, NULL);
tablet->xTrans[0] = trans->mat[0][0];
tablet->xTrans[1] = trans->mat[0][1];
tablet->xTrans[2] = trans->mat[0][2];
tablet->yTrans[0] = trans->mat[1][0];
tablet->yTrans[1] = trans->mat[1][1];
tablet->yTrans[2] = trans->mat[1][2];
WlzFreeAffineTransform(trans);
view_struct->tablet_initialised = 1;
/* initialise the globals */
modifiers = 0;
tabletDrawingFlag = 0;
quitDrawingTrigger = 0;
if( tabletPoly ){
WlzFreePolyDmn(tabletPoly);
tabletPoly = NULL;
}
/* now add the tablet stream as an event input source */
TabletStart(tablet);
TabletClearEvents(tablet);
tabletInputId = XtAppAddInput(globals.app_con, tablet->fd,
(XtPointer) XtInputReadMask,
tabletInputProc, (XtPointer) view_struct);
return;
}
/*######################### setup_mon_window() #########################*/
void
setup_mon_window(char *font_name)
{
int i,
his_log_length,
led_width,
new_max_bar_length;
XmFontListEntry entry;
/* Get width and height of font and fid for the GC. */
if (font_struct != NULL)
{
XFreeFont(display, font_struct);
font_struct = NULL;
}
if (fontlist != NULL)
{
XmFontListFree(fontlist);
fontlist = NULL;
}
if ((font_struct = XLoadQueryFont(display, font_name)) == NULL)
{
(void)fprintf(stderr, "Could not load %s font.\n", font_name);
if ((font_struct = XLoadQueryFont(display, DEFAULT_FONT)) == NULL)
{
(void)fprintf(stderr, "Could not load %s font.\n", DEFAULT_FONT);
exit(INCORRECT);
}
else
{
(void)strcpy(font_name, DEFAULT_FONT);
}
}
if ((entry = XmFontListEntryLoad(display, font_name, XmFONT_IS_FONT, "TAG1")) == NULL)
{
(void)fprintf(stderr,
"Failed to load font with XmFontListEntryLoad() : %s (%s %d)\n",
strerror(errno), __FILE__, __LINE__);
exit(INCORRECT);
}
fontlist = XmFontListAppendEntry(NULL, entry);
XmFontListEntryFree(&entry);
if (line_height != 0)
{
/* Set the font for the monitor pulldown. */
XtVaSetValues(mw[MON_W], XmNfontList, fontlist, NULL);
if ((mcp.show_ms_log != NO_PERMISSION) ||
(mcp.show_mon_log != NO_PERMISSION) ||
(mcp.mon_info != NO_PERMISSION) ||
(mcp.retry != NO_PERMISSION) ||
(mcp.switch_afd != NO_PERMISSION) ||
(mcp.disable != NO_PERMISSION))
{
if (mcp.show_ms_log != NO_PERMISSION)
{
XtVaSetValues(ow[MON_SYS_LOG_W], XmNfontList, fontlist, NULL);
XtVaSetValues(pw[0], XmNfontList, fontlist, NULL);
}
if (mcp.show_mon_log != NO_PERMISSION)
{
XtVaSetValues(ow[MON_LOG_W], XmNfontList, fontlist, NULL);
XtVaSetValues(pw[1], XmNfontList, fontlist, NULL);
}
if (mcp.mon_info != NO_PERMISSION)
{
XtVaSetValues(ow[MON_INFO_W], XmNfontList, fontlist, NULL);
XtVaSetValues(pw[4], XmNfontList, fontlist, NULL);
}
if (mcp.retry != NO_PERMISSION)
{
XtVaSetValues(ow[MON_RETRY_W], XmNfontList, fontlist, NULL);
XtVaSetValues(pw[2], XmNfontList, fontlist, NULL);
}
if (mcp.switch_afd != NO_PERMISSION)
{
XtVaSetValues(ow[MON_SWITCH_W], XmNfontList, fontlist, NULL);
XtVaSetValues(pw[3], XmNfontList, fontlist, NULL);
}
if (mcp.disable != NO_PERMISSION)
{
XtVaSetValues(ow[MON_DISABLE_W], XmNfontList, fontlist, NULL);
XtVaSetValues(pw[5], XmNfontList, fontlist, NULL);
}
if ((ping_cmd != NULL) || (traceroute_cmd != NULL))
{
XtVaSetValues(ow[MON_TEST_W], XmNfontList, fontlist, NULL);
if (ping_cmd != NULL)
{
XtVaSetValues(tw[PING_W], XmNfontList, fontlist, NULL);
}
if (traceroute_cmd != NULL)
{
XtVaSetValues(tw[TRACEROUTE_W], XmNfontList, fontlist, NULL);
}
}
}
XtVaSetValues(ow[MON_SELECT_W], XmNfontList, fontlist, NULL);
XtVaSetValues(ow[MON_EXIT_W], XmNfontList, fontlist, NULL);
/* Set the font for the RAFD pulldown. */
if ((mcp.afd_ctrl != NO_PERMISSION) ||
(mcp.show_slog != NO_PERMISSION) ||
(mcp.show_elog != NO_PERMISSION) ||
(mcp.show_rlog != NO_PERMISSION) ||
(mcp.show_tlog != NO_PERMISSION) ||
(mcp.show_ilog != NO_PERMISSION) ||
(mcp.show_plog != NO_PERMISSION) ||
(mcp.show_olog != NO_PERMISSION) ||
(mcp.show_dlog != NO_PERMISSION) ||
(mcp.show_queue != NO_PERMISSION) ||
(mcp.afd_load != NO_PERMISSION))
{
XtVaSetValues(mw[LOG_W], XmNfontList, fontlist, NULL);
if (mcp.afd_ctrl != NO_PERMISSION)
{
XtVaSetValues(vw[MON_AFD_CTRL_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_slog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_SYSTEM_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_elog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_EVENT_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_rlog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_RECEIVE_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_tlog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_TRANS_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_ilog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_INPUT_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_plog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_PRODUCTION_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_olog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_OUTPUT_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_dlog != NO_PERMISSION)
{
XtVaSetValues(vw[MON_DELETE_W], XmNfontList, fontlist, NULL);
}
if (mcp.show_queue != NO_PERMISSION)
{
XtVaSetValues(vw[MON_SHOW_QUEUE_W], XmNfontList, fontlist, NULL);
}
if (mcp.afd_load != NO_PERMISSION)
{
XtVaSetValues(vw[MON_VIEW_LOAD_W], XmNfontList, fontlist, NULL);
XtVaSetValues(lw[FILE_LOAD_W], XmNfontList, fontlist, NULL);
XtVaSetValues(lw[KBYTE_LOAD_W], XmNfontList, fontlist, NULL);
XtVaSetValues(lw[CONNECTION_LOAD_W], XmNfontList, fontlist, NULL);
XtVaSetValues(lw[TRANSFER_LOAD_W], XmNfontList, fontlist, NULL);
}
}
/* Set the font for the Control pulldown. */
if ((mcp.amg_ctrl != NO_PERMISSION) ||
(mcp.fd_ctrl != NO_PERMISSION) ||
(mcp.rr_dc != NO_PERMISSION) ||
(mcp.rr_hc != NO_PERMISSION) ||
(mcp.edit_hc != NO_PERMISSION) ||
(mcp.dir_ctrl != NO_PERMISSION) ||
(mcp.startup_afd != NO_PERMISSION) ||
(mcp.shutdown_afd != NO_PERMISSION))
{
XtVaSetValues(mw[CONTROL_W], XmNfontList, fontlist, NULL);
if (mcp.amg_ctrl != NO_PERMISSION)
{
XtVaSetValues(cw[AMG_CTRL_W], XmNfontList, fontlist, NULL);
}
if (mcp.fd_ctrl != NO_PERMISSION)
{
XtVaSetValues(cw[FD_CTRL_W], XmNfontList, fontlist, NULL);
}
if (mcp.rr_dc != NO_PERMISSION)
{
XtVaSetValues(cw[RR_DC_W], XmNfontList, fontlist, NULL);
}
if (mcp.rr_hc != NO_PERMISSION)
{
XtVaSetValues(cw[RR_HC_W], XmNfontList, fontlist, NULL);
}
if (mcp.edit_hc != NO_PERMISSION)
{
XtVaSetValues(cw[EDIT_HC_W], XmNfontList, fontlist, NULL);
}
if (mcp.dir_ctrl != NO_PERMISSION)
{
XtVaSetValues(cw[DIR_CTRL_W], XmNfontList, fontlist, NULL);
}
if (mcp.startup_afd != NO_PERMISSION)
{
XtVaSetValues(cw[STARTUP_AFD_W], XmNfontList, fontlist, NULL);
}
if (mcp.shutdown_afd != NO_PERMISSION)
{
XtVaSetValues(cw[SHUTDOWN_AFD_W], XmNfontList, fontlist, NULL);
}
}
/* Set the font for the Setup pulldown. */
XtVaSetValues(mw[CONFIG_W], XmNfontList, fontlist, NULL);
XtVaSetValues(sw[FONT_W], XmNfontList, fontlist, NULL);
XtVaSetValues(sw[ROWS_W], XmNfontList, fontlist, NULL);
XtVaSetValues(sw[STYLE_W], XmNfontList, fontlist, NULL);
XtVaSetValues(sw[HISTORY_W], XmNfontList, fontlist, NULL);
XtVaSetValues(sw[MON_OTHER_W], XmNfontList, fontlist, NULL);
if (have_groups == YES)
{
XtVaSetValues(sw[MON_OPEN_ALL_GROUPS_W], XmNfontList, fontlist, NULL);
XtVaSetValues(sw[MON_CLOSE_ALL_GROUPS_W], XmNfontList, fontlist, NULL);
}
XtVaSetValues(sw[MON_SAVE_W], XmNfontList, fontlist, NULL);
/* Set the font for the Help pulldown. */
#ifdef _WITH_HELP_PULLDOWN
XtVaSetValues(mw[HELP_W], XmNfontList, fontlist, NULL);
XtVaSetValues(hw[ABOUT_W], XmNfontList, fontlist, NULL);
XtVaSetValues(hw[HYPER_W], XmNfontList, fontlist, NULL);
XtVaSetValues(hw[VERSION_W], XmNfontList, fontlist, NULL);
#endif
/* Set the font for the Row pulldown. */
XtVaSetValues(rw[ROW_0_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_1_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_2_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_3_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_4_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_5_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_6_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_7_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_8_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_9_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_10_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_11_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_12_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_13_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_14_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_15_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_16_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_17_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_18_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_19_W], XmNfontList, fontlist, NULL);
XtVaSetValues(rw[ROW_20_W], XmNfontList, fontlist, NULL);
/* Set the font for the Line Style pulldown. */
XtVaSetValues(lsw[STYLE_0_W], XmNfontList, fontlist, NULL);
XtVaSetValues(lsw[STYLE_1_W], XmNfontList, fontlist, NULL);
XtVaSetValues(lsw[STYLE_2_W], XmNfontList, fontlist, NULL);
/* Set the font for the history pulldown. */
for (i = 0; i < NO_OF_HISTORY_LOGS; i++)
{
XtVaSetValues(hlw[i], XmNfontList, fontlist, NULL);
}
/* Set the font for the Other options pulldown. */
XtVaSetValues(oow[FORCE_SHIFT_SELECT_W], XmNfontList, fontlist, NULL);
XtVaSetValues(oow[AUTO_SAVE_W], XmNfontList, fontlist, NULL);
XtVaSetValues(oow[FRAMED_GROUPS_W], XmNfontList, fontlist, NULL);
}
glyph_height = font_struct->ascent + font_struct->descent;
glyph_width = font_struct->per_char->width;
new_max_bar_length = glyph_width * BAR_LENGTH_MODIFIER;
/* We now have to recalculate the length of all */
/* bars and the scale, because a font change */
/* might have occurred. */
if (new_max_bar_length != max_bar_length)
{
unsigned int new_bar_length;
max_bar_length = new_max_bar_length;
step_size = MAX_INTENSITY / max_bar_length;
/* NOTE: We do not care what the line style is because the */
/* following could happen: font size = 7x13 style = */
/* chars + bars, the user now wants chars only and */
/* then reduces the font to 5x7. After a while he */
/* wants the bars again. Thus we always need to re- */
/* calculate the bar length and queue scale! */
for (i = 0; i < no_of_afds; i++)
{
/* Calculate new scale for active transfers bar. */
if (connect_data[i].max_connections < 1)
{
connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1] = (double)max_bar_length;
}
else
{
connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1] = max_bar_length / connect_data[i].max_connections;
}
if (connect_data[i].no_of_transfers == 0)
{
new_bar_length = 0;
}
else if (connect_data[i].no_of_transfers >= connect_data[i].max_connections)
{
new_bar_length = max_bar_length;
}
else
{
new_bar_length = connect_data[i].no_of_transfers * connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1];
}
if (new_bar_length >= max_bar_length)
{
connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] = max_bar_length;
connect_data[i].blue_color_offset = MAX_INTENSITY;
connect_data[i].green_color_offset = 0;
}
else
{
connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] = new_bar_length;
connect_data[i].blue_color_offset = new_bar_length * step_size;
connect_data[i].green_color_offset = MAX_INTENSITY - connect_data[i].blue_color_offset;
}
/* Calculate new scale for error bar. */
if (connect_data[i].no_of_hosts < 1)
{
connect_data[i].scale[HOST_ERROR_BAR_NO - 1] = (double)max_bar_length;
}
else
{
connect_data[i].scale[HOST_ERROR_BAR_NO - 1] = max_bar_length / connect_data[i].no_of_hosts;
}
if (connect_data[i].host_error_counter == 0)
{
connect_data[i].bar_length[HOST_ERROR_BAR_NO] = 0;
}
else if (connect_data[i].host_error_counter >= connect_data[i].no_of_hosts)
{
connect_data[i].bar_length[HOST_ERROR_BAR_NO] = max_bar_length;
}
else
{
connect_data[i].bar_length[HOST_ERROR_BAR_NO] = connect_data[i].host_error_counter *
connect_data[i].scale[HOST_ERROR_BAR_NO - 1];
}
/* Calculate new bar length for the transfer rate. */
if (connect_data[i].average_tr > 1.0)
{
/* First ensure we do not divide by zero. */
if (connect_data[i].max_average_tr < 2.0)
{
connect_data[i].bar_length[MON_TR_BAR_NO] =
log10(connect_data[i].average_tr) *
max_bar_length /
log10((double) 2.0);
}
else
{
connect_data[i].bar_length[MON_TR_BAR_NO] =
log10(connect_data[i].average_tr) *
max_bar_length /
log10(connect_data[i].max_average_tr);
}
}
else
{
connect_data[i].bar_length[MON_TR_BAR_NO] = 0;
}
} /* for (i = 0; i < no_of_afds; i++) */
}
text_offset = font_struct->ascent;
line_height = SPACE_ABOVE_LINE + glyph_height + SPACE_BELOW_LINE;
bar_thickness_3 = glyph_height / 3;
y_offset_led = (glyph_height - glyph_width) / 2;
led_width = glyph_height / 3;
y_center_log = SPACE_ABOVE_LINE + (glyph_height / 2);
if (his_log_set > 0)
{
his_log_length = (his_log_set * bar_thickness_3) + DEFAULT_FRAME_SPACE;
}
else
{
his_log_length = 0;
}
line_length = DEFAULT_FRAME_SPACE +
(MAX_AFDNAME_LENGTH * glyph_width) +
DEFAULT_FRAME_SPACE +
(3 * (led_width + PROC_LED_SPACING)) +
glyph_height + (glyph_height / 2) + DEFAULT_FRAME_SPACE +
his_log_length + DEFAULT_FRAME_SPACE;
if (line_style == BARS_ONLY)
{
line_length += (int)max_bar_length + DEFAULT_FRAME_SPACE;
}
else if (line_style == CHARACTERS_ONLY)
{
line_length += (32 * glyph_width) + DEFAULT_FRAME_SPACE;
}
else
{
line_length += (32 * glyph_width) + DEFAULT_FRAME_SPACE +
(int)max_bar_length + DEFAULT_FRAME_SPACE;
}
x_offset_led = DEFAULT_FRAME_SPACE + (MAX_AFDNAME_LENGTH * glyph_width) +
DEFAULT_FRAME_SPACE;
x_offset_log_status = x_offset_led + (3 * (led_width + PROC_LED_SPACING)) +
(glyph_height / 2) + DEFAULT_FRAME_SPACE;
x_center_log_status = x_offset_log_status + (glyph_height / 2);
x_offset_log_history = x_offset_log_status + glyph_height +
DEFAULT_FRAME_SPACE;
for (i = 0; i < LOG_FIFO_SIZE; i++)
{
coord[i].x = x_center_log_status +
(int)((glyph_height / 2) *
cos((double)((log_angle * i * PI) / 180)));
coord[i].y = y_center_log -
(int)((glyph_height / 2) *
sin((double)((log_angle * i * PI) / 180)));
}
if (line_style == BARS_ONLY)
{
x_offset_bars = x_offset_log_history + his_log_length;
}
else if (line_style == CHARACTERS_ONLY)
{
x_offset_characters = x_offset_log_history + his_log_length;
x_offset_ec = x_offset_characters + (27 * glyph_width);
x_offset_eh = x_offset_ec + (3 *glyph_width);
}
else
{
x_offset_characters = x_offset_log_history + his_log_length;
x_offset_bars = x_offset_characters + (32 * glyph_width) +
DEFAULT_FRAME_SPACE;
x_offset_ec = x_offset_characters + (27 * glyph_width);
x_offset_eh = x_offset_ec + (3 *glyph_width);
}
return;
}
static void
ToolTipPost (XtPointer client_data,
XtIntervalId * id)
{
Widget w = (Widget) client_data;
int rx,
ry,
x,
y;
unsigned int key;
Window root,
child;
XtWidgetGeometry geo;
Position destX,
destY;
XmToolTipConfigTrait ttp; /* ToolTip pointer */
ttp = ToolTipGetData (w);
if (ttp == NULL)
{
XtWarning ("ToolTipGetData() returned NULL in ToolTipPost()");
return;
}
ttp->timer = (XtIntervalId) NULL;
XQueryPointer (XtDisplay (w),
XtWindow (w), &root, &child, &rx, &ry, &x, &y, &key);
if (ttp->duration_timer != (XtIntervalId) NULL)
{
XtRemoveTimeOut (ttp->duration_timer);
ttp->duration_timer = (XtIntervalId) NULL;
}
if (XmIsPrimitive(w) || XmIsGadget(w))
{
XtVaSetValues (ttp->label,
XmNlabelString,
XmGetToolTipString(w),
NULL);
}
else
{
XmString string;
string = XmStringCreateLocalized (XtName (w));
XtVaSetValues (ttp->label, XmNlabelString, string, NULL);
XmStringFree (string);
}
XtQueryGeometry (ttp->label, NULL, &geo);
/* rws 25 Feb 2001
Fix for Bug #1153
Don't let the tip be off the right/bottom of the screen
*/
destX = rx + (XmIsGadget (w) ? XtX (w) : 0) - x + XtWidth (w) / 2;
if (destX + geo.width > WidthOfScreen (XtScreen (w)))
{
destX = WidthOfScreen (XtScreen (w)) - geo.width;
}
destY = ry + (XmIsGadget (w) ? XtY (w) : 0) - y + XtHeight (w);
if (destY + geo.height > HeightOfScreen (XtScreen (w)))
{
destY = ry + (XmIsGadget (w) ? XtY (w) : 0) - y - geo.height;
}
XtVaSetValues (XtParent (ttp->label),
XmNx, rx + 1,
XmNy, ry + 1, XmNwidth, 1, XmNheight, 1, NULL);
ttp->slider =
XtVaCreateWidget ("ToolTipSlider", xmSlideContextWidgetClass,
XmGetXmDisplay (XtDisplay (w)), XmNslideWidget,
XtParent (ttp->label),
XmNslideDestX, destX,
XmNslideDestY, destY,
XmNslideDestWidth, geo.width,
XmNslideDestHeight, geo.height, NULL);
XtAddCallback (ttp->slider, XmNslideFinishCallback,
(XtCallbackProc) ToolTipPostFinish, ttp);
XtPopup (XtParent (ttp->label), XtGrabNone);
}
static int motFileDlgPopup(Ihandle* ih, int x, int y)
{
InativeHandle* parent = iupDialogGetNativeParent(ih);
Widget filebox, dialog;
int dialogtype, style = XmDIALOG_FULL_APPLICATION_MODAL;
IFnss file_cb = NULL;
Widget preview_canvas = NULL;
char* value;
iupAttribSetInt(ih, "_IUPDLG_X", x); /* used in iupDialogUpdatePosition */
iupAttribSetInt(ih, "_IUPDLG_Y", y);
value = iupAttribGetStr(ih, "DIALOGTYPE");
if (iupStrEqualNoCase(value, "SAVE"))
dialogtype = IUP_DIALOGSAVE;
else if (iupStrEqualNoCase(value, "DIR"))
dialogtype = IUP_DIALOGDIR;
else
dialogtype = IUP_DIALOGOPEN;
iupAttribSetInt(ih, "_IUPDLG_DIALOGTYPE", dialogtype);
if (parent)
{
filebox = XmCreateFileSelectionDialog(parent, "filedialog", NULL, 0);
dialog = XtParent(filebox);
}
else
{
dialog = XtAppCreateShell(NULL, "filedialog", topLevelShellWidgetClass, iupmot_display, NULL, 0);
filebox = XmCreateFileSelectionBox(dialog, "filebox", NULL, 0);
style = XmDIALOG_MODELESS;
XtVaSetValues(dialog,
XmNmwmInputMode, MWM_INPUT_FULL_APPLICATION_MODAL,
XmNmappedWhenManaged, False,
XmNsaveUnder, True,
NULL);
}
if (!filebox)
return IUP_NOERROR;
if (!iupAttribGetBoolean(ih, "SHOWHIDDEN"))
XtVaSetValues(filebox, XmNfileFilterStyle, XmFILTER_HIDDEN_FILES, NULL);
value = iupAttribGet(ih, "TITLE");
if (!value)
{
if (dialogtype == IUP_DIALOGSAVE)
value = "IUP_SAVEAS";
else if (dialogtype == IUP_DIALOGOPEN)
value = "IUP_OPEN";
else
value = "IUP_SELECTDIR";
iupAttribSetStr(ih, "TITLE", iupStrMessageGet(value));
}
iupmotSetString(filebox, XmNdialogTitle, value);
XtVaSetValues(filebox,
XmNdialogStyle, style,
XmNautoUnmanage, False,
NULL);
if (dialogtype == IUP_DIALOGDIR)
XtVaSetValues(filebox, XmNfileTypeMask, XmFILE_DIRECTORY, NULL);
/* just check for the path inside FILE */
value = iupAttribGet(ih, "FILE");
if (value && value[0] == '/')
{
char* dir = iupStrFileGetPath(value);
iupAttribStoreStr(ih, "DIRECTORY", dir);
free(dir);
}
/* set XmNdirectory before XmNpattern and before XmNdirSpec */
value = iupAttribGet(ih, "DIRECTORY");
if (value)
iupmotSetString(filebox, XmNdirectory, value);
value = iupAttribGet(ih, "FILTER");
if (value)
{
char *filter = value;
char *p = strchr(value, ';');
if (p)
{
int size = p-value;
filter = (char*)malloc(size+1);
memcpy(filter, value, size);
filter[size] = 0;
}
iupmotSetString(filebox, XmNpattern, filter);
if (filter != value)
free(filter);
}
value = iupAttribGet(ih, "FILE");
if (value)
{
char* file = value;
if (value[0] != '/') /* if does not contains a full path, then add the directory */
{
char* cur_dir = NULL;
char* dir = iupAttribGet(ih, "DIRECTORY");
if (!dir)
{
cur_dir = iupdrvGetCurrentDirectory();
dir = cur_dir;
}
file = iupStrFileMakeFileName(dir, value);
if (cur_dir)
free(cur_dir);
}
/* clear value before setting. Do not know why we have to do this,
but if not cleared it will fail to set the XmNdirSpec value. */
iupmotSetString(filebox, XmNdirSpec, "");
iupmotSetString(filebox, XmNdirSpec, file);
if (file != value)
free(file);
}
if (!IupGetCallback(ih, "HELP_CB"))
XtUnmanageChild(XmFileSelectionBoxGetChild(filebox, XmDIALOG_HELP_BUTTON));
XtAddCallback(filebox, XmNokCallback, (XtCallbackProc)motFileDlgCallback, (XtPointer)ih);
XtAddCallback(filebox, XmNcancelCallback, (XtCallbackProc)motFileDlgCallback, (XtPointer)ih);
XtAddCallback(filebox, XmNhelpCallback, (XtCallbackProc)motFileDlgHelpCallback, (XtPointer)ih);
if (dialogtype == IUP_DIALOGDIR)
{
Widget new_folder = XtVaCreateManagedWidget("new_folder", xmPushButtonWidgetClass, filebox,
XmNlabelType, XmSTRING,
NULL);
iupmotSetString(new_folder, XmNlabelString, iupStrMessageGet("IUP_CREATEFOLDER"));
XtAddCallback(new_folder, XmNactivateCallback, (XtCallbackProc)motFileDlgNewFolderCallback, (XtPointer)filebox);
}
else
{
file_cb = (IFnss)IupGetCallback(ih, "FILE_CB");
if (file_cb)
{
Widget list = XmFileSelectionBoxGetChild(filebox, XmDIALOG_LIST);
XtAddCallback(list, XmNbrowseSelectionCallback, (XtCallbackProc)motFileDlgBrowseSelectionCallback, (XtPointer)ih);
list = XmFileSelectionBoxGetChild(filebox, XmDIALOG_DIR_LIST);
XtAddCallback(list, XmNbrowseSelectionCallback, (XtCallbackProc)motFileDlgBrowseSelectionCallback, (XtPointer)ih);
if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
{
Widget frame = XtVaCreateManagedWidget("preview_canvas", xmFrameWidgetClass, filebox,
XmNshadowType, XmSHADOW_ETCHED_IN,
NULL);
preview_canvas = XtVaCreateManagedWidget("preview_canvas", xmDrawingAreaWidgetClass, frame,
XmNwidth, 180,
XmNheight, 150,
XmNresizePolicy, XmRESIZE_GROW,
NULL);
XtAddCallback(preview_canvas, XmNexposeCallback, (XtCallbackProc)motFileDlgPreviewCanvasExposeCallback, (XtPointer)ih);
XtAddCallback(preview_canvas, XmNresizeCallback, (XtCallbackProc)motFileDlgPreviewCanvasResizeCallback, (XtPointer)ih);
iupAttribSetStr(ih, "_IUPDLG_FILEBOX", (char*)filebox);
}
}
}
XmAddWMProtocolCallback(dialog, iupmot_wm_deletewindow, motFileDlgCBclose, (XtPointer)ih);
XtManageChild(filebox);
XtRealizeWidget(dialog);
ih->handle = dialog;
iupDialogUpdatePosition(ih);
ih->handle = NULL; /* reset handle */
if (file_cb)
{
if (preview_canvas)
motFileDlgPreviewCanvasInit(ih, preview_canvas);
file_cb(ih, NULL, "INIT");
}
if (style == XmDIALOG_MODELESS)
XtPopup(dialog, XtGrabExclusive);
/* while the user hasn't provided an answer, simulate main loop.
** The answer changes as soon as the user selects one of the
** buttons and the callback routine changes its value. */
iupAttribSetStr(ih, "STATUS", NULL);
while (iupAttribGet(ih, "STATUS") == NULL)
XtAppProcessEvent(iupmot_appcontext, XtIMAll);
if (file_cb)
{
if (preview_canvas)
XFreeGC(iupmot_display, (GC)iupAttribGet(ih, "PREVIEWDC"));
file_cb(ih, NULL, "FINISH");
}
if (!iupAttribGet(ih, "_IUP_WM_DELETE"))
{
XtUnmanageChild(filebox);
if (style == XmDIALOG_MODELESS)
{
XtPopdown(dialog);
XtDestroyWidget(dialog);
}
}
return IUP_NOERROR;
}
int MwListBox(Widget pw, char *text, char *choices[], int nchoices)
{
Widget form, buttonframe,
buttonbox, label, viewport, listframe, list,
okbutton, cancelbutton;
int n;
XtAppContext app_context = XtWidgetToApplicationContext(pw);
Screen *s = XtScreen(pw);
unsigned long white = WhitePixelOfScreen(s);
listshell = XtVaCreatePopupShell("lsel_shell",
transientShellWidgetClass, pw,
XtNtitle, _("List"),
XtNwidth, 300,
XtNheight, 300,
(char *)0);
form = XtVaCreateManagedWidget("lsel_form",
mwRudegridWidgetClass, listshell,
XtNxLayout, "5 100% 5",
XtNyLayout, "5 100% 5 35",
(char *)0);
buttonframe = XtVaCreateManagedWidget("lsel_buttonframe",
mwFrameWidgetClass, form,
XtNgridy, 3,
XtNgridWidth, 3,
XtNshadowWidth, 1,
(char *)0);
buttonbox = XtVaCreateManagedWidget("lsel_buttonbox",
boxWidgetClass, buttonframe,
XtNborderWidth, 0,
(char *)0);
listframe = XtVaCreateManagedWidget("lsel_listframe",
mwFrameWidgetClass, form,
XtNgridx, 1,
XtNgridy, 1,
XtNshadowType, Groove,
XtNmarginWidth, 2,
XtNmarginHeight, 2,
XtNallowResize, False,
(char *)0);
label = XtVaCreateManagedWidget("lsel_label",
labelWidgetClass, listframe,
(char *)0);
MwLabelSet(label, text);
XtVaSetValues(listframe,
XtNtitle, label,
(char *)0);
viewport = XtVaCreateManagedWidget("lsel_viewport",
viewportWidgetClass, listframe,
XtNforceBars, True,
XtNborderWidth, 0,
(char *)0);
list = XtVaCreateManagedWidget("lsel_list",
listWidgetClass, viewport,
XtNbackground, white,
(char *)0);
XawListChange(list, choices, nchoices, 0, True);
XtVaSetValues(list, XtNwidth, MwWidthGet(list)+20, (char *)0);
okbutton = add_button(buttonbox, "lsel_okbutton",
"OK", listsel_clicked, (XtPointer)1);
cancelbutton = add_button(buttonbox, "lsel_cancelbutton",
"Cancel", listsel_clicked, (XtPointer)0);
status = MW_WAITING;
MwCenter(listshell);
XtPopup(listshell, XtGrabNonexclusive);
XawListChange(list, choices, nchoices, 0, True);
wm_del(listshell);
while (status == MW_WAITING) {
XEvent event_return;
XtAppNextEvent(app_context, &event_return);
XtDispatchEvent(&event_return);
}
n = XawListShowCurrent(list)->list_index;
XtDestroyWidget(listshell);
if (status != MW_ABORT) /* clicked OK */
return n;
else /* clicked Cancel */
return -1;
}
void wxBitmapButton::OnSetBitmap()
{
wxBitmapButtonBase::OnSetBitmap();
if ( m_bitmapsOriginal[State_Normal].IsOk() )
{
Pixmap pixmap = 0;
Pixmap insensPixmap = 0;
Pixmap armPixmap = 0;
// Must re-make the bitmap to have its transparent areas drawn
// in the current widget background colour.
if ( m_bitmapsOriginal[State_Normal].GetMask() )
{
WXPixel backgroundPixel;
XtVaGetValues((Widget) m_mainWidget,
XmNbackground, &backgroundPixel,
NULL);
wxColour col;
col.SetPixel(backgroundPixel);
wxBitmap newBitmap =
wxCreateMaskedBitmap(m_bitmapsOriginal[State_Normal], col);
m_bitmaps[State_Normal] = newBitmap;
m_bitmapCache.SetBitmap( m_bitmaps[State_Normal] );
pixmap = (Pixmap) m_bitmaps[State_Normal].GetDrawable();
}
else
{
m_bitmapCache.SetBitmap( m_bitmaps[State_Normal] );
pixmap = (Pixmap) m_bitmapCache.GetLabelPixmap(m_mainWidget);
}
if (m_bitmapsOriginal[State_Disabled].IsOk())
{
if (m_bitmapsOriginal[State_Disabled].GetMask())
{
WXPixel backgroundPixel;
XtVaGetValues((Widget) m_mainWidget,
XmNbackground, &backgroundPixel,
NULL);
wxColour col;
col.SetPixel(backgroundPixel);
wxBitmap newBitmap =
wxCreateMaskedBitmap(m_bitmapsOriginal[State_Disabled], col);
m_bitmaps[State_Disabled] = newBitmap;
insensPixmap = (Pixmap) m_bitmaps[State_Disabled].GetDrawable();
}
else
insensPixmap = (Pixmap) m_bitmapCache.GetInsensPixmap(m_mainWidget);
}
else
insensPixmap = (Pixmap) m_bitmapCache.GetInsensPixmap(m_mainWidget);
// Now make the bitmap representing the armed state
if (m_bitmapsOriginal[State_Pressed].IsOk())
{
if (m_bitmapsOriginal[State_Pressed].GetMask())
{
WXPixel backgroundPixel;
XtVaGetValues((Widget) m_mainWidget,
XmNarmColor, &backgroundPixel,
NULL);
wxColour col;
col.SetPixel(backgroundPixel);
wxBitmap newBitmap =
wxCreateMaskedBitmap(m_bitmapsOriginal[State_Pressed], col);
m_bitmaps[State_Pressed] = newBitmap;
armPixmap = (Pixmap) m_bitmaps[State_Pressed].GetDrawable();
}
else
armPixmap = (Pixmap) m_bitmapCache.GetArmPixmap(m_mainWidget);
}
else
armPixmap = (Pixmap) m_bitmapCache.GetArmPixmap(m_mainWidget);
XtVaSetValues ((Widget) m_mainWidget,
XmNlabelPixmap, pixmap,
XmNlabelInsensitivePixmap, insensPixmap,
XmNarmPixmap, armPixmap,
XmNlabelType, XmPIXMAP,
NULL);
}
else
{
// Null bitmap: must not use current pixmap
// since it is no longer valid.
XtVaSetValues ((Widget) m_mainWidget,
XmNlabelType, XmSTRING,
XmNlabelPixmap, XmUNSPECIFIED_PIXMAP,
XmNlabelInsensitivePixmap, XmUNSPECIFIED_PIXMAP,
XmNarmPixmap, XmUNSPECIFIED_PIXMAP,
NULL);
}
}
void writesdm(char *filename)
{
cdmObjectHandle ds, mesh, meshref;
cdmObjectHandle PtVec3C, PtScalarT, ZoneScalarT, FldHandle;
cdm_int64 status;
short flag;
long i, j, nvect;
char str2[] = "Error - cannot open file: ";
XmString string, string1, string2;
double *temparray, *tempvect1, *tempvect2, *tempvect3;
/* Create the dataset that contains the field data. */
printf("\nStoring Field data in CDM file \"%s\".\n", filename);
ds = cdmDataset_Create(cdmHDF5, cdmCreate, filename);
if (ds < 0)
{
errorfile = 0;
string1 = XmStringLtoRCreate(str2,
XmSTRING_DEFAULT_CHARSET);
string2 = XmStringLtoRCreate(filnam,
XmSTRING_DEFAULT_CHARSET);
string = XmStringConcat(string1,string2);
XtVaSetValues(objerrlab,XmNlabelString,string,NULL);
XmStringFree(string);
XmStringFree(string1);
XmStringFree(string2);
MyManageChild(errorform);
return;
}
mesh = cdmGenPolyhedralMesh_Create(ds, 3, 3, nnodes, "XCMUPoly3DMesh");
if (mesh < 0)
{
printf("Cannot create mesh.\n");
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMesh_Commit(mesh);
/* Write velocities. */
flag = -1;
if (nvectin > -1) flag = 1;
else if (cvectin > -1) flag = 0;
if (flag > -1)
{
/* Define velocity field template. */
PtVec3C = cdmGenPolyhedralMeshFieldTemplate_Create(ds, mesh, 3,
"ThreeCompPtVector");
if (PtVec3C < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefCellCategory(PtVec3C, 1,
cdm0Cell);
if (status < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefDataType(PtVec3C, 1,
cdmFloat64);
if (status < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefCellCategory(PtVec3C, 2,
cdm0Cell);
if (status < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefDataType(PtVec3C, 2,
cdmFloat64);
if (status < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefCellCategory(PtVec3C, 3,
cdm0Cell);
if (status < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefDataType(PtVec3C, 3,
cdmFloat64);
if (status < 0)
{
printf("Cannot create ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_Commit(PtVec3C);
if (status < 0)
{
printf("Cannot commit ThreeCompPtVector template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
/* Fill vector arrays. */
if (flag == 1)
{
nvect = nnodes;
tempvect1 = (double *)malloc((nnodes+1)*sizeof(double));
tempvect2 = (double *)malloc((nnodes+1)*sizeof(double));
tempvect3 = (double *)malloc((nnodes+1)*sizeof(double));
fillnodevalue(vectfldx,tempvect1);
fillnodevalue(vectfldy,tempvect2);
fillnodevalue(vectfldz,tempvect3);
}
else
{
nvect = ncells;
tempvect1 = (double *)malloc((ncells+1)*sizeof(double));
tempvect2 = (double *)malloc((ncells+1)*sizeof(double));
tempvect3 = (double *)malloc((ncells+1)*sizeof(double));
fillcellvalue(cvectfldx,tempvect1+1);
fillcellvalue(cvectfldy,tempvect2+1);
fillcellvalue(cvectfldz,tempvect3+1);
}
/* Store vector data. */
FldHandle = cdmGenPolyhedralMeshField_Create(ds, PtVec3C, "Velocity");
if (FldHandle < 0)
{
printf("Cannot create Velocity field.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
printf("\nStoring first velocity component with %ld values.\n",nvect);
status = cdmGenPolyhedralMeshField_DefFieldVals(FldHandle,1,1,nvect,1,
tempvect1+1);
if (status < 0)
{
printf("Cannot create Velocity field.\n");
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
printf("\nStoring second velocity component with %ld values.\n",nvect);
status = cdmGenPolyhedralMeshField_DefFieldVals(FldHandle,1,1,nvect,1,
tempvect2+1);
if (status < 0)
{
printf("Cannot create Velocity field.\n");
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
printf("\nStoring third velocity component with %ld values.\n",nvect);
status = cdmGenPolyhedralMeshField_DefFieldVals(FldHandle,1,1,nvect,1,
tempvect3+1);
if (status < 0)
{
printf("Cannot create Velocity field.\n");
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
free(tempvect1); free(tempvect2); free(tempvect3);
status = cdmGenPolyhedralMeshField_Commit(FldHandle);
if (status < 0)
{
printf("Cannot create Velocity field.\n");
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
}
/* Define point scalar field template, if field data exists. */
flag = 0;
for (i = 0; i < MAXFIELDS; i++) flag += nvars_to_write[i];
if (flag > 0)
{
PtScalarT = cdmGenPolyhedralMeshFieldTemplate_Create(ds, mesh, 1,
"PointScalarT");
if (PtScalarT < 0)
{
printf("Cannot create PointScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefCellCategory(PtScalarT, 1,
cdm0Cell);
if (status < 0)
{
printf("Cannot create PointScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefDataType(PtScalarT, 1,
cdmFloat64);
if (status < 0)
{
printf("Cannot create PointScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_Commit(PtScalarT);
if (status < 0)
{
printf("Cannot commit PointScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
/* Loop through node fields and store data. */
temparray = (double *)malloc((nnodes+1)*sizeof(double));
for (i = 0; i < MAXFIELDS; i++)
{
if (nvars_to_write[i])
{
FldHandle = cdmGenPolyhedralMeshField_Create(ds, PtScalarT,
fieldname[i]);
if (FldHandle < 0)
{
printf("Cannot create point scalar field \"%s\".\n",
fieldname[i]);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
fillnodevalue(i,temparray);
printf("\nStoring point component %s with %ld values.\n",
fieldname[i], nnodes);
status = cdmGenPolyhedralMeshField_DefFieldVals(FldHandle, 1, 1,
nnodes, 1, temparray+1);
if (status < 0)
{
printf("Cannot create point scalar field \"%s\".\n",
fieldname[i]);
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshField_Commit(FldHandle);
if (status < 0)
{
printf("Cannot create point scalar field \"%s\".\n",
fieldname[i]);
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
cdmGenPolyhedralMeshField_Delete(FldHandle);
}
}
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
free(temparray);
}
/* Define cell scalar field template, if field data exists. */
flag = 0;
for (i = 0; i < MAXFIELDS; i++) flag += cvars_to_write[i];
if (flag > 0)
{
ZoneScalarT = cdmGenPolyhedralMeshFieldTemplate_Create(ds, mesh, 1,
"ZoneScalarT");
if (ZoneScalarT < 0)
{
printf("Cannot create ZoneScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefCellCategory(ZoneScalarT, 1,
cdm0Cell);
if (status < 0)
{
printf("Cannot create ZoneScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_DefDataType(ZoneScalarT, 1,
cdmFloat64);
if (status < 0)
{
printf("Cannot create ZoneScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshFieldTemplate_Commit(ZoneScalarT);
if (status < 0)
{
printf("Cannot commit ZoneScalarT template.\n");
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
/* Loop through cell fields and store data. */
temparray = (double *)malloc((ncells)*sizeof(double));
for (i = 0; i < MAXFIELDS; i++)
{
if (cvars_to_write[i])
{
FldHandle = cdmGenPolyhedralMeshField_Create(ds, ZoneScalarT,
cfieldname[i]);
if (FldHandle < 0)
{
printf("Cannot create zone scalar field \"%s\".\n",
cfieldname[i]);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
fillcellvalue(i,temparray);
printf("\nStoring zone component %s with %ld values.\n",
cfieldname[i], ncells);
status = cdmGenPolyhedralMeshField_DefFieldVals(FldHandle, 1, 1,
ncells, 1, temparray);
if (status < 0)
{
printf("Cannot create zone scalar field \"%s\".\n",
cfieldname[i]);
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
status = cdmGenPolyhedralMeshField_Commit(FldHandle);
if (status < 0)
{
printf("Cannot create zone scalar field \"%s\".\n",
cfieldname[i]);
cdmGenPolyhedralMeshField_Delete(FldHandle);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtScalarT);
cdmGenPolyhedralMeshFieldTemplate_Delete(PtVec3C);
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
return;
}
cdmGenPolyhedralMeshField_Delete(FldHandle);
}
}
free(temparray);
cdmGenPolyhedralMeshFieldTemplate_Delete(ZoneScalarT);
}
/* Cleanup. */
cdmGenPolyhedralMesh_Delete(mesh);
cdmDataset_Delete(ds);
}
void create_hotlinks_popup(Widget, XtPointer, XtPointer)
{
int x, y;
static Widget top, dialog;
Arg args[3];
set_wait_cursor();
if (top == NULL)
{
char *label1[5];
Widget but1[5];
label1[0] = (char *)"Link";
label1[1] = (char *)"Files...";
label1[2] = (char *)"Unlink";
label1[3] = (char *)"Update";
label1[4] = (char *)"Close";
XmGetPos(app_shell, 0, &x, &y);
top = XmCreateDialogShell(app_shell, (char *)"Hot links", NULL, 0);
handle_close(top);
XtVaSetValues(top, XmNx, x, XmNy, y, NULL);
dialog = XmCreateRowColumn(top, (char *)"dialog_rc", NULL, 0);
XtSetArg(args[0], XmNlistSizePolicy, XmRESIZE_IF_POSSIBLE);
XtSetArg(args[1], XmNvisibleItemCount, 5);
hotlink_list_item = XmCreateScrolledList(dialog, (char *)"list", args, 2);
XtManageChild(hotlink_list_item);
hotlink_set_item = CreateSetSelector(dialog, "Link set:",
SET_SELECT_ACTIVE,
FILTER_SELECT_ALL,
GRAPH_SELECT_CURRENT,
SELECTION_TYPE_MULTIPLE);
DefineSetSelectorFilter(&hotlink_set_item);
hotlink_file_item = CreateTextItem2(dialog, 30, "To file or pipe:");
hotlink_source_item = CreatePanelChoice(dialog, "Source: ", 3,
"Disk file",
"Pipe",
NULL,
NULL);
XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, dialog, NULL);
CreateCommandButtons(dialog, 5, but1, label1);
XtAddCallback(but1[0], XmNactivateCallback, (XtCallbackProc)do_hotlink_proc,
(XtPointer)NULL);
XtAddCallback(but1[1], XmNactivateCallback, (XtCallbackProc)create_hotfiles_popup,
(XtPointer)NULL);
XtAddCallback(but1[2], XmNactivateCallback, (XtCallbackProc)do_hotunlink_proc,
(XtPointer)NULL);
XtAddCallback(but1[3], XmNactivateCallback, (XtCallbackProc)do_hotupdate_proc,
(XtPointer)NULL);
XtAddCallback(but1[4], XmNactivateCallback, (XtCallbackProc)destroy_dialog,
(XtPointer)top);
XtManageChild(dialog);
hotlink_frame = top;
}
XtRaise(top);
update_hotlinks();
unset_wait_cursor();
}
int wxFileDialog::ShowModal()
{
WX_HOOK_MODAL_DIALOG();
wxBeginBusyCursor();
// static char fileBuf[512];
Widget parentWidget = (Widget) 0;
if (m_parent)
parentWidget = (Widget) m_parent->GetTopWidget();
else
parentWidget = (Widget) wxTheApp->GetTopLevelWidget();
// prepare the arg list
Display* dpy = XtDisplay(parentWidget);
Arg args[10];
int ac = 0;
if (m_backgroundColour.IsOk())
{
wxComputeColours (dpy, & m_backgroundColour, NULL);
XtSetArg(args[ac], XmNbackground, g_itemColors[wxBACK_INDEX].pixel); ac++;
XtSetArg(args[ac], XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel); ac++;
XtSetArg(args[ac], XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel); ac++;
XtSetArg(args[ac], XmNforeground, g_itemColors[wxFORE_INDEX].pixel); ac++;
}
wxFont font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
#if __WXMOTIF20__ && !__WXLESSTIF__
XtSetArg(args[ac], XmNbuttonRenderTable, font.GetFontTypeC(dpy)); ac++;
XtSetArg(args[ac], XmNlabelRenderTable, font.GetFontTypeC(dpy)); ac++;
XtSetArg(args[ac], XmNtextRenderTable, font.GetFontTypeC(dpy)); ac++;
#else
XtSetArg(args[ac], XmNbuttonFontList, font.GetFontTypeC(dpy)); ac++;
XtSetArg(args[ac], XmNlabelFontList, font.GetFontTypeC(dpy)); ac++;
XtSetArg(args[ac], XmNtextFontList, font.GetFontTypeC(dpy)); ac++;
#endif
Widget fileSel = XmCreateFileSelectionDialog(parentWidget,
wxMOTIF_STR("file_selector"),
args, ac);
#define wxFSChild( name ) \
XmFileSelectionBoxGetChild(fileSel, name)
XtUnmanageChild(wxFSChild(XmDIALOG_HELP_BUTTON));
Widget filterWidget = wxFSChild(XmDIALOG_FILTER_TEXT);
Widget selectionWidget = wxFSChild(XmDIALOG_TEXT);
Widget dirListWidget = wxFSChild(XmDIALOG_DIR_LIST);
Widget fileListWidget = wxFSChild(XmDIALOG_LIST);
// for changing labels
Widget okWidget = wxFSChild(XmDIALOG_OK_BUTTON);
Widget applyWidget = wxFSChild(XmDIALOG_APPLY_BUTTON);
Widget cancelWidget = wxFSChild(XmDIALOG_CANCEL_BUTTON);
Widget dirlistLabel = wxFSChild(XmDIALOG_DIR_LIST_LABEL);
Widget filterLabel = wxFSChild(XmDIALOG_FILTER_LABEL);
Widget listLabel = wxFSChild(XmDIALOG_LIST_LABEL);
Widget selectionLabel = wxFSChild(XmDIALOG_SELECTION_LABEL);
#undef wxFSChild
// change labels
wxXmString btnOK( wxGetStockLabel( wxID_OK, false ) ),
btnCancel( wxGetStockLabel( wxID_CANCEL, false ) ),
btnFilter( _("Filter") ), lblFilter( _("Filter") ),
lblDirectories( _("Directories") ),
lblFiles( _("Files" ) ), lblSelection( _("Selection") );
XtVaSetValues( okWidget, XmNlabelString, btnOK(), NULL );
XtVaSetValues( applyWidget, XmNlabelString, btnFilter(), NULL );
XtVaSetValues( cancelWidget, XmNlabelString, btnCancel(), NULL );
XtVaSetValues( dirlistLabel, XmNlabelString, lblDirectories(), NULL );
XtVaSetValues( filterLabel, XmNlabelString, lblFilter(), NULL );
XtVaSetValues( listLabel, XmNlabelString, lblFiles(), NULL );
XtVaSetValues( selectionLabel, XmNlabelString, lblSelection(), NULL );
Widget shell = XtParent(fileSel);
if ( !m_message.empty() )
XtVaSetValues(shell,
XmNtitle, (const char*)m_message.mb_str(),
NULL);
if (!m_wildCard.empty())
{
// return something understandable by Motif
wxString wildCard = ParseWildCard( m_wildCard );
wxString filter;
if (!m_dir.empty())
filter = m_dir + wxString("/") + wildCard;
else
filter = wildCard;
XmTextSetString(filterWidget, filter.char_str());
XmFileSelectionDoSearch(fileSel, NULL);
}
// Suggested by Terry Gitnick, 16/9/97, because of change in Motif
// file selector on Solaris 1.5.1.
if ( !m_dir.empty() )
{
wxXmString thePath( m_dir );
XtVaSetValues (fileSel,
XmNdirectory, thePath(),
NULL);
}
wxString entirePath;
if (!m_dir.empty())
{
entirePath = m_dir + wxString("/") + m_fileName;
}
else
{
entirePath = m_fileName;
}
if (!entirePath.empty())
{
XmTextSetString(selectionWidget, entirePath.char_str());
}
XtAddCallback(fileSel, XmNcancelCallback,
(XtCallbackProc)wxFileSelCancel, (XtPointer)NULL);
XtAddCallback(fileSel, XmNokCallback,
(XtCallbackProc)wxFileSelOk, (XtPointer)NULL);
XtAddCallback(fileSel, XmNunmapCallback,
(XtCallbackProc)wxFileSelClose, (XtPointer)this);
//#if XmVersion > 1000
// I'm not sure about what you mean with XmVersion.
// If this is for Motif1.1/Motif1.2, then check XmVersion>=1200
// (Motif1.1.4 ==> XmVersion 1100 )
// Nevertheless, I put here a #define, so anyone can choose in (I)makefile.
//
#if !DEFAULT_FILE_SELECTOR_SIZE
int width = wxFSB_WIDTH;
int height = wxFSB_HEIGHT;
XtVaSetValues(fileSel,
XmNwidth, width,
XmNheight, height,
XmNresizePolicy, XmRESIZE_NONE,
NULL);
#endif
wxDoChangeBackgroundColour((WXWidget) filterWidget, *wxWHITE);
wxDoChangeBackgroundColour((WXWidget) selectionWidget, *wxWHITE);
wxChangeListBoxColours(this, dirListWidget);
wxChangeListBoxColours(this, fileListWidget);
XtManageChild(fileSel);
m_fileSelectorAnswer = wxEmptyString;
m_fileSelectorReturned = false;
wxEndBusyCursor();
XtAddGrab(XtParent(fileSel), True, False);
XtAppContext context = (XtAppContext) wxTheApp->GetAppContext();
XEvent event;
while (!m_fileSelectorReturned)
{
XtAppNextEvent(context, &event);
XtDispatchEvent(&event);
}
XtRemoveGrab(XtParent(fileSel));
XtUnmapWidget(XtParent(fileSel));
XtDestroyWidget(XtParent(fileSel));
// Now process all events, because otherwise
// this might remain on the screen
wxFlushEvents(XtDisplay(fileSel));
m_path = m_fileSelectorAnswer;
m_fileName = wxFileNameFromPath(m_fileSelectorAnswer);
m_dir = wxPathOnly(m_path);
if (m_fileName.empty())
return wxID_CANCEL;
else
return wxID_OK;
}
void fillIn(Widget w)
{
XtVaSetValues(w, XtNsensitive, (XtArgVal) True, NULL);
}
static int motButtonMapMethod(Ihandle* ih)
{
char* value;
int num_args = 0;
Arg args[30];
value = iupAttribGet(ih, "IMAGE");
if (value)
{
ih->data->type = IUP_BUTTON_IMAGE;
iupMOT_SETARG(args, num_args, XmNlabelType, XmPIXMAP);
}
else
{
ih->data->type = IUP_BUTTON_TEXT;
iupMOT_SETARG(args, num_args, XmNlabelType, XmSTRING);
}
/* Core */
iupMOT_SETARG(args, num_args, XmNmappedWhenManaged, False); /* not visible when managed */
iupMOT_SETARG(args, num_args, XmNx, 0); /* x-position */
iupMOT_SETARG(args, num_args, XmNy, 0); /* y-position */
iupMOT_SETARG(args, num_args, XmNwidth, 10); /* default width to avoid 0 */
iupMOT_SETARG(args, num_args, XmNheight, 10); /* default height to avoid 0 */
/* Label */
iupMOT_SETARG(args, num_args, XmNrecomputeSize, False); /* no automatic resize from text */
iupMOT_SETARG(args, num_args, XmNmarginHeight, 0); /* default padding */
iupMOT_SETARG(args, num_args, XmNmarginWidth, 0);
iupMOT_SETARG(args, num_args, XmNmarginTop, 0); /* no extra margins */
iupMOT_SETARG(args, num_args, XmNmarginLeft, 0);
iupMOT_SETARG(args, num_args, XmNmarginBottom, 0);
iupMOT_SETARG(args, num_args, XmNmarginRight, 0);
/* PushButton */
iupMOT_SETARG(args, num_args, XmNfillOnArm, False);
/* Primitive */
if (iupAttribGetBoolean(ih, "CANFOCUS"))
iupMOT_SETARG(args, num_args, XmNtraversalOn, True);
else
iupMOT_SETARG(args, num_args, XmNtraversalOn, False);
iupMOT_SETARG(args, num_args, XmNhighlightThickness, 2);
iupMOT_SETARG(args, num_args, XmNnavigationType, XmTAB_GROUP);
ih->handle = XtCreateManagedWidget(
iupDialogGetChildIdStr(ih), /* child identifier */
xmPushButtonWidgetClass, /* widget class */
iupChildTreeGetNativeParentHandle(ih), /* widget parent */
args, num_args);
if (!ih->handle)
return IUP_ERROR;
ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
value = iupAttribGet(ih, "IMPRESS");
if (iupAttribGetBoolean(ih, "FLAT") && !value)
{
XtVaSetValues(ih->handle, XmNshadowThickness, 0, NULL);
XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)motButtonEnterLeaveWindowEvent, (XtPointer)ih);
XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)motButtonEnterLeaveWindowEvent, (XtPointer)ih);
}
else
{
if (value && !iupAttribGetBoolean(ih, "IMPRESSBORDER"))
{
/* In Motif the button will lose its focus feedback also */
XtVaSetValues(ih->handle, XmNhighlightThickness, 0, NULL);
XtVaSetValues(ih->handle, XmNshadowThickness, 0, NULL);
}
else
XtVaSetValues(ih->handle, XmNshadowThickness, 2, NULL);
XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
}
XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
XtAddEventHandler(ih->handle, KeyPressMask, False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
XtAddCallback(ih->handle, XmNactivateCallback, (XtCallbackProc)motButtonActivateCallback, (XtPointer)ih);
XtAddEventHandler(ih->handle, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)iupmotButtonPressReleaseEvent, (XtPointer)ih);
/* Disable Drag Source */
iupmotDisableDragSource(ih->handle);
/* initialize the widget */
XtRealizeWidget(ih->handle);
if (ih->data->type == IUP_BUTTON_TEXT)
iupmotSetString(ih->handle, XmNlabelString, "");
return IUP_NOERROR;
}
void wxSlider::SetValue(int value)
{
XtVaSetValues ((Widget) m_mainWidget, XmNvalue, value, NULL);
}
