1046 lines
31 KiB
C
1046 lines
31 KiB
C
/*
|
||
* $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.
|
||
*/
|
||
/* $XFree86: xc/programs/editres/widgets.c,v 1.5 2001/01/17 23:44:52 dawes Exp $ */
|
||
|
||
/*
|
||
* 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 Widget CreateTopArea ( Widget parent );
|
||
static void CreateCommandMenu ( Widget parent, String toolkit );
|
||
static void CreateTreeCommandMenu ( Widget parent, String toolkit );
|
||
static void CreateResourceNameForm ( Widget parent, WNode * node );
|
||
static void SetToggleGroupLeaders ( WNode * node );
|
||
static void MakeBoxLookNice ( Widget dot, Widget star, Widget any,
|
||
Widget single, Widget name, Widget class,
|
||
int endbox );
|
||
static void CreateLists ( Widget parent, WNode * node, char **names,
|
||
char **cons_names );
|
||
static void CreateValueWidget ( Widget parent, WNode * node );
|
||
static void PopupOnNode ( WNode * node, Widget shell );
|
||
static void FreeClientData ( Widget w, XtPointer ptr, XtPointer junk );
|
||
static void FreeResBox ( Widget w, XtPointer ptr, XtPointer junk );
|
||
|
||
|
||
|
||
/* 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(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++) {
|
||
XtCallbackProc 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, viewport, pane_child;
|
||
ResourceBoxInfo * res_box;
|
||
Dimension max_width = WidthOfScreen(XtScreen(node->widget)) - 20;
|
||
Dimension max_height = HeightOfScreen(XtScreen(node->widget)) - 40;
|
||
|
||
res_box = (ResourceBoxInfo *) XtMalloc(sizeof(ResourceBoxInfo));
|
||
node->resources->res_box = res_box;
|
||
|
||
res_box->shell = XtVaCreatePopupShell(global_effective_toolkit,
|
||
/*RESOURCE_BOX,*/
|
||
transientShellWidgetClass,
|
||
node->widget,
|
||
XtNmaxWidth, max_width,
|
||
XtNmaxHeight, max_height, NULL);
|
||
XtAddCallback(res_box->shell, XtNdestroyCallback,
|
||
FreeResBox, (XtPointer) node);
|
||
|
||
pane = XtCreateManagedWidget("pane", panedWidgetClass,
|
||
res_box->shell, NULL, ZERO);
|
||
|
||
viewport = XtCreateManagedWidget("mainViewport", viewportWidgetClass,
|
||
pane, NULL, 0);
|
||
pane_child = XtCreateManagedWidget("pane", panedWidgetClass,
|
||
viewport, NULL, ZERO);
|
||
|
||
res_box->res_label = XtCreateManagedWidget("resourceLabel",
|
||
labelWidgetClass,
|
||
pane_child, NULL, ZERO);
|
||
|
||
CreateResourceNameForm(pane_child, node);
|
||
CreateLists(pane_child, 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 = NULL, *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;
|
||
|
||
num_args = 0;
|
||
if (endbox < 0) {
|
||
any_width -= dot_star_width & 1;
|
||
XtSetArg(args[num_args], XtNhorizDistance,
|
||
h_dist[2] + (dot_star_width >> 1) + (dot_star_width & 1));
|
||
++num_args;
|
||
}
|
||
|
||
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;
|
||
{
|
||
Widget viewport;
|
||
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++; }
|
||
viewport = XtCreateManagedWidget("normalViewport", viewportWidgetClass,
|
||
parent, NULL, 0);
|
||
res_box->norm_list = XtCreateManagedWidget("namesList", listWidgetClass,
|
||
viewport, 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++;
|
||
viewport = XtCreateManagedWidget("constraintViewport", viewportWidgetClass,
|
||
parent, NULL, 0);
|
||
res_box->cons_list = XtCreateManagedWidget("constraintList",
|
||
listWidgetClass,
|
||
viewport, 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, max_loc;
|
||
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);
|
||
|
||
max_loc = WidthOfScreen(XtScreen(shell)) - (Position) (width + 2 * bw);
|
||
if (x > max_loc)
|
||
x = max_loc;
|
||
if (x < 0)
|
||
x = 0;
|
||
|
||
max_loc = HeightOfScreen(XtScreen(shell)) - (Position) (height + 2 * bw);
|
||
if (y > max_loc)
|
||
y = max_loc;
|
||
if (y < 0)
|
||
y = 0;
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
|
||
|