WidgetNode.h File Reference

#include <X11/Intrinsic.h>
#include <X11/Xfuncproto.h>

Include dependency graph for WidgetNode.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_XmuWidgetNode
Defines
#define	XmuWnClass(wn)   ((wn)->widget_class_ptr[0])
#define	XmuWnClassname(wn)   (XmuWnClass(wn)->core_class.class_name)
#define	XmuWnSuperclass(wn)   ((XmuWnClass(wn))->core_class.superclass)
Typedefs
typedef _XmuWidgetNode	XmuWidgetNode
Functions
_XFUNCPROTOBEGIN void	XmuWnInitializeNodes (XmuWidgetNode *nodearray, int nnodes)
void	XmuWnFetchResources (XmuWidgetNode *node, Widget toplevel, XmuWidgetNode *topnode)
int	XmuWnCountOwnedResources (XmuWidgetNode *node, XmuWidgetNode *ownernode, Bool constraints)
XmuWidgetNode *	XmuWnNameToNode (XmuWidgetNode *nodelist, int nnodes, _Xconst char *name)

---

Define Documentation

#define XmuWnClass

(

wn

)

((wn)->widget_class_ptr[0])

Definition at line 61 of file WidgetNode.h.

Referenced by XmuWnFetchResources(), and XmuWnInitializeNodes().

#define XmuWnClassname

(

wn

)

(XmuWnClass(wn)->core_class.class_name)

Definition at line 62 of file WidgetNode.h.

Referenced by XmuWnInitializeNodes().

#define XmuWnSuperclass

(

wn

)

((XmuWnClass(wn))->core_class.superclass)

Definition at line 63 of file WidgetNode.h.

Referenced by XmuWnInitializeNodes().

---

Typedef Documentation

typedef struct _XmuWidgetNode XmuWidgetNode

---

Function Documentation

int XmuWnCountOwnedResources	(	XmuWidgetNode *	node,
		XmuWidgetNode *	ownernode,
		Bool	constraints
	)

Definition at line 279 of file WidgetNode.c.

References _XmuWidgetNode::constraintwn, i, _XmuWidgetNode::nconstraints, _XmuWidgetNode::nresources, and _XmuWidgetNode::resourcewn.

{
    register int i;
    XmuWidgetNode **wn = (cons ? node->constraintwn : node->resourcewn);
    int nmatches = 0;

    for (i = (cons ? node->nconstraints : node->nresources); i > 0; i--, wn++)
      if (*wn == ownernode) nmatches++;
    return nmatches;
}

void XmuWnFetchResources	(	XmuWidgetNode *	node,
		Widget	toplevel,
		XmuWidgetNode *	topnode
	)

Definition at line 211 of file WidgetNode.c.

References compare_resource_entries(), dummy, _XmuWidgetNode::have_resources, _XmuWidgetNode::label, _XmuWidgetNode::nresources, NULL, _XmuWidgetNode::resourcewn, _XmuWidgetNode::superclass, and XmuWnClass.

{
    Widget dummy;
    XmuWidgetNode *wn;

    if (node->have_resources) return;

    dummy = XtCreateWidget (node->label, XmuWnClass(node), toplevel,
                            NULL, 0);
    if (dummy) XtDestroyWidget (dummy);


    /*
     * walk up tree geting resources; since we've instantiated the widget,
     * we know that all of our superclasses have been initialized
     */
    for (wn = node; wn && !wn->have_resources; wn = wn->superclass) {
        XtGetResourceList (XmuWnClass(wn), &wn->resources, &wn->nresources);
        if (wn->resources) {
            qsort ((char *) wn->resources, wn->nresources,
                   sizeof(XtResource), compare_resource_entries);
        }
        wn->resourcewn = (XmuWidgetNode **) XtCalloc (wn->nresources,
                                                  sizeof (XmuWidgetNode *));
        if (!wn->resourcewn) {
            fprintf (stderr,
                     "%s:  unable to calloc %d %ld byte widget node ptrs\n",
                     "XmuWnFetchResources", wn->nresources,
                     (unsigned long)sizeof (XmuWidgetNode *));
            exit (1);
        }

        XtGetConstraintResourceList (XmuWnClass(wn), &wn->constraints,
                                     &wn->nconstraints);
        if (wn->constraints) {
            qsort ((char *) wn->constraints, wn->nconstraints,
                   sizeof(XtResource), compare_resource_entries);
        }
        wn->constraintwn = (XmuWidgetNode **)
          XtCalloc (wn->nconstraints, sizeof (XmuWidgetNode *));
        if (!wn->constraintwn) {
            fprintf (stderr,
                     "%s:  unable to calloc %d %ld byte widget node ptrs\n",
                     "XmuWnFetchResources", wn->nconstraints,
                     (unsigned long)sizeof (XmuWidgetNode *));
            exit (1);
        }

        wn->have_resources = True;
        if (wn == topnode) break;
    }


    /*
     * Walk up tree removing all resources that appear in superclass; we can
     * mash the resource list in place since it was copied out of widget.
     */
    for (wn = node; wn; wn = wn->superclass) {
        mark_resource_owner (wn);
        if (wn == topnode) break;
    }

    return;
}

