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          struct List *membList = (struct List *)&gd->gd_Members;
 808          n1 = membList->lh_Head;
 809
 810          while ((n2 = n1->ln_Succ)->ln_Succ)
 811          {
 812             Remove(n2);
 813             AddHead(membList, n2);
 814          };
 815       };
 816
 817       /*
 818        * All OK?
 819        */
 820       if (!(gd->gd_Flags & GDF_ADD_FAILURE))
 821       {
 822          if (GADGET(rc)->Activation & GACT_TOPBORDER) l++;
 823
 824          DoSuperSetMethodNG(cl, (Object *)rc, BT_LeftOffset, HSpace(l),  BT_RightOffset,  HSpace(r),
 825                                               BT_TopOffset,  VSpace(t),  BT_BottomOffset, VSpace(b), TAG_DONE);
 826
 827          GroupSetAttrs(cl, (Object *)rc, ops);
 828       }
 829       else
 830       {
 831          /*
 832           * Noop... dump the object.
 833           */
 834          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 835          rc = 0;
 836       };
 837    };
 838    return rc;
 839 }
 840 METHOD_END
 841 ///
 842 /// OM_SET
 843 /*
 844  * Set one or more attributes.
 845  */
 846 METHOD(GroupClassSet, struct opSet *, ops)
 847 {
 848    /*
 849     * First we let the superclass have a go at it.
 850     */
 851    AsmDoSuperMethodA(cl, obj, (Msg)ops);
 852
 853    return GroupSetAttrs(cl, obj, ops);
 854 }
 855 METHOD_END
 856 ///
 857 /// OM_GET
 858 METHOD(GroupClassGet, struct opGet *, opg)
 859 {
 860    GD       *gd = INST_DATA(cl, obj);
 861    ULONG     rc = 1;
 862    IPTR     *store = opg->opg_Storage;
 863
 864    switch (opg->opg_AttrID)
 865    {
 866    case GROUP_Rows:
 867       STORE gd->gd_Rows;
 868       break;
 869
 870    case GROUP_Columns:
 871       STORE gd->gd_Columns;
 872       break;
 873
 874    case GROUP_HorizSpacing:
 875       STORE gd->gd_SpaceX;
 876       break;
 877
 878    case GROUP_VertSpacing:
 879       STORE gd->gd_SpaceY;
 880       break;
 881
 882    case GROUP_HorizAlign:
 883       STORE gd->gd_HAlign;
 884       break;
 885
 886    case GROUP_VertAlign:
 887       STORE gd->gd_VAlign;
 888       break;
 889
 890    case GROUP_Members:
 891       STORE gd->gd_MD;
 892       break;
 893
 894    case GROUP_NumMembers:
 895       STORE gd->gd_NumMembers;
 896       break;
 897
 898    case GROUP_Style:
 899       STORE gd->gd_Style;
 900       break;
 901
 902    default:
 903       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 904       break;
 905    };
 906    return rc;
 907 }
 908 METHOD_END
 909
 910 static Object **ObtainMembers(Object *obj,GD *gd,BOOL *got_members_list)
 911 {
 912    if(gd->gd_MD==NULL)
 913    {
 914       if (!(gd->gd_MD = (Object **)AsmDoMethod(obj, GROUPM_OBTAINMEMBERS, GROMF_WAIT|GROMF_VISIBLE, &gd->gd_NumMembers)))
 915          return 0;
 916       *got_members_list=TRUE;
 917    }
 918    else
 919       *got_members_list=FALSE;
 920    return(gd->gd_MD);
 921 }
 922
 923 static VOID ReleaseMembers(Object *obj,GD *gd,BOOL got_members_list)
 924 {
 925    if(got_members_list)
 926    {
 927       AsmDoMethod(obj, GROUPM_RELEASEMEMBERS, gd->gd_MD);
 928       gd->gd_MD=NULL;
 929       gd->gd_NumMembers=0;
 930    }
 931 }
 932
 933 ///
 934 /// BASE_LAYOUT
 935 /*
 936  * Layout the group.
 937  */
 938 METHOD(GroupClassLayout, struct bmLayout *, bml)
 939 {
 940    GD           *gd = INST_DATA(cl, obj);
 941    BC           *bc = BASE_DATA(obj);
 942    Object       *m;
 943    MD           *md;
 944    TD           *td, *cd, *rd;
 945    BOOL          changed,got_members_list;
 946    ULONG         totalweight, totalsize, tw, th;
 947 /*   UBYTE         align; */
 948    int           r, c, size, last;
 949    int           x, y, dx, dy, w, h;
 950
 951    /*
 952     * Layout the baseclass.
 953     */
 954    AsmDoSuperMethodA(cl, obj, (Msg)bml);
 955
 956    if (!(bml->bml_Flags & BLF_CUSTOM_GROUP))
 957    {
 958       w = bc->bc_InnerBox.Width  - (HSpace(gd->gd_SpaceX) * (gd->gd_Columns - 1));
 959       h = bc->bc_InnerBox.Height - (VSpace(gd->gd_SpaceY) * (gd->gd_Rows - 1));
 960
 961       if(ObtainMembers(obj,gd,&got_members_list)==NULL)
 962          return(0);
 963       if (!gd->gd_NumMembers)
 964       {
 965          ReleaseMembers(obj,gd,got_members_list);
 966          return 1;
 967       }
 968
 969       /*
 970        * Set starting values.
 971        */
 972       tw = 0;
 973       for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
 974       {
 975          tw += (td->td_Size = td->td_Nom);
 976       };
 977
 978       last = 0;
 979       do
 980       {
 981          /*
 982           * First loop to get total weight.
 983           */
 984          totalweight = 0;
 985          totalsize   = w;
 986          for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
 987          {
 988             if (td->td_Size < td->td_Max)
 989                totalweight += td->td_Weight;
 990             else
 991                totalsize   -= td->td_Size;
 992          };
 993
 994          if ((totalweight == 0) || (totalsize <= 0)) break;
 995
 996          /*
 997           * Loop to get all scaled sizes.
 998           */
 999          tw = 0;
1000          for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1001          {
1002             if (td->td_Size < td->td_Max)
1003             {
1004                size = ScaleWeight(totalsize, totalweight, td->td_Weight);
1005                td->td_Size = range(size, td->td_Min, td->td_Max);
1006             };
1007
1008             /*
1009              * Keep track of the total size.
1010              */
1011             tw += td->td_Size;
1012          };
1013          if (tw == last) break;
1014          last = tw;
1015       }  while (tw < w);
1016
1017       /*
1018        * Constantly adjust the size of objects which where scaled larger
1019        * than their minimum size when the total scaled size was larger than
1020        * the area the objects must fit in.
1021        */
1022       while (tw > w)
1023       {
1024          changed = FALSE;
1025          for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1026          {
1027             /*
1028              * Was the size bigger than the minimum size?
1029              */
1030             if (td->td_Size > td->td_Min)
1031             {
1032                changed = TRUE;
1033                td->td_Size--;
1034                tw--;
1035             };
1036
1037             /*
1038              * Are we done yet?
1039              */
1040             if (tw <= w) break;
1041          };
1042          if (!changed) break;
1043       };
1044
1045       /*
1046        * Set starting values.
1047        */
1048       th = 0;
1049       for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1050       {
1051          th += (td->td_Size = td->td_Nom);
1052       };
1053
1054       last = 0;
1055       do
1056       {
1057          /*
1058           * First loop to get total weight.
1059           */
1060          totalweight = 0;
1061          totalsize   = h;
1062
1063          for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1064          {
1065             if (td->td_Size < td->td_Max)
1066                totalweight += td->td_Weight;
1067             else
1068                totalsize   -= td->td_Size;
1069          };
1070
1071          if ((totalweight == 0) || (totalsize <= 0)) break;
1072
1073          /*
1074           * Loop to get all scaled sizes.
1075           */
1076          th = 0;
1077          for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1078          {
1079             if (td->td_Size < td->td_Max)
1080             {
1081                size = ScaleWeight(totalsize, totalweight, td->td_Weight);
1082                td->td_Size = range(size, td->td_Min, td->td_Max);
1083             };
1084
1085             /*
1086              * Keep track of the total size.
1087              */
1088             th += td->td_Size;
1089          };
1090          if (th == last) break;
1091          last = th;
1092       }  while (th < h);
1093
1094       /*
1095        * Constantly adjust the size of objects which where scaled larger
1096        * than their minimum size when the total scaled size was larger than
1097        * the area the objects must fit in.
1098        */
1099       while (th > h)
1100       {
1101          changed = FALSE;
1102          for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1103          {
1104             /*
1105              * Was the size bigger than the minimum size?
1106              */
1107             if (td->td_Size > td->td_Min)
1108             {
1109                changed = TRUE;
1110                td->td_Size--;
1111                th--;
1112             };
1113
1114             /*
1115              * Are we done yet?
1116              */
1117             if (th <= h) break;
1118          };
1119          if (!changed) break;
1120       };
1121
1122       /*
1123        * Scan through the members.
1124        */
1125       x = bc->bc_InnerBox.Left;
1126
1127       for (c = 0, cd = gd->gd_CD; c < gd->gd_Columns; c++, cd++)
1128       {
1129          y = bc->bc_InnerBox.Top;
1130
1131          for (r = 0, rd = gd->gd_RD; r < gd->gd_Rows; r++, rd++)
1132          {
1133             if ((m = GroupNode(gd, r, c)))
1134             {
1135                md = MEMBER_DATA(m);
1136
1137                md->md_Bounds.Width  = range(cd->td_Size - md->md_HBLeft, md->md_MinWidth,  md->md_MaxWidth);
1138                md->md_Bounds.Height = range(rd->td_Size,                 md->md_MinHeight, md->md_MaxHeight);
1139
1140                switch (md->md_HAlign ? md->md_HAlign : gd->gd_HAlign)
1141                {
1142                default:
1143                case GRALIGN_LEFT:
1144                   dx = md->md_HBLeft;
1145                   break;
1146                case GRALIGN_CENTER:
1147                   dx = max(0, cd->td_Size - md->md_Bounds.Width) >> 1;
1148                   break;
1149                case GRALIGN_RIGHT:
1150                   dx = max(0, cd->td_Size - md->md_Bounds.Width);
1151                   break;
1152                };
1153
1154                switch (md->md_VAlign ? md->md_VAlign : gd->gd_VAlign)
1155                {
1156                default:
1157                case GRALIGN_TOP:
1158                   dy = 0;
1159                   break;
1160                case GRALIGN_CENTER:
1161                   dy = max(0, rd->td_Size - md->md_Bounds.Height) >> 1;
1162                   break;
1163                case GRALIGN_BOTTOM:
1164                   dy = max(0, rd->td_Size - md->md_Bounds.Height);
1165                   break;
1166                };
1167
1168                md->md_Bounds.Left = x + dx;
1169                md->md_Bounds.Top  = y + dy;
1170             };
1171             y += rd->td_Size + VSpace(gd->gd_SpaceY);
1172          };
1173          x += cd->td_Size + HSpace(gd->gd_SpaceX);
1174       }
1175       ReleaseMembers(obj,gd,got_members_list);
1176    };
1177
1178    return 1;
1179 }
1180 METHOD_END
1181 ///
1182 /// BASE_RENDER
1183
1184 struct SubRender
1185 {
1186    struct Message     sr_Message;
1187    Object            *sr_Object;
1188    struct GadgetInfo *sr_GInfo;
1189    struct RastPort   *sr_RPort;
1190 };
1191
1192 VOID SAVEDS subrender_task(void)
1193 {
1194    struct Process    *proc = (struct Process *)FindTask(NULL);
1195    struct SubRender  *sr;
1196
1197    WaitPort(&proc->pr_MsgPort);
1198    sr = (struct SubRender *)GetMsg(&proc->pr_MsgPort);
1199
1200    AsmDoMethod(sr->sr_Object, GM_RENDER, sr->sr_GInfo, sr->sr_RPort, GREDRAW_REDRAW);
1201
1202    ReplyMsg((struct Message *)sr);
1203 }
1204
1205 /*
1206  * Render the group.
1207  */
1208 METHOD(GroupClassRender, struct bmRender *, bmr)
1209 {
1210    GD                *gd = INST_DATA(cl, obj);
1211    BC                *bc = BASE_DATA(obj);
1212    Object            *m;
1213    MD                *md;
1214    struct BaseInfo   *bi = bmr->bmr_BInfo;
1215    struct RastPort   *rp = bi->bi_RPort;
1216    struct Process    *proc;
1217    struct MsgPort    *msgport = NULL;
1218    struct SubRender  *sr;
1219 /*   ULONG              rc = 0; */
1220    BOOL               subrender = FALSE; // no multitasking yet
1221    int                render_count = 0;
1222
1223    if (gd->gd_Flags & GDF_IS_MASTER)
1224    {
1225       if (!bc->bc_Frame)
1226       {
1227          BSetDPenA(bi, BACKGROUNDPEN);
1228          BBoxFillA(bi, &bc->bc_OuterBox);
1229       };
1230    };
1231
1232 WW(kprintf("***GroupClassRender*** obj = %x\n", obj));
1233
1234    /*
1235     * Render the baseclass.
1236     */
1237    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
1238
1239    /*
1240     * Top-border group hack...
1241     */
1242    if (GADGET(obj)->Activation & GACT_TOPBORDER)
1243    {
1244       BSetDPenA(bi, SHADOWPEN);
1245       Move(rp, bc->bc_OuterBox.Left, bc->bc_OuterBox.Top + 1);
1246       Draw(rp, bc->bc_OuterBox.Left, bc->bc_OuterBox.Top + bc->bc_OuterBox.Height - 1);
1247    };
1248
1249    if (subrender)
1250    {
1251       msgport = CreateMsgPort();
1252       if (!msgport) subrender = FALSE;
1253    };
1254
1255    m = NULL;
1256    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
1257    {
1258       /*
1259        * Setup object position/dimensions and render it.
1260        */
1261       SetGadgetBounds(md->md_Object, &md->md_Bounds);
1262
1263       proc = NULL;
1264
1265       if (subrender)
1266       {
1267          if ((sr = BGUI_AllocPoolMem(sizeof(struct SubRender))))
1268          {
1269             proc = CreateNewProcTags(NP_Entry, subrender_task, NP_Name, "BGUI Render", TAG_DONE);
1270
1271             if (!proc) BGUI_FreePoolMem(sr);
1272          };
1273       }
1274
1275       if (proc)
1276       {
1277          render_count++;
1278
1279          sr->sr_Message.mn_ReplyPort = msgport;
1280          sr->sr_Message.mn_Length    = sizeof(struct SubRender);
1281          sr->sr_Object               = md->md_Object;
1282          sr->sr_GInfo                = (struct GadgetInfo *)bi;
1283          sr->sr_RPort                = rp;
1284
1285          PutMsg(&proc->pr_MsgPort, &sr->sr_Message);
1286       }
1287       else
1288       {
1289          AsmDoMethod(md->md_Object, GM_RENDER, bi, rp, GREDRAW_REDRAW);
1290       };
1291    };
1292    if (subrender)
1293    {
1294       /*
1295        * Wait for all subtasks to finish.
1296        */
1297       while (render_count)
1298       {
1299          WaitPort(msgport);
1300          while ((sr = (struct SubRender *)GetMsg(msgport)))
1301          {
1302             BGUI_FreePoolMem(sr);
1303             render_count--;
1304          };
1305       };
1306       DeleteMsgPort(msgport);
1307    };
1308    return 1;
1309 }
1310 METHOD_END
1311 ///
1312 /// GM_HITTEST
1313 /*
1314  * Pass on the hittest message.
1315  */
1316 METHOD(GroupClassHitTest, struct gpHitTest *, gph)
1317 {
1318    GD                *gd = INST_DATA(cl, obj);
1319    Object            *m;
1320    MD                *md;
1321    ULONG              rc;
1322
1323    /*
1324     * See if a member was "hit".
1325     */
1326    m = NULL;
1327    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
1328    {
1329       /*
1330        * This member hit?
1331        */
1332       if ((rc = ForwardMsg(obj, md->md_Object, (Msg)gph)) == GMR_GADGETHIT)
1333       {
1334          /*
1335           * Make it the active one.
1336           */
1337          gd->gd_Active = md->md_Object;
1338          return rc;
1339       };
1340    };
1341
1342    /*
1343     * Safety precautions.
1344     */
1345    gd->gd_Active = NULL;
1346
1347    return 0;
1348 }
1349 METHOD_END
1350 ///
1351 /// GM_GOACTIVE, GM_HANDLEINPUT
1352 /*
1353  * Forward a GM_GOACTIVE or GM_HANDLEINPUT message.
1354  */
1355 METHOD(GroupClassActiveInput, struct gpInput *, gpi)
1356 {
1357    GD                *gd = INST_DATA(cl, obj);
1358    ULONG              rc = GMR_NOREUSE;
1359
1360    /*
1361     * Do we have an active member?
1362     */
1363    if (gd->gd_Active)
1364    {
1365       /*
1366        * Tell'm its active.
1367        */
1368       if (gpi->MethodID == GM_GOACTIVE)
1369          DoSetMethodNG(gd->gd_Active, BT_IsActive, TRUE, TAG_END);
1370
1371       rc = ForwardMsg(obj, gd->gd_Active, (Msg)gpi);
1372
1373       /*
1374        * Clone the ID.
1375        */
1376       DoSuperSetMethodNG(cl, obj, GA_ID, GADGET(gd->gd_Active)->GadgetID, TAG_DONE);
1377    }
1378    return rc;
1379 }
1380 METHOD_END
1381 ///
1382 /// GM_GOINACTIVE
1383 /*
1384  * Forward the GM_GOINACTIVE message.
1385  */
1386 METHOD(GroupClassInActive, Msg, msg)
1387 {
1388    GD          *gd = INST_DATA(cl, obj);
1389    ULONG        rc = 0;
1390
1391    /*
1392     * Inactivate the active member.
1393     */
1394    if (gd->gd_Active)
1395    {
1396       rc = AsmDoMethodA(gd->gd_Active, msg);
1397       /*
1398        * Tell 'm its in-active.
1399        */
1400       DoSetMethodNG(gd->gd_Active, BT_IsActive, FALSE, TAG_END);
1401       gd->gd_Active = NULL;
1402    };
1403    return rc;
1404 }
1405 METHOD_END
1406 ///
1407 /// OM_DISPOSE
1408 /*
1409  * Dispose of the group and all
1410  * it's members.
1411  */
1412 METHOD(GroupClassDispose, Msg, msg)
1413 {
1414    GD           *gd = INST_DATA(cl, obj);
1415    Object       *m, *o;
1416    MD           *md;
1417
1418    /*
1419     * Remove and dispose of all members.
1420     */
1421    while ((m = ListHeadObject((struct List *)&gd->gd_Members)))
1422    {
1423       md = MEMBER_DATA(m);
1424       o  = md->md_Object;
1425
1426       /*
1427        * Free the node.
1428        */
1429       AsmDoMethod(m, OM_DISPOSE);
1430
1431       /*
1432        * Dispose of the member.
1433        */
1434       AsmDoMethod(o, OM_DISPOSE);
1435    };
1436
1437    if (gd->gd_RD) BGUI_FreePoolMem(gd->gd_RD);
1438    if (gd->gd_CD) BGUI_FreePoolMem(gd->gd_CD);
1439
1440    /*
1441     * Leave the rest up to the superclass.
1442     */
1443    return AsmDoSuperMethodA(cl, obj, msg);
1444 }
1445 METHOD_END
1446 ///
1447 /// GRM_ADDMEMBER
1448 /*
1449  * Add a member to the group.
1450  */
1451 METHOD(GroupClassAddMember, struct grmAddMember *, grma)
1452 {
1453    GD             *gd = INST_DATA(cl, obj);
1454    Object         *m;
1455
1456    /*
1457     * Allocate and initialize node.
1458     */
1459    if ((m = NewGroupMember(obj, grma->grma_Member, (struct TagItem *)&grma->grma_Attr)))
1460    {
1461       /*
1462        * Add it to the list.
1463        */
1464       AsmDoMethod(m, RM_ADDTAIL, &gd->gd_Members);
1465
1466 WW(kprintf("** GroupClassAddMember\n"));
1467 WW(if(BASE_DATA(obj)->bc_Window) kprintf("** GroupClassAddMember: sending WM_SETUPGADGET to window\n"));
1468
1469       if(BASE_DATA(obj)->bc_Window)
1470          AsmDoMethod(BASE_DATA(obj)->bc_Window, WM_SETUPGADGET, grma->grma_Member, NULL);
1471
1472       /*
1473        * Try to re-layout the group.
1474        */
1475 WW(kprintf("** GroupClassAddMember: calling relayoutgroup: LGO_Relayout = %d\n",GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grma->grma_Attr)));
1476
1477       if(GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grma->grma_Attr)
1478       && !RelayoutGroup(obj))
1479       {
1480 WW(kprintf("** GroupClassAddMember: relayoutgroup failed. returning FALSE\n"));
1481          DisposeObject(m);
1482          RelayoutGroup(obj);
1483
1484          return FALSE;
1485       };
1486 WW(kprintf("** GroupClassAddMember: everything done. returning TRUE\n"));
1487
1488       return TRUE;
1489    };
1490    return FALSE;
1491 }
1492 METHOD_END
1493 ///
1494 /// GRM_INSERTMEMBER
1495 /*
1496  * Insert a member in the group.
1497  */
1498 METHOD(GroupClassInsert, struct grmInsertMember *, grmi)
1499 {
1500    GD             *gd = INST_DATA(cl, obj);
1501    Object         *m;
1502
1503    /*
1504     * No NULL-objects.
1505     */
1506    if (!grmi->grmi_Member)
1507       return FALSE;
1508
1509    /*
1510     * Allocate and initialize node.
1511     */
1512    if ((m = NewGroupMember(obj, grmi->grmi_Member, (struct TagItem *)&grmi->grmi_Attr)))
1513    {
1514       AsmDoMethod(m, RM_INSERT, &gd->gd_Members, FindObNode(gd, grmi->grmi_Pred));
1515
1516       if(BASE_DATA(obj)->bc_Window)
1517          AsmDoMethod(BASE_DATA(obj)->bc_Window, WM_SETUPGADGET, grmi->grmi_Member, NULL);
1518
1519       /*
1520        * Try to re-layout the group.
1521        */
1522       if(GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grmi->grmi_Attr)
1523       && !RelayoutGroup(obj))
1524       {
1525          DisposeObject(m);
1526          RelayoutGroup(obj);
1527
1528          return FALSE;
1529       };
1530       return TRUE;
1531    };
1532    return FALSE;
1533 }
1534 METHOD_END
1535 ///
1536 /// GRM_REPLACEMEMBER
1537 /*
1538  * Replace a member in the group.
1539  */
1540 METHOD(GroupClassReplace, struct grmReplaceMember *, grrm)
1541 {
1542    GD             *gd = INST_DATA(cl, obj);
1543    Object         *m, *old;
1544
1545    /*
1546     * No NULL-objects.
1547     */
1548    if (!grrm->grrm_MemberA || !grrm->grrm_MemberB)
1549       return 0;
1550
1551    /*
1552     * Allocate and initialize node.
1553     */
1554    if ((m = NewGroupMember(obj, grrm->grrm_MemberB, (struct TagItem *)&grrm->grrm_Attr)))
1555    {
1556       /*
1557        * Find member to replace.
1558        */
1559       if ((old = FindObNode(gd, grrm->grrm_MemberA)))
1560       {
1561          AsmDoMethod(m, RM_INSERT, &gd->gd_Members, old);
1562          AsmDoMethod(old, RM_REMOVE);
1563
1564          if(BASE_DATA(obj)->bc_Window)
1565             AsmDoMethod(BASE_DATA(obj)->bc_Window, WM_SETUPGADGET, grrm->grrm_MemberB, NULL);
1566
1567          /*
1568           * Try to re-layout the group.
1569           */
1570          if(GetTagData(LGO_Relayout, TRUE, (struct TagItem *)&grrm->grrm_Attr)
1571          && !RelayoutGroup(obj))
1572          {
1573             AsmDoMethod(old, RM_INSERT, &gd->gd_Members);
1574             DisposeObject(m);
1575             RelayoutGroup(obj);
1576
1577             return 0;
1578          };
1579
1580          /*
1581           * Deallocate replaced node.
1582           */
1583          DisposeObject(old);
1584
1585          /*
1586           * Set return code.
1587           */
1588          return (IPTR)grrm->grrm_MemberA;
1589       };
1590    };
1591    return 0;
1592 }
1593 METHOD_END
1594 ///
1595 /// GRM_REMMEMBER
1596 /*
1597  * Remove an object from the list.
1598  */
1599 METHOD(GroupClassRemMember, struct grmRemMember *, grmr)
1600 {
1601    GD             *gd = INST_DATA(cl, obj);
1602    Object         *m;
1603
1604    if ((m = FindObNode(gd, grmr->grmr_Member)))
1605    {
1606       /*
1607        * Remove and dealocate it.
1608        */
1609       DisposeObject(m);
1610
1611       /*
1612        * Relayout the group.
1613        */
1614       RelayoutGroup(obj);
1615
1616       return (IPTR)grmr->grmr_Member;
1617    }
1618    return (IPTR)NULL;
1619 }
1620 METHOD_END
1621 ///
1622 /// GROUPM_OBTAINMEMBERS
1623
1624 METHOD(GroupClassObtainMembers, struct gmObtainMembers *, gmom)
1625 {
1626    GD      *gd = INST_DATA(cl, obj);
1627    MD      *md;
1628    Object **o, *m;
1629    int      n;
1630    ULONG    flags = gmom->gmom_Flags;
1631
1632    if (flags & GROMF_WAIT)
1633    {
1634       if (flags & GROMF_EXCLUSIVE)
1635       {
1636          ObtainSemaphore(&gd->gd_Lock);
1637       }
1638       else
1639       {
1640          ObtainSemaphoreShared(&gd->gd_Lock);
1641       };
1642    }
1643    else
1644    {
1645       if (flags & GROMF_EXCLUSIVE)
1646       {
1647          n = AttemptSemaphore(&gd->gd_Lock);
1648       }
1649       else
1650       {
1651          n = AttemptSemaphoreShared(&gd->gd_Lock);
1652       };
1653       if (!n) return 0;
1654    };
1655
1656    n = 0;
1657    m = NULL;
1658    while ((md = NextGroupNode(gd, &m, (flags & GROMF_VISIBLE) ? MDF_HIDDEN : 0)))
1659       n++;
1660
1661    o = BGUI_AllocPoolMem(sizeof(Object *) * (n + 2));
1662
1663    if (!o)
1664    {
1665       ReleaseSemaphore(&gd->gd_Lock);
1666       return 0;
1667    }
1668
1669    *o++ = obj;  // Marker for safety.
1670
1671    m = NULL;
1672    while ((md = NextGroupNode(gd, &m, (flags & GROMF_VISIBLE) ? MDF_HIDDEN : 0)))
1673    {
1674       if (flags & GROMF_OBJECTS)
1675          *o++ = md->md_Object;
1676       else
1677          *o++ = m;
1678    };
1679
1680    if (gmom->gmom_Number) *(gmom->gmom_Number) = n;
1681    return (IPTR)(o - n);
1682 }
1683 METHOD_END
1684 ///
1685 /// GROUPM_RELEASEMEMBERS
1686
1687 METHOD(GroupClassReleaseMembers, struct gmReleaseMembers *, gmrm)
1688 {
1689    GD       *gd = INST_DATA(cl, obj);
1690    Object  **o = gmrm->gmrm_Array - 1;
1691    int       rc = -1;
1692
1693    if (*o == obj)  // Check for safety marker.
1694    {
1695       if (gd->gd_Lock.ss_Owner == FindTask(NULL))
1696       {
1697          rc = gd->gd_Lock.ss_NestCount - 1;
1698
1699          ReleaseSemaphore(&gd->gd_Lock);
1700       };
1701       BGUI_FreePoolMem(o);
1702    }
1703 #ifdef DEBUG_BGUI
1704    else
1705       D(bug("*** Attempt to free an invalid group members list\n"));
1706 #endif
1707    return (ULONG)rc;     // rc < 0 = failure, rc = 0 is freed, rc > 0 still locked.
1708 }
1709 METHOD_END
1710 ///
1711 /// RelayoutGroup
1712
1713 makeproto ASM ULONG RelayoutGroup(REG(a0) Object *obj)
1714 {
1715    BC                 *bc = BASE_DATA(obj);
1716    struct Window      *w = NULL;
1717    struct bmRelayout  bmr;
1718    ULONG               rc = 1;
1719
1720 WW(kprintf("** GroupClass_RelayoutGrop\n"));
1721
1722    if (bc->bc_Window)
1723    {
1724 WW(kprintf("** GroupClass_RelayoutGrop: has bc->bc_Window\n"));
1725       Get_Attr(bc->bc_Window, WINDOW_Window, (IPTR *)&w);
1726
1727       if (w)
1728       {
1729          bmr.MethodID   = BASE_RELAYOUT;
1730          bmr.bmr_GInfo = NULL;
1731          bmr.bmr_RPort = w->RPort;
1732 WW(kprintf("** GroupClass_RelayoutGrop: has WINDOW_Window --> sending BASE_RELAYOUT to obj\n"));
1733
1734          rc = BGUI_DoGadgetMethodA(obj, w, NULL, (Msg)&bmr);
1735       };
1736    };
1737    return rc;
1738 }
1739 ///
1740
1741 /// MemberDimensions
1742 /*
1743  * Calculate the minimum size of a group.
1744  */
1745 STATIC ASM BOOL MemberDimensions(REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct bmDimensions *bmd)
1746 {
1747    GD                *gd = INST_DATA(cl, obj);
1748    Object            *m;
1749    MD                *md;
1750    TD                *td;
1751    ULONG              minw, minh, nomw, nomh, maxw, maxh;
1752    ULONG              tmin, tmax, tnom;
1753    int                r, c;
1754    BOOL               got_members_list;
1755
1756    if(ObtainMembers(obj,gd,&got_members_list)==NULL)
1757       return FALSE;
1758    if (gd->gd_NumMembers)
1759    {
1760       if (gd->gd_Style == GRSTYLE_HORIZONTAL)
1761       {
1762          gd->gd_Rows = range(gd->gd_Rows, 1, gd->gd_NumMembers);
1763          gd->gd_Columns = (gd->gd_NumMembers + (gd->gd_Rows - 1)) / gd->gd_Rows;
1764       };
1765
1766       if (gd->gd_Style == GRSTYLE_VERTICAL)
1767       {
1768          gd->gd_Columns = range(gd->gd_Columns, 1, gd->gd_NumMembers);
1769          gd->gd_Rows = (gd->gd_NumMembers + (gd->gd_Columns - 1)) / gd->gd_Columns;
1770       };
1771
1772       if (gd->gd_RD) BGUI_FreePoolMem(gd->gd_RD);
1773       if (gd->gd_CD) BGUI_FreePoolMem(gd->gd_CD);
1774
1775       gd->gd_RD = BGUI_AllocPoolMem(sizeof(TD) * gd->gd_Rows);
1776       gd->gd_CD = BGUI_AllocPoolMem(sizeof(TD) * gd->gd_Columns);
1777
1778       if (!(gd->gd_RD && gd->gd_CD)) return FALSE;
1779
1780       /*
1781        * Scan through the members.
1782        */
1783       for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1784       {
1785          td->td_PreAlign = 0;
1786
1787          for (r = 0; r < gd->gd_Rows; r++)
1788          {
1789             if ((m = GroupNode(gd, r, c)))
1790             {
1791                md = MEMBER_DATA(m);
1792
1793                /*
1794                 * Find out how much we must adjust for alignment.
1795                 */
1796                AsmDoMethod(md->md_Object, BASE_LEFTEXT, bmd->bmd_BInfo->bi_RPort, &md->md_HBLeft);
1797
1798                if (!md->md_HBLeft)
1799                {
1800                   if (!(md->md_Flags & MDF_NO_NO_ALIGN))
1801                      md->md_Flags |= MDF_NO_ALIGN;
1802                }
1803                else
1804                {
1805                   if (md->md_HBLeft > td->td_PreAlign) td->td_PreAlign = md->md_HBLeft;
1806                };
1807             };
1808          };
1809
1810          tmin = 0;
1811          tnom = 0;
1812          tmax = 0;
1813
1814          for (r = 0; r < gd->gd_Rows; r++)
1815          {
1816             if ((m = GroupNode(gd, r, c)))
1817             {
1818                md = MEMBER_DATA(m);
1819
1820                if (!(md->md_Flags & MDF_NO_ALIGN))
1821                {
1822                   md->md_HBLeft = td->td_PreAlign - md->md_HBLeft;
1823                }
1824                else
1825                {
1826                   md->md_HBLeft = 0;
1827                };
1828
1829                if (r == 0) td->td_Weight = md->md_Weight;
1830
1831                /*
1832                 * Adjust the minimum width with the maximum extention.
1833                 */
1834                tmin = max(tmin, md->md_MinWidth + md->md_HBLeft);
1835                tnom = max(tnom, md->md_NomWidth + md->md_HBLeft);
1836                tmax = max(tmax, md->md_MaxWidth);
1837             };
1838          };
1839
1840          td->td_Min = tmin;
1841          td->td_Max = tmax;
1842          td->td_Nom = range(tnom, tmin, tmax);
1843       };
1844
1845       /*
1846        * Scan through the members.
1847        */
1848       for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1849       {
1850          tmin = 0;
1851          tnom = 0;
1852          tmax = 0;
1853
1854          for (c = 0; c < gd->gd_Columns; c++)
1855          {
1856             if ((m = GroupNode(gd, r, c)))
1857             {
1858                md = MEMBER_DATA(m);
1859
1860                if (c == 0) td->td_Weight = md->md_Weight;
1861
1862                tmin = max(tmin, md->md_MinHeight);
1863                tnom = max(tnom, md->md_NomHeight);
1864                tmax = max(tmax, md->md_MaxHeight);
1865             };
1866          };
1867
1868          td->td_Min = tmin;
1869          td->td_Max = tmax;
1870          td->td_Nom = range(tnom, tmin, tmax);
1871       };
1872
1873       minw = nomw = HSpace(gd->gd_SpaceX) * (gd->gd_Columns - 1);
1874       minh = nomh = VSpace(gd->gd_SpaceY) * (gd->gd_Rows - 1);
1875       maxw = maxh = 0;
1876
1877       for (r = 0, td = gd->gd_RD; r < gd->gd_Rows; r++, td++)
1878       {
1879          minh += td->td_Min;
1880          nomh += td->td_Nom;
1881          maxh += td->td_Max;
1882       };
1883
1884       for (c = 0, td = gd->gd_CD; c < gd->gd_Columns; c++, td++)
1885       {
1886          minw += td->td_Min;
1887          nomw += td->td_Nom;
1888          maxw += td->td_Max;
1889       };
1890    }
1891    else
1892    {
1893       /*
1894        * No members.
1895        */
1896       minw = minh = 0;
1897       nomw = nomh = 0;
1898       maxw = maxh = 0xFFFF;
1899    };
1900
1901    ReleaseMembers(obj,gd,got_members_list);
1902
1903    minw = max(minw, 1);
1904    minh = max(minh, 1);
1905
1906    maxw = range(maxw, minw, 0xFFFF);
1907    maxh = range(maxh, minh, 0xFFFF);
1908
1909    nomw = range(nomw, minw, maxw);
1910    nomh = range(nomh, minh, maxh);
1911
1912    bmd->bmd_Extent->be_Min.Width  += minw;
1913    bmd->bmd_Extent->be_Min.Height += minh;
1914    bmd->bmd_Extent->be_Nom.Width  += nomw;
1915    bmd->bmd_Extent->be_Nom.Height += nomh;
1916    bmd->bmd_Extent->be_Max.Width   = maxw;
1917    bmd->bmd_Extent->be_Max.Height  = maxh;
1918
1919    return TRUE;
1920 }
1921 ///
1922 /// BASE_DIMENSIONS
1923 /*
1924  * They want our dimensions info.
1925  */
1926 METHOD(GroupClassDimensions, struct bmDimensions *, bmd)
1927 {
1928    GD                   *gd = INST_DATA(cl, obj);
1929 /*   BC                   *bc = BASE_DATA(obj); */
1930    Object               *m;
1931    MD                   *md;
1932    struct grmDimensions  dim;
1933    UWORD                 mw = 0, mh = 0, minw, minh, maxw, maxh, nomw, nomh;
1934    ULONG                 rc;
1935
1936    dim.MethodID            = GRM_DIMENSIONS;
1937    dim.grmd_GInfo          = (struct GadgetInfo *)bmd->bmd_BInfo;
1938    dim.grmd_RPort          = bmd->bmd_BInfo->bi_RPort;
1939    dim.grmd_Flags          = bmd->bmd_Flags | GDIMF_MAXIMUM|GDIMF_NOMINAL;
1940    dim.grmd_MinSize.Width  = &minw;
1941    dim.grmd_MinSize.Height = &minh;
1942    dim.grmd_MaxSize.Width  = &maxw;
1943    dim.grmd_MaxSize.Height = &maxh;
1944    dim.grmd_NomSize.Width  = &nomw;
1945    dim.grmd_NomSize.Height = &nomh;
1946
1947    /*
1948     * Browse through the members.
1949     */
1950    m = NULL;
1951    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN)))
1952    {
1953       if (md->md_Flags & MDF_SPACING)
1954       {
1955          md->md_MinWidth  = 0;
1956          md->md_MinHeight = 0;
1957          md->md_NomWidth  = 0;
1958          md->md_NomHeight = 0;
1959          md->md_MaxWidth  = 0xFFFF;
1960          md->md_MaxHeight = 0xFFFF;
1961       }
1962       else
1963       {
1964          /*
1965           * Ask dimensions.
1966           */
1967          AsmDoMethodA(md->md_Object, (Msg)&dim);
1968
1969          /*
1970           * Make sure the fixed sizes are not smaller than allowed.
1971           */
1972          if (md->md_FixedWidth >= 0)
1973          {
1974             maxw = minw = nomw = range(md->md_FixedWidth, minw, maxw);
1975          };
1976          if (md->md_FixedHeight >= 0)
1977          {
1978             maxh = minh = nomh = range(md->md_FixedHeight, minh, maxh);
1979          };
1980          if (minw > mw) mw = minw;
1981          if (minh > mh) mh = minh;
1982
1983          md->md_MinWidth  = minw;
1984          md->md_MinHeight = minh;
1985          md->md_MaxWidth  = max(minw, maxw);
1986          md->md_MaxHeight = max(minh, maxh);
1987          md->md_NomWidth  = range(nomw, minw, maxw);
1988          md->md_NomHeight = range(nomh, minh, maxh);
1989       };
1990    };
1991
1992    m = NULL;
1993    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN)))
1994    {
1995       /*
1996        * Set equal width/height.
1997        */
1998       if (gd->gd_Flags & GDF_EQUAL_MINWIDTH)  md->md_MinWidth  = mw;
1999       if (gd->gd_Flags & GDF_EQUAL_MINHEIGHT) md->md_MinHeight = mh;
2000    };
2001
2002    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)bmd)))
2003    {
2004       /*
2005        * Calculate constraints.
2006        */
2007       if (!(bmd->bmd_Flags & BDF_CUSTOM_GROUP))
2008          rc = MemberDimensions(cl, obj, bmd);
2009    };
2010    return rc;
2011 }
2012 METHOD_END
2013 ///
2014 /// GRM_DIMENSIONS
2015 METHOD(GroupClassDimensionsX, struct grmDimensions *, dim)
2016 {
2017    GD    *gd = INST_DATA(cl, obj);
2018    ULONG rc=0;
2019    BOOL got_members_list;
2020
2021    if(ObtainMembers(obj,gd,&got_members_list)==NULL)
2022       return(0);
2023    rc=AsmDoSuperMethodA(cl, obj, (Msg)dim);
2024    ReleaseMembers(obj,gd,got_members_list);
2025    return(rc);
2026 }
2027 METHOD_END
2028
2029 ///
2030 /// BASE_SHOWHELP
2031 /*
2032  * Pass on the help message.
2033  */
2034 METHOD(GroupClassHelp, struct bmShowHelp *, bsh)
2035 {
2036    GD           *gd = INST_DATA(cl, obj);
2037    Object       *m;
2038    MD           *md;
2039    ULONG         rc = BMHELP_NOT_ME;
2040
2041    m = NULL;
2042    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)) && (rc == BMHELP_NOT_ME))
2043    {
2044       /*
2045        * Is this the one?
2046        */
2047       rc = AsmDoMethodA(md->md_Object, (Msg)bsh);
2048    };
2049    return rc;
2050 }
2051 METHOD_END
2052 ///
2053 /// GRM_ADDSPACEMEMBER
2054 /*
2055  * Add a spacing object.
2056  */
2057 METHOD(GroupClassAddSpaceMember, struct grmAddSpaceMember *, grms)
2058 {
2059    GD           *gd = INST_DATA(cl, obj);
2060    Object       *m;
2061
2062    if ((m = NewSpaceObject(obj, grms->grms_Weight)))
2063    {
2064       AsmDoMethod(m, RM_ADDTAIL, &gd->gd_Members);
2065       return TRUE;
2066    };
2067    return FALSE;
2068 }
2069 METHOD_END
2070 ///
2071 /// BASE_LEFTEXT
2072 /*
2073  * Route a BASE_LEFTEXT method.
2074  */
2075 METHOD(GroupClassLeftExt, struct bmLeftExt *, le)
2076 {
2077    GD          *gd = INST_DATA(cl, obj);
2078    BC          *bc = BASE_DATA(obj);
2079    IPTR         rc;
2080
2081    /*
2082     * Do we have a label or frame? If so we
2083     * take the left-extention of this object.
2084     */
2085    if (bc->bc_Label)
2086    {
2087       return AsmDoSuperMethodA(cl, obj, (Msg)le);
2088    };
2089
2090    if (bc->bc_Frame)
2091    {
2092       Get_Attr(bc->bc_Frame, FRM_Type, &rc);
2093       if (rc != FRTYPE_NONE)
2094       {
2095          return AsmDoSuperMethodA(cl, obj, (Msg)le);
2096       };
2097    };
2098
2099    /*
2100     * Get the biggest in the first column.
2101     */
2102    if(gd->gd_CD)
2103       *(le->bmle_Extention) = gd->gd_CD[0].td_PreAlign;
2104    else
2105    {
2106       *(le->bmle_Extention)=0;
2107    }
2108
2109    return 1;
2110 }
2111 METHOD_END
2112 ///
2113 /// GRM_WHICHOBJECT
2114 /*
2115  * Which object is under the mouse?
2116  */
2117 METHOD(GroupClassWhichObject, struct grmWhichObject *, grwo)
2118 {
2119    GD              *gd = INST_DATA(cl, obj);
2120    struct IBox     *ibox;
2121    Object          *m;
2122    MD              *md;
2123    WORD             x, y;
2124    ULONG            rc;
2125
2126    /*
2127     * Pick up the coords.
2128     */
2129    x = grwo->grwo_Coords.X;
2130    y = grwo->grwo_Coords.Y;
2131
2132    /*
2133     * See if the coords are over a member.
2134     */
2135    m = NULL;
2136    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
2137    {
2138       /*
2139        * If this is a group/page we pass on the method.
2140        */
2141       if (IsMulti(md->md_Object))
2142       {
2143          if ((rc = AsmDoMethodA(md->md_Object, (Msg)grwo)))
2144             return rc;
2145       }
2146
2147       /*
2148        * Get hitbox bounds.
2149        */
2150       ibox = GADGETBOX(md->md_Object);
2151
2152       /*
2153        * Over this object?
2154        */
2155       if (x >= ibox->Left && x < (ibox->Left + ibox->Width ) &&
2156           y >= ibox->Top  && y < (ibox->Top  + ibox->Height))
2157          /*
2158           * Yes.
2159           */
2160          return (IPTR)md->md_Object;
2161
2162    }
2163    return (IPTR)NULL;
2164 }
2165 METHOD_END
2166 ///
2167 /// BASE_FINDKEY
2168 /*
2169  * Which object has the proper key?
2170  */
2171 METHOD(GroupClassFindKey, struct bmFindKey *, bmfk)
2172 {
2173    GD           *gd = INST_DATA(cl, obj);
2174    Object       *m;
2175    MD           *md;
2176    ULONG         rc;
2177
2178    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)bmfk)))
2179       return rc;
2180
2181    m = NULL;
2182    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN | MDF_SPACING)))
2183    {
2184       if ((rc = AsmDoMethodA(md->md_Object, (Msg)bmfk)))
2185          return rc;
2186    };
2187    return 0;
2188 }
2189 METHOD_END
2190 ///
2191 /// #?
2192 /*
2193  * Attach keys from labels.
2194  */
2195 METHOD(GroupClassAll, Msg, msg)
2196 {
2197    GD           *gd = INST_DATA(cl, obj);
2198    Object       *m;
2199    MD           *md;
2200    ULONG         rc;
2201
2202    rc = AsmDoSuperMethodA(cl, obj, msg);
2203
2204    m = NULL;
2205    while ((md = NextGroupNode(gd, &m, MDF_HIDDEN)))
2206    {
2207       rc += AsmDoMethodA(md->md_Object, msg);
2208    };
2209    return rc;
2210 }
2211 METHOD_END
2212 ///
2213 /// BASE_IS_MULTI
2214 METHOD(GroupClassIsMulti, Msg, msg)
2215 {
2216    return TRUE;
2217 }
2218 METHOD_END
2219 ///
2220 /// Class initialization.
2221 /*
2222  * Class function table.
2223  */
2224 STATIC DPFUNC ClassFunc[] = {
2225    { BASE_RENDER,            GroupClassRender },
2226    { BASE_LAYOUT,            GroupClassLayout },
2227    { BASE_DIMENSIONS,        GroupClassDimensions },
2228    { GRM_DIMENSIONS,         GroupClassDimensionsX },
2229
2230    { OM_NEW,                 GroupClassNew },
2231    { OM_SET,                 GroupClassSet },
2232    { OM_GET,                 GroupClassGet },
2233    { OM_DISPOSE,             GroupClassDispose },
2234    { GM_GOACTIVE,            GroupClassActiveInput },
2235    { GM_HANDLEINPUT,         GroupClassActiveInput },
2236    { GM_GOINACTIVE,          GroupClassInActive },
2237    { GM_HITTEST,             GroupClassHitTest },
2238
2239    { GROUPM_OBTAINMEMBERS,   GroupClassObtainMembers },
2240    { GROUPM_RELEASEMEMBERS,  GroupClassReleaseMembers },
2241    { GROUPM_NEWMEMBER,       GroupClassNewMember },
2242    { GRM_ADDMEMBER,          GroupClassAddMember },
2243    { GRM_REMMEMBER,          GroupClassRemMember },
2244    { GRM_ADDSPACEMEMBER,     GroupClassAddSpaceMember },
2245    { GRM_INSERTMEMBER,       GroupClassInsert },
2246    { GRM_REPLACEMEMBER,      GroupClassReplace },
2247    { GRM_WHICHOBJECT,        GroupClassWhichObject },
2248    { BASE_MOVEBOUNDS,        GroupClassAll },
2249    { BASE_FINDKEY,           GroupClassFindKey },
2250    { BASE_KEYLABEL,          GroupClassAll },
2251    { BASE_LOCALIZE,          GroupClassAll },
2252    { BASE_SHOWHELP,          GroupClassHelp },
2253    { BASE_LEFTEXT,           GroupClassLeftExt },
2254    { BASE_INHIBIT,           GroupClassAll },
2255    { BASE_IS_MULTI,          GroupClassIsMulti },
2256
2257    { DF_END },
2258 };
2259
2260 /*
2261  * Simple class initialization.
2262  */
2263 makeproto Class *InitGroupClass(void)
2264 {
2265    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
2266                          CLASS_ObjectSize,     sizeof(GD),
2267                          CLASS_DFTable,        ClassFunc,
2268                          TAG_DONE);
2269 }
2270 ///