Tree.c File Reference

#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Xaw3d/XawInit.h>
#include <X11/Xaw3d/Cardinals.h>
#include <X11/Xaw3d/TreeP.h>

Include dependency graph for Tree.c:

Go to the source code of this file.

Defines
#define	IsHorizontal(tw)
Functions
static void	ClassInitialize ()
static void	Initialize ()
static void	ConstraintInitialize ()
static void	ConstraintDestroy ()
static Boolean	ConstraintSetValues ()
static void	Destroy ()
static Boolean	SetValues ()
static XtGeometryResult	GeometryManager ()
static void	ChangeManaged ()
static void	Redisplay ()
static XtGeometryResult	QueryGeometry ()
static void	insert_node ()
static void	delete_node ()
static void	layout_tree ()
static void	initialize_dimensions (Dimension **listp, int *sizep, int n)
static GC	get_tree_gc (TreeWidget w)
static void	insert_node (Widget parent, Widget node)
static void	delete_node (Widget parent, Widget node)
static void	check_gravity (TreeWidget tw, XtGravity grav)
static void	Initialize (Widget grequest, Widget gnew, ArgList args, Cardinal *num_args)
static void	ConstraintInitialize (Widget request, Widget new, ArgList args, Cardinal *num_args)
static Boolean	SetValues (Widget gcurrent, Widget grequest, Widget gnew, ArgList args, Cardinal *num_args)
static Boolean	ConstraintSetValues (Widget current, Widget request, Widget new, ArgList args, Cardinal *num_args)
static void	ConstraintDestroy (Widget w)
static XtGeometryResult	GeometryManager (Widget w, XtWidgetGeometry *request, XtWidgetGeometry *reply)
static void	ChangeManaged (Widget gw)
static void	Destroy (Widget gw)
static void	Redisplay (Widget gw, XEvent *event, Region region)
static XtGeometryResult	QueryGeometry (Widget w, XtWidgetGeometry *intended, XtWidgetGeometry *preferred)
static void	compute_bounding_box_subtree (TreeWidget tree, Widget w, int depth)
static void	set_positions (TreeWidget tw, Widget w, int level)
static void	arrange_subtree (TreeWidget tree, Widget w, int depth, Position x, Position y)
static void	set_tree_size (TreeWidget tw, Boolean insetvalues, Dimension width, Dimension height)
static void	layout_tree (TreeWidget tw, Boolean insetvalues)
void	XawTreeForceLayout (Widget tree)
Variables
static XtResource	resources []
static XtResource	treeConstraintResources []
TreeClassRec	treeClassRec
WidgetClass	treeWidgetClass = (WidgetClass) &treeClassRec

---

Define Documentation

#define IsHorizontal

(

tw

)

Value:

((tw)->tree.gravity == WestGravity || \
                          (tw)->tree.gravity == EastGravity)

Definition at line 59 of file Tree.c.

Referenced by arrange_subtree(), compute_bounding_box_subtree(), Initialize(), and SetValues().

---

Function Documentation

static void arrange_subtree	(	TreeWidget	tree,
		Widget	w,
		int	depth,
		Position	x,
		Position	y
	)			[static]

Definition at line 815 of file Tree.c.

References _TreeConstraintsPart::bbheight, _TreeConstraintsPart::bbsubheight, _TreeConstraintsPart::bbsubwidth, _TreeConstraintsPart::bbwidth, _TreeConstraintsPart::children, i, int, IsHorizontal, _TreeConstraintsPart::n_children, NULL, _TreeConstraintsRec::tree, TREE_CONSTRAINT, _TreeConstraintsPart::x, and _TreeConstraintsPart::y.

Referenced by layout_tree().

