void
DmxPrintOutput::setPageMargin (
_DtPrintMarginEnum which,
const char *margin,
DtMailBoolean *parse_error
)
{
int pixels = 0;
XtEnum xt_parse_error = FALSE;
char *marginstring = strdup(margin);
if (parse_error)
*parse_error = DTM_FALSE;
switch (which)
{
case DTPRINT_OPTION_MARGIN_TOP:
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
marginstring,
XmVERTICAL,
XmPIXELS,
&xt_parse_error);
if (!xt_parse_error && pixels > 0)
_margin_top = pixels;
break;
case DTPRINT_OPTION_MARGIN_RIGHT:
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
marginstring,
XmHORIZONTAL,
XmPIXELS,
&xt_parse_error);
if (!xt_parse_error && pixels > 0)
_margin_right = pixels;
break;
case DTPRINT_OPTION_MARGIN_BOTTOM:
_margin_bottom = pixels;
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
marginstring,
XmVERTICAL,
XmPIXELS,
&xt_parse_error);
if (!xt_parse_error && pixels > 0)
_margin_bottom = pixels;
break;
case DTPRINT_OPTION_MARGIN_LEFT:
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
marginstring,
XmHORIZONTAL,
XmPIXELS,
&xt_parse_error);
if (!xt_parse_error && pixels > 0)
_margin_left = pixels;
break;
default:
// TBD: Need to log an error.
return;
}
if (!xt_parse_error)
setInnerPageDimensions(
_margin_top,
_margin_right,
_margin_bottom,
_margin_left);
else
*parse_error = DTM_TRUE;
free(marginstring);
}
void
DmxPrintOutput::setPageMargins (
const char *top,
const char *right,
const char *bottom,
const char *left,
DtMailBoolean *parse_error
)
{
int pixels = 0;
XtEnum xt_parse_error = FALSE;
char *margin;
*parse_error = DTM_FALSE;
margin = strdup(top);
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
margin,
XmVERTICAL,
XmPIXELS,
&xt_parse_error);
free(margin);
if (!xt_parse_error && pixels > 0)
{
_margin_top = pixels;
}
else
{
*parse_error = DTM_TRUE;
return;
}
margin = strdup(right);
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
margin,
XmHORIZONTAL,
XmPIXELS,
&xt_parse_error);
free(margin);
if (!xt_parse_error && pixels > 0)
{
_margin_right = pixels;
}
else
{
*parse_error = DTM_TRUE;
return;
}
margin = strdup(bottom);
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
margin,
XmVERTICAL,
XmPIXELS,
&xt_parse_error);
free(margin);
if (!xt_parse_error && pixels > 0)
{
_margin_bottom = pixels;
}
else
{
*parse_error = DTM_TRUE;
return;
}
margin = strdup(left);
pixels = XmConvertStringToUnits(
XtScreenOfObject(_pshell),
margin,
XmHORIZONTAL,
XmPIXELS,
&xt_parse_error);
free(margin);
if (!xt_parse_error && pixels > 0)
{
_margin_left = pixels;
}
else
{
*parse_error = DTM_TRUE;
return;
}
setInnerPageDimensions(
_margin_top,
_margin_right,
_margin_bottom,
_margin_left);
}
/************************************************************************
* PrintOutputSetPageMargins
* Set the contents of all the page margins
************************************************************************/
void
PrintOutputSetPageMargins(
PrintOutput *pOutput,
const char *top,
const char *right,
const char *bottom,
const char *left,
Boolean *parseError
)
{
int pixels = 0;
XtEnum xtParseError = FALSE;
char *margin;
*parseError = FALSE;
margin = XtNewString(top);
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
margin,
XmVERTICAL,
XmPIXELS,
&xtParseError);
XtFree(margin);
if (!xtParseError && pixels > 0)
{
pOutput->marginTop = pixels;
}
else
{
*parseError = TRUE;
return;
}
margin = XtNewString(right);
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
margin,
XmHORIZONTAL,
XmPIXELS,
&xtParseError);
XtFree(margin);
if (!xtParseError && pixels > 0)
{
pOutput->marginRight = pixels;
}
else
{
*parseError = TRUE;
return;
}
margin = XtNewString(bottom);
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
margin,
XmVERTICAL,
XmPIXELS,
&xtParseError);
XtFree(margin);
if (!xtParseError && pixels > 0)
{
pOutput->marginBottom = pixels;
}
else
{
*parseError = TRUE;
return;
}
margin = XtNewString(left);
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
margin,
XmHORIZONTAL,
XmPIXELS,
&xtParseError);
XtFree(margin);
if (!xtParseError && pixels > 0)
{
pOutput->marginLeft = pixels;
}
else
{
*parseError = TRUE;
return;
}
_poSetInnerPageDimensions(
pOutput,
pOutput->marginTop,
pOutput->marginRight,
pOutput->marginBottom,
pOutput->marginLeft);
}
int
main(int argc, char *argv[])
{
#define MAIN_CHILDREN 3
#define FORM_CHILDREN 3
#define PLANE_CHILDREN 6
#define TRAFFIC_CHILDREN 3
#define SetMenuEntry(k,l,p,d) labels[k]=l;procs[k]=p;private[k]=d;
Pixmap flying;
Pixmap parked;
Pixmap mask;
Widget theWidgetRoot;
Widget main_tab[MAIN_CHILDREN];
Widget from_tab[PLANE_CHILDREN];
Widget to_tab[TRAFFIC_CHILDREN];
Widget form_tab[FORM_CHILDREN];
Widget framed[2];
Widget entry;
static char myClass[] = "XmdAirport";
Arg args[10];
int n ;
String labels[4];
XtCallbackProc procs[4];
XtPointer private[4];
XGCValues gcv;
Airport this;
/*
* Initialize
*/
this = (Airport) XtCalloc(sizeof(AirportRec), 1);
XtSetLanguageProc(NULL, (XtLanguageProc) NULL, NULL);
theWidgetRoot = XtVaOpenApplication( &this->context,
myClass,
NULL,
0,
&argc,
argv,
NULL,
sessionShellWidgetClass,
XmNallowShellResize, True,
NULL);
this->display = XtDisplay(theWidgetRoot);
FlightAtom = XmInternAtom(this->display, "FLIGHT", False);
DeleteAtom = XmInternAtom(this->display, "DELETE", False);
XtGetApplicationResources(theWidgetRoot, &AirportResources,
AirportResourcesSpecs,
XtNumber(AirportResourcesSpecs),
(ArgList) NULL, 0);
/*
* Create the Main Window, the menubar and the pulldown menus
*/
n = 0;
this->main = XmCreateMainWindow(theWidgetRoot, "main", args, n);
n = 0;
main_tab[0] = XmCreateMenuBar(this->main, "menubar", args, n);
n = 0;
SetMenuEntry(n, "Exit",
(XtCallbackProc) ExitCallback, (XtPointer) this ); n++;
entry = MenuBarEntry(main_tab[0], "File", labels, procs, private, n);
n = 0;
SetMenuEntry(0, "Tutorial",
(XtCallbackProc) HelpCallback, (XtPointer) this); n++;
entry = MenuBarEntry(main_tab[0], "Help", labels, procs, private, n);
n = 0;
XtSetArg(args[n], XmNmenuHelpWidget, entry); n++;
XtSetValues(main_tab[0], args, n);
/*
* Create the Airport widget structure.
* Two framed radio boxes show state.
* A drawing area in the middle show track and planes
*/
n = 0;
this->screen_width = WidthOfScreen(XtScreenOfObject(this->main));
this->screen_height = HeightOfScreen(XtScreenOfObject(this->main));
XtSetArg(args[n], XmNwidth, this->screen_width*3/7); n++;
XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
main_tab[1] = XmCreateForm(this->main, "airport", args, n);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM) ; n++;
form_tab[0] = XmCreateFrame(main_tab[1], "flight", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
framed[0] = XmCreateLabel(form_tab[0], "title", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++;
XtSetArg(args[n], XmNresizePolicy, XmRESIZE_GROW); n++;
XtSetArg(args[n], XmNradioBehavior, True); n++;
framed[1] = XmCreateRadioBox(form_tab[0], "panel", args, n);
n = 0;
XtSetArg(args[n], XmNset, True); n++;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.departure =
from_tab[0] = XmCreateToggleButton(framed[1],
"departure", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.over_ocean =
from_tab[1] = XmCreateToggleButton(framed[1],
"over_ocean", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.over_land =
from_tab[2] = XmCreateToggleButton(framed[1],
"over_land", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.over_site =
from_tab[3] = XmCreateToggleButton(framed[1],
"radar", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.landing =
from_tab[4] = XmCreateToggleButton(framed[1], "landing", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.landed =
from_tab[5] = XmCreateToggleButton(framed[1], "landed", args, n);
XtManageChildren(from_tab, PLANE_CHILDREN);
XtManageChildren(framed, 2);
/*
* Create the Airport Traffic control state
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM) ; n++;
form_tab[1] = XmCreateFrame(main_tab[1], "traffic", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
framed[0] = XmCreateLabel(form_tab[1], "title", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++;
XtSetArg(args[n], XmNradioBehavior, True); n++;
framed[1] = XmCreateRadioBox(form_tab[1], "traffic_box", args, n);
n = 0;
XtSetArg(args[n], XmNset, True); n++;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->to.leave =
to_tab[1] = XmCreateToggleButton(framed[1],
"no_traffic", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->to.enter =
to_tab[0] = XmCreateToggleButton(framed[1],
"radar_echo", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->to.landing =
to_tab[2] = XmCreateToggleButton(framed[1],
"landing", args, n);
XtManageChildren(to_tab, TRAFFIC_CHILDREN);
XtManageChildren(framed, 2);
/*
* Create the Airport picture
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET) ; n++;
XtSetArg(args[n], XmNleftWidget, form_tab[0]) ; n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET) ; n++;
XtSetArg(args[n], XmNrightWidget, form_tab[1]) ; n++;
this->airport =
form_tab[2] = XmCreateDrawingArea(main_tab[1], "da", args, n);
XtAddCallback(this->airport, XmNexposeCallback,
(XtCallbackProc) ShowAirport, (XtPointer) this);
XtAddCallback(this->airport, XmNresizeCallback,
(XtCallbackProc) ResizeAirport, (XtPointer) this);
XtAddCallback(this->airport, XmNinputCallback,
(XtCallbackProc) AirportInput, (XtPointer) this);
/*
* Create the Airport Message area
*/
n = 0;
main_tab[2] = XmCreateFrame(this->main, "message", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
framed[0] = XmCreateLabel(main_tab[2], "title", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++;
XtSetArg(args[n], XmNvisibleItemCount, 4); n++;
this->msg_area = XmCreateScrolledList(main_tab[2], "msg_list", args, n);
XtManageChild(this->msg_area);
framed[1] = XtParent(this->msg_area);
XtManageChildren(framed, 2);
n = 0;
XtSetArg(args[n], XmNmenuBar, main_tab[0]); n++;
XtSetArg(args[n], XmNworkWindow, main_tab[1]); n++;
XtSetArg(args[n], XmNmessageWindow, main_tab[2]); n++;
XtSetValues(this->main, args, n);
XtManageChildren(form_tab, FORM_CHILDREN);
XtManageChildren(main_tab, MAIN_CHILDREN);
XtManageChild(this->main);
XtRealizeWidget(theWidgetRoot);
/*
* Create the drag icon
*/
parked = XCreateBitmapFromData(this->display,
XtWindow(this->main), (char*)plane_bits,
plane_width, plane_height);
flying = XCreateBitmapFromData(this->display,
XtWindow(this->main), (char*)flying_bits,
flying_icon_width, flying_icon_height);
mask = XCreateBitmapFromData(this->display,
XtWindow(this->main), (char*)flying_mask_bits,
flying_mask_width, flying_mask_height);
n = 0;
XtSetArg(args[n], XmNpixmap, flying); n++;
XtSetArg(args[n], XmNdepth, 1); n++;
XtSetArg(args[n], XmNmask, mask); n++;
XtSetArg(args[n], XmNwidth, flying_icon_width); n++;
XtSetArg(args[n], XmNheight, flying_icon_height) ; n++;
this->dragIcon = XmCreateDragIcon(form_tab[2], "drag", args, n);
if (this->dragIcon == NULL) {
printf("cannot create drag icon\n");
exit(0);
}
/* Create GC for drawing planes */
gcv.function = GXcopy;
gcv.fill_style = FillOpaqueStippled;
gcv.stipple = parked;
gcv.foreground = AirportResources.spot_foreground;
gcv.background = AirportResources.spot_background;
this->park.gc = XCreateGC(this->display, XtWindow(this->main),
GCFunction|GCStipple|GCFillStyle
|GCForeground|GCBackground,
&gcv);
gcv.line_style = LineDoubleDash;
gcv.line_width = AirportResources.track_border_width;
gcv.fill_style = FillSolid;
gcv.foreground = AirportResources.track_foreground;
gcv.background = AirportResources.track_background;
this->track.gc = XCreateGC(this->display, XtWindow(this->main),
GCFunction|GCLineWidth|GCLineStyle
|GCFillStyle|GCForeground|GCBackground,
&gcv);
XtAppMainLoop(this->context);
return 0; /* make compiler happy */
}
/************************************************************************
* PrintOutputSetPageMargin
* Set the contents of the specified page margin
************************************************************************/
void
PrintOutputSetPageMargin(
PrintOutput *pOutput,
_DtPrintMarginEnum which,
const char *margin,
Boolean *parseError
)
{
int pixels = 0;
XtEnum xtParseError = FALSE;
char *marginString = XtNewString(margin);
if (parseError)
*parseError = FALSE;
switch (which)
{
case DTPRINT_OPTION_MARGIN_TOP:
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
marginString,
XmVERTICAL,
XmPIXELS,
&xtParseError);
if (!xtParseError && pixels > 0)
pOutput->marginTop = pixels;
break;
case DTPRINT_OPTION_MARGIN_RIGHT:
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
marginString,
XmHORIZONTAL,
XmPIXELS,
&xtParseError);
if (!xtParseError && pixels > 0)
pOutput->marginRight = pixels;
break;
case DTPRINT_OPTION_MARGIN_BOTTOM:
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
marginString,
XmVERTICAL,
XmPIXELS,
&xtParseError);
if (!xtParseError && pixels > 0)
pOutput->marginBottom = pixels;
break;
case DTPRINT_OPTION_MARGIN_LEFT:
pixels = XmConvertStringToUnits(
XtScreenOfObject(pOutput->pShell),
marginString,
XmHORIZONTAL,
XmPIXELS,
&xtParseError);
if (!xtParseError && pixels > 0)
pOutput->marginLeft = pixels;
break;
default:
return;
}
if (!xtParseError)
_poSetInnerPageDimensions(
pOutput,
pOutput->marginTop,
pOutput->marginRight,
pOutput->marginBottom,
pOutput->marginLeft);
else
*parseError = TRUE;
XtFree(marginString);
}
/*======================================================== DndHandleDragging
* Takes care of the drag and drop process. Wait until the pointer had moved
* a little. Then takes control over the pointer until the buttons are
* released. After that send a Drag And Drop ClientMessage event. Returns
* non-zero if a drop did take place.
*===========================================================================*/
int MwDndHandleDragging(Widget widget,XEvent *event)
{
XEvent Event;
Window root = RootWindowOfScreen(XtScreenOfObject(widget));
XtAppContext app= XtWidgetToApplicationContext(widget);
Window DispatchWindow;
int DropX,DropY;
if(Dragging) return 0;
if(abs(StartEvent.x_root - event->xmotion.x_root) < DragPrecision &&
abs(StartEvent.y_root - event->xmotion.y_root) < DragPrecision)
return 0;
XUngrabPointer(dpy,CurrentTime);
/* Take control over the pointer */
XGrabPointer(dpy,root,False,
ButtonMotionMask|ButtonPressMask|ButtonReleaseMask,
GrabModeSync,GrabModeAsync,root,
DndCursor[DataType].CursorID,
CurrentTime);
/* Wait for button release */
Dragging=1; RootFlag=0;
while(Dragging)
{
XAllowEvents(dpy,SyncPointer,CurrentTime);
XtAppNextEvent(app,&Event);
switch(Event.type)
{
case ButtonRelease:
if(Event.xbutton.subwindow)
RootFlag=0;
else
RootFlag=1;
Dragging=0;
break;
default:
XtDispatchEvent(&Event);
break;
}
}
DataOK=0;
/* Now release the pointer */
XUngrabPointer(dpy,CurrentTime);
/* Try to guess if the drop occurred in the root window */
if(!RootFlag)
{
Target=XmuClientWindow(dpy,Event.xbutton.subwindow);
if(Target==Event.xbutton.subwindow)
DispatchWindow=Target;
else
DispatchWindow=PointerWindow;
}
else
Target=DispatchWindow=XtWindow(MwDndGetMainWidget(widget));
/* Now build the event structure */
DropX=Event.xbutton.x_root;
DropY=Event.xbutton.y_root;
Event.xclient.type = ClientMessage;
Event.xclient.display = dpy;
Event.xclient.message_type = MwDndProtocol;
Event.xclient.format = 32;
Event.xclient.window = Target;
Event.xclient.data.l[0] = DataType;
Event.xclient.data.l[1] = (long)event->xbutton.state;
Event.xclient.data.l[2] = (long)XtWindow(widget);
Event.xclient.data.l[3] = DropX + 65536L*(long)DropY;
Event.xclient.data.l[4] = 1;
/* Send the drop message */
XSendEvent(dpy,DispatchWindow,True,NoEventMask,&Event);
/* Send an old style version of the message just in case */
Event.xclient.message_type = OldDndProtocol;
XSendEvent(dpy,DispatchWindow,True,NoEventMask,&Event);
#ifdef DEBUG
fprintf(stderr,"ClientMessage sent to 0x%x(0x%x).\n",
DispatchWindow,Target);
fprintf(stderr,"The drop coordinates are (%d,%d).\n",DropX,DropY);
#endif
return 1;
}
/* Function Name:
* GetClientWindow
*
* Description:
* Gets the Client's window by asking the user.
*
* Arguments:
* w - a widget.
*
* Returns:
* a clients window, or None.
*
* Calls:
* SetMessage - utils.c
*
* Global Data:
*/
Window
GetClientWindow(Widget w, int *x, int *y)
{
int status;
Cursor cursor;
XEvent event;
int buttons = 0;
int keys = 0;
Display *dpy = XtDisplayOfObject(w);
Window target_win = None;
Window root_win = RootWindowOfScreen(XtScreenOfObject(w));
XtAppContext context = XtWidgetToApplicationContext(w);
char buffer[10];
int len;
KeySym keycode;
/* >>>>> HACK for batchres */
if (global_winID != None)
{
/* we submit the winID given by parameter only once! */
/* otherwise there is an infinite loop */
target_win = global_winID;
global_winID = None;
return(target_win);
}
/* <<<<< HACK for batchres */
/* Make the target cursor */
cursor = XCreateFontCursor(dpy,
XC_crosshair);
/* Grab the pointer using target cursor, letting it room all over */
status = XGrabPointer(dpy, /* Display */
root_win, /* grab_window */
False, /* owner_events */
ButtonPressMask | ButtonReleaseMask,
GrabModeSync, /* pointer_mode */
GrabModeAsync, /* keyboard_mode */
root_win, /* confine_to */
cursor, /* cursor */
CurrentTime); /* time, when grab took place */
if (status != GrabSuccess)
{
/* "Can't grab the mouse" */
SetMessage(global_screen_data.info_label,
res_labels[5],
"Can't grab the mouse");
return(None);
} /* if (grab of mouse pointer unsuccessful) */
/* Grab the keyboard, letting it room all over */
status = XGrabKeyboard(dpy, /* Display */
root_win, /* grab_window */
False, /* owner_events */
GrabModeAsync, /* pointer_mode */
GrabModeAsync, /* keyboard_mode */
CurrentTime); /* time, when grab took place */
if (status != GrabSuccess)
{
/* "Can't grab the keyboard" */
SetMessage(global_screen_data.info_label,
res_labels[37],
"Can't grab the keyboard");
return(None);
} /* if (grab of keyboard unsuccessful) */
/* Let the user select a window... */
while ( (target_win == None) || (buttons != 0) )
{
/* printf("targetwin: 0x%x, buttons: %d\n", target_win, buttons); */
/* allow one more event */
XAllowEvents(dpy,
SyncPointer,
CurrentTime);
XtAppNextEvent(context,
&event);
switch (event.type)
{
case ButtonPress:
/* printf("ButtonWindow 0x%x\n", event.xbutton.window); */
if (event.xbutton.window != root_win)
{
XtDispatchEvent(&event);
break;
}
if (target_win == None)
{
target_win = event.xbutton.subwindow; /* window selected */
if (x != NULL)
{
*x = event.xbutton.x_root;
}
if (y != NULL)
{
*y = event.xbutton.y_root;
}
}
buttons++;
break; /* ButtonPress */
case ButtonRelease:
if (event.xbutton.window != root_win)
{
XtDispatchEvent(&event);
break;
}
if (buttons > 0) /* There may have been some */
{ /* down before we started */
buttons--;
}
break; /* ButtonRelease */
case KeyPress:
/* <Key>ESC aborts, <Key>Return + <Key>Spacebar select */
len = (XLookupString(&(event.xkey),
buffer, sizeof(buffer),
&keycode,
(XComposeStatus*)NULL));
/* printf("keycode: 0x%x\n", keycode); */
switch (keycode)
{
case XK_Return:
case XK_space:
case XK_Select:
case XK_KP_Space:
case XK_KP_Enter:
/* printf("Ret, space, Select, ...\n"); */
/* printf("KeyWindow 0x%x\n", event.xkey.window); */
/* if (event.xkey.window != root_win) */
/* { */
/* XtDispatchEvent(&event); */
/* break; */
/* } */
/* printf(" window root \n"); */
if (target_win == None)
{
/* printf(" subwindow 0x%x\n", event.xkey.subwindow); */
target_win = event.xkey.subwindow; /* window selected */
if (x != NULL)
{
*x = event.xkey.x_root;
}
if (y != NULL)
{
*y = event.xkey.y_root;
}
}
break; /* XK_Return */
case XK_Escape:
case XK_Cancel:
case XK_Break:
XUngrabPointer(dpy,
CurrentTime); /* Done with pointer */
XUngrabKeyboard(dpy,
CurrentTime); /* Done with keyboard */
return ((Window)None);
break; /* XK_Escape */
default:
fprintf(stderr,
"Unknown key! Press <ESC> to abort, <Return> to select\n");
break;
} /* switch (keycode) */
break; /* KeyPress */
default:
XtDispatchEvent(&event);
break; /* default */
} /* switch (event.type) */
} /* while () */
/* If the XServer supports KeyRelease, we throw it away */
while ((event.type == KeyRelease) || (event.type == KeyPress))
{
XtDispatchEvent(&event);
} /* while (discard Keyboard-Events) */
XUngrabPointer(dpy,
CurrentTime); /* Done with pointer */
XUngrabKeyboard(dpy,
CurrentTime); /* Done with keyboard */
/* printf("[GetClientWindow] target_win 0x%x, XmuClientWindow 0x%x\n", */
/* target_win, */
/* XmuClientWindow(dpy, target_win)); */
return (XmuClientWindow(dpy,
target_win));
} /* GetClientWindow() */
Window
GetClientWindow(Widget w, int *x, int *y)
{
int status;
Cursor cursor;
XEvent event;
int buttons = 0;
Display * dpy = XtDisplayOfObject(w);
Window target_win = None, root = RootWindowOfScreen(XtScreenOfObject(w));
XtAppContext app = XtWidgetToApplicationContext(w);
/* Make the target cursor */
cursor = XCreateFontCursor(dpy, XC_crosshair);
/* Grab the pointer using target cursor, letting it room all over */
status = XGrabPointer(dpy, root, False,
ButtonPressMask|ButtonReleaseMask, GrabModeSync,
GrabModeAsync, root, cursor, CurrentTime);
if (status != GrabSuccess) {
SetMessage(global_screen_data.info_label, res_labels[5]);
return(None);
}
/* Let the user select a window... */
while ((target_win == None) || (buttons != 0)) {
/* allow one more event */
XAllowEvents(dpy, SyncPointer, CurrentTime);
XtAppNextEvent(app, &event);
switch (event.type) {
case ButtonPress:
if (event.xbutton.window != root) {
XtDispatchEvent(&event);
break;
}
if (target_win == None) {
target_win = event.xbutton.subwindow; /* window selected */
if (x != NULL)
*x = event.xbutton.x_root;
if (y != NULL)
*y = event.xbutton.y_root;
}
buttons++;
break;
case ButtonRelease:
if (event.xbutton.window != root) {
XtDispatchEvent(&event);
break;
}
if (buttons > 0) /* There may have been some
down before we started */
buttons--;
break;
default:
XtDispatchEvent(&event);
break;
}
}
XUngrabPointer(dpy, CurrentTime); /* Done with pointer */
return(XmuClientWindow(dpy, target_win));
}
static XtCacheRef *GetResources(
Widget widget, /* Widget resources are associated with */
char* base, /* Base address of memory to write to */
XrmNameList names, /* Full inheritance name of widget */
XrmClassList classes, /* Full inheritance class of widget */
XrmResourceList* table, /* The list of resources required. */
unsigned num_resources, /* number of items in resource list */
XrmQuarkList quark_args, /* Arg names quarkified */
ArgList args, /* ArgList to override resources */
unsigned num_args, /* number of items in arg list */
XtTypedArgList typed_args, /* Typed arg list to override resources */
Cardinal* pNumTypedArgs, /* number of items in typed arg list */
Boolean tm_hack) /* do baseTranslations */
{
/*
* assert: *pNumTypedArgs == 0 if num_args > 0
* assert: num_args == 0 if *pNumTypedArgs > 0
*/
#define SEARCHLISTLEN 100
#define MAXRESOURCES 400
XrmValue value;
XrmQuark rawType;
XrmValue convValue;
XrmHashTable stackSearchList[SEARCHLISTLEN];
XrmHashTable *searchList = stackSearchList;
unsigned int searchListSize = SEARCHLISTLEN;
Boolean found[MAXRESOURCES];
int typed[MAXRESOURCES];
XtCacheRef cache_ref[MAXRESOURCES];
XtCacheRef *cache_ptr, *cache_base;
Boolean persistent_resources = True;
Boolean found_persistence = False;
int num_typed_args = *pNumTypedArgs;
XrmDatabase db;
Boolean do_tm_hack = False;
if ((args == NULL) && (num_args != 0)) {
XtAppWarningMsg(XtWidgetToApplicationContext(widget),
"invalidArgCount","getResources",XtCXtToolkitError,
"argument count > 0 on NULL argument list",
(String *)NULL, (Cardinal *)NULL);
num_args = 0;
}
if (num_resources == 0) {
return NULL;
} else if (num_resources >= MAXRESOURCES) {
XtAppWarningMsg(XtWidgetToApplicationContext(widget),
"invalidResourceCount","getResources",XtCXtToolkitError,
"too many resources",
(String *)NULL, (Cardinal *)NULL);
return NULL;
} else if (table == NULL) {
XtAppWarningMsg(XtWidgetToApplicationContext(widget),
"invalidResourceCount","getResources",XtCXtToolkitError,
"resource count > 0 on NULL resource list",
(String *)NULL, (Cardinal *)NULL);
return NULL;
}
/* Mark each resource as not found on arg list */
bzero((char *) found, (int) (num_resources * sizeof(Boolean)));
bzero((char *) typed, (int) (num_resources * sizeof(int)));
/* Copy the args into the resources, mark each as found */
{
register ArgList arg;
register XtTypedArgList typed_arg;
register XrmName argName;
register Cardinal j;
register int i;
register XrmResourceList rx;
register XrmResourceList *res;
for (arg = args, i = 0; (Cardinal)i < num_args; i++, arg++) {
argName = quark_args[i];
if (argName == QinitialResourcesPersistent) {
persistent_resources = (Boolean)arg->value;
found_persistence = True;
continue;
}
for (j = 0, res = table; j < num_resources; j++, res++) {
rx = *res;
if (argName == rx->xrm_name) {
_XtCopyFromArg(
arg->value,
base - rx->xrm_offset - 1,
rx->xrm_size);
found[j] = TRUE;
break;
}
}
}
for (typed_arg = typed_args, i = 0; i < num_typed_args;
i++, typed_arg++) {
register XrmRepresentation argType;
argName = quark_args[i];
argType = (typed_arg->type == NULL) ? NULLQUARK
: XrmStringToRepresentation(typed_arg->type);
if (argName == QinitialResourcesPersistent) {
persistent_resources = (Boolean)typed_arg->value;
found_persistence = True;
break;
}
for (j = 0, res = table; j < num_resources; j++, res++) {
rx = *res;
if (argName == rx->xrm_name) {
if (argType != NULLQUARK && argType != rx->xrm_type) {
typed[j] = i + 1;
} else {
_XtCopyFromArg(
typed_arg->value,
base - rx->xrm_offset - 1,
rx->xrm_size);
}
found[j] = TRUE;
break;
}
}
}
}
/* Ask resource manager for a list of database levels that we can
do a single-level search on each resource */
db = XtScreenDatabase(XtScreenOfObject(widget));
while (!XrmQGetSearchList(db, names, classes,
searchList, searchListSize)) {
if (searchList == stackSearchList)
searchList = NULL;
searchList = (XrmHashTable*)XtRealloc((char*)searchList,
sizeof(XrmHashTable) *
(searchListSize *= 2));
}
if (persistent_resources)
cache_base = NULL;
else
cache_base = cache_ref;
/* geez, this is an ugly mess */
if (XtIsShell(widget)) {
register XrmResourceList *res;
register Cardinal j;
Screen *oldscreen = widget->core.screen;
/* look up screen resource first, since real rdb depends on it */
for (res = table, j = 0; j < num_resources; j++, res++) {
if ((*res)->xrm_name != Qscreen)
continue;
if (typed[j]) {
register XtTypedArg* arg = typed_args + typed[j] - 1;
XrmQuark from_type;
XrmValue from_val, to_val;
from_type = StringToQuark(arg->type);
from_val.size = arg->size;
if ((from_type == QString) || ((unsigned) arg->size > sizeof(XtArgVal)))
from_val.addr = (XPointer)arg->value;
else
from_val.addr = (XPointer)&arg->value;
to_val.size = sizeof(Screen*);
to_val.addr = (XPointer)&widget->core.screen;
found[j] = _XtConvert(widget, from_type, &from_val,
QScreen, &to_val, cache_base);
if (cache_base && *cache_base)
cache_base++;
}
if (!found[j]) {
if (XrmQGetSearchResource(searchList, Qscreen, QScreen,
&rawType, &value)) {
if (rawType != QScreen) {
convValue.size = sizeof(Screen*);
convValue.addr = (XPointer)&widget->core.screen;
(void)_XtConvert(widget, rawType, &value,
QScreen, &convValue, cache_base);
if (cache_base && *cache_base)
cache_base++;
} else {
widget->core.screen = *((Screen **)value.addr);
}
}
}
break;
}
/* now get the database to use for the rest of the resources */
if (widget->core.screen != oldscreen) {
db = XtScreenDatabase(widget->core.screen);
while (!XrmQGetSearchList(db, names, classes,
searchList, searchListSize)) {
if (searchList == stackSearchList)
searchList = NULL;
searchList = (XrmHashTable*)XtRealloc((char*)searchList,
sizeof(XrmHashTable) *
(searchListSize *= 2));
}
}
}
/* go to the resource manager for those resources not found yet */
/* if it's not in the resource database use the default value */
{
register XrmResourceList rx;
register XrmResourceList *res;
register Cardinal j;
register XrmRepresentation xrm_type;
register XrmRepresentation xrm_default_type;
char char_val;
short short_val;
int int_val;
long long_val;
char* char_ptr;
if (!found_persistence) {
if (XrmQGetSearchResource(searchList, QinitialResourcesPersistent,
QInitialResourcesPersistent, &rawType, &value)) {
if (rawType != QBoolean) {
convValue.size = sizeof(Boolean);
convValue.addr = (XPointer)&persistent_resources;
(void)_XtConvert(widget, rawType, &value, QBoolean,
&convValue, NULL);
}
else
persistent_resources = *(Boolean*)value.addr;
}
}
if (persistent_resources)
cache_ptr = NULL;
else if (cache_base)
cache_ptr = cache_base;
else
cache_ptr = cache_ref;
for (res = table, j = 0; j < num_resources; j++, res++) {
rx = *res;
xrm_type = rx->xrm_type;
if (typed[j]) {
register XtTypedArg* arg = typed_args + typed[j] - 1;
/*
* This resource value has been specified as a typed arg and
* has to be converted. Typed arg conversions are done here
* to correctly interpose them with normal resource conversions.
*/
XrmQuark from_type;
XrmValue from_val, to_val;
Boolean converted;
from_type = StringToQuark(arg->type);
from_val.size = arg->size;
if ((from_type == QString) || ((unsigned) arg->size > sizeof(XtArgVal)))
from_val.addr = (XPointer)arg->value;
else
from_val.addr = (XPointer)&arg->value;
to_val.size = rx->xrm_size;
to_val.addr = base - rx->xrm_offset - 1;
converted = _XtConvert(widget, from_type, &from_val,
xrm_type, &to_val, cache_ptr);
if (converted) {
/* Copy the converted value back into the typed argument.
* normally the data should be <= sizeof(XtArgVal) and
* is stored directly into the 'value' field .... BUT
* if the resource size is greater than sizeof(XtArgVal)
* then we dynamically alloc a block of store to hold the
* data and zap a copy in there !!! .... freeing it later
* the size field in the typed arg is negated to indicate
* that the store pointed to by the value field is
* dynamic .......
* "freeing" happens in the case of _XtCreate after the
* CallInitialize ..... other clients of GetResources
* using typed args should be aware of the need to free
* this store .....
*/
if(rx->xrm_size > sizeof(XtArgVal)) {
arg->value = (XtArgVal) __XtMalloc(rx->xrm_size);
arg->size = -(arg->size);
} else { /* will fit - copy directly into value field */
arg->value = (XtArgVal) NULL;
}
CopyToArg((char *)(base - rx->xrm_offset - 1),
&arg->value, rx->xrm_size);
} else {
/* Conversion failed. Get default value. */
found[j] = False;
}
if (cache_ptr && *cache_ptr)
cache_ptr++;
}
if (!found[j]) {
Boolean already_copied = False;
Boolean have_value = False;
if (XrmQGetSearchResource(searchList,
rx->xrm_name, rx->xrm_class, &rawType, &value)) {
if (rawType != xrm_type) {
convValue.size = rx->xrm_size;
convValue.addr = (XPointer)(base - rx->xrm_offset - 1);
already_copied = have_value =
_XtConvert(widget, rawType, &value,
xrm_type, &convValue, cache_ptr);
if (cache_ptr && *cache_ptr)
cache_ptr++;
} else have_value = True;
if (have_value && rx->xrm_name == Qtranslations)
do_tm_hack = True;
}
LOCK_PROCESS;
if (!have_value
&& ((rx->xrm_default_type == QImmediate)
|| (rx->xrm_default_type == xrm_type)
|| (rx->xrm_default_addr != NULL))) {
/* Convert default value to proper type */
xrm_default_type = rx->xrm_default_type;
if (xrm_default_type == QCallProc) {
#ifdef CRAY
if ( (int) Cjumpp != (int) Cjump)
(*(XtResourceDefaultProc)
(((int)(rx->xrm_default_addr))<<2))(
widget,-(rx->xrm_offset+1), &value);
else
#endif
(*(XtResourceDefaultProc)(rx->xrm_default_addr))(
widget,-(rx->xrm_offset+1), &value);
} else if (xrm_default_type == QImmediate) {
/* XtRImmediate == XtRString for type XtRString */
if (xrm_type == QString) {
value.addr = rx->xrm_default_addr;
} else if (rx->xrm_size == sizeof(int)) {
int_val = (int)(long)rx->xrm_default_addr;
value.addr = (XPointer) &int_val;
} else if (rx->xrm_size == sizeof(short)) {
short_val = (short)(long)rx->xrm_default_addr;
value.addr = (XPointer) &short_val;
} else if (rx->xrm_size == sizeof(char)) {
char_val = (char)(long)rx->xrm_default_addr;
value.addr = (XPointer) &char_val;
} else if (rx->xrm_size == sizeof(long)) {
long_val = (long)rx->xrm_default_addr;
value.addr = (XPointer) &long_val;
} else if (rx->xrm_size == sizeof(char*)) {
char_ptr = (char*)rx->xrm_default_addr;
value.addr = (XPointer) &char_ptr;
} else {
value.addr = (XPointer) &(rx->xrm_default_addr);
}
} else if (xrm_default_type == xrm_type) {
value.addr = rx->xrm_default_addr;
} else {
value.addr = rx->xrm_default_addr;
if (xrm_default_type == QString) {
value.size = strlen((char *)value.addr) + 1;
} else {
value.size = sizeof(XtPointer);
}
convValue.size = rx->xrm_size;
convValue.addr = (XPointer)(base - rx->xrm_offset - 1);
already_copied =
_XtConvert(widget, xrm_default_type, &value,
xrm_type, &convValue, cache_ptr);
if (!already_copied)
value.addr = NULL;
if (cache_ptr && *cache_ptr)
cache_ptr++;
}
}
if (!already_copied) {
if (xrm_type == QString) {
*((String*)(base - rx->xrm_offset - 1)) = value.addr;
} else {
if (value.addr != NULL) {
XtMemmove(base - rx->xrm_offset - 1,
value.addr, rx->xrm_size);
} else {
/* didn't get value, initialize to NULL... */
XtBZero(base - rx->xrm_offset - 1, rx->xrm_size);
}
}
}
UNLOCK_PROCESS;
if (typed[j]) {
/*
* This resource value was specified as a typed arg.
* However, the default value is being used here since
* type type conversion failed, so we compress the list.
*/
register XtTypedArg* arg = typed_args + typed[j] - 1;
register int i;
for (i = num_typed_args - typed[j]; i > 0; i--, arg++) {
*arg = *(arg+1);
}
num_typed_args--;
}
}
}
if (tm_hack)
widget->core.tm.current_state = NULL;
if (tm_hack &&
(!widget->core.tm.translations ||
(do_tm_hack &&
widget->core.tm.translations->operation != XtTableReplace)) &&
XrmQGetSearchResource(searchList, QbaseTranslations,
QTranslations, &rawType, &value)) {
if (rawType != QTranslationTable) {
convValue.size = sizeof(XtTranslations);
convValue.addr = (XPointer)&widget->core.tm.current_state;
(void)_XtConvert(widget, rawType, &value,
QTranslationTable, &convValue, cache_ptr);
if (cache_ptr && *cache_ptr)
cache_ptr++;
} else {
/* value.addr can be NULL see: !already_copied */
if (value.addr)
*((XtTranslations *)&widget->core.tm.current_state) =
*((XtTranslations *)value.addr);
}
}
}
if ((Cardinal)num_typed_args != *pNumTypedArgs) *pNumTypedArgs = num_typed_args;
if (searchList != stackSearchList) XtFree((char*)searchList);
if (!cache_ptr)
cache_ptr = cache_base;
if (cache_ptr && cache_ptr != cache_ref) {
int cache_ref_size = cache_ptr - cache_ref;
XtCacheRef *refs = (XtCacheRef*)
__XtMalloc((unsigned)sizeof(XtCacheRef)*(cache_ref_size + 1));
(void) memmove(refs, cache_ref, sizeof(XtCacheRef)*cache_ref_size );
refs[cache_ref_size] = NULL;
return refs;
}
return (XtCacheRef*)NULL;
}
