static void fav_list_dlg_purge_favlist (PgmState * pgm) { Arg arglist[20]; Cardinal i = 0; int sz; char **list; if (pgm->flist_loaded) { pgm->flist_loaded = 0; // pgm->current_fav_list=NULL; i = 0; XtSetArg (arglist[i], XtNlist, &list); i++; XtSetArg (arglist[i], XtNnumberStrings, &sz); i++; XtGetValues (pgm->flist_list, arglist, i); XawListChange (pgm->flist_list, NULL, 0, 0, True); XtSetSensitive (pgm->flist_list, False); mnuStrFree (list, sz); } }
void WGeMotif::action_inputfocus( Widget w, XmAnyCallbackStruct *data) { Arg args[1]; WGeMotif *ge; XtSetArg (args[0], XmNuserData, &ge); XtGetValues (w, args, 1); if ( !ge) return; if ( mrm_IsIconicState(w)) return; if ( ge->set_focus_disabled) return; if ( ge->graph) ((Graph *)ge->graph)->set_inputfocus(1); disable_set_focus( ge, 400); }
static void do_netcdffile_proc(Widget, XtPointer, XtPointer) { Widget dialog = (Widget)client_data; Arg args; XmString list_item; char *s; char fname[256]; set_wait_cursor(); XtSetArg(args, XmNtextString, &list_item); XtGetValues(dialog, &args, 1); XmStringGetLtoR(list_item, charset, &s); xv_setstr(netcdf_file_item, s); XtFree(s); unset_wait_cursor(); XtUnmanageChild(dialog); update_netcdfs(); }
void CoXHelpMotif::action_inputfocus( Widget w, XmAnyCallbackStruct *data) { Arg args[1]; CoXHelpMotif *xhelp; XtSetArg (args[0], XmNuserData, &xhelp); XtGetValues (w, args, 1); if ( !xhelp) return; if ( mrm_IsIconicState(w)) return; if ( xhelp->set_focus_disabled) return; if ( xhelp->xhelpnav && xhelp->displayed) { xhelp->xhelpnav->set_inputfocus(); } CoXHelpMotif::disable_set_focus( xhelp, 400); }
static void SpinCallback (Widget w, XtPointer client_data, XtPointer call_data) { String name, val; Arg args[16]; char buf[MSG_SIZ], *p; int j = 0; // Initialisation is necessary because the text value may be non-numeric causing the scanf conversion to fail int data = (intptr_t) client_data; Option *opt = dialogOptions[data >> 8] + (data & 255); XtSetArg(args[0], XtNlabel, &name); XtGetValues(w, args, 1); GetWidgetText(opt, &val); sscanf(val, "%d", &j); if (strcmp(name, _("browse")) == 0) { char *q=val, *r; for(r = ""; *q; q++) if(*q == '.') r = q; else if(*q == '/') r = ""; // last dot after last slash if(!strcmp(r, "") && !currentCps && opt->type == FileName && opt->textValue) r = opt->textValue; Browse(data>>8, opt->name, NULL, r, opt->type == PathName, "", &p, (FILE**) opt); return; } else
void BBoxMailFlag( ButtonBox buttonbox, char* name, int up) { Arg args[1]; Pixel flag; Button button = BBoxFindButtonNamed(buttonbox, name); if (button) { /* avoid unnecessary exposures */ XtSetArg(args[0], XtNleftBitmap, &flag); XtGetValues(button->widget, args, (Cardinal)1); if (up && flag != app_resources.flag_up) { XtSetArg(args[0], XtNleftBitmap, app_resources.flag_up); XtSetValues(button->widget, args, (Cardinal)1); } else if (!up && flag != app_resources.flag_down) { XtSetArg(args[0], XtNleftBitmap, app_resources.flag_down); XtSetValues(button->widget, args, (Cardinal)1); } } }
/* * File selection box callback */ void openCB(Widget w,int client_data,XmFileSelectionBoxCallbackStruct *call_data) { if (client_data==DIALOG_CANCEL) { /* do nothing if cancel is selected. */ XtUnmanageChild(open_dialog); return; } else if (client_data==DIALOG_ALL) { /* Add all the listed files */ Arg al[10]; int ac; Widget the_list; int nbfile; XmStringTable files; int i; the_list=XmFileSelectionBoxGetChild(open_dialog,XmDIALOG_LIST); if (!XmIsList(the_list)) { printf("PANIC: List are not what they used to be\n"); exit; } ac=0; XtSetArg(al[ac], XmNitemCount, &nbfile); ac++; XtSetArg(al[ac], XmNitems, &files); ac++; XtGetValues(the_list, al, ac); for (i=0;i<nbfile;i++) XmListAddItemUnselected(file_list,files[i],0); } else { /* get filename from file selection box and add it to the list*/ XmListAddItemUnselected(file_list,call_data->value,0); XtUnmanageChild(open_dialog); } }
/****************************************************************************** * * CreateGC: * Called by Initialize and by SetValues. * *****************************************************************************/ static void CreateGC ( Widget w ) { ExmSimpleWidget sw = (ExmSimpleWidget)w; XGCValues values; XtGCMask valueMask; Arg args[2]; Pixmap insensitiveStippleBitmap; /* This function creates two GC's: one to render a sensitive widget and the other to render an insensitive widget. */ /* First, create the sensitive GC (named normal_GC). */ valueMask = GCForeground | GCBackground | GCGraphicsExposures; values.foreground = sw->primitive.foreground; values.background = sw->core.background_pixel; values.graphics_exposures = False; sw->simple.normal_gc = XtGetGC ((Widget)sw, valueMask, &values); /* Next, create the insensitive GC. This GC will share the same foreground, background, and graphics exposures as the sensitive GC, but will hold a different fill style and stipple pattern. The stipple pattern is stored in the XmNinsensitiveStippleBitmap resource of XmScreen. */ valueMask |= GCFillStyle | GCStipple; values.fill_style = FillStippled; /* Gather the Motif-appropriate insensitive stipple bitmap. */ XtSetArg(args[0], XmNinsensitiveStippleBitmap, &insensitiveStippleBitmap); XtGetValues(XmGetXmScreen(XtScreen(w)), args, 1); values.stipple = insensitiveStippleBitmap; sw->simple.insensitive_gc = XtGetGC((Widget)sw, valueMask, &values); }
void ScopeMenu::receive (UpdateMenu &msg, void *client_data) { xList<UAS_SearchScope *> &scope_list = search_scope_mgr().scope_list(); List_Iterator<UAS_SearchScope *> s (scope_list); int n; Arg args[2]; WidgetList kids; Cardinal num_kids; n = 0; XtSetArg(args[n], XmNnumChildren, &num_kids); n++; XtSetArg(args[n], XmNchildren, &kids); n++; XtGetValues(f_pull_menu, args, n); // destroy all toggle buttons in menu for (unsigned int i = 0; i < num_kids; i++) { XtUnmanageChild (kids[i]); XtDestroyWidget (kids[i]); } // select current scope if(f_use_current_section) f_current_scope = s.item(); else { s++; f_current_scope = s.item(); } fill_menu(); XtUnmanageChild(XtParent(f_option_menu)); XtManageChild(XtParent(f_option_menu)); XtUnmanageChild(f_option_menu); XtManageChild(f_option_menu); }
static void callback (Widget w, Resource * node, XmPushButtonCallbackStruct * pbcs) { int vi; have_xy = 0; lesstif_show_crosshair (0); if (pbcs->event && pbcs->event->type == KeyPress) { Dimension wx, wy; Widget aw = XtWindowToWidget (display, pbcs->event->xkey.window); action_x = pbcs->event->xkey.x; action_y = pbcs->event->xkey.y; if (aw) { Widget p = work_area; while (p && p != aw) { n = 0; stdarg (XmNx, &wx); stdarg (XmNy, &wy); XtGetValues (p, args, n); action_x -= wx; action_y -= wy; p = XtParent (p); } if (p == aw) have_xy = 1; } //printf("have xy from %s: %d %d\n", XtName(aw), action_x, action_y); } lesstif_need_idle_proc (); for (vi = 1; vi < node->c; vi++) if (resource_type (node->v[vi]) == 10) if (hid_parse_actions (node->v[vi].value)) return; }
static void scroll_v_action( Widget w, XtPointer client_data, XtPointer call_data) { XmScrollBarCallbackStruct *cbs = (XmScrollBarCallbackStruct *) call_data; GrowCtx *ctx = (GrowCtx *) ((GrowWidget) client_data)->grow.grow_ctx; Arg arg[20]; int i; int maximum, slider, value, bottom; // Calculate if position is bottom i = 0; XtSetArg( arg[i], XmNmaximum, &maximum);i++; XtSetArg( arg[i], XmNsliderSize, &slider);i++; XtSetArg( arg[i], XmNvalue, &value);i++; XtGetValues( w, arg, i); if ( slider + value == maximum) bottom = 1; else bottom = 0; switch( cbs->reason) { case XmCR_DRAG: case XmCR_VALUE_CHANGED: case XmCR_INCREMENT: case XmCR_DECREMENT: case XmCR_PAGE_INCREMENT: case XmCR_PAGE_DECREMENT: case XmCR_TO_TOP: case XmCR_TO_BOTTOM: glow_scroll_vertical( ctx, cbs->value, bottom); break; } }
static void sched_purge (PgmState * a) { Arg arglist[20]; Cardinal i = 0; int sz; char **list; if (a->sched_loaded) { rsDestroy (a->r_sch, a->r_sch_sz); rsDestroy (a->pr_sch, a->pr_sch_sz); a->sched_loaded = 0; i = 0; XtSetArg (arglist[i], XtNlist, &list); i++; XtSetArg (arglist[i], XtNnumberStrings, &sz); i++; XtGetValues (a->sched_list, arglist, i); XawListChange (a->sched_list, NULL, 0, 0, True); XtSetSensitive (a->sched_list, False); mnuStrFree (list, sz); } }
static void switch_dlg_purge_pos (PgmState * pgm) { Arg arglist[20]; Cardinal i = 0; int sz; char **list; if (0 != pgm->pos_loaded) { pgm->pos_loaded = 0; pgm->pos_idx = XAW_LIST_NONE; i = 0; XtSetArg (arglist[i], XtNlist, &list); i++; XtSetArg (arglist[i], XtNnumberStrings, &sz); i++; XtGetValues (pgm->switch_dlg_pos_list, arglist, i); XawListChange (pgm->switch_dlg_pos_list, NULL, 0, 0, True); XtSetSensitive (pgm->switch_dlg_pos_list, False); mnuStrFree (list, sz); switch_dlg_purge_bands (pgm); } }
static void rdata_proc(Widget, XtPointer, XtPointer) { int graphno, autoflag; Arg args; XmString list_item; char *s; XtSetArg(args, XmNtextString, &list_item); XtGetValues(rdata_dialog, &args, 1); XmStringGetLtoR(list_item, charset, &s); graphno = GetChoice(read_graph_item) - 1; autoflag = XmToggleButtonGetState(read_auto_item); if (graphno == -1) { graphno = cg; } if (g[graphno].active == OFF) { set_graph_active(graphno); } set_type_proc(GetChoice(read_ftype_item)); set_wait_cursor(); if (getdata(graphno, s, cursource, curtype)) { if (autoscale_onread || autoflag) { autoscale_proc((Widget)NULL, (XtPointer)0, (XtPointer)NULL); } else { drawgraph(); } } XtFree(s); unset_wait_cursor(); }
Widget MakeLabel(char *txt) { int n = 0; int bg_color = -1; Arg wargs[5]; /* Used to set widget resources */ Widget label; if (lsx_curwin->toplevel == NULL && OpenDisplay(0, NULL) == 0) return NULL; n = 0; if (txt) { XtSetArg(wargs[n], XtNlabel, txt); n++; } label = XtCreateManagedWidget("label", labelWidgetClass, lsx_curwin->form_widget,wargs,n); if (label == NULL) return NULL; /* this little contortion here is to make sure there is no * border around the label (else it looks exactly like a command * button, and that's confusing) */ n = 0; XtSetArg(wargs[n], XtNbackground, &bg_color); n++; XtGetValues(label, wargs, n); n = 0; XtSetArg(wargs[n], XtNborder, bg_color); n++; XtSetValues(label, wargs, n); return label; } /* end of MakeLabel() */
static void accept_axislabel_proc(Widget w, XtPointer client_data, XtPointer call_data) { Arg a; tickmarks t; int iv; get_graph_tickmarks(cg, &t, curaxis); t.label_layout = GetChoice(axislabellayout) ? LAYOUT_PERPENDICULAR : LAYOUT_PARALLEL; t.label_place = GetChoice(axislabelplace) ? TYPE_SPEC : TYPE_AUTO; if (t.label_place == TYPE_SPEC) { char buf[128]; strcpy(buf, xv_getstr(axislabelspec)); sscanf(buf, "%lf %lf", &t.label.x, &t.label.y); } t.label.font = GetChoice(axislabelfont); t.label.color = GetChoice(axislabelcolor); t.label.linew = GetChoice(axislabellinew) + 1; XtSetArg(a, XmNvalue, &iv); XtGetValues(axislabelcharsize, &a, 1); t.label.charsize = iv / 100.0; set_graph_tickmarks(cg, &t, curaxis); drawgraph(); set_dirtystate(); }
void mrm_PositionPopup( Widget popup, Widget parent, int x, int y) { short x0, y0, x1, y1; Arg args[5]; Widget grandparent; x0 = (short) x; y0 = (short) y; grandparent = XtParent(parent); while( grandparent) { XtSetArg( args[0], XmNx, &x1); XtSetArg( args[1], XmNy, &y1); XtGetValues( parent, args, 2); if ( XtIsShell( parent)) break; x0 += x1; y0 += y1; parent = grandparent; grandparent = XtParent( parent); } XtSetArg(args[0], XmNx, x0); XtSetArg(args[1], XmNy, y0); XtSetValues( popup, args, 2); }
static int ProcessUIParams(PluginInstance* This, Boolean trusted, Boolean use_fwp, Boolean use_lbx, RxParams *in, RxReturnParams *out, char **x_ui_auth_ret) { XSecurityAuthorization dum; int dummy; char *display_name; This->app_group = None; if (out->embedded != RxFalse) { /* default is embedded */ /* let's see whether the server supports AppGroups or not */ if (RxGlobal.has_appgroup == RxUndef) { if (XQueryExtension(RxGlobal.dpy, "XC-APPGROUP", &dummy, &dummy, &dummy) && XagQueryVersion (RxGlobal.dpy, &dummy, &dummy)) RxGlobal.has_appgroup = RxTrue; else RxGlobal.has_appgroup = RxFalse; } if (RxGlobal.has_appgroup == RxTrue) { Screen *scr; Colormap cmap; Arg arg; /* use plugin's colormap as the default colormap */ XtSetArg(arg, XtNcolormap, &cmap); XtGetValues(This->plugin_widget, &arg, 1); scr = XtScreen(This->plugin_widget); if (cmap == DefaultColormapOfScreen(scr)) { XagCreateEmbeddedApplicationGroup (RxGlobal.dpy, None, cmap, BlackPixelOfScreen(scr), WhitePixelOfScreen(scr), &This->app_group); } else { XColor black, white; Pixel pixels[2]; black.red = black.green = black.blue = 0; XAllocColor(RxGlobal.dpy, cmap, &black); white.red = white.green = white.blue = 65535; XAllocColor(RxGlobal.dpy, cmap, &white); XagCreateEmbeddedApplicationGroup (RxGlobal.dpy, None, cmap, pixels[0] = black.pixel, pixels[1] = white.pixel, &This->app_group); XFreeColors(RxGlobal.dpy, cmap, pixels, 2, 0); } SetupStructureNotify (This); RxpSetupPluginEventHandlers (This); } else { /* too bad */ out->embedded = RxFalse; fprintf(stderr, "Warning: Cannot perform embedding as \ requested, APPGROUP extension not supported\n"); } } if (in->x_ui_auth[0] != 0) { GetXAuth(RxGlobal.dpy, in->x_ui_auth[0], in->x_ui_auth_data[0], trusted, This->app_group, False, DEFAULT_TIMEOUT, x_ui_auth_ret, &This->x_ui_auth_id, &dummy); } else if (in->x_auth[0] != 0) GetXAuth(RxGlobal.dpy, in->x_auth[0], in->x_auth_data[0], trusted, This->app_group, False, DEFAULT_TIMEOUT, x_ui_auth_ret, &This->x_ui_auth_id, &dummy); /* make sure we use the server the user wants us to use */ if (RxGlobal.has_real_server == RxUndef) { Display *rdpy = RxGlobal.dpy; char *real_display = getenv("XREALDISPLAY"); RxGlobal.has_real_server = RxFalse; if (real_display != NULL) { rdpy = XOpenDisplay(real_display); if (rdpy == NULL) rdpy = RxGlobal.dpy; else RxGlobal.has_real_server = RxTrue; } /* let's see now whether the server supports LBX or not */ if (XQueryExtension(rdpy, "LBX", &dummy, &dummy, &dummy)) RxGlobal.has_ui_lbx = RxTrue; else RxGlobal.has_ui_lbx = RxFalse; if (rdpy != RxGlobal.dpy) XCloseDisplay(rdpy); } if (RxGlobal.has_real_server == RxTrue) display_name = getenv("XREALDISPLAY"); else display_name = DisplayString(RxGlobal.dpy); /* let's see whether we have a firewall proxy */ if (use_fwp == True && RxGlobal.has_ui_fwp == RxUndef) { RxGlobal.fwp_dpyname = GetXFwpDisplayName(display_name); if (RxGlobal.fwp_dpyname != NULL) RxGlobal.has_ui_fwp = RxTrue; else { /* * We were supposed to use the firewall proxy but we * couldn't get a connection. There is no need to * continue. */ return 1; } } if (use_fwp == True && RxGlobal.has_ui_fwp == RxTrue) out->ui = GetXUrl(RxGlobal.fwp_dpyname, *x_ui_auth_ret, in->action); else out->ui = GetXUrl(display_name, *x_ui_auth_ret, in->action); if (in->x_ui_lbx == RxTrue) { if (use_lbx == True) { if (RxGlobal.has_ui_lbx == RxTrue) { out->x_ui_lbx = RxTrue; /* let's get a key for the proxy now */ if (in->x_ui_lbx_auth[0] != 0) { GetXAuth(RxGlobal.dpy, in->x_ui_lbx_auth[0], in->x_ui_lbx_auth_data[0], trusted, None, False, DEFAULT_TIMEOUT, &out->x_ui_lbx_auth, &dum, &dummy); } else if (in->x_auth[0] != 0) GetXAuth(RxGlobal.dpy, in->x_auth[0], in->x_auth_data[0], trusted, None, False, DEFAULT_TIMEOUT, &out->x_ui_lbx_auth, &dum, &dummy); } else { out->x_ui_lbx = RxFalse; fprintf(stderr, "Warning: Cannot setup LBX as requested, \ LBX extension not supported\n"); } } else out->x_ui_lbx = RxFalse; } else /* it's either RxFalse or RxUndef */
int main(int argc, char *argv[]) { Arg arglist[10]; Cardinal num_args; #ifdef USE_PRIVSEP struct passwd *pw; #endif XtSetLanguageProc(NULL,NULL,NULL); top = XtInitialize ("xconsole", "XConsole", options, XtNumber (options), &argc, argv); XtGetApplicationResources (top, (XtPointer)&app_resources, resources, XtNumber (resources), NULL, 0); #ifdef USE_PRIVSEP /* Revoke privileges if any */ if (getuid() == 0) { /* Running as root */ pw = getpwnam(XCONSOLE_USER); if (!pw) { fprintf(stderr, "%s user not found\n", XCONSOLE_USER); exit(2); } if (priv_init(pw->pw_uid, pw->pw_gid) < 0) { fprintf(stderr, "priv_init failed\n"); exit(2); } } else if (priv_init(-1, -1) < 0) { fprintf(stderr, "priv_init failed\n"); exit(2); } #endif if (app_resources.daemon) if (fork ()) exit (0); XtAddActions (actions, XtNumber (actions)); text = XtCreateManagedWidget ("text", asciiTextWidgetClass, top, NULL, 0); XtRealizeWidget (top); num_args = 0; XtSetArg(arglist[num_args], XtNiconic, &iconified); num_args++; XtGetValues(top, arglist, num_args); if (iconified) Iconified((Widget)NULL, (XEvent*)NULL, (String*)NULL, (Cardinal*)NULL); else Deiconified((Widget)NULL,(XEvent*)NULL,(String*)NULL,(Cardinal*)NULL); wm_delete_window = XInternAtom(XtDisplay(top), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(top), XtWindow(top), &wm_delete_window, 1); XmuGetHostname (mit_console_name + MIT_CONSOLE_LEN, 255); mit_console = XInternAtom(XtDisplay(top), mit_console_name, False); if (XGetSelectionOwner (XtDisplay (top), mit_console)) { XtGetSelectionValue(top, mit_console, XA_STRING, InsertSelection, NULL, CurrentTime); } else { XtOwnSelection(top, mit_console, CurrentTime, ConvertSelection, LoseSelection, NULL); OpenConsole (); } #ifdef USE_OSM ioerror = XSetIOErrorHandler(IOError); #endif #ifdef USE_PRIVSEP if (pledge("stdio rpath sendfd recvfd", NULL) == -1) err(1, "pledge"); #endif XtMainLoop (); return 0; }
int GSsetwidgetattr (Gwidget_t *widget, int attrn, Gwattr_t *attrp) { PIXpoint_t po; PIXsize_t ps; Dimension width, height; int ai; XColor c; int color; RESETARGS; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRSIZE: GETSIZE (attrp[ai].u.s, ps, MINSWSIZE); ADD2ARGS (XtNwidth, ps.x); ADD2ARGS (XtNheight, ps.y); break; case G_ATTRBORDERWIDTH: ADD2ARGS (XtNborderWidth, attrp[ai].u.i); break; case G_ATTRCHILDCENTER: GETORIGIN (attrp[ai].u.p, po); ADD2ARGS (XtNwidth, &width); ADD2ARGS (XtNheight, &height); XtGetValues (widget->w, argp, argn); po.x -= width / 2, po.y -= height / 2; if (po.x < 0) po.x = 0; if (po.y < 0) po.y = 0; XawViewportSetCoordinates (widget->w, po.x, po.y); break; case G_ATTRMODE: if (strcmp ("forcebars", attrp[ai].u.t) == 0) ADD2ARGS (XtNforceBars, True); else { Gerr (POS, G_ERRBADATTRVALUE, attrp[ai].u.t); return -1; } break; case G_ATTRCOLOR: color = attrp[ai].u.c.index; if (color != 0 && color != 1) { Gerr (POS, G_ERRBADCOLORINDEX, color); return -1; } c.red = attrp[ai].u.c.r * 257; c.green = attrp[ai].u.c.g * 257; c.blue = attrp[ai].u.c.b * 257; if (XAllocColor ( Gdisplay, DefaultColormap (Gdisplay, Gscreenn), &c )) { if (color == 0) ADD2ARGS (XtNbackground, c.pixel); else ADD2ARGS (XtNforeground, c.pixel); } break; case G_ATTRWINDOWID: Gerr (POS, G_ERRCANNOTSETATTR2, "windowid"); return -1; case G_ATTRUSERDATA: widget->udata = attrp[ai].u.u; break; default: Gerr (POS, G_ERRBADATTRID, attrp[ai].id); return -1; } } XtSetValues (widget->w, argp, argn); return 0; }
/************************************************************** * DaCreateGui: **************************************************************/ Widget DaCreateGui(char * name, char * aclass, int argc, char ** argv, Display * display) { Arg args[15]; Widget widget_array[10]; int n; /***************** object of type : ApplicationShell *****************/ n = 0; /* Setup argc & argv attribute */ XtSetArg(args[n], XtNargc, argc); n++; XtSetArg(args[n], XtNargv, argv); n++; widget_array[WI_DAINPUT] = XtAppCreateShell(name, aclass, applicationShellWidgetClass, display, args, n); /***************** mainWindow : XmMainWindow *****************/ widget_array[WI_MAINWINDOW] = XmCreateMainWindow(widget_array[WI_DAINPUT], "mainWindow", NULL, 0); /***************** menuBar : XmMenuBar *****************/ widget_array[WI_MENUBAR] = XmCreateMenuBar(widget_array[WI_MAINWINDOW], "menuBar", NULL, 0); /***************** File : XmCascadeButton *****************/ widget_array[WI_FILE] = XmCreateCascadeButton(widget_array[WI_MENUBAR], "File", NULL, 0); /***************** fileMenu : XmPulldownMenu *****************/ widget_array[WI_FILEMENU] = XmCreatePulldownMenu(widget_array[WI_MENUBAR], "fileMenu", NULL, 0); { Arg args[1]; XtSetArg(args[0], XmNsubMenuId, widget_array[WI_FILEMENU]); XtSetValues(widget_array[WI_FILE], args, 1); } /***************** Exit : XmPushButton *****************/ widget_array[WI_EXIT] = XmCreatePushButton(widget_array[WI_FILEMENU], "Exit", NULL, 0); XtAddCallback(widget_array[WI_EXIT], XmNactivateCallback, DaExit, NULL); /***************** Help : XmCascadeButton *****************/ widget_array[WI_HELP] = XmCreateCascadeButton(widget_array[WI_MENUBAR], "Help", NULL, 0); /***************** helpMenu : XmPulldownMenu *****************/ widget_array[WI_HELPMENU] = XmCreatePulldownMenu(widget_array[WI_MENUBAR], "helpMenu", NULL, 0); { Arg args[1]; XtSetArg(args[0], XmNsubMenuId, widget_array[WI_HELPMENU]); XtSetValues(widget_array[WI_HELP], args, 1); } /***************** Overview : XmPushButton *****************/ widget_array[WI_OVERVIEW] = XmCreatePushButton(widget_array[WI_HELPMENU], "Overview", NULL, 0); XtAddCallback(widget_array[WI_OVERVIEW], XmNactivateCallback, DaOverView, NULL); /***************** workArea : XmDrawingArea *****************/ n = 0; XtSetArg(args[n], XmNwidth, 300); n++; XtSetArg(args[n], XmNheight, 35); n++; widget_array[WI_WORKAREA] = XmCreateDrawingArea(widget_array[WI_MAINWINDOW], "workArea", args, n); /* * Register drawing area for input method support and set input * context values. */ XmImRegister(widget_array[WI_WORKAREA], 0); { Pixel bg, fg; Pixmap bg_pixmap; n = 0; XtSetArg(args[n], XmNbackground, &bg); n++; XtSetArg(args[n], XmNforeground, &fg); n++; XtSetArg(args[n], XmNbackgroundPixmap, &bg_pixmap);n++; XtGetValues(widget_array[WI_WORKAREA], args, n); n = 0; XtSetArg(args[n], XmNbackground, bg); n++; XtSetArg(args[n], XmNforeground, fg); n++; XtSetArg(args[n], XmNbackgroundPixmap, bg_pixmap);n++; XmImSetValues(widget_array[WI_WORKAREA], args, n); } /* * Add event handler for focus events. This is needed for the * input method to correctly display the input area. */ XtAddEventHandler(widget_array[WI_WORKAREA], EnterWindowMask|LeaveWindowMask|FocusChangeMask, False, DaFocusHandler, NULL); XtAddCallback(widget_array[WI_WORKAREA], XmNexposeCallback, DaRedrawText, NULL); XtAddCallback(widget_array[WI_WORKAREA], XmNinputCallback, DaInputText, NULL); XtAddCallback(widget_array[WI_WORKAREA], XmNresizeCallback, DaResizedText, NULL); /***************** menuBar : XmMenuBar *****************/ n = 0; XtSetArg(args[n], XmNmenuHelpWidget, widget_array[WI_HELP]); n++; XtSetValues(widget_array[WI_MENUBAR], args, n); XtManageChild(widget_array[WI_EXIT]); XtManageChild(widget_array[WI_FILE]); XtManageChild(widget_array[WI_OVERVIEW]); XtManageChild(widget_array[WI_HELP]); XtManageChild(widget_array[WI_MENUBAR]); XtManageChild(widget_array[WI_WORKAREA]); XtManageChild(widget_array[WI_MAINWINDOW]); /* * Return the first created widget. */ return widget_array[WI_DAINPUT]; }
int main(int argc, char **argv) { char *file_name = 0; Cardinal i; static Arg labelArgs[] = { {XtNlabel, (XtArgVal) pageLabel}, }; XtAppContext xtcontext; Arg topLevelArgs[2]; Widget entry; Arg pageNumberArgs[1]; int page_number; toplevel = XtAppInitialize(&xtcontext, "GXditview", options, XtNumber (options), &argc, argv, fallback_resources, NULL, 0); if (argc > 2 || (argc == 2 && (!strcmp(argv[1], "-help") || !strcmp(argv[1], "--help")))) Syntax(argv[0]); XtGetApplicationResources(toplevel, (XtPointer)&app_resources, resources, XtNumber(resources), NULL, (Cardinal) 0); if (app_resources.print_command) strcpy(current_print_command, app_resources.print_command); XtAppAddActions(xtcontext, xditview_actions, XtNumber (xditview_actions)); XtSetArg (topLevelArgs[0], XtNiconPixmap, XCreateBitmapFromData (XtDisplay (toplevel), XtScreen(toplevel)->root, (char *)xdit_bits, xdit_width, xdit_height)); XtSetArg (topLevelArgs[1], XtNiconMask, XCreateBitmapFromData (XtDisplay (toplevel), XtScreen(toplevel)->root, (char *)xdit_mask_bits, xdit_mask_width, xdit_mask_height)); XtSetValues (toplevel, topLevelArgs, 2); if (argc > 1) file_name = argv[1]; /* * create the menu and insert the entries */ simpleMenu = XtCreatePopupShell ("menu", simpleMenuWidgetClass, toplevel, NULL, 0); for (i = 0; i < XtNumber (menuEntries); i++) { entry = XtCreateManagedWidget(menuEntries[i].name, smeBSBObjectClass, simpleMenu, NULL, (Cardinal) 0); XtAddCallback(entry, XtNcallback, menuEntries[i].function, NULL); } paned = XtCreateManagedWidget("paned", panedWidgetClass, toplevel, NULL, (Cardinal) 0); viewport = XtCreateManagedWidget("viewport", viewportWidgetClass, paned, NULL, (Cardinal) 0); dvi = XtCreateManagedWidget ("dvi", dviWidgetClass, viewport, NULL, 0); page = XtCreateManagedWidget ("label", labelWidgetClass, paned, labelArgs, XtNumber (labelArgs)); XtSetArg (pageNumberArgs[0], XtNpageNumber, &page_number); XtGetValues (dvi, pageNumberArgs, 1); if (file_name) NewFile (file_name); /* NewFile modifies current_file_name, so do this here. */ if (app_resources.filename) strcpy(current_file_name, app_resources.filename); XtRealizeWidget (toplevel); if (file_name) SetPageNumber (page_number); XtAppMainLoop(xtcontext); return 0; }
/********************************************************************* * Function: ResizeDisplayArea * * ResizeDisplayArea resizes the Display Area and re-formats the * text based on a row and column values given. * *********************************************************************/ void _DtHelpResizeDisplayArea ( Widget parent, XtPointer client_data, int rows, int columns ) { int count = 0; register int n; unsigned long char_width; Arg args[5]; Dimension newWidth; Dimension newHeight; Dimension vertWidth = 0; Dimension horzHeight = 0; Dimension tstWidth; Dimension tstHeight; Dimension oldWidth; Dimension oldHeight; XEvent event; XmDrawnButtonCallbackStruct callBack; DtHelpDispAreaStruct *pDAS = (DtHelpDispAreaStruct *) client_data; /* * check the values. */ if (rows <= 0) rows = 1; if (columns <= 0) columns = 1; /* Set the size of the text view area to the requested number of columns */ /* and lines. */ char_width = pDAS->charWidth * columns; newWidth = char_width / 10 + (char_width % 10 ? 1 : 0) + 2 * (pDAS->decorThickness + pDAS->marginWidth); newHeight = pDAS->lineHeight * rows + 2 * pDAS->decorThickness; /* * get the width and height of the scroll bars. */ if (pDAS->vertScrollWid) { XtSetArg (args[0], XmNwidth , &vertWidth); XtGetValues (pDAS->vertScrollWid, args, 1); } if (pDAS->horzScrollWid) { XtSetArg (args[0], XmNheight , &horzHeight); XtGetValues (pDAS->horzScrollWid, args, 1); } /* * loop a couple of times at most to get the sizing correct. * This is caused by the fact we can't do a set values on * the drawn button itself, someone above it is rejecting * the resize request. So, resize the great-grandparent * (a couple of times if necessary). */ do { /* * take into consideration the scrollbars. */ tstWidth = newWidth; tstHeight = newHeight; if (pDAS->vertScrollWid && _DtHelpIS_AS_NEEDED(pDAS->neededFlags, _DtHelpVERTICAL_SCROLLBAR) && pDAS->vertIsMapped) { if (tstWidth > vertWidth) tstWidth -= vertWidth; else tstWidth = 0; } if (pDAS->horzScrollWid && _DtHelpIS_AS_NEEDED(pDAS->neededFlags, _DtHelpHORIZONTAL_SCROLLBAR) && pDAS->horzIsMapped) { if (tstHeight > horzHeight) tstHeight -= horzHeight; else tstHeight = 0; } if (tstWidth == pDAS->dispWidth && tstHeight == pDAS->dispHeight) return; /* * kludge around the fact that some parent is not letting * me resize the drawn button. Get the parent's size and * resize that! */ n = 0; XtSetArg(args[n], XmNwidth, &oldWidth); ++n; XtSetArg(args[n], XmNheight, &oldHeight); ++n; XtGetValues(parent, args, n); /* * calculate its new size */ oldWidth = oldWidth - pDAS->dispWidth + tstWidth; oldHeight = oldHeight - pDAS->dispHeight + tstHeight; /* * set my parent's size to affect me. */ n = 0; XtSetArg(args[n], XmNwidth, oldWidth); ++n; XtSetArg(args[n], XmNheight, oldHeight); ++n; XtSetValues(parent, args, n); } while (count++ < 2); /* * check to see if the Set Values on my parent took care of everything. */ if (pDAS->vertScrollWid && _DtHelpIS_AS_NEEDED(pDAS->neededFlags, _DtHelpVERTICAL_SCROLLBAR) && pDAS->vertIsMapped) { if (newWidth > vertWidth) newWidth -= vertWidth; else newWidth = 0; } if (pDAS->horzScrollWid && _DtHelpIS_AS_NEEDED(pDAS->neededFlags, _DtHelpHORIZONTAL_SCROLLBAR) && pDAS->horzIsMapped) { if (newHeight > horzHeight) newHeight -= horzHeight; else newHeight = 0; } if (newWidth == pDAS->dispWidth && newHeight == pDAS->dispHeight) return; /* * clean up _DtHelpClearSelection (pDAS); */ /* * reset the scroll bars and possibly reformat the text. */ _DtHelpSetScrollBars (client_data, newWidth, newHeight); if (XtIsRealized (pDAS->dispWid)) _DtHelpCleanAndDrawWholeCanvas(client_data); } /* End _DtHelpResizeDisplayArea */
/* Set DEBUG_CARTESIAN_PLOT in eventHandlers.c to do this with Btn3 */ void dumpCartesianPlot(Widget w) { Arg args[20]; int n=0; Dimension borderWidth; Dimension shadowThickness; Dimension highlightThickness; int headerBorderWidth; int headerHeight; int headerWidth; int graphBorderWidth; Dimension height; Dimension width; int legendBorderWidth; Dimension legendWidth; time_t timeBase; XtSetArg(args[n],XtNplotLegendWidth,&legendWidth); n++; /*XtSetArg(args[n],XtNplotLegendHeight,&legendHeight); n++;*/ XtSetArg(args[n],XtNplotLegendBorderWidth,&legendBorderWidth); n++; XtSetArg(args[n],XmNwidth,&width); n++; XtSetArg(args[n],XmNheight,&height); n++; XtSetArg(args[n],XtNplotGraphBorderWidth,&graphBorderWidth); n++; /*XtSetArg(args[n],XtNplotGraphWidth,&graphWidth); n++; XtSetArg(args[n],XtNplotGraphHeight,&graphHeight); n++;*/ XtSetArg(args[n],XtNplotHeaderWidth,&headerWidth); n++; XtSetArg(args[n],XtNplotHeaderHeight,&headerHeight); n++; XtSetArg(args[n],XtNplotHeaderBorderWidth,&headerBorderWidth); n++; XtSetArg(args[n],XmNhighlightThickness,&highlightThickness); n++; XtSetArg(args[n],XmNshadowThickness,&shadowThickness); n++; XtSetArg(args[n],XmNborderWidth,&borderWidth); n++; /*XtSetArg(args[n],XtNplotFooterBorderWidth,&footerBorderWidth); n++; XtSetArg(args[n],XtNplotFooterHeight,&footerHeight); n++; XtSetArg(args[n],XtNplotFooterWidth,&footerWidth); n++; XtSetArg(args[n],XtNplotFooterBorderWidth,&footerBorderWidth); n++; XtSetArg(args[n],XmNunitType,&unitType); n++;*/ XtSetArg(args[n],XtNplotTimeBase,&timeBase); n++; XtGetValues(w,args,n); print("\nJPT Widget (%x)\n"); print(" width: %d\n",width); print(" height: %d\n",height); print(" highlightThickness: %d\n",highlightThickness); print(" shadowThickness: %d\n",shadowThickness); print(" borderWidth: %d\n",borderWidth); print(" graphBorderWidth: %d\n",graphBorderWidth); /*print(" graphWidth: %d\n",graphWidth); print(" graphHeight: %d\n",graphHeight);*/ print(" headerBorderWidth: %d\n",headerBorderWidth); print(" headerWidth: %d\n",headerWidth); print(" headerHeight: %d\n",headerHeight); /*print(" footerWidth: %d\n",footerBorderWidth); print(" footerWidth: %d\n",footerWidth); print(" footerHeight: %d\n",footerHeight);*/ print(" legendBorderWidth: %d\n",legendBorderWidth); print(" legendWidth: %d\n",legendWidth); /*print(" legendHeight: %d\n",legendHeight);*/ /*print(" unitType: %d (PIXELS %d, MM %d, IN %d, PTS %d, FONT %d)\n",unitType, XmPIXELS,Xm100TH_MILLIMETERS,Xm1000TH_INCHES,Xm100TH_POINTS,Xm100TH_FONT_UNITS);*/ print("timeBase: %d\n",timeBase); }
static Boolean ConvertSelection(Widget w, Atom *selection, Atom *target, Atom *type, XtPointer *value, unsigned long *length, int *format) { Display* d = XtDisplay(w); XSelectionRequestEvent* req = XtGetSelectionRequest(w, *selection, (XtRequestId)NULL); if (*target == XA_TARGETS(d)) { Atom* targetP; Atom* std_targets; unsigned long std_length; XmuConvertStandardSelection(w, req->time, selection, target, type, (XPointer*)&std_targets, &std_length, format); *value = XtMalloc(sizeof(Atom)*(std_length + 7)); targetP = *(Atom**)value; *targetP++ = XA_STRING; *targetP++ = XA_TEXT(d); *targetP++ = XA_UTF8_STRING(d); *targetP++ = XA_COMPOUND_TEXT(d); *targetP++ = XA_LENGTH(d); *targetP++ = XA_LIST_LENGTH(d); *targetP++ = XA_CHARACTER_POSITION(d); *length = std_length + (targetP - (*(Atom **) value)); memmove( (char*)targetP, (char*)std_targets, sizeof(Atom)*std_length); XtFree((char*)std_targets); *type = XA_ATOM; *format = 32; return True; } if (*target == XA_LIST_LENGTH(d) || *target == XA_LENGTH(d)) { long * temp; temp = (long *) XtMalloc(sizeof(long)); if (*target == XA_LIST_LENGTH(d)) *temp = 1L; else /* *target == XA_LENGTH(d) */ *temp = (long) TextLength (text); *value = (XPointer) temp; *type = XA_INTEGER; *length = 1L; *format = 32; return True; } if (*target == XA_CHARACTER_POSITION(d)) { long * temp; temp = (long *) XtMalloc(2 * sizeof(long)); temp[0] = (long) 0; temp[1] = TextLength (text); *value = (XPointer) temp; *type = XA_SPAN(d); *length = 2L; *format = 32; return True; } if (*target == XA_STRING || *target == XA_TEXT(d) || *target == XA_UTF8_STRING(d) || *target == XA_COMPOUND_TEXT(d)) { Arg args[1]; Widget source; XTextProperty prop; int ret, style = XStdICCTextStyle; /* a safe default for TEXT */ char *data; source = XawTextGetSource (text); XtSetArg (args[0], XtNstring, &data); XtGetValues (source, args, 1); if (*target == XA_UTF8_STRING(d)) style = XUTF8StringStyle; else if (*target == XA_COMPOUND_TEXT(d)) style = XCompoundTextStyle; else if (*target == XA_STRING) style = XStringStyle; ret = XmbTextListToTextProperty (d, &data, 1, style, &prop); if (ret >= Success) { *length = prop.nitems; *value = prop.value; *type = prop.encoding; *format = prop.format; return True; } else return False; } if (XmuConvertStandardSelection(w, req->time, selection, target, type, (XPointer *) value, length, format)) return True; return False; }
/********************************************************************* * Function: CreateDA * * CreateDA creates a Text Graphic area with the appropriate scroll bars. * *********************************************************************/ static XtPointer HelpCreateDA( Widget parent, char *name, short vert_flag, short horz_flag, Boolean traversal_flag, _DtCvValue honor_size, _DtCvRenderType render_type, int rows, int columns, unsigned short media_resolution, void (*hyperTextCB)(), void (*resizeCB)(), int (*exec_ok_routine)(), XtPointer client_data, XmFontList default_list ) { DtHelpDispAreaStruct *pDAS; DAArgs DA_args; Arg args[20]; int n; int maxFontAscent; int maxFontDescent; int maxFontCharWidth; short margin_width; short margin_height; short shadowThick, highThick; Dimension hBarHeight = 0; Dimension vBarWidth = 0; Dimension width; Boolean value; Widget form; Display *dpy = XtDisplay(parent); Screen *retScr = XtScreen(parent); int screen = XScreenNumberOfScreen(retScr); Colormap colormap; Pixmap tile; XGCValues gcValues; unsigned long gcMask; unsigned long char_width; Atom xa_ave_width; XFontStruct *tmpFont = NULL; XtPointer default_font = NULL; XRectangle rectangle[1]; XmFontContext fontContext; XmFontListEntry fontEntry; XmFontType fontType; /* Allocate the Display Area. */ pDAS = (DtHelpDispAreaStruct *) XtMalloc(sizeof(DtHelpDispAreaStruct)); /* * get the resources */ XtGetSubresources(parent, &DA_args, name, "XmDrawnButton", Resources, XtNumber(Resources), NULL, 0); if (rows <= 0) rows = 1; if (columns <= 0) columns = 1; /* * initialize the structure variables. */ pDAS->text_selected = False; pDAS->primary = False; pDAS->select_state = _DtHelpNothingDoing; pDAS->toc_y = 0; pDAS->toc_base = 0; pDAS->toc_flag = 0; if (traversal_flag) pDAS->toc_flag = _DT_HELP_SHADOW_TRAVERSAL | _DT_HELP_NOT_INITIALIZED; pDAS->max_spc = 0; pDAS->cur_spc = 0; pDAS->maxX = 0; pDAS->virtualX = 0; pDAS->firstVisible = 0; pDAS->visibleCount = rows; pDAS->maxYpos = 0; pDAS->neededFlags = 0; pDAS->vert_init_scr = DA_args.initialDelay; pDAS->vert_rep_scr = DA_args.repeatDelay; pDAS->horz_init_scr = DA_args.initialDelay; pDAS->horz_rep_scr = DA_args.repeatDelay; pDAS->moveThreshold = DA_args.moveThreshold; pDAS->marginWidth = DA_args.marginWidth; pDAS->marginHeight = DA_args.marginHeight; pDAS->searchColor = DA_args.search_color; pDAS->depth = 0; pDAS->spc_chars = NULL; pDAS->scr_timer_id = 0; pDAS->def_pix = 0; pDAS->context = NULL; pDAS->vertIsMapped = False; pDAS->horzIsMapped = False; pDAS->lst_topic = NULL; pDAS->nextNonVisible = 0; pDAS->media_resolution = media_resolution; pDAS->honor_size = honor_size; pDAS->render_type = render_type; pDAS->dtinfo = 0; pDAS->stipple = None; /* * locale dependant information */ pDAS->nl_to_space = 1; pDAS->cant_begin_chars = NULL; pDAS->cant_end_chars = NULL; if (1 < MB_CUR_MAX) _DtHelpLoadMultiInfo (&(pDAS->cant_begin_chars), &(pDAS->cant_end_chars), &(pDAS->nl_to_space)); /* * initialize the hypertext callback pointer */ pDAS->exec_filter = exec_ok_routine; pDAS->hyperCall = hyperTextCB; pDAS->resizeCall = resizeCB; pDAS->clientData = client_data; /* * zero out other callback fields */ pDAS->vScrollNotify = NULL ; pDAS->armCallback = NULL ; /* * create the atoms needed */ xa_ave_width = XmInternAtom(dpy, "AVERAGE_WIDTH" , False); /* * Malloc for the default font. */ (void) XmeRenderTableGetDefaultFont(DA_args.userFont, &tmpFont); if (default_list != NULL && XmFontListInitFontContext (&fontContext, default_list)) { fontEntry = XmFontListNextEntry (fontContext); if (fontEntry != NULL) default_font = XmFontListEntryGetFont (fontEntry, &fontType); XmFontListFreeFontContext (fontContext); } /* * fake out the next call by using the parent as the display widget */ pDAS->dispWid = parent; __DtHelpFontDatabaseInit (pDAS, default_font, fontType, tmpFont); /* * Get the base font meterics. */ __DtHelpFontMetrics (pDAS->font_info, __DtHelpDefaultFontIndexGet(pDAS), &maxFontAscent, &maxFontDescent, &maxFontCharWidth, NULL, NULL); pDAS->leading = DA_args.leading; pDAS->fontAscent = maxFontAscent; pDAS->lineHeight = maxFontAscent + maxFontDescent + pDAS->leading + 1; n = __DtHelpDefaultFontIndexGet(pDAS); if (n < 0) value = get_fontsetproperty(__DtHelpFontSetGet(pDAS->font_info, n), xa_ave_width, ((unsigned long *) &(pDAS->charWidth))); else value = XGetFontProperty(__DtHelpFontStructGet(pDAS->font_info, n), xa_ave_width, ((unsigned long *) &(pDAS->charWidth))); if (False == value || 0 == pDAS->charWidth) { int len = maxFontCharWidth; if (n < 0) len += XmbTextEscapement( __DtHelpFontSetGet(pDAS->font_info,n),"1",1); else len += XTextWidth(__DtHelpFontStructGet(pDAS->font_info, n),"1",1); pDAS->charWidth = 10 * len / 2; } /* * Create the form to manage the window and scroll bars. */ n = 0; XtSetArg(args[n], XmNresizePolicy , XmRESIZE_ANY); ++n; XtSetArg(args[n], XmNshadowType , XmSHADOW_OUT); ++n; form = XmCreateForm(parent, "DisplayAreaForm", args, n); XtManageChild(form); /* * force the shadowThickness to zero. The XmManager will try to set * this to one. */ n = 0; XtSetArg(args[n], XmNshadowThickness , 0); ++n; XtSetArg(args[n], XmNhighlightThickness, 0); ++n; XtSetValues (form, args, n); /* * get the colors and margin widths and heights */ n = 0; XtSetArg (args[n], XmNmarginWidth , &margin_width); ++n; XtSetArg (args[n], XmNmarginHeight, &margin_height); ++n; XtSetArg (args[n], XmNcolormap , &colormap); ++n; XtGetValues(form, args, n); /* Create the vertical scrollbar. */ pDAS->vertScrollWid = NULL; if (vert_flag != _DtHelpNONE) { if (vert_flag == _DtHelpSTATIC) pDAS->vertIsMapped = True; n = 0; XtSetArg(args[n], XmNtopAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNtopOffset , 0); ++n; XtSetArg(args[n], XmNbottomAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNbottomOffset , margin_height); ++n; XtSetArg(args[n], XmNrightAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNrightOffset , 0); ++n; XtSetArg(args[n], XmNorientation , XmVERTICAL); ++n; XtSetArg(args[n], XmNtraversalOn , True); ++n; XtSetArg(args[n], XmNhighlightThickness, 1); ++n; XtSetArg(args[n], XmNshadowType , XmSHADOW_IN); ++n; XtSetArg(args[n], XmNvalue , 0); ++n; XtSetArg(args[n], XmNminimum , 0); ++n; /* fake out the scrollbar manager, who will init dims to 100 */ XtSetArg(args[n], XmNheight , 1); ++n; XtSetArg(args[n], XmNmaximum , 1); ++n; XtSetArg(args[n], XmNincrement , 1); ++n; XtSetArg(args[n], XmNpageIncrement , 1); ++n; XtSetArg(args[n], XmNsliderSize , 1); ++n; XtSetArg(args[n], XtNmappedWhenManaged , pDAS->vertIsMapped); ++n; pDAS->vertScrollWid = XmCreateScrollBar(form, "DisplayDtHelpVertScrollBar", args, n); XtManageChild(pDAS->vertScrollWid); if (vert_flag != _DtHelpSTATIC) pDAS->neededFlags = _DtHelpSET_AS_NEEDED (pDAS->neededFlags, _DtHelpVERTICAL_SCROLLBAR); XtAddCallback(pDAS->vertScrollWid, XmNdragCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNincrementCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNdecrementCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNpageIncrementCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNpageDecrementCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNtoBottomCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNtoTopCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->vertScrollWid, XmNvalueChangedCallback, _DtHelpVertScrollCB, (XtPointer) pDAS); XtAddEventHandler (pDAS->vertScrollWid, ButtonPressMask, True, (XtEventHandler)_DtHelpMoveBtnFocusCB,(XtPointer) pDAS); } /* Create the horizontal scrollbar. */ pDAS->horzScrollWid = NULL; if (horz_flag != _DtHelpNONE) { if (horz_flag == _DtHelpSTATIC) pDAS->horzIsMapped = True; n = 0; XtSetArg(args[n], XmNbottomAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNbottomOffset , 0); ++n; XtSetArg(args[n], XmNrightAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNrightOffset , margin_width); ++n; XtSetArg(args[n], XmNleftAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNleftOffset , 0); ++n; XtSetArg(args[n], XmNorientation , XmHORIZONTAL); ++n; XtSetArg(args[n], XmNtraversalOn , True); ++n; XtSetArg(args[n], XmNhighlightThickness, 1); ++n; XtSetArg(args[n], XmNshadowType , XmSHADOW_IN); ++n; XtSetArg(args[n], XmNvalue , 0); ++n; XtSetArg(args[n], XmNminimum , 0); ++n; XtSetArg(args[n], XmNmaximum , (pDAS->charWidth/10)); ++n; /* fake out the scrollbar manager, who will init dims to 100 */ XtSetArg(args[n], XmNwidth , 1); ++n; XtSetArg(args[n], XmNincrement , (pDAS->charWidth/10)); ++n; XtSetArg(args[n], XmNpageIncrement , (pDAS->charWidth/10)); ++n; XtSetArg(args[n], XmNsliderSize , (pDAS->charWidth/10)); ++n; XtSetArg(args[n], XtNmappedWhenManaged , pDAS->horzIsMapped); ++n; pDAS->horzScrollWid = XmCreateScrollBar(form, "DisplayHorzScrollBar", args, n); XtManageChild(pDAS->horzScrollWid); if (horz_flag != _DtHelpSTATIC) pDAS->neededFlags = _DtHelpSET_AS_NEEDED (pDAS->neededFlags, _DtHelpHORIZONTAL_SCROLLBAR); XtAddCallback(pDAS->horzScrollWid, XmNdragCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNincrementCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNdecrementCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNpageIncrementCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNpageDecrementCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNtoBottomCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNtoTopCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); XtAddCallback(pDAS->horzScrollWid, XmNvalueChangedCallback, _DtHelpHorzScrollCB, (XtPointer) pDAS); } /* * check for the horizontal attachments */ n = 0; if (horz_flag == _DtHelpSTATIC) { XtSetArg(args[n], XmNbottomAttachment , XmATTACH_WIDGET); ++n; XtSetArg(args[n], XmNbottomWidget , pDAS->horzScrollWid); ++n; } else { XtSetArg(args[n], XmNbottomAttachment , XmATTACH_FORM); ++n; } /* * check for the vertical attachments */ if (vert_flag == _DtHelpSTATIC) { XtSetArg(args[n], XmNrightAttachment , XmATTACH_WIDGET); ++n; XtSetArg(args[n], XmNrightWidget , pDAS->vertScrollWid); ++n; } else { XtSetArg(args[n], XmNrightAttachment , XmATTACH_FORM); ++n; } /* * do the rest of the arguments */ XtSetArg(args[n], XmNbottomOffset , margin_height); ++n; XtSetArg(args[n], XmNrightOffset , margin_width); ++n; XtSetArg(args[n], XmNtopAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNtopOffset , 0); ++n; XtSetArg(args[n], XmNleftAttachment , XmATTACH_FORM); ++n; XtSetArg(args[n], XmNleftOffset , 0); ++n; XtSetArg(args[n], XmNrecomputeSize , False); ++n; XtSetArg(args[n], XmNpushButtonEnabled , False); ++n; XtSetArg(args[n], XmNtraversalOn , True); ++n; XtSetArg(args[n], XmNhighlightThickness, 1); ++n; XtSetArg(args[n], XmNshadowType , XmSHADOW_IN); ++n; XtSetArg(args[n], XmNmultiClick , XmMULTICLICK_DISCARD); ++n; XtSetArg(args[n], XmNuserData , pDAS); ++n; pDAS->dispWid = XmCreateDrawnButton(form, name, args, n); XtManageChild(pDAS->dispWid); XtAddCallback(pDAS->dispWid, XmNexposeCallback, _DtHelpExposeCB, (XtPointer) pDAS); XtAddCallback(pDAS->dispWid, XmNresizeCallback, _DtHelpResizeCB, (XtPointer) pDAS); XtAddCallback(pDAS->dispWid, XmNarmCallback, _DtHelpClickOrSelectCB, (XtPointer) pDAS); XtAddCallback(pDAS->dispWid, XmNdisarmCallback, _DtHelpEndSelectionCB, (XtPointer) pDAS); XtAddEventHandler (pDAS->dispWid, Button1MotionMask, True, (XtEventHandler)_DtHelpMouseMoveCB, (XtPointer) pDAS); /* * add my actions * parse the translations. */ _DtHelpProcessLock(); if (DrawnBTrans == NULL) DrawnBTrans = XtParseTranslationTable(DrawnBTransTable); /* * override the translations XtSetArg(args[n], XmNtranslations , DrawnBTrans); ++n; */ if (DrawnBTrans != NULL) XtOverrideTranslations(pDAS->dispWid, DrawnBTrans); _DtHelpProcessUnlock(); if (_XmGetFocusPolicy(parent) == XmPOINTER) { XtAddEventHandler (pDAS->dispWid, EnterWindowMask, True, (XtEventHandler)_DtHelpEnterLeaveCB, (XtPointer) pDAS); XtAddEventHandler (pDAS->dispWid, LeaveWindowMask, True, (XtEventHandler)_DtHelpEnterLeaveCB, (XtPointer) pDAS); } else XtAddEventHandler (pDAS->dispWid, FocusChangeMask, True, (XtEventHandler)_DtHelpFocusCB, (XtPointer) pDAS); XtAddEventHandler (pDAS->dispWid, VisibilityChangeMask, True, (XtEventHandler)_DtHelpVisibilityCB, (XtPointer) pDAS); /* Add a destroy callback so that the display area can clean up prior to * the help widget getting destroyed (e.g. display area's parent) */ XtAddCallback(pDAS->dispWid, XmNdestroyCallback, _DtHelpDisplayAreaDestroyCB, (XtPointer) pDAS); n = 0; XtSetArg(args[n], XmNshadowThickness , &shadowThick); ++n; XtSetArg(args[n], XmNhighlightThickness, &highThick); ++n; XtSetArg(args[n], XmNforeground , &(pDAS->foregroundColor)); ++n; XtSetArg(args[n], XmNbackground , &(pDAS->backgroundColor)); ++n; XtSetArg(args[n], XmNhighlightColor, &(pDAS->traversalColor) ); ++n; XtSetArg(args[n], XmNdepth , &(pDAS->depth) ); ++n; XtGetValues(pDAS->dispWid, args, n); pDAS->decorThickness = shadowThick + highThick; /* * Get the underline information */ GetUnderLineInfo (dpy, pDAS, &(pDAS->lineThickness)); /* * get the tiling pattern. */ tile = XmGetPixmap (XtScreen(pDAS->dispWid), "50_foreground", pDAS->foregroundColor, pDAS->backgroundColor); /* * Get the data for the graphics contexts and create the GC's. */ gcMask = (GCFunction | GCPlaneMask | GCForeground | GCBackground | GCLineWidth | GCLineStyle | GCClipXOrigin | GCClipYOrigin | GCClipMask); gcValues.function = GXcopy; gcValues.plane_mask = AllPlanes; gcValues.foreground = pDAS->foregroundColor; gcValues.background = pDAS->backgroundColor; gcValues.line_style = LineSolid; gcValues.line_width = pDAS->lineThickness; gcValues.clip_x_origin = 0; gcValues.clip_y_origin = 0; gcValues.clip_mask = None; if (tile) { gcMask |= GCTile; gcValues.tile = tile; } pDAS->normalGC = XCreateGC(dpy, RootWindowOfScreen(XtScreen(pDAS->dispWid)), gcMask, &gcValues); gcMask &= (~GCTile); pDAS->pixmapGC = XCreateGC(dpy, RootWindowOfScreen(XtScreen(pDAS->dispWid)), gcMask, &gcValues); gcValues.foreground = pDAS->backgroundColor; gcValues.background = pDAS->foregroundColor; pDAS->invertGC = XCreateGC(dpy, RootWindowOfScreen(XtScreen(pDAS->dispWid)), gcMask, &gcValues); /* * Set the size of the text view area to the requested * number of columns and lines. */ char_width = pDAS->charWidth * columns; /* * Make sure the margins include enough room for a traversal line */ if (((int) pDAS->marginWidth) < pDAS->lineThickness) pDAS->marginWidth = pDAS->lineThickness; if (((int) pDAS->marginHeight) < pDAS->lineThickness) pDAS->marginHeight = pDAS->lineThickness; if (pDAS->leading < pDAS->lineThickness) pDAS->leading = pDAS->lineThickness; /* * get the scrollbar widths. */ if (NULL != pDAS->horzScrollWid) { n = 0; XtSetArg(args[n], XmNheight , &hBarHeight); n++; XtSetArg(args[n], XmNinitialDelay, &(pDAS->horz_init_scr)); n++; XtSetArg(args[n], XmNrepeatDelay , &(pDAS->horz_rep_scr)); n++; XtGetValues(pDAS->horzScrollWid, args, n); } if (NULL != pDAS->vertScrollWid) { n = 0; XtSetArg(args[n], XmNwidth , &vBarWidth); n++; XtSetArg(args[n], XmNinitialDelay, &(pDAS->vert_init_scr)); n++; XtSetArg(args[n], XmNrepeatDelay , &(pDAS->vert_rep_scr)); n++; XtGetValues(pDAS->vertScrollWid, args, n); } /* * calculate the display area height/width */ pDAS->dispUseWidth = ((int) (char_width / 10 + (char_width % 10 ? 1 : 0))) + 2 * pDAS->marginWidth; if (vert_flag != _DtHelpSTATIC && pDAS->dispUseWidth < vBarWidth) pDAS->dispUseWidth = vBarWidth; pDAS->dispWidth = pDAS->dispUseWidth + 2 * pDAS->decorThickness; pDAS->dispUseHeight = pDAS->lineHeight * rows; if (horz_flag != _DtHelpSTATIC && pDAS->dispUseHeight < hBarHeight) pDAS->dispUseHeight = hBarHeight; pDAS->dispHeight = pDAS->dispUseHeight + 2 * pDAS->decorThickness; /* * Truncate the width and height to the size of the display. * This will prevent an X protocal error when it is asked for * a too large size. Besides, any decent window manager will * force the overall size to the height and width of the display. * This simply refines the size down to a closer (but not perfect) * fit. */ if (((int) pDAS->dispWidth) > XDisplayWidth (dpy, screen)) { pDAS->dispWidth = XDisplayWidth (dpy, screen); } if (((int) pDAS->dispHeight) > XDisplayHeight (dpy, screen)) { pDAS->dispHeight = XDisplayHeight (dpy, screen); } n = 0; pDAS->formWidth = 0; pDAS->formHeight = 0; XtSetArg(args[n], XmNwidth, pDAS->dispWidth); ++n; XtSetArg(args[n], XmNheight, pDAS->dispHeight); ++n; XtSetValues(pDAS->dispWid, args, n); /* * set the scroll bar values */ if (pDAS->vertScrollWid != NULL) { n = 0; XtSetArg(args[n], XmNmaximum , pDAS->dispUseHeight); ++n; XtSetArg(args[n], XmNincrement , pDAS->lineHeight); ++n; XtSetArg(args[n], XmNpageIncrement , pDAS->lineHeight); ++n; XtSetArg(args[n], XmNsliderSize , pDAS->dispUseHeight); ++n; XtSetValues(pDAS->vertScrollWid, args, n); } if (pDAS->resizeCall) (*(pDAS->resizeCall)) (pDAS->clientData); /* * calculate the offset for the right edge of the * horizontal scrollbar. */ if (vert_flag == _DtHelpSTATIC && pDAS->horzScrollWid) { width = vBarWidth + margin_width; XtSetArg(args[0], XmNrightOffset , width); XtSetValues(pDAS->horzScrollWid, args, 1); } /* * calculate the offset for the bottom end of the * vertical scrollbar. */ if (horz_flag == _DtHelpSTATIC && pDAS->vertScrollWid) { width = hBarHeight + margin_height; XtSetArg(args[0], XmNbottomOffset , width); XtSetValues(pDAS->vertScrollWid, args, 1); } rectangle[0].x = pDAS->decorThickness; rectangle[0].y = pDAS->decorThickness; rectangle[0].width = pDAS->dispUseWidth; rectangle[0].height = pDAS->dispUseHeight; XSetClipRectangles(XtDisplay(pDAS->dispWid), pDAS->normalGC, 0, 0, rectangle, 1, Unsorted); XSetClipRectangles(XtDisplay(pDAS->dispWid), pDAS->invertGC, 0, 0, rectangle, 1, Unsorted); /* * get the colormap and the visual */ if (!XtIsShell(parent) && XtParent(parent) != NULL) parent = XtParent(parent); pDAS->visual = NULL; n = 0; XtSetArg (args[n], XmNcolormap, &(pDAS->colormap)); n++; XtSetArg (args[n], XmNvisual , &(pDAS->visual )); n++; XtGetValues (parent, args, n); if (pDAS->visual == NULL) pDAS->visual = XDefaultVisualOfScreen(XtScreen(pDAS->dispWid)); /* * set up the canvas */ _DtHelpProcessLock(); DefVirtFunctions.exec_cmd_filter = exec_ok_routine; pDAS->canvas = _DtCanvasCreate (DefVirtFunctions, (_DtCvPointer) pDAS); _DtHelpProcessUnlock(); return (XtPointer) pDAS; } /* End _DtHelpCreateDA */
int32_t awt_motif_getIMStatusHeight(Widget vw, jobject tc) { XmICStruct *icp; XmVendorShellExtObject ve; XmWidgetExtData extData; XmImInfo *im_info; int32_t width = 0; int32_t height = 0; XRectangle rect; XRectangle *rp; int32_t old_height; Arg args[1]; int32_t base_height; XFontSet fs; XFontSet fss = NULL; XFontSet fsp = NULL; extData = (XmWidgetExtData)_XmGetWidgetExtData((Widget) vw, XmSHELL_EXTENSION); ve = (XmVendorShellExtObject) extData->widget; if ((icp = get_iclist(vw)) == NULL) { ve->vendor.im_height = 0; return 0; } im_info = (XmImInfo *) ve->vendor.im_info; if (im_info->xic == NULL) { ve->vendor.im_height = 0; return 0; } status_vlist[0].name = XNFontSet; status_vlist[1].name = NULL; preedit_vlist[0].name = XNFontSet; preedit_vlist[1].name = NULL; xic_vlist[0].name = XNAreaNeeded; xic_vlist[1].name = NULL; im_info->status_width = 0; im_info->status_height = 0; im_info->preedit_width = 0; im_info->preedit_height = 0; for (; icp != NULL; icp = icp->next) { if (im_info->input_style & XIMStatusArea) { if (icp->status_height == 0) { char *ret; if (icp->font_list == NO_ARG_VAL || (fss = extract_fontset((XmFontList) icp->font_list)) == NULL) continue; status_vlist[0].value = (XtArgVal) fss; XSetICValues(im_info->xic, XNStatusAttributes, &status_vlist[0], NULL); xic_vlist[0].value = (XtArgVal) & rp; ret = XGetICValues(im_info->xic, XNStatusAttributes, &xic_vlist[0], NULL); if (ret) { /* Cannot obtain XIC value. IM server may be gone. */ ve->vendor.im_height = 0; return 0; } else { icp->status_width = rp->width; icp->status_height = rp->height; XFree(rp); } } if (icp->status_width > im_info->status_width) im_info->status_width = icp->status_width; if (icp->status_height > im_info->status_height) im_info->status_height = icp->status_height; } if (im_info->input_style & XIMPreeditArea) { if (icp->preedit_height == 0) { if (icp->font_list == NO_ARG_VAL || (fsp = extract_fontset((XmFontList) icp->font_list)) == NULL) continue; preedit_vlist[0].value = (XtArgVal) fsp; XSetICValues(im_info->xic, XNPreeditAttributes, &preedit_vlist[0], NULL); xic_vlist[0].value = (XtArgVal) & rp; XGetICValues(im_info->xic, XNPreeditAttributes, &xic_vlist[0], NULL); icp->preedit_width = rp->width; icp->preedit_height = rp->height; XFree(rp); } if (icp->preedit_width > im_info->preedit_width) im_info->preedit_width = icp->preedit_width; if (icp->preedit_height > im_info->preedit_height) im_info->preedit_height = icp->preedit_height; } } if (im_info->current != NULL && (fss != NULL || fsp != NULL)) { if (im_info->current->font_list != NO_ARG_VAL && (fs = extract_fontset((XmFontList) im_info->current->font_list)) != NULL) { if (fss != NULL) status_vlist[0].value = (XtArgVal) fs; else status_vlist[0].name = NULL; if (fsp != NULL) preedit_vlist[0].value = (XtArgVal) fs; else preedit_vlist[0].name = NULL; XSetICValues(im_info->xic, XNStatusAttributes, &status_vlist[0], XNPreeditAttributes, &preedit_vlist[0], NULL); } } if (im_info->status_height > im_info->preedit_height) height = im_info->status_height; else height = im_info->preedit_height; old_height = ve->vendor.im_height; if (height) height += SEPARATOR_HEIGHT; ve->vendor.im_height = height; XtSetArg(args[0], XtNbaseHeight, &base_height); XtGetValues(vw, args, 1); if (base_height < 0) base_height = 0; XtSetArg(args[0], XtNbaseHeight, base_height); XtSetValues(vw, args, 1); return height; }
int GTgetwidgetattr (Gwidget_t *widget, int attrn, Gwattr_t *attrp) { Dimension width, height; XawTextEditType mode; XawTextBlock tb; Widget w; int rtn, ai; long fi, li; for (ai = 0; ai < attrn; ai++) { RESETARGS; switch (attrp[ai].id) { case G_ATTRSIZE: ADD2ARGS (XtNwidth, &width); ADD2ARGS (XtNheight, &height); XtGetValues (widget->w, argp, argn); attrp[ai].u.s.x = width, attrp[ai].u.s.y = height; break; case G_ATTRBORDERWIDTH: ADD2ARGS (XtNborderWidth, &width); XtGetValues (widget->w, argp, argn); attrp[ai].u.i = width; break; case G_ATTRTEXT: w = XawTextGetSource (widget->w); tb.firstPos = 0, tb.ptr = NULL, tb.format = FMT8BIT, tb.length = 0; rtn = XawTextSourceRead (w, 0, &tb, 30000); if (rtn > Gbufn + 1) { Gbufp = Marraygrow (Gbufp, (long) (rtn + 1) * BUFSIZE); Gbufn = rtn + 1; } for (Gbufi = 0; Gbufi < rtn; Gbufi++) Gbufp[Gbufi] = tb.ptr[Gbufi]; Gbufp[Gbufi++] = '\000'; attrp[ai].u.t = &Gbufp[0]; break; case G_ATTRAPPENDTEXT: Gerr (POS, G_ERRCANNOTGETATTR, "appendtext"); return -1; case G_ATTRSELECTION: w = XawTextGetSource (widget->w); XawTextGetSelectionPos (widget->w, &fi, &li); tb.firstPos = 0, tb.ptr = NULL, tb.format = FMT8BIT, tb.length = 0; rtn = XawTextSourceRead (w, fi, &tb, li - fi); if (li - fi > Gbufn + 1) { Gbufp = Marraygrow (Gbufp, (long) (rtn + 1) * BUFSIZE); Gbufn = rtn + 1; } for (Gbufi = 0; Gbufi < li - fi; Gbufi++) Gbufp[Gbufi] = tb.ptr[Gbufi]; Gbufp[Gbufi++] = '\000'; attrp[ai].u.t = &Gbufp[0]; break; case G_ATTRMODE: ADD2ARGS (XtNeditType, &mode); XtGetValues (widget->w, argp, argn); if (mode == XawtextAppend) attrp[ai].u.t = "oneline"; else if (mode == XawtextEdit) attrp[ai].u.t = "input"; else if (mode == XawtextRead) attrp[ai].u.t = "output"; else { panic (POS, "GTgetwidgetattr", "unexpected text mode"); return -1; } break; case G_ATTRWINDOWID: sprintf (&Gbufp[0], "0x%lx", XtWindow (widget->w)); attrp[ai].u.t = &Gbufp[0]; break; case G_ATTRNEWLINECB: attrp[ai].u.func = WTU->func; break; case G_ATTRUSERDATA: attrp[ai].u.u = widget->udata; break; default: Gerr (POS, G_ERRBADATTRID, attrp[ai].id); return -1; } } return 0; }
static void makeButtonsAndBoxes(Widget parent) { Widget outer, b_row, viewport; Arg arglist[10]; Cardinal num_args; xedit_flist_item *item; static char *labelWindow = "labelWindow", *editWindow = "editWindow"; static char *formWindow = "formWindow", *positionWindow = "positionWindow"; outer = XtCreateManagedWidget("paned", panedWidgetClass, parent, NULL, ZERO); b_row = XtCreateManagedWidget("buttons", panedWidgetClass, outer, NULL, ZERO); { MakeCommandButton(b_row, "quit", DoQuit); MakeCommandButton(b_row, "save", DoSave); MakeCommandButton(b_row, "load", DoLoad); filenamewindow = MakeStringBox(b_row, "filename", NULL); } hintswindow = XtCreateManagedWidget("bc_label", labelWidgetClass, outer, NULL, ZERO); num_args = 0; XtSetArg(arglist[num_args], XtNeditType, XawtextEdit); ++num_args; messwidget = XtCreateManagedWidget("messageWindow", asciiTextWidgetClass, outer, arglist, num_args); num_args = 0; XtSetArg(arglist[num_args], XtNorientation, XtorientHorizontal); ++num_args; hpane = XtCreateManagedWidget("hpane", panedWidgetClass, outer, arglist, num_args); num_args = 0; XtSetArg(arglist[num_args], XtNorientation, XtorientVertical); ++num_args; vpanes[0] = XtCreateManagedWidget("vpane", panedWidgetClass, hpane, arglist, num_args); XtSetArg(arglist[num_args], XtNheight, 1); ++num_args; XtSetArg(arglist[num_args], XtNwidth, 1); ++num_args; vpanes[1] = XtCreateWidget("vpane", panedWidgetClass, hpane, arglist, num_args); forms[0] = XtCreateManagedWidget(formWindow, formWidgetClass, vpanes[0], NULL, 0); labelwindow = XtCreateManagedWidget(labelWindow,labelWidgetClass, forms[0], NULL, 0); labels[0] = labelwindow; positions[0] = XtCreateManagedWidget(positionWindow,labelWidgetClass, forms[0], NULL, 0); forms[2] = XtCreateWidget(formWindow, formWidgetClass, vpanes[1], NULL, 0); labels[2] = XtCreateManagedWidget(labelWindow,labelWidgetClass, forms[2], NULL, 0); positions[2] = XtCreateManagedWidget(positionWindow,labelWidgetClass, forms[2], NULL, 0); num_args = 0; XtSetArg(arglist[num_args], XtNtype, XawAsciiFile); ++num_args; XtSetArg(arglist[num_args], XtNeditType, XawtextEdit); ++num_args; textwindow = XtCreateManagedWidget(editWindow, asciiTextWidgetClass, vpanes[0], arglist, num_args); /* Get international resource value form the textwindow */ num_args = 0; XtSetArg(arglist[num_args], XtNinternational, &international); ++num_args; XtGetValues(textwindow, arglist, num_args); num_args = 0; XtSetArg(arglist[num_args], XtNtype, XawAsciiFile); ++num_args; XtSetArg(arglist[num_args], XtNeditType, XawtextEdit); ++num_args; scratch = XtVaCreateWidget("textSource", international ? multiSrcObjectClass : asciiSrcObjectClass, topwindow, XtNtype, XawAsciiFile, XtNeditType, XawtextEdit, NULL, NULL); XtSetValues(scratch, arglist, num_args); num_args = 0; XtSetArg(arglist[num_args], XtNtextSource, scratch); ++num_args; XtSetValues(textwindow, arglist, num_args); texts[0] = textwindow; num_args = 0; XtSetArg(arglist[num_args], XtNtextSource, scratch); ++num_args; XtSetArg(arglist[num_args], XtNdisplayCaret, False); ++num_args; texts[2] = XtCreateWidget(editWindow, asciiTextWidgetClass, vpanes[1], arglist, num_args); forms[1] = XtCreateWidget(formWindow, formWidgetClass, vpanes[0], NULL, 0); labels[1] = XtCreateManagedWidget(labelWindow,labelWidgetClass, forms[1], NULL, 0); positions[1] = XtCreateManagedWidget(positionWindow,labelWidgetClass, forms[1], NULL, 0); texts[1] = XtCreateWidget(editWindow, asciiTextWidgetClass, vpanes[0], arglist, num_args); dirlabel = XtCreateWidget("dirlabel", labelWidgetClass, vpanes[1], NULL, 0); num_args = 0; XtSetArg(arglist[num_args], XtNheight, 1); ++num_args; XtSetArg(arglist[num_args], XtNwidth, 1); ++num_args; viewport = XtCreateWidget("viewport", viewportWidgetClass, vpanes[1], arglist, num_args); dirwindow = XtCreateManagedWidget("dirwindow", listWidgetClass, viewport, NULL, 0); item = AddTextSource(scratch, "*scratch*", "*scratch*", 0, WRITE_OK); item->wrap = XawtextWrapLine; item->flags |= WRAP_BIT; XtAddCallback(item->source, XtNcallback, SourceChanged, (XtPointer)item); ResetSourceChanged(item); flist.current = item; for (num_args = 0; num_args < 3; num_args++) XtAddCallback(texts[num_args], XtNpositionCallback, PositionChanged, NULL); for (num_args = 0; num_args < 3; num_args++) { XtSetArg(arglist[0], XtNwrap, &wrapmodes[num_args]); XtGetValues(texts[num_args], arglist, 1); } XtAddCallback(dirwindow, XtNcallback, DirWindowCB, NULL); }
Widget CreateConstraintResourceControls( Widget parent, Widget left_widget, Widget bottom_widget, unsigned int child_type ) { XmString string; Widget RowColumn; Widget ArrowSensLabel, ArrowSensPulldown, ArrowSensOptions, ArrowSensPB[NUM_ARROW_SENS_BTNS]; Widget DecimalPtsLabel, DecimalPtsTF; Widget IncrValueLabel, IncrValueTF; Widget MaxValueLabel, MaxValueTF; Widget MinValueLabel, MinValueTF; Widget NumValuesLabel, NumValuesTF; Widget PositionLabel; Widget ChildTypeLabel, ChildTypePulldown, ChildTypeOptions, ChildTypePB[NUM_CHILD_TYPE_BTNS]; Widget ValuesLabel, ValuesList; char buffer[30], buffer2[30]; Widget client_widget; int i, j; XmStringTable stringTable; client_widget = ( child_type == XmSTRING ) ? StringTextF : NumericTextF; n = 0; XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++; XtSetArg( args[n], XmNleftWidget, left_widget ); n++; XtSetArg( args[n], XmNbottomAttachment, XmATTACH_WIDGET ); n++; XtSetArg( args[n], XmNbottomWidget, bottom_widget ); n++; XtSetArg(args[n], XmNnumColumns, 9); n++; XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++; XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++; RowColumn = XmCreateRowColumn( parent, "RowColumn", args, n ); XtManageChild( RowColumn ); /* * Create label and option menu for XmNarrowSensitivity resource. */ string = XmStringCreateLtoR("Arrow Sensitivity", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; ArrowSensLabel = XmCreateLabel( RowColumn, "ArrowSensLabel", args, n ); XtManageChild( ArrowSensLabel ); XmStringFree( string ); n = 0; ArrowSensPulldown = XmCreatePulldownMenu(RowColumn, "ArrowSensPulldown", args, n); for ( i = 0; i < NUM_ARROW_SENS_BTNS; i++ ) { string = XmStringCreateLtoR( arrow_sens_strings[i], XmFONTLIST_DEFAULT_TAG ); if ( child_type == XmSTRING ) sprintf( buffer, "StringArrowSensPB%d", i ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "NumericArrowSensPB%d", i ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; ArrowSensPB[i] = XmCreatePushButton( ArrowSensPulldown, buffer, args, n ); XmStringFree( string ); if ( child_type == XmSTRING ) { string_arrow_sens_cd[i].textfield = client_widget; string_arrow_sens_cd[i].sensitivity = arrow_sens[i]; XtAddCallback( ArrowSensPB[i], XmNactivateCallback, ArrowSensCB, &string_arrow_sens_cd[i]); } else if ( child_type = XmNUMERIC ) { numeric_arrow_sens_cd[i].textfield = client_widget; numeric_arrow_sens_cd[i].sensitivity = arrow_sens[i]; XtAddCallback( ArrowSensPB[i], XmNactivateCallback, ArrowSensCB, &numeric_arrow_sens_cd[i]); } } XtManageChildren( ArrowSensPB, NUM_ARROW_SENS_BTNS ); if ( child_type == XmSTRING ) sprintf( buffer, "StringArrowSensOptions", i ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "NumericArrowSensOptions", i ); n = 0; XtSetArg( args[n], XmNmenuHistory, ArrowSensPB[NUM_ARROW_SENS_BTNS - 1] ); n++; XtSetArg( args[n], XmNsubMenuId, ArrowSensPulldown ); n++; ArrowSensOptions = XmCreateOptionMenu( RowColumn, buffer, args, n ); XtManageChild( ArrowSensOptions ); string = XmStringCreateLtoR("Decimal Points", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; DecimalPtsLabel = XmCreateLabel( RowColumn, "DecimalPtsLabel", args, n ); XtManageChild( DecimalPtsLabel ); XmStringFree( string ); n = 0; XtSetArg( args[n], XmNvalue, "0" ); n++; if ( child_type == XmSTRING ) sprintf( buffer, "%s", "StringDecimalPtsTF" ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "%s", "NumericDecimalPtsTF" ); DecimalPtsTF = XmCreateTextField( RowColumn, buffer, args, n ); XtManageChild( DecimalPtsTF ); XtAddCallback( DecimalPtsTF, XmNactivateCallback, DecimalPtsCB, (XtPointer)client_widget ); string = XmStringCreateLtoR("Increment Value", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; IncrValueLabel = XmCreateLabel( RowColumn, "IncrValueLabel", args, n ); XtManageChild( IncrValueLabel ); XmStringFree( string ); n = 0; XtSetArg( args[n], XmNvalue, "1" ); n++; if ( child_type == XmSTRING ) sprintf( buffer, "%s", "StringIncrValueTF" ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "%s", "NumericIncrValueTF" ); IncrValueTF = XmCreateTextField( RowColumn, buffer, args, n ); XtManageChild( IncrValueTF ); XtAddCallback( IncrValueTF, XmNactivateCallback, IncrValueCB, (XtPointer)client_widget ); string = XmStringCreateLtoR("Maximum Value", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; MaxValueLabel = XmCreateLabel( RowColumn, "MaxValueLabel", args, n ); XtManageChild( MaxValueLabel ); XmStringFree( string ); n = 0; XtSetArg( args[n], XmNvalue, "10" ); n++; if ( child_type == XmSTRING ) sprintf( buffer, "%s", "StringMaxValueTF" ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "%s", "NumericMaxValueTF" ); MaxValueTF = XmCreateTextField( RowColumn, buffer, args, n ); XtManageChild( MaxValueTF ); XtAddCallback( MaxValueTF, XmNactivateCallback, MaxValueCB, (XtPointer)client_widget ); string = XmStringCreateLtoR("Minimum Value", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; MinValueLabel = XmCreateLabel( RowColumn, "MinValueLabel", args, n ); XtManageChild( MinValueLabel ); XmStringFree( string ); n = 0; XtSetArg( args[n], XmNvalue, "0" ); n++; if ( child_type == XmSTRING ) sprintf( buffer, "%s", "StringMinValueTF" ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "%s", "NumericMinValueTF" ); MinValueTF = XmCreateTextField( RowColumn, buffer, args, n ); XtManageChild( MinValueTF ); XtAddCallback( MinValueTF, XmNactivateCallback, MinValueCB, (XtPointer)client_widget ); string = XmStringCreateLtoR("Num Values", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; NumValuesLabel = XmCreateLabel( RowColumn, "NumValuesLabel", args, n ); XtManageChild( NumValuesLabel ); XmStringFree( string ); client_widget = ( child_type == XmSTRING ) ? StringTextF : NumericTextF; /* * Get current value of XmNnumValues resource. */ n = 0; XtSetArg( args[n], XmNnumValues, &j ); n++; XtGetValues( client_widget, args, n ); sprintf( buffer, "%d", j ); n = 0; XtSetArg( args[n], XmNvalue, buffer ); n++; if ( child_type == XmSTRING ) sprintf( buffer2, "%s", "StringNumValuesTF" ); else if ( child_type == XmNUMERIC ) sprintf( buffer2, "%s", "NumericNumValuesTF" ); NumValuesTF = XmCreateTextField( RowColumn, buffer2, args, n ); XtManageChild( NumValuesTF ); XtAddCallback( NumValuesTF, XmNactivateCallback, NumValuesCB, (XtPointer)client_widget ); string = XmStringCreateLtoR("Position", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; PositionLabel = XmCreateLabel( RowColumn, "PositionLabel", args, n ); XtManageChild( PositionLabel ); XmStringFree( string ); n = 0; XtSetArg( args[n], XmNvalue, "0" ); n++; if ( child_type == XmSTRING ) { sprintf( buffer, "%s", "StringPositionTF" ); StringPositionTF = XmCreateTextField( RowColumn, buffer, args, n ); XtManageChild( StringPositionTF ); XtAddCallback( StringPositionTF, XmNactivateCallback, PositionCB, (XtPointer)client_widget ); XtAddCallback( SpinBox1, XmNvalueChangedCallback, UpdatePositionCB, (XtPointer)StringPositionTF ); } else if ( child_type == XmNUMERIC ) { sprintf( buffer, "%s", "NumericPositionTF" ); NumericPositionTF = XmCreateTextField( RowColumn, buffer, args, n ); XtManageChild( NumericPositionTF ); XtAddCallback( NumericPositionTF, XmNactivateCallback, PositionCB, (XtPointer)client_widget ); XtAddCallback( SpinBox2, XmNvalueChangedCallback, UpdatePositionCB, (XtPointer)NumericPositionTF ); } string = XmStringCreateLtoR("SpinBox Child Type", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; ChildTypeLabel = XmCreateLabel( RowColumn, "ChildTypeLabel", args, n ); XtManageChild( ChildTypeLabel ); XmStringFree( string ); n = 0; ChildTypePulldown = XmCreatePulldownMenu(RowColumn, "ChildTypePulldown", args, n); for ( i = 0; i < NUM_CHILD_TYPE_BTNS; i++ ) { string = XmStringCreateLtoR( child_type_strings[i], XmFONTLIST_DEFAULT_TAG ); if ( child_type == XmSTRING ) sprintf( buffer, "StringChildTypePB%d", i ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "NumericChildTypePB%d", i ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; ChildTypePB[i] = XmCreatePushButton( ChildTypePulldown, buffer, args, n ); XmStringFree( string ); if ( child_type == XmSTRING ) { string_child_type_cd[i].textfield = client_widget; string_child_type_cd[i].child_type = child_types[i]; XtAddCallback( ChildTypePB[i], XmNactivateCallback, ChildTypeCB, &string_child_type_cd[i] ); } else if ( child_type == XmNUMERIC ) { numeric_child_type_cd[i].textfield = client_widget; numeric_child_type_cd[i].child_type = child_types[i]; XtAddCallback( ChildTypePB[i], XmNactivateCallback, ChildTypeCB, &numeric_child_type_cd[i] ); } } XtManageChildren( ChildTypePB, NUM_CHILD_TYPE_BTNS ); n = 0; if ( child_type == XmSTRING ) { XtSetArg( args[n], XmNmenuHistory, ChildTypePB[0] ); n++; } else if ( child_type == XmNUMERIC ) { XtSetArg( args[n], XmNmenuHistory, ChildTypePB[1] ); n++; } XtSetArg( args[n], XmNsubMenuId, ChildTypePulldown ); n++; ChildTypeOptions = XmCreateOptionMenu( RowColumn, "ChildTypeOptions", args, n ); XtManageChild( ChildTypeOptions ); string = XmStringCreateLtoR( "Values", XmFONTLIST_DEFAULT_TAG ); n = 0; XtSetArg( args[n], XmNlabelString, string ); n++; ValuesLabel = XmCreateLabel( RowColumn, "ValuesLabel", args, n ); XtManageChild( ValuesLabel ); XmStringFree( string ); /* * Get current values for XmNvalues resource. */ n = 0; XtSetArg( args[n], XmNnumValues, &j ); n++; XtSetArg( args[n], XmNvalues, &stringTable ); n++; XtGetValues( client_widget, args, n ); /* * Assign current string values to List for display. */ if ( child_type == XmSTRING ) sprintf( buffer, "%s", "StringValuesList" ); else if ( child_type == XmNUMERIC ) sprintf( buffer, "%s", "NumericValuesList" ); n = 0; XtSetArg( args[n], XmNitemCount, j ); n++; XtSetArg( args[n], XmNitems, stringTable ); n++; XtSetArg( args[n], XmNvisibleItemCount, 1 ); n++; ValuesList = XmCreateScrolledList( RowColumn, buffer, args, n ); XtManageChild( ValuesList ); return( RowColumn ); }