home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume8 / dtree / part02 < prev    next >
Text File  |  1990-08-15  |  28KB  |  863 lines
  1. Path: uunet!decwrl!apple!sun-barr!newstop!sun!hpkronos.hpl.hp.com
  2. From: kk@hpkronos.hpl.hp.com (Konstantinos Konstantinides)
  3. Newsgroups: comp.sources.x
  4. Subject: v08i073: dtree, Part02/02
  5. Message-ID: <140747@sun.Eng.Sun.COM>
  6. Date: 16 Aug 90 03:04:43 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 852
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: Konstantinos Konstantinides <kk@hpkronos.hpl.hp.com>
  12. Posting-number: Volume 8, Issue 73
  13. Archive-name: dtree/part02
  14.  
  15. # This is a shell archive.  Remove anything before this line,
  16. # then unpack it by saving it in a file and typing "sh file".
  17. #
  18. # Wrapped by Konstantinos Konstantinides <kk@hpkronos> on Tue Aug 14 15:06:51 1990
  19. #
  20. # This archive contains:
  21. #    Tree.c    Tree.h    TreeP.h    
  22. #
  23.  
  24. LANG=""; export LANG
  25. PATH=/bin:/usr/bin:$PATH; export PATH
  26.  
  27. echo x - Tree.c
  28. cat >Tree.c <<'@EOF'
  29. /**********************************************************************************
  30.   * Tree.c: The Tree Widget Source File
  31.   *         From:
  32.   *                   The X Window System, 
  33.   *            Programming and Applications with Xt
  34.   *                   OSF/Motif Edition
  35.   *         by
  36.   *                Douglas Young
  37.   *              Prentice Hall, 1990
  38.   *
  39.   *                 Example described on pages: 397-419
  40.   *
  41.   *
  42.   *  Copyright 1989 by Prentice Hall
  43.   *  All Rights Reserved
  44.   *
  45.   * This code is based on the OSF/Motif widget set and the X Window System
  46.   *
  47.   * Permission to use, copy, modify, and distribute this software for 
  48.   * any purpose and without fee is hereby granted, provided that the above
  49.   * copyright notice appear in all copies and that both the copyright notice
  50.   * and this permission notice appear in supporting documentation.
  51.   *
  52.   * Prentice Hall and the author disclaim all warranties with regard to 
  53.   * this software, including all implied warranties of merchantability and fitness.
  54.   * In no event shall Prentice Hall or the author be liable for any special,
  55.   * indirect or cosequential damages or any damages whatsoever resulting from 
  56.   * loss of use, data or profits, whether in an action of contract, negligence 
  57.   * or other tortious action, arising out of or in connection with the use 
  58.   * or performance of this software.
  59.   *
  60.   * Open Software Foundation is a trademark of The Open Software Foundation, Inc.
  61.   * OSF is a trademark of Open Software Foundation, Inc.
  62.   * OSF/Motif is a trademark of Open Software Foundation, Inc.
  63.   * Motif is a trademark of Open Software Foundation, Inc.
  64.   * DEC is a registered trademark of Digital Equipment Corporation
  65.   * HP is a registered trademark of the Hewlett Packard Company
  66.   * DIGITAL is a registered trademark of Digital Equipment Corporation
  67.   * X Window System is a trademark of the Massachusetts Institute of Technology
  68.   **********************************************************************************/
  69.  
  70.  
  71. #include      <X11/Intrinsic.h>
  72. #include      <X11/IntrinsicP.h>
  73. #include      <X11/StringDefs.h>
  74. #include      <X11/CoreP.h>
  75. #include      <X11/CompositeP.h>
  76. #include      <X11/ConstrainP.h>
  77. #include      "Tree.h"
  78. #include      "TreeP.h"
  79. #define   MAX(a,b) ((a) > (b) ? (a) : (b))
  80.  
  81. static void             Initialize();
  82. static void             ConstraintInitialize();
  83. static void             ConstraintDestroy();
  84. static Boolean          ConstraintSetValues();
  85. static Boolean          SetValues();
  86. static XtGeometryResult GeometryManager();
  87. static void             ChangeManaged();
  88. static void             insert_new_node();
  89. static void             delete_node();
  90. static void             new_layout();
  91. static void             Redisplay();
  92. static TreeOffsetPtr    create_offset();
  93. static int              compute_positions();
  94. static void             shift_subtree();
  95. static void             set_positions();
  96. static void             reset();
  97. static Position         current_position();
  98. static void             set_current_position();
  99. static Position         sum_of_positions();
  100.  
  101. static XtResource resources[] = {
  102.  {XtNhorizontalSpace,XtCSpace,XtRDimension,sizeof(Dimension),
  103.    XtOffset(XsTreeWidget, tree.h_min_space), XtRString,"15" },
  104.  {XtNverticalSpace,XtCSpace, XtRDimension,sizeof (Dimension),
  105.    XtOffset(XsTreeWidget, tree.v_min_space), XtRString,"5"  },
  106.  {XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
  107.   XtOffset(XsTreeWidget, tree.foreground), XtRString,"Black"},
  108. };
  109.  
  110. static XtResource treeConstraintResources[] = {
  111.  {XtNsuperNode, XtCSuperNode, XtRPointer, sizeof(Widget),
  112.    XtOffset(TreeConstraints, tree.super_node),
  113.    XtRPointer, NULL},
  114. };
  115.  
  116. XsTreeClassRec XstreeClassRec = {
  117.   {
  118.     /* core_class fields  */
  119.     (WidgetClass) &constraintClassRec,/* superclass         */
  120.     "Tree",                           /* class_name         */
  121.     sizeof(XsTreeRec),                /* widget_size        */
  122.     NULL,                             /* class_init         */
  123.     NULL,                             /* class_part_init    */
  124.     FALSE,                            /* class_inited       */    
  125.     Initialize,                       /* initialize         */
  126.     NULL,                             /* initialize_hook    */    
  127.     XtInheritRealize,                 /* realize            */
  128.     NULL,                             /* actions            */
  129.     0,                                /* num_actions        */    
  130.     resources,                        /* resources          */
  131.     XtNumber(resources),              /* num_resources      */
  132.     NULLQUARK,                        /* xrm_class          */
  133.     TRUE,                             /* compress_motion    */    
  134.     TRUE,                             /* compress_exposure  */    
  135.     TRUE,                             /* compress_enterleave*/    
  136.     TRUE,                             /* visible_interest   */
  137.     NULL,                             /* destroy            */
  138.     NULL,                             /* resize             */
  139.     Redisplay,                        /* expose             */
  140.     SetValues,                        /* set_values         */
  141.     NULL,                             /* set_values_hook    */    
  142.     XtInheritSetValuesAlmost,         /* set_values_almost  */
  143.     NULL,                             /* get_values_hook    */    
  144.     NULL,                             /* accept_focus       */
  145.     XtVersion,                        /* version            */    
  146.     NULL,                             /* callback_private   */
  147.     NULL,                             /* tm_table           */
  148.     NULL,                             /* query_geometry     */    
  149.     NULL,                             /* display_accelerator*/
  150.     NULL,                             /* extension          */
  151.   },
  152.   {
  153.     /* composite_class fields */
  154.     GeometryManager,                 /* geometry_manager    */
  155.     ChangeManaged,                   /* change_managed      */
  156.     XtInheritInsertChild,            /* insert_child        */    
  157.     XtInheritDeleteChild,            /* delete_child        */    
  158.     NULL,                            /* extension           */
  159.   },
  160.   { 
  161.     /* constraint_class fields */
  162.    treeConstraintResources,          /* subresources        */
  163.    XtNumber(treeConstraintResources),/* subresource_count   */
  164.    sizeof(TreeConstraintsRec),       /* constraint_size     */
  165.    ConstraintInitialize,             /* initialize          */
  166.    ConstraintDestroy,                /* destroy             */
  167.    ConstraintSetValues,              /* set_values          */
  168.    NULL,                             /* extension           */
  169.    },
  170.   {
  171.     /* Tree class fields */
  172.     0,                               /* ignore              */    
  173.   }
  174. };
  175.  
  176. WidgetClass XstreeWidgetClass = (WidgetClass) &XstreeClassRec;
  177.  
  178. static void Initialize(request, new)
  179.     XsTreeWidget request, new;
  180. {
  181.   Arg       wargs[2];
  182.   XGCValues values;
  183.   XtGCMask  valueMask;
  184.   /*
  185.    * Make sure the widget's width and height are 
  186.    * greater than zero.
  187.    */
  188.   if (request->core.width <= 0)
  189.     new->core.width = 5;
  190.   if (request->core.height <= 0)
  191.     new->core.height = 5;
  192.   /*
  193.    * Create a graphics context for the connecting lines.
  194.    */
  195.   valueMask = GCForeground | GCBackground;
  196.   values.foreground = new->tree.foreground;
  197.   values.background = new->core.background_pixel;
  198.   new->tree.gc = XtGetGC (new, valueMask, &values);  
  199.   /*
  200.    * Create the hidden root widget.
  201.    */
  202.   new->tree.tree_root = (Widget) NULL;
  203.   XtSetArg(wargs[0], XtNwidth, 1);
  204.   XtSetArg(wargs[1], XtNheight, 1);
  205.   new->tree.tree_root = 
  206.           XtCreateWidget("root", widgetClass, new, wargs, 2);
  207.   /*
  208.    * Allocate the tables used by the layout
  209.    * algorithm.
  210.    */
  211.   new->tree.horizontal = create_offset(10);
  212.   new->tree.vertical   = create_offset(10);
  213. } 
  214.  
  215. static void ConstraintInitialize(request, new)
  216.      Widget request, new;
  217. {
  218.   TreeConstraints tree_const = TREE_CONSTRAINT(new);
  219.   XsTreeWidget tw = (XsTreeWidget) new->core.parent;
  220.   /*
  221.    * Initialize the widget to have no sub-nodes.
  222.    */
  223.   tree_const->tree.n_sub_nodes = 0;
  224.   tree_const->tree.max_sub_nodes = 0;
  225.   tree_const->tree.sub_nodes = (WidgetList) NULL;
  226.   tree_const->tree.x = tree_const->tree.y = 0; 
  227.   /*
  228.    * If this widget has a super-node, add it to that 
  229.    * widget' sub-nodes list. Otherwise make it a sub-node of 
  230.    * the tree_root widget.
  231.    */
  232.   if(tree_const->tree.super_node)
  233.     insert_new_node(tree_const->tree.super_node, new);
  234.   else
  235.     if(tw->tree.tree_root)
  236.       insert_new_node(tw->tree.tree_root, new);
  237. } 
  238.  
  239. static Boolean SetValues(current, request, new)
  240.     XsTreeWidget current, request, new;
  241. {
  242.  int       redraw = FALSE;
  243.  XGCValues values;
  244.  XtGCMask  valueMask;
  245.  /*
  246.   * If the foreground color has changed, redo the GC's
  247.   * and indicate a redraw.
  248.   */
  249.  if (new->tree.foreground != current->tree.foreground ||
  250.      new->core.background_pixel !=
  251.                            current->core.background_pixel){
  252.    valueMask         = GCForeground | GCBackground;
  253.    values.foreground = new->tree.foreground;
  254.    values.background = new->core.background_pixel;
  255.    XtReleaseGC(new, new->tree.gc);
  256.    new->tree.gc    = XtGetGC (new, valueMask, &values);   
  257.    redraw = TRUE;     
  258.  }
  259.  /*
  260.   * If the minimum spacing has changed, recalculate the
  261.   * tree layout. new_layout() does a redraw, so we don't
  262.   * need SetValues to do another one.
  263.   */
  264.  if (new->tree.v_min_space != current->tree.v_min_space ||
  265.      new->tree.h_min_space != current->tree.h_min_space){ 
  266.    new_layout(new);
  267.    redraw = FALSE;
  268.  }
  269.  return (redraw);
  270. }
  271.  
  272. static Boolean ConstraintSetValues(current, request, new)
  273.     Widget current, request, new;
  274. {
  275.  TreeConstraints newconst = TREE_CONSTRAINT(new);
  276.  TreeConstraints current_const = TREE_CONSTRAINT(current);
  277.  XsTreeWidget tw = (XsTreeWidget) new->core.parent;
  278.  /*
  279.   * If the super_node field has changed, remove the widget
  280.   * from the old widget's sub_nodes list and add it to the
  281.   * new one.
  282.   */
  283.  if(current_const->tree.super_node !=
  284.                                   newconst->tree.super_node){
  285.    if(current_const->tree.super_node)
  286.      delete_node(current_const->tree.super_node, new);
  287.    if(newconst->tree.super_node)
  288.      insert_new_node(newconst->tree.super_node, new);
  289.    /*
  290.     * If the Tree widget has been realized, 
  291.     * compute new layout.
  292.     */
  293.    if(XtIsRealized(tw))
  294.      new_layout(tw);
  295.   }               
  296.   return (False);
  297. }
  298.  
  299. static void insert_new_node(super_node, node)
  300.      Widget super_node, node;
  301. {
  302.   TreeConstraints super_const = TREE_CONSTRAINT(super_node);
  303.   TreeConstraints node_const = TREE_CONSTRAINT(node);
  304.   int index = super_const->tree.n_sub_nodes;
  305.   
  306.   node_const->tree.super_node = super_node;
  307.   /*
  308.    * If there is no more room in the sub_nodes array, 
  309.    * allocate additional space.
  310.    */  
  311.   if(super_const->tree.n_sub_nodes ==
  312.                              super_const->tree.max_sub_nodes){
  313.     super_const->tree.max_sub_nodes += 
  314.                     (super_const->tree.max_sub_nodes / 2) + 2;
  315.     super_const->tree.sub_nodes = 
  316.      (WidgetList) XtRealloc(super_const->tree.sub_nodes, 
  317.                            (super_const->tree.max_sub_nodes) *
  318.                             sizeof(Widget));
  319.   } 
  320.   /*
  321.    * Add the sub_node in the next available slot and 
  322.    * increment the counter.
  323.    */
  324.   super_const->tree.sub_nodes[index] = node;
  325.   super_const->tree.n_sub_nodes++;
  326. }
  327.  
  328. static void delete_node(super_node, node)
  329.     Widget  super_node, node;
  330. {
  331.   TreeConstraints node_const = TREE_CONSTRAINT(node);
  332.   TreeConstraints super_const;
  333.   int             pos, i;
  334.   /*
  335.    * Make sure the super_node exists.
  336.    */
  337.   if(!super_node) return;  
  338.   
  339.   super_const = TREE_CONSTRAINT(super_node);
  340.   /*
  341.    * Find the sub_node on its super_node's list.
  342.    */
  343.   for (pos = 0; pos < super_const->tree.n_sub_nodes; pos++)
  344.     if (super_const->tree.sub_nodes[pos] == node)
  345.       break;
  346.   if (pos == super_const->tree.n_sub_nodes) return;
  347.   /*
  348.    * Decrement the number of sub_nodes
  349.    */  
  350.   super_const->tree.n_sub_nodes--;
  351.   /*
  352.    * Fill in the gap left by the sub_node.
  353.    * Zero the last slot for good luck.
  354.    */
  355.   for (i = pos; i < super_const->tree.n_sub_nodes; i++) 
  356.     super_const->tree.sub_nodes[i] = 
  357.                             super_const->tree.sub_nodes[i+1];
  358.  super_const->tree.sub_nodes[super_const->tree.n_sub_nodes]=0;
  359. }
  360.  
  361. static void ConstraintDestroy(w) 
  362. #ifdef JUST_LIKE_BOOK  /* Unimportant but perhaps confusing */
  363.      XsTreeWidget w;
  364. #else
  365.      Widget w;
  366. #endif
  367. { 
  368.   TreeConstraints tree_const = TREE_CONSTRAINT(w);
  369.   int i;
  370.  /* 
  371.   * Remove the widget from its parent's sub-nodes list and
  372.   * make all this widget's sub-nodes sub-nodes of the parent.
  373.   */
  374.   if(tree_const->tree.super_node) { 
  375.     delete_node(tree_const->tree.super_node, w);
  376.     for(i=0;i< tree_const->tree.n_sub_nodes; i++)
  377.       insert_new_node(tree_const->tree.super_node, 
  378.                       tree_const->tree.sub_nodes[i]);
  379.   }
  380.   new_layout(w->core.parent);
  381. }
  382.  
  383. static XtGeometryResult GeometryManager(w, request, reply)
  384.     Widget               w;
  385.     XtWidgetGeometry    *request;
  386.     XtWidgetGeometry    *reply;
  387. {
  388.  
  389.  XsTreeWidget tw = (XsTreeWidget) w->core.parent;
  390.  /*
  391.   * No position changes allowed!.
  392.   */
  393.  if ((request->request_mode & CWX && request->x!=w->core.x)
  394.      ||(request->request_mode & CWY && request->y!=w->core.y))
  395.   return (XtGeometryNo);
  396.  /*
  397.   * Allow all resize requests.
  398.   */
  399.  if (request->request_mode & CWWidth)
  400.    w->core.width = request->width;
  401.  if (request->request_mode & CWHeight)
  402.    w->core.height = request->height;
  403.  if (request->request_mode & CWBorderWidth)
  404.    w->core.border_width = request->border_width;
  405.  /*
  406.   *  Compute the new layout based on the new widget sizes;
  407.   */
  408.  new_layout(tw);
  409.  return (XtGeometryYes);
  410. }
  411.  
  412. static void ChangeManaged(tw)
  413.     XsTreeWidget tw;
  414. {
  415.   new_layout(tw);
  416. }
  417.  
  418.  
  419. static void Redisplay (w, event, region)
  420.      XsTreeWidget   w;
  421.      XEvent        *event;
  422.      Region         region;
  423. {
  424.   int              i, j;
  425.   TreeConstraints tree_const;
  426.   Widget          child;
  427.   /*
  428.    * If the Tree widget is visible, visit each managed child.
  429.    */
  430.   if(w->core.visible)
  431.    for (i = 0; i < w -> composite.num_children; i++){
  432.      child = w -> composite.children[i];
  433.      tree_const = TREE_CONSTRAINT(child);
  434.      /*
  435.       * Draw a line between the right edge of each widget
  436.       * and the left edge of each of its sub_nodes. Don't
  437.       * draw lines from the fake tree_root.
  438.       */
  439.      if(child != w->tree.tree_root && 
  440.         tree_const->tree.n_sub_nodes)
  441.        for (j = 0; j < tree_const->tree.n_sub_nodes; j++)
  442.          XDrawLine(XtDisplay(w), XtWindow(w), 
  443.                    w->tree.gc,
  444.                    child->core.x + child->core.width, 
  445.                    child->core.y + child->core.height / 2,
  446.                    tree_const->tree.sub_nodes[j]->core.x,
  447.                    tree_const->tree.sub_nodes[j]->core.y + 
  448.                 tree_const->tree.sub_nodes[j]->core.height/2);
  449.     }
  450. }
  451.  
  452. static void new_layout(tw)
  453.      XsTreeWidget   tw;
  454. {
  455.   /*
  456.    *  Reset the auxiliary tables.
  457.    */
  458.   reset(tw->tree.vertical);
  459.   reset(tw->tree.horizontal);
  460.   /*
  461.    * Compute each widget's x,y position
  462.    */
  463.   compute_positions(tw, tw->tree.tree_root, 0);
  464.   /*
  465.    * Move each widget into place.
  466.    */
  467.   set_positions(tw, tw->tree.tree_root, 0, 0);
  468.   /*
  469.    * Trigger a redisplay of the lines connecting nodes.
  470.    */
  471.   if(XtIsRealized(tw))
  472.     XClearArea(XtDisplay(tw), XtWindow(tw), 0, 0, 0, 0, TRUE);
  473. }
  474.  
  475.  static int compute_positions(tw, w, level)
  476.      XsTreeWidget tw;
  477.      Widget       w;
  478.      long         level;
  479. {
  480.  Position       current_hpos, current_vpos;
  481.  int             i, depth = 0;
  482.  TreeConstraints tree_const = TREE_CONSTRAINT(w);
  483.  /*
  484.   * Get the current positions for this level.
  485.   */
  486.  current_hpos = current_position(tw->tree.horizontal, level);
  487.  current_vpos = current_position(tw->tree.vertical, level);
  488.  /*
  489.   * Set the current horizontal width to the max widths of all
  490.   * widgets at this level.
  491.   */
  492.  set_current_position(tw->tree.horizontal, level, 
  493.                       MAX(current_hpos, w->core.width));
  494.  /*
  495.   * If the node has no sub_nodes, just set the vertical 
  496.   * position to the next available space.
  497.   */
  498.  if(tree_const->tree.n_sub_nodes == 0){
  499.    tree_const->tree.y = current_vpos;
  500.  }
  501.  else {
  502.    Widget          first_kid, last_kid;
  503.    TreeConstraints const1, const2;
  504.    Position        top, bottom;
  505.   /*
  506.    * If the node has sub_nodes, recursively figure the 
  507.    * positions of each sub_node.
  508.    */
  509.    for(i = 0; i < tree_const->tree.n_sub_nodes; i++)
  510.     depth = compute_positions(tw, 
  511.                               tree_const->tree.sub_nodes[i],
  512.                               level + 1);
  513.   /*
  514.    * Now that the vertical positions of all children are 
  515.    * known, find the vertical extent of all sub_nodes.
  516.    */
  517.   first_kid= tree_const->tree.sub_nodes[0];
  518.   last_kid = 
  519.    tree_const->tree.sub_nodes[tree_const->tree.n_sub_nodes-1];
  520.   const1   = TREE_CONSTRAINT(first_kid);
  521.   const2   = TREE_CONSTRAINT(last_kid);
  522.   top      = const1->tree.y + first_kid->core.height / 2; 
  523.   bottom   = const2->tree.y + last_kid->core.height / 2;
  524.   /*
  525.    * Set the node's position to the center of its sub_nodes.
  526.    */
  527.   tree_const->tree.y = (top + bottom)/2 - (w->core.height/ 2);
  528.   /*
  529.    * If this position is less than the next available 
  530.    * position, correct it to be the next available
  531.    * position, calculate the amount by which all sub_nodes
  532.    * must be shifted, and shift the entire sub-tree.
  533.    */
  534.    if(tree_const->tree.y < current_vpos){
  535.      Dimension offset = current_vpos - tree_const->tree.y;
  536.      for(i = 0; i < tree_const->tree.n_sub_nodes; i++)
  537.        shift_subtree(tree_const->tree.sub_nodes[i], offset);
  538.     /*
  539.      * Adjust the next available space at all levels below
  540.      * the current level.
  541.      */
  542.      for(i = level + 1; i <= depth; i++){
  543.        Position pos = current_position(tw->tree.vertical, i);
  544.        set_current_position(tw->tree.vertical, i, pos+offset);
  545.      }
  546.      tree_const->tree.y = current_vpos;
  547.      }
  548.    }
  549.  /*
  550.   * Record the current vertical position at this level.
  551.   */
  552.   set_current_position(tw->tree.vertical, level,
  553.                        tw->tree.v_min_space + 
  554.                        tree_const->tree.y + w->core.height);
  555.   return (MAX(depth, level));
  556. }
  557.  
  558. static void shift_subtree(w, offset)
  559.      Widget     w;
  560.      Dimension  offset;
  561. {
  562.   int             i;
  563.   TreeConstraints tree_const = TREE_CONSTRAINT(w);
  564.   /*
  565.    * Shift the node by the offset.
  566.    */
  567.   tree_const->tree.y += offset; 
  568.   /*
  569.    * Shift each sub-node into place.
  570.    */
  571.   for(i=0; i< tree_const->tree.n_sub_nodes; i++)
  572.     shift_subtree(tree_const->tree.sub_nodes[i], offset);
  573. }
  574.  
  575. static void set_positions(tw, w, level)
  576.      XsTreeWidget tw;
  577.      Widget       w;
  578.      int          level;
  579. {
  580.  int               i;
  581.  Dimension         replyWidth = 0, replyHeight = 0;
  582.  XtGeometryResult  result;
  583.   
  584.  if(w){
  585.   TreeConstraints tree_const = TREE_CONSTRAINT(w);
  586.  /*
  587.   * Add up the sum of the width's of all nodes to this 
  588.   * depth, and use it as the x position.
  589.   */
  590.   tree_const->tree.x = (level * tw->tree.h_min_space) + 
  591.                 sum_of_positions(tw->tree.horizontal, level);
  592.  /*
  593.   * Move the widget into position.
  594.   */
  595.   XtMoveWidget (w, tree_const->tree.x, tree_const->tree.y);
  596.  /*
  597.   * If the widget position plus its width or height doesn't
  598.   * fit in the tree, ask if the tree can be resized.
  599.   */
  600.   if(tw->core.width < tree_const->tree.x + w->core.width ||
  601.      tw->core.height < tree_const->tree.y + w->core.height){
  602.     result = 
  603.       XtMakeResizeRequest(tw, MAX(tw->core.width, 
  604.                                   tree_const->tree.x + 
  605.                                   w->core.width),
  606.                               MAX(tw->core.height, 
  607.                                   tree_const->tree.y + 
  608.                                   w->core.height),
  609.                           &replyWidth, &replyHeight);
  610.     /*
  611.      * Accept any compromise.
  612.      */
  613.      if (result == XtGeometryAlmost)
  614.        XtMakeResizeRequest (tw, replyWidth, replyHeight, 
  615.                              NULL, NULL);
  616.   }
  617.  /*
  618.   * Set the positions of all sub_nodes.
  619.   */
  620.   for(i=0; i< tree_const->tree.n_sub_nodes;i++)
  621.     set_positions(tw, tree_const->tree.sub_nodes[i], level+1);
  622.   }
  623. }
  624.  
  625. static TreeOffsetPtr create_offset(size)
  626.    long size;
  627. {
  628.  TreeOffsetPtr  offset = 
  629.                  (TreeOffsetPtr) XtMalloc(sizeof(TreeOffset));
  630.  offset->size = size;
  631.  offset->array = 
  632.              (Dimension *) XtMalloc(size * sizeof(Dimension));
  633.  return (offset);
  634. }
  635.  
  636. static void reset(offset)
  637.    TreeOffsetPtr offset;
  638. {
  639.   long i;
  640.   for(i=0; i< offset->size; i++)
  641.     offset->array[i] = 0;
  642. }
  643.  
  644. static Position current_position(offset, position)
  645.    TreeOffsetPtr  offset;
  646.    long          position;
  647. {
  648.   if(position >= offset->size)
  649.     return (0);
  650.   return (offset->array[position]);
  651.  }
  652.  
  653. static void set_current_position(offset, index, value)
  654.    TreeOffsetPtr offset;
  655.    int           index;
  656.    Dimension     value;
  657. {
  658.  if(index >= offset->size){
  659.    offset->size = index + index / 2;
  660.    offset->array =
  661.     (Dimension *) XtRealloc(offset->array, 
  662.                             offset->size * sizeof(Dimension));
  663.  }
  664.  offset->array[index] = value;
  665. }
  666.  
  667. static Position sum_of_positions(offset, index)
  668.    TreeOffsetPtr  offset;
  669.    long           index;
  670. {
  671.   int    i;
  672.   Position  sum  = 0;
  673.   long      stop = index;
  674.   if(index > offset->size) 
  675.     stop = offset->size;
  676.   for (i=0;i < stop; i++)
  677.     sum += offset->array[i];
  678.   return (sum);
  679. }
  680.  
  681. @EOF
  682.  
  683. chmod 644 Tree.c
  684.  
  685. echo x - Tree.h
  686. cat >Tree.h <<'@EOF'
  687. /**********************************************************************************
  688.  * Tree.h: Public header file for the Tree widget
  689.   *         From:
  690.   *                   The X Window System, 
  691.   *            Programming and Applications with Xt
  692.   *                   OSF/Motif Edition
  693.   *         by
  694.   *                Douglas Young
  695.   *              Prentice Hall, 1990
  696.   *
  697.   *                 Example described on pages: 397-419
  698.   *
  699.   *
  700.   *  Copyright 1989 by Prentice Hall
  701.   *  All Rights Reserved
  702.   *
  703.   * This code is based on the OSF/Motif widget set and the X Window System
  704.   *
  705.   * Permission to use, copy, modify, and distribute this software for 
  706.   * any purpose and without fee is hereby granted, provided that the above
  707.   * copyright notice appear in all copies and that both the copyright notice
  708.   * and this permission notice appear in supporting documentation.
  709.   *
  710.   * Prentice Hall and the author disclaim all warranties with regard to 
  711.   * this software, including all implied warranties of merchantability and fitness.
  712.   * In no event shall Prentice Hall or the author be liable for any special,
  713.   * indirect or cosequential damages or any damages whatsoever resulting from 
  714.   * loss of use, data or profits, whether in an action of contract, negligence 
  715.   * or other tortious action, arising out of or in connection with the use 
  716.   * or performance of this software.
  717.   *
  718.   * Open Software Foundation is a trademark of The Open Software Foundation, Inc.
  719.   * OSF is a trademark of Open Software Foundation, Inc.
  720.   * OSF/Motif is a trademark of Open Software Foundation, Inc.
  721.   * Motif is a trademark of Open Software Foundation, Inc.
  722.   * DEC is a registered trademark of Digital Equipment Corporation
  723.   * HP is a registered trademark of the Hewlett Packard Company
  724.   * DIGITAL is a registered trademark of Digital Equipment Corporation
  725.   * X Window System is a trademark of the Massachusetts Institute of Technology
  726.   **********************************************************************************/
  727.  
  728.  
  729.  
  730. #ifndef TREE_H
  731. #define TREE_H
  732.  
  733. extern WidgetClass  XstreeWidgetClass;
  734.  
  735. typedef struct _XsTreeClassRec *XsTreeWidgetClass;
  736. typedef struct _XsTreeRec      *XsTreeWidget;
  737.  
  738. #define XtNhorizontalSpace    "horizontalSpace"
  739. #define XtNverticalSpace      "verticalSpace"
  740. #define XtCPad                "Pad"
  741. #define XtNsuperNode          "superNode"
  742. #define XtCSuperNode          "SuperNode"
  743.  
  744. #endif TREE_H
  745. @EOF
  746.  
  747. chmod 644 Tree.h
  748.  
  749. echo x - TreeP.h
  750. cat >TreeP.h <<'@EOF'
  751. /**********************************************************************************
  752.  * TreeP.h: Private header file for the Tree widget
  753.   *         From:
  754.   *                   The X Window System, 
  755.   *            Programming and Applications with Xt
  756.   *                   OSF/Motif Edition
  757.   *         by
  758.   *                Douglas Young
  759.   *              Prentice Hall, 1990
  760.   *
  761.   *                 Example described on pages: 397-419
  762.   *
  763.   *
  764.   *  Copyright 1989 by Prentice Hall
  765.   *  All Rights Reserved
  766.   *
  767.   * This code is based on the OSF/Motif widget set and the X Window System
  768.   *
  769.   * Permission to use, copy, modify, and distribute this software for 
  770.   * any purpose and without fee is hereby granted, provided that the above
  771.   * copyright notice appear in all copies and that both the copyright notice
  772.   * and this permission notice appear in supporting documentation.
  773.   *
  774.   * Prentice Hall and the author disclaim all warranties with regard to 
  775.   * this software, including all implied warranties of merchantability and fitness.
  776.   * In no event shall Prentice Hall or the author be liable for any special,
  777.   * indirect or cosequential damages or any damages whatsoever resulting from 
  778.   * loss of use, data or profits, whether in an action of contract, negligence 
  779.   * or other tortious action, arising out of or in connection with the use 
  780.   * or performance of this software.
  781.   *
  782.   * Open Software Foundation is a trademark of The Open Software Foundation, Inc.
  783.   * OSF is a trademark of Open Software Foundation, Inc.
  784.   * OSF/Motif is a trademark of Open Software Foundation, Inc.
  785.   * Motif is a trademark of Open Software Foundation, Inc.
  786.   * DEC is a registered trademark of Digital Equipment Corporation
  787.   * HP is a registered trademark of the Hewlett Packard Company
  788.   * DIGITAL is a registered trademark of Digital Equipment Corporation
  789.   * X Window System is a trademark of the Massachusetts Institute of Technology
  790.   **********************************************************************************/
  791.  
  792.  
  793. #ifndef TREEP_H
  794. #define TREEP_H
  795. typedef struct _XsTreeClassPart {
  796.     int         ignore;
  797. } XsTreeClassPart;
  798.  
  799. typedef struct _XsTreeClassRec {
  800.     CoreClassPart       core_class;
  801.     CompositeClassPart  composite_class;
  802.     ConstraintClassPart constraint_class;
  803.     XsTreeClassPart     tree_class;
  804. } XsTreeClassRec;
  805.  
  806. extern XsTreeClassRec XstreeClassRec;
  807.  
  808. typedef struct {
  809.     Dimension  *array;
  810.     int         size;
  811.   }  TreeOffset, *TreeOffsetPtr;
  812.  
  813. typedef struct {
  814.     Dimension      h_min_space;
  815.     Dimension      v_min_space;
  816.     Pixel          foreground;
  817.     GC             gc;
  818.     TreeOffsetPtr  horizontal;
  819.     TreeOffsetPtr  vertical;
  820.     Widget         tree_root;
  821. } XsTreePart;
  822.  
  823.  
  824. typedef struct _XsTreeRec {
  825.     CorePart        core;
  826.     CompositePart   composite;
  827.     ConstraintPart  constraint;
  828.     XsTreePart      tree;
  829. }  XsTreeRec;
  830.  
  831.  
  832.  
  833. typedef struct _TreeConstraintsPart {
  834.   Widget        super_node;
  835.   WidgetList    sub_nodes;
  836.   long          n_sub_nodes;
  837.   long          max_sub_nodes;
  838.   Position      x, y;
  839. } TreeConstraintsPart;
  840.  
  841. typedef struct _TreeConstraintsRec {
  842.    TreeConstraintsPart tree;
  843. } TreeConstraintsRec, *TreeConstraints;
  844.  
  845.  
  846. #define TREE_CONSTRAINT(w) \
  847.                    ((TreeConstraints)((w)->core.constraints))
  848.  
  849. #endif TREEP_H
  850.  
  851.  
  852.  
  853. @EOF
  854.  
  855. chmod 644 TreeP.h
  856.  
  857. exit 0
  858.  
  859. dan
  860. ----------------------------------------------------
  861. O'Reilly && Associates   argv@sun.com / argv@ora.com
  862. Opinions expressed reflect those of the author only.
  863.