{
    TreeConstraints tc = TREE_CONSTRAINT(w);  /* info attached to all kids */
    TreeConstraints firstcc, lastcc;
    int i;
    int newx, newy;
    Bool horiz = IsHorizontal (tree);
    Widget child = NULL;
    Dimension tmp;
    Dimension bw2 = w->core.border_width * 2;
    Bool relayout = True;


    /*
     * If no children, then just lay out where requested.
     */
    tc->tree.x = x;
    tc->tree.y = y;

    if (horiz) {
        int myh = (w->core.height + bw2);

        if (myh > (int)tc->tree.bbsubheight) {
            y += (myh - (int)tc->tree.bbsubheight) / 2;
            relayout = False;
        }
    } else {
        int myw = (w->core.width + bw2);

        if (myw > (int)tc->tree.bbsubwidth) {
            x += (myw - (int)tc->tree.bbsubwidth) / 2;
            relayout = False;
        }
    }

    if ((tmp = ((Dimension) x) + tc->tree.bbwidth) > tree->tree.maxwidth)
      tree->tree.maxwidth = tmp;
    if ((tmp = ((Dimension) y) + tc->tree.bbheight) > tree->tree.maxheight)
      tree->tree.maxheight = tmp;

    if (tc->tree.n_children == 0) return;


    /*
     * Have children, so walk down tree laying out children, then laying
     * out parents.
     */
    if (horiz) {
        newx = x + tree->tree.largest[depth];
        if (depth > 0) newx += tree->tree.hpad;
        newy = y;
    } else {
        newx = x;
        newy = y + tree->tree.largest[depth];
        if (depth > 0) newy += tree->tree.vpad;
    }

    for (i = 0; i < tc->tree.n_children; i++) {
        TreeConstraints cc;

        child = tc->tree.children[i];   /* last value is used outside loop */
        cc = TREE_CONSTRAINT(child);

        arrange_subtree (tree, child, depth + 1, newx, newy);
        if (horiz) {
            newy += tree->tree.vpad + cc->tree.bbheight;
        } else {
            newx += tree->tree.hpad + cc->tree.bbwidth;
        }
    }

    /*
     * now layout parent between first and last children
     */
    if (relayout) {
        Position adjusted;
        firstcc = TREE_CONSTRAINT (tc->tree.children[0]);
        lastcc = TREE_CONSTRAINT (child);

        /* Adjustments are disallowed if they result in a position above
         * or to the left of the originally requested position, because
         * this could collide with the position of the previous sibling.
         */
        if (horiz) {
            tc->tree.x = x;
            adjusted = firstcc->tree.y +
              ((lastcc->tree.y + (Position) child->core.height + 
                (Position) child->core.border_width * 2 -
                firstcc->tree.y - (Position) w->core.height - 
                (Position) w->core.border_width * 2 + 1) / 2);
            if (adjusted > tc->tree.y) tc->tree.y = adjusted;
        } else {
            adjusted = firstcc->tree.x +
              ((lastcc->tree.x + (Position) child->core.width +
                (Position) child->core.border_width * 2 -
                firstcc->tree.x - (Position) w->core.width -
                (Position) w->core.border_width * 2 + 1) / 2);
            if (adjusted > tc->tree.x) tc->tree.x = adjusted;
            tc->tree.y = y;
        }
    }
}

Here is the caller graph for this function:

static void ChangeManaged

(

Widget

gw

)

[static]

Definition at line 552 of file Tree.c.

References FALSE, and layout_tree().

{
    layout_tree ((TreeWidget) gw, FALSE);
}

Here is the call graph for this function:

static void ChangeManaged

(

)

[static]

static void check_gravity	(	TreeWidget	tw,
		XtGravity	grav
	)			[static]

Definition at line 297 of file Tree.c.

Referenced by Initialize(), and SetValues().

{
    switch (tw->tree.gravity) {
      case WestGravity: case NorthGravity: case EastGravity: case SouthGravity:
        break;
      default:
        tw->tree.gravity = grav;
        break;
    }
}

Here is the caller graph for this function:

static void ClassInitialize

(

)

[static]

Definition at line 121 of file Simple.c.

References NULL, XawInitializeWidgetSet(), XmuCvtStringToColorCursor(), XmuCvtStringToOrientation(), XtNpointerColor, XtNpointerColorBackground, and XtRColorCursor.

{
    static XtConvertArgRec convertArg[] = {
        {XtWidgetBaseOffset, (XtPointer) XtOffsetOf(WidgetRec, core.screen),
             sizeof(Screen *)},
        {XtResourceString, (XtPointer) XtNpointerColor, sizeof(Pixel)},
        {XtResourceString, (XtPointer) XtNpointerColorBackground, 
             sizeof(Pixel)},
        {XtWidgetBaseOffset, (XtPointer) XtOffsetOf(WidgetRec, core.colormap),
             sizeof(Colormap)}
    };

    XawInitializeWidgetSet();
    XtSetTypeConverter( XtRString, XtRColorCursor, XmuCvtStringToColorCursor,
                       convertArg, XtNumber(convertArg), 
                       XtCacheByDisplay, (XtDestructor)NULL);
}

Here is the call graph for this function:

static void compute_bounding_box_subtree	(	TreeWidget	tree,
		Widget	w,
		int	depth
	)			[static]

Definition at line 701 of file Tree.c.

References _TreeConstraintsPart::bbheight, _TreeConstraintsPart::bbsubheight, _TreeConstraintsPart::bbsubwidth, _TreeConstraintsPart::bbwidth, _TreeConstraintsPart::children, i, initialize_dimensions(), IsHorizontal, _TreeConstraintsPart::n_children, _TreeConstraintsRec::tree, and TREE_CONSTRAINT.

Referenced by layout_tree().

