bgui/rootclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * rootclass.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.5  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.4  2003/01/18 19:10:00  chodorowski
  18  * Instead of using the _AROS or __AROS preprocessor symbols, use __AROS__.
  19  *
  20  * Revision 42.3  2000/08/17 15:09:18  chodorowski
  21  * Fixed compiler warnings.
  22  *
  23  * Revision 42.2  2000/05/29 00:40:24  bergers
  24  * Update to compile with AROS now. Should also still compile with SASC etc since I only made changes that test the define __AROS__. The compilation is still very noisy but it does the trick for the main directory. Maybe members of the BGUI team should also have a look at the compiler warnings because some could also cause problems on other systems... (Comparison always TRUE due to datatype (or something like that)). And please compile it on an Amiga to see whether it still works... Thanks.
  25  *
  26  * Revision 42.1  2000/05/15 19:27:02  stegerg
  27  * another hundreds of REG() macro replacements in func headers/protos.
  28  *
  29  * Revision 42.0  2000/05/09 22:10:06  mlemos
  30  * Bumped to revision 42.0 before handing BGUI to AROS team
  31  *
  32  * Revision 41.11  2000/05/09 19:55:01  mlemos
  33  * Merged with the branch Manuel_Lemos_fixes.
  34  *
  35  * Revision 41.10.2.7  1999/07/31 01:56:37  mlemos
  36  * Added calls to the code that keeps track of the created objects.
  37  *
  38  * Revision 41.10.2.6  1999/07/03 15:17:45  mlemos
  39  * Replaced the calls to CallHookPkt to BGUI_CallHookPkt.
  40  *
  41  * Revision 41.10.2.5  1998/11/21 00:27:15  mlemos
  42  * Fixed erroneous code in OM_UPDATE.
  43  *
  44  * Revision 41.10.2.4  1998/11/19 01:23:33  mlemos
  45  * Fixed the return value type of BASE_ADDMAP value.
  46  *
  47  * Revision 41.10.2.3  1998/09/19 01:54:21  mlemos
  48  * Made BASE_ADDHOOK method return TRUE on success rather than the hook linet
  49  * entry pointer.
  50  *
  51  * Revision 41.10.2.2  1998/03/02 23:49:04  mlemos
  52  * Switched vector allocation functions calls to BGUI allocation functions.
  53  *
  54  * Revision 41.10.2.1  1998/03/01 15:39:19  mlemos
  55  * Added support to track BaseInfo memory leaks.
  56  *
  57  * Revision 41.10  1998/02/25 21:13:01  mlemos
  58  * Bumping to 41.10
  59  *
  60  * Revision 1.1  1998/02/25 17:09:41  mlemos
  61  * Ian sources
  62  *
  63  *
  64  */
  65
  66 #include "include/classdefs.h"
  67
  68 #define NOTIFY_MAP      1
  69 #define NOTIFY_ATTR     2
  70 #define NOTIFY_METHOD   3
  71 #define NOTIFY_HOOK     4
  72
  73 typedef struct Notif {
  74    struct Notif      *n_Next;
  75    struct Notif      *n_Prev;
  76    UBYTE              n_Type;
  77    BYTE               n_Pri;
  78    ULONG              n_Flags;
  79    struct TagItem     n_Condition;
  80    Object            *n_Object;
  81 }  NOTIF;
  82
  83 /*
  84  * Structures to track notification
  85  */
  86 typedef struct {
  87    NOTIF              m_Node;
  88    struct TagItem    *m_MapList;
  89 }  MAP;
  90
  91 typedef struct {
  92    NOTIF              a_Node;
  93    struct TagItem     a_Attr;
  94 }  ATTR;
  95
  96 typedef struct {
  97    NOTIF              m_Node;
  98    IPTR               m_Method[1];
  99 }  METHOD;
 100
 101 typedef struct {
 102    NOTIF              h_Node;
 103    struct Hook       *h_Hook;
 104 }  HOOK;
 105
 106
 107 /*
 108  * Object instance data.
 109  */
 110 typedef struct {
 111    struct MinNode     rd_Node;               /* Node for adding to objects.       */
 112    WORD               rd_NodeOffset;         /* Offset of node from object.       */
 113    struct MinList     rd_NotifyList;         /* Notification list.                */
 114    UWORD              rd_LoopCount;          /* To prevent infinite notification. */
 115 }  RD;
 116
 117 /// OM_NEW
 118 /*
 119  * Create a shiny new object.
 120  */
 121 METHOD(RootClassNew, struct opSet *, ops)
 122 {
 123    RD             *rd;
 124    IPTR            rc;
 125
 126    /*
 127     * We let the superclass setup an object
 128     * for us.
 129     */
 130    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)ops)))
 131    {
 132       /*
 133        * Get the instance data.
 134        */
 135       rd = INST_DATA(cl, rc);
 136
 137       rd->rd_NodeOffset = (BYTE *)rc - (BYTE *)rd;
 138
 139       /*
 140        * Initialize the notification lists.
 141        */
 142       NewList((struct List *)&rd->rd_NotifyList);
 143 #ifdef DEBUG_BGUI
 144       TrackNewObject((Object *)rc,ops->ops_AttrList);
 145 #endif
 146    }
 147    return rc;
 148 }
 149 METHOD_END
 150 ///
 151 /// OM_NOTIFY
 152 /*
 153  * We need to update our targets.
 154  */
 155 METHOD(RootClassNotify, struct opUpdate *, opu)
 156 {
 157    RD               *rd = INST_DATA(cl, obj);
 158    NOTIF            *n = (NOTIF *)rd->rd_NotifyList.mlh_Head;
 159    struct TagItem   *clones;
 160    Object           *target;
 161    struct TagItem   *tag;
 162    IPTR             *msg;
 163    IPTR              rc;
 164    BOOL              cond;
 165    int               type;
 166
 167    /*
 168     * Make sure that the ICA_xxx
 169     * attributes will function.
 170     */
 171    rc = AsmDoSuperMethodA(cl, obj, (Msg)opu);
 172
 173    /*
 174     * Broadcast the message to all
 175     * targets mapping the attributes
 176     * when necessary.
 177     */
 178    while (n->n_Next)
 179    {
 180       type   = n->n_Type;
 181       target = n->n_Object;
 182
 183       /*
 184        * Object counter not 0?  Do not update.
 185        */
 186       if (target)
 187       {
 188          /*
 189           * Peng...
 190           */
 191          if (AsmDoMethod(target, RM_SETLOOP))
 192             /*
 193              * Break the loop...we are done.
 194              */
 195             return rc;
 196       };
 197
 198       /*
 199        * Check condition, if we have one.
 200        */
 201       if (n->n_Flags & (RAF_FALSE|RAF_TRUE))
 202       {
 203          cond = FALSE;
 204          /*
 205           * Conditional tag present in
 206           * the notification tags?
 207           */
 208          if ((tag = FindTagItem(n->n_Condition.ti_Tag, opu->opu_AttrList)))
 209          {
 210             cond = (n->n_Condition.ti_Data == tag->ti_Data);
 211             if (n->n_Flags & RAF_FALSE) cond = !cond;
 212          };
 213          if (!cond) type = 0;
 214       };
 215
 216       /*
 217        * Skip interim messages?
 218        */
 219       if (n->n_Flags & RAF_NO_INTERIM)
 220       {
 221          if (opu->opu_Flags & OPUF_INTERIM) type = 0;
 222       };
 223
 224       switch (type)
 225       {
 226       case NOTIFY_MAP:
 227          /*
 228           * When the object has a maplist
 229           * we map the clones.
 230           */
 231          if (((MAP *)n)->m_MapList)
 232          {
 233             /*
 234              * Clone the original attribute list.
 235              */
 236             if ((clones = CloneTagItems(opu->opu_AttrList)))
 237             {
 238                MapTags(clones, ((MAP *)n)->m_MapList, MAP_KEEP_NOT_FOUND);
 239
 240                AsmDoMethod(target, OM_UPDATE, clones, (n->n_Flags & RAF_NO_GINFO) ? NULL : opu->opu_GInfo, opu->opu_Flags);
 241
 242                /*
 243                 * Free the clones.
 244                 */
 245                FreeTagItems(clones);
 246             };
 247          }
 248          else
 249          {
 250             AsmDoMethodA(n->n_Object, (Msg)opu);
 251          };
 252          break;
 253
 254       case NOTIFY_ATTR:
 255          /*
 256           * Set tag.
 257           */
 258          DoSetMethod(target, (n->n_Flags & RAF_NO_GINFO) ? NULL : opu->opu_GInfo,
 259             ((ATTR *)n)->a_Attr.ti_Tag, ((ATTR *)n)->a_Attr.ti_Data, TAG_DONE);
 260          break;
 261
 262       case NOTIFY_METHOD:
 263          msg = ((METHOD *)n)->m_Method;
 264
 265          /*
 266           * Set GadgetInfo?
 267           */
 268          if (!(n->n_Flags & RAF_NO_GINFO))
 269          {
 270             switch (msg[0])
 271             {
 272             case OM_NEW:
 273             case OM_SET:
 274             case OM_UPDATE:
 275             case OM_NOTIFY:
 276                /*
 277                 * These methods get the GadgetInfo in the third long-word.
 278                 */
 279                msg[2] = (IPTR)opu->opu_GInfo;
 280                break;
 281
 282             default:
 283                /*
 284                 * All others in the second long-word.
 285                 */
 286                msg[1] = (IPTR)opu->opu_GInfo;
 287                break;
 288             };
 289          };
 290          AsmDoMethodA(target, (Msg)msg);
 291          break;
 292
 293       case NOTIFY_HOOK:
 294          if (!BGUI_CallHookPkt(((HOOK *)n)->h_Hook, (void *)obj, (void *)opu))
 295             return rc;
 296          break;
 297       };
 298
 299       if (target) AsmDoMethod(target, RM_CLEARLOOP);
 300
 301       n = n->n_Next;
 302    };
 303    return rc;
 304 }
 305 METHOD_END
 306 ///
 307 /// OM_DISPOSE
 308
 309 STATIC VOID FreeNotif(NOTIF *n)
 310 {
 311    switch (n->n_Type)
 312    {
 313    case NOTIFY_MAP:
 314       FreeTagItems(((MAP *)n)->m_MapList);
 315       break;
 316    };
 317    BGUI_FreePoolMem(n);
 318 }
 319
 320 /*
 321  * They do not need us anymore.
 322  */
 323 METHOD(RootClassDispose, Msg, msg)
 324 {
 325    RD          *rd = INST_DATA(cl, obj);
 326    NOTIF       *n;
 327
 328    /*
 329     * Remove all targets and deallocate all resources.
 330     */
 331    while ((n = (NOTIF *)RemHead((struct List *)&rd->rd_NotifyList)))
 332       FreeNotif(n);
 333
 334    /*
 335     * Remove us from any list we may be in.
 336     */
 337    AsmDoMethod(obj, RM_REMOVE);
 338
 339    /*
 340     * Let the superclass dispose of us.
 341     */
 342 #ifdef DEBUG_BGUI
 343    TrackDisposedObject(obj);
 344 #endif
 345    return AsmDoSuperMethodA(cl, obj, msg);
 346 }
 347 METHOD_END
 348 ///
 349 /// OM_UPDATE
 350 /*
 351  * Emulate OM_UPDATE with new methods.
 352  */
 353 METHOD(RootClassUpdateX, struct opUpdate *, opu)
 354 {
 355    ULONG rc = (ULONG)AsmCoerceMethod(cl,obj, RM_SETM, opu->opu_AttrList, (opu->opu_Flags & OPUF_INTERIM) ? RAF_INTERIM|RAF_UPDATE : RAF_UPDATE);
 356
 357    if (opu->opu_GInfo
 358    && !(opu->opu_Flags & OPUF_INTERIM))
 359       AsmDoMethod(obj, RM_REFRESH, opu->opu_GInfo, rc);
 360
 361    return (IPTR)rc;
 362 }
 363 METHOD_END
 364 ///
 365 /// OM_SET
 366 /*
 367  * Emulate OM_SET with new methods.
 368  */
 369 METHOD(RootClassSetX, struct opSet *, ops)
 370 {
 371    ULONG rc = (ULONG)AsmDoMethod(obj, RM_SETM, ops->ops_AttrList, 0);
 372
 373    if (ops->ops_GInfo) AsmDoMethod(obj, RM_REFRESH, ops->ops_GInfo, rc);
 374
 375    return (IPTR)rc;
 376 }
 377 METHOD_END
 378 ///
 379 /// OM_GET
 380 /*
 381  * Emulate OM_GET with new methods.
 382  */
 383 METHOD(RootClassGetX, struct opGet *, opg)
 384 {
 385    return AsmDoMethod(obj, RM_GET, &opg->opg_AttrID, 0);
 386 }
 387 METHOD_END
 388 ///
 389 /// RM_SET
 390 /*
 391  * Emulate RM_SET for any superclass.
 392  */
 393 METHOD(RootClassSet, struct rmAttr *, ra)
 394 {
 395    struct TagItem tags[2];
 396    ULONG          rc;
 397
 398    tags[0].ti_Tag  = ra->ra_Attr->ti_Tag;
 399    tags[0].ti_Data = ra->ra_Attr->ti_Data;
 400    tags[1].ti_Tag  = TAG_DONE;
 401
 402    rc = (ULONG)AsmDoSuperMethod(cl, obj, (ra->ra_Flags & RAF_UPDATE) ? OM_UPDATE : OM_SET, tags, NULL,
 403                                   (ra->ra_Flags & RAF_INTERIM) ? OPUF_INTERIM : 0);
 404
 405    return ((rc > 0) ? /* (RAF_UNDERSTOOD|RAF_REDRAW) */ 0 : 0);
 406 }
 407 METHOD_END
 408 ///
 409 /// RM_GET
 410 /*
 411  * Emulate RM_GET for any superclass.
 412  */
 413 METHOD(RootClassGet, struct rmAttr *, ra)
 414 {
 415    AsmDoSuperMethod(cl, obj, OM_GET, ra->ra_Attr->ti_Tag, ra->ra_Attr->ti_Data);
 416
 417    return 0;
 418 }
 419 METHOD_END
 420 ///
 421 /// RM_SETM
 422
 423 METHOD(RootClassSetM, struct rmAttr *, ra1)
 424 {
 425    struct rmAttr   ra;
 426    struct TagItem *tstate = ra1->ra_Attr;
 427    ULONG           rc = 0;
 428
 429    ra.MethodID   = RM_SET;
 430    ra.ra_Flags   = ra1->ra_Flags;
 431
 432    while ((ra.ra_Attr = BGUI_NextTagItem(&tstate)))
 433       rc |= (ULONG)AsmDoMethodA(obj, (Msg)&ra);
 434
 435    return (IPTR)rc;
 436 }
 437 METHOD_END
 438 ///
 439 /// RM_GETM
 440
 441 METHOD(RootClassGetM, struct rmAttr *, ra1)
 442 {
 443    struct rmAttr   ra;
 444    struct TagItem *tstate = ra1->ra_Attr;
 445    ULONG           rc = 0;
 446
 447    ra.MethodID   = RM_GET;
 448    ra.ra_Flags   = ra1->ra_Flags;
 449
 450    while ((ra.ra_Attr = BGUI_NextTagItem(&tstate)))
 451       rc |= (ULONG)AsmDoMethodA(obj, (Msg)&ra);
 452
 453    return (IPTR)rc;
 454 }
 455 METHOD_END
 456 ///
 457
 458 /// AddNotify
 459
 460 void AddNotify(RD *rd, NOTIF *n, Msg msg, int type)
 461 {
 462    /*
 463     * Set notify object.
 464     */
 465    n->n_Type      = type;
 466    n->n_Pri       = ((struct rmAddAttr *)msg)->raa_Priority;
 467    n->n_Flags     = ((struct rmAddAttr *)msg)->raa_Flags;
 468    n->n_Condition = ((struct rmAddAttr *)msg)->raa_Condition;
 469    n->n_Object    = ((struct rmAddAttr *)msg)->raa_Object;
 470
 471    /*
 472     * Add the target to the list.
 473     */
 474    Enqueue((struct List *)&rd->rd_NotifyList, (struct Node *)n);
 475 }
 476 ///
 477 /// RM_ADDMAP
 478 /*
 479  * Add a map object to the list.
 480  */
 481 METHOD(RootClassAddMap, struct rmAddMap *, ram)
 482 {
 483    RD             *rd = INST_DATA(cl, obj);
 484    MAP            *am = NULL;
 485
 486    /*
 487     * Check if the object is valid.
 488     */
 489    if (ram->ram_Object && (ram->ram_Object != obj))
 490    {
 491       /*
 492        * Allocate and initialize a MAP structure.
 493        */
 494       if ((am = (MAP *)BGUI_AllocPoolMem(sizeof(MAP))))
 495       {
 496          /*
 497           * Check if we need to make a map list.
 498           */
 499          if (ram->ram_MapList)
 500          {
 501             /*
 502              * Clone the maplist.
 503              */
 504             if (!(am->m_MapList = CloneTagItems(ram->ram_MapList)))
 505             {
 506                BGUI_FreePoolMem(am);
 507                return (IPTR)NULL;
 508             };
 509          };
 510
 511          /*
 512           * Add notification.
 513           */
 514          AddNotify(rd, (NOTIF *)am, (Msg)ram, NOTIFY_MAP);
 515       };
 516    }
 517    return (IPTR)am;
 518 }
 519 METHOD_END
 520 ///
 521 /// RM_ADDATTR
 522 /*
 523  * Add an attribute conditional object to the list.
 524  */
 525 METHOD(RootClassAddAttr, struct rmAddAttr *, raa)
 526 {
 527    RD          *rd = INST_DATA(cl, obj);
 528    ATTR        *aa = NULL;
 529
 530    /*
 531     * Check if the object is valid.
 532     */
 533    if (raa->raa_Object && (raa->raa_Object != obj))
 534    {
 535       /*
 536        * Allocate and initialize an ATTR structure.
 537        */
 538       if ((aa = (ATTR *)BGUI_AllocPoolMem(sizeof(ATTR))))
 539       {
 540          /*
 541           * Copy the attribute.
 542           */
 543          aa->a_Attr = raa->raa_Attr;
 544
 545          /*
 546           * Add notification.
 547           */
 548          AddNotify(rd, (NOTIF *)aa, (Msg)raa, NOTIFY_ATTR);
 549       };
 550    }
 551    return (IPTR)aa;
 552 }
 553 METHOD_END
 554 ///
 555 /// RM_ADDMETHOD
 556 /*
 557  * Add a method object to the list.
 558  */
 559 METHOD(RootClassAddMethod, struct rmAddMethod *, ram)
 560 {
 561    RD         *rd = INST_DATA(cl, obj);
 562    METHOD     *am = NULL;
 563
 564    /*
 565     * Check if the object is valid.
 566     */
 567    if (ram->ram_Size && ram->ram_Object && (ram->ram_Object != obj))
 568    {
 569       /*
 570        * Allocate and initialize a METHOD structure.
 571        */
 572       if ((am = (METHOD *)BGUI_AllocPoolMem(sizeof(METHOD) + ram->ram_Size - sizeof(ULONG))))
 573       {
 574          /*
 575           * Copy the method.
 576           */
 577          CopyMem((void *)&ram->ram_MethodID, (void *)am->m_Method, ram->ram_Size);
 578
 579          /*
 580           * Add notification.
 581           */
 582          AddNotify(rd, (NOTIF *)am, (Msg)ram, NOTIFY_METHOD);
 583       };
 584    };
 585    return (IPTR)am;
 586 }
 587 METHOD_END
 588 ///
 589 /// RM_ADDHOOK
 590 /*
 591  * Add a hook to the list.
 592  */
 593 METHOD(RootClassAddHook, struct rmAddHook *, rah)
 594 {
 595    RD          *rd = INST_DATA(cl, obj);
 596    HOOK        *ah = NULL;
 597
 598    /*
 599     * Check if the hook is valid.
 600     */
 601    if (rah->rah_Hook)
 602    {
 603       /*
 604        * Allocate and initialize a HOOK structure.
 605        */
 606       if ((ah = (HOOK *)BGUI_AllocPoolMem(sizeof(HOOK))))
 607       {
 608          /*
 609           * Copy the hook.
 610           */
 611          ah->h_Hook = rah->rah_Hook;
 612
 613          /*
 614           * Add notification.
 615           */
 616          AddNotify(rd, (NOTIF *)ah, (Msg)rah, NOTIFY_HOOK);
 617
 618          ah->h_Node.n_Object = NULL;
 619       };
 620    };
 621    return (IPTR)ah;
 622 }
 623 METHOD_END
 624 ///
 625
 626 /*
 627  * Remove an object from a list.
 628  */
 629 METHOD(NotifyClassRemove, struct bmRemove *, brt)
 630 {
 631 #if 0
 632    RD           *rd = INST_DATA(cl, obj);
 633    NOTIF        *n = (NOTIF *)rd->rd_NotifyList.mlh_Head;
 634    ULONG         type;
 635
 636    switch (brt->MethodID)
 637    {
 638    case BASE_REMMAP:
 639       type = NOTIFY_TARGET;
 640       break;
 641    case BASE_REMCONDITIONAL:
 642       type = NOTIFY_CONDITIONAL;
 643       break;
 644    case BASE_REMMETHOD:
 645       type = NOTIFY_METHOD;
 646       break;
 647    case BASE_REMHOOK:
 648       type = NOTIFY_HOOK;
 649       break;
 650    };
 651
 652    /*
 653     * Find an object in the target list.
 654     */
 655    while (n->n_Next)
 656    {
 657       if ((n->n_Type == type) && ((n->n_Object == brt->bar_Object) || (!n->n_Object)))
 658       {
 659          /*
 660           * Remove it from the list.
 661           */
 662          Remove((struct Node *)n);
 663
 664          /*
 665           * Deallocate the structure.
 666           */
 667          FreeNotif(n);
 668
 669          return 1;
 670       };
 671       n = n->n_Next;
 672    };
 673 #endif
 674
 675    return 0;
 676 }
 677 METHOD_END
 678
 679 /// RM_SETLOOP
 680 /*
 681  * Set infinite loop counter.
 682  */
 683 METHOD(RootClassSetLoop, Msg, msg)
 684 {
 685    RD          *rd = INST_DATA(cl, obj);
 686
 687    if (rd->rd_LoopCount)
 688       return (IPTR)TRUE;
 689
 690    rd->rd_LoopCount++;
 691
 692    return (IPTR)FALSE;
 693 }
 694 METHOD_END
 695 ///
 696 /// RM_CLEARLOOP
 697 /*
 698  * Clear infinite loop counter.
 699  */
 700 METHOD(RootClassClearLoop, Msg, msg)
 701 {
 702    RD          *rd = INST_DATA(cl, obj);
 703
 704    rd->rd_LoopCount--;
 705
 706    return FALSE;
 707 }
 708 METHOD_END
 709 ///
 710
 711 /// RM_REMOVE
 712
 713 METHOD(RootClassRemove, Msg, msg)
 714 {
 715    RD             *rd = INST_DATA(cl, obj);
 716    struct MinNode *mln = &rd->rd_Node;
 717
 718    if (mln->mln_Succ && mln->mln_Pred)
 719    {
 720       Remove((struct Node *)mln);
 721       mln->mln_Succ = mln->mln_Pred = NULL;
 722       return (IPTR)TRUE;
 723    };
 724    return (IPTR)FALSE;
 725 }
 726 METHOD_END
 727 ///
 728 /// RM_ADDHEAD
 729
 730 METHOD(RootClassAddHead, struct rmAdd *, ra)
 731 {
 732    RD           *rd = INST_DATA(cl, obj);
 733
 734    AddHead(ra->ra_List, (struct Node *)&rd->rd_Node);
 735
 736    return (IPTR)TRUE;
 737 }
 738 METHOD_END
 739 ///
 740 /// RM_ADDTAIL
 741
 742 METHOD(RootClassAddTail, struct rmAdd *, ra)
 743 {
 744    RD           *rd = INST_DATA(cl, obj);
 745
 746    AddTail(ra->ra_List, (struct Node *)&rd->rd_Node);
 747
 748    return (IPTR)TRUE;
 749 }
 750 METHOD_END
 751 ///
 752 /// RM_INSERT
 753
 754 METHOD(RootClassInsert, struct rmInsert *, ri)
 755 {
 756    RD           *rd = INST_DATA(cl, obj), *rd2;
 757
 758    if (ri->ri_Previous)
 759    {
 760       rd2 = INST_DATA(cl, ri->ri_Previous);
 761       Insert(ri->ri_List, (struct Node *)&rd->rd_Node, (struct Node *)&rd2->rd_Node);
 762    }
 763    else
 764    {
 765       AddHead(ri->ri_List, (struct Node *)&rd->rd_Node);
 766    };
 767    return (IPTR)TRUE;
 768 }
 769 METHOD_END
 770 ///
 771 /// RM_PREV
 772
 773 METHOD(RootClassPrev, Msg, msg)
 774 {
 775    RD             *rd = INST_DATA(cl, obj);
 776    struct MinNode *mn = rd->rd_Node.mln_Pred;
 777
 778    if (mn && mn->mln_Pred)
 779       return (IPTR)((UBYTE *)mn + rd->rd_NodeOffset);
 780
 781    return (IPTR)NULL;
 782 }
 783 METHOD_END
 784 ///
 785 /// RM_NEXT
 786
 787 METHOD(RootClassNext, Msg, msg)
 788 {
 789    RD             *rd = INST_DATA(cl, obj);
 790    struct MinNode *mn = rd->rd_Node.mln_Succ;
 791
 792    if (mn && mn->mln_Succ)
 793       return (IPTR)((UBYTE *)mn + rd->rd_NodeOffset);
 794
 795    return (IPTR)NULL;
 796 }
 797 METHOD_END
 798 ///
 799
 800 makeproto Object *ListHeadObject(struct List *lh)
 801 {
 802    RD *rd     = (RD *)(lh->lh_Head);
 803
 804    if (rd->rd_Node.mln_Succ) return (Object *)(((UBYTE *)rd) + rd->rd_NodeOffset);
 805    else                      return NULL;
 806 }
 807 makeproto Object *ListTailObject(struct List *lh)
 808 {
 809    RD *rd     = (RD *)(lh->lh_TailPred);
 810
 811    if (rd->rd_Node.mln_Pred) return (Object *)(((UBYTE *)rd) + rd->rd_NodeOffset);
 812    else                      return NULL;
 813 }
 814
 815 /// BASE_ADDMAP
 816
 817 METHOD(BaseClassAddMap, struct bmAddMap *, bam)
 818 {
 819    return (IPTR)(AsmDoMethod(obj, RM_ADDMAP, 0, 0, 0, 0, bam->bam_Object, bam->bam_MapList)!=0);
 820 }
 821 METHOD_END
 822 ///
 823 /// BASE_ADDMETHOD
 824
 825 METHOD(BaseClassAddMethod, struct bmAddMethod *, bam)
 826 {
 827    struct rmAddMethod *ram;
 828
 829    int    size = bam->bam_Size * sizeof(ULONG);
 830    IPTR   nh = 0;
 831
 832    if ((ram = BGUI_AllocPoolMem(sizeof(struct bmAddMethod) + size)))
 833    {
 834       ram->MethodID   = RM_ADDMETHOD;
 835       ram->ram_Object = bam->bam_Object;
 836       ram->ram_Flags  = bam->bam_Flags;
 837       ram->ram_Size   = size;
 838
 839       CopyMem((void *)&bam->bam_MethodID, (void *)&ram->ram_MethodID, size);
 840
 841       nh = AsmDoMethodA(obj, (Msg)ram);
 842
 843       BGUI_FreePoolMem(ram);
 844    };
 845    return nh;
 846 }
 847 METHOD_END
 848 ///
 849 /// BASE_ADDCONDITIONAL
 850
 851 METHOD(BaseClassAddConditional, struct bmAddConditional *, bac)
 852 {
 853    IPTR  nh;
 854
 855    if ((nh = AsmDoMethod(obj, RM_ADDATTR, 0, RAF_FALSE, bac->bac_Condition.ti_Tag, bac->bac_Condition.ti_Data,
 856                              bac->bac_Object,          bac->bac_FALSE.ti_Tag,     bac->bac_FALSE.ti_Data)))
 857    {
 858       if (AsmDoMethod(obj, RM_ADDATTR, 0, RAF_TRUE,  bac->bac_Condition.ti_Tag, bac->bac_Condition.ti_Data,
 859                            bac->bac_Object,          bac->bac_TRUE.ti_Tag,      bac->bac_TRUE.ti_Data))
 860          return (IPTR)TRUE;
 861
 862       AsmDoMethod(obj, RM_REMNOTIFY, 0, nh);
 863    }
 864    return (IPTR)FALSE;
 865 }
 866 METHOD_END
 867 ///
 868 /// BASE_ADDHOOK
 869
 870 METHOD(BaseClassAddHook, struct bmAddHook *, bah)
 871 {
 872    return (IPTR)(AsmDoMethod(obj, RM_ADDHOOK, 0, 0, 0, 0, bah->bah_Hook)!=0);
 873 }
 874 METHOD_END
 875 ///
 876
 877 /// IM_DRAW
 878
 879 METHOD(ImageClassDraw, struct impDraw *, imp)
 880 {
 881    int              x = imp->imp_Offset.X;
 882    int              y = imp->imp_Offset.Y;
 883    IPTR             rc = (IPTR)0;
 884    struct BaseInfo *bi;
 885
 886 #ifdef DEBUG_BGUI
 887    if ((bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_RastPort, imp->imp_RPort, BI_DrawInfo, imp->imp_DrInfo, TAG_DONE)))
 888 #else
 889    if ((bi = AllocBaseInfo(BI_RastPort, imp->imp_RPort, BI_DrawInfo, imp->imp_DrInfo, TAG_DONE)))
 890 #endif
 891    {
 892       if (x) IMAGE(obj)->LeftEdge += x;
 893       if (y) IMAGE(obj)->TopEdge  += y;
 894
 895       rc = AsmDoMethod(obj, BASE_RENDER, bi, imp->imp_State);
 896
 897       if (x) IMAGE(obj)->LeftEdge -= x;
 898       if (y) IMAGE(obj)->TopEdge  -= y;
 899
 900       FreeBaseInfo(bi);
 901    };
 902    return rc;
 903 }
 904 METHOD_END
 905 ///
 906
 907 /// Class initialization.
 908 /*
 909  * Class function array.
 910  */
 911 STATIC DPFUNC ClassFunc[] =
 912 {
 913    { RM_SET,                 RootClassSet },
 914    { RM_GET,                 RootClassGet },
 915    { RM_SETM,                RootClassSetM },
 916    { RM_GETM,                RootClassGetM },
 917    { OM_SET,                 RootClassSetX },
 918    { OM_GET,                 RootClassGetX },
 919    { OM_UPDATE,              RootClassUpdateX },
 920    { OM_NEW,                 RootClassNew },
 921    { OM_DISPOSE,             RootClassDispose },
 922    { OM_NOTIFY,              RootClassNotify },
 923    { RM_SETLOOP,             RootClassSetLoop },
 924    { RM_CLEARLOOP,           RootClassClearLoop },
 925
 926    { RM_REMOVE,              RootClassRemove },
 927    { RM_ADDHEAD,             RootClassAddHead },
 928    { RM_ADDTAIL,             RootClassAddTail },
 929    { RM_INSERT,              RootClassInsert },
 930    { RM_NEXT,                RootClassNext },
 931    { RM_PREV,                RootClassPrev },
 932
 933    { RM_ADDMAP,              RootClassAddMap },
 934    { RM_ADDATTR,             RootClassAddAttr },
 935    { RM_ADDMETHOD,           RootClassAddMethod },
 936    { RM_ADDHOOK,             RootClassAddHook },
 937
 938    { BASE_ADDMAP,            BaseClassAddMap },
 939    { BASE_ADDCONDITIONAL,    BaseClassAddConditional },
 940    { BASE_ADDMETHOD,         BaseClassAddMethod },
 941    { BASE_ADDHOOK,           BaseClassAddHook },
 942    { BASE_REMMAP,            NotifyClassRemove },
 943    { BASE_REMCONDITIONAL,    NotifyClassRemove },
 944    { BASE_REMMETHOD,         NotifyClassRemove },
 945    { BASE_REMHOOK,           NotifyClassRemove },
 946
 947    { IM_DRAW,                ImageClassDraw },
 948
 949    { DF_END }
 950 };
 951
 952 Class *InitRootSubClass(char *superclass)
 953 {
 954    return BGUI_MakeClass(CLASS_SuperClassID, superclass,
 955                          CLASS_ObjectSize,   sizeof(RD),
 956                          CLASS_DFTable,      ClassFunc,
 957                          TAG_DONE);
 958 }
 959
 960 /*
 961  * Simple class initialization.
 962  */
 963 makeproto Class *InitRootClass(void)
 964 {
 965    return InitRootSubClass("rootclass");
 966 }
 967
 968 makeproto Class *InitGadgetClass(void)
 969 {
 970    return InitRootSubClass("gadgetclass");
 971 }
 972
 973 makeproto Class *InitImageClass(void)
 974 {
 975    return InitRootSubClass("imageclass");
 976 }
 977 ///
 978