char *
_XmExtObjAlloc(Cardinal size)
{
int i;
if (cache == NULL)
{
cache = (XmExtCache *)XtCalloc(XmNUM_ELEMENTS, sizeof(XmExtCache));
}
if (size < XmNUM_BYTES)
{
for (i = 0; i < XmNUM_ELEMENTS; i++)
{
if (cache[i].inuse == False)
{
cache[i].inuse = True;
return cache[i].data;
}
}
}
return XtCalloc(1, size);
}
XawTextProperty *
XawTextSinkCopyProperty(Widget w, XrmQuark property)
{
XawTextProperty *cur, *ret;
if ((cur = XawTextSinkGetProperty(w, property)) == NULL)
cur = XawTextSinkGetProperty(w, Qdefault);
ret = (XawTextProperty*)XtCalloc(1, sizeof(XawTextProperty));
if (cur)
memcpy(ret, cur, sizeof(XawTextProperty));
ret->identifier = NULLQUARK;
ret->mask &= ~XAW_TPROP_FONT;
return (ret);
}
void
InitializeVidmodes(void)
{
int i;
Display *display = XtDisplay(toplevel);
computer.num_vidmodes = ScreenCount(display);
computer.vidmodes = (xf86cfgVidmode**)
XtMalloc(sizeof(xf86cfgVidmode*) * computer.num_vidmodes);
for (i = 0; i < computer.num_vidmodes; i++) {
computer.vidmodes[i] = (xf86cfgVidmode*)
XtCalloc(1, sizeof(xf86cfgVidmode));
computer.vidmodes[i]->screen = i;
}
}
void start_tag_line(
char *fname
)
{
if (fname) {
if (!tag_linebuf)
tag_linebuf = (char *) XtCalloc(BUFSIZ, sizeof(char));
tag_linebuf[0] = 0;
tag_file = fname;
} else {
if (tag_linebuf)
XtFree(tag_linebuf);
tag_linebuf = tag_file = 0;
}
tag_line_num = 0;
}
void
_XmExtObjFree(XtPointer element)
{
int i;
if (cache == NULL)
cache = (XmExtCache *)XtCalloc(XmNUM_ELEMENTS, sizeof(XmExtCache));
for (i = 0; i < XmNUM_ELEMENTS; i++)
{
if (element == cache[i].data)
{
cache[i].inuse = False;
return;
}
}
XtFree((char *)element);
}
unsigned int intern_object(void *obj)
{
oblist_t *node = find_node_if(&obj_eql, obj);
if (node != NULL)
return node->oid;
if (oblist == NULL)
init_oids();
if ((node = (void*)XtCalloc(1, sizeof(oblist_t))) == NULL)
fatal_error("intern_object: out of memory");
node->next = oblist;
node->prev = NULL;
if (node->next) node->next->prev = node;
node->obj = obj;
node->oid = next_oid();
oblist = node;
return node->oid;
}
/*ARGSUSED*/
static void
AddModeCallback(Widget w, XtPointer call_data, XtPointer client_data)
{
if (vidtune && vidtune->monitor) {
char *label;
Arg args[1];
XF86ConfModeLinePtr mode;
XtSetArg(args[0], XtNstring, &label);
XtGetValues(text, args, 1);
if (*label == '\0') {
XBell(XtDisplay(w), 80);
return;
}
if (xf86findModeLine(label, vidtune->monitor->mon_modeline_lst)
!= NULL && !ForceAddMode())
return;
mode = (XF86ConfModeLinePtr)XtCalloc(1, sizeof(XF86ConfModeLineRec));
mode->ml_identifier = XtNewString(label);
mode->ml_clock = dot_clock;
mode->ml_hdisplay = modeline.hdisplay;
mode->ml_hsyncstart = modeline.hsyncstart;
mode->ml_hsyncend = modeline.hsyncend;
mode->ml_htotal = modeline.htotal;
mode->ml_vdisplay = modeline.vdisplay;
mode->ml_vsyncstart = modeline.vsyncstart;
mode->ml_vsyncend = modeline.vsyncend;
mode->ml_vtotal = modeline.vtotal;
/* mode->ml_vscan = ???;*/
mode->ml_flags = modeline.flags;
mode->ml_hskew = modeline.hskew;
vidtune->monitor->mon_modeline_lst =
xf86addModeLine(vidtune->monitor->mon_modeline_lst, mode);
}
else
XBell(XtDisplay(w), 80);
}
/* ARGSUSED */
static void
Initialize (Widget greq, Widget gset, ArgList args, Cardinal *num_args)
{
XmPannerWidget req = (XmPannerWidget) greq, set = (XmPannerWidget) gset;
Dimension defwidth, defheight;
#ifdef DEMO
_XmInitialIzeConverters(greq);
#endif
XmPanner_private(set) =
(XmPannerPrivateData *)XtCalloc(1, sizeof(XmPannerPrivateData));
ASSIGN_MAX(XmPanner_canvas_width(req), 1);
ASSIGN_MAX(XmPanner_canvas_height(req), 1);
if (XmPanner_default_scale(req) < 1)
XmPanner_default_scale(set) = XmPannerDefaultScale;
GetDefaultSize (req, &defwidth, &defheight);
if (req->core.width < 1)
set->core.width = defwidth;
if (req->core.height < 1)
set->core.height = defheight;
XmPanner_slider_gc(set) = XmPanner_xor_gc(set) = NULL;
ResetSliderGC (set); /* foreground */
ResetXorGC (set); /* foreground ^ background */
Rescale(set); /* does a position check */
XmPanner_tmp(set).doing = FALSE;
XmPanner_tmp(set).showing = FALSE;
}
static void
initialize_dimensions(Dimension **listp, int *sizep, int n)
{
int i;
Dimension *l;
if (!*listp) {
*listp = (Dimension *) XtCalloc ((unsigned int) n,
(unsigned int) sizeof(Dimension));
*sizep = ((*listp) ? n : 0);
return;
}
if (n > *sizep) {
*listp = (Dimension *) XtRealloc((char *) *listp,
(unsigned int) (n*sizeof(Dimension)));
if (!*listp) {
*sizep = 0;
return;
}
for (i = *sizep, l = (*listp) + i; i < n; i++, l++) *l = 0;
*sizep = n;
}
return;
}
int CoWowMotif::DisplayWarranty()
{
char text[4000];
Arg arg[12];
Widget question_widget;
XmString CStr2, TitleStr, okstr, cancelstr, helpstr;
wow_t_question_cb *cbdata;
XmFontList fontlist;
XFontStruct *font;
XmFontListEntry fontentry;
char title[80];
FILE *fp;
int i;
char fname[256];
// Display only once
if ( HideWarranty())
return 1;
sprintf( fname, "$pwr_exe/%s/acceptlicense.txt", lng_get_language_str());
dcli_translate_filename( fname, fname);
fp = fopen( fname, "r");
if ( !fp) {
strcpy( fname, "$pwr_exe/en_us/acceptlicense.txt");
dcli_translate_filename( fname, fname);
fp = fopen( fname, "r");
if ( !fp) return 1;
}
for ( i = 0; i < (int)sizeof(text) - 1; i++) {
text[i] = fgetc( fp);
if ( text[i] == EOF)
break;
}
text[i] = 0;
fclose( fp);
strcpy( title, lng_translate("Accept License Terms"));
// Set default fontlist
font = XLoadQueryFont( XtDisplay(m_parent),
"-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
fontlist = XmFontListAppendEntry( NULL, fontentry);
XtFree( (char *)fontentry);
CStr2 = XmStringCreateLtoR( text, XmSTRING_DEFAULT_CHARSET);
TitleStr = XmStringCreateLtoR( title, XmSTRING_DEFAULT_CHARSET);
okstr = XmStringCreateLtoR( lng_translate( "I Accept"), XmSTRING_DEFAULT_CHARSET );
cancelstr = XmStringCreateLtoR( lng_translate( "Quit"), XmSTRING_DEFAULT_CHARSET );
helpstr = XmStringCreateLtoR( lng_translate( "Show License"), XmSTRING_DEFAULT_CHARSET );
XtSetArg(arg[0],XmNheight,75);
XtSetArg(arg[1],XmNwidth,700);
XtSetArg(arg[2],XmNmessageString, CStr2);
XtSetArg(arg[3],XmNx,400);
XtSetArg(arg[4],XmNy,300);
XtSetArg(arg[5],XmNdialogTitle,TitleStr);
XtSetArg(arg[6], XmNokLabelString, okstr);
XtSetArg(arg[7], XmNcancelLabelString, cancelstr);
XtSetArg(arg[8], XmNhelpLabelString, helpstr);
XtSetArg(arg[9], XmNbuttonFontList, fontlist);
XtSetArg(arg[10], XmNlabelFontList, fontlist);
XtSetArg(arg[11], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);
cbdata = (wow_t_question_cb *) XtCalloc( 1, sizeof(*cbdata));
cbdata->questionbox_ok = warranty_ok_cb;
cbdata->questionbox_cancel = warranty_cancel_cb;
cbdata->questionbox_help = warranty_help_cb;
cbdata->ctx = 0;
cbdata->data = (void *)this;
question_widget = XmCreateMessageDialog( m_parent,(char*) "questionDialog",arg, 12);
XtAddCallback( question_widget, XmNokCallback,
(XtCallbackProc) question_ok_cb, cbdata);
XtAddCallback( question_widget, XmNcancelCallback,
(XtCallbackProc) question_cancel_cb, cbdata);
XtAddCallback( question_widget, XmNhelpCallback,
(XtCallbackProc) question_help_cb, cbdata);
XmStringFree( CStr2);
XmStringFree( TitleStr);
XmStringFree( okstr);
XmStringFree( cancelstr);
XmStringFree( helpstr);
XmFontListFree( fontlist);
XtManageChild( question_widget);
return 1;
}
/*
* Implementation
*/
XtPointer
MonitorConfig(XtPointer conf)
{
XF86ConfMonitorPtr monitor = (XF86ConfMonitorPtr)conf;
char monitor_name[48];
Arg args[1];
current_monitor = monitor;
xf86info.cur_list = MONITOR;
XtSetSensitive(back, xf86info.lists[MONITOR].cur_function > 0);
XtSetSensitive(next, xf86info.lists[MONITOR].cur_function <
xf86info.lists[MONITOR].num_functions - 1);
(xf86info.lists[MONITOR].functions[xf86info.lists[MONITOR].cur_function])
(&xf86info);
XawListUnhighlight(hlist);
XawListUnhighlight(vlist);
if (monitor != NULL) {
XF86ConfScreenPtr screen = XF86Config->conf_screen_lst;
char str[PARSER_RANGE_SIZE];
XtSetArg(args[0], XtNstring, monitor->mon_identifier);
XtSetValues(ident_widget, args, 1);
while (screen != NULL) {
if (screen->scrn_monitor == monitor)
break;
screen = (XF86ConfScreenPtr)(screen->list.next);
}
if (screen != NULL) {
oldcard = card = screen->scrn_device;
XtSetArg(args[0], XtNlabel, card->dev_identifier);
}
else {
oldcard = card = NULL;
XtSetArg(args[0], XtNlabel, "");
}
XtSetValues(cmenu, args, 1);
mon_n_hsync = monitor->mon_n_hsync;
memcpy(mon_hsync, monitor->mon_hsync,
sizeof(parser_range) * mon_n_hsync);
*str = '\0';
parser_range_to_string(str, mon_hsync, mon_n_hsync);
XtSetArg(args[0], XtNstring, str);
XtSetValues(hsync, args, 1);
mon_n_vrefresh = monitor->mon_n_vrefresh;
memcpy(mon_vrefresh, monitor->mon_vrefresh,
sizeof(parser_range) * mon_n_vrefresh);
*str = '\0';
parser_range_to_string(str, mon_vrefresh, mon_n_vrefresh);
XtSetArg(args[0], XtNstring, str);
XtSetValues(vsync, args, 1);
}
else {
XF86ConfMonitorPtr monitor = XF86Config->conf_monitor_lst;
int nmonitors = 0;
oldcard = card = NULL;
while (monitor != NULL) {
++nmonitors;
monitor = (XF86ConfMonitorPtr)(monitor->list.next);
}
do {
XmuSnprintf(monitor_name, sizeof(monitor_name),
"Monitor%d", nmonitors);
++nmonitors;
} while (xf86findMonitor(monitor_name,
XF86Config->conf_monitor_lst));
XtSetArg(args[0], XtNstring, monitor_name);
XtSetValues(ident_widget, args, 1);
XtSetArg(args[0], XtNstring, "");
XtSetValues(hsync, args, 1);
XtSetValues(vsync, args, 1);
XtSetArg(args[0], XtNlabel, "");
XtSetValues(cmenu, args, 1);
}
if (ConfigLoop(MonitorConfigCheck) == True) {
if (monitor == NULL) {
monitor = (XF86ConfMonitorPtr)
XtCalloc(1, sizeof(XF86ConfMonitorRec));
monitor->mon_identifier = XtNewString(ident_string);
}
memcpy(monitor->mon_hsync, mon_hsync, sizeof(parser_range) *
(monitor->mon_n_hsync = mon_n_hsync));
memcpy(monitor->mon_vrefresh, mon_vrefresh, sizeof(parser_range) *
(monitor->mon_n_vrefresh = mon_n_vrefresh));
if (strcasecmp(monitor->mon_identifier, ident_string))
xf86renameMonitor(XF86Config, monitor, ident_string);
if (oldcard != card) {
int i;
for (i = 0; i < computer.num_devices; i++)
if (computer.devices[i]->widget == config)
break;
if (computer.devices[i]->config == NULL)
XF86Config->conf_monitor_lst =
xf86addMonitor(XF86Config->conf_monitor_lst,
monitor);
computer.devices[i]->config = (XtPointer)monitor;
ChangeScreen(monitor, monitor, card, oldcard);
DrawCables();
}
return (monitor);
}
return (NULL);
}
GRAU( XtPointer, call)
{
#define CHUNK 512
Boolean first = True;
String rscs = XtNewString((String)client);
String *valueList = (String *)XtCalloc(CHUNK, sizeof(String));
char *start;
char *ptr, *cptr;
String name;
String rsc;
int i, count = 0;
Widget *current;
for ( start = rscs; rscs && *rscs; rscs = strtok(NULL, "\n"))
{
if ( first )
{
rscs = strtok(rscs, "\n");
first = False;
}
valueList[count] = XtNewString(rscs);
count++;
if ( count == CHUNK )
{
valueList =
(String *)XtRealloc((char *)valueList,
(count + CHUNK) * sizeof(String));
}
}
XtFree((char *)start);
for ( i = 0; i < count; i++ )
{
/*
* First, extract the widget name and generate a string to
* pass to BxWidgetIdsFromNames().
*/
cptr = strrchr(valueList[i], '.');
if ( cptr != NULL )
{
*cptr = '\000';
}
else
{
printf("Callback Error (BxSetValuesCB):\n\t\
Syntax Error - specify BxSetValuesCB data as\n\t\
<Widget Name>.<Resource> = <Value>\n");
XtFree((char *)(valueList[i]));
continue;
}
name = valueList[i];
while( (name && *name) && isspace(*name) )
{
name++;
}
ptr = name + strlen(name) - 1;
while( ptr && *ptr )
{
if ( isspace(*ptr) )
{
ptr--;
}
else
{
ptr++;
break;
}
}
if ( ptr && *ptr )
{
*ptr = '\0';
}
if ( ptr == NULL )
{
printf("Callback Error (BxSetValuesCB):\n\t\
Syntax Error - specify BxSetValuesCB data as\n\t\
<Widget Name>.<Resource> = <Value>\n");
XtFree((char *)(valueList[i]));
return;
}
/*
* Next, get the resource name to set.
*/
rsc = ++cptr;
cptr = strchr(rsc, '=');
if ( cptr != NULL )
{
*cptr = '\000';
}
else
{
printf("Callback Error (BxSetValuesCB):\n\t\
Syntax Error - specify BxSetValuesCB data as\n\t\
<Widget Name>.<Resource> = <Value>\n");
XtFree((char *)(valueList[i]));
continue;
}
while( (rsc && *rsc) && isspace(*rsc) )
{
rsc++;
}
ptr = rsc + strlen(rsc) - 1;
while( ptr && *ptr )
{
if ( isspace(*ptr) )
{
ptr--;
}
else
{
ptr++;
break;
}
}
if ( ptr && *ptr )
{
*ptr = '\0';
}
/*
* Lastly, get the string value to which to set the resource.
*/
start = ++cptr;
while( (start && *start) && isspace(*start) )
{
start++;
}
if ( start == NULL )
{
printf("Callback Error (BxSetValuesCB):\n\t\
Syntax Error - specify BxSetValuesCB data as\n\t\
<Widget Name>.<Resource> = <Value>\n");
XtFree((char *)(valueList[i]));
return;
}
/*
* Implementation
*/
XtPointer
ScreenConfig(XtPointer conf)
{
XF86ConfDisplayPtr disp;
Arg args[2];
int i, oldrotate;
screen = (XF86ConfScreenPtr)conf;
if (screen == NULL)
return (NULL);
XtSetArg(args[0], XtNstring, screen->scrn_identifier);
XtSetValues(ident_widget, args, 1);
if ((default_depth = screen->scrn_defaultdepth) <= 0)
default_depth = 8;
sel_index = unsel_index = -1;
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == screen) {
SetScreenRotate(computer.screens[i]);
rotate = computer.screens[i]->rotate;
}
oldrotate = rotate;
ndefmodes = 0;
disp = screen->scrn_display_lst;
while (disp != NULL) {
if (disp->disp_depth == default_depth) {
XF86ModePtr mod = disp->disp_mode_lst;
while (mod != NULL) {
if (ndefmodes % 16 == 0)
defmodes = (char**)
XtRealloc((XtPointer)defmodes,
(ndefmodes + 16) * sizeof(char*));
defmodes[ndefmodes++] = XtNewString(mod->mode_name);
mod = (XF86ModePtr)(mod->list.next);
}
break;
}
disp = (XF86ConfDisplayPtr)(disp->list.next);
}
if (ndefmodes == 0) {
defmodes = (char**)XtMalloc(sizeof(char*));
defmodes[0] = XtNewString("640x480");
ndefmodes = 1;
}
if (listL != NULL) {
XawListUnhighlight(listL);
XawListUnhighlight(listR);
}
xf86info.cur_list = SCREEN;
XtSetSensitive(back, xf86info.lists[SCREEN].cur_function > 0);
XtSetSensitive(next, xf86info.lists[SCREEN].cur_function <
xf86info.lists[SCREEN].num_functions - 1);
(xf86info.lists[SCREEN].functions[xf86info.lists[SCREEN].cur_function])
(&xf86info);
if (ConfigLoop(NULL) == True) {
XF86ModePtr prev = NULL, mod;
/* user may have changed the default depth, read variables again */
disp = screen->scrn_display_lst;
while (disp != NULL) {
if (disp->disp_depth == default_depth)
break;
disp = (XF86ConfDisplayPtr)(disp->list.next);
}
if (disp == NULL) {
disp = (XF86ConfDisplayPtr)XtCalloc(1, sizeof(XF86ConfDisplayRec));
screen->scrn_display_lst = (XF86ConfDisplayPtr)
xf86addListItem((GenericListPtr)(screen->scrn_display_lst),
(GenericListPtr)(disp));
disp->disp_depth = default_depth;
}
if (strcasecmp(screen->scrn_identifier, ident_string))
xf86renameScreen(XF86Config, screen, ident_string);
screen->scrn_defaultdepth = default_depth;
XtSetArg(args[0], XtNlist, NULL);
XtSetArg(args[1], XtNnumberStrings, 0);
XtSetValues(listL, args, 2);
XtSetArg(args[0], XtNlist, NULL);
XtSetArg(args[1], XtNnumberStrings, 0);
XtSetValues(listR, args, 2);
mod = disp->disp_mode_lst;
/* free all modes */
while (mod != NULL) {
prev = mod;
mod = (XF86ModePtr)(mod->list.next);
XtFree(prev->mode_name);
XtFree((XtPointer)prev);
}
/* readd modes */
for (i = 0; i < ndefmodes; i++) {
mod = XtNew(XF86ModeRec);
mod->mode_name = XtNewString(defmodes[i]);
XtFree(defmodes[i]);
if (i == 0)
disp->disp_mode_lst = mod;
else
prev->list.next = mod;
prev = mod;
}
if (i == 0)
disp->disp_mode_lst = NULL;
else
mod->list.next = NULL;
XtFree((XtPointer)defmodes);
defmodes = NULL;
ndefmodes = 0;
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == screen)
computer.screens[i]->rotate = rotate;
if (oldrotate != rotate) {
static char *Rotate = "Rotate";
if (screen->scrn_option_lst != NULL)
xf86removeOption(&screen->scrn_option_lst, Rotate);
if (rotate)
screen->scrn_option_lst =
xf86addNewOption(screen->scrn_option_lst,
XtNewString(Rotate),
XtNewString(rotate > 0 ? "CW" : "CCW"));
UpdateScreenUI();
AdjustScreenUI();
}
return ((XtPointer)screen);
}
XtSetArg(args[0], XtNlist, NULL);
XtSetArg(args[1], XtNnumberStrings, 0);
XtSetValues(listL, args, 2);
XtSetArg(args[0], XtNlist, NULL);
XtSetArg(args[1], XtNnumberStrings, 0);
XtSetValues(listR, args, 2);
for (i = 0; i < ndefmodes; i++)
XtFree(defmodes[i]);
XtFree((XtPointer)defmodes);
defmodes = NULL;
ndefmodes = 0;
return (NULL);
}
char *
XFE_ABDirListView::DragConvert(Atom atom)
{
/* pack data
*/
if (atom == XFE_OutlinerDrop::_XA_NETSCAPE_DIRSERV) {
#if defined(DEBUG_tao)
printf("\nXFE_ABDirListView::DragConvert:_XA_NETSCAPE_DIRSERV\n");
#endif
uint32 count = 0;
const int *indices = 0;
m_outliner->getSelection(&indices, (int *) &count);
char tmp[32];
sprintf(tmp, "%d", count);
int len = XP_STRLEN(tmp);
char *buf = (char *) XtCalloc(len, sizeof(char));
buf = XP_STRCAT(buf, tmp);
for (int i=0; i < count; i++) {
sprintf(tmp, "%d", indices[i]);
len += XP_STRLEN(tmp)+1;
buf = XtRealloc(buf, len);
buf = XP_STRCAT(buf, " ");
buf = XP_STRCAT(buf, tmp);
}/* for i */
#if defined(DEBUG_tao)
printf("\nXFE_ABDirListView::DragConvert:_XA_NETSCAPE_DIRSERV=%x\n", buf);
#endif
return buf;
}/* if */
else if (atom == XFE_OutlinerDrop::_XA_NETSCAPE_PAB) {
#if defined(DEBUG_tao)
printf("\nXFE_ABDirListView::DragConvert:_XA_NETSCAPE_PAB\n");
#endif
uint32 count = 0;
const int *indices = 0;
m_outliner->getSelection(&indices, (int *) &count);
char tmp[32];
sprintf(tmp, "%d", count);
int len = XP_STRLEN(tmp);
char *buf = (char *) XtCalloc(len, sizeof(char));
buf = XP_STRCAT(buf, tmp);
for (int i=0; i < count; i++) {
sprintf(tmp, "%d", indices[i]);
len += XP_STRLEN(tmp)+1;
buf = XtRealloc(buf, len);
buf = XP_STRCAT(buf, " ");
buf = XP_STRCAT(buf, tmp);
}/* for i */
#if defined(DEBUG_tao)
printf("\nXFE_ABDirListView::DragConvert:_XA_NETSCAPE_PAB=%x\n", buf);
#endif
return buf;
}/* else if */
return (char *) NULL;
}
static void
GetFullFontList(Widget w)
{
Widget b;
int i, j, nfonts, ii, nogood, ac;
char **list, *p, *q;
char field[14][64]; /* ??? FIX ME */
struct xlfd_fields **fields;
Arg al[2];
/*
* Use userdata field to pass the FC widget id.
*
* We need this because we might get called from a tearoff,
* and in a tearoff we cannot walk up the widget tree to find
* the FontChooser.
*/
ac = 0;
XtSetArg(al[ac], XmNuserData, (XtPointer)w); ac++;
for (i=0; i<14; i++) {
XtAddCallback(FC_Menus(w)[i], XmNentryCallback, FCFilter, (XtPointer)i);
b = XmCreatePushButtonGadget(FC_Menus(w)[i], "*", al, ac);
XtManageChild(b);
XtVaSetValues(FC_Menus(w)[i], XmNmenuHistory, b, NULL);
FC_Setting(w)[i] = XtNewString("*");
}
list = XListFonts(XtDisplay(w), FC_Pattern(w), 4096, &nfonts);
fields = (struct xlfd_fields **)XtCalloc(14, sizeof(struct xlfd_fields *));
for (i=0; i<nfonts; i++) {
/* sscanf doesn't cope well with empty fields, so do this ourselves. */
nogood = 0;
for (j=0, p=list[i]; j<14; j++) {
/* Scan for a dash and a string starting at p, store it in field */
if (*p != '-') {
fprintf(stderr, "%s: Can't scan font name '%s'\n",
XtName(w), list[i]);
nogood = 1;
break;
}
p++;
for (q=p, ii=0; *q && *q != '-' && ii < 64; q++, ii++)
field[j][ii] = *q;
field[j][ii] = '\0';
if (*q)
p = q;
else
break;
}
for (j=0; j<14; j++) {
Remember(fields, j, field[j]);
}
}
/* Create buttons */
for (i=0; i<14; i++) {
/*
* Sort according to criteria from resource.
*/
if (FC_SortCriteria(w) && strlen(FC_SortCriteria(w)) > 13) {
size_t s, n;
s = sizeof(char *);
n = fields[i]->num;
if (FC_SortCriteria(w)[i] == 'n' || FC_SortCriteria(w)[i] == 'N') {
qsort(fields[i]->names, n, s, qsort_helper_num);
} else if (FC_SortCriteria(w)[i] == 'a' || FC_SortCriteria(w)[i] == 'A') {
qsort(fields[i]->names, n, s, qsort_helper_alpha);
} else {
; /* don't sort, silently */
}
}
for (j=0; j<fields[i]->num; j++) {
b = XmCreatePushButtonGadget(FC_Menus(w)[i], fields[i]->names[j], al, ac);
XtManageChild(b);
XtFree(fields[i]->names[j]);
}
XtFree((XtPointer)fields[i]->names);
XtFree((XtPointer)fields[i]);
}
XtFree((XtPointer)fields);
XFreeFontNames(list);
ShowCount(w, nfonts);
}
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 */
}
void
ReadCardsDatabase(void)
{
#ifdef USE_MODULES
if (!nomodules) {
int i, j, ivendor, idevice;
char name[256];
_Xconst char *vendor, *device;
CardsEntry *entry = NULL, *tmp;
xf86cfgModuleOptions *opts = module_options;
const pciDeviceInfo **pDev;
/* Only list cards that have a driver installed */
while (opts) {
if (opts->chipsets) {
SymTabPtr chips = opts->chipsets;
while (chips->name) {
vendor = opts->name;
device = chips->name;
ivendor = (chips->token & 0xffff0000) >> 16;
idevice = chips->token & 0xffff0;
if (ivendor == 0)
ivendor = opts->vendor;
if (xf86PCIVendorInfo) {
for (i = 0; xf86PCIVendorInfo[i].VendorName; i++)
if (ivendor == xf86PCIVendorInfo[i].VendorID) {
vendor = xf86PCIVendorInfo[i].VendorName;
break;
}
if (xf86PCIVendorInfo[i].VendorName) {
if ((pDev = xf86PCIVendorInfo[i].Device)) {
for (j = 0; pDev[j]; j++)
if (idevice == pDev[j]->DeviceID) {
device = pDev[j]->DeviceName;
break;
}
}
}
}
/* Since frequently there is more than one driver for a
* single vendor, it is required to avoid duplicates.
*/
XmuSnprintf(name, sizeof(name), "%s %s", vendor, device);
tmp = LookupCard(name);
if (tmp == NULL || strcmp(tmp->chipset, chips->name) ||
strcmp(tmp->driver, opts->name)) {
entry = (CardsEntry*)XtCalloc(1, sizeof(CardsEntry));
if (NumCardsEntry % 16 == 0) {
CardsDB = (CardsEntry**)XtRealloc((XtPointer)CardsDB,
sizeof(CardsEntry*) * (NumCardsEntry + 16));
}
CardsDB[NumCardsEntry++] = entry;
entry->name = XtNewString(name);
/* XXX no private copy of strings */
entry->chipset = (char*)chips->name;
entry->driver = opts->name;
/* better than linear searchs to find duplicates */
qsort(CardsDB, NumCardsEntry, sizeof(CardsEntry*),
CompareCards);
}
++chips;
}
}
opts = opts->next;
}
/*
* ------------------------------------------------------------------------
* Name: PdmShellNew
*
* Description:
*
* Allocates a new PdmShell data structure.
*
* Return value:
*
* A pointer to the new PdmShell structure.
*
*/
static PdmShell*
PdmShellNew()
{
return (PdmShell*)XtCalloc(1, sizeof(PdmShell));
}
int
main(
int argc,
char **argv )
{
Display *display;
Arg args[20];
int n=0;
char *actionName;
int numArgs = 0;
DtActionArg *ap = NULL;
XtSetLanguageProc(NULL, NULL, NULL);
_DtEnvControl(DT_ENV_SET);
(void) signal(SIGCHLD, (void (*)())SIG_IGN);
/* Initialize the toolkit and open the display */
XtToolkitInitialize() ;
appContext = XtCreateApplicationContext() ;
if ( !(display = XtOpenDisplay( appContext, NULL, argv[0], "Dtaction",
option_list,
sizeof(option_list)/sizeof(XrmOptionDescRec),
&argc, argv)) )
{
setlocale(LC_ALL, "");
fprintf(stderr, "%s", GETMESSAGE(1,11,"Can't open display.\n"));
exit(-1);
}
XtSetArg(args[n], XmNallowShellResize, True); n++;
XtSetArg(args[n], XmNmappedWhenManaged, False); n++;
XtSetArg(args[n], XmNheight, 1); n++;
XtSetArg(args[n], XmNwidth, 1); n++;
toplevel = XtAppCreateShell( argv[0], "Dtaction",
topLevelShellWidgetClass, display, args, n) ;
XtRealizeWidget(toplevel);
display = XtDisplay (toplevel);
XtGetApplicationResources(toplevel, &appArgs,
resources, XtNumber(resources), NULL, 0);
password = XtMalloc(1);
password[0] = '\0';
stars = XtMalloc(1);
stars[0] = '\0';
/* Get Dt initialized */
if (DtInitialize (display, toplevel, argv[0], "Dtaction") == False)
{
/* Fatal Error: could not connect to the messaging system. */
/* DtInitialize() has already logged an appropriate error msg */
exit(-1);
}
/*
* If the request specified that it wanted to run as a different
* user, then take care of prompting for a password, and doing any
* necessary verification and logging.
*/
CheckUserRequest();
/* Load the filetype/action dbs; DtInvokeAction() requires this */
DtDbLoad();
/*
* Get the requested action name
*/
if ( (actionName = argv[1]) == NULL)
{
fprintf(stderr, "%s", GETMESSAGE(1,10,"No action name specified.\n"));
exit(-1);
}
if ( argc > 2 )
{
/*
* create an action arg array for the file objects for
* this action. This number of objects should be one
* less than the argument count. The returned vector will
* be terminated by a null pointer.
*/
numArgs= argc - 2;
ap = (DtActionArg *) XtCalloc(numArgs,sizeof(DtActionArg));
}
/*
* This client is restricted to FILE arguments.
* for the time being.
*/
for ( n = 0; n < numArgs; n++) {
ap[n].argClass = DtACTION_FILE;
ap[n].u.file.name = argv[n+2];
}
actionId = DtActionInvoke(toplevel, actionName, ap, numArgs,
appArgs.termOpts,
appArgs.execHost,
appArgs.contextDir,
True, /* use indicator */
(DtActionCallbackProc) actionStatusCallback,
NULL);
/*
* Set up a timer if we didn't get a valid procId -- since there will
* be no invocation update in that case.
* We must invoke XtMainLoop() at least once, to force any prompt or
* error dialogs to get posted.
*/
if ( !actionId)
XtAppAddTimeOut(appContext,
10, (XtTimerCallbackProc)CheckForDone,
NULL);
XtAppMainLoop(appContext);
return EXIT_SUCCESS;
}
/*ARGSUSED*/
static void
AddVesaModeCallback(Widget w, XtPointer call_data, XtPointer client_data)
{
xf86cfgVesaModeInfo *vesa = (xf86cfgVesaModeInfo*)call_data;
XF86VidModeModeInfo mode;
int num_infos = vidtune->num_infos;
memcpy(&mode, &vesa->info, sizeof(XF86VidModeModeInfo));
if (XF86VidModeAddModeLine(XtDisplay(toplevel), vidtune->screen,
&vesa->info, &mode)) {
XSync(XtDisplay(toplevel), False);
GetModes();
}
else {
XBell(XtDisplayOfObject(w), 80);
return;
}
if (vidtune && num_infos == vidtune->num_infos) {
/* XF86VidModeAddModeLine returned True, but no modeline was added */
XBell(XtDisplayOfObject(w), 80);
if (vidtune->monitor && AddMode()) {
XF86ConfModeLinePtr mode;
char label[256], *ptr, *str;
XmuSnprintf(label, sizeof(label), "%s", vesa->ident);
/* format mode name to not have spaces */
ptr = strchr(label, ')');
if (ptr)
*++ptr = '\0';
ptr = str = label;
while (*ptr) {
if (*ptr != ' ')
*str++ = *ptr;
++ptr;
}
*str = '\0';
if (xf86findModeLine(label, vidtune->monitor->mon_modeline_lst)
!= NULL && !ForceAddMode())
return;
mode = (XF86ConfModeLinePtr)XtCalloc(1, sizeof(XF86ConfModeLineRec));
mode->ml_identifier = XtNewString(label);
mode->ml_clock = vesa->info.dotclock;
mode->ml_hdisplay = vesa->info.hdisplay;
mode->ml_hsyncstart = vesa->info.hsyncstart;
mode->ml_hsyncend = vesa->info.hsyncend;
mode->ml_htotal = vesa->info.htotal;
mode->ml_vdisplay = vesa->info.vdisplay;
mode->ml_vsyncstart = vesa->info.vsyncstart;
mode->ml_vsyncend = vesa->info.vsyncend;
mode->ml_vtotal = vesa->info.vtotal;
/* mode->ml_vscan = ???;*/
mode->ml_flags = vesa->info.flags;
mode->ml_hskew = vesa->info.hskew;
vidtune->monitor->mon_modeline_lst =
xf86addModeLine(vidtune->monitor->mon_modeline_lst, mode);
}
}
}
void
CheckChipsets(xf86cfgModuleOptions *opts, int *err)
{
int i, j, ichk, ivnd = 0, vendor = -1, device;
const pciDeviceInfo **pDev;
SymTabPtr chips = opts->chipsets;
chipset_check *check = NULL;
int num_check = 0;
if (!chips) {
CheckMsg(CHECKER_NO_CHIPSETS, "WARNING No chipsets specified.\n");
++*err;
return;
}
while (chips->name) {
device = chips->token & 0xffff;
vendor = (chips->token & 0xffff0000) >> 16;
if (vendor == 0)
vendor = opts->vendor;
for (ichk = 0; ichk < num_check; ichk++)
if (check[ichk].vendor == vendor)
break;
if (ichk >= num_check) {
check = (chipset_check*)
XtRealloc((XtPointer)check,
sizeof(chipset_check) * (num_check + 1));
check[num_check].vendor = vendor;
memset(&check[num_check], 0, sizeof(chipset_check));
++num_check;
}
/* Search for vendor in xf86PCIVendorInfo */
if (xf86PCIVendorInfo) {
for (ivnd = 0; xf86PCIVendorInfo[ivnd].VendorID; ivnd++)
if (vendor == xf86PCIVendorInfo[ivnd].VendorID)
break;
}
if (xf86PCIVendorInfo && xf86PCIVendorInfo[ivnd].VendorID) {
check[ichk].valid_vendor = 1;
check[ichk].ivendor = ivnd;
}
else {
CheckMsg(CHECKER_CANNOT_VERIFY_CHIPSET,
"WARNING Cannot verify chipset \"%s\" (0x%x)\n",
chips->name, device);
++*err;
++chips;
continue;
}
if (xf86PCIVendorInfo &&
(pDev = xf86PCIVendorInfo[ivnd].Device) != NULL) {
if (check[ichk].chipsets == NULL) {
for (j = 0; pDev[j]; j++)
;
check[ichk].chipsets = (char*)XtCalloc(1, j);
}
for (j = 0; pDev[j]; j++) {
if (device == pDev[j]->DeviceID) {
if (strcmp(chips->name, pDev[j]->DeviceName)) {
CheckMsg(CHECKER_NOMATCH_CHIPSET_STRINGS,
"WARNING chipset strings don't match: \"%s\" \"%s\" (0x%x)\n",
chips->name, xf86PCIVendorInfo[ivnd].Device[j]->DeviceName,
device);
++*err;
}
break;
}
}
if (!pDev[j]) {
CheckMsg(CHECKER_CHIPSET_NOT_LISTED,
"WARNING chipset \"%s\" (0x%x) not in list.\n", chips->name, device);
++*err;
}
else
check[ichk].chipsets[j] = 1;
}
++chips;
}
for (i = 0; i < num_check; i++) {
if (!check[i].valid_vendor) {
CheckMsg(CHECKER_CHIPSET_NO_VENDOR,
"WARNING No such vendor 0x%x\n", vendor);
++*err;
}
for (j = 0; j < check[i].num_chipsets; j++) {
if (xf86PCIVendorInfo && !check[i].chipsets[j]) {
CheckMsg(CHECKER_CHIPSET_NOT_SUPPORTED,
"NOTICE chipset \"%s\" (0x%x) not listed as supported.\n",
xf86PCIVendorInfo[check[i].ivendor].Device[j]->DeviceName,
xf86PCIVendorInfo[check[i].ivendor].Device[j]->DeviceID);
}
}
XtFree(check[i].chipsets);
}
XtFree((XtPointer)check);
}
/***********************************************************************
* *
* Show (manage) the ntuple scanner. *
* *
***********************************************************************/
static void show_ntupleScanner(Widget w, XtPointer cd,
XmAnyCallbackStruct *call_data)
{
Widget widget;
Pixmap pixmap;
Display *display;
char *title, *first, *nrow;
XmString xmtit;
int i, ifirst, nevent;
if (ntuple.id == 0) return;
if (no_scan) {
no_scan = False;
return;
}
/*
* Copy items from the ntuple structure for local use.
* These items are necessary for being able to scan an Ntuple that
* is no longer in the Ntuple viewer.
*/
ntuple_id = ntuple.id;
ntuple_nrows = ntuple.nrows;
strcpy(ntuple_dir, ntuple.dir);
if (n_scanners >= MAX_SCANNERS) {
km_inform_user(w, "Cannot open more Ntuple scanners.", "");
return;
}
widget = create_ntupleScan();
(void)get_scan_context(widget);
/* set icon for scan window */
display = XtDisplay(widget);
pixmap = XCreateBitmapFromData(display, DefaultRootWindow(display),
scan_bits, scan_width,
scan_height);
for (i = 0; i < MAX_SCANNERS; i++) {
if (!scanner[i].widget) {
title = XtCalloc(MAX_STRING, 1);
sprintf(title, "Ntuple Scanner %d", i+1);
XtVaSetValues(XtParent(widget), XmNtitle, title,
XmNiconName, title,
XmNiconPixmap, pixmap,
XmNdeleteResponse, XmUNMAP,
NULL);
/* make scanner known to KUIP's Exec window */
km_store_appShell(widget, title);
XtFree(title);
break;
}
}
/*
* Make sure that if the window is popped down, the scanner is
* properly destroyed.
*/
XtAddCallback(XtParent(widget), XmNpopdownCallback,
(XtCallbackProc)popdown_cb, widget);
/*
* Install close callback
*/
XtAddCallback(closeScButton, XmNactivateCallback,
(XtCallbackProc)close_cb, widget);
/*
* Install callbacks for text, re-scan, next and previous buttons
*/
XtAddCallback(firstScText, XmNactivateCallback,
(XtCallbackProc)next_cb, widget);
XtAddCallback(nrowScText, XmNactivateCallback,
(XtCallbackProc)next_cb, widget);
XtAddCallback(scanScButton, XmNactivateCallback,
(XtCallbackProc)next_cb, widget);
XtAddCallback(nextScButton, XmNactivateCallback,
(XtCallbackProc)next_cb, widget);
XtAddCallback(previousScButton, XmNactivateCallback,
(XtCallbackProc)next_cb, widget);
XtSetSensitive(previousScButton, False);
/* "Previous" does not work with new QP */
XtVaSetValues(previousScButton, XmNmappedWhenManaged, False, NULL);
/*
* Fill in the first and number of row fields as well as the
* Ntuple title label
*/
first = XmTextGetString(firstNtText);
nrow = XmTextGetString(nrowNtText);
ifirst = atoi(first);
nevent = atoi(nrow);
if (nevent > MAX_ROWS) nevent = MAX_ROWS;
if (ifirst+nevent-1 >= ntuple_nrows)
XtSetSensitive(nextScButton, False);
XtFree(nrow);
nrow = XtCalloc(20, 1);
sprintf(nrow, "%d", nevent);
XmTextSetString(firstScText, first);
XmTextSetString(nrowScText, nrow);
XtFree(first);
XtFree(nrow);
XtVaGetValues(titleNtLabel, XmNlabelString, &xmtit, NULL);
XtVaSetValues(titleScLabel, XmNlabelString, xmtit, NULL);
/* execute the scan command */
matrix = (Widget) NULL;
no_vars = -1;
execute_scan_cmd(w, widget);
/* finally popup the scanner */
UxPopupInterface(widget, XtGrabNone);
n_scanners++;
for (i = 0; i < MAX_SCANNERS; i++) {
if (!scanner[i].widget) {
scanner[i].widget = widget;
break;
}
}
save_scan_context(widget);
}
void
XmuWnFetchResources(XmuWidgetNode *node, Widget toplevel,
XmuWidgetNode *topnode)
{
Widget dummy;
XmuWidgetNode *wn;
if (node->have_resources) return;
dummy = XtCreateWidget (node->label, XmuWnClass(node), toplevel,
NULL, ZERO);
if (dummy) XtDestroyWidget (dummy);
/*
* walk up tree geting resources; since we've instantiated the widget,
* we know that all of our superclasses have been initialized
*/
for (wn = node; wn && !wn->have_resources; wn = wn->superclass) {
XtGetResourceList (XmuWnClass(wn), &wn->resources, &wn->nresources);
if (wn->resources) {
qsort ((char *) wn->resources, wn->nresources,
sizeof(XtResource), compare_resource_entries);
}
wn->resourcewn = (XmuWidgetNode **) XtCalloc (wn->nresources,
sizeof (XmuWidgetNode *));
if (!wn->resourcewn) {
fprintf (stderr,
"%s: unable to calloc %d %lu byte widget node ptrs\n",
"XmuWnFetchResources",wn->nresources,
sizeof (XmuWidgetNode *));
exit (1);
}
XtGetConstraintResourceList (XmuWnClass(wn), &wn->constraints,
&wn->nconstraints);
if (wn->constraints) {
qsort ((char *) wn->constraints, wn->nconstraints,
sizeof(XtResource), compare_resource_entries);
}
wn->constraintwn = (XmuWidgetNode **)
XtCalloc (wn->nconstraints, sizeof (XmuWidgetNode *));
if (!wn->constraintwn) {
fprintf (stderr,
"%s: unable to calloc %d %d byte widget node ptrs\n",
"XmuWnFetchResources", wn->nconstraints,
(int)sizeof (XmuWidgetNode *));
exit (1);
}
wn->have_resources = True;
if (wn == topnode) break;
}
/*
* Walk up tree removing all resources that appear in superclass; we can
* mash the resource list in place since it was copied out of widget.
*/
for (wn = node; wn; wn = wn->superclass) {
mark_resource_owner (wn);
if (wn == topnode) break;
}
return;
}
/***********************************************************************
* *
* Scan the next or previous "number of row" rows. *
* *
***********************************************************************/
static void next_cb(Widget w, Widget scan, XmAnyCallbackStruct *call_data)
{
char *first, *nrow;
int ifirst, nevent;
(void)get_scan_context(scan);
if (w != scanScButton) {
first = XmTextGetString(firstScText);
nrow = XmTextGetString(nrowScText);
ifirst = atoi(first);
nevent = atoi(nrow);
if (w == nextScButton) {
ifirst = last_event + 1;
if (ifirst+nevent-1 >= ntuple_nrows)
XtSetSensitive(nextScButton, False);
XtSetSensitive(previousScButton, True);
}
if (w == previousScButton) {
/* ifirst range check is done in matrix_row */
XtSetSensitive(nextScButton, True);
}
if (w == firstScText) {
XtSetSensitive(nextScButton, True);
XtSetSensitive(previousScButton, True);
if (ifirst <= 1) {
ifirst = 1;
XtSetSensitive(previousScButton, False);
}
if (ifirst+nevent-1 >= ntuple_nrows) {
if (ifirst > ntuple_nrows)
ifirst = ntuple_nrows;
XtSetSensitive(nextScButton, False);
}
}
if (w == nrowScText) {
if (nevent < 1) nevent = 1;
if (nevent > MAX_ROWS) nevent = MAX_ROWS;
if (ifirst+nevent-1 >= ntuple_nrows)
XtSetSensitive(nextScButton, False);
else
XtSetSensitive(nextScButton, True);
}
XtFree(first);
first = XtCalloc(20, 1);
sprintf(first, "%d", ifirst);
XmTextSetString(firstScText, first);
sprintf(first, "%d", nevent);
XmTextSetString(nrowScText, first);
XtFree(first);
XtFree(nrow);
}
/* execute the scan command */
execute_scan_cmd(w, scan);
save_scan_context(scan);
}
static void
initialize(Widget request, Widget new_w, ArgList args, Cardinal *num_args)
{
Widget option = NULL, menu = NULL, demo, form, top = NULL, count_label;
Arg al[10];
int ac, i;
XmString xms;
char *p, *q, *fn, *n;
MB_DialogType(new_w) = XmDIALOG_MESSAGE;
ac = 0;
form = XmCreateForm(new_w, "form", al, ac);
p = fn = strdup(FC_FieldNames(new_w));
n = XtMalloc(strlen(fn) + 10);
FC_Menus(new_w) = (Widget *)XtCalloc(14, sizeof(Widget));
FC_Setting(new_w) = (String *)XtCalloc(14, sizeof(String));
for (i=0; i<14; i++)
FC_Setting(new_w)[i] = NULL;
for (i=0; i<14; i++) { /* XLFD has this many fields */
q = strchr(p, ',');
if (q)
*q = '\0';
strcpy(n, p);
strcat(n, "_pulldown");
ac = 0;
FC_Menus(new_w)[i] = menu = XmCreatePulldownMenu(form, n, al, ac);
XtAddCallback(menu, XmNmapCallback, FitMenuOnScreen, NULL);
strcpy(n, p);
xms = XmStringCreateSimple(n);
strcat(n, "_option");
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, menu); ac++;
if (i == 0 || i == 4 || i == 10) {
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
} else {
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, option); ac++;
}
if (i >= 4) {
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, top); ac++;
}
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNlabelString, xms); ac++;
option = XmCreateOptionMenu(form, n, al, ac);
XtManageChild(option);
XmStringFree(xms);
if (i == 3 || i == 9)
top = option;
if (q)
p = q+1;
}
free(fn);
XtFree(n);
ac = 0;
xms = XmStringCreateSimple(FC_CountString(new_w));
XtSetArg(al[ac], XmNlabelString, xms); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 10); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, option); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
FC_CountWidget(new_w) = count_label = XmCreateLabelGadget(form, "count_label", al, ac);
XmStringFree(xms);
ac = 0;
xms = XmStringCreateSimple(FC_DemoString(new_w));
XtSetArg(al[ac], XmNlabelString, xms); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, option); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
FC_DemoWidget(new_w) = demo = XmCreateLabelGadget(form, "demo_label", al, ac);
XmStringFree(xms);
if (FC_ShowDemo(new_w)) {
XtManageChild(count_label);
XtManageChild(demo);
}
GetFullFontList(new_w);
XtManageChild(form);
}
/***********************************************************************
* *
* Execute the scan command for scanner widget. *
* *
***********************************************************************/
static void execute_scan_cmd(Widget button, Widget scan)
{
char *cmd, *cut, *first, *nrow, *vlist, *var, *s;
int ifirst, nevent, nvar, cnt, i, update;
XmString *xmlst, xmstr;
cmd = XtCalloc(MAX_CMD_LENGTH, 1);
vlist = XtCalloc(MAX_CMD_LENGTH, 1);
/* cut = XtCalloc(MAX_STRING, 1); */
if (no_vars == -1) {
/*
* get the variables to be scanned from the right-hand list of the
* column selection dialog
*/
XtVaGetValues(var2NtSList, XmNitemCount, &cnt,
XmNitems, &xmlst,
NULL);
nvar = 0;
for (i = 0; i < cnt; i++) {
nvar++;
if (nvar > MAX_COLS) {
nvar--;
km_inform_user(button, "Cannot scan more than 512 columns.", "");
break;
}
var = extract_normal_string(xmlst[i]);
/* get rid of extended info */
if ((s = strchr(var, '(')) || (s = strchr(var, '[')) ||
(s = strchr(var, ':')))
*s = '\0';
strcat(vlist, var); strcat(vlist, " ");
XtFree(var);
}
no_vars = nvar;
strcpy(var_list, vlist);
} else {
nvar = no_vars;
strcpy(vlist, var_list);
}
/* get the cuts */
if (strempty(cut_expression) || XmToggleButtonGetState(ignoreCutNtToggle))
/* strcpy(cut, "!"); */
cut = strdup ("!");
else
/* strcpy(cut, cut_expression); */
cut = strdup (cut_expression);
first = XmTextGetString(firstScText);
nrow = XmTextGetString(nrowScText);
ifirst = atoi(first);
max_rows = atoi(nrow);
/* check range values */
update = 0;
if (ifirst < 1) {
ifirst = 1;
update++;
}
if (ifirst > ntuple_nrows) {
ifirst = ntuple_nrows;
update++;
}
if (max_rows < 1) {
max_rows = 1;
update++;
}
if (max_rows > MAX_ROWS) {
max_rows = MAX_ROWS;
update++;
}
if (update) {
XtFree(first);
first = XtCalloc(15, 1);
sprintf(first, "%d", ifirst);
XmTextSetString(firstScText, first);
sprintf(first, "%d", max_rows);
XmTextSetString(nrowScText, first);
}
if (button == previousScButton) {
ifirst--;
nevent = -99999999;
reverse_order = True;
} else {
nevent = 99999999;
reverse_order = False;
}
/* construct and execute Paw command */
if (nvar)
sprintf(cmd, "Ntuple/Scan %s/%d %s %d %d %d %s", ntuple_dir, ntuple_id,
cut, nevent, -ifirst, nvar, vlist);
else
sprintf(cmd, "Ntuple/Scan %s/%d %s %d %d", ntuple_dir, ntuple_id,
cut, nevent, -ifirst);
km_all_cursor(KM_WAIT_CURSOR);
execute_kuip_cmd(cmd);
/* show number of rows and columns displayed in scanner */
cut = malloc( MAX_STRING );
sprintf(cut, "%d R %d C", nrows, ncols);
xmstr = XmStringCreate(cut, XmSTRING_DEFAULT_CHARSET);
XtVaSetValues(columnsScLabel, XmNlabelString, xmstr, NULL);
XmStringFree(xmstr);
km_all_cursor(KM_MAIN_CURSOR);
XtFree(cmd);
/* XtFree(cut); */
free (cut);
XtFree(vlist);
XtFree(first);
XtFree(nrow);
}
/*++++++++++++++++++++++++++++++++++++++*/
int
main(
int argc,
char **argv )
{
int n;
Arg args[MAX_ARGS];
XEvent event;
XPropertyEvent *pEvent=(XPropertyEvent *)&event;
long mwmFunc;
Boolean useMaskRtn, useIconFileCacheRtn;
char *dirs = NULL;
char *string;
Visual *visual;
#ifdef USERHELP
malloc_check(1);
malloc_trace(0);
#endif
XtSetLanguageProc(NULL, NULL, NULL);
_DtEnvControl(DT_ENV_SET);
/* Initialize the toolkit and open the display */
style.shell =
XtInitialize(argv[0], XMCLASS, option_list, 1, (int *)&argc, argv);
#ifdef __osf__
_XmColorObjCreate(style.shell, NULL, NULL);
#endif
/* Allow all WS manipulation functions except resize and maximize */
mwmFunc = MWM_FUNC_ALL ^ (MWM_FUNC_RESIZE | MWM_FUNC_MAXIMIZE);
n = 0;
XtSetArg(args[n], XmNmwmFunctions, mwmFunc); n++;
XtSetArg(args[n], XmNuseAsyncGeometry, True); n++;
XtSetValues(style.shell, args, n);
/* initialize global style data */
style.display = XtDisplay(style.shell);
style.screen = DefaultScreenOfDisplay(style.display);
style.screenNum = DefaultScreen(style.display);
style.colormap = DefaultColormap(style.display, style.screenNum);
style.root = DefaultRootWindow(style.display);
style.execName = argv[0];
style.errDialog = NULL;
style.tmpXmStr = NULL;
style.home = (char *) XtMalloc(strlen((char *) getenv("HOME")) + 1);
strcpy(style.home, (char *) getenv("HOME"));
style.colorDialog = NULL;
style.backdropDialog = NULL;
style.fontDialog = NULL;
style.kbdDialog = NULL;
style.mouseDialog = NULL;
style.audioDialog = NULL;
style.screenDialog = NULL;
style.startupDialog = NULL;
style.dtwmDialog = NULL;
style.i18nDialog = NULL;
visual = XDefaultVisual(style.display,style.screenNum);
style.visualClass = visual->class;
if (progName = DtStrrchr(argv[0], '/')) progName++;
else progName = argv[0];
/* Get the lock established to ensure only one dtstyle process
* is running per screen .. first malloc enough space*/
if (_DtGetLock (style.display, STYLE_LOCK) == 0)
{
_DtSimpleError (progName, DtError, NULL, "%s",
((char *)GETMESSAGE(2, 5, "Style Manager is already running, second attempt aborted.")));
exit(1);
}
InitDtstyleProtocol();
SetWindowProperties();
/* Register error handlers */
XSetErrorHandler(ErrorHandler);
XSetIOErrorHandler(IOErrorHandler);
XtAppSetErrorHandler(XtWidgetToApplicationContext(style.shell),
ToolkitErrorHandler);
XtAddEventHandler(style.shell, StructureNotifyMask, 0,
(XtEventHandler)MwmReparentNotify, NULL);
/* set up resolution dependent layout variables */
switch (_DtGetDisplayResolution(style.display, style.screenNum))
{
case LOW_RES_DISPLAY:
style.horizontalSpacing =
style.verticalSpacing = 3;
break;
case MED_RES_DISPLAY:
style.horizontalSpacing =
style.verticalSpacing = 5;
break;
case HIGH_RES_DISPLAY:
style.horizontalSpacing =
style.verticalSpacing = 8;
break;
}
GetApplicationResources();
XmeGetIconControlInfo(style.screen, &useMaskRtn,
&style.useMultiColorIcons, &useIconFileCacheRtn);
/* add the directory $HOME/.dt/backdrops */
string = (char *)XtMalloc(strlen(style.home) + strlen("/.dt/backdrops:") + 1);
sprintf(string, "%s/.dt/backdrops:", style.home);
dirs = (char *)XtCalloc(1, strlen("/etc/dt/backdrops:/usr/dt/backdrops") +
(style.xrdb.backdropDir == NULL ? 2 :
strlen(style.xrdb.backdropDir)) +
strlen(string) + 2);
strcpy(dirs, string);
if (style.xrdb.backdropDir)
{
strcat(dirs, style.xrdb.backdropDir);
strcat(dirs, ":");
}
strcat(dirs, "/etc/dt/backdrops:/usr/dt/backdrops");
_DtWsmSetBackdropSearchPath(style.screen, dirs, style.useMultiColorIcons);
if (string != NULL)
XtFree((char *)string);
if (dirs != NULL)
XtFree((char *)dirs);
style.count = 0;
/* if this is started from save session we need to set up the BMS
first, otherwise do it after making the window. (for user perception
for how long it takes for the dtstyle to come up) */
if(style.xrdb.session != NULL) {
DtInitialize (style.display, style.shell, progName, progName);
/*Restore a session or build and display the main Window.*/
if(!restoreSession(style.shell,style.xrdb.session))
init_mainWindow(style.shell);
}
else {
init_mainWindow(style.shell);
DtInitialize (style.display, style.shell, progName, progName);
InitializeAtoms();
CheckMonitor(style.shell);
GetDefaultPal(style.shell);
}
signal(SIGINT,(void (*)())activateCB_exitBtn);
signal(SIGTERM,(void (*)())activateCB_exitBtn);
/* to avoid defunct screen saver processes */
signal(SIGCHLD, (void (*)())WaitChildDeath);
/* backdrop dialog needs to know when the workspace changes to recolor
the bitmap displayed in the dialog */
ListenForWorkspaceChange();
/* if using COLOR builtin, style.workProcs is True */
if ((XmeUseColorObj() != FALSE) && style.workProcs)
XtAppAddWorkProc(XtWidgetToApplicationContext(style.shell),
NewCreateD, style.shell);
XtAppMainLoop(XtWidgetToApplicationContext(style.shell));
return 0;
}
void matrix_row(int *ievt, struct dsc$descriptor_s *row_dsc)
{
char *row = row_dsc->dsc$a_pointer;
#else
void matrix_row(int *ievt, char *row)
{
#endif
int i;
char **rows, **evt, *s, lab[MAXLAB+1];
static int cur_event;
if (!matrix) return;
/* when scan command finished it calls this routine with *ievt = -1 */
if (*ievt == -1) {
if (nrows == 0)
km_inform_user(matrix, "No events satisfied the imposed cuts.", "");
if (reverse_order) {
s = XtCalloc(MAX_STRING, 1);
sprintf(s, "%d", cur_event);
XmTextSetString(firstScText, s);
if (cur_event == 1)
XtSetSensitive(previousScButton, False);
XtFree(s);
}
return;
}
if (nrows >= max_rows) {
*ievt = -1;
return;
}
s = row;
rows = (char **) XtMalloc(ncols * sizeof(char *));
evt = (char **) XtMalloc(1 * sizeof(char *));
for (i = 0; i < ncols; i++) {
strncpy(lab, s, MAXLAB); lab[MAXLAB] = '\0';
rows[i] = km_strip(lab);
s += MAXLAB;
}
cur_event = *ievt;
evt[0] = XtMalloc(10);
sprintf(evt[0], "%d", *ievt);
if (!nrows) {
for (i = 0; i < ncols; i++)
XbaeMatrixSetCell(matrix, 0, i, rows[i]);
XtVaSetValues(matrix, XmNrowLabels, evt, NULL);
last_event = *ievt;
} else {
if (reverse_order)
/* Scan the events in reverse order and add matrix element */
/* from bottom to top */
XbaeMatrixAddRows(matrix, 0, rows, evt, NULL, 1);
else {
/* Scan the events in normal order and add matrix element */
/* from top to bottom */
XbaeMatrixAddRows(matrix, nrows, rows, evt, NULL, 1);
last_event = *ievt;
}
}
nrows++;
for (i = 0; i < ncols; i++)
XtFree(rows[i]);
XtFree(evt[0]);
XtFree((char *) rows);
XtFree((char *) evt);
}
/*
* XmeTraitSet installs trait on object. It is typically called from a widget's
* class_part_initialize method. Subclasses of this object inherit the trait.
*
* object Specifies the object.
* trait The trait name (an XrmQuark value).
*
* Returns True on success.
*/
extern Boolean
XmeTraitSet(XtPointer obj, XrmQuark trait, XtPointer rec)
{
int i, j;
if (obj == NULL || trait == 0) {
DEBUGOUT(_LtDebug(__FILE__, NULL, "XmeTraitSet(NULL)\n"));
_XmInitTraits();
return False;
}
DEBUGOUT(_LtDebug(__FILE__, NULL, "XmeTraitSet(%s,%s)\n",
((WidgetClass)obj)->core_class.class_name,
XrmQuarkToString(trait)));
for (i=0; i<_num_traits; i++)
{
if (_traits[i].wc == (WidgetClass)obj)
{
/* Expand array */
if (_traits[i].num == 0)
{
_traits[i].num += NUM_TRAITS;
if (_traits[i].traits) {
_traits[i].traits = (_XmTraitRec *) XtRealloc(
(char *)_traits[i].traits,
sizeof(_XmTraitRec) * _traits[i].num);
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: _traits[%d].traits = %p,"
" size %d = %d * %d\n",
i, _traits[i].traits,
_traits[i].num * sizeof(_XmTraitRec),
_traits[i].num,
sizeof(_XmTraitRec)));
} else {
_traits[i].traits = (_XmTraitRec *) XtCalloc(
_traits[i].num, sizeof(_XmTraitRec));
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: _traits[%d].traits = %p,"
" size %d = %d * %d\n",
i, _traits[i].traits,
_traits[i].num * sizeof(_XmTraitRec),
_traits[i].num,
sizeof(_XmTraitRec)));
}
}
for (j=0; _traits[i].traits[j].trait && j<_traits[i].num; j++)
if (_traits[i].traits[j].trait == trait)
{
/* Trait was already installed !! */
/* If rec == NULL this removes the trait.
* Code for supporting this is in XmeTraitGet */
_traits[i].traits[j].traitrec = rec;
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: overwrite _traits[%d]."
"traits[%d].traitrec\n",
i, j));
return True;
}
if (j == _traits[i].num)
{
/* Expand array first */
_traits[i].num += NUM_TRAITS;
if (_traits[i].traits) {
_traits[i].traits = (_XmTraitRec *) XtRealloc(
(char *)_traits[i].traits,
sizeof(_XmTraitRec) * _traits[i].num);
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: _traits[%d].traits = %p,"
" size %d = %d * %d\n",
i, _traits[i].traits,
_traits[i].num * sizeof(_XmTraitRec),
_traits[i].num,
sizeof(_XmTraitRec)));
} else {
_traits[i].traits = (_XmTraitRec *) XtCalloc(
_traits[i].num, sizeof(_XmTraitRec));
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: _traits[%d].traits = %p,"
" size %d = %d * %d\n",
i, _traits[i].traits,
_traits[i].num * sizeof(_XmTraitRec),
_traits[i].num,
sizeof(_XmTraitRec)));
}
}
/* Add the trait to the list */
_traits[i].traits[j].trait = trait;
_traits[i].traits[j].traitrec = rec;
#if 0
_traits[i].traits[j+1].trait = NULLQUARK;
#endif
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: write _traits[%d]."
"traits[%d].traitrec\n",
i, j));
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: write _traits[%d]."
"traits[%d].traitrec\n",
i, j+1));
return True;
}
}
/* No traits known yet for this widget class */
if (_max_traits == _num_traits) {
_max_traits += NUM_WIDGET_CLASSES;
if (_traits) {
_traits = (struct _XmTraitWidgetList *)
XtRealloc((char *)_traits,
_max_traits * sizeof(struct _XmTraitWidgetList));
} else {
_traits = (struct _XmTraitWidgetList *) XtCalloc(
_max_traits, sizeof(struct _XmTraitWidgetList));
DEBUGOUT(_LtDebug(__FILE__, NULL,
"XmeTraitSet: _traits = %p, size %d = %d * %d\n",
_traits,
_max_traits * sizeof(struct _XmTraitWidgetList),
_max_traits,
sizeof(struct _XmTraitWidgetList)));
}
}
DEBUGOUT(_LtDebug(__FILE__, NULL, "XmeTraitSet: set _traits[%d]\n", i));
_traits[i].wc = (WidgetClass)obj;
_traits[i].num = 0;
_traits[i].traits = NULL;
_num_traits++;
DEBUGOUT(_LtDebug0(__FILE__, NULL, "Recursive Call : ")); /* no \n */
return XmeTraitSet(obj, trait, rec); /* Recursive call */
}
Bool
LoaderInitializeOptions(void)
{
static int first = 1;
static char *modules = "lib/modules";
volatile Bool options_ok = False;
char *ptr, query[256];
char *ptr2, query2[256];
char *type;
XrmValue value;
XrmQuark names[2];
XrmQuark classes[2];
volatile int i;
static ModuleType module_types[] = {
GenericModule, FontRendererModule, InputModule, VideoModule, NullModule
};
/* The offset in this vector must match loader.h:enum ModuleType values */
static char *module_strs[] = {
"Null Module", "Video Module", "Input Module", "Generic Module", "Font Module"
};
if (first) {
checkerLegend = (char**)
XtCalloc(1, sizeof(char*) * (CHECKER_LAST_MESSAGE + 1));
checkerErrors = (int*)
XtCalloc(1, sizeof(int) * (CHECKER_LAST_MESSAGE + 1));
xf86cfgLoaderInit();
first = 0;
checkerLegend[CHECKER_OPTIONS_FILE_MISSING] =
"The Options file, normally /usr/X11R6/lib/X11/Options was not found.\n";
checkerLegend[CHECKER_OPTION_DESCRIPTION_MISSING] =
"No description for the module option. The description should be in\n"
"in the Options file, and using the sintax:\n"
"Module.Option: any text describing the option";
checkerLegend[CHECKER_LOAD_FAILED] =
"Failed to load the module. Usually the loader will print a complete\n"
"description for the reason the module was not loaded. Use the -verbose\n"
"command line option if it is not printing any messages.";
checkerLegend[CHECKER_RECOGNIZED_AS] =
"This message means the module code did not follow what was expected\n"
"by the checker. For video drivers, it did not call xf86AddDriver,\n"
"a input module did not call xf86AddInputDriver and a font renderer\n"
"module did not call LoadFont. This message can also be printed if\n"
"the module is in the incorrect directory.";
checkerLegend[CHECKER_NO_OPTIONS_AVAILABLE] =
"The driver does not have an AvailableOptions function, or that\n"
"function is returning NULL. If the driver is returning NULL, and\n"
"really does not need any options from "__XCONFIGFILE__", than the message\n"
"can be ignored.";
checkerLegend[CHECKER_NO_VENDOR_CHIPSET] =
"The checker could not fetch the PCI chipset/vendor information from\n"
"the module. The checker currently wraps xf86PrintChipsets and\n"
"xf86MatchPciInstances to read the information from the module.";
checkerLegend[CHECKER_CANNOT_VERIFY_CHIPSET] =
"The vendor id was not found, so it is not possible to search the list\n"
"of chipsets.";
checkerLegend[CHECKER_OPTION_UNUSED] =
"The option description is defined in the Options file, but the option\n"
"was name not retrieved when calling the module AvailableOptions.";
checkerLegend[CHECKER_NOMATCH_CHIPSET_STRINGS] =
"The string specified in the module does not match the one in\n"
"common/xf86PciInfo.h";
checkerLegend[CHECKER_CHIPSET_NOT_LISTED] =
"This means that common/xf86PciInfo.h does not have an entry for the\n"
"given vendor and id.";
checkerLegend[CHECKER_CHIPSET_NOT_SUPPORTED] =
"The chipset is listed in common/xf86PciInfo.h, but the driver does\n"
"not support it, or does not list it in the chipsets fetched by the checker.";
checkerLegend[CHECKER_CHIPSET_NO_VENDOR] =
"The vendor id specified to xf86MatchPciInstances is not defined in\n"
"common/xf86PciInfo.h";
checkerLegend[CHECKER_NO_CHIPSETS] =
"No chipsets were passed to xf86MatchPciIntances.";
checkerLegend[CHECKER_FILE_MODULE_NAME_MISMATCH] =
"The module name string does not match the the modname field of the\n"
"XF86ModuleVersionInfo structure. This generally is not an error, but\n"
"to may be a good idea to use the same string to avoid confusion.";
}
if (XF86Module_path == NULL) {
XF86Module_path = malloc(strlen(XFree86Dir) + strlen(modules) + 2);
sprintf(XF86Module_path, "%s/%s", XFree86Dir, modules);
}
if (loaderPath == NULL || strcmp(XF86Module_path, loaderPath))
loaderPath = strdup(XF86Module_path);
else
/* nothing new */
return (True);
if (!noverify) {
options_ok = InitializeOptionsDatabase();
InitializePciInfo();
}
for (i = 0; module_types[i] != NullModule; i++) {
xf86cfgLoaderInitList(module_types[i]);
if (!noverify)
ErrorF("================= Checking modules of type \"%s\" =================\n",
module_strs[module_types[i]]);
if (loaderList) {
for (ploaderList = loaderList; *ploaderList; ploaderList++) {
signal_caught = 0;
signal(SIGTRAP, sig_handler);
signal(SIGBUS, sig_handler);
signal(SIGSEGV, sig_handler);
signal(SIGILL, sig_handler);
signal(SIGFPE, sig_handler);
if (sigsetjmp(jmp, 1) == 0) {
if (!noverify) {
int ok, nfont_modules;
nfont_modules = numFontModules;
error_level = 0;
ErrorF("CHECK MODULE %s\n", *ploaderList);
if ((ok = xf86cfgCheckModule()) == 0) {
CheckMsg(CHECKER_LOAD_FAILED,
"ERROR Failed to load module.\n");
error_level += 50;
}
else if (module_type != module_types[i]) {
CheckMsg(CHECKER_RECOGNIZED_AS,
"WARNING %s recognized as a \"%s\"\n", *ploaderList,
module_strs[module_type]);
++error_level;
}
if (ok) {
if (options_ok) {
if ((module_options == NULL || module_options->option == NULL) &&
module_type != GenericModule) {
CheckMsg(CHECKER_NO_OPTIONS_AVAILABLE,
"WARNING Not a generic module, but no options available.\n");
++error_level;
}
else if (module_options && strcmp(module_options->name, *ploaderList) == 0) {
ErrorF(" CHECK OPTIONS\n");
option = module_options->option;
while (option->name) {
XmuSnprintf(query, sizeof(query), "%s.%s", *ploaderList, option->name);
for (ptr = query, ptr2 = query2; *ptr; ptr++) {
if (*ptr != '_' && *ptr != ' ' && *ptr != '\t')
*ptr2 = tolower(*ptr);
}
*ptr2 = '\0';
/* all resources are in lowercase */
if (!XrmGetResource(options_xrm, query2, "Module.Option", &type, &value) ||
value.addr == NULL) {
CheckMsg(CHECKER_OPTION_DESCRIPTION_MISSING,
"WARNING no description for %s\n", query);
++error_level;
}
++option;
}
/* now do a linear search for Options file entries that are not
* in the driver.
*/
names[0] = XrmPermStringToQuark(module_options->name);
classes[0] = XrmPermStringToQuark("Option");
names[1] = classes[1] = NULLQUARK;
(void)XrmEnumerateDatabase(options_xrm, (XrmNameList)&names, (XrmClassList)&classes,
XrmEnumOneLevel, EnumDatabase, NULL);
}
}
else {
CheckMsg(CHECKER_OPTIONS_FILE_MISSING,
"ERROR Options file missing.\n");
error_level += 10;
}
if (module_type == VideoModule &&
(module_options == NULL || module_options->vendor < 0 ||
module_options->chipsets == NULL)) {
CheckMsg(CHECKER_NO_VENDOR_CHIPSET,
"WARNING No vendor/chipset information available.\n");
++error_level;
}
else if (module_type == VideoModule) {
if (module_options == NULL) {
/* No description for this, if this happen,
* something really strange happened. */
ErrorF(" ERROR No module_options!?!\n");
error_level += 50;
}
else {
ErrorF(" CHECK CHIPSETS\n");
CheckChipsets(module_options, &error_level);
}
}
/* font modules check */
if (module_type == FontRendererModule) {
if (strcmp(*ploaderList, font_module->name)) {
/* not an error */
ErrorF(" NOTICE FontModule->name specification mismatch: \"%s\" \"%s\"\n",
*ploaderList, font_module->name);
}
if (nfont_modules + 1 != numFontModules) {
/* not an error */
ErrorF(" NOTICE font module \"%s\" loaded more than one font renderer.\n",
*ploaderList);
}
}
else if (nfont_modules != numFontModules) {
ErrorF(" WARNING number of font modules changed from %d to %d.\n",
nfont_modules, numFontModules);
++error_level;
}
}
ErrorF(" SUMMARY error_level set to %d.\n\n", error_level);
}
else
(void)xf86cfgCheckModule();
}
signal(SIGTRAP, SIG_DFL);
signal(SIGBUS, SIG_DFL);
signal(SIGSEGV, SIG_DFL);
signal(SIGILL, SIG_DFL);
signal(SIGFPE, SIG_DFL);
}
xf86cfgLoaderFreeList();
}
else
ErrorF(" ERROR Failed to initialize module list.\n");
}
if (!noverify) {
ErrorF("===================================== LEGEND ===============================\n");
ErrorF("NOTICE lines are just informative.\n");
ErrorF("WARNING lines add 1 to error_level.\n");
ErrorF("ERROR lines add 2 or more (based on the severity of the error) to error_level.\n\n");
for (i = 0; i <= CHECKER_LAST_MESSAGE; i++)
if (checkerErrors[i]) {
ErrorF("%3d\n%s\n\n", i, checkerLegend[i]);
}
}
return (True);
}
