Xw/Form.c

   1 /*************************************<+>*************************************
   2  *****************************************************************************
   3  **
   4  **   File:        Form.c
   5  **
   6  **   Project:     X Widgets
   7  **
   8  **   Description: Contains code for the X Widget's Form manager.
   9  **
  10  *****************************************************************************
  11  **
  12  **   Copyright (c) 1988 by Hewlett-Packard Company
  13  **   Copyright (c) 1988 by the Massachusetts Institute of Technology
  14  **
  15  **   Permission to use, copy, modify, and distribute this software
  16  **   and its documentation for any purpose and without fee is hereby
  17  **   granted, provided that the above copyright notice appear in all
  18  **   copies and that both that copyright notice and this permission
  19  **   notice appear in supporting documentation, and that the names of
  20  **   Hewlett-Packard or  M.I.T.  not be used in advertising or publicity
  21  **   pertaining to distribution of the software without specific, written
  22  **   prior permission.
  23  **
  24  *****************************************************************************
  25  *************************************<+>*************************************/
  26
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31 #include <X11/Xlib.h>
  32 #include <X11/IntrinsicP.h>
  33 #include <X11/Intrinsic.h>
  34 #include <Xw/Xw.h>
  35 #include <Xw/XwP.h>
  36 #include <Xw/Form.h>
  37 #include <Xw/FormP.h>
  38 #include <X11/StringDefs.h>
  39 #include <X11/keysymdef.h>
  40
  41
  42 /*  Constraint resource list for Form  */
  43
  44 static XtResource constraintResources[] =
  45 {
  46    {
  47       XtNxRefName, XtCXRefName, XtRString, sizeof(caddr_t),
  48       XtOffset(XwFormConstraints, x_ref_name), XtRString, (caddr_t) NULL
  49    },
  50
  51    {
  52       XtNxRefWidget, XtCXRefWidget, XtRPointer, sizeof(caddr_t),
  53       XtOffset(XwFormConstraints, x_ref_widget), XtRPointer, NULL
  54    },
  55
  56    {
  57       XtNxOffset, XtCXOffset, XtRInt, sizeof(int),
  58       XtOffset(XwFormConstraints, x_offset), XtRString, "0"
  59    },
  60
  61    {
  62       XtNxAddWidth, XtCXAddWidth, XtRBoolean, sizeof(Boolean),
  63       XtOffset(XwFormConstraints, x_add_width), XtRString, "False"
  64    },
  65
  66    {
  67       XtNxVaryOffset, XtCXVaryOffset, XtRBoolean, sizeof(Boolean),
  68       XtOffset(XwFormConstraints, x_vary_offset), XtRString, "False"
  69    },
  70
  71    {
  72       XtNxResizable, XtCXResizable, XtRBoolean, sizeof(Boolean),
  73       XtOffset(XwFormConstraints, x_resizable), XtRString, "False"
  74    },
  75
  76    {
  77       XtNxAttachRight, XtCXAttachRight, XtRBoolean, sizeof(Boolean),
  78       XtOffset(XwFormConstraints, x_attach_right), XtRString, "False"
  79    },
  80
  81    {
  82       XtNxAttachOffset, XtCXAttachOffset, XtRInt, sizeof(int),
  83       XtOffset(XwFormConstraints, x_attach_offset), XtRString, "0"
  84    },
  85
  86    {
  87       XtNyRefName, XtCYRefName, XtRString, sizeof(caddr_t),
  88       XtOffset(XwFormConstraints, y_ref_name), XtRString, (caddr_t) NULL
  89    },
  90
  91    {
  92       XtNyRefWidget, XtCYRefWidget, XtRPointer, sizeof(caddr_t),
  93       XtOffset(XwFormConstraints, y_ref_widget), XtRPointer, NULL
  94    },
  95
  96    {
  97       XtNyOffset, XtCYOffset, XtRInt, sizeof(int),
  98       XtOffset(XwFormConstraints, y_offset), XtRString, "0"
  99    },
 100
 101    {
 102       XtNyAddHeight, XtCYAddHeight, XtRBoolean, sizeof(Boolean),
 103       XtOffset(XwFormConstraints, y_add_height), XtRString, "False"
 104    },
 105
 106    {
 107       XtNyVaryOffset, XtCYVaryOffset, XtRBoolean, sizeof(Boolean),
 108       XtOffset(XwFormConstraints, y_vary_offset), XtRString, "False"
 109    },
 110
 111    {
 112       XtNyResizable, XtCYResizable, XtRBoolean, sizeof(Boolean),
 113       XtOffset(XwFormConstraints, y_resizable), XtRString, "False"
 114    },
 115
 116    {
 117       XtNyAttachBottom, XtCYAttachBottom, XtRBoolean, sizeof(Boolean),
 118       XtOffset(XwFormConstraints, y_attach_bottom), XtRString, "False"
 119    },
 120
 121    {
 122       XtNyAttachOffset, XtCYAttachOffset, XtRInt, sizeof(int),
 123       XtOffset(XwFormConstraints, y_attach_offset), XtRString, "0"
 124    }
 125 };
 126
 127
 128
 129 /*  Static routine definitions  */
 130
 131 static void    Initialize();
 132 static void    Realize();
 133 static void    Resize();
 134 static void    Destroy();
 135 static Boolean SetValues();
 136
 137 static void      ChangeManaged();
 138 static XtGeometryResult GeometryManager();
 139
 140 static void      ConstraintInitialize();
 141 static void    ConstraintDestroy();
 142 static Boolean ConstraintSetValues();
 143
 144 static void        GetRefWidget();
 145 static Widget      XwFindWidget();
 146 static XwFormRef * XwGetFormRef();
 147 static Widget      XwFindValidRef();
 148 static XwFormRef * XwRefTreeSearch();
 149 static XwFormRef * XwParentRefTreeSearch();
 150 static void        XwMakeRefs();
 151 static void        XwDestroyRefs();
 152 static void        XwProcessRefs();
 153 static void        XwAddRef();
 154 static void        XwRemoveRef();
 155 static void        XwFindDepthAndCount();
 156 static void        XwInitProcessList();
 157 static void        XwConstrainList();
 158 static void        XwFreeConstraintList();
 159
 160
 161 /*  Static global variable definitions  */
 162
 163 static int depth, leaves, arrayIndex;
 164
 165
 166 /*  The Form class record */
 167
 168 XwFormClassRec XwformClassRec =
 169 {
 170    {
 171       (WidgetClass) &XwmanagerClassRec, /* superclass            */
 172       "XwForm",                         /* class_name            */
 173       sizeof(XwFormRec),                /* widget_size           */
 174       NULL,                             /* class_initialize      */
 175       NULL,                             /* class_part_initialize */
 176       FALSE,                            /* class_inited          */
 177       (XtInitProc) Initialize,          /* initialize            */
 178       NULL,                             /* initialize_hook       */
 179       (XtRealizeProc) Realize,          /* realize               */
 180       NULL,                             /* actions               */
 181       0,                                /* num_actions           */
 182       NULL,                             /* resources             */
 183       0,                                /* num_resources         */
 184       NULLQUARK,                        /* xrm_class             */
 185       TRUE,                             /* compress_motion       */
 186       TRUE,                             /* compress_exposure     */
 187       TRUE,                             /* compress_enterleave   */
 188       FALSE,                            /* visible_interest      */
 189       (XtWidgetProc) Destroy,           /* destroy               */
 190       (XtWidgetProc) Resize,            /* resize                */
 191       NULL,                             /* expose                */
 192       (XtSetValuesFunc) SetValues,      /* set_values            */
 193       NULL,                             /* set_values_hook       */
 194       XtInheritSetValuesAlmost,         /* set_values_almost     */
 195       NULL,                             /* get_values_hook       */
 196       NULL,                             /* accept_focus          */
 197       XtVersion,                        /* version               */
 198       NULL,                             /* callback private      */
 199       NULL,                             /* tm_table              */
 200       NULL,                             /* query_geometry        */
 201     /* display_accelerator      */      XtInheritDisplayAccelerator,
 202     /* extension                */      NULL
 203    },
 204
 205    {                                         /*  composite class           */
 206       (XtGeometryHandler) GeometryManager,   /*  geometry_manager          */
 207       (XtWidgetProc) ChangeManaged,          /*  change_managed            */
 208       XtInheritInsertChild,                  /* insert_child               */
 209       XtInheritDeleteChild,                  /*  delete_child (inherited)  */
 210       NULL,
 211    },
 212
 213    {                                      /*  constraint class            */
 214       constraintResources,                /*  constraint resource set     */
 215       XtNumber(constraintResources),      /*  num_resources               */
 216       sizeof(XwFormConstraintRec),        /*  size of the constraint data */
 217       (XtInitProc) ConstraintInitialize,  /*  contraint initilize proc    */
 218       (XtWidgetProc) ConstraintDestroy,   /*  contraint destroy proc      */
 219       (XtSetValuesFunc) ConstraintSetValues,  /*  contraint set values proc */
 220       NULL,
 221    },
 222
 223    {                           /*  manager class      */
 224       (XwTraversalProc) XtInheritTraversalProc   /*  traversal handler  */
 225    },
 226
 227    {              /*  form class  */
 228       0           /*  mumble      */
 229    }
 230 };
 231
 232
 233 WidgetClass XwformWidgetClass = (WidgetClass) &XwformClassRec;
 234
 235
 236
 237
 238 /************************************************************************
 239  *
 240  *  Initialize
 241  *     The main widget instance initialization routine.
 242  *
 243  ************************************************************************/
 244
 245 static void Initialize (request, new)
 246 XwFormWidget request, new;
 247
 248 {
 249    /*  Initialize the tree fields to NULL  */
 250
 251    new -> form.width_tree =
 252       XwGetFormRef (new, NULL, 0, False, False, True, False, 0, 0, 0);
 253    new -> form.height_tree =
 254       XwGetFormRef (new, NULL, 0, False, False, True, False, 0, 0, 0);
 255
 256
 257    /*  Set up a geometry for the widget if it is currently 0.  */
 258
 259    if (request -> core.width == 0)
 260       new -> core.width += 200;
 261    if (request -> core.height == 0)
 262       new -> core.height += 200;
 263 }
 264
 265
 266
 267
 268 /************************************************************************
 269  *
 270  *  ConstraintInitialize
 271  *     The main widget instance constraint initialization routine.
 272  *
 273  ************************************************************************/
 274
 275 static void ConstraintInitialize (request, new)
 276 Widget request, new;
 277
 278 {
 279    XwFormConstraintRec * constraintRec;
 280
 281    constraintRec = (XwFormConstraintRec *) new -> core.constraints;
 282
 283
 284    /*  Initialize the contraint widget sizes for later processing  */
 285
 286    constraintRec -> set_x = 0;
 287    constraintRec -> set_y = 0;
 288    constraintRec -> set_width = 0;
 289    constraintRec -> set_height = 0;
 290
 291    constraintRec -> x = new -> core.x;
 292    constraintRec -> y = new -> core.y;
 293    constraintRec -> width = new -> core.width;
 294    constraintRec -> height = new -> core.height;
 295
 296    constraintRec -> managed = False;
 297
 298
 299    /*  Get and save copies of the names of the reference widgets  */
 300
 301    GetRefWidget (&constraintRec -> x_ref_widget,
 302                  &constraintRec -> x_ref_name, new);
 303    GetRefWidget (&constraintRec -> y_ref_widget,
 304                  &constraintRec -> y_ref_name, new);
 305
 306 }
 307
 308
 309
 310
 311 /************************************************************************
 312  *
 313  *  GetRefWidget
 314  *     Get and verify the reference widget given.
 315  *
 316  ************************************************************************/
 317
 318 static void GetRefWidget (widget, name, new)
 319 Widget *  widget;
 320 char   ** name;
 321 Widget    new;
 322
 323 {
 324    if (*widget != NULL)
 325    {
 326       if (*name != NULL)
 327       {
 328          if (strcmp (*name, (char *) ((*widget) -> core.name)) != 0)
 329          {
 330             XtWarning
 331                ("Form: The reference widget and widget name do not match.");
 332             *name = (char *) (*widget) -> core.name;
 333          }
 334       }
 335       else
 336          *name = (char *) (*widget) -> core.name;
 337
 338       if ((*widget) != new -> core.parent &&
 339           (*widget) -> core.parent != new -> core.parent)
 340       {
 341          XtWarning ("Form: The reference widget is not a child of the form");
 342          XtWarning ("      or the form widget.");
 343          *name = new -> core.parent -> core.name;
 344          *widget = new -> core.parent;
 345       }
 346    }
 347
 348    else if (*name != NULL)
 349    {
 350       if ((*widget = XwFindWidget ((CompositeWidget)(new->core.parent), *name)) == NULL)
 351       {
 352          XtWarning ("Form: The reference widget was not found.");
 353          *name = new -> core.parent -> core.name;
 354          *widget = new -> core.parent;
 355       }
 356    }
 357    else
 358    {
 359       *name = new -> core.parent -> core.name;
 360       *widget = new -> core.parent;
 361    }
 362
 363    *name = strcpy (XtMalloc((unsigned) XwStrlen (*name) + 1), *name);
 364 }
 365
 366
 367
 368
 369 /************************************************************************
 370  *
 371  *  XwFindWidget
 372  *
 373  ************************************************************************/
 374
 375 static Widget XwFindWidget (w, name)
 376 CompositeWidget w;
 377 char   * name;
 378
 379 {
 380    register int i;
 381    register Widget * list;
 382    int count;
 383
 384    if (strcmp (name, w -> core.name) == 0)
 385       return ((Widget) w);
 386
 387    list = w -> composite.children;
 388    count = w -> composite.num_children;
 389
 390    for (i = 0; i < count; i++)
 391    {
 392       if (strcmp (name, (*list) -> core.name) == 0)
 393          return (*list);
 394       list++;
 395    }
 396    return (NULL);
 397 }
 398
 399
 400
 401
 402 /************************************************************************
 403  *
 404  *  Realize
 405  *      Create the widget window and create the gc's.
 406  *
 407  ************************************************************************/
 408
 409 static void Realize (fw, valueMask, attributes)
 410 XwFormWidget           fw;
 411 XtValueMask          * valueMask;
 412 XSetWindowAttributes * attributes;
 413
 414 {
 415    Mask newValueMask = *valueMask;
 416    XtCreateWindow ((Widget)fw, InputOutput, (Visual *) CopyFromParent,
 417                    newValueMask, attributes);
 418    _XwRegisterName(fw);
 419    XwProcessRefs (fw, False);
 420 }
 421
 422
 423
 424
 425 /************************************************************************
 426  *
 427  *  Resize
 428  *
 429  ************************************************************************/
 430
 431 static void Resize (fw)
 432 XwFormWidget fw;
 433
 434 {
 435    if (XtIsRealized ((Widget)fw)) XwProcessRefs (fw, False);
 436 }
 437
 438
 439
 440
 441
 442 /************************************************************************
 443  *
 444  *  Destroy
 445  *      Deallocate the head structures of the reference trees.
 446  *      The rest of the tree has already been deallocated.
 447  *
 448  ************************************************************************/
 449
 450 static void Destroy (fw)
 451 XwFormWidget fw;
 452
 453 {
 454    XtFree ((char *)(fw -> form.width_tree));
 455    XtFree ((char *)(fw -> form.height_tree));
 456 }
 457
 458
 459
 460
 461 /************************************************************************
 462  *
 463  *  ConstraintDestroy
 464  *      Deallocate the allocated referenence names.
 465  *
 466  ************************************************************************/
 467
 468 static void ConstraintDestroy (w)
 469 XwFormWidget w;
 470
 471 {
 472    XwFormConstraintRec * constraint;
 473
 474    constraint = (XwFormConstraintRec *) w -> core.constraints;
 475
 476    if (constraint -> x_ref_name != NULL) XtFree (constraint -> x_ref_name);
 477    if (constraint -> y_ref_name != NULL) XtFree (constraint -> y_ref_name);
 478 }
 479
 480
 481
 482
 483
 484 /************************************************************************
 485  *
 486  *  SetValues
 487  *      Currently nothing needs to be done.  The XtSetValues call
 488  *      handles geometry requests and form does not define any
 489  *      new resources.
 490  *
 491  ************************************************************************/
 492
 493 static Boolean SetValues (current, request, new)
 494 XwFormWidget current, request, new;
 495
 496 {
 497    return (False);
 498 }
 499
 500
 501
 502
 503 /************************************************************************
 504  *
 505  *  ConstraintSetValues
 506  *      Process changes in the constraint set of a widget.
 507  *
 508  ************************************************************************/
 509
 510 static Boolean ConstraintSetValues (current, request, new)
 511 Widget current, request, new;
 512
 513 {
 514    XwFormConstraintRec * curConstraint;
 515    XwFormConstraintRec * newConstraint;
 516    XwFormConstraintRec * tempConstraint;
 517
 518
 519    curConstraint = (XwFormConstraintRec *) current -> core.constraints;
 520    newConstraint = (XwFormConstraintRec *) new -> core.constraints;
 521
 522
 523    /*  Check the geometrys to see if new's contraint record  */
 524    /*  saved geometry data needs to be updated.              */
 525
 526    if (XtIsRealized (current))
 527    {
 528       if (new -> core.x != current -> core.x)
 529          newConstraint -> set_x = new -> core.x;
 530       if (new -> core.y != current -> core.y)
 531          newConstraint -> set_y = new -> core.y;
 532       if (new -> core.width != current -> core.width)
 533          newConstraint -> set_width = new -> core.width;
 534       if (new -> core.height != current -> core.height)
 535          newConstraint -> set_height = new -> core.height;
 536    }
 537
 538
 539    /*  If the reference widget or name has changed, set the  */
 540    /*  opposing member to NULL in order to get the proper    */
 541    /*  referencing.  For names, the string space will be     */
 542    /*  deallocated out of current later.                     */
 543
 544    if (newConstraint -> x_ref_widget != curConstraint -> x_ref_widget)
 545       newConstraint -> x_ref_name = NULL;
 546    else if (newConstraint -> x_ref_name != curConstraint -> x_ref_name)
 547       newConstraint -> x_ref_widget = NULL;
 548
 549    if (newConstraint -> y_ref_widget != curConstraint -> y_ref_widget)
 550       newConstraint -> y_ref_name = NULL;
 551    else if (newConstraint -> y_ref_name != curConstraint -> y_ref_name)
 552       newConstraint -> y_ref_widget = NULL;
 553
 554
 555    /*  Get and save copies of the names of the reference widget names  */
 556    /*  and get the reference widgets.                                  */
 557
 558    GetRefWidget (&newConstraint -> x_ref_widget,
 559                  &newConstraint -> x_ref_name, new);
 560    GetRefWidget (&newConstraint -> y_ref_widget,
 561                  &newConstraint -> y_ref_name, new);
 562
 563
 564    /*  See if the reference widgets have changed.  If so, free the  */
 565    /*  old allocated names and set them to the new names.           */
 566
 567    if (newConstraint -> x_ref_widget != curConstraint -> x_ref_widget)
 568    {
 569       XtFree (curConstraint -> x_ref_name);
 570       curConstraint -> x_ref_name = newConstraint -> x_ref_name;
 571    }
 572
 573    if (newConstraint -> y_ref_widget != curConstraint -> y_ref_widget)
 574    {
 575       XtFree (curConstraint -> y_ref_name);
 576       curConstraint -> y_ref_name = newConstraint -> y_ref_name;
 577    }
 578
 579
 580    /*  See if any constraint data for the widget has changed.  */
 581    /*  Is so, remove the old reference tree elements from the  */
 582    /*  forms constraint processing trees and build and insert  */
 583    /*  new reference tree elements.                            */
 584    /*                                                          */
 585    /*  Once this is finished, reprocess the constraint trees.  */
 586
 587    if (newConstraint -> x_ref_widget != curConstraint -> x_ref_widget       ||
 588        newConstraint -> y_ref_widget != curConstraint -> y_ref_widget       ||
 589
 590        newConstraint -> x_offset != curConstraint -> x_offset               ||
 591        newConstraint -> y_offset != curConstraint -> y_offset               ||
 592
 593        newConstraint -> x_vary_offset != curConstraint -> x_vary_offset     ||
 594        newConstraint -> y_vary_offset != curConstraint -> y_vary_offset     ||
 595
 596        newConstraint -> x_resizable != curConstraint -> x_resizable         ||
 597        newConstraint -> y_resizable != curConstraint -> y_resizable         ||
 598
 599        newConstraint -> x_add_width != curConstraint -> x_add_width         ||
 600        newConstraint -> y_add_height != curConstraint -> y_add_height       ||
 601
 602        newConstraint -> x_attach_right != curConstraint -> x_attach_right   ||
 603        newConstraint -> y_attach_bottom != curConstraint -> y_attach_bottom ||
 604
 605        newConstraint -> x_attach_offset != curConstraint -> x_attach_offset ||
 606        newConstraint -> y_attach_offset != curConstraint -> y_attach_offset)
 607    {
 608       if (XtIsRealized (current) && current -> core.managed)
 609       {
 610          XwDestroyRefs (current);
 611
 612          tempConstraint = (XwFormConstraintRec *) current -> core.constraints;
 613          current -> core.constraints = new -> core.constraints;
 614          XwMakeRefs (current);
 615          current -> core.constraints = (caddr_t) tempConstraint;
 616       }
 617
 618       if (XtIsRealized (current)) XwProcessRefs (new -> core.parent, True);
 619    }
 620
 621    return (False);
 622 }
 623
 624
 625
 626
 627 /************************************************************************
 628  *
 629  *  GeometryManager
 630  *      Always accept the childs new size, set the childs constraint
 631  *      record size to the new size and process the constraints.
 632  *
 633  ************************************************************************/
 634
 635 static XtGeometryResult GeometryManager (w, request, reply)
 636 Widget w;
 637 XtWidgetGeometry * request;
 638 XtWidgetGeometry * reply;
 639
 640 {
 641    XwFormWidget fw = (XwFormWidget) w -> core.parent;
 642    XwFormConstraintRec * constraint;
 643    XwFormRef * xRef;
 644    XwFormRef * yRef;
 645    int newBorder = w -> core.border_width;
 646    Boolean moveFlag = False;
 647    Boolean resizeFlag = False;
 648
 649
 650    constraint = (XwFormConstraintRec *) w -> core.constraints;
 651
 652    if (request -> request_mode & CWX)
 653       constraint -> set_x = request -> x;
 654
 655    if (request -> request_mode & CWY)
 656       constraint -> set_y = request -> y;
 657
 658    if (request -> request_mode & CWWidth)
 659       constraint -> set_width = request -> width;
 660
 661    if (request -> request_mode & CWHeight)
 662       constraint -> set_height = request -> height;
 663
 664    if (request -> request_mode & CWBorderWidth)
 665       newBorder = request -> border_width;
 666
 667
 668    /*  If the x or the width has changed, find the horizontal  */
 669    /*  reference tree structure for this widget and update it  */
 670
 671    xRef = yRef = NULL;
 672    if  ((request->request_mode & CWWidth) || (request->request_mode & CWX))
 673    {
 674       if ((xRef = XwRefTreeSearch (w, fw -> form.width_tree)) != NULL)
 675       {
 676          if  (request->request_mode & CWX)
 677             xRef -> set_loc = request -> x;
 678          if  (request->request_mode & CWWidth)
 679             xRef -> set_size = request -> width;
 680       }
 681    }
 682
 683
 684    /*  If the y or the height has changed, find the vertical   */
 685    /*  reference tree structure for this widget and update it  */
 686
 687    if  ((request->request_mode & CWHeight) || (request->request_mode & CWY))
 688    {
 689       if ((yRef = XwRefTreeSearch (w, fw -> form.height_tree)) != NULL)
 690       {
 691          if  (request->request_mode & CWY)
 692             yRef -> set_loc = request -> y;
 693          if  (request->request_mode & CWHeight)
 694             yRef -> set_size = request -> height;
 695       }
 696    }
 697
 698
 699    /*  Process the constraints if either of the ref structs have changed */
 700
 701    if (xRef != NULL || yRef != NULL)
 702    {
 703       if ((request->request_mode & CWX) || (request->request_mode & CWY))
 704          moveFlag = True;
 705       if ((request->request_mode & CWWidth) ||
 706           (request->request_mode & CWHeight))
 707          resizeFlag = True;
 708
 709       if (moveFlag && resizeFlag)
 710          XtConfigureWidget (w, constraint -> set_x, constraint -> set_y,
 711                             constraint -> set_width, constraint -> set_height,
 712                             newBorder);
 713       else if (resizeFlag)
 714          XtResizeWidget (w, constraint -> set_width, constraint -> set_height,
 715                             newBorder);
 716       else if (moveFlag)
 717          XtMoveWidget (w, constraint -> set_x, constraint -> set_y);
 718
 719
 720       XwProcessRefs (w -> core.parent, True);
 721    }
 722
 723
 724    /*  See if an almost condition should be returned  */
 725
 726    if (((request->request_mode & CWX) && w->core.x != request->x) ||
 727        ((request->request_mode & CWY) && w->core.y != request->y) ||
 728        ((request->request_mode & CWWidth) &&
 729          w->core.width != request->width) ||
 730        ((request->request_mode & CWHeight) &&
 731          w->core.height != request->height))
 732    {
 733       reply->request_mode = request->request_mode;
 734
 735       if (request->request_mode & CWX) reply->x = w->core.x;
 736       if (request->request_mode & CWY) reply->y = w->core.y;
 737       if (request->request_mode & CWWidth) reply->width = w->core.width;
 738       if (request->request_mode & CWHeight) reply->height = w->core.height;
 739       if (request->request_mode & CWBorderWidth)
 740          reply->border_width = request->border_width;
 741       if (request->request_mode & CWSibling)
 742          reply->sibling = request->sibling;
 743       if (request->request_mode & CWStackMode)
 744           reply->stack_mode = request->stack_mode;
 745
 746       return (XtGeometryAlmost);
 747    }
 748
 749    return (XtGeometryDone);
 750 }
 751
 752
 753
 754
 755 /************************************************************************
 756  *
 757  *  ChangeManaged
 758  *
 759  ************************************************************************/
 760
 761 static void ChangeManaged (fw)
 762 XwFormWidget fw;
 763
 764 {
 765    Widget child;
 766    XwFormConstraintRec * constraint;
 767    register int i;
 768
 769
 770    /*  If the widget is being managed, build up the reference     */
 771    /*  structures for it, adjust any references, and process the  */
 772    /*  reference set.  If unmanaged, remove its reference.        */
 773
 774    for (i = 0; i < fw -> composite.num_children; i++)
 775    {
 776       child = fw -> composite.children[i];
 777       constraint = (XwFormConstraintRec *) child -> core.constraints;
 778
 779       if (constraint -> set_width == 0)
 780       {
 781          constraint -> set_x = child -> core.x;
 782          constraint -> set_y = child -> core.y;
 783          constraint -> set_width = child -> core.width;
 784          constraint -> set_height = child -> core.height;
 785       }
 786
 787       if (child -> core.managed != constraint -> managed)
 788       {
 789          if (child -> core.managed)
 790          {
 791             if (constraint->width_when_unmanaged != child->core.width)
 792                constraint->set_width = child->core.width;
 793             if (constraint->height_when_unmanaged != child->core.height)
 794                constraint->set_height = child->core.height;
 795             XwMakeRefs (child);
 796          }
 797          else
 798          {
 799             constraint -> width_when_unmanaged = child->core.width;
 800             constraint -> height_when_unmanaged = child->core.height;
 801             XwDestroyRefs (child);
 802          }
 803          constraint -> managed = child -> core.managed;
 804       }
 805    }
 806
 807    XwProcessRefs (fw, True);
 808 }
 809
 810
 811
 812
 813 /************************************************************************
 814  *
 815  *  XwMakeRefs
 816  *      Build up and insert into the forms reference trees the reference
 817  *      structures needed for the widget w.
 818  *
 819  ************************************************************************/
 820
 821 static void XwMakeRefs (w)
 822 Widget w;
 823
 824 {
 825    Widget xRefWidget;
 826    Widget yRefWidget;
 827    XwFormWidget formWidget;
 828    XwFormConstraintRec * constraint;
 829    XwFormRef * xRefParent;
 830    XwFormRef * yRefParent;
 831    XwFormRef * xRef;
 832    XwFormRef * yRef;
 833    XwFormRef * checkRef;
 834    register int i;
 835
 836
 837    formWidget = (XwFormWidget) w -> core.parent;
 838    constraint = (XwFormConstraintRec *) w -> core.constraints;
 839
 840
 841    /*  The "true" reference widget may be unmanaged, so  */
 842    /*  we need to back up through the reference set      */
 843    /*  perhaps all the way to Form.                      */
 844
 845    xRefWidget = XwFindValidRef (constraint -> x_ref_widget, XwHORIZONTAL,
 846                                 formWidget -> form.width_tree);
 847    yRefWidget = XwFindValidRef (constraint -> y_ref_widget, XwVERTICAL,
 848                                 formWidget -> form.height_tree);
 849
 850
 851    /*  Search the referencing trees for the referencing widgets  */
 852    /*  The constraint reference struct will be added as a child  */
 853    /*  of this struct.                                           */
 854
 855    if (xRefWidget != NULL)
 856       xRefParent = XwRefTreeSearch (xRefWidget, formWidget -> form.width_tree);
 857
 858    if (yRefWidget != NULL)
 859       yRefParent = XwRefTreeSearch (yRefWidget, formWidget->form.height_tree);
 860
 861
 862    /*  Allocate, initialize, and insert the reference structures  */
 863
 864    if (xRefWidget != NULL)
 865    {
 866       xRef = XwGetFormRef (w, xRefWidget, constraint->x_offset,
 867                            constraint->x_add_width, constraint->x_vary_offset,
 868                            constraint->x_resizable, constraint->x_attach_right,
 869                            constraint->x_attach_offset,
 870                            constraint->set_x, constraint->set_width);
 871       XwAddRef (xRefParent, xRef);
 872    }
 873
 874    if (yRefWidget != NULL)
 875    {
 876       yRef = XwGetFormRef(w, yRefWidget, constraint->y_offset,
 877                           constraint->y_add_height, constraint->y_vary_offset,
 878                           constraint->y_resizable, constraint->y_attach_bottom,
 879                           constraint->y_attach_offset,
 880                           constraint->set_y, constraint->set_height);
 881       XwAddRef (yRefParent, yRef);
 882    }
 883
 884
 885    /*  Search through the parents reference set to get any child  */
 886    /*  references which need to be made child references of the   */
 887    /*  widget just added.                                         */
 888
 889    for (i = 0; i < xRefParent -> ref_to_count; i++)
 890    {
 891       checkRef = xRefParent -> ref_to[i];
 892       constraint = (XwFormConstraintRec *) checkRef->this->core.constraints;
 893
 894       if (XwFindValidRef (constraint->x_ref_widget, XwHORIZONTAL,
 895                           formWidget -> form.width_tree) != xRefWidget)
 896       {
 897          XwRemoveRef (xRefParent, checkRef);
 898          checkRef -> ref = xRef -> this;
 899          XwAddRef (xRef, checkRef);
 900       }
 901    }
 902
 903    for (i = 0; i < yRefParent -> ref_to_count; i++)
 904    {
 905       checkRef = yRefParent -> ref_to[i];
 906       constraint = (XwFormConstraintRec *) checkRef->this->core.constraints;
 907
 908       if (XwFindValidRef (constraint->y_ref_widget, XwVERTICAL,
 909                           formWidget -> form.height_tree) != yRefWidget)
 910       {
 911          XwRemoveRef (yRefParent, checkRef);
 912          checkRef -> ref = yRef -> this;
 913          XwAddRef (yRef, checkRef);
 914       }
 915    }
 916 }
 917
 918
 919
 920
 921 /************************************************************************
 922  *
 923  *  XwDestroyRefs
 924  *      Remove and deallocate the reference structures for the widget w.
 925  *
 926  ************************************************************************/
 927
 928 static void XwDestroyRefs (w)
 929 Widget w;
 930
 931 {
 932    Widget xRefWidget;
 933    Widget yRefWidget;
 934    XwFormWidget formWidget;
 935    XwFormConstraintRec * constraint;
 936    XwFormRef * xRefParent;
 937    XwFormRef * yRefParent;
 938    XwFormRef * xRef;
 939    XwFormRef * yRef;
 940    XwFormRef * tempRef;
 941    register int i;
 942
 943
 944    formWidget = (XwFormWidget) w -> core.parent;
 945    constraint = (XwFormConstraintRec *) w -> core.constraints;
 946
 947
 948    /*  Search through the reference trees to see if the widget  */
 949    /*  is within the tree.                                      */
 950
 951    xRefWidget = w;
 952    yRefWidget = w;
 953
 954    xRefParent =
 955       XwParentRefTreeSearch (xRefWidget, formWidget -> form.width_tree,
 956                                          formWidget -> form.width_tree);
 957    yRefParent =
 958       XwParentRefTreeSearch (yRefWidget, formWidget -> form.height_tree,
 959                                           formWidget -> form.height_tree);
 960
 961
 962    /*  For both the width and height references, if the ref parent was  */
 963    /*  not null, find the reference to be removed within the parents    */
 964    /*  list, remove this reference.  Then, for any references attached  */
 965    /*  to the one just removed, reparent them to the parent reference.  */
 966
 967    if (xRefParent != NULL)
 968    {
 969       for (i = 0; i < xRefParent -> ref_to_count; i++)
 970       {
 971          if (xRefParent -> ref_to[i] -> this == xRefWidget)
 972          {
 973              xRef = xRefParent -> ref_to[i];
 974              break;
 975          }
 976       }
 977
 978       XwRemoveRef (xRefParent, xRefParent -> ref_to[i]);
 979
 980       while (xRef -> ref_to_count)
 981       {
 982          tempRef = xRef -> ref_to[0];
 983          tempRef -> ref = xRefParent -> this;
 984          XwRemoveRef (xRef, tempRef);
 985          XwAddRef (xRefParent, tempRef);
 986       }
 987
 988       XtFree ((char *)xRef);
 989    }
 990
 991    if (yRefParent != NULL)
 992    {
 993       for (i = 0; i < yRefParent -> ref_to_count; i++)
 994       {
 995          if (yRefParent -> ref_to[i] -> this == yRefWidget)
 996          {
 997             yRef = yRefParent -> ref_to[i];
 998             break;
 999          }
1000       }
1001
1002       XwRemoveRef (yRefParent, yRef);
1003
1004       while (yRef -> ref_to_count)
1005       {
1006          tempRef = yRef -> ref_to[0];
1007          tempRef -> ref = yRefParent -> this;
1008          XwRemoveRef (yRef, tempRef);
1009          XwAddRef (yRefParent, tempRef);
1010       }
1011
1012       XtFree ((char *)yRef);
1013    }
1014 }
1015
1016
1017
1018
1019 /************************************************************************
1020  *
1021  *  XwGetFormRef
1022  *      Allocate and initialize a form constraint referencing structure.
1023  *
1024  ************************************************************************/
1025
1026 static XwFormRef *
1027 XwGetFormRef (this, ref, offset, add, vary,
1028               resizable, attach, attach_offset, loc, size)
1029 Widget  this;
1030 Widget  ref;
1031 int     offset;
1032 Boolean add;
1033 Boolean vary;
1034 Boolean resizable;
1035 Boolean attach;
1036 int     attach_offset;
1037
1038 {
1039    XwFormRef * formRef;
1040
1041    formRef = (XwFormRef *) XtMalloc (sizeof (XwFormRef));
1042    formRef -> this = this;
1043    formRef -> ref = ref;
1044    formRef -> offset = offset;
1045    formRef -> add = add;
1046    formRef -> vary = vary;
1047    formRef -> resizable = resizable;
1048    formRef -> attach = attach;
1049    formRef -> attach_offset = attach_offset;
1050
1051    formRef -> set_loc = loc;
1052    formRef -> set_size = size;
1053
1054    formRef -> ref_to = NULL;
1055    formRef -> ref_to_count = 0;
1056
1057    return (formRef);
1058 }
1059
1060
1061
1062
1063 /************************************************************************
1064  *
1065  *  XwFindValidRef
1066  *      Given an initial reference widget to be used as a constraint,
1067  *      find a valid (managed) reference widget.  This is done by
1068  *      backtracking through the widget references listed in the
1069  *      constraint records.  If no valid constraint is found, "form"
1070  *      is returned indicating that this reference should be stuck
1071  *      immediately under the form reference structure.
1072  *
1073  ************************************************************************/
1074
1075 static Widget XwFindValidRef (refWidget, refType, formRef)
1076 Widget refWidget;
1077 int    refType;
1078 XwFormRef * formRef;
1079
1080 {
1081    XwFormConstraintRec * constraint;
1082
1083    if (refWidget == NULL) return (NULL);
1084
1085    while (1)
1086    {
1087       if (XwRefTreeSearch (refWidget, formRef) != NULL) return (refWidget);
1088
1089       constraint = (XwFormConstraintRec *) refWidget -> core.constraints;
1090
1091       if (refType == XwHORIZONTAL) refWidget = constraint -> x_ref_widget;
1092       else refWidget = constraint -> y_ref_widget;
1093
1094       if (refWidget == NULL) return (refWidget -> core.parent);
1095    }
1096 }
1097
1098
1099
1100
1101 /************************************************************************
1102  *
1103  *  XwRefTreeSearch
1104  *      Search the reference tree until the widget listed is found.
1105  *
1106  ************************************************************************/
1107
1108 static XwFormRef * XwRefTreeSearch (w, formRef)
1109 Widget w;
1110 XwFormRef * formRef;
1111
1112 {
1113    register int i;
1114    XwFormRef * tempRef;
1115
1116    if (formRef == NULL) return (NULL);
1117    if (formRef -> this == w) return (formRef);
1118
1119    for (i = 0; i < formRef -> ref_to_count; i++)
1120    {
1121       tempRef = XwRefTreeSearch (w, formRef -> ref_to[i]);
1122       if (tempRef != NULL) return (tempRef);
1123    }
1124
1125    return (NULL);
1126 }
1127
1128
1129
1130
1131 /************************************************************************
1132  *
1133  *  XwParentRefTreeSearch
1134  *      Search the reference tree until the parent reference of the
1135  *      widget listed is found.
1136  *
1137  ************************************************************************/
1138
1139 static XwFormRef * XwParentRefTreeSearch (w, wFormRef, parentFormRef)
1140 Widget w;
1141 XwFormRef * wFormRef;
1142 XwFormRef * parentFormRef;
1143
1144 {
1145    register int i;
1146    XwFormRef * tempRef;
1147
1148    if (parentFormRef == NULL) return (NULL);
1149    if (wFormRef -> this == w) return (parentFormRef);
1150
1151    for (i = 0; i < wFormRef -> ref_to_count; i++)
1152    {
1153       tempRef =
1154          XwParentRefTreeSearch (w, wFormRef -> ref_to[i], wFormRef);
1155       if (tempRef != NULL) return (tempRef);
1156    }
1157
1158    return (NULL);
1159 }
1160
1161
1162
1163
1164 /************************************************************************
1165  *
1166  *  XwAddRef
1167  *      Add a reference structure into a parent reference structure.
1168  *
1169  ************************************************************************/
1170
1171 static void XwAddRef (refParent, ref)
1172 XwFormRef * refParent;
1173 XwFormRef * ref;
1174
1175 {
1176    refParent -> ref_to =
1177       (XwFormRef **)
1178          XtRealloc ((char *) refParent -> ref_to,
1179                     sizeof (XwFormRef *) * (refParent -> ref_to_count + 1));
1180
1181    refParent -> ref_to[refParent -> ref_to_count] = ref;
1182    refParent -> ref_to_count += 1;
1183 }
1184
1185
1186
1187
1188 /************************************************************************
1189  *
1190  *  XwRemoveRef
1191  *      Remove a reference structure from a parent reference structure.
1192  *
1193  ************************************************************************/
1194
1195 static void XwRemoveRef (refParent, ref)
1196 XwFormRef * refParent;
1197 XwFormRef * ref;
1198
1199 {
1200    register int i, j;
1201
1202    for (i = 0; i < refParent -> ref_to_count; i++)
1203    {
1204       if (refParent -> ref_to[i] == ref)
1205       {
1206          for (j = i; j < refParent -> ref_to_count - 1; j++)
1207             refParent -> ref_to[j] = refParent -> ref_to[j + 1];
1208          break;
1209       }
1210    }
1211
1212    if (refParent -> ref_to_count > 1)
1213    {
1214       refParent -> ref_to =
1215          (XwFormRef **)  XtRealloc ((char *) refParent -> ref_to,
1216          sizeof (XwFormRef *) * (refParent -> ref_to_count - 1));
1217
1218    }
1219    else
1220    {
1221       XtFree ((char *)(refParent -> ref_to));
1222       refParent -> ref_to = NULL;
1223    }
1224
1225    refParent -> ref_to_count -= 1;
1226 }
1227
1228
1229
1230
1231 /************************************************************************
1232  *
1233  *  XwProcessRefs
1234  *      Traverse throught the form's reference trees, calculate new
1235  *      child sizes and locations based on the constraints and adjust
1236  *      the children as is calculated.  The resizable flag indicates
1237  *      whether the form can be resized or not.
1238  *
1239  ************************************************************************/
1240
1241 static void XwProcessRefs (fw, formResizable)
1242 XwFormWidget fw;
1243 Boolean      formResizable;
1244
1245 {
1246    int formWidth, formHeight;
1247    register int i, j;
1248
1249    int horDepth, horLeaves;
1250    int vertDepth, vertLeaves;
1251    XwFormProcess ** horProcessList;
1252    XwFormProcess ** vertProcessList;
1253
1254    XtGeometryResult geometryReturn;
1255    Dimension replyW, replyH;
1256
1257    XwFormConstraintRec * constraintRec;
1258    Widget child;
1259    Boolean moveFlag, resizeFlag;
1260
1261
1262    /*  Initialize the form width and height variables  */
1263
1264    if (fw -> manager.layout == XwIGNORE) formResizable = False;
1265
1266    if (formResizable) formWidth = formHeight = -1;
1267    else
1268    {
1269       formWidth = fw -> core.width;
1270       formHeight = fw -> core.height;
1271    }
1272
1273
1274    /*  Traverse the reference trees to find the depth and leaf node count  */
1275
1276    leaves = 0;
1277    depth = 0;
1278    XwFindDepthAndCount (fw -> form.width_tree, 1);
1279    horDepth = depth;
1280    horLeaves = leaves;
1281
1282    leaves = 0;
1283    depth = 0;
1284    XwFindDepthAndCount (fw -> form.height_tree, 1);
1285    vertDepth = depth;
1286    vertLeaves = leaves;
1287
1288    if (horDepth == 0 && vertDepth == 0)
1289       return;
1290
1291
1292    /*  Allocate and initialize the constraint array processing structures  */
1293
1294    horProcessList =
1295        (XwFormProcess **) XtMalloc (sizeof (XwFormProcess **) * horLeaves);
1296    for (i = 0; i < horLeaves; i++)
1297    {
1298       horProcessList[i] =
1299          (XwFormProcess *) XtMalloc (sizeof (XwFormProcess) * horDepth);
1300
1301       for (j = 0; j < horDepth; j++)
1302          horProcessList[i][j].ref = NULL;
1303    }
1304
1305
1306    vertProcessList =
1307       (XwFormProcess **) XtMalloc (sizeof (XwFormProcess **) * vertLeaves);
1308    for (i = 0; i < vertLeaves; i++)
1309    {
1310       vertProcessList[i] =
1311          (XwFormProcess *) XtMalloc (sizeof (XwFormProcess) * vertDepth);
1312
1313       for (j = 0; j < vertDepth; j++)
1314          vertProcessList[i][j].ref = NULL;
1315    }
1316
1317
1318    /*  Initialize the process array placing each node of the tree into    */
1319    /*  the array such that it is listed only once and its first children  */
1320    /*  listed directly next within the array.                             */
1321
1322    arrayIndex = 0;
1323    XwInitProcessList (horProcessList, fw -> form.width_tree, 0);
1324    arrayIndex = 0;
1325    XwInitProcessList (vertProcessList, fw -> form.height_tree, 0);
1326
1327
1328    /*  Process each array such that each row of the arrays contain  */
1329    /*  their required sizes and locations to match the constraints  */
1330
1331    XwConstrainList (horProcessList, horLeaves,
1332                     horDepth, &formWidth, formResizable, XwHORIZONTAL);
1333    XwConstrainList (vertProcessList, vertLeaves,
1334                     vertDepth, &formHeight, formResizable, XwVERTICAL);
1335
1336
1337    /*  If the form is resizable and the form width or height returned  */
1338    /*  is different from the current form width or height, then make   */
1339    /*  a geometry request to get the new form size.  If almost is      */
1340    /*  returned, use these sizes and reprocess the constrain lists     */
1341
1342    if (formResizable &&
1343        (formWidth != fw -> core.width || formHeight != fw -> core.height))
1344    {
1345       geometryReturn =
1346          XtMakeResizeRequest((Widget)fw, formWidth, formHeight, &replyW, &replyH);
1347
1348       if (geometryReturn == XtGeometryAlmost)
1349       {
1350          formWidth = replyW;
1351          formHeight = replyH;
1352
1353          XtMakeResizeRequest((Widget)fw, formWidth, formHeight, NULL, NULL);
1354
1355          XwConstrainList (horProcessList, horLeaves,
1356                           horDepth, &formWidth, False, XwHORIZONTAL);
1357          XwConstrainList (vertProcessList, vertLeaves,
1358                           vertDepth, &formHeight, False, XwVERTICAL);
1359       }
1360
1361       else if (geometryReturn == XtGeometryNo)
1362       {
1363          formWidth = fw -> core.width;
1364          formHeight = fw -> core.height;
1365
1366          XwConstrainList (horProcessList, horLeaves,
1367                           horDepth, &formWidth, False, XwHORIZONTAL);
1368          XwConstrainList (vertProcessList, vertLeaves,
1369                           vertDepth, &formHeight, False, XwVERTICAL);
1370       }
1371    }
1372
1373
1374    /*  Process the forms child list to compare the widget sizes and  */
1375    /*  locations with the widgets current values and if changed,     */
1376    /*  reposition, resize, or reconfigure the child.                 */
1377
1378    for (i = 0; i < fw -> composite.num_children; i++)
1379    {
1380       child = (Widget) fw -> composite.children[i];
1381
1382       if (child -> core.managed)
1383       {
1384          constraintRec = (XwFormConstraintRec *) child -> core.constraints;
1385
1386          moveFlag = resizeFlag = False;
1387
1388          if (constraintRec -> x != child -> core.x ||
1389              constraintRec -> y != child -> core.y)
1390             moveFlag = True;
1391
1392          if (constraintRec -> width != child -> core.width ||
1393              constraintRec -> height != child -> core.height)
1394             resizeFlag = True;
1395
1396          if (moveFlag && resizeFlag)
1397             XtConfigureWidget (child, constraintRec->x, constraintRec->y,
1398                                constraintRec->width, constraintRec->height,
1399                                child -> core.border_width);
1400          else if (moveFlag)
1401             XtMoveWidget (child, constraintRec->x, constraintRec->y);
1402          else if (resizeFlag)
1403             XtResizeWidget (child, constraintRec->width,
1404                             constraintRec->height, child->core.border_width);
1405       }
1406    }
1407
1408    XwFreeConstraintList (horProcessList, horLeaves);
1409    XwFreeConstraintList (vertProcessList, vertLeaves);
1410 }
1411
1412
1413
1414
1415 /************************************************************************
1416  *
1417  *  XwFreeConstraintList
1418  *      Free an allocated constraint list.
1419  *
1420  ************************************************************************/
1421
1422 static void XwFreeConstraintList (processList, leaves)
1423 XwFormProcess ** processList;
1424 int leaves;
1425
1426 {
1427    register int i;
1428
1429
1430    /*  Free each array attached to the list then free the list  */
1431
1432    for (i = 0; i < leaves; i++)
1433       XtFree ((char *)(processList[i]));
1434
1435    XtFree ((char *)processList);
1436 }
1437
1438
1439
1440
1441 /************************************************************************
1442  *
1443  *  XwFindDepthAndCount
1444  *      Search a constraint reference tree and find the maximum depth
1445  *      of the tree and the number of leaves in the tree.
1446  *
1447  ************************************************************************/
1448
1449 static void XwFindDepthAndCount (node, nodeLevel)
1450 XwFormRef * node;
1451 int         nodeLevel;
1452
1453 {
1454    register int i;
1455
1456    if (node -> ref_to == NULL) leaves++;
1457    else
1458    {
1459       nodeLevel++;
1460       if (nodeLevel > depth) depth = nodeLevel;
1461       for (i = 0; i < node -> ref_to_count; i++)
1462          XwFindDepthAndCount (node -> ref_to[i], nodeLevel);
1463    }
1464 }
1465
1466
1467
1468
1469 /************************************************************************
1470  *
1471  *  XwInitProcessList
1472  *      Search a constraint reference tree and find place the ref node
1473  *      pointers into the list.
1474  *
1475  ************************************************************************/
1476
1477 static void XwInitProcessList (processList, node, nodeLevel)
1478 XwFormProcess ** processList;
1479 XwFormRef      * node;
1480 int              nodeLevel;
1481
1482 {
1483    register int i;
1484
1485    processList[arrayIndex][nodeLevel].ref = node;
1486
1487    if (node -> ref_to == NULL)
1488    {
1489       processList[arrayIndex][nodeLevel].leaf = True;
1490       arrayIndex++;
1491    }
1492    else
1493    {
1494       processList[arrayIndex][nodeLevel].leaf = False;
1495       nodeLevel++;
1496       for (i = 0; i < node -> ref_to_count; i++)
1497          XwInitProcessList (processList, node -> ref_to[i], nodeLevel);
1498    }
1499 }
1500
1501
1502
1503 /************************************************************************
1504  *
1505  *  XwConstrainList
1506  *      Process each array such that each row of the arrays contain
1507  *      their required sizes and locations to match the constraints
1508  *
1509  ************************************************************************/
1510
1511 static void XwConstrainList (processList, leaves, depth,
1512                              formSize, varySize, orient)
1513 XwFormProcess ** processList;
1514 int              leaves;
1515 int              depth;
1516 int            * formSize;
1517 Boolean          varySize;
1518 int              orient;
1519
1520 {
1521    register int i, j;
1522    register XwFormRef  * ref;
1523    XwFormConstraintRec * constraint;
1524    XwFormConstraintRec * parentConstraint;
1525    int heldSize;
1526    int sizeDif;
1527    int vary, resize;
1528    int varyCount, varyAmount;
1529    int resizeCount, resizeAmount;
1530    int constantSubtract;
1531    int addAmount, subtractAmount;
1532    int size, separation;
1533
1534
1535
1536    heldSize = 0;
1537
1538
1539    for (i = 0; i < leaves; i++)         /* Process all array lines  */
1540    {
1541       processList[i][0].size = 0;
1542       processList[i][0].loc = 0;
1543
1544
1545       for (j = 1; j < depth; j++)       /* Process array line */
1546       {
1547          ref = processList[i][j].ref;
1548
1549          if (ref != NULL)
1550          {
1551             processList[i][j].size = ref -> set_size;
1552
1553             if (ref -> ref == ref -> this -> core.parent)
1554             {
1555                if (ref -> offset != 0)
1556                   processList[i][j].loc = ref -> offset;
1557                else
1558                   processList[i][j].loc = ref -> set_loc;
1559             }
1560             else
1561             {
1562                processList[i][j].loc =
1563                   processList[i][j - 1].loc + ref->offset;
1564                if (ref -> add)
1565                   processList[i][j].loc += processList[i][j - 1].size +
1566                   processList[i][j].ref -> this -> core.border_width * 2;
1567             }
1568
1569          }
1570          else
1571          {
1572             processList[i][j].ref = processList[i - 1][j].ref;
1573             processList[i][j].loc = processList[i - 1][j].loc;
1574             processList[i][j].size = processList[i - 1][j].size;
1575             processList[i][j].leaf = processList[i - 1][j].leaf;
1576          }
1577
1578          if (processList[i][j].leaf)
1579          {
1580             if (processList[i][0].size < processList[i][j].size +
1581                 processList[i][j].ref -> this -> core.border_width * 2 +
1582                 processList[i][j].loc + ref -> attach_offset)
1583             {
1584                processList[i][0].size = processList[i][j].size +
1585                   processList[i][j].ref -> this -> core.border_width * 2 +
1586                   processList[i][j].loc + ref -> attach_offset;
1587             }
1588
1589             if (processList[i][j].leaf && processList[i][0].size > heldSize)
1590                heldSize = processList[i][0].size;
1591
1592             break;
1593          }
1594       }
1595    }
1596
1597
1598    /*  Each array line has now been processed to optimal size.  Reprocess  */
1599    /*  each line to constrain it to formSize if not varySize or to         */
1600    /*  heldSize if varySize.                                               */
1601
1602    if (varySize)
1603       *formSize = heldSize;
1604
1605
1606
1607    for (i = 0; i < leaves; i++)
1608    {
1609
1610       /*  For each array line if the 0th size (calculated form size needed  */
1611       /*  for this array line is less than the form size then increase the  */
1612       /*  seperations between widgets whose constaints allow it.            */
1613       /*  If can't do it by varying separation, but can do it by resizing,  */
1614       /*  then do that.                                                     */
1615
1616       if (processList[i][0].size < *formSize)
1617       {
1618          sizeDif = *formSize - processList[i][0].size;
1619
1620          varyCount = 0;
1621          resizeCount = 0;
1622          for (j = 1; j < depth; j++)
1623          {
1624              /*  Can't vary the first spacing  */
1625              if (j > 1 && processList[i][j].ref -> vary) varyCount++;
1626              if (processList[i][j].ref -> resizable) resizeCount++;
1627              if (processList[i][j].leaf) break;
1628          }
1629
1630          addAmount = 0;
1631          resizeAmount = 0;
1632          if (varyCount == 0)
1633          {
1634              varyAmount = 0;
1635              if (resizeCount != 0)
1636                 resizeAmount = sizeDif / resizeCount;
1637          }
1638          else varyAmount = sizeDif / varyCount;
1639
1640          j = 1;
1641
1642          while (j < depth)
1643          {
1644             if (j > 1 && processList[i][j].ref -> vary)
1645                addAmount += varyAmount;
1646             processList[i][j].loc += addAmount;
1647             if (processList[i][j].ref -> resizable)
1648             {
1649                processList[i][j].size += resizeAmount;
1650                addAmount += resizeAmount;
1651             }
1652
1653             if (processList[i][j].leaf) break;
1654
1655             j++;
1656          }
1657
1658          if (j > 1)
1659          {
1660             if (processList[i][j].ref -> vary   &&
1661                 processList[i][j].ref -> attach)
1662                processList[i][j].loc = *formSize - processList[i][j].size -
1663                                        processList[i][j].ref -> attach_offset;
1664             else if (processList[i][j].ref -> vary == False &&
1665                      processList[i][j].ref -> resizable     &&
1666                      processList[i][j].ref -> attach)
1667             {
1668                processList[i][j].size =
1669                   *formSize - processList[i][j].loc -
1670                   processList[i][j].ref -> this -> core.border_width * 2 -
1671                   processList[i][j].ref -> attach_offset;
1672             }
1673          }
1674          else
1675          {
1676             if (processList[i][j].ref -> vary == False &&
1677                 processList[i][j].ref -> resizable     &&
1678                 processList[i][j].ref -> attach)
1679             {
1680                processList[i][j].loc = processList[i][j].ref -> offset;
1681                processList[i][j].size =
1682                   *formSize - processList[i][j].loc -
1683                   processList[i][j].ref -> this -> core.border_width * 2 -
1684                   processList[i][j].ref -> attach_offset;
1685
1686             }
1687             else if (processList[i][j].ref -> vary &&
1688                      processList[i][j].ref -> attach)
1689             {
1690                processList[i][j].loc =
1691                   *formSize - processList[i][j].size -
1692                   processList[i][j].ref -> this -> core.border_width * 2 -
1693                   processList[i][j].ref -> attach_offset;
1694             }
1695             else if (processList[i][j].ref -> vary &&
1696                      processList[i][j].ref -> attach == False)
1697             {
1698                processList[i][j].loc = processList[i][j].ref -> offset;
1699             }
1700          }
1701       }
1702
1703
1704       /*  If the form size has gotton smaller, process the vary constraints */
1705       /*  until the needed size is correct or all seperations are 1 pixel.  */
1706       /*  If separations go to 1, then process the resizable widgets        */
1707       /*  until the needed size is correct or the sizes have gone to 1      */
1708       /*  pixel.  If the size is still not correct punt, cannot find a      */
1709       /*  usable size so clip it.                                           */
1710
1711       if (processList[i][0].size > *formSize)
1712       {
1713          sizeDif = processList[i][0].size - *formSize;
1714
1715          varyAmount = 0;
1716          varyCount = 0;
1717
1718          j = 0;
1719          do
1720          {
1721             j++;
1722
1723             if (j > 1 && processList[i][j].ref -> vary &&
1724                 processList[i][j].ref -> offset)
1725             {
1726                varyAmount += processList[i][j].ref -> offset;
1727                varyCount++;
1728             }
1729          }
1730          while (processList[i][j].leaf == False);
1731
1732
1733          resizeAmount = 0;
1734          resizeCount = 0;
1735          for (j = 1; j < depth; j++)
1736          {
1737             if (processList[i][j].ref->resizable && processList[i][j].size > 1)
1738             {
1739                if (processList[i][j].leaf || processList[i][j+1].ref->add)
1740                {
1741                   resizeCount++;
1742                   resizeAmount += processList[i][j].size - 1;
1743                }
1744             }
1745             if (processList[i][j].leaf) break;
1746          }
1747
1748
1749          /*  Do we have enough varience to match the constraints?  */
1750
1751          if (varyAmount + resizeAmount > sizeDif)
1752          {
1753
1754             /*  first process out the vary amount  */
1755
1756             if (varyCount)
1757             {
1758                do
1759                {
1760                   subtractAmount = 0;
1761
1762                   for (j = 1; j < depth; j++)
1763                   {
1764                      if (j > 1 && processList[i][j].ref -> vary)
1765                      {
1766                         vary =
1767                            processList[i][j].loc - processList[i][j - 1].loc;
1768
1769                         if (processList[i][j].ref -> add)
1770                            vary = vary - processList[i][j - 1].size - 1 -
1771                                   processList[i][j-1].ref->
1772                                   this->core.border_width * 2;
1773                      }
1774                      else vary = 0;
1775
1776                      if (vary > 0) subtractAmount++;
1777
1778                      if (subtractAmount)
1779                      {
1780                         processList[i][j].loc -= subtractAmount;
1781                         sizeDif--;
1782                      }
1783
1784                      if (processList[i][j].leaf) break;
1785                   }
1786                }
1787                while (subtractAmount != 0 && sizeDif > 0);
1788             }
1789
1790
1791             /*  now process resize constraints if further constraint */
1792             /*  processing is necessary.                             */
1793
1794             if (sizeDif)
1795             {
1796                if (resizeAmount > sizeDif) resizeAmount = sizeDif;
1797                if (resizeCount) constantSubtract = resizeAmount / resizeCount;
1798
1799                while (resizeAmount > 0)
1800                {
1801                   subtractAmount = 0;
1802
1803                   for (j = 1; j < depth; j++)
1804                   {
1805                      if (processList[i][j].ref -> add)
1806                         processList[i][j].loc -= subtractAmount;
1807
1808                      if (processList[i][j].ref -> resizable)
1809                      {
1810                         if (processList[i][j].leaf ||
1811                             processList[i][j + 1].ref -> add)
1812                            resize = processList[i][j].size - 1;
1813                         else
1814                            resize = 0;
1815
1816                         if (resize > 1)
1817                         {
1818                            if (constantSubtract < resize)
1819                               resize = constantSubtract;
1820                            subtractAmount += resize;
1821                            processList[i][j].size -= resize;
1822                         }
1823                      }
1824
1825                      if (processList[i][j].leaf) break;
1826                   }
1827
1828                   resizeAmount -= subtractAmount;
1829                   constantSubtract = 1;
1830                }
1831             }
1832          }
1833       }
1834    }
1835
1836
1837
1838    /*  Now each array line is processed such that its line is properly  */
1839    /*  constrained to match the specified form size.  Since a single    */
1840    /*  widget reference structure can be referenced in multiple array   */
1841    /*  lines, the minumum constraint for each widget needs to be found. */
1842    /*  When found, the width and height will be placed into the widgets */
1843    /*  constraint structure.                                            */
1844
1845    for (i = 1; i < depth; i++)
1846    {
1847       ref = NULL;
1848
1849       for (j = 0; j < leaves + 1; j++)    /*  loop one to many - for exit  */
1850       {
1851          if (j == leaves || ref != processList[j][i].ref)
1852          {
1853             if (j == leaves || ref != NULL)
1854             {
1855                if (ref != NULL)
1856                {
1857                   constraint =
1858                      (XwFormConstraintRec *) ref -> this -> core.constraints;
1859                   parentConstraint =
1860                      (XwFormConstraintRec *) ref -> ref -> core.constraints;
1861
1862                   if (orient == XwHORIZONTAL) constraint -> width = size;
1863                   else constraint -> height = size;
1864
1865                   if (i > 1)
1866                   {
1867                      if (orient== XwHORIZONTAL)
1868                         constraint -> x = parentConstraint -> x + separation;
1869                      else
1870                         constraint -> y = parentConstraint -> y + separation;
1871                   }
1872                   else
1873                   {
1874                      if (orient == XwHORIZONTAL) constraint -> x = separation;
1875                      else constraint -> y = separation;
1876                   }
1877                }
1878
1879                if (j == leaves) break;  /* exit out of the inner loop  */
1880             }
1881
1882             ref = processList[j][i].ref;
1883             separation = 10000000;
1884             size = 10000000;
1885          }
1886
1887          if (ref != NULL)
1888          {
1889             if (size > processList[j][i].size) size = processList[j][i].size;
1890
1891             if (i > 1)
1892             {
1893                if (separation > processList[j][i].loc-processList[j][i-1].loc)
1894                   separation = processList[j][i].loc-processList[j][i-1].loc;
1895             }
1896             else
1897                if (separation > processList[j][i].loc)
1898                    separation = processList[j][i].loc;
1899          }
1900       }
1901    }
1902 }