Here is the call graph for this function:

_XFUNCPROTOBEGIN void XmuWnInitializeNodes	(	XmuWidgetNode *	nodearray,
		int	nnodes
	)

Definition at line 144 of file WidgetNode.c.

References _XmuWidgetNode::children, _XmuWidgetNode::constraints, _XmuWidgetNode::constraintwn, _XmuWidgetNode::data, done, _XmuWidgetNode::have_resources, i, j, _XmuWidgetNode::label, _XmuWidgetNode::lowered_classname, _XmuWidgetNode::lowered_label, namelen, _XmuWidgetNode::nconstraints, _XmuWidgetNode::nresources, NULL, _XmuWidgetNode::resources, _XmuWidgetNode::resourcewn, _XmuWidgetNode::siblings, _XmuWidgetNode::superclass, superclass, XmuCopyISOLatin1Lowered(), XmuWnClass, XmuWnClassname, and XmuWnSuperclass.

{
    int i;
    XmuWidgetNode *wn;

    /*
     * Assume that the node array is in alphabetic order, so we need to
     * search backwards to make sure that the children are listed forward.
     */
    for (i = nnodes - 1, wn = nodearray + (nnodes - 1); i >= 0; i--, wn--) {
        WidgetClass superclass = XmuWnSuperclass(wn);
        int j;
        XmuWidgetNode *swn;
        int lablen = strlen (wn->label);
        int namelen = strlen (XmuWnClassname(wn));

        wn->lowered_label = XtMalloc (lablen + namelen + 2);
#if 0
        /* XtMalloc exits if failed */
        if (!wn->lowered_label) {
            fprintf (stderr,
                     "%s:  unable to allocate %d bytes for widget name\n",
                     "XmuWnInitializeNodes", lablen + namelen + 2);
            exit (1);
        }
#endif
        wn->lowered_classname = wn->lowered_label + (lablen + 1);
        XmuCopyISOLatin1Lowered (wn->lowered_label, wn->label);
        XmuCopyISOLatin1Lowered (wn->lowered_classname, XmuWnClassname(wn));
        wn->superclass = NULL;
        wn->have_resources = False;
        wn->resources = NULL;
        wn->resourcewn = NULL;
        wn->nresources = 0;
        wn->constraints = NULL;
        wn->constraintwn = NULL;
        wn->nconstraints = 0;
        wn->data = (XtPointer) NULL;

        /*
         * walk up the superclass chain
         */
        while (superclass) {
            for (j = 0, swn = nodearray; j < nnodes; j++, swn++) {
                if (superclass == XmuWnClass(swn)) {
                    wn->superclass = swn;
                    goto done;          /* stupid C language */
                }
            }
            /*
             * Hmm, we have a hidden superclass (such as in core in R4); just
             * ignore it and keep on walking
             */
            superclass = superclass->core_class.superclass;
        }
      done: 
        if (wn->superclass) {
            wn->siblings = wn->superclass->children;
            wn->superclass->children = wn;
        }
    }

    return;
}

Here is the call graph for this function:

XmuWidgetNode* XmuWnNameToNode	(	XmuWidgetNode *	nodelist,
		int	nnodes,
		_Xconst char *	name
	)

Definition at line 293 of file WidgetNode.c.

References i, _XmuWidgetNode::lowered_classname, _XmuWidgetNode::lowered_label, and XmuNCopyISOLatin1Lowered().

{
    int i;
    XmuWidgetNode *wn;
    char tmp[1024];

    XmuNCopyISOLatin1Lowered(tmp, name, sizeof(tmp));
    for (i = 0, wn = nodelist; i < nnodes; i++, wn++) {
        if (strcmp (tmp, wn->lowered_label) == 0 ||
            strcmp (tmp, wn->lowered_classname) == 0) {
          return wn;
        }
    }
    return NULL;
}

Here is the call graph for this function:

---