diff options
Diffstat (limited to 'widgets.c')
| -rw-r--r-- | widgets.c | 1037 |
1 files changed, 1037 insertions, 0 deletions
diff --git a/widgets.c b/widgets.c new file mode 100644 index 0000000..2342e6a --- /dev/null +++ b/widgets.c @@ -0,0 +1,1037 @@ +/* + * $Xorg: widgets.c,v 1.4 2001/02/09 02:05:30 xorgcvs Exp $ + * +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + */ + +/* + * Code for creating all widgets used by EditRes. + */ + +#include <stdio.h> +#include <X11/Intrinsic.h> +#include <X11/StringDefs.h> /* Get standard string definations. */ + +#include <X11/Xaw/AsciiText.h> +#include <X11/Xaw/Box.h> +#include <X11/Xaw/Cardinals.h> +#include <X11/Xaw/Label.h> +#include <X11/Xaw/List.h> +#include <X11/Xaw/MenuButton.h> +#include <X11/Xaw/Paned.h> +#include <X11/Xaw/Panner.h> +#include <X11/Xaw/Porthole.h> +#include <X11/Xaw/SmeBSB.h> +#include <X11/Xaw/SmeLine.h> +#include <X11/Xaw/SimpleMenu.h> +#include <X11/Xaw/Toggle.h> +#include <X11/Xaw/Tree.h> +#include <X11/Xaw/Viewport.h> + +#include "editresP.h" + + + +/* + * functions. + */ + +static void CreateResourceNameForm(), SetToggleGroupLeaders(), CreateLists(); +static void CreateCommandMenu(), CreateTreeCommandMenu(), FreeClientData(); +static void FreeResBox(), CreateValueWidget(), PopupOnNode(); +static Widget CreateTopArea(); +static void MakeBoxLookNice(); + +extern void GetResourceList(), AnyChosen(), SetResourceString(); +extern void PannerCallback(), PortholeCallback(), DumpTreeToFile(); +extern void Quit(), SendTree(), FlashActiveWidgets(); +extern void TreeSelect(), TreeRelabel(), TreeActivate(), FindWidget(); +extern void ResourceListCallback(), PopdownResBox(), SaveResource(); +extern void GetNamesAndClasses(), ApplyResource(), ActivateResourceWidgets(); +extern void ActivateWidgetsAndSetResourceString(), SetFile(); + +extern void InitSetValues(); + + + +/* Function Name: RebuildMenusAndLabel + * Description: Determins if the user has selected an application + * which uses a different toolkit. Xt is the default. + * If this is so, destroys and recreates the menus and + * information label at the top of the application. + * Arguments: toolkit - name of the toolkit. + * Returns: none. + */ + +static Widget box = NULL; +static Widget hPane = NULL; + +#define Offset(index) sizeof(String) * index + +#define res_entry(index, name, class) \ + {name, class, XtRString, sizeof(String), \ + Offset(index), XtRString, (XtPointer)NULL} + +static XtResource resources[] = { + res_entry(0, "label0", "Label0"), + res_entry(1, "label1", "Label1"), + res_entry(2, "label2", "Label2"), + res_entry(3, "label3", "Label3"), + res_entry(4, "label4", "Label4"), + res_entry(5, "label5", "Label5"), + res_entry(6, "label6", "Label6"), + res_entry(7, "label7", "Label7"), + res_entry(8, "label8", "Label8"), + res_entry(9, "label9", "Label9"), + res_entry(11, "label11", "Label11"), + res_entry(12, "label12", "Label12"), + res_entry(13, "label13", "Label13"), + res_entry(14, "label14", "Label14"), + res_entry(15, "label15", "Label15"), + res_entry(16, "label16", "Label16"), + res_entry(17, "label17", "Label17"), + res_entry(18, "label18", "Label18"), + res_entry(19, "label19", "Label19"), + res_entry(20, "label20", "Label20"), + res_entry(21, "label21", "Label21"), + res_entry(22, "label22", "Label22"), + res_entry(23, "label23", "Label23"), + res_entry(24, "label24", "Label24"), + res_entry(25, "label25", "Label25"), + res_entry(26, "label26", "Label26"), + res_entry(27, "label27", "Label27"), + res_entry(28, "label28", "Label28"), + res_entry(29, "label29", "Label29"), + res_entry(30, "label30", "Label30"), + res_entry(31, "label31", "Label31"), + res_entry(32, "label32", "Label32"), + res_entry(33, "label33", "Label33"), + res_entry(34, "label34", "Label34"), + res_entry(35, "label35", "Label35"), + res_entry(36, "label36", "Label36") +}; + +#undef res_entry + +#undef Offset + +void +RebuildMenusAndLabel(toolkit) + String toolkit; +{ + if (strcmp(global_effective_toolkit, toolkit)) { + CreateCommandMenu(box, toolkit); + CreateTreeCommandMenu(box, toolkit); + XtDestroyWidget(global_screen_data.info_label); + global_screen_data.info_label = XtCreateManagedWidget(toolkit, + labelWidgetClass, + hPane, NULL, ZERO); + /* get the new toolkit label application resources for info_label */ + XtGetApplicationResources(global_screen_data.info_label, + res_labels, resources, + XtNumber(resources), NULL, 0); + + global_effective_toolkit = toolkit; + } +} + + + +/* Function Name: BuildWidgetTree + * Description: Creates all widgets for Editres. + * Arguments: parent - the shell to put them into. + * Returns: none. + */ + +void +BuildWidgetTree(parent) +Widget parent; +{ + Widget paned, porthole, panner; + + paned = XtCreateManagedWidget("paned", panedWidgetClass, parent, + NULL, ZERO); + + panner = CreateTopArea(paned); + + porthole = XtCreateManagedWidget("porthole", portholeWidgetClass, + paned, NULL, ZERO); + +/* + * Allow the panner and porthole to talk to each other. + */ + + XtAddCallback(porthole, + XtNreportCallback, PortholeCallback, (XtPointer) panner); + XtAddCallback(panner, + XtNreportCallback, PannerCallback, (XtPointer) porthole); + + global_tree_parent = porthole; +} + + + + +/* Function Name: CreateTopArea + * Description: Creates the top part of the display + * Arguments: parent - widget to put this menu bar into. + * Returns: none. + */ + + +static Widget +CreateTopArea(parent) +Widget parent; +{ + Widget panner; + + box = XtCreateManagedWidget("box", boxWidgetClass, parent, NULL, ZERO); + + CreateCommandMenu(box, "xt"); + CreateTreeCommandMenu(box, "xt"); + + hPane = XtCreateManagedWidget("hPane",panedWidgetClass, parent, NULL,ZERO); + + { + panner = XtCreateManagedWidget("panner", pannerWidgetClass, + hPane, NULL, ZERO); + + global_screen_data.info_label = XtCreateManagedWidget("xt", + labelWidgetClass, + hPane, NULL,ZERO); + + /* get the "xt label" application resources for info_label */ + XtGetApplicationResources(global_screen_data.info_label, + res_labels, resources, + XtNumber(resources), NULL, 0); + + } + + return(panner); +} + + + +/* Function Name: SetEntriesInsensitive + * Description: Make menu entries unusable. + * Arguments: entries - address of widget array. + * num - number of widgets. + * sensitive - whether to sensitize or desensitize. + * Returns: none. + */ +void +SetEntriesSensitive(entries, num, sensitive) +Widget *entries; +int num; +Boolean sensitive; +{ +int i; for (i=0; i<num; i++) XtSetSensitive(entries[i], sensitive); +} + + + +/* Function Name: CreateCommandMenu + * Description: Creates the command menu. + * Arguments: parent - widget to put this menu into. + * toolkit - name given to the SimpleMenu widget. + * Returns: none. + */ + +static Widget cmenu = NULL, cbutton = NULL; +/* at first most menu entries are insensitive */ +static Boolean CM_set_insensitive = True; +Widget CM_entries[NUM_CM_ENTRIES]; + +static void +CreateCommandMenu(parent, toolkit) +Widget parent; +String toolkit; +{ + Arg args[1]; + + if (cmenu) { XtDestroyWidget(cmenu); CM_set_insensitive = False; } + else + cbutton = XtCreateManagedWidget("commands", menuButtonWidgetClass, + parent, NULL, ZERO); + + /* set the menu name to the toolkit name */ + XtSetArg(args[0], XtNmenuName, toolkit); + XtSetValues(cbutton, args, ONE); + + cmenu = XtCreatePopupShell(toolkit, simpleMenuWidgetClass, cbutton, + NULL, ZERO); + + CM_entries[0] = XtCreateManagedWidget("sendTree", smeBSBObjectClass,cmenu, + NULL, ZERO); + XtAddCallback(CM_entries[0], XtNcallback, SendTree, (XtPointer) TRUE); + + CM_entries[1]=XtCreateManagedWidget("refreshTree",smeBSBObjectClass,cmenu, + NULL, ZERO); + XtAddCallback(CM_entries[1], XtNcallback, SendTree, (XtPointer) FALSE); + + CM_entries[2] = XtCreateManagedWidget("dumpTreeToFile", + smeBSBObjectClass,cmenu, + NULL, ZERO); + XtAddCallback(CM_entries[2], XtNcallback, DumpTreeToFile, NULL); + + CM_entries[3] = XtCreateManagedWidget("line", smeLineObjectClass, cmenu, + NULL, ZERO); + CM_entries[4]= XtCreateManagedWidget("getResourceList", + smeBSBObjectClass,cmenu, + NULL, ZERO); + XtAddCallback(CM_entries[4], XtNcallback, GetResourceList, NULL); + + CM_entries[5] = XtCreateManagedWidget("setValues", smeBSBObjectClass, + cmenu, + NULL, ZERO); + XtAddCallback(CM_entries[5], XtNcallback, InitSetValues, NULL); + + CM_entries[6] = XtCreateManagedWidget("line", smeLineObjectClass, cmenu, + NULL, ZERO); + + CM_entries[7] = XtCreateManagedWidget("quit", smeBSBObjectClass, cmenu, + NULL, ZERO); + XtAddCallback(CM_entries[7], XtNcallback, Quit, NULL); + + if (CM_set_insensitive) + SetEntriesSensitive(&CM_entries[CM_OFFSET], CM_NUM, False); +} + + + +/* Function Name: CreateTreeCommandMenu + * Description: Creats the command menu. + * Arguments: parent - widget to put this menu into. + * Returns: none. + */ + +#define SELECT 0 +#define ACTIVATE 1 +#define LABEL 2 +#define LINE 3 +#define FIND 4 +#define FLASH 5 + +struct tree_ops_menu { + char * name; + int type; + XtPointer data; +}; + +static Widget tmenu = NULL, tbutton = NULL; +/* at first most menu entries are insensitive */ +static Boolean TM_set_insensitive = True; +Widget TM_entries[NUM_TM_ENTRIES]; + +static void +CreateTreeCommandMenu(parent, toolkit) +Widget parent; +String toolkit; +{ + int i, number; + static struct tree_ops_menu tree_menu[] = { + { "showClientWidget", FIND, (XtPointer) NULL }, + { "selectAll", SELECT, (XtPointer) SelectAll }, + { "unselectAll", SELECT, (XtPointer) SelectNone }, + { "invertAll", SELECT, (XtPointer) SelectInvert }, + { "line", LINE, (XtPointer) NULL }, + { "selectChildren", SELECT, (XtPointer) SelectChildren }, + { "selectParent", SELECT, (XtPointer) SelectParent }, + { "selectDescendants", SELECT, (XtPointer) SelectDescendants }, + { "selectAncestors", SELECT, (XtPointer) SelectAncestors }, + { "line", LINE, (XtPointer) NULL }, + { "showWidgetNames", LABEL, (XtPointer) NameLabel }, + { "showClassNames", LABEL, (XtPointer) ClassLabel }, + { "showWidgetIDs", LABEL, (XtPointer) IDLabel}, + { "showWidgetWindows", LABEL, (XtPointer) WindowLabel }, + { "line", LINE, (XtPointer) NULL }, + { "flashActiveWidgets", FLASH, (XtPointer) NULL } + }; + Arg args[1]; + + if (tmenu) { XtDestroyWidget(tmenu); TM_set_insensitive = False; } + else + tbutton = XtCreateManagedWidget("treeCommands", menuButtonWidgetClass, + parent, NULL, ZERO); + + XtSetArg(args[0], XtNmenuName, toolkit); + XtSetValues(tbutton, args, ONE); + + tmenu = XtCreatePopupShell(toolkit, simpleMenuWidgetClass, tbutton, + NULL, ZERO); + + for ( i = 0, number = XtNumber(tree_menu) ; i < number ; i++) { + void (*func)(); + WidgetClass class = smeBSBObjectClass; + + switch (tree_menu[i].type) { + case SELECT: + func = TreeSelect; + break; + case LABEL: + func = TreeRelabel; + break; + case LINE: + func = NULL; + class = smeLineObjectClass; + break; + case FIND: + func = FindWidget; + break; + case FLASH: + func = FlashActiveWidgets; + break; + default: + continue; + } + + TM_entries[i] = XtCreateManagedWidget(tree_menu[i].name, class, tmenu, + NULL, ZERO); + if (func != NULL) + XtAddCallback(TM_entries[i], XtNcallback, func,tree_menu[i].data); + } + if (TM_set_insensitive) SetEntriesSensitive(&TM_entries[TM_OFFSET], + TM_NUM, False); +} + + + +static Pixmap old_pixmap; + +/* Function Name: PrepareToLayoutTree + * Description: prepares the Tree widget to be layed out. + * Arguments: tree - the Tree widget. + * Returns: none + */ + +void +PrepareToLayoutTree(tree) +Widget tree; +{ + Arg args[1]; + + XtSetArg(args[0], XtNbackgroundPixmap, &old_pixmap); + XtGetValues(XtParent(tree), args, ONE); + + XtSetArg(args[0], XtNbackgroundPixmap, None); + XtSetValues(XtParent(tree), args, ONE); + + XtUnmapWidget(tree); +} + + + +/* Function Name: LayoutTree + * Description: Laysout the tree widget. + * Arguments: tree - the widget tree. + * Returns: none. + */ + +void +LayoutTree(tree) +Widget tree; +{ + Arg args[1]; + + XawTreeForceLayout(tree); + XtMapWidget(tree); + + XtSetArg(args[0], XtNbackgroundPixmap, old_pixmap); + XtSetValues(XtParent(tree), args, ONE); +} + + + +/************************************************************ + * + * Functions for creating the Resource Box. + * + ************************************************************/ + +/* Function Name: CreateResourceBoxWidgets + * Description: Creates the widgets that make up the resource box. + * Arguments: node - the widget node. + * names - the list of names that make up the normal resources. + * cons_names - the list of names that make up + * the constraint resources. + * Returns: none. + */ + +void +CreateResourceBoxWidgets(node, names, cons_names) +WNode * node; +char **names, **cons_names; +{ + Widget pane, box, button; + ResourceBoxInfo * res_box; + + res_box = (ResourceBoxInfo *) XtMalloc(sizeof(ResourceBoxInfo)); + node->resources->res_box = res_box; + + res_box->shell = XtCreatePopupShell(global_effective_toolkit, + /*RESOURCE_BOX,*/ + transientShellWidgetClass, + node->widget, NULL, ZERO); + XtAddCallback(res_box->shell, XtNdestroyCallback, + FreeResBox, (XtPointer) node); + + pane = XtCreateManagedWidget("pane", panedWidgetClass, + res_box->shell, NULL, ZERO); + + res_box->res_label = XtCreateManagedWidget("resourceLabel", + labelWidgetClass, + pane, NULL, ZERO); + + CreateResourceNameForm(pane, node); + CreateLists(pane, node, names, cons_names); + CreateValueWidget(pane, node); + + XtSetKeyboardFocus(pane, res_box->value_wid); /* send keyboard to value. */ + + box = XtCreateManagedWidget("commandBox", boxWidgetClass, + pane, NULL, ZERO); + + button = XtCreateManagedWidget("setFile", commandWidgetClass, + box, NULL, ZERO); + XtAddCallback(button, XtNcallback, SetFile, NULL); + + button = XtCreateManagedWidget("save", commandWidgetClass, + box, NULL, ZERO); + XtAddCallback(button, XtNcallback, SaveResource,(XtPointer) res_box); + + button = XtCreateManagedWidget("apply", commandWidgetClass, + box, NULL, ZERO); + XtAddCallback(button, XtNcallback, ApplyResource,(XtPointer) node); + + button = XtCreateManagedWidget("saveAndApply", commandWidgetClass, + box, NULL, ZERO); + XtAddCallback(button, XtNcallback, SaveResource,(XtPointer) res_box); + XtAddCallback(button, XtNcallback, ApplyResource,(XtPointer) node); + + button = XtCreateManagedWidget("cancel", commandWidgetClass, + box, NULL, ZERO); + XtAddCallback(button,XtNcallback,PopdownResBox,(XtPointer)res_box->shell); + + SetToggleGroupLeaders(node); + PopupOnNode(node, res_box->shell); +} + + + +/* Function Name: CreateResourceNameForm + * Description: Creates the Form widget with children that represent + * the full resource name for this object. + * Arguments: parent - parent of the form. + * node - the node corrosponding to this object. + * Returns: none + */ + +static void +CreateResourceNameForm(parent, node) +Widget parent; +WNode * node; +{ + ResourceBoxInfo * res_box = node->resources->res_box; + AnyInfo *new_info, *old_info; + char **names, **classes; + Widget form; + NameInfo * name_info = NULL; + Cardinal num_args; + Arg args[10]; + int i; + Widget dot, star, name, class, single, any; + + GetNamesAndClasses(node, &names, &classes); + + form = XtCreateManagedWidget("namesAndClasses", formWidgetClass, + parent, NULL, ZERO); + + name = class = any = NULL; + i = 0; + old_info = NULL; + while (TRUE) { + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, name); num_args++; + XtSetArg(args[num_args], XtNradioData, "."); num_args++; + dot = XtCreateManagedWidget("dot", toggleWidgetClass, + form, args, num_args); + XtAddCallback(dot, XtNcallback, + ActivateWidgetsAndSetResourceString,(XtPointer) node); + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, class); num_args++; + XtSetArg(args[num_args], XtNfromVert, dot); num_args++; + XtSetArg(args[num_args], XtNradioGroup, dot); num_args++; + XtSetArg(args[num_args], XtNradioData, "*"); num_args++; + star = XtCreateManagedWidget("star", toggleWidgetClass, + form, args, num_args); + XtAddCallback(star,XtNcallback, + ActivateWidgetsAndSetResourceString, (XtPointer) node); + + if (name_info != NULL) { + name_info->next = (NameInfo *) XtMalloc(sizeof(NameInfo)); + name_info = name_info->next; + } + else + res_box->name_info = + name_info = (NameInfo *) XtMalloc(sizeof(NameInfo)); + + name_info->sep_leader = dot; + name_info->name_leader = NULL; + + if (names[i] != NULL) { + new_info = (AnyInfo *) XtMalloc(sizeof(AnyInfo)); + new_info->node = node; + new_info->left_dot = dot; + new_info->left_star = star; + new_info->left_count = 0; + if (old_info != NULL) + old_info->right_count = &(new_info->left_count); + } + else if (old_info != NULL) + old_info->right_count = NULL; + + if (old_info != NULL) { + old_info->right_dot = dot; + old_info->right_star = star; + + XtAddCallback(any, XtNcallback, AnyChosen, (XtPointer) old_info); + XtAddCallback(any, XtNdestroyCallback, + FreeClientData, (XtPointer) old_info); + } + + if ( names[i] == NULL) /* no more name and class boxes. */ + break; + + old_info = new_info; + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, dot); num_args++; + XtSetArg(args[num_args], XtNlabel, names[i]); num_args++; + XtSetArg(args[num_args], XtNradioData, names[i]); num_args++; + name = XtCreateManagedWidget("name", toggleWidgetClass, + form, args, num_args); + XtAddCallback(name,XtNcallback, + ActivateWidgetsAndSetResourceString,(XtPointer) node); + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, star); num_args++; + XtSetArg(args[num_args], XtNfromVert, name); num_args++; + XtSetArg(args[num_args], XtNlabel, classes[i]); num_args++; + XtSetArg(args[num_args], XtNradioGroup, name); num_args++; + XtSetArg(args[num_args], XtNradioData, classes[i]); num_args++; + class = XtCreateManagedWidget("class", toggleWidgetClass, + form,args,num_args); + XtAddCallback(class, XtNcallback, + ActivateWidgetsAndSetResourceString,(XtPointer) node); + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, star); num_args++; + XtSetArg(args[num_args], XtNfromVert, class); num_args++; + XtSetArg(args[num_args], XtNradioData, "?"); num_args++; + XtSetArg(args[num_args], XtNradioGroup, name); num_args++; + single = XtCreateManagedWidget("single", toggleWidgetClass, + form, args, num_args); + XtAddCallback(single,XtNcallback, + ActivateWidgetsAndSetResourceString,(XtPointer) node); + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, any); num_args++; + XtSetArg(args[num_args], XtNfromVert, single); num_args++; + XtSetArg(args[num_args], XtNradioGroup, name); num_args++; + XtSetArg(args[num_args], XtNradioData, ANY_RADIO_DATA); num_args++; + any = XtCreateManagedWidget("any", toggleWidgetClass, + form, args, num_args); + + name_info->name_leader = name; + + MakeBoxLookNice(dot, star, any, single, name, class, + (i == 0 ? -1 : (names[i + 1] ? 0 : 1))); + + i++; + } + + name_info->next = NULL; + XtFree((char *)names); /* Free what you allocate... */ + XtFree((char *)classes); +} + + + +/* Function Name: SetToggleGroupLeaders + * Description: Sets the leaders of each toggle group. + * node - The widget node containing this res box. + * Returns: none + */ + +static void +SetToggleGroupLeaders(node) +WNode * node; +{ + NameInfo *name; + ResourceBoxInfo * res_box = node->resources->res_box; + static Arg args[] = { + {XtNstate, (XtArgVal) TRUE} + }; + + for (name = res_box->name_info; name != NULL; name = name->next) { + XtSetValues(name->sep_leader, args, XtNumber(args)); + if (name->name_leader != NULL) + XtSetValues(name->name_leader, args, XtNumber(args)); + } + SetResourceString(NULL, (XtPointer) node, NULL); +} + + + +/* Function Name: MakeBoxLookNice + * Description: Resizes the box that contains the resource names + * to look a bit nicer. + * Arguments: dot, star - the widgets containing the separator types. + * any, single, name, class - the widgets that contain the + * name and class of this object. + * Returns: none. + */ + +static void +MakeBoxLookNice(dot, star, any, single, name, class, endbox) +Widget dot, star, any, single, name, class; +int endbox; +{ + +#define MAX_HDIST 3 + + Arg args[10]; + Cardinal num_args; + Dimension any_width, name_class_width, dot_star_width; + Dimension width_1, width_2; + int h_dist[MAX_HDIST]; + int i; + + /* + * Make sure that the dot and star widgets are the same size. + */ + + num_args = 0; + XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[0])); num_args++; + XtSetArg(args[num_args], XtNwidth, &width_1); num_args++; + XtGetValues(dot, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[1])); num_args++; + XtSetArg(args[num_args], XtNwidth, &width_2); num_args++; + XtGetValues(star, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[2])); num_args++; + XtSetArg(args[num_args], XtNwidth, &any_width); num_args++; + XtGetValues(any, args, num_args); + + dot_star_width = (width_1 > width_2) ? width_1 : width_2; + for (i = 1 ; i < MAX_HDIST; i++) { + if (h_dist[i] > h_dist[0]) h_dist[0] = h_dist[i]; + } + + num_args = 0; + XtSetArg(args[num_args], XtNhorizDistance, h_dist[0]); num_args++; + XtSetValues(any, args, num_args); + + /* + * Add a new arg, and continue... + */ + XtSetArg(args[num_args], XtNwidth, dot_star_width); num_args++; + XtSetValues(star, args, num_args); + XtSetValues(dot, args, num_args); + + + /* + * Now make sure that the Any Widget is as wide as the longest + * of the name and class widgets, plus space for the dot and star widgets. + * Don't forget the Form widget's internal space. + */ + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, &width_1); num_args++; + XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[0])); num_args++; + XtGetValues(name, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, &width_2); num_args++; + XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[1])); num_args++; + XtGetValues(class, args, num_args); + + if (width_2 > width_1) width_1 = width_2; + if (h_dist[1] > h_dist[0]) h_dist[0] = h_dist[1]; + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, &width_2); num_args++; + XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[1])); num_args++; + XtGetValues(single, args, num_args); + + name_class_width = (width_1 > width_2) ? width_1 : width_2; + if (h_dist[1] > h_dist[0]) h_dist[0] = h_dist[1]; + if (any_width > name_class_width) + name_class_width = any_width; + any_width = dot_star_width + h_dist[0] + name_class_width; + if (endbox < 0) + any_width += dot_star_width / 2; + else if (endbox > 0) + any_width += (dot_star_width - dot_star_width / 2); + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, any_width); num_args++; + XtSetValues(any, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, name_class_width); num_args++; + XtSetArg(args[num_args], XtNhorizDistance, h_dist[0]); num_args++; + XtSetValues(name, args, num_args); + XtSetValues(class, args, num_args); + XtSetValues(single, args, num_args); +} + + + +/* Function Name: CreateLists + * Description: Creates the list widgets for the normal and constraint + * resources + * Arguments: parent - parent of the lists. + * node - The widget node containing this res box. + * names, cons_names - lists for norm and cons resource boxes. + * Returns: none + */ + +static char* noneList[] = {"None"}; + +static void +CreateLists(parent, node, names, cons_names) +Widget parent; +WNode * node; +char **names, **cons_names; +{ + Cardinal num_args; + ResourceBoxInfo * res_box = node->resources->res_box; + Arg args[3]; + + (void) XtCreateManagedWidget("namesLabel", labelWidgetClass, + parent, NULL, ZERO); + + num_args = 0; + /* if the first list item is the widget name we want an empty + * list. + */ + if (!names) { + XtSetArg(args[num_args], XtNlist, noneList); num_args++; + XtSetArg(args[num_args], XtNnumberStrings, 1); num_args++; + XtSetArg(args[num_args], XtNsensitive, False); num_args++; + } + else { XtSetArg(args[num_args], XtNlist, names); num_args++; } + res_box->norm_list = XtCreateManagedWidget("namesList", listWidgetClass, + parent, args, num_args); + XtAddCallback(res_box->norm_list, XtNcallback, + ResourceListCallback, (XtPointer) node); + XtAddCallback(res_box->norm_list, XtNdestroyCallback, + FreeClientData, (XtPointer) names); + + if (cons_names != NULL) { + (void) XtCreateManagedWidget("constraintLabel", labelWidgetClass, + parent, NULL, ZERO); + + num_args = 0; + XtSetArg(args[num_args], XtNlist, cons_names); num_args++; + res_box->cons_list = XtCreateManagedWidget("constraintList", + listWidgetClass, + parent, args, num_args); + XtAddCallback(res_box->cons_list, XtNcallback, + ResourceListCallback, (XtPointer) node); + XtAddCallback(res_box->cons_list, XtNdestroyCallback, + FreeClientData, (XtPointer) cons_names); + } + else + res_box->cons_list = NULL; +} + +/* Function Name: CreateValueWidget + * Description: Creates the value widget for entering the resources value. + * Arguments: parent - parent of this widget. + * res_box - the resource box info. + * Returns: none. + */ + +static void +CreateValueWidget(parent, node) +Widget parent; +WNode * node; +{ + Widget form, label; + Cardinal num_args; + Arg args[10]; + ResourceBoxInfo * res_box = node->resources->res_box; + + form = XtCreateManagedWidget("valueForm", formWidgetClass, + parent, NULL, ZERO); + + num_args = 0; + XtSetArg(args[num_args], XtNleft, XawChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XawChainLeft); num_args++; + XtSetArg(args[num_args], XtNtop, XawChainTop); num_args++; + XtSetArg(args[num_args], XtNbottom, XawChainBottom); num_args++; + label = XtCreateManagedWidget("valueLabel", labelWidgetClass, + form, args, num_args); + + num_args = 0; + XtSetArg(args[num_args], XtNfromHoriz, label); num_args++; + XtSetArg(args[num_args], XtNleft, XawChainLeft); num_args++; + XtSetArg(args[num_args], XtNright, XawChainRight); num_args++; + XtSetArg(args[num_args], XtNtop, XawChainTop); num_args++; + XtSetArg(args[num_args], XtNbottom, XawChainBottom); num_args++; + res_box->value_wid = XtCreateManagedWidget("valueText", + asciiTextWidgetClass, + form, args, num_args); +#ifdef notdef + XtAddCallback(XawTextGetSource(res_box->value_wid), XtNcallback, + SetResourceString, (XtPointer) node); +#endif +} + + + +/* Function Name: PopupOnNode + * Description: Pops a shell widget up centered on the node specified. + * Arguments: node - the node. + * shell - the shell to popup. + * Returns: none. + */ + +extern Atom wm_delete_window; + +static void +PopupOnNode(node, shell) +WNode * node; +Widget shell; +{ + Arg args[3]; + Cardinal num_args; + Position x, y; + Dimension width, height, bw; + + num_args = 0; + XtSetArg(args[num_args], XtNwidth, &width); num_args++; + XtSetArg(args[num_args], XtNheight, &height); num_args++; + XtSetArg(args[num_args], XtNborderWidth, &bw); num_args++; + XtGetValues(node->widget, args, num_args); + XtTranslateCoords(node->widget, + (Position) (width/2 + bw), (Position) (height/2 + bw), + &x, &y); + + XtOverrideTranslations + (shell, XtParseTranslationTable ("<Message>WM_PROTOCOLS: quit()")); + XtRealizeWidget(shell); + wm_delete_window = XInternAtom(XtDisplay(shell), "WM_DELETE_WINDOW", + False); + (void) XSetWMProtocols (XtDisplay(shell), XtWindow(shell), + &wm_delete_window, 1); + XtGetValues(shell, args, num_args); /* use same arg_list. */ + + x -= (Position) (width/2 + bw); + y -= (Position) (height/2 + bw); + + if (x < 0) + x = 0; + else { + Position max_loc = WidthOfScreen(XtScreen(shell)) - + (Position) (width + 2 * bw); + if (x > max_loc) + x = max_loc; + } + + if (y < 0) + y = 0; + else { + Position max_loc = HeightOfScreen(XtScreen(shell)) - + (Position) (height + 2 * bw); + if (y > max_loc) + y = max_loc; + } + + num_args = 0; + XtSetArg(args[num_args], XtNx, x); num_args++; + XtSetArg(args[num_args], XtNy, y); num_args++; + XtSetValues(shell, args, num_args); + + XtPopup(shell, XtGrabNone); +} + + + +/* Function Name: FreeClientData + * Description: Frees the client data passed to this function. + * Arguments: w - UNUSED. + * list_ptr - pointer to the list to check. + * junk - UNUSED. + * Returns: none + */ + +/* ARGSUSED */ +static void +FreeClientData(w, ptr, junk) +Widget w; +XtPointer ptr, junk; +{ + XtFree(ptr); +} + + + +/* Function Name: FreeResBox. + * Description: Frees resource box allocated memory. + * Arguments: w - UNUSED. + * ptr - pointer to the node that has this resources box. + * junk - UNUSED. + * Returns: none + */ + +/* ARGSUSED */ +static void +FreeResBox(w, ptr, junk) +Widget w; +XtPointer ptr, junk; +{ + WNode * node = (WNode *) ptr; + NameInfo *old_name, *name = node->resources->res_box->name_info; + + global_resource_box_up = FALSE; + + XtFree((XtPointer) node->resources->res_box); + node->resources->res_box = NULL; + + while (name != NULL) { + old_name = name; + name = name->next; + XtFree((XtPointer) old_name); + } +} + + + |