{
    TreeConstraints tc = TREE_CONSTRAINT(w);  /* info attached to all kids */
    int i;
    Bool horiz = IsHorizontal (tree);
    Dimension newwidth, newheight;
    Dimension bw2 = w->core.border_width * 2;

    /*
     * Set the max-size per level.
     */
    if (depth >= tree->tree.n_largest) {
        initialize_dimensions (&tree->tree.largest,
                               &tree->tree.n_largest, depth + 1);
    }
    newwidth = ((horiz ? w->core.width : w->core.height) + bw2);
    if (tree->tree.largest[depth] < newwidth)
      tree->tree.largest[depth] = newwidth;


    /*
     * initialize
     */
    tc->tree.bbwidth = w->core.width + bw2;
    tc->tree.bbheight = w->core.height + bw2;

    if (tc->tree.n_children == 0) return;

    /*
     * Figure the size of the opposite dimension (vertical if tree is 
     * horizontal, else vice versa).  The other dimension will be set 
     * in the second pass once we know the maximum dimensions.
     */
    newwidth = 0;
    newheight = 0;
    for (i = 0; i < tc->tree.n_children; i++) {
        Widget child = tc->tree.children[i];
        TreeConstraints cc = TREE_CONSTRAINT(child);
            
        compute_bounding_box_subtree (tree, child, depth + 1);

        if (horiz) {
            if (newwidth < cc->tree.bbwidth) newwidth = cc->tree.bbwidth;
            newheight += tree->tree.vpad + cc->tree.bbheight;
        } else {
            if (newheight < cc->tree.bbheight) newheight = cc->tree.bbheight;
            newwidth += tree->tree.hpad + cc->tree.bbwidth;
        }
    }


    tc->tree.bbsubwidth = newwidth;
    tc->tree.bbsubheight = newheight;

    /*
     * Now fit parent onto side (or top) of bounding box and correct for
     * extra padding.  Be careful of unsigned arithmetic.
     */
    if (horiz) {
        tc->tree.bbwidth += tree->tree.hpad + newwidth;
        newheight -= tree->tree.vpad;
        if (newheight > tc->tree.bbheight) tc->tree.bbheight = newheight;
    } else {
        tc->tree.bbheight += tree->tree.vpad + newheight;
        newwidth -= tree->tree.hpad;
        if (newwidth > tc->tree.bbwidth) tc->tree.bbwidth = newwidth;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ConstraintDestroy

(

Widget

w

)

[static]

Definition at line 495 of file Tree.c.

References _TreeConstraintsPart::children, delete_node(), FALSE, i, insert_node(), layout_tree(), _TreeConstraintsPart::n_children, NULL, _TreeConstraintsPart::parent, _TreeConstraintsRec::tree, _TreeRec::tree, TREE_CONSTRAINT, and TreePart::tree_root.

{ 
    TreeConstraints tc = TREE_CONSTRAINT(w);
    TreeWidget tw = (TreeWidget) XtParent(w);
    int i;

    /* 
     * Remove the widget from its parent's sub-nodes list and
     * make all this widget's sub-nodes sub-nodes of the parent.
     */
  
    if (tw->tree.tree_root == w) {
        if (tc->tree.n_children > 0)
          tw->tree.tree_root = tc->tree.children[0];
        else
          tw->tree.tree_root = NULL;
    }

    delete_node (tc->tree.parent, (Widget) w);
    for (i = 0; i< tc->tree.n_children; i++)
      insert_node (tc->tree.parent, tc->tree.children[i]);

    layout_tree ((TreeWidget) (w->core.parent), FALSE);
}

Here is the call graph for this function:

static void ConstraintDestroy

(

)

[static]

static void ConstraintInitialize	(	Widget	request,
		Widget	new,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 384 of file Tree.c.

References _TreeConstraintsPart::bbsubheight, _TreeConstraintsPart::bbsubwidth, _TreeConstraintsPart::children, insert_node(), _TreeConstraintsPart::max_children, _TreeConstraintsPart::n_children, NULL, _TreeConstraintsPart::parent, _TreeRec::tree, _TreeConstraintsRec::tree, TREE_CONSTRAINT, TreePart::tree_root, _TreeConstraintsPart::x, and _TreeConstraintsPart::y.

{
    TreeConstraints tc = TREE_CONSTRAINT(new);
    TreeWidget tw = (TreeWidget) new->core.parent;

    /*
     * Initialize the widget to have no sub-nodes.
     */
    tc->tree.n_children = 0;
    tc->tree.max_children = 0;
    tc->tree.children = (Widget *) NULL;
    tc->tree.x = tc->tree.y = 0; 
    tc->tree.bbsubwidth = 0;
    tc->tree.bbsubheight = 0;


    /*
     * If this widget has a super-node, add it to that 
     * widget' sub-nodes list. Otherwise make it a sub-node of 
     * the tree_root widget.
     */
    if (tc->tree.parent)
      insert_node (tc->tree.parent, new);
    else if (tw->tree.tree_root)
      insert_node (tw->tree.tree_root, new);
} 

Here is the call graph for this function:

static void ConstraintInitialize

(

)

[static]

static Boolean ConstraintSetValues	(	Widget	current,
		Widget	request,
		Widget	new,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 464 of file Tree.c.

References delete_node(), FALSE, insert_node(), layout_tree(), _TreeConstraintsPart::parent, _TreeConstraintsRec::tree, and TREE_CONSTRAINT.

{
    TreeConstraints newc = TREE_CONSTRAINT(new);
    TreeConstraints curc = TREE_CONSTRAINT(current);
    TreeWidget tw = (TreeWidget) new->core.parent;

    /*
     * If the parent field has changed, remove the widget
     * from the old widget's children list and add it to the
     * new one.
     */
    if (curc->tree.parent != newc->tree.parent){
        if (curc->tree.parent)
          delete_node (curc->tree.parent, new);
        if (newc->tree.parent)
          insert_node(newc->tree.parent, new);

        /*
         * If the Tree widget has been realized, 
         * compute new layout.
         */
        if (XtIsRealized((Widget)tw))
          layout_tree (tw, FALSE);
    }
    return False;
}

Here is the call graph for this function:

static Boolean ConstraintSetValues

(

)

[static]

static void delete_node	(	Widget	parent,
		Widget	node
	)			[static]

Definition at line 261 of file Tree.c.

References _TreeConstraintsPart::children, i, _TreeConstraintsPart::n_children, pos, _TreeConstraintsRec::tree, and TREE_CONSTRAINT.

{
    TreeConstraints pc;
    int pos, i;

    /*
     * Make sure the parent exists.
     */
    if (!parent) return;  
  
    pc = TREE_CONSTRAINT(parent);

    /*
     * Find the sub_node on its parent's list.
     */
    for (pos = 0; pos < pc->tree.n_children; pos++)
      if (pc->tree.children[pos] == node) break;

    if (pos == pc->tree.n_children) return;

    /*
     * Decrement the number of children
     */  
    pc->tree.n_children--;

    /*
     * Fill in the gap left by the sub_node.
     * Zero the last slot for good luck.
     */
    for (i = pos; i < pc->tree.n_children; i++) 
      pc->tree.children[i] = pc->tree.children[i+1];

    pc->tree.children[pc->tree.n_children]=0;
}

static void delete_node

(

)

[static]

Referenced by ConstraintDestroy(), and ConstraintSetValues().

Here is the caller graph for this function:

static void Destroy

(

Widget

gw

)

[static]

Definition at line 559 of file Tree.c.

References w.

{
    TreeWidget w = (TreeWidget) gw;

    XtReleaseGC (gw, w->tree.gc);
    if (w->tree.largest) XtFree ((char *) w->tree.largest);
}

static void Destroy

(

)

[static]

static XtGeometryResult GeometryManager	(	Widget	w,
		XtWidgetGeometry *	request,
		XtWidgetGeometry *	reply
	)			[static]

Definition at line 522 of file Tree.c.

References TreePart::auto_reconfigure, FALSE, layout_tree(), and _TreeRec::tree.

{

    TreeWidget tw = (TreeWidget) w->core.parent;

    /*
     * No position changes allowed!.
     */
    if ((request->request_mode & CWX && request->x!=w->core.x)
        ||(request->request_mode & CWY && request->y!=w->core.y))
      return (XtGeometryNo);

    /*
     * Allow all resize requests.
     */

    if (request->request_mode & CWWidth)
      w->core.width = request->width;
    if (request->request_mode & CWHeight)
      w->core.height = request->height;
    if (request->request_mode & CWBorderWidth)
      w->core.border_width = request->border_width;

    if (tw->tree.auto_reconfigure) layout_tree (tw, FALSE);
    return (XtGeometryYes);
}

Here is the call graph for this function:

static XtGeometryResult GeometryManager

(

)

[static]

static GC get_tree_gc

(

TreeWidget

w

)

[static]

Definition at line 211 of file Tree.c.

Referenced by Initialize(), and SetValues().

{
    XtGCMask valuemask = GCBackground | GCForeground;
    XGCValues values;

    values.background = w->core.background_pixel;
    values.foreground = w->tree.foreground;
    if (w->tree.line_width != 0) {
        valuemask |= GCLineWidth;
        values.line_width = w->tree.line_width;
    }

    return XtGetGC ((Widget) w, valuemask, &values);
}

Here is the caller graph for this function:

static void Initialize	(	Widget	grequest,
		Widget	gnew,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 326 of file Tree.c.

References check_gravity(), _TreeRec::core, get_tree_gc(), TreePart::hpad, initialize_dimensions(), IsHorizontal, NULL, _TreeRec::tree, TREE_HORIZONTAL_DEFAULT_SPACING, TREE_INITIAL_DEPTH, TREE_VERTICAL_DEFAULT_SPACING, TWO, and TreePart::vpad.

{
    TreeWidget request = (TreeWidget) grequest, new = (TreeWidget) gnew;
    Arg arglist[2];

    /*
     * Make sure the widget's width and height are 
     * greater than zero.
     */
    if (request->core.width <= 0) new->core.width = 5;
    if (request->core.height <= 0) new->core.height = 5;

    /*
     * Set the padding according to the orientation
     */
    if (request->tree.hpad == 0 && request->tree.vpad == 0) {
        if (IsHorizontal (request)) {
            new->tree.hpad = TREE_HORIZONTAL_DEFAULT_SPACING;
            new->tree.vpad = TREE_VERTICAL_DEFAULT_SPACING;
        } else {
            new->tree.hpad = TREE_VERTICAL_DEFAULT_SPACING;
            new->tree.vpad = TREE_HORIZONTAL_DEFAULT_SPACING;
        }
    }

    /*
     * Create a graphics context for the connecting lines.
     */
    new->tree.gc = get_tree_gc (new);

    /*
     * Create the hidden root widget.
     */
    new->tree.tree_root = (Widget) NULL;
    XtSetArg(arglist[0], XtNwidth, 1);
    XtSetArg(arglist[1], XtNheight, 1);
    new->tree.tree_root = XtCreateWidget ("root", widgetClass, gnew,
                                          arglist,TWO);

    /*
     * Allocate the array used to hold the widest values per depth
     */
    new->tree.largest = NULL;
    new->tree.n_largest = 0;
    initialize_dimensions (&new->tree.largest, &new->tree.n_largest, 
                           TREE_INITIAL_DEPTH);

    /*
     * make sure that our gravity is one of the acceptable values
     */
    check_gravity (new, WestGravity);
} 

Here is the call graph for this function:

static void Initialize

(

)

[static]

Definition at line 26 of file javasci_globals.c.

{
  static char env[1024];
  static char initstr[]="exec(\"SCI/etc/scilab.start\",-1);quit;";
  static int iflag=-1, stacksize = 1000000, ierr=0;

  #ifdef _MSC_VER
    static char JavaSciInterf[]="javasci";
    static char nw[]="-nw";
    static char nb[]="-nb";
  #endif

  
  char *p1 = (char*)getenv ("SCI");
  
  
  #ifdef _MSC_VER
  /* Supprime le mode windows et la baniere */
    add_sci_argv(JavaSciInterf);
    add_sci_argv(nb);
  #endif
  
  #ifdef _MSC_VER 
    if ( p1== NULL )
    {
                /* Detection Scilab path */
                char modname[MAX_PATH+1];
                if (!GetModuleFileName (GetModuleHandle("javasci.dll"), modname, MAX_PATH))
                {
                        MessageBox(NULL,"javasci.dll not found","Warning",MB_ICONWARNING);
                }
                else
                {
                        char *p;
                        if ((p = strrchr (modname, '\\')) == NULL) exit(1); /* remove \javasci.dll from modname */
                        else
                        {
                                *p='\0';
                                if ((p = strrchr (modname, '\\')) == NULL) exit(1); /* remove \bin from modname */
                                else
                                {
                                        *p='\0';
                                        set_sci_env(modname);
                                }
                        }
                }
    }
    else 
        {
                char *pathSCI=(char*)MALLOC((strlen(p1)+1)*sizeof(char));
                sprintf(pathSCI,"%s",p1);
                set_sci_env(pathSCI);
                if (pathSCI) {FREE(pathSCI);pathSCI=NULL;}
        }
  #else
   if (p1==NULL)
   {
        fprintf(stderr,"Please define SCI environment variable\n");
        sprintf (env, "%s=%s", "SCI",SCI);
        setSCIpath(SCI);
        putenv (env);
   }
  #endif
  /* set TMPDIR */
  C2F(settmpdir)();
  /* Scilab Initialization */
  C2F(inisci)(&iflag,&stacksize,&ierr);
  if ( ierr > 0 ) 
    {
      fprintf(stderr,"Scilab initialization failed !\n");
      exit(1);
    }


  /* Initialisation fenetre graphique */
  #ifdef _MSC_VER
    InitWindowGraphDll();
  #endif

  /* pour initialisation de la primitive scilab : fromjava() */
  SetFromJavaToON();

  /* Chargement de Scilab.start */
  C2F(scirun)(initstr,(int)strlen(initstr));
 
}

static void initialize_dimensions	(	Dimension **	listp,
		int *	sizep,
		int	n
	)			[static]

Definition at line 184 of file Tree.c.

References i, and l.

Referenced by compute_bounding_box_subtree(), Initialize(), and layout_tree().

{
    int i;
    Dimension *l;

    if (!*listp) {
        *listp = (Dimension *) XtCalloc ((unsigned int) n,
                                         (unsigned int) sizeof(Dimension));
        *sizep = ((*listp) ? n : 0);
        return;
    }
    if (n > *sizep) {
        *listp = (Dimension *) XtRealloc((char *) *listp,
                                         (unsigned int) (n*sizeof(Dimension)));
        if (!*listp) {
            *sizep = 0;
            return;
        }
        for (i = *sizep, l = (*listp) + i; i < n; i++, l++) *l = 0;
        *sizep = n;
    }
    return;
}

Here is the caller graph for this function:

static void insert_node	(	Widget	parent,
		Widget	node
	)			[static]

Definition at line 227 of file Tree.c.

References _TreeConstraintsPart::children, _TreeConstraintsPart::max_children, _TreeConstraintsPart::n_children, nc, NULL, _TreeConstraintsRec::tree, and TREE_CONSTRAINT.

{
    TreeConstraints pc;
    TreeConstraints nc = TREE_CONSTRAINT(node);
    int nindex;
  
    nc->tree.parent = parent;

    if (parent == NULL) return;

    /*
     * If there isn't more room in the children array, 
     * allocate additional space.
     */  
    pc = TREE_CONSTRAINT(parent);
    nindex = pc->tree.n_children;
  
    if (pc->tree.n_children == pc->tree.max_children) {
        pc->tree.max_children += (pc->tree.max_children / 2) + 2;
        pc->tree.children = (WidgetList) XtRealloc ((char *)pc->tree.children, 
                                                    (unsigned int)
                                                    ((pc->tree.max_children) *
                                                    sizeof(Widget)));
    } 

    /*
     * Add the sub_node in the next available slot and 
     * increment the counter.
     */
    pc->tree.children[nindex] = node;
    pc->tree.n_children++;
}

static void insert_node

(

)

[static]

Referenced by ConstraintDestroy(), ConstraintInitialize(), and ConstraintSetValues().

Here is the caller graph for this function:

static void layout_tree	(	TreeWidget	tw,
		Boolean	insetvalues
	)			[static]

Definition at line 946 of file Tree.c.

References arrange_subtree(), compute_bounding_box_subtree(), i, initialize_dimensions(), NULL, set_positions(), and set_tree_size().

{
    int i;
    Dimension *dp;

    /*
     * Do a depth-first search computing the width and height of the bounding
     * box for the tree at that position (and below).  Then, walk again using
     * this information to layout the children at each level.
     */

    if (tw->tree.tree_root == NULL)
        return;

    tw->tree.maxwidth = tw->tree.maxheight = 0;
    for (i = 0, dp = tw->tree.largest; i < tw->tree.n_largest; i++, dp++)
      *dp = 0;
    initialize_dimensions (&tw->tree.largest, &tw->tree.n_largest, 
                           tw->tree.n_largest);
    compute_bounding_box_subtree (tw, tw->tree.tree_root, 0);

   /*
    * Second pass to do final layout.  Each child's bounding box is stacked
    * on top of (if horizontal, else next to) on top of its siblings.  The
    * parent is centered between the first and last children.
    */
    arrange_subtree (tw, tw->tree.tree_root, 0, 0, 0);

    /*
     * Move each widget into place.
     */
    set_tree_size (tw, insetvalues, tw->tree.maxwidth, tw->tree.maxheight);
    set_positions (tw, tw->tree.tree_root, 0);

    /*
     * And redisplay.
     */
    if (XtIsRealized ((Widget) tw)) {
        XClearArea (XtDisplay(tw), XtWindow((Widget)tw), 0, 0, 0, 0, True);
    }
}

Here is the call graph for this function:

static void layout_tree

(

)

[static]

Referenced by ChangeManaged(), ConstraintDestroy(), ConstraintSetValues(), GeometryManager(), SetValues(), and XawTreeForceLayout().

Here is the caller graph for this function:

static XtGeometryResult QueryGeometry	(	Widget	w,
		XtWidgetGeometry *	intended,
		XtWidgetGeometry *	preferred
	)			[static]

Definition at line 667 of file Tree.c.

References TreePart::maxheight, TreePart::maxwidth, and _TreeRec::tree.

{
    TreeWidget tw = (TreeWidget) w;

    preferred->request_mode = (CWWidth | CWHeight);
    preferred->width = tw->tree.maxwidth;
    preferred->height = tw->tree.maxheight;

    if (((intended->request_mode & (CWWidth | CWHeight)) ==
         (CWWidth | CWHeight)) &&
        intended->width == preferred->width &&
        intended->height == preferred->height)
      return XtGeometryYes;
    else if (preferred->width == w->core.width &&
             preferred->height == w->core.height)
      return XtGeometryNo;
    else
      return XtGeometryAlmost;
}

static XtGeometryResult QueryGeometry

(

)

[static]

static void Redisplay	(	Widget	gw,
		XEvent *	event,
		Region	region
	)			[static]

Definition at line 570 of file Tree.c.

References _TreeRec::composite, _TreeRec::core, dpy, TreePart::gc, gc, TreePart::gravity, i, j, _TreeRec::tree, TREE_CONSTRAINT, TreePart::tree_root, and w.

{
    TreeWidget tw = (TreeWidget) gw;

    /*
     * If the Tree widget is visible, visit each managed child.
     */
    if (tw->core.visible) {
        int i, j;
        Display *dpy = XtDisplay (tw);
        Window w = XtWindow (tw);

        for (i = 0; i < tw->composite.num_children; i++) {
            Widget child = tw->composite.children[i];
            TreeConstraints tc = TREE_CONSTRAINT(child);

            /*
             * Don't draw lines from the fake tree_root.
             */
            if (child != tw->tree.tree_root && tc->tree.n_children) {
                int srcx = child->core.x + child->core.border_width;
                int srcy = child->core.y + child->core.border_width;

                switch (tw->tree.gravity) {
                  case WestGravity:
                    srcx += child->core.width + child->core.border_width;
                    /* fall through */
                  case EastGravity:
                    srcy += child->core.height / 2;
                    break;

                  case NorthGravity:
                    srcy += child->core.height + child->core.border_width;
                    /* fall through */
                  case SouthGravity:
                    srcx += child->core.width / 2;
                    break;
                }

                for (j = 0; j < tc->tree.n_children; j++) {
                    Widget k = tc->tree.children[j];
                    GC gc = (tc->tree.gc ? tc->tree.gc : tw->tree.gc);

                    switch (tw->tree.gravity) {
                      case WestGravity:
                        /*
                         * right center to left center
                         */
                        XDrawLine (dpy, w, gc, srcx, srcy,
                                   (int) k->core.x,
                                   (k->core.y + ((int) k->core.border_width) +
                                    ((int) k->core.height) / 2));
                        break;

                      case NorthGravity:
                        /*
                         * bottom center to top center
                         */
                        XDrawLine (dpy, w, gc, srcx, srcy,
                                   (k->core.x + ((int) k->core.border_width) +
                                    ((int) k->core.width) / 2),
                                   (int) k->core.y);
                        break;

                      case EastGravity:
                        /*
                         * left center to right center
                         */
                        XDrawLine (dpy, w, gc, srcx, srcy,
                                   (k->core.x +
                                    (((int) k->core.border_width) << 1) +
                                    (int) k->core.width),
                                   (k->core.y + ((int) k->core.border_width) +
                                    ((int) k->core.height) / 2));
                        break;

                      case SouthGravity:
                        /*
                         * top center to bottom center
                         */
                        XDrawLine (dpy, w, gc, srcx, srcy,
                                   (k->core.x + ((int) k->core.border_width) +
                                    ((int) k->core.width) / 2),
                                   (k->core.y +
                                    (((int) k->core.border_width) << 1) +
                                    (int) k->core.height));
                        break;
                    }
                }
            }
        }
    }
}

static void Redisplay

(

)

[static]

static void set_positions	(	TreeWidget	tw,
		Widget	w,
		int	level
	)			[static]

Definition at line 774 of file Tree.c.

References _TreeConstraintsPart::children, i, _TreeConstraintsPart::n_children, _TreeConstraintsRec::tree, TREE_CONSTRAINT, _TreeConstraintsPart::x, and _TreeConstraintsPart::y.

Referenced by layout_tree().

{
    int i;
  
    if (w) {
        TreeConstraints tc = TREE_CONSTRAINT(w);

        if (level > 0) {
            /*
             * mirror if necessary
             */
            switch (tw->tree.gravity) {
              case EastGravity:
                tc->tree.x = (((Position) tw->tree.maxwidth) -
                              ((Position) w->core.width) - tc->tree.x);
                break;

              case SouthGravity:
                tc->tree.y = (((Position) tw->tree.maxheight) -
                              ((Position) w->core.height) - tc->tree.y);
                break;
            }

            /*
             * Move the widget into position.
             */
            XtMoveWidget (w, tc->tree.x, tc->tree.y);
        }

        /*
         * Set the positions of all children.
         */
        for (i = 0; i < tc->tree.n_children; i++)
          set_positions (tw, tc->tree.children[i], level + 1);
    }
}

Here is the caller graph for this function:

static void set_tree_size	(	TreeWidget	tw,
		Boolean	insetvalues,
		Dimension	width,
		Dimension	height
	)			[static]

Definition at line 922 of file Tree.c.

References NULL, and result.

Referenced by layout_tree().

{
    if (insetvalues) {
        tw->core.width = width;
        tw->core.height = height;
    } else {
        Dimension replyWidth = 0, replyHeight = 0;
        XtGeometryResult result = XtMakeResizeRequest ((Widget) tw,
                                                       width, height,
                                                       &replyWidth,
                                                       &replyHeight);
        /*
         * Accept any compromise.
         */
        if (result == XtGeometryAlmost)
          XtMakeResizeRequest ((Widget) tw, replyWidth, replyHeight,
                               (Dimension *) NULL, (Dimension *) NULL);
    }
    return;
}

Here is the caller graph for this function:

static Boolean SetValues	(	Widget	gcurrent,
		Widget	grequest,
		Widget	gnew,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 416 of file Tree.c.

References check_gravity(), _TreeRec::core, FALSE, TreePart::foreground, get_tree_gc(), TreePart::gravity, TreePart::hpad, IsHorizontal, layout_tree(), TreePart::line_width, _TreeRec::tree, TRUE, and TreePart::vpad.

{
    TreeWidget current = (TreeWidget) gcurrent, new = (TreeWidget) gnew;
    Boolean redraw = FALSE;

    /*
     * If the foreground color has changed, redo the GC's
     * and indicate a redraw.
     */
    if (new->tree.foreground != current->tree.foreground ||
        new->core.background_pixel != current->core.background_pixel ||
        new->tree.line_width != current->tree.line_width) {
        XtReleaseGC (gnew, new->tree.gc);
        new->tree.gc = get_tree_gc (new);
        redraw = TRUE;     
    }

    /*
     * If the minimum spacing has changed, recalculate the
     * tree layout. layout_tree() does a redraw, so we don't
     * need SetValues to do another one.
     */
    if (new->tree.gravity != current->tree.gravity) {
        check_gravity (new, current->tree.gravity);
    }

    if (IsHorizontal(new) != IsHorizontal(current)) {
        if (new->tree.vpad == current->tree.vpad &&
            new->tree.hpad == current->tree.hpad) {
            new->tree.vpad = current->tree.hpad;
            new->tree.hpad = current->tree.vpad;
        }
    }

    if (new->tree.vpad != current->tree.vpad ||
        new->tree.hpad != current->tree.hpad ||
        new->tree.gravity != current->tree.gravity) {
        layout_tree (new, TRUE);
        redraw = FALSE;
    }
    return redraw;
}

Here is the call graph for this function:

static Boolean SetValues

(

)

[static]

void XawTreeForceLayout

(

Widget

tree

)

Definition at line 1002 of file Tree.c.

References FALSE, and layout_tree().

{
    layout_tree ((TreeWidget) tree, FALSE);
}

Here is the call graph for this function:

---

Variable Documentation

XtResource resources[] [static]

Initial value:

 {
    { XtNautoReconfigure, XtCAutoReconfigure, XtRBoolean, sizeof (Boolean),
        XtOffsetOf(TreeRec, tree.auto_reconfigure), XtRImmediate,
        (XtPointer) FALSE },
    { XtNhSpace, XtCHSpace, XtRDimension, sizeof (Dimension),
        XtOffsetOf(TreeRec, tree.hpad), XtRImmediate, (XtPointer) 0 },
    { XtNvSpace, XtCVSpace, XtRDimension, sizeof (Dimension),
        XtOffsetOf(TreeRec, tree.vpad), XtRImmediate, (XtPointer) 0 },
    { XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
        XtOffsetOf(TreeRec, tree.foreground), XtRString,
        XtDefaultForeground},
    { XtNlineWidth, XtCLineWidth, XtRDimension, sizeof (Dimension),
        XtOffsetOf(TreeRec, tree.line_width), XtRImmediate, (XtPointer) 0 },
    { XtNgravity, XtCGravity, XtRGravity, sizeof (XtGravity),
        XtOffsetOf(TreeRec, tree.gravity), XtRImmediate,
        (XtPointer) WestGravity },
}

Definition at line 85 of file Tree.c.

TreeClassRec treeClassRec

Definition at line 115 of file Tree.c.

XtResource treeConstraintResources[] [static]

Initial value:

 {
    { XtNtreeParent, XtCTreeParent, XtRWidget, sizeof (Widget),
        XtOffsetOf(TreeConstraintsRec, tree.parent), XtRImmediate, NULL },
    { XtNtreeGC, XtCTreeGC, XtRGC, sizeof(GC),
        XtOffsetOf(TreeConstraintsRec, tree.gc), XtRImmediate, NULL },
}

Definition at line 107 of file Tree.c.

WidgetClass treeWidgetClass = (WidgetClass) &treeClassRec

Definition at line 175 of file Tree.c.

---