rom/intuition/gadgetclass.c

   1 /*
   2     Copyright  1995-2005, The AROS Development Team. All rights reserved.
   3     Copyright  2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <exec/types.h>
   8
   9 #include <dos/dos.h>
  10 #include <dos/dosextens.h>
  11
  12 #include <intuition/intuition.h>
  13 #include <intuition/intuitionbase.h>
  14 #include <intuition/classes.h>
  15 #include <intuition/classusr.h>
  16 #include <intuition/gadgetclass.h>
  17 #include <intuition/cghooks.h>
  18 #include <intuition/icclass.h>
  19
  20 #include <graphics/gfxbase.h>
  21 #include <graphics/gfxmacros.h>
  22
  23 #include <utility/tagitem.h>
  24 #include <utility/hooks.h>
  25
  26 #include <clib/macros.h>
  27
  28 #include <string.h>
  29
  30 #include <proto/exec.h>
  31 #include <proto/intuition.h>
  32 #include <proto/graphics.h>
  33 #include <proto/utility.h>
  34
  35 #ifndef __MORPHOS__
  36
  37 struct ICData;
  38 #include "intuition_intern.h"
  39 #include <aros/asmcall.h>
  40 #include <proto/alib.h>
  41 #include "gadgets.h"
  42
  43 #endif /* !__MORPHOS__ */
  44
  45 #define DEBUG_GADGET(x) ;
  46
  47 /****************************************************************************/
  48
  49 #undef IntuitionBase
  50 #define IntuitionBase ((struct IntuitionBase *)cl->cl_UserData)
  51
  52 /* set gadget attributes
  53 */
  54 static ULONG set_gadgetclass(Class *cl, struct ExtGadget *eg, struct opSet *msg)
  55 {
  56     const struct TagItem *tstate = msg->ops_AttrList;
  57     struct TagItem       *tag;
  58     IPTR                  tidata;
  59     ULONG                 retval = 0UL; /* set to non-zero to signal visual changes */
  60
  61     while ( (tag = NextTagItem(&tstate)) )
  62     {
  63         tidata = tag->ti_Data;
  64
  65         switch(tag->ti_Tag)
  66         {
  67             case GA_Left:
  68                 eg->LeftEdge = (WORD)tidata;
  69                 //eg->Flags &= ~GFLG_RELRIGHT;
  70                 retval = 1UL;
  71                 break;
  72
  73             case GA_Top:
  74                 eg->TopEdge = (WORD)tidata;
  75                 //eg->Flags &= ~GFLG_RELBOTTOM;
  76                 retval = 1UL;
  77                 break;
  78
  79             case GA_Width:
  80                 eg->Width = (WORD)tidata;
  81                 eg->Flags &= ~GFLG_RELWIDTH;
  82                 retval = 1UL;
  83                 break;
  84
  85             case GA_Height:
  86                 eg->Height = (WORD)tidata;
  87                 eg->Flags &= ~GFLG_RELHEIGHT;
  88                 retval = 1UL;
  89                 break;
  90
  91             case GA_RelRight:
  92                 eg->LeftEdge = (WORD)tidata;
  93                 eg->Flags |= GFLG_RELRIGHT;
  94                 retval = 1UL;
  95                 break;
  96
  97             case GA_RelBottom:
  98                 eg->TopEdge = (WORD)tidata;
  99                 eg->Flags |= GFLG_RELBOTTOM;
 100                 retval = 1UL;
 101                 break;
 102
 103             case GA_RelWidth:
 104                 eg->Width = (WORD)tidata;
 105                 eg->Flags |= GFLG_RELWIDTH;
 106                 retval = 1UL;
 107                 break;
 108
 109             case GA_RelHeight:
 110                 eg->Height = (WORD)tidata;
 111                 eg->Flags |= GFLG_RELHEIGHT;
 112                 retval = 1UL;
 113                 break;
 114
 115             case GA_RelSpecial:
 116                 if (tidata)
 117                 {
 118                     eg->Flags |= GFLG_RELSPECIAL;
 119                 }
 120                 else
 121                 {
 122                     eg->Flags &= ~GFLG_RELSPECIAL;
 123                 }
 124                 retval = 1UL;
 125                 break;
 126
 127             case GA_Bounds:
 128                 if (tidata)
 129                 {
 130                     eg->BoundsLeftEdge = ((struct IBox *)tidata)->Left;
 131                     eg->BoundsTopEdge  = ((struct IBox *)tidata)->Top;
 132                     eg->BoundsWidth    = ((struct IBox *)tidata)->Width;
 133                     eg->BoundsHeight   = ((struct IBox *)tidata)->Height;
 134                     eg->MoreFlags |= GMORE_BOUNDS;
 135                 }
 136                 retval = 1UL;
 137                 break;
 138
 139             case GA_GadgetHelp:
 140                 if (tidata)
 141                 {
 142                     eg->MoreFlags |= GMORE_GADGETHELP;
 143                 }
 144                 else
 145                 {
 146                     eg->MoreFlags &= ~GMORE_GADGETHELP;
 147                 }
 148                 retval = 1UL;
 149                 break;
 150
 151             case GA_Next:
 152                 eg->NextGadget = (struct ExtGadget *)tidata;
 153                 break;
 154
 155             case GA_Previous:
 156                 if( (tidata != 0L) && (msg->MethodID == OM_NEW) )
 157                 {
 158                     eg->NextGadget = ((struct ExtGadget *)tidata)->NextGadget;
 159                     ((struct ExtGadget *)tidata)->NextGadget = eg;
 160                 }
 161                 break;
 162
 163             case GA_IntuiText:
 164                 eg->GadgetText = (struct IntuiText *)tidata;
 165                 if (tidata)
 166                 {
 167                     eg->Flags &= ~GFLG_LABELMASK;
 168                     eg->Flags |= GFLG_LABELITEXT;
 169                 }
 170                 retval = 1UL;
 171                 break;
 172
 173             case GA_Text:
 174                 eg->GadgetText = (struct IntuiText *)tidata;
 175                 if (tidata)
 176                 {
 177                     eg->Flags &= ~GFLG_LABELMASK;
 178                     eg->Flags |= GFLG_LABELSTRING;
 179                 }
 180                 retval = 1UL;
 181                 break;
 182
 183             case GA_LabelImage:
 184                 eg->GadgetText = (struct IntuiText *)tidata;
 185                 if (tidata)
 186                 {
 187                     eg->Flags &= ~GFLG_LABELMASK;
 188                     eg->Flags |= GFLG_LABELIMAGE;
 189                 }
 190                 retval = 1UL;
 191                 break;
 192
 193             case GA_Image:
 194                 eg->GadgetRender = (APTR)tidata;
 195                 if (tidata)
 196                 {
 197                     eg->Flags |= GFLG_GADGIMAGE;
 198                 }
 199                 retval = 1UL;
 200                 break;
 201
 202             case GA_Border:
 203                 eg->GadgetRender = (APTR)tidata;
 204                 if (tidata)
 205                 {
 206                     eg->Flags &= ~GFLG_GADGIMAGE;
 207                 }
 208                 retval = 1UL;
 209                 break;
 210
 211             case GA_SelectRender:
 212                 eg->SelectRender = (APTR)tidata;
 213                 {
 214                     eg->Flags |= (GFLG_GADGIMAGE & GFLG_GADGHIMAGE);
 215                 }
 216                 retval = 1UL;
 217                 break;
 218
 219             case GA_SpecialInfo:
 220                 eg->SpecialInfo = (APTR)tidata;
 221                 break;
 222
 223             case GA_GZZGadget:
 224                 if ( tidata != FALSE )
 225                 {
 226                     eg->GadgetType |= GTYP_GZZGADGET;
 227                 }
 228                 else
 229                 {
 230                     eg->GadgetType &= ~GTYP_GZZGADGET;
 231                 }
 232                 break;
 233
 234             case GA_SysGadget:
 235                 if ( tidata != FALSE )
 236                 {
 237                     eg->GadgetType |= GTYP_SYSGADGET;
 238                 }
 239                 else
 240                 {
 241                     eg->GadgetType &= ~GTYP_SYSGADGET;
 242                 }
 243                 break;
 244
 245             case GA_Selected:
 246                 if ( tidata != FALSE )
 247                 {
 248                     eg->Flags |= GFLG_SELECTED;
 249                 }
 250                 else
 251                 {
 252                     eg->Flags &= ~GFLG_SELECTED;
 253                 }
 254                 retval = 1UL;
 255                 break;
 256
 257             case GA_Disabled:
 258                 if ( tidata != FALSE )
 259                 {
 260                     eg->Flags |= GFLG_DISABLED;
 261                 }
 262                 else
 263                 {
 264                     eg->Flags &= ~GFLG_DISABLED;
 265                 }
 266                 retval = 1UL;
 267                 break;
 268
 269             case GA_EndGadget:
 270                 if ( tidata != FALSE )
 271                 {
 272                     eg->Activation |= GACT_ENDGADGET;
 273                 }
 274                 else
 275                 {
 276                     eg->Activation &= ~GACT_ENDGADGET;
 277                 }
 278                 break;
 279
 280             case GA_Immediate:
 281                 if ( tidata != FALSE )
 282                 {
 283                     eg->Activation |= GACT_IMMEDIATE;
 284                 }
 285                 else
 286                 {
 287                     eg->Activation &= ~GACT_IMMEDIATE;
 288                 }
 289                 break;
 290
 291             case GA_RelVerify:
 292                 if ( tidata != FALSE )
 293                 {
 294                     eg->Activation |= GACT_RELVERIFY;
 295                 }
 296                 else
 297                 {
 298                     eg->Activation &= ~GACT_RELVERIFY;
 299                 }
 300                 break;
 301
 302             case GA_FollowMouse:
 303                 if ( tidata != FALSE )
 304                 {
 305                     eg->Activation |= GACT_FOLLOWMOUSE;
 306                 }
 307                 else
 308                 {
 309                     eg->Activation &= ~GACT_FOLLOWMOUSE;
 310                 }
 311                 break;
 312
 313             case GA_RightBorder:
 314                 if ( tidata != FALSE )
 315                 {
 316                     eg->Activation |= GACT_RIGHTBORDER;
 317                 }
 318                 else
 319                 {
 320                     eg->Activation &= ~GACT_RIGHTBORDER;
 321                 }
 322                 break;
 323
 324             case GA_LeftBorder:
 325                 if ( tidata != FALSE )
 326                 {
 327                     eg->Activation |= GACT_LEFTBORDER;
 328                 }
 329                 else
 330                 {
 331                     eg->Activation &= ~GACT_LEFTBORDER;
 332                 }
 333                 break;
 334
 335             case GA_TopBorder:
 336                 if ( tidata != FALSE )
 337                 {
 338                     eg->Activation |= GACT_TOPBORDER;
 339                 }
 340                 else
 341                 {
 342                     eg->Activation &= ~GACT_TOPBORDER;
 343                 }
 344                 break;
 345
 346             case GA_BottomBorder:
 347                 if ( tidata != FALSE )
 348                 {
 349                     eg->Activation |= GACT_BOTTOMBORDER;
 350                 }
 351                 else
 352                 {
 353                     eg->Activation &= ~GACT_BOTTOMBORDER;
 354                 }
 355                 break;
 356
 357             case GA_ToggleSelect:
 358                 if (tidata)
 359                 {
 360                     eg->Activation |= GACT_TOGGLESELECT;
 361                 }
 362                 else
 363                 {
 364                     eg->Activation &= ~GACT_TOGGLESELECT;
 365                 }
 366                 break;
 367
 368             case GA_TabCycle:
 369                 if (tidata)
 370                 {
 371                     eg->Flags |= GFLG_TABCYCLE;
 372                 }
 373                 else
 374                 {
 375                     eg->Flags &= ~GFLG_TABCYCLE;
 376                 }
 377                 break;
 378
 379             case GA_Highlight:
 380                 eg->Flags &= ~GFLG_GADGHIGHBITS;
 381                 eg->Flags |= tidata & GFLG_GADGHIGHBITS;
 382                 break;
 383
 384             case GA_SysGType:
 385                 eg->GadgetType &= ~GTYP_SYSTYPEMASK;
 386                 eg->GadgetType |= tidata & GTYP_SYSTYPEMASK;
 387                 break;
 388
 389             case GA_ID:
 390                 /* GA_ID should NOT be set if this is a OM_UPDATE.
 391                 ** This is because gadgets should send their GA_ID
 392                 ** when doing a OM_NOTIFY, so that the receiver
 393                 ** might see who sent the message.
 394                 ** But we surely don't want to change the GA_ID
 395                 ** of the reciver to that of the sender.
 396                 */
 397                 if (msg->MethodID != OM_UPDATE)
 398                 {
 399                     eg->GadgetID = tidata;
 400                 }
 401                 break;
 402
 403             case GA_UserData:
 404                 eg->UserData = (APTR)tidata;
 405                 DEBUG_GADGET(dprintf("set_gadgetclass: UserData 0x%lx\n",tidata));
 406                 break;
 407
 408             case ICA_TARGET:
 409                 ((struct GadgetData *)eg)->IC.ic_Target = (Object *)tidata;
 410                 break;
 411
 412             case ICA_MAP:
 413                 ((struct GadgetData *)eg)->IC.ic_Mapping = (struct TagItem *)tidata;
 414                 break;
 415
 416         } /* switch tag */
 417
 418     } /* while NextTagItem */
 419
 420 #if 0
 421     /* This seems to be wrong here. Instead buttongclass is where
 422        something like this happens, so look there (stegerg) */
 423
 424     if ((msg->MethodID == OM_NEW) &&
 425             (eg->Flags & GFLG_GADGIMAGE) &&
 426             (eg->GadgetRender != NULL))
 427     {
 428         if (eg->Width  == 0) eg->Width  = ((struct Image *)eg->GadgetRender)->Width;
 429         if (eg->Height == 0) eg->Height = ((struct Image *)eg->GadgetRender)->Height;
 430     }
 431 #endif
 432
 433     return retval;
 434 }
 435
 436
 437 IPTR GadgetClass__OM_NEW(Class *cl, Object *o, struct opSet *msg)
 438 {
 439     struct ExtGadget *eg = (struct ExtGadget *)DoSuperMethodA(cl, o, (Msg)msg);
 440
 441     if (eg)
 442     {
 443         /* set some defaults */
 444         /*
 445          * The instance object is cleared memory!
 446          * memset (eg, 0, sizeof(struct GadgetData));
 447          */
 448         eg->Flags         = GFLG_EXTENDED;
 449         eg->GadgetType    = GTYP_CUSTOMGADGET;
 450     eg->MoreFlags     = GMORE_BOOPSIGADGET;
 451         eg->MutualExclude = (LONG)&((Class *)o)->cl_Dispatcher;
 452
 453         /* Handle our special tags - overrides defaults */
 454         set_gadgetclass(cl, eg, msg);
 455     }
 456
 457     return (IPTR)eg;
 458 }
 459
 460 IPTR GadgetClass__OM_SET(Class *cl, struct ExtGadget *eg, struct opSet *msg)
 461 {
 462     return DoSuperMethodA(cl, (Object *)eg, (Msg)msg) + set_gadgetclass(cl, eg, (struct opSet *)msg);
 463 }
 464
 465 IPTR GadgetClass__OM_NOTIFY(Class *cl, struct GadgetData *gd, struct opUpdate *msg)
 466 {
 467     DEBUG_GADGET(dprintf("dispatch_gadgetclass: OM_NOTIFY\n"));
 468     DoNotify(cl, (Object *)gd, &(gd->IC), msg);
 469     DEBUG_GADGET(dprintf("dispatch_gadgetclass: OM_NOTIFY done\n"));
 470
 471     return (IPTR)0;
 472 }
 473
 474 IPTR GadgetClass__OM_DISPOSE(Class *cl, struct GadgetData *gd, Msg msg)
 475 {
 476     FreeICData((struct ICData *)&gd->IC);
 477     return DoSuperMethodA(cl, (Object *)gd, (Msg)msg);
 478 }
 479
 480 /* get gadget attributes - gadgetclass really has no gettable
 481  * attributes, but we will implement some useful ones anyway. ;0
 482  */
 483 IPTR GadgetClass__OM_GET(Class *cl, struct ExtGadget *eg, struct opGet *msg)
 484 {
 485     ULONG retval = 1UL;
 486
 487     switch (msg->opg_AttrID)
 488     {
 489         case GA_Left:
 490         case GA_RelRight:
 491             *msg->opg_Storage = (IPTR) eg->LeftEdge;
 492             break;
 493
 494         case GA_Top:
 495         case GA_RelBottom:
 496             *msg->opg_Storage = (IPTR) eg->TopEdge;
 497             break;
 498
 499         case GA_Width:
 500         case GA_RelWidth:
 501             *msg->opg_Storage = (IPTR) eg->Width;
 502             break;
 503
 504         case GA_Height:
 505         case GA_RelHeight:
 506             *msg->opg_Storage = (IPTR) eg->Height;
 507             break;
 508
 509         case GA_Selected:
 510             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_SELECTED) != 0);
 511             break;
 512
 513         case GA_Disabled:
 514             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_DISABLED) != 0);
 515             break;
 516
 517         case GA_ID:
 518             *msg->opg_Storage = (IPTR)eg->GadgetID;
 519             break;
 520
 521         case GA_UserData:
 522             *msg->opg_Storage = (IPTR)eg->UserData;
 523             break;
 524
 525         case GA_RelSpecial:
 526             *msg->opg_Storage = (IPTR)(eg->Flags & GFLG_RELSPECIAL) ? TRUE : FALSE;
 527             break;
 528
 529         case GA_GadgetHelp:
 530             *msg->opg_Storage = (IPTR)(eg->MoreFlags & GMORE_GADGETHELP) ? TRUE : FALSE;
 531             break;
 532
 533         case GA_Next:
 534             *msg->opg_Storage = (IPTR)eg->NextGadget;
 535             break;
 536
 537         case GA_IntuiText:
 538             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_LABELITEXT) ? eg->GadgetText : 0);
 539             break;
 540
 541         case GA_Text:
 542             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_LABELSTRING) ? eg->GadgetText : 0);
 543             break;
 544
 545         case GA_LabelImage:
 546             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_LABELIMAGE) ? eg->GadgetText : 0);
 547             break;
 548
 549         case GA_Image:
 550             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_GADGIMAGE) ? eg->GadgetRender : 0);
 551             break;
 552
 553         case GA_Border:
 554             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_GADGIMAGE) ? 0 : eg->GadgetRender);
 555             break;
 556
 557         case GA_SelectRender:
 558             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_GADGHIMAGE) ? eg->SelectRender : 0);
 559             break;
 560
 561         case GA_SpecialInfo:
 562             *msg->opg_Storage = (IPTR)eg->SpecialInfo;
 563             break;
 564
 565         case GA_GZZGadget:
 566             *msg->opg_Storage = (IPTR)((eg->GadgetType & GTYP_GZZGADGET) ? TRUE : FALSE);
 567             break;
 568
 569         case GA_SysGadget:
 570             *msg->opg_Storage = (IPTR)((eg->GadgetType & GTYP_SYSGADGET) ? TRUE : FALSE);
 571             break;
 572
 573         case GA_EndGadget:
 574             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_ENDGADGET) ? TRUE : FALSE);
 575             break;
 576
 577         case GA_Immediate:
 578             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_IMMEDIATE) ? TRUE : FALSE);
 579             break;
 580
 581         case GA_RelVerify:
 582             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_RELVERIFY) ? TRUE : FALSE);
 583             break;
 584
 585         case GA_FollowMouse:
 586             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_FOLLOWMOUSE) ? TRUE : FALSE);
 587             break;
 588
 589         case GA_RightBorder:
 590             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_RIGHTBORDER) ? TRUE : FALSE);
 591             break;
 592
 593         case GA_LeftBorder:
 594             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_LEFTBORDER) ? TRUE : FALSE);
 595             break;
 596
 597         case GA_TopBorder:
 598             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_TOPBORDER) ? TRUE : FALSE);
 599             break;
 600
 601         case GA_BottomBorder:
 602             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_BOTTOMBORDER) ? TRUE : FALSE);
 603             break;
 604
 605         case GA_ToggleSelect:
 606             *msg->opg_Storage = (IPTR)((eg->Activation & GACT_TOGGLESELECT) ? TRUE : FALSE);
 607             break;
 608
 609         case GA_TabCycle:
 610             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_TABCYCLE) ? TRUE : FALSE);
 611             break;
 612
 613         case GA_Highlight:
 614             *msg->opg_Storage = (IPTR)((eg->Flags & GFLG_GADGHIGHBITS) ? TRUE : FALSE);
 615             break;
 616
 617         case GA_SysGType:
 618             *msg->opg_Storage = (IPTR)(eg->GadgetType & GTYP_SYSTYPEMASK);
 619             break;
 620
 621         case ICA_TARGET:
 622             *msg->opg_Storage = (IPTR)((struct GadgetData *)eg)->IC.ic_Target;
 623             break;
 624
 625         case ICA_MAP:
 626             *msg->opg_Storage = (IPTR)((struct GadgetData *)eg)->IC.ic_Mapping;
 627             break;
 628
 629         case GA_Bounds:
 630             if (msg->opg_Storage)
 631             {
 632                 struct IBox *ibox = (struct IBox *)msg->opg_Storage;
 633
 634                 ibox->Left = eg->BoundsLeftEdge;
 635                 ibox->Top = eg->BoundsTopEdge;
 636                 ibox->Width = eg->BoundsWidth;
 637                 ibox->Height = eg->BoundsHeight;
 638             }
 639             break;
 640
 641
 642         default:
 643         #if 0
 644             /* DONT DO THIS!! For example BGUI propclass relies on this not happening!! */
 645
 646             *msg->opg_Storage = (IPTR)NULL;
 647             */
 648         #endif
 649             retval = 0UL;
 650             break;
 651
 652     } /* switch attrid) */
 653
 654     return(retval);
 655 }
 656
 657 /* test if we should try to activate this gadget...
 658  */
 659 IPTR GadgetClass__GM_HITTEST(Class *cl, Object *o, struct gpHitTest *gpht)
 660 {
 661     return (IPTR)GMR_GADGETHIT;
 662 }
 663
 664 /* Methods follows that only need to return a value because they should be handled by
 665  * the subclasses
 666  */
 667 IPTR GadgetClass__One(Class *cl, Object *o, Msg msg)
 668 {
 669      return (IPTR)1;
 670 }
 671
 672 IPTR GadgetClass__Zero(Class *cl, Object *o, Msg msg)
 673 {
 674     return (IPTR)0;
 675 }
 676
 677 IPTR GadgetClass_NoReuse(Class *cl, Object *o, Msg msg)
 678 {
 679     return (IPTR)GMR_NOREUSE;
 680 }
 681
 682 IPTR GadgetClass__GM_HELPTEST(Class *cl, Object *o, Msg msg)
 683 {
 684     DEBUG_GADGET(dprintf("dispatch_gadgetclass: GM_HELPTEST\n"));
 685     return (IPTR)GMR_HELPHIT;
 686 }
 687
 688 IPTR GadgetClass__ICM_SETLOOP(Class *cl, struct GadgetData *gd, Msg msg)
 689 {
 690     DEBUG_GADGET(dprintf("dispatch_gadgetclass: ICM_SETLOOP\n"));
 691     gd->IC.ic_LoopCounter += 1UL;
 692
 693     return (IPTR)0;
 694 }
 695
 696 IPTR GadgetClass__ICM_CLEARLOOP(Class *cl, struct GadgetData *gd, Msg msg)
 697 {
 698     DEBUG_GADGET(dprintf("dispatch_gadgetclass: ICM_CLEARLOOP\n"));
 699     gd->IC.ic_LoopCounter -= 1UL;
 700
 701     return (IPTR)0;
 702 }
 703
 704 IPTR GadgetClass__ICM_CHECKLOOP(Class *cl, struct GadgetData *gd, Msg msg)
 705 {
 706     DEBUG_GADGET(dprintf("dispatch_gadgetclass: ICM_CHECKLOOP\n"));
 707     return (IPTR)gd->IC.ic_LoopCounter;
 708 }