bgui/groupclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * groupclass.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 42.4  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.3  2000/08/10 17:52:47  stegerg
  18  * temp fix for relayout refresh bug which only happens in AROS. temp. solved
  19  * by doing a RefreshGList in windowclass.c/WindowClassRelease method.
  20  *
  21  * Revision 42.2  2000/05/15 19:27:01  stegerg
  22  * another hundreds of REG() macro replacements in func headers/protos.
  23  *
  24  * Revision 42.1  2000/05/14 23:32:47  stegerg
  25  * changed over 200 function headers which all use register
  26  * parameters (oh boy ...), because the simple REG() macro
  27  * doesn't work with AROS. And there are still hundreds
  28  * of headers left to be fixed :(
  29  *
  30  * Many of these functions would also work with stack
  31  * params, but since i have fixed every single one
  32  * I encountered up to now, I guess will have to do
  33  * the same for the rest.
  34  *
  35  * Revision 42.0  2000/05/09 22:09:07  mlemos
  36  * Bumped to revision 42.0 before handing BGUI to AROS team
  37  *
  38  * Revision 41.11  2000/05/09 19:54:22  mlemos
  39  * Merged with the branch Manuel_Lemos_fixes.
  40  *
  41  * Revision 41.10.2.11  1999/08/30 04:57:41  mlemos
  42  * Made the methods that change group members on-fly setup the gadget
  43  * attributes using the window WINDOW_SETUPGADGET method.
  44  *
  45  * Revision 41.10.2.10  1999/08/29 20:21:59  mlemos
  46  * Renamed the GRM_RELAYOUT to BASE_RELAYOUT.
  47  *
  48  * Revision 41.10.2.9  1999/08/29 18:58:51  mlemos
  49  * Added support to the LGO_Relayout attribute to be able to not relayout a
  50  * when calling GRM_ADDMEMBER, GRM_INSERTMEMBER, GRM_REPLACEMEMBER.
  51  *
  52  * Revision 41.10.2.8  1998/10/14 04:07:55  mlemos
  53  * Fixed the computation of group members minimum, maximum and nominam sizes.
  54  *
  55  * Revision 41.10.2.7  1998/07/05 19:19:26  mlemos
  56  * Fixed bug of Group node instance data pointer be passed instead of the
  57  * object pointer.
  58  *
  59  * Revision 41.10.2.6  1998/03/02 01:31:21  mlemos
  60  * Fixed members list memory leak when group has no members.
  61  * Added functions to obtain and release the members list.
  62  *
  63  * Revision 41.10.2.5  1998/03/02 00:22:18  mlemos
  64  * Fixed extention determination when a group is empty.
  65  *
  66  * Revision 41.10.2.4  1998/03/01 17:36:48  mlemos
  67  * Fixed memory leaks from group member list allocations.
  68  * Prevented nest calls to retrieve copies of the group members list.
  69  *
  70  * Revision 41.10.2.3  1998/02/28 02:44:06  mlemos
  71  * Made GRM_DIMENSIONS method obtain the group members list.
  72  *
  73  * Revision 41.10.2.2  1998/02/26 22:37:53  mlemos
  74  * Commented out unused variables.
  75  * Added casts to GadgetInfo structure where BaseInfo is passed.
  76  * Fixed Group Node Class RM_REMOVE call.
  77  *
  78  * Revision 41.10.2.1  1998/02/26 17:45:40  mlemos
  79  * Added support for getting a group node object
  80  *
  81  * Revision 41.10  1998/02/25 21:12:11  mlemos
  82  * Bumping to 41.10
  83  *
  84  * Revision 1.1  1998/02/25 17:08:29  mlemos
  85  * Ian sources
  86  *
  87  *
  88  */
  89
  90 #define WW(x)
  91
  92 #include "include/classdefs.h"
  93
  94 /// Class definitions.
  95 /*
  96  * Group member node.
  97  */
  98 typedef struct {
  99    Object         *md_Object;                   /* The object itself.        */
 100    struct IBox     md_Bounds;                   /* Bounds relative to group. */
 101    ULONG           md_Weight;                   /* The object weight.        */
 102    WORD            md_FixedWidth;               /* Fixed width.              */
 103    WORD            md_FixedHeight;              /* Fixed height.             */
 104    UWORD           md_AspectX, md_AspectY;      /* Fixed Aspect ratio.       */
 105    UWORD           md_MinWidth, md_MinHeight;   /* Minimum width and height. */
 106    UWORD           md_MaxWidth, md_MaxHeight;   /* Maximum width and height. */
 107    UWORD           md_NomWidth, md_NomHeight;   /* Nominal width and height. */
 108    UWORD           md_HBLeft;                   /* Hit-box leftedge.         */
 109    UWORD           md_ScaledSize;               /* Scaled size.              */
 110    UWORD           md_Flags;                    /* See below.                */
 111    UBYTE           md_HAlign, md_VAlign;        /* Alignment.                */
 112    Object         *md_Group;                    /* The group we are in.      */
 113 }  MD;
 114
 115 #define MDF_FIXEDWIDTH     (1<<0)         /* Fix width.                           */
 116 #define MDF_FIXEDHEIGHT    (1<<1)         /* Fix height.                          */
 117 #define MDF_SPACING        (1<<2)         /* This is a spacing object.            */
 118 #define MDF_NO_ALIGN       (1<<3)         /* Object must not be aligned.          */
 119 #define MDF_RESERVED       (1<<4)         /* Reserved bit.                        */
 120 #define MDF_NO_NO_ALIGN    (1<<5)         /* Force alignment.                     */
 121 #define MDF_HIDDEN         (1<<6)         /* Member hidden?                       */
 122 ///
 123
 124 /// SetGroupNodeAttrs
 125
 126 STATIC IPTR ASM SetGroupNodeAttrs(REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct opSet *ops)
 127 {
 128    MD              *md = INST_DATA(cl, obj);
 129    IPTR             data;
 130    struct TagItem  *tstate = ops->ops_AttrList;
 131    struct TagItem  *tag;
 132    BOOL             relayout = FALSE;
 133
 134    /*
 135     * Scan LGO attributes.
 136     */
 137    while ((tag = NextTagItem(&tstate)))
 138    {
 139       data = tag->ti_Data;
 140       switch (tag->ti_Tag)
 141       {
 142       case LGO_Left:
 143          md->md_Bounds.Left = data;
 144          break;
 145
 146       case LGO_Top:
 147          md->md_Bounds.Top = data;
 148          break;
 149
 150       case LGO_Width:
 151          md->md_Bounds.Width = data;
 152          break;
 153
 154       case LGO_Height:
 155          md->md_Bounds.Height = data;
 156          break;
 157
 158       case LGO_Object:
 159          md->md_Object = (Object *)data;
 160          break;
 161
 162       case LGO_Group:
 163          md->md_Group = (Object *)data;
 164          break;
 165
 166       case LGO_SpaceObject:
 167          md->md_Object = BGUI_NewObjectA(BGUI_SPACING_OBJECT, NULL);
 168          md->md_Weight = data;
 169          md->md_Flags |= MDF_SPACING;
 170          break;
 171
 172       case LGO_Weight:
 173          if (data < 1) data = 1;
 174          if (md->md_Weight != data)
 175          {
 176             md->md_Weight = data;
 177             relayout = TRUE;
 178          };
 179          break;
 180
 181       case LGO_FixWidth:
 182          md->md_FixedWidth  = (WORD)data;
 183          break;
 184
 185       case LGO_FixHeight:
 186          md->md_FixedHeight = (WORD)data;
 187          break;
 188
 189       case LGO_FixMinWidth:
 190          md->md_FixedWidth  = data ? 0 : -1;
 191          break;
 192
 193       case LGO_FixMinHeight:
 194          md->md_FixedHeight = data ? 0 : -1;
 195          break;
 196
 197       case LGO_Align:
 198          if (data)
 199             md->md_Flags |= MDF_NO_NO_ALIGN;
 200          break;
 201
 202       case LGO_NoAlign:
 203          if (data)
 204             md->md_Flags |= MDF_NO_ALIGN;
 205          break;
 206
 207       case LGO_FixAspect:
 208          if ((md->md_AspectX != ((data>>16) & 0xffff)) &&
 209              (md->md_AspectY != ((data>> 0) & 0xffff)))
 210          {
 211             md->md_AspectX = (data>>16) & 0xffff;
 212             md->md_AspectY = (data>> 0) & 0xffff;
 213             relayout = TRUE;
 214          };
 215          break;
 216
 217       case LGO_Visible:
 218          if (data)
 219          {
 220             if (md->md_Flags & MDF_HIDDEN)
 221             {
 222                md->md_Flags &= ~MDF_HIDDEN;
 223                relayout = TRUE;
 224             };
 225          }
 226          else
 227          {
 228             if (!(md->md_Flags & MDF_HIDDEN))
 229             {
 230                md->md_Flags |= MDF_HIDDEN;
 231                relayout = TRUE;
 232             };
 233          };
 234          break;
 235       };
 236    };
 237    if (relayout && md->md_Group) RelayoutGroup(md->md_Group);
 238
 239    return 1;
 240 }
 241 ///
 242
 243 /// OM_NEW
 244 /*
 245  * Create a shiny new object.
 246  */
 247 METHOD(GroupNodeClassNew, struct opSet *, ops)
 248 {
 249    MD          *md;
 250    IPTR         rc;
 251
 252    /*
 253     * First we let the superclass
 254     * create the object.
 255     */
 256    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)ops)))
 257    {
 258       md                 = INST_DATA(cl, rc);
 259       md->md_Weight      = DEFAULT_WEIGHT;
 260       md->md_FixedWidth  = -1;
 261       md->md_FixedHeight = -1;
 262
 263       /*
 264        * Setup user attributes.
 265        */
 266       SetGroupNodeAttrs(cl, (Object *)rc, ops);
 267
 268       if (md->md_Object && md->md_Group)
 269       {
 270          DoSetMethodNG(md->md_Object, BT_GroupMember,  rc,
 271                                       BT_ParentGroup,  md->md_Group,
 272                                       BT_ParentWindow, BASE_DATA(md->md_Group)->bc_Window,
 273                                       TAG_DONE);
 274
 275          return rc;
 276       };
 277
 278       AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 279    }
 280    return 0;
 281 }
 282 METHOD_END
 283 ///
 284 /// OM_SET
 285 /*
 286  * Change one or more of the object
 287  * it's attributes.
 288  */
 289 METHOD(GroupNodeClassSet, struct opSet *, ops)
 290 {
 291    AsmDoSuperMethodA(cl, obj, (Msg)ops);
 292
 293    return SetGroupNodeAttrs(cl, obj, ops);
 294 }
 295 METHOD_END
 296 ///
 297 /// OM_GET
 298 /*
 299  * Give one of the attributes.
 300  */
 301 METHOD(GroupNodeClassGet, struct opGet *, opg)
 302 {
 303    MD             *md = INST_DATA(cl, obj);
 304    ULONG           rc = 1;
 305    IPTR           *store = opg->opg_Storage;
 306
 307    switch (opg->opg_AttrID)
 308    {
 309    case LGO_MinWidth:
 310       STORE md->md_MinWidth;
 311       break;
 312    case LGO_MinHeight:
 313       STORE md->md_MinHeight;
 314       break;
 315    case LGO_MaxWidth:
 316       STORE md->md_MaxWidth;
 317       break;
 318    case LGO_MaxHeight:
 319       STORE md->md_MaxHeight;
 320       break;
 321    case LGO_NomWidth:
 322       STORE md->md_NomWidth;
 323       break;
 324    case LGO_NomHeight:
 325       STORE md->md_NomHeight;
 326       break;
 327    case LGO_Object:
 328       STORE md->md_Object;
 329       break;
 330    default:
 331       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 332       break;
 333    };
 334    return rc;
 335 }
 336 METHOD_END
 337 ///
 338 /// RM_REMOVE
 339 /*
 340  * Remove node.
 341  */
 342 METHOD(GroupNodeClassRemove, Msg, msg)
 343 {
 344    MD          *md = INST_DATA(cl, obj);
 345
 346    if (md->md_Object)
 347      DoSetMethodNG(md->md_Object, BT_ParentWindow, NULL, BT_ParentGroup, NULL, BT_GroupMember, NULL, TAG_DONE);
 348
 349    return AsmDoSuperMethodA(cl, obj, msg);
 350 }
 351 METHOD_END
 352 ///
 353
 354 /// Class initialization.
 355 /*
 356  * Function table.
 357  */
 358 STATIC DPFUNC ClassFuncNode[] = {
 359    { OM_NEW,              GroupNodeClassNew },
 360    { OM_SET,              GroupNodeClassSet },
 361    { OM_GET,              GroupNodeClassGet },
 362    { RM_REMOVE,           GroupNodeClassRemove },
 363    { DF_END },
 364 };
 365
 366 static Class *GMClass = NULL;
 367 #define MEMBER_DATA(m) ((MD *)INST_DATA(GMClass, ((Object *)m)))
 368
 369 /*
 370  * Simple class initialization.
 371  */
 372 makeproto Class *InitGroupNodeClass(void)
 373 {
 374    return GMClass = BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_ROOT_OBJECT,
 375                                    CLASS_ObjectSize,     sizeof(MD),
 376                                    CLASS_DFTable,        ClassFuncNode,
 377                                    TAG_DONE);
 378 }
 379 ///
 380
 381
 382 /// Class definitions.
 383
 384 typedef struct {
 385    UWORD           td_Min;
 386    UWORD           td_Nom;
 387    UWORD           td_Max;
 388    UWORD           td_Size;
 389    UWORD           td_Weight;
 390    UWORD           td_PreAlign;
 391    UWORD           td_PostAlign;
 392 }  TD;
 393
 394 /*
 395  * Object instance data.
 396  */
 397 typedef struct {
 398    struct SignalSemaphore   gd_Lock;         /* Semaphore for safety purposes. */
 399    Object                 **gd_MD;           /* Array of object pointers.      */
 400    struct MinList           gd_Members;      /* Group members.                 */
 401    UWORD                    gd_NumMembers;   /* Number of members.             */
 402    UWORD                    gd_Rows;         /* Rows in HGroup.                */
 403    UWORD                    gd_Columns;      /* Columns in VGroup.             */
 404    UBYTE                    gd_HAlign;       /* Horizontal alignment.          */
 405    UBYTE                    gd_VAlign;       /* Vertical alignment.            */
 406    UWORD                    gd_SpaceX;       /* Inner-object spacing.          */
 407    UWORD                    gd_SpaceY;       /* Inner-object spacing.          */
 408    TD                      *gd_RD, *gd_CD;   /* Row and column descriptors.    */
 409    Object                  *gd_Active;       /* Active member.                 */
 410    UBYTE                    gd_Flags;        /* See below.                     */
 411    UBYTE                    gd_Style;        /* Style.                         */
 412 }  GD;
 413
 414 #define GDF_ADD_FAILURE         (1<<0)         /* Error flag.                          */
 415 #define GDF_HAS_TITLE           (1<<1)         /* Group is framed with a title.        */
 416 #define GDF_IS_MASTER           (1<<2)         /* This is the master group.            */
 417 #define GDF_EQUAL_MINWIDTH      (1<<3)         /* All objects have the same min width. */
 418 #define GDF_EQUAL_MINHEIGHT     (1<<4)         /* All objects have the same min height.*/
 419 #define GDF_BUFFER              (1<<5)         /* Buffer rendering.                    */
 420 ///
 421
 422 /// NextGroupNode
 423
 424 STATIC ASM MD *NextGroupNode(REG(a0) GD *gd, REG(a1) Object **node, REG(d0) ULONG flags)
 425 {
 426    Object    *next;
 427    MD        *md;
 428
 429    do
 430    {
 431       if (*node) next = (Object *)AsmDoMethod(*node, RM_NEXT);
 432       else       next = ListHeadObject((struct List *)&gd->gd_Members);
 433
 434       if (!(*node = next)) return NULL;
 435
 436       md = MEMBER_DATA(next);
 437
 438    }  while (md->md_Flags & flags);
 439
 440    return md;
 441 }
 442 ///
 443 /// GroupNode
 444
 445 STATIC ASM Object *GroupNode(REG(a0) GD *gd, REG(d0) int i, REG(d1) int j)
 446 {
 447    switch (gd->gd_Style)
 448    {
 449    case GRSTYLE_HORIZONTAL:
 450       j = (i * gd->gd_Columns) + j;
 451       break;
 452    case GRSTYLE_VERTICAL:
 453       j = (j * gd->gd_Rows) + i;
 454       break;
 455    default:
 456       return NULL;
 457    };
 458
 459    if (j < gd->gd_NumMembers) return gd->gd_MD[j];
 460
 461    return NULL;
 462 }
 463
 464 ///
 465 /// VSpace, HSpace
 466
 467 static UWORD VSpace(UWORD space)
 468 {
 469    switch (space)
 470    {
 471    case (UWORD)GRSPACE_NARROW:
 472       return (UWORD)GetTagData(GROUP_DefVSpaceNarrow, 2, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 473    case (UWORD)GRSPACE_NORMAL:
 474       return (UWORD)GetTagData(GROUP_DefVSpaceNormal, 4, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 475    case (UWORD)GRSPACE_WIDE:
 476       return (UWORD)GetTagData(GROUP_DefVSpaceWide,   8, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 477    };
 478    return space;
 479 }
 480 static UWORD HSpace(UWORD space)
 481 {
 482    switch (space)
 483    {
 484    case (UWORD)GRSPACE_NARROW:
 485       return (UWORD)GetTagData(GROUP_DefHSpaceNarrow, 2, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 486    case (UWORD)GRSPACE_NORMAL:
 487       return (UWORD)GetTagData(GROUP_DefHSpaceNormal, 4, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 488    case (UWORD)GRSPACE_WIDE:
 489       return (UWORD)GetTagData(GROUP_DefHSpaceWide,   8, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 490    };
 491    return space;
 492 }
 493 ///
 494 /// FindObNode
 495
 496 STATIC ASM Object *FindObNode(REG(a0) GD *gd, REG(a1) Object *find)
 497 {
 498    Object         *m = NULL;
 499    MD             *md;
 500
 501    if (find)
 502    {
 503       /*
 504        * Try to locate the object.
 505        */
 506       while ((md = NextGroupNode(gd, &m, 0)))
 507       {
 508          /*
 509           * Is this the one?
 510           */
 511          if (md->md_Object == find) return m;
 512       };
 513    };
 514    return NULL;
 515 }
 516 ///
 517
 518 /// GROUPM_NEWMEMBER
 519
 520 METHOD(GroupClassNewMember, struct opSet *, ops)
 521 {
 522    return (IPTR)BGUI_NewObjectA(BGUI_GROUP_NODE, ops->ops_AttrList);
 523 }
 524 METHOD_END
 525 ///
 526 /// NewGroupMember
 527 /*
 528  * Allocate and initialize a member structure.
 529  */
 530 STATIC Object *NewGroupMember(Object *obj, Object *member, struct TagItem *attrs)
 531 {
 532    struct TagItem tags[3], *t = tags;
 533
 534    t->ti_Tag = LGO_Group;  t->ti_Data = (IPTR)obj; t++;
 535    t->ti_Tag = LGO_Object; t->ti_Data = (IPTR)member; t++;
 536    t->ti_Tag = TAG_MORE;   t->ti_Data = (IPTR)attrs;
 537
 538    return (Object *)AsmDoMethod(obj, GROUPM_NEWMEMBER, tags, NULL);
 539 }
 540 ///
 541 /// NewSpaceObject
 542 /*
 543  * Add a spacing object.
 544  */
 545 STATIC Object *NewSpaceObject(Object *obj, ULONG weight)
 546 {
 547    struct TagItem tags[3], *t = tags;
 548
 549    t->ti_Tag = LGO_Group;  t->ti_Data = (IPTR)obj; t++;
 550    t->ti_Tag = LGO_SpaceObject; t->ti_Data = (IPTR)weight; t++;
 551    t->ti_Tag = TAG_DONE;
 552
 553    return (Object *)AsmDoMethod(obj, GROUPM_NEWMEMBER, tags, NULL);
 554 }
 555 ///
 556 /// GroupSetAttrs
 557 /*
 558  * Pass an attribute on to the members.
 559  */
 560 STATIC ASM void PassAttr(REG(a0) GD *gd, REG(a1) struct TagItem *tag, REG(a2) struct GadgetInfo *gi)
 561 {
 562    Object         *m;
 563    MD             *md;
 564    struct opSet    ops;
 565    struct TagItem  T[2];
 566
 567    T[0].ti_Tag      = tag->ti_Tag;
 568    T[0].ti_Data     = tag->ti_Data;
 569    T[1].ti_Tag      = TAG_DONE;
 570
 571    ops.MethodID     = OM_SET;
 572    ops.ops_AttrList = T;
 573    ops.ops_GInfo    = gi;
 574
 575    m = NULL;
 576    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
 577       AsmDoMethodA(md->md_Object, (Msg)&ops);
 578 }
 579
 580 /*
 581  * Set one or more attributes.
 582  */
 583 IPTR ASM GroupSetAttrs(REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct opSet *ops)
 584 {
 585    GD                *gd = INST_DATA(cl, obj);
 586    BC                *bc = BASE_DATA(obj);
 587    struct TagItem    *tstate = ops->ops_AttrList, *tag;
 588    ULONG              data, attr;
 589    struct GadgetInfo *gi = ops->ops_GInfo;
 590
 591    /*
 592     * Make sure we stay with the correct activation flags.
 593     */
 594    GADGET(obj)->Activation |= GACT_RELVERIFY;
 595
 596    /*
 597     * Pass on some tags.
 598     */
 599    while ((tag = BGUI_NextTagItem(&tstate)))
 600    {
 601       data = tag->ti_Data;
 602       switch (tag->ti_Tag)
 603       {
 604       case FRM_Title:
 605          if (data) gd->gd_Flags |= GDF_HAS_TITLE;
 606          else      gd->gd_Flags &= ~GDF_HAS_TITLE;
 607          break;
 608
 609       case FRM_Type:
 610          if (data == FRTYPE_DEFAULT)
 611          {
 612             data = GetTagData(FRM_DefaultType, FRTYPE_NEXT, BGUI_GetDefaultTags(BGUI_GROUP_GADGET));
 613             DoSetMethodNG(bc->bc_Frame, FRM_Type, data, TAG_DONE);
 614          };
 615          break;
 616
 617       case GA_TopBorder:
 618       case GA_BottomBorder:
 619       case GA_LeftBorder:
 620       case GA_RightBorder:
 621       case BT_TextAttr:
 622       case BT_ParentWindow:
 623       case BT_ParentView:
 624       case GA_Disabled:
 625       case FRM_ThinFrame:
 626          PassAttr(gd, tag, gi);
 627          break;
 628
 629       case GROUP_IsMaster:
 630          /*
 631           * Master group?
 632           */
 633          if (data) gd->gd_Flags |=  GDF_IS_MASTER;
 634          else      gd->gd_Flags &= ~GDF_IS_MASTER;
 635          break;
 636
 637       case GROUP_Spacing:
 638          gd->gd_SpaceX = gd->gd_SpaceY = data;
 639          break;
 640
 641       case GROUP_HorizSpacing:
 642          gd->gd_SpaceX = data;
 643          break;
 644
 645       case GROUP_VertSpacing:
 646          gd->gd_SpaceY = data;
 647          break;
 648
 649       case GROUP_Rows:
 650          gd->gd_Rows = data;
 651          break;
 652
 653       case GROUP_Columns:
 654          gd->gd_Columns = data;
 655          break;
 656
 657       case GROUP_Style:
 658          gd->gd_Style = data;
 659          break;
 660
 661       case GROUP_HorizAlign:
 662          gd->gd_HAlign = data;
 663          break;
 664
 665       case GROUP_VertAlign:
 666          gd->gd_VAlign = data;
 667          break;
 668
 669       case GROUP_EqualWidth:
 670          if (data) gd->gd_Flags |=  GDF_EQUAL_MINWIDTH;
 671          else      gd->gd_Flags &= ~GDF_EQUAL_MINWIDTH;
 672          break;
 673
 674       case GROUP_EqualHeight:
 675          if (data) gd->gd_Flags |=  GDF_EQUAL_MINHEIGHT;
 676          else      gd->gd_Flags &= ~GDF_EQUAL_MINHEIGHT;
 677          break;
 678
 679       case GROUP_BackFill:
 680          attr = FRM_BackFill;
 681          goto frame_attr;
 682
 683       case GROUP_BackPen:
 684          attr = FRM_BackPen;
 685          goto frame_attr;
 686
 687       case GROUP_BackDriPen:
 688          attr = FRM_BackDriPen;
 689          goto frame_attr;
 690
 691       frame_attr:
 692          DoSuperSetMethodNG(cl, obj, bc->bc_Frame ? TAG_IGNORE : FRM_Type, FRTYPE_NONE, attr, data, TAG_DONE);
 693          break;
 694       };
 695    };
 696    return 1;
 697 }
 698 ///
 699
 700 /// OM_NEW
 701 /*
 702  * Create a new object.
 703  */
 704 METHOD(GroupClassNew, struct opSet *, ops)
 705 {
 706    GD               *gd;
 707    struct TagItem   *tags = ops->ops_AttrList, *tstate, *tag;
 708    IPTR              rc;
 709    IPTR              data;
 710    BOOL              invert = FALSE;
 711    Object           *m;
 712    struct Node      *n1, *n2;
 713    int               l = 0, r = 0, t = 0, b = 0;
 714
 715    /*
 716     * Let the superclass make an object.
 717     */
 718    if ((rc = NewSuperObject(cl, obj, tags)))
 719    {
 720       /*
 721        * Obtain instance data.
 722        */
 723       gd = INST_DATA(cl, rc);
 724
 725       /*
 726        * Initialize member list and other data.
 727        */
 728       NewList((struct List *)&gd->gd_Members);
 729       InitSemaphore(&gd->gd_Lock);
 730       gd->gd_MD=NULL;
 731       gd->gd_NumMembers=0;
 732
 733       tstate = tags;
 734       /*
 735        * Initialize the rest of the instance data.
 736        */
 737       while ((tag = BGUI_NextTagItem(&tstate)))
 738       {
 739          data = tag->ti_Data;
 740
 741          switch (tag->ti_Tag)
 742          {
 743          case GROUP_Offset:
 744             l = r = t = b = data;
 745             break;
 746
 747          case GROUP_HorizOffset:
 748             l = r = data;
 749             break;
 750
 751          case GROUP_VertOffset:
 752             t = b = data;
 753             break;
 754
 755          case GROUP_LeftOffset:
 756             l = data;
 757             break;
 758
 759          case GROUP_TopOffset:
 760             t = data;
 761             break;
 762
 763          case GROUP_RightOffset:
 764             r = data;
 765             break;
 766
 767          case GROUP_BottomOffset:
 768             b = data;
 769             break;
 770
 771          case GROUP_Inverted:
 772             invert = data;
 773             break;
 774
 775          case GROUP_SpaceObject:
 776             if ((m = NewSpaceObject((Object *)rc, data)))
 777             {
 778                AsmDoMethod(m, RM_ADDTAIL, &gd->gd_Members);
 779                break;
 780             };
 781             gd->gd_Flags |= GDF_ADD_FAILURE;
 782             break;
 783
 784          case GROUP_Member:
 785             if (data)
 786             {
 787                if ((m = NewGroupMember((Object *)rc, (Object *)data, tag + 1)))
 788                {
 789                   AsmDoMethod(m, RM_ADDTAIL, &gd->gd_Members);
 790                   break;
 791                };
 792                /*
 793                 * Dispose of the member.
 794                 */
 795                AsmDoMethod((Object *)data, OM_DISPOSE);
 796             };
 797             /*
 798              * Set error flag.
 799              */
 800             gd->gd_Flags |= GDF_ADD_FAILURE;
 801             break;
 802          };
 803       };
 804
 805       if (invert)
 806       {
 807          n1 = ((struct List *)&gd->gd_Members)->lh_Head;
 808
 809          while ((n2 = n1->ln_Succ)->ln_Succ)
 810          {
 811             Remove(n2);
 812             AddHead((struct List *)&gd->gd_Members, n2);
 813          };
 814       };
 815
 816       /*
 817        * All OK?
 818        */
 819       if (!(gd->gd_Flags & GDF_ADD_FAILURE))
 820       {
 821          if (GADGET(rc)->Activation & GACT_TOPBORDER) l++;
 822
 823          DoSuperSetMethodNG(cl, (Object *)rc, BT_LeftOffset, HSpace(l),  BT_RightOffset,  HSpace(r),
 824                                               BT_TopOffset,  VSpace(t),  BT_BottomOffset, VSpace(b), TAG_DONE);
 825
 826          GroupSetAttrs(cl, (Object *)rc, ops);
 827       }
 828       else
 829       {
 830          /*
 831           * Noop... dump the object.
 832           */
 833          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 834          rc = 0;
 835       };
 836    };
 837    return rc;
 838 }
 839 METHOD_END
 840 ///
 841 /// OM_SET
 842 /*
 843  * Set one or more attributes.
 844  */
 845 METHOD(GroupClassSet, struct opSet *, ops)
 846 {
 847    /*
 848     * First we let the superclass have a go at it.
 849     */
 850    AsmDoSuperMethodA(cl, obj, (Msg)ops);
 851
 852    return GroupSetAttrs(cl, obj, ops);
 853 }
 854 METHOD_END
 855 ///
 856 /// OM_GET
 857 METHOD(GroupClassGet, struct opGet *, opg)
 858 {
 859    GD       *gd = INST_DATA(cl, obj);
 860    ULONG     rc = 1;
 861    IPTR     *store = opg->opg_Storage;
 862
 863    switch (opg->opg_AttrID)
 864    {
 865    case GROUP_Rows:
 866       STORE gd->gd_Rows;
 867       break;
 868
 869    case GROUP_Columns:
 870       STORE gd->gd_Columns;
 871       break;
 872
 873    case GROUP_HorizSpacing:
 874       STORE gd->gd_SpaceX;
 875       break;
 876
 877    case GROUP_VertSpacing:
 878       STORE gd->gd_SpaceY;
 879       break;
 880
 881    case GROUP_HorizAlign:
 882       STORE gd->gd_HAlign;
 883       break;
 884
 885    case GROUP_VertAlign:
 886       STORE gd->gd_VAlign;
 887       break;
 888
 889    case GROUP_Members:
 890       STORE gd->gd_MD;
 891       break;
 892
 893    case GROUP_NumMembers:
 894       STORE gd->gd_NumMembers;
 895       break;
 896
 897    case GROUP_Style:
 898       STORE gd->gd_Style;
 899       break;
 900
 901    default:
 902       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 903       break;
 904    };
 905    return rc;
 906 }
 907 METHOD_END
 908
 909 static Object **ObtainMembers(Object *obj,GD *gd,BOOL *got_members_list)
 910 {
 911    if(gd->gd_MD==NULL)
 912    {
 913       if (!(gd->gd_MD = (Object **)AsmDoMethod(obj, GROUPM_OBTAINMEMBERS, GROMF_WAIT|GROMF_VISIBLE, &gd->gd_NumMembers)))
 914          return 0;
 915       *got_members_list=TRUE;
 916    }
 917    else
 918       *got_members_list=FALSE;
 919    return(gd->gd_MD);
 920 }
 921
 922 static VOID ReleaseMembers(Object *obj,GD *gd,BOOL got_members_list)
 923 {
 924    if(got_members_list)
 925    {
 926       AsmDoMethod(obj, GROUPM_RELEASEMEMBERS, gd->gd_MD);
 927       gd->gd_MD=NULL;
 928       gd->gd_NumMembers=0;
 929    }
 930 }
 931
 932 ///
 933 /// BASE_LAYOUT
 934 /*
 935  * Layout the group.
 936  */
 937 METHOD(GroupClassLayout, struct bmLayout *, bml)
 938 {
 939    GD           *gd = INST_DATA(cl, obj);
 940    BC           *bc = BASE_DATA(obj);
 941    Object       *m;
 942    MD           *md;
 943    TD           *td, *cd, *rd;
 944    BOOL          changed,got_members_list;
 945    ULONG         totalweight, totalsize, tw, th;
 946 /*   UBYTE         align; */
 947    int           r, c, size, last;
 948    int           x, y, dx, dy, w, h;
 949
 950    /*
 951     * Layout the baseclass.
 952     */
 953    AsmDoSuperMethodA(cl, obj, (Msg)bml);
 954
 955    if (!(bml->bml_Flags & BLF_CUSTOM_GROUP))
 956    {
 957       w = bc->bc_InnerBox.Width  - (HSpace(gd->gd_SpaceX) * (gd->gd_Columns - 1));
 958       h = bc->bc_InnerBox.Height - (VSpace(gd->gd_SpaceY) * (gd->gd_Rows - 1));
 959
 960       if(ObtainMembers(obj,gd,&got_members_list)==NULL)
 961          return(0);
 962       if (!gd->gd_NumMembers)
 963       {
 964          ReleaseMembers(obj,gd,got_members_list);
 965          return 1;
 966       }
 967
 968       /*
 969        * Set starting values.
 970        */
 971       tw = 0;
 972       for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
 973       {
 974          tw += (td->td_Size = td->td_Nom);
 975       };
 976
 977       last = 0;
 978       do
 979       {
 980          /*
 981           * First loop to get total weight.
 982           */
 983          totalweight = 0;
 984          totalsize   = w;
 985          for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
 986          {
 987             if (td->td_Size < td->td_Max)
 988                totalweight += td->td_Weight;
 989             else
 990                totalsize   -= td->td_Size;
 991          };
 992
 993          if ((totalweight == 0) || (totalsize <= 0)) break;
 994
 995          /*
 996           * Loop to get all scaled sizes.
 997           */
 998          tw = 0;
 999          for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1000          {
1001             if (td->td_Size < td->td_Max)
1002             {
1003                size = ScaleWeight(totalsize, totalweight, td->td_Weight);
1004                td->td_Size = range(size, td->td_Min, td->td_Max);
1005             };
1006
1007             /*
1008              * Keep track of the total size.
1009              */
1010             tw += td->td_Size;
1011          };
1012          if (tw == last) break;
1013          last = tw;
1014       }  while (tw < w);
1015
1016       /*
1017        * Constantly adjust the size of objects which where scaled larger
1018        * than their minimum size when the total scaled size was larger than
1019        * the area the objects must fit in.
1020        */
1021       while (tw > w)
1022       {
1023          changed = FALSE;
1024          for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1025          {
1026             /*
1027              * Was the size bigger than the minimum size?
1028              */
1029             if (td->td_Size > td->td_Min)
1030             {
1031                changed = TRUE;
1032                td->td_Size--;
1033                tw--;
1034             };
1035
1036             /*
1037              * Are we done yet?
1038              */
1039             if (tw <= w) break;
1040          };
1041          if (!changed) break;
1042       };
1043
1044       /*
1045        * Set starting values.
1046        */
1047       th = 0;
1048       for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1049       {
1050          th += (td->td_Size = td->td_Nom);
1051       };
1052
1053       last = 0;
1054       do
1055       {
1056          /*
1057           * First loop to get total weight.
1058           */
1059          totalweight = 0;
1060          totalsize   = h;
1061
1062          for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1063          {
1064             if (td->td_Size < td->td_Max)
1065                totalweight += td->td_Weight;
1066             else
1067                totalsize   -= td->td_Size;
1068          };
1069
1070          if ((totalweight == 0) || (totalsize <= 0)) break;
1071
1072          /*
1073           * Loop to get all scaled sizes.
1074           */
1075          th = 0;
1076          for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1077          {
1078             if (td->td_Size < td->td_Max)
1079             {
1080                size = ScaleWeight(totalsize, totalweight, td->td_Weight);
1081                td->td_Size = range(size, td->td_Min, td->td_Max);
1082             };
1083
1084             /*
1085              * Keep track of the total size.
1086              */
1087             th += td->td_Size;
1088          };
1089          if (th == last) break;
1090          last = th;
1091       }  while (th < h);
1092
1093       /*
1094        * Constantly adjust the size of objects which where scaled larger
1095        * than their minimum size when the total scaled size was larger than
1096        * the area the objects must fit in.
1097        */
1098       while (th > h)
1099       {
1100          changed = FALSE;
1101          for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1102          {
1103             /*
1104              * Was the size bigger than the minimum size?
1105              */
1106             if (td->td_Size > td->td_Min)
1107             {
1108                changed = TRUE;
1109                td->td_Size--;
1110                th--;
1111             };
1112
1113             /*
1114              * Are we done yet?
1115              */
1116             if (th <= h) break;
1117          };
1118          if (!changed) break;
1119       };
1120
1121       /*
1122        * Scan through the members.
1123        */
1124       x = bc->bc_InnerBox.Left;
1125
1126       for (c = 0, cd = gd->gd_CD; c < gd->gd_Columns; c++, cd++)
1127       {
1128          y = bc->bc_InnerBox.Top;
1129
1130          for (r = 0, rd = gd->gd_RD; r < gd->gd_Rows; r++, rd++)
1131          {
1132             if ((m = GroupNode(gd, r, c)))
1133             {
1134                md = MEMBER_DATA(m);
1135
1136                md->md_Bounds.Width  = range(cd->td_Size - md->md_HBLeft, md->md_MinWidth,  md->md_MaxWidth);
1137                md->md_Bounds.Height = range(rd->td_Size,                 md->md_MinHeight, md->md_MaxHeight);
1138
1139                switch (md->md_HAlign ? md->md_HAlign : gd->gd_HAlign)
1140                {
1141                default:
1142                case GRALIGN_LEFT:
1143                   dx = md->md_HBLeft;
1144                   break;
1145                case GRALIGN_CENTER:
1146                   dx = max(0, cd->td_Size - md->md_Bounds.Width) >> 1;
1147                   break;
1148                case GRALIGN_RIGHT:
1149                   dx = max(0, cd->td_Size - md->md_Bounds.Width);
1150                   break;
1151                };
1152
1153                switch (md->md_VAlign ? md->md_VAlign : gd->gd_VAlign)
1154                {
1155                default:
1156                case GRALIGN_TOP:
1157                   dy = 0;
1158                   break;
1159                case GRALIGN_CENTER:
1160                   dy = max(0, rd->td_Size - md->md_Bounds.Height) >> 1;
1161                   break;
1162                case GRALIGN_BOTTOM:
1163                   dy = max(0, rd->td_Size - md->md_Bounds.Height);
1164                   break;
1165                };
1166
1167                md->md_Bounds.Left = x + dx;
1168                md->md_Bounds.Top  = y + dy;
1169             };
1170             y += rd->td_Size + VSpace(gd->gd_SpaceY);
1171          };
1172          x += cd->td_Size + HSpace(gd->gd_SpaceX);
1173       }
1174       ReleaseMembers(obj,gd,got_members_list);
1175    };
1176
1177    return 1;
1178 }
1179 METHOD_END
1180 ///
1181 /// BASE_RENDER
1182
1183 struct SubRender
1184 {
1185    struct Message     sr_Message;
1186    Object            *sr_Object;
1187    struct GadgetInfo *sr_GInfo;
1188    struct RastPort   *sr_RPort;
1189 };
1190
1191 VOID SAVEDS subrender_task(void)
1192 {
1193    struct Process    *proc = (struct Process *)FindTask(NULL);
1194    struct SubRender  *sr;
1195
1196    WaitPort(&proc->pr_MsgPort);
1197    sr = (struct SubRender *)GetMsg(&proc->pr_MsgPort);
1198
1199    AsmDoMethod(sr->sr_Object, GM_RENDER, sr->sr_GInfo, sr->sr_RPort, GREDRAW_REDRAW);
1200
1201    ReplyMsg((struct Message *)sr);
1202 }
1203
1204 /*
1205  * Render the group.
1206  */
1207 METHOD(GroupClassRender, struct bmRender *, bmr)
1208 {
1209    GD                *gd = INST_DATA(cl, obj);
1210    BC                *bc = BASE_DATA(obj);
1211    Object            *m;
1212    MD                *md;
1213    struct BaseInfo   *bi = bmr->bmr_BInfo;
1214    struct RastPort   *rp = bi->bi_RPort;
1215    struct Process    *proc;
1216    struct MsgPort    *msgport = NULL;
1217    struct SubRender  *sr;
1218 /*   ULONG              rc = 0; */
1219    BOOL               subrender = FALSE; // no multitasking yet
1220    int                render_count = 0;
1221
1222    if (gd->gd_Flags & GDF_IS_MASTER)
1223    {
1224       if (!bc->bc_Frame)
1225       {
1226          BSetDPenA(bi, BACKGROUNDPEN);
1227          BBoxFillA(bi, &bc->bc_OuterBox);
1228       };
1229    };
1230
1231 WW(kprintf("***GroupClassRender*** obj = %x\n", obj));
1232
1233    /*
1234     * Render the baseclass.
1235     */
1236    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
1237
1238    /*
1239     * Top-border group hack...
1240     */
1241    if (GADGET(obj)->Activation & GACT_TOPBORDER)
1242    {
1243       BSetDPenA(bi, SHADOWPEN);
1244       Move(rp, bc->bc_OuterBox.Left, bc->bc_OuterBox.Top + 1);
1245       Draw(rp, bc->bc_OuterBox.Left, bc->bc_OuterBox.Top + bc->bc_OuterBox.Height - 1);
1246    };
1247
1248    if (subrender)
1249    {
1250       msgport = CreateMsgPort();
1251       if (!msgport) subrender = FALSE;
1252    };
1253
1254    m = NULL;
1255    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
1256    {
1257       /*
1258        * Setup object position/dimensions and render it.
1259        */
1260       SetGadgetBounds(md->md_Object, &md->md_Bounds);
1261
1262       proc = NULL;
1263
1264       if (subrender)
1265       {
1266          if ((sr = BGUI_AllocPoolMem(sizeof(struct SubRender))))
1267          {
1268             proc = CreateNewProcTags(NP_Entry, subrender_task, NP_Name, "BGUI Render", TAG_DONE);
1269
1270             if (!proc) BGUI_FreePoolMem(sr);
1271          };
1272       }
1273
1274       if (proc)
1275       {
1276          render_count++;
1277
1278          sr->sr_Message.mn_ReplyPort = msgport;
1279          sr->sr_Message.mn_Length    = sizeof(struct SubRender);
1280          sr->sr_Object               = md->md_Object;
1281          sr->sr_GInfo                = (struct GadgetInfo *)bi;
1282          sr->sr_RPort                = rp;
1283
1284          PutMsg(&proc->pr_MsgPort, &sr->sr_Message);
1285       }
1286       else
1287       {
1288          AsmDoMethod(md->md_Object, GM_RENDER, bi, rp, GREDRAW_REDRAW);
1289       };
1290    };
1291    if (subrender)
1292    {
1293       /*
1294        * Wait for all subtasks to finish.
1295        */
1296       while (render_count)
1297       {
1298          WaitPort(msgport);
1299          while ((sr = (struct SubRender *)GetMsg(msgport)))
1300          {
1301             BGUI_FreePoolMem(sr);
1302             render_count--;
1303          };
1304       };
1305       DeleteMsgPort(msgport);
1306    };
1307    return 1;
1308 }
1309 METHOD_END
1310 ///
1311 /// GM_HITTEST
1312 /*
1313  * Pass on the hittest message.
1314  */
1315 METHOD(GroupClassHitTest, struct gpHitTest *, gph)
1316 {
1317    GD                *gd = INST_DATA(cl, obj);
1318    Object            *m;
1319    MD                *md;
1320    ULONG              rc;
1321
1322    /*
1323     * See if a member was "hit".
1324     */
1325    m = NULL;
1326    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
1327    {
1328       /*
1329        * This member hit?
1330        */
1331       if ((rc = ForwardMsg(obj, md->md_Object, (Msg)gph)) == GMR_GADGETHIT)
1332       {
1333          /*
1334           * Make it the active one.
1335           */
1336          gd->gd_Active = md->md_Object;
1337          return rc;
1338       };
1339    };
1340
1341    /*
1342     * Safety precautions.
1343     */
1344    gd->gd_Active = NULL;
1345
1346    return 0;
1347 }
1348 METHOD_END
1349 ///
1350 /// GM_GOACTIVE, GM_HANDLEINPUT
1351 /*
1352  * Forward a GM_GOACTIVE or GM_HANDLEINPUT message.
1353  */
1354 METHOD(GroupClassActiveInput, struct gpInput *, gpi)
1355 {
1356    GD                *gd = INST_DATA(cl, obj);
1357    ULONG              rc = GMR_NOREUSE;
1358
1359    /*
1360     * Do we have an active member?
1361     */
1362    if (gd->gd_Active)
1363    {
1364       /*
1365        * Tell'm its active.
1366        */
1367       if (gpi->MethodID == GM_GOACTIVE)
1368          DoSetMethodNG(gd->gd_Active, BT_IsActive, TRUE, TAG_END);
1369
1370       rc = ForwardMsg(obj, gd->gd_Active, (Msg)gpi);
1371
1372       /*
1373        * Clone the ID.
1374        */
1375       DoSuperSetMethodNG(cl, obj, GA_ID, GADGET(gd->gd_Active)->GadgetID, TAG_DONE);
1376    }
1377    return rc;
1378 }
1379 METHOD_END
1380 ///
1381 /// GM_GOINACTIVE
1382 /*
1383  * Forward the GM_GOINACTIVE message.
1384  */
1385 METHOD(GroupClassInActive, Msg, msg)
1386 {
1387    GD          *gd = INST_DATA(cl, obj);
1388    ULONG        rc = 0;
1389
1390    /*
1391     * Inactivate the active member.
1392     */
1393    if (gd->gd_Active)
1394    {
1395       rc = AsmDoMethodA(gd->gd_Active, msg);
1396       /*
1397        * Tell 'm its in-active.
1398        */
1399       DoSetMethodNG(gd->gd_Active, BT_IsActive, FALSE, TAG_END);
1400       gd->gd_Active = NULL;
1401    };
1402    return rc;
1403 }
1404 METHOD_END
1405 ///
1406 /// OM_DISPOSE
1407 /*
1408  * Dispose of the group and all
1409  * it's members.
1410  */
1411 METHOD(GroupClassDispose, Msg, msg)
1412 {
1413    GD           *gd = INST_DATA(cl, obj);
1414    Object       *m, *o;
1415    MD           *md;
1416
1417    /*
1418     * Remove and dispose of all members.
1419     */
1420    while ((m = ListHeadObject((struct List *)&gd->gd_Members)))
1421    {
1422       md = MEMBER_DATA(m);
1423       o  = md->md_Object;
1424
1425       /*
1426        * Free the node.
1427        */
1428       AsmDoMethod(m, OM_DISPOSE);
1429
1430       /*
1431        * Dispose of the member.
1432        */
1433       AsmDoMethod(o, OM_DISPOSE);
1434    };
1435
1436    if (gd->gd_RD) BGUI_FreePoolMem(gd->gd_RD);
1437    if (gd->gd_CD) BGUI_FreePoolMem(gd->gd_CD);
1438
1439    /*
1440     * Leave the rest up to the superclass.
1441     */
1442    return AsmDoSuperMethodA(cl, obj, msg);
1443 }
1444 METHOD_END
1445 ///
1446 /// GRM_ADDMEMBER
1447 /*
1448  * Add a member to the group.
1449  */
1450 METHOD(GroupClassAddMember, struct grmAddMember *, grma)
1451 {
1452    GD             *gd = INST_DATA(cl, obj);
1453    Object         *m;
1454
1455    /*
1456     * Allocate and initialize node.
1457     */
1458    if ((m = NewGroupMember(obj, grma->grma_Member, (struct TagItem *)&grma->grma_Attr)))
1459    {
1460       /*
1461        * Add it to the list.
1462        */
1463       AsmDoMethod(m, RM_ADDTAIL, &gd->gd_Members);
1464
1465 WW(kprintf("** GroupClassAddMember\n"));
1466 WW(if(BASE_DATA(obj)->bc_Window) kprintf("** GroupClassAddMember: sending WM_SETUPGADGET to window\n"));
1467
1468       if(BASE_DATA(obj)->bc_Window)
1469          AsmDoMethod(BASE_DATA(obj)->bc_Window, WM_SETUPGADGET, grma->grma_Member, NULL);
1470
1471       /*
1472        * Try to re-layout the group.
1473        */
1474 WW(kprintf("** GroupClassAddMember: calling relayoutgroup: LGO_Relayout = %d\n",GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grma->grma_Attr)));
1475
1476       if(GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grma->grma_Attr)
1477       && !RelayoutGroup(obj))
1478       {
1479 WW(kprintf("** GroupClassAddMember: relayoutgroup failed. returning FALSE\n"));
1480          DisposeObject(m);
1481          RelayoutGroup(obj);
1482
1483          return FALSE;
1484       };
1485 WW(kprintf("** GroupClassAddMember: everything done. returning TRUE\n"));
1486
1487       return TRUE;
1488    };
1489    return FALSE;
1490 }
1491 METHOD_END
1492 ///
1493 /// GRM_INSERTMEMBER
1494 /*
1495  * Insert a member in the group.
1496  */
1497 METHOD(GroupClassInsert, struct grmInsertMember *, grmi)
1498 {
1499    GD             *gd = INST_DATA(cl, obj);
1500    Object         *m;
1501
1502    /*
1503     * No NULL-objects.
1504     */
1505    if (!grmi->grmi_Member)
1506       return FALSE;
1507
1508    /*
1509     * Allocate and initialize node.
1510     */
1511    if ((m = NewGroupMember(obj, grmi->grmi_Member, (struct TagItem *)&grmi->grmi_Attr)))
1512    {
1513       AsmDoMethod(m, RM_INSERT, &gd->gd_Members, FindObNode(gd, grmi->grmi_Pred));
1514
1515       if(BASE_DATA(obj)->bc_Window)
1516          AsmDoMethod(BASE_DATA(obj)->bc_Window, WM_SETUPGADGET, grmi->grmi_Member, NULL);
1517
1518       /*
1519        * Try to re-layout the group.
1520        */
1521       if(GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grmi->grmi_Attr)
1522       && !RelayoutGroup(obj))
1523       {
1524          DisposeObject(m);
1525          RelayoutGroup(obj);
1526
1527          return FALSE;
1528       };
1529       return TRUE;
1530    };
1531    return FALSE;
1532 }
1533 METHOD_END
1534 ///
1535 /// GRM_REPLACEMEMBER
1536 /*
1537  * Replace a member in the group.
1538  */
1539 METHOD(GroupClassReplace, struct grmReplaceMember *, grrm)
1540 {
1541    GD             *gd = INST_DATA(cl, obj);
1542    Object         *m, *old;
1543
1544    /*
1545     * No NULL-objects.
1546     */
1547    if (!grrm->grrm_MemberA || !grrm->grrm_MemberB)
1548       return 0;
1549
1550    /*
1551     * Allocate and initialize node.
1552     */
1553    if ((m = NewGroupMember(obj, grrm->grrm_MemberB, (struct TagItem *)&grrm->grrm_Attr)))
1554    {
1555       /*
1556        * Find member to replace.
1557        */
1558       if ((old = FindObNode(gd, grrm->grrm_MemberA)))
1559       {
1560          AsmDoMethod(m, RM_INSERT, &gd->gd_Members, old);
1561          AsmDoMethod(old, RM_REMOVE);
1562
1563          if(BASE_DATA(obj)->bc_Window)
1564             AsmDoMethod(BASE_DATA(obj)->bc_Window, WM_SETUPGADGET, grrm->grrm_MemberB, NULL);
1565
1566          /*
1567           * Try to re-layout the group.
1568           */
1569          if(GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grrm->grrm_Attr)
1570          && !RelayoutGroup(obj))
1571          {
1572             AsmDoMethod(old, RM_INSERT, &gd->gd_Members);
1573             DisposeObject(m);
1574             RelayoutGroup(obj);
1575
1576             return 0;
1577          };
1578
1579          /*
1580           * Deallocate replaced node.
1581           */
1582          DisposeObject(old);
1583
1584          /*
1585           * Set return code.
1586           */
1587          return (IPTR)grrm->grrm_MemberA;
1588       };
1589    };
1590    return 0;
1591 }
1592 METHOD_END
1593 ///
1594 /// GRM_REMMEMBER
1595 /*
1596  * Remove an object from the list.
1597  */
1598 METHOD(GroupClassRemMember, struct grmRemMember *, grmr)
1599 {
1600    GD             *gd = INST_DATA(cl, obj);
1601    Object         *m;
1602
1603    if ((m = FindObNode(gd, grmr->grmr_Member)))
1604    {
1605       /*
1606        * Remove and dealocate it.
1607        */
1608       DisposeObject(m);
1609
1610       /*
1611        * Relayout the group.
1612        */
1613       RelayoutGroup(obj);
1614
1615       return (IPTR)grmr->grmr_Member;
1616    }
1617    return (IPTR)NULL;
1618 }
1619 METHOD_END
1620 ///
1621 /// GROUPM_OBTAINMEMBERS
1622
1623 METHOD(GroupClassObtainMembers, struct gmObtainMembers *, gmom)
1624 {
1625    GD      *gd = INST_DATA(cl, obj);
1626    MD      *md;
1627    Object **o, *m;
1628    int      n;
1629    ULONG    flags = gmom->gmom_Flags;
1630
1631    if (flags & GROMF_WAIT)
1632    {
1633       if (flags & GROMF_EXCLUSIVE)
1634       {
1635          ObtainSemaphore(&gd->gd_Lock);
1636       }
1637       else
1638       {
1639          ObtainSemaphoreShared(&gd->gd_Lock);
1640       };
1641    }
1642    else
1643    {
1644       if (flags & GROMF_EXCLUSIVE)
1645       {
1646          n = AttemptSemaphore(&gd->gd_Lock);
1647       }
1648       else
1649       {
1650          n = AttemptSemaphoreShared(&gd->gd_Lock);
1651       };
1652       if (!n) return 0;
1653    };
1654
1655    n = 0;
1656    m = NULL;
1657    while ((md = NextGroupNode(gd, &m, (flags & GROMF_VISIBLE) ? MDF_HIDDEN : 0)))
1658       n++;
1659
1660    o = BGUI_AllocPoolMem(sizeof(Object *) * (n + 2));
1661
1662    if (!o)
1663    {
1664       ReleaseSemaphore(&gd->gd_Lock);
1665       return 0;
1666    }
1667
1668    *o++ = obj;  // Marker for safety.
1669
1670    m = NULL;
1671    while ((md = NextGroupNode(gd, &m, (flags & GROMF_VISIBLE) ? MDF_HIDDEN : 0)))
1672    {
1673       if (flags & GROMF_OBJECTS)
1674          *o++ = md->md_Object;
1675       else
1676          *o++ = m;
1677    };
1678
1679    if (gmom->gmom_Number) *(gmom->gmom_Number) = n;
1680    return (IPTR)(o - n);
1681 }
1682 METHOD_END
1683 ///
1684 /// GROUPM_RELEASEMEMBERS
1685
1686 METHOD(GroupClassReleaseMembers, struct gmReleaseMembers *, gmrm)
1687 {
1688    GD       *gd = INST_DATA(cl, obj);
1689    Object  **o = gmrm->gmrm_Array - 1;
1690    int       rc = -1;
1691
1692    if (*o == obj)  // Check for safety marker.
1693    {
1694       if (gd->gd_Lock.ss_Owner == FindTask(NULL))
1695       {
1696          rc = gd->gd_Lock.ss_NestCount - 1;
1697
1698          ReleaseSemaphore(&gd->gd_Lock);
1699       };
1700       BGUI_FreePoolMem(o);
1701    }
1702 #ifdef DEBUG_BGUI
1703    else
1704       D(bug("*** Attempt to free an invalid group members list\n"));
1705 #endif
1706    return (ULONG)rc;     // rc < 0 = failure, rc = 0 is freed, rc > 0 still locked.
1707 }
1708 METHOD_END
1709 ///
1710 /// RelayoutGroup
1711
1712 makeproto ASM ULONG RelayoutGroup(REG(a0) Object *obj)
1713 {
1714    BC                 *bc = BASE_DATA(obj);
1715    struct Window      *w = NULL;
1716    struct bmRelayout  bmr;
1717    ULONG               rc = 1;
1718
1719 WW(kprintf("** GroupClass_RelayoutGrop\n"));
1720
1721    if (bc->bc_Window)
1722    {
1723 WW(kprintf("** GroupClass_RelayoutGrop: has bc->bc_Window\n"));
1724       Get_Attr(bc->bc_Window, WINDOW_Window, (IPTR *)&w);
1725
1726       if (w)
1727       {
1728          bmr.MethodID   = BASE_RELAYOUT;
1729          bmr.bmr_GInfo = NULL;
1730          bmr.bmr_RPort = w->RPort;
1731 WW(kprintf("** GroupClass_RelayoutGrop: has WINDOW_Window --> sending BASE_RELAYOUT to obj\n"));
1732
1733          rc = BGUI_DoGadgetMethodA(obj, w, NULL, (Msg)&bmr);
1734       };
1735    };
1736    return rc;
1737 }
1738 ///
1739
1740 /// MemberDimensions
1741 /*
1742  * Calculate the minimum size of a group.
1743  */
1744 STATIC ASM BOOL MemberDimensions(REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct bmDimensions *bmd)
1745 {
1746    GD                *gd = INST_DATA(cl, obj);
1747    Object            *m;
1748    MD                *md;
1749    TD                *td;
1750    ULONG              minw, minh, nomw, nomh, maxw, maxh;
1751    ULONG              tmin, tmax, tnom;
1752    int                r, c;
1753    BOOL               got_members_list;
1754
1755    if(ObtainMembers(obj,gd,&got_members_list)==NULL)
1756       return FALSE;
1757    if (gd->gd_NumMembers)
1758    {
1759       if (gd->gd_Style == GRSTYLE_HORIZONTAL)
1760       {
1761          gd->gd_Rows = range(gd->gd_Rows, 1, gd->gd_NumMembers);
1762          gd->gd_Columns = (gd->gd_NumMembers + (gd->gd_Rows - 1)) / gd->gd_Rows;
1763       };
1764
1765       if (gd->gd_Style == GRSTYLE_VERTICAL)
1766       {
1767          gd->gd_Columns = range(gd->gd_Columns, 1, gd->gd_NumMembers);
1768          gd->gd_Rows = (gd->gd_NumMembers + (gd->gd_Columns - 1)) / gd->gd_Columns;
1769       };
1770
1771       if (gd->gd_RD) BGUI_FreePoolMem(gd->gd_RD);
1772       if (gd->gd_CD) BGUI_FreePoolMem(gd->gd_CD);
1773
1774       gd->gd_RD = BGUI_AllocPoolMem(sizeof(TD) * gd->gd_Rows);
1775       gd->gd_CD = BGUI_AllocPoolMem(sizeof(TD) * gd->gd_Columns);
1776
1777       if (!(gd->gd_RD && gd->gd_CD)) return FALSE;
1778
1779       /*
1780        * Scan through the members.
1781        */
1782       for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1783       {
1784          td->td_PreAlign = 0;
1785
1786          for (r = 0; r < gd->gd_Rows; r++)
1787          {
1788             if ((m = GroupNode(gd, r, c)))
1789             {
1790                md = MEMBER_DATA(m);
1791
1792                /*
1793                 * Find out how much we must adjust for alignment.
1794                 */
1795                AsmDoMethod(md->md_Object, BASE_LEFTEXT, bmd->bmd_BInfo->bi_RPort, &md->md_HBLeft);
1796
1797                if (!md->md_HBLeft)
1798                {
1799                   if (!(md->md_Flags & MDF_NO_NO_ALIGN))
1800                      md->md_Flags |= MDF_NO_ALIGN;
1801                }
1802                else
1803                {
1804                   if (md->md_HBLeft > td->td_PreAlign) td->td_PreAlign = md->md_HBLeft;
1805                };
1806             };
1807          };
1808
1809          tmin = 0;
1810          tnom = 0;
1811          tmax = 0;
1812
1813          for (r = 0; r < gd->gd_Rows; r++)
1814          {
1815             if ((m = GroupNode(gd, r, c)))
1816             {
1817                md = MEMBER_DATA(m);
1818
1819                if (!(md->md_Flags & MDF_NO_ALIGN))
1820                {
1821                   md->md_HBLeft = td->td_PreAlign - md->md_HBLeft;
1822                }
1823                else
1824                {
1825                   md->md_HBLeft = 0;
1826                };
1827
1828                if (r == 0) td->td_Weight = md->md_Weight;
1829
1830                /*
1831                 * Adjust the minimum width with the maximum extention.
1832                 */
1833                tmin = max(tmin, md->md_MinWidth + md->md_HBLeft);
1834                tnom = max(tnom, md->md_NomWidth + md->md_HBLeft);
1835                tmax = max(tmax, md->md_MaxWidth);
1836             };
1837          };
1838
1839          td->td_Min = tmin;
1840          td->td_Max = tmax;
1841          td->td_Nom = range(tnom, tmin, tmax);
1842       };
1843
1844       /*
1845        * Scan through the members.
1846        */
1847       for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1848       {
1849          tmin = 0;
1850          tnom = 0;
1851          tmax = 0;
1852
1853          for (c = 0; c < gd->gd_Columns; c++)
1854          {
1855             if ((m = GroupNode(gd, r, c)))
1856             {
1857                md = MEMBER_DATA(m);
1858
1859                if (c == 0) td->td_Weight = md->md_Weight;
1860
1861                tmin = max(tmin, md->md_MinHeight);
1862                tnom = max(tnom, md->md_NomHeight);
1863                tmax = max(tmax, md->md_MaxHeight);
1864             };
1865          };
1866
1867          td->td_Min = tmin;
1868          td->td_Max = tmax;
1869          td->td_Nom = range(tnom, tmin, tmax);
1870       };
1871
1872       minw = nomw = HSpace(gd->gd_SpaceX) * (gd->gd_Columns - 1);
1873       minh = nomh = VSpace(gd->gd_SpaceY) * (gd->gd_Rows - 1);
1874       maxw = maxh = 0;
1875
1876       for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1877       {
1878          minh += td->td_Min;
1879          nomh += td->td_Nom;
1880          maxh += td->td_Max;
1881       };
1882
1883       for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1884       {
1885          minw += td->td_Min;
1886          nomw += td->td_Nom;
1887          maxw += td->td_Max;
1888       };
1889    }
1890    else
1891    {
1892       /*
1893        * No members.
1894        */
1895       minw = minh = 0;
1896       nomw = nomh = 0;
1897       maxw = maxh = 0xFFFF;
1898    };
1899
1900    ReleaseMembers(obj,gd,got_members_list);
1901
1902    minw = max(minw, 1);
1903    minh = max(minh, 1);
1904
1905    maxw = range(maxw, minw, 0xFFFF);
1906    maxh = range(maxh, minh, 0xFFFF);
1907
1908    nomw = range(nomw, minw, maxw);
1909    nomh = range(nomh, minh, maxh);
1910
1911    bmd->bmd_Extent->be_Min.Width  += minw;
1912    bmd->bmd_Extent->be_Min.Height += minh;
1913    bmd->bmd_Extent->be_Nom.Width  += nomw;
1914    bmd->bmd_Extent->be_Nom.Height += nomh;
1915    bmd->bmd_Extent->be_Max.Width   = maxw;
1916    bmd->bmd_Extent->be_Max.Height  = maxh;
1917
1918    return TRUE;
1919 }
1920 ///
1921 /// BASE_DIMENSIONS
1922 /*
1923  * They want our dimensions info.
1924  */
1925 METHOD(GroupClassDimensions, struct bmDimensions *, bmd)
1926 {
1927    GD                   *gd = INST_DATA(cl, obj);
1928 /*   BC                   *bc = BASE_DATA(obj); */
1929    Object               *m;
1930    MD                   *md;
1931    struct grmDimensions  dim;
1932    UWORD                 mw = 0, mh = 0, minw, minh, maxw, maxh, nomw, nomh;
1933    ULONG                 rc;
1934
1935    dim.MethodID            = GRM_DIMENSIONS;
1936    dim.grmd_GInfo          = (struct GadgetInfo *)bmd->bmd_BInfo;
1937    dim.grmd_RPort          = bmd->bmd_BInfo->bi_RPort;
1938    dim.grmd_Flags          = bmd->bmd_Flags | GDIMF_MAXIMUM|GDIMF_NOMINAL;
1939    dim.grmd_MinSize.Width  = &minw;
1940    dim.grmd_MinSize.Height = &minh;
1941    dim.grmd_MaxSize.Width  = &maxw;
1942    dim.grmd_MaxSize.Height = &maxh;
1943    dim.grmd_NomSize.Width  = &nomw;
1944    dim.grmd_NomSize.Height = &nomh;
1945
1946    /*
1947     * Browse through the members.
1948     */
1949    m = NULL;
1950    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN)))
1951    {
1952       if (md->md_Flags & MDF_SPACING)
1953       {
1954          md->md_MinWidth  = 0;
1955          md->md_MinHeight = 0;
1956          md->md_NomWidth  = 0;
1957          md->md_NomHeight = 0;
1958          md->md_MaxWidth  = 0xFFFF;
1959          md->md_MaxHeight = 0xFFFF;
1960       }
1961       else
1962       {
1963          /*
1964           * Ask dimensions.
1965           */
1966          AsmDoMethodA(md->md_Object, (Msg)&dim);
1967
1968          /*
1969           * Make sure the fixed sizes are not smaller than allowed.
1970           */
1971          if (md->md_FixedWidth >= 0)
1972          {
1973             maxw = minw = nomw = range(md->md_FixedWidth, minw, maxw);
1974          };
1975          if (md->md_FixedHeight >= 0)
1976          {
1977             maxh = minh = nomh = range(md->md_FixedHeight, minh, maxh);
1978          };
1979          if (minw > mw) mw = minw;
1980          if (minh > mh) mh = minh;
1981
1982          md->md_MinWidth  = minw;
1983          md->md_MinHeight = minh;
1984          md->md_MaxWidth  = max(minw, maxw);
1985          md->md_MaxHeight = max(minh, maxh);
1986          md->md_NomWidth  = range(nomw, minw, maxw);
1987          md->md_NomHeight = range(nomh, minh, maxh);
1988       };
1989    };
1990
1991    m = NULL;
1992    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN)))
1993    {
1994       /*
1995        * Set equal width/height.
1996        */
1997       if (gd->gd_Flags & GDF_EQUAL_MINWIDTH)  md->md_MinWidth  = mw;
1998       if (gd->gd_Flags & GDF_EQUAL_MINHEIGHT) md->md_MinHeight = mh;
1999    };
2000
2001    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)bmd)))
2002    {
2003       /*
2004        * Calculate constraints.
2005        */
2006       if (!(bmd->bmd_Flags & BDF_CUSTOM_GROUP))
2007          rc = MemberDimensions(cl, obj, bmd);
2008    };
2009    return rc;
2010 }
2011 METHOD_END
2012 ///
2013 /// GRM_DIMENSIONS
2014 METHOD(GroupClassDimensionsX, struct grmDimensions *, dim)
2015 {
2016    GD    *gd = INST_DATA(cl, obj);
2017    ULONG rc=0;
2018    BOOL got_members_list;
2019
2020    if(ObtainMembers(obj,gd,&got_members_list)==NULL)
2021       return(0);
2022    rc=AsmDoSuperMethodA(cl, obj, (Msg)dim);
2023    ReleaseMembers(obj,gd,got_members_list);
2024    return(rc);
2025 }
2026 METHOD_END
2027
2028 ///
2029 /// BASE_SHOWHELP
2030 /*
2031  * Pass on the help message.
2032  */
2033 METHOD(GroupClassHelp, struct bmShowHelp *, bsh)
2034 {
2035    GD           *gd = INST_DATA(cl, obj);
2036    Object       *m;
2037    MD           *md;
2038    ULONG         rc = BMHELP_NOT_ME;
2039
2040    m = NULL;
2041    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)) && (rc == BMHELP_NOT_ME))
2042    {
2043       /*
2044        * Is this the one?
2045        */
2046       rc = AsmDoMethodA(md->md_Object, (Msg)bsh);
2047    };
2048    return rc;
2049 }
2050 METHOD_END
2051 ///
2052 /// GRM_ADDSPACEMEMBER
2053 /*
2054  * Add a spacing object.
2055  */
2056 METHOD(GroupClassAddSpaceMember, struct grmAddSpaceMember *, grms)
2057 {
2058    GD           *gd = INST_DATA(cl, obj);
2059    Object       *m;
2060
2061    if ((m = NewSpaceObject(obj, grms->grms_Weight)))
2062    {
2063       AsmDoMethod(m, RM_ADDTAIL, &gd->gd_Members);
2064       return TRUE;
2065    };
2066    return FALSE;
2067 }
2068 METHOD_END
2069 ///
2070 /// BASE_LEFTEXT
2071 /*
2072  * Route a BASE_LEFTEXT method.
2073  */
2074 METHOD(GroupClassLeftExt, struct bmLeftExt *, le)
2075 {
2076    GD          *gd = INST_DATA(cl, obj);
2077    BC          *bc = BASE_DATA(obj);
2078    IPTR         rc;
2079
2080    /*
2081     * Do we have a label or frame? If so we
2082     * take the left-extention of this object.
2083     */
2084    if (bc->bc_Label)
2085    {
2086       return AsmDoSuperMethodA(cl, obj, (Msg)le);
2087    };
2088
2089    if (bc->bc_Frame)
2090    {
2091       Get_Attr(bc->bc_Frame, FRM_Type, &rc);
2092       if (rc != FRTYPE_NONE)
2093       {
2094          return AsmDoSuperMethodA(cl, obj, (Msg)le);
2095       };
2096    };
2097
2098    /*
2099     * Get the biggest in the first column.
2100     */
2101    if(gd->gd_CD)
2102       *(le->bmle_Extention) = gd->gd_CD[0].td_PreAlign;
2103    else
2104    {
2105       *(le->bmle_Extention)=0;
2106    }
2107
2108    return 1;
2109 }
2110 METHOD_END
2111 ///
2112 /// GRM_WHICHOBJECT
2113 /*
2114  * Which object is under the mouse?
2115  */
2116 METHOD(GroupClassWhichObject, struct grmWhichObject *, grwo)
2117 {
2118    GD              *gd = INST_DATA(cl, obj);
2119    struct IBox     *ibox;
2120    Object          *m;
2121    MD              *md;
2122    WORD             x, y;
2123    ULONG            rc;
2124
2125    /*
2126     * Pick up the coords.
2127     */
2128    x = grwo->grwo_Coords.X;
2129    y = grwo->grwo_Coords.Y;
2130
2131    /*
2132     * See if the coords are over a member.
2133     */
2134    m = NULL;
2135    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
2136    {
2137       /*
2138        * If this is a group/page we pass on the method.
2139        */
2140       if (IsMulti(md->md_Object))
2141       {
2142          if ((rc = AsmDoMethodA(md->md_Object, (Msg)grwo)))
2143             return rc;
2144       }
2145
2146       /*
2147        * Get hitbox bounds.
2148        */
2149       ibox = GADGETBOX(md->md_Object);
2150
2151       /*
2152        * Over this object?
2153        */
2154       if (x >= ibox->Left && x < (ibox->Left + ibox->Width ) &&
2155           y >= ibox->Top  && y < (ibox->Top  + ibox->Height))
2156          /*
2157           * Yes.
2158           */
2159          return (IPTR)md->md_Object;
2160
2161    }
2162    return (IPTR)NULL;
2163 }
2164 METHOD_END
2165 ///
2166 /// BASE_FINDKEY
2167 /*
2168  * Which object has the proper key?
2169  */
2170 METHOD(GroupClassFindKey, struct bmFindKey *, bmfk)
2171 {
2172    GD           *gd = INST_DATA(cl, obj);
2173    Object       *m;
2174    MD           *md;
2175    ULONG         rc;
2176
2177    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)bmfk)))
2178       return rc;
2179
2180    m = NULL;
2181    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
2182    {
2183       if ((rc = AsmDoMethodA(md->md_Object, (Msg)bmfk)))
2184          return rc;
2185    };
2186    return 0;
2187 }
2188 METHOD_END
2189 ///
2190 /// #?
2191 /*
2192  * Attach keys from labels.
2193  */
2194 METHOD(GroupClassAll, Msg, msg)
2195 {
2196    GD           *gd = INST_DATA(cl, obj);
2197    Object       *m;
2198    MD           *md;
2199    ULONG         rc;
2200
2201    rc = AsmDoSuperMethodA(cl, obj, msg);
2202
2203    m = NULL;
2204    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN)))
2205    {
2206       rc += AsmDoMethodA(md->md_Object, msg);
2207    };
2208    return rc;
2209 }
2210 METHOD_END
2211 ///
2212 /// BASE_IS_MULTI
2213 METHOD(GroupClassIsMulti, Msg, msg)
2214 {
2215    return TRUE;
2216 }
2217 METHOD_END
2218 ///
2219 /// Class initialization.
2220 /*
2221  * Class function table.
2222  */
2223 STATIC DPFUNC ClassFunc[] = {
2224    { BASE_RENDER,            GroupClassRender },
2225    { BASE_LAYOUT,            GroupClassLayout },
2226    { BASE_DIMENSIONS,        GroupClassDimensions },
2227    { GRM_DIMENSIONS,         GroupClassDimensionsX },
2228
2229    { OM_NEW,                 GroupClassNew },
2230    { OM_SET,                 GroupClassSet },
2231    { OM_GET,                 GroupClassGet },
2232    { OM_DISPOSE,             GroupClassDispose },
2233    { GM_GOACTIVE,            GroupClassActiveInput },
2234    { GM_HANDLEINPUT,         GroupClassActiveInput },
2235    { GM_GOINACTIVE,          GroupClassInActive },
2236    { GM_HITTEST,             GroupClassHitTest },
2237
2238    { GROUPM_OBTAINMEMBERS,   GroupClassObtainMembers },
2239    { GROUPM_RELEASEMEMBERS,  GroupClassReleaseMembers },
2240    { GROUPM_NEWMEMBER,       GroupClassNewMember },
2241    { GRM_ADDMEMBER,          GroupClassAddMember },
2242    { GRM_REMMEMBER,          GroupClassRemMember },
2243    { GRM_ADDSPACEMEMBER,     GroupClassAddSpaceMember },
2244    { GRM_INSERTMEMBER,       GroupClassInsert },
2245    { GRM_REPLACEMEMBER,      GroupClassReplace },
2246    { GRM_WHICHOBJECT,        GroupClassWhichObject },
2247    { BASE_MOVEBOUNDS,        GroupClassAll },
2248    { BASE_FINDKEY,           GroupClassFindKey },
2249    { BASE_KEYLABEL,          GroupClassAll },
2250    { BASE_LOCALIZE,          GroupClassAll },
2251    { BASE_SHOWHELP,          GroupClassHelp },
2252    { BASE_LEFTEXT,           GroupClassLeftExt },
2253    { BASE_INHIBIT,           GroupClassAll },
2254    { BASE_IS_MULTI,          GroupClassIsMulti },
2255
2256    { DF_END },
2257 };
2258
2259 /*
2260  * Simple class initialization.
2261  */
2262 makeproto Class *InitGroupClass(void)
2263 {
2264    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
2265                          CLASS_ObjectSize,     sizeof(GD),
2266                          CLASS_DFTable,        ClassFunc,
2267                          TAG_DONE);
2268 }
2269 ///