bgui/buttonclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * buttonclass.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.3  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.2  2000/05/15 19:27:00  stegerg
  18  * another hundreds of REG() macro replacements in func headers/protos.
  19  *
  20  * Revision 42.1  2000/05/14 23:32:46  stegerg
  21  * changed over 200 function headers which all use register
  22  * parameters (oh boy ...), because the simple REG() macro
  23  * doesn't work with AROS. And there are still hundreds
  24  * of headers left to be fixed :(
  25  *
  26  * Many of these functions would also work with stack
  27  * params, but since i have fixed every single one
  28  * I encountered up to now, I guess will have to do
  29  * the same for the rest.
  30  *
  31  * Revision 42.0  2000/05/09 22:08:32  mlemos
  32  * Bumped to revision 42.0 before handing BGUI to AROS team
  33  *
  34  * Revision 41.11  2000/05/09 19:53:59  mlemos
  35  * Merged with the branch Manuel_Lemos_fixes.
  36  *
  37  * Revision 41.10.2.3  1999/07/31 01:54:49  mlemos
  38  * Ensured that the base object frame is restored before the object is
  39  * disposed if the frame object was overwritte by the button class.
  40  *
  41  * Revision 41.10.2.2  1998/12/06 23:01:41  mlemos
  42  * Fixed bug of select only buttons being deselected by keyboard activation.
  43  *
  44  * Revision 41.10.2.1  1998/11/17 16:05:36  mlemos
  45  * Fixed the return value of BASE_RENDER to always reflect image changes.
  46  *
  47  * Revision 41.10  1998/02/25 21:11:42  mlemos
  48  * Bumping to 41.10
  49  *
  50  * Revision 1.1  1998/02/25 17:07:43  mlemos
  51  * Ian sources
  52  *
  53  *
  54  */
  55
  56 /// Class definitions.
  57 #include "include/classdefs.h"
  58
  59 /*
  60  * Object instance data.
  61  */
  62 typedef struct {
  63    ULONG              bd_Flags;        /* See below.                    */
  64    struct Image      *bd_Image;        /* Intuition image.              */
  65    struct Image      *bd_SelImage;     /* Selected intuition image.     */
  66    Object            *bd_Vector;       /* Vector image.                 */
  67    Object            *bd_SelVector;    /* Selected vector image.        */
  68    Object            *bd_StoreFrame;   /* Storage for frame object.     */
  69    UWORD              bd_ScaleWidth;   /* Design width of the vector.   */
  70    UWORD              bd_ScaleHeight;  /* Design height of the vector.  */
  71 }  BD;
  72
  73 #define BDF_NO_DESELECT    (1<<0)      /* Don't deselect when selected. */
  74 #define BDF_ENCLOSE        (1<<1)      /* Enclose image in frame.       */
  75 #define BDF_SYSIMAGE       (1<<2)      /* This is a system image.       */
  76 #define BDF_STORED_FRAME   (1<<3)      /* Stored base instance frame.   */
  77 ///
  78 /// ButtonSetAttrs
  79 /*
  80  * Change the object's attributes.
  81  */
  82 STATIC ASM IPTR ButtonSetAttrs(REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct opSet *ops)
  83 {
  84    BD              *bd = INST_DATA(cl, obj);
  85    BC              *bc = BASE_DATA(obj);
  86    IPTR             data;
  87    Tag              attr;
  88    struct TagItem  *tstate = ops->ops_AttrList;
  89    struct TagItem  *tag;
  90    BOOL             vis = FALSE;
  91
  92    /*
  93     * Evaluate tags.
  94     */
  95    while ((tag = NextTagItem(&tstate)))
  96    {
  97       data = tag->ti_Data;
  98       switch (attr = tag->ti_Tag)
  99       {
 100       case VIT_VectorArray:
 101       case VIT_BuiltIn:
 102       case VIT_Pen:
 103       case VIT_DriPen:
 104          if (bd->bd_Vector)
 105          {
 106             DoSetMethodNG(bd->bd_Vector, attr, data, TAG_DONE);
 107             vis = TRUE;
 108          };
 109          break;
 110
 111       case SYSIA_Which:
 112          if (bd->bd_Flags & BDF_SYSIMAGE)
 113          {
 114             DoSetMethodNG((Object *)bd->bd_Image, SYSIA_Which, data, TAG_DONE);
 115             break;
 116          };
 117          bd->bd_Image      = (struct Image *)BGUI_NewObject(BGUI_SYSTEM_IMAGE, SYSIA_Which, data, TAG_DONE);
 118          bd->bd_StoreFrame = bc->bc_Frame;
 119          bd->bd_Flags     |= BDF_STORED_FRAME;
 120          bc->bc_Frame      = NULL;
 121          bd->bd_SelImage   = NULL;
 122          bd->bd_Flags     |= BDF_SYSIMAGE;
 123          vis = TRUE;
 124          break;
 125
 126       case BUTTON_Image:
 127       case BUTTON_SelectedImage:
 128          if (bd->bd_Flags & BDF_SYSIMAGE)
 129          {
 130             bc->bc_Frame      = bd->bd_StoreFrame;
 131             bd->bd_StoreFrame = NULL;
 132             bd->bd_Flags &= ~BDF_STORED_FRAME;
 133             if (bd->bd_Image) DisposeObject(bd->bd_Image);
 134             bd->bd_Flags &= ~BDF_SYSIMAGE;
 135          };
 136          if (attr == BUTTON_Image)
 137          {
 138             bd->bd_Image = (struct Image *)data;
 139             vis = TRUE;
 140          }
 141          else
 142          {
 143             bd->bd_SelImage = (struct Image *)data;
 144             vis = TRUE;
 145          };
 146          break;
 147
 148       case BUTTON_Vector:
 149          if (bd->bd_Vector) DisposeObject(bd->bd_Vector);
 150          bd->bd_Vector = (Object *)data;
 151          vis = TRUE;
 152          break;
 153
 154       case BUTTON_SelectedVector:
 155          if (bd->bd_SelVector) DisposeObject(bd->bd_SelVector);
 156          bd->bd_SelVector = (Object *)data;
 157          vis = TRUE;
 158          break;
 159
 160       case BUTTON_ScaleMinWidth:
 161          bd->bd_ScaleWidth = data;
 162          break;
 163
 164       case BUTTON_ScaleMinHeight:
 165          bd->bd_ScaleHeight = data;
 166          break;
 167
 168       case BUTTON_SelectOnly:
 169          if (data) bd->bd_Flags |= BDF_NO_DESELECT;
 170          else      bd->bd_Flags &= ~BDF_NO_DESELECT;
 171          break;
 172
 173       case BUTTON_EncloseImage:
 174          if (data) bd->bd_Flags |= BDF_ENCLOSE;
 175          else      bd->bd_Flags &= ~BDF_ENCLOSE;
 176          break;
 177       };
 178    };
 179
 180    /*
 181     * Force the correct activation flags.
 182     */
 183    if (GADGET(obj)->Activation & GACT_TOGGLESELECT)
 184    {
 185       GADGET(obj)->Activation |= GACT_IMMEDIATE;
 186       GADGET(obj)->Activation &= ~GACT_RELVERIFY;
 187    }
 188    else
 189    {
 190       GADGET(obj)->Activation &= ~GACT_IMMEDIATE;
 191       GADGET(obj)->Activation |= GACT_RELVERIFY;
 192    }
 193    return vis;
 194 }
 195
 196 ///
 197 /// OM_NEW
 198 /*
 199  * Create a new object.
 200  */
 201 METHOD(ButtonClassNew, struct opSet *, ops)
 202 {
 203    BD               *bd;
 204    struct TagItem   *tags;
 205    IPTR              rc;
 206    struct opSet      opn = *ops;
 207
 208    tags = DefTagList(BGUI_BUTTON_GADGET, ops->ops_AttrList);
 209
 210    /*
 211     * First we let the superclass
 212     * create an object.
 213     */
 214    if ((rc = NewSuperObject(cl, obj, tags)))
 215    {
 216       /*
 217        * Get the instance data.
 218        */
 219       bd = INST_DATA(cl, rc);
 220
 221       opn.ops_AttrList = tags;
 222       ButtonSetAttrs(cl, (Object *)rc, &opn);
 223
 224       /*
 225        * See if we get a vector image.
 226        */
 227       if (!bd->bd_Image && !bd->bd_Vector)
 228          bd->bd_Vector = CreateVector(tags);
 229    };
 230    FreeTagItems(tags);
 231
 232    return rc;
 233 }
 234 METHOD_END
 235 ///
 236 /// OM_SET, OM_UPDATE
 237 /*
 238  * Change the object's attributes.
 239  */
 240 METHOD(ButtonClassSetUpdate, struct opUpdate *, opu)
 241 {
 242    BD              *bd = INST_DATA(cl, obj);
 243    WORD             dis = GADGET(obj)->Flags & GFLG_DISABLED;
 244    WORD             sel = GADGET(obj)->Flags & GFLG_SELECTED;
 245    BOOL             vis;
 246
 247    /*
 248     * First we let the superclass do it's thing.
 249     */
 250    AsmDoSuperMethodA(cl, obj, (Msg)opu);
 251
 252    /*
 253     * F*ck interim messages.
 254     */
 255    if (opu->MethodID == OM_UPDATE && (opu->opu_Flags & OPUF_INTERIM))
 256       return 1;
 257
 258    vis = ButtonSetAttrs(cl, obj, (struct opSet *)opu);
 259
 260    /*
 261     * Visual change necessary?
 262     */
 263    if (((GADGET(obj)->Flags & GFLG_DISABLED) != dis) ||
 264        ((GADGET(obj)->Flags & GFLG_SELECTED) != sel) || vis)
 265    {
 266       DoRenderMethod(obj, opu->opu_GInfo, GREDRAW_REDRAW);
 267    }
 268
 269    /*
 270     * Notify target when a toggle gadget's selected state changed.
 271     */
 272    if (GADGET(obj)->Activation & GACT_TOGGLESELECT)
 273    {
 274       if ((GADGET(obj)->Flags & GFLG_SELECTED) != sel)
 275       {
 276          /*
 277           * Special MX magic...
 278           */
 279          if (!(sel && (bd->bd_Flags & BDF_NO_DESELECT)))
 280          {
 281             DoNotifyMethod(obj, opu->opu_GInfo, 0, GA_ID,       GADGET(obj)->GadgetID,
 282                                 GA_Selected, !sel, GA_UserData, GADGET(obj)->UserData, TAG_END);
 283          };
 284       };
 285    };
 286
 287    return 1;
 288 }
 289 METHOD_END
 290 ///
 291 /// BASE_RENDER
 292 /*
 293  * Render the object.
 294  */
 295 METHOD(ButtonClassRender, struct bmRender *, bmr)
 296 {
 297    BD                *bd = INST_DATA(cl, obj);
 298    BC                *bc = BASE_DATA(obj);
 299    struct BaseInfo   *bi = bmr->bmr_BInfo;
 300    struct Image      *image = NULL;
 301    Object            *vector = NULL;
 302    int                x, y;
 303    ULONG              rc;
 304    ULONG              state = GadgetState(bi, obj, FALSE);
 305
 306    /*
 307     * Render the baseclass.
 308     */
 309    rc=AsmDoSuperMethodA(cl, obj, (Msg)bmr);
 310
 311    /*
 312     * Pick up the image to render.
 313     */
 314    if (GADGET(obj)->Flags & GFLG_SELECTED)
 315    {
 316       image  = bd->bd_SelImage;
 317       vector = bd->bd_SelVector;
 318    };
 319    if (!image)  image  = bd->bd_Image;
 320    if (!vector) vector = bd->bd_Vector;
 321
 322    /*
 323     * Setup and render the gadget.
 324     */
 325    if (image)
 326    {
 327       if (bd->bd_Flags & BDF_SYSIMAGE)
 328       {
 329          /*
 330           * Setup the image dimensions.
 331           */
 332          image->LeftEdge = bc->bc_OuterBox.Left;
 333          image->TopEdge  = bc->bc_OuterBox.Top;
 334          image->Width    = bc->bc_OuterBox.Width;
 335          image->Height   = bc->bc_OuterBox.Height;
 336
 337          x = y = 0;
 338       }
 339       else
 340       {
 341          /*
 342           * Setup the left and top edge.
 343           */
 344          image->LeftEdge = bc->bc_InnerBox.Left;
 345          image->TopEdge  = bc->bc_InnerBox.Top;
 346
 347          /*
 348           * Center it in the hitbox.
 349           */
 350          x = (bc->bc_InnerBox.Width  - image->Width ) >> 1;
 351          y = (bc->bc_InnerBox.Height - image->Height) >> 1;
 352       };
 353       /*
 354        * Render it.
 355        */
 356       BDrawImageState(bi, (Object *)image, x, y, state);
 357
 358       rc = 1;
 359    }
 360    else if (vector)
 361    {
 362       /*
 363        * Setup vector bounds.
 364        */
 365       DoSetMethodNG(vector,
 366          IA_Left,    bc->bc_InnerBox.Left  - 1,  IA_Top,     bc->bc_InnerBox.Top    - 1,
 367          IA_Width,   bc->bc_InnerBox.Width + 2,  IA_Height,  bc->bc_InnerBox.Height + 2,
 368          TAG_END);
 369
 370       /*
 371        * Render it.
 372        */
 373       rc = AsmDoMethod(vector, BASE_RENDER, bi, state);
 374    };
 375
 376    /*
 377     * Disabled?
 378     */
 379    if (GADGET(obj)->Flags & GFLG_DISABLED)
 380       BDisableBox(bi, &bc->bc_HitBox);
 381
 382    return rc;
 383 }
 384 METHOD_END
 385 ///
 386 /// GM_GOACTIVE
 387 /*
 388  * We must go active.
 389  */
 390 STATIC METHOD(ButtonClassGoActive, struct gpInput *, gpi)
 391 {
 392    BD                   *bd = INST_DATA(cl, obj);
 393    ULONG                 rc;
 394    struct GadgetInfo    *gi = gpi->gpi_GInfo;
 395
 396    /*
 397     * We cannot go active when
 398     * we are disabled.
 399     */
 400    if (GADGET(obj)->Flags & GFLG_DISABLED)
 401       return GMR_NOREUSE;
 402
 403    /*
 404     * We must be triggered by a mouse click
 405     * or something simular.
 406     */
 407    if (gpi->gpi_IEvent)
 408    {
 409       /*
 410        * Let the superclass have a go...
 411        */
 412       AsmDoSuperMethodA(cl, obj, (Msg)gpi);
 413
 414       /*
 415        * Toggle gadget?
 416        */
 417       if (GADGET(obj)->Activation & GACT_TOGGLESELECT)
 418       {
 419          /*
 420           * Special MX magic...
 421           */
 422          if ((bd->bd_Flags & BDF_NO_DESELECT) && (GADGET( obj )->Flags & GFLG_SELECTED))
 423             return GMR_NOREUSE;
 424
 425          /*
 426           * Toggle selected bit.
 427           */
 428          GADGET(obj)->Flags ^= GFLG_SELECTED;
 429
 430          /*
 431           * Redraw and notify.
 432           */
 433          DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 434          DoNotifyMethod(obj, gi, 0, GA_ID,       GADGET(obj)->GadgetID,
 435                                     GA_Selected, GADGET(obj)->Flags & GFLG_SELECTED,
 436                                     GA_UserData, GADGET(obj)->UserData, TAG_DONE);
 437
 438          rc = GMR_NOREUSE | GMR_VERIFY;
 439       }
 440       else
 441       {
 442          /*
 443           * Normal buttons require input.
 444           */
 445          GADGET(obj)->Flags |= GFLG_SELECTED;
 446          DoRenderMethod(obj, gpi->gpi_GInfo, GREDRAW_REDRAW);
 447          rc = GMR_MEACTIVE;
 448       }
 449    } else
 450       rc = GMR_NOREUSE;
 451
 452    return rc;
 453 }
 454 METHOD_END
 455
 456 ///
 457 /// GM_HANDLEINPUT
 458 /*
 459  * Handle button gadget input.
 460  */
 461 STATIC METHOD(ButtonClassHandleInput, struct gpInput *,gpi)
 462 {
 463    WORD                  sel = 0;
 464    struct gpHitTest      gph;
 465    struct GadgetInfo    *gi = gpi->gpi_GInfo;
 466    ULONG                 rc = GMR_MEACTIVE;
 467
 468    /*
 469     * Mouse over the object?
 470     */
 471    gph.MethodID      = GM_HITTEST;
 472    gph.gpht_GInfo    = gi;
 473    gph.gpht_Mouse.X  = gpi->gpi_Mouse.X;
 474    gph.gpht_Mouse.Y  = gpi->gpi_Mouse.Y;
 475
 476    if (AsmDoMethodA(obj, (Msg)&gph) == GMR_GADGETHIT)
 477       sel = GFLG_SELECTED;
 478
 479    /*
 480     * Check mouse input.
 481     */
 482    if (gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
 483    {
 484       switch (gpi->gpi_IEvent->ie_Code)
 485       {
 486          case MIDDLEUP:
 487          case MENUUP:
 488          case SELECTUP:
 489             /*
 490              * When we are selected we verify.
 491              */
 492             if (sel)
 493             {
 494                /*
 495                 * Send final notification.
 496                 */
 497                DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, GA_UserData, GADGET(obj)->UserData, TAG_END);
 498                rc = GMR_NOREUSE|GMR_VERIFY;
 499             }
 500             else
 501             {
 502                rc = GMR_NOREUSE;
 503             };
 504             sel = 0;
 505             break;
 506
 507          case MIDDLEDOWN:
 508          case MENUDOWN:
 509          case SELECTDOWN:
 510             /*
 511              * Another button aborts the selection.
 512              */
 513             DoSetMethodNG(obj, BT_ReportID, FALSE, TAG_DONE);
 514             rc = GMR_NOREUSE;
 515             sel = 0;
 516             break;
 517       }
 518    } else if ( gpi->gpi_IEvent->ie_Class == IECLASS_TIMER ) {
 519       /*
 520        * Every timer tick will result in an interim
 521        * notification while the object is selected.
 522        */
 523       if (sel)
 524          DoNotifyMethod(obj, gi, OPUF_INTERIM, GA_ID, GADGET(obj)->GadgetID, GA_UserData, GADGET(obj)->UserData, TAG_END);
 525    }
 526
 527    /*
 528     * Visual change?
 529     */
 530    if ((GADGET(obj)->Flags & GFLG_SELECTED) != sel)
 531    {
 532       /*
 533        * Flip selected bit and redraw.
 534        */
 535       GADGET(obj)->Flags ^= GFLG_SELECTED;
 536       DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 537    }
 538
 539    return rc;
 540 }
 541 METHOD_END
 542 ///
 543 /// OM_GET
 544 /*
 545  * They want to know something.
 546  */
 547 METHOD(ButtonClassGet, struct opGet *, opg)
 548 {
 549    ULONG       rc = 1;
 550    IPTR       *store = opg->opg_Storage;
 551
 552    switch (opg->opg_AttrID)
 553    {
 554    /*
 555     * We make GA_Selected OM_GET'able.
 556     */
 557    case GA_Selected:
 558       STORE (GADGET(obj)->Flags & GFLG_SELECTED);
 559       break;
 560
 561    default:
 562       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 563       break;
 564    }
 565    return rc;
 566 }
 567 METHOD_END
 568 ///
 569 /// OM_DISPOSE
 570 /*
 571  * Dispose of ourselves.
 572  */
 573 METHOD(ButtonClassDispose, Msg, msg)
 574 {
 575    BD    *bd = INST_DATA(cl, obj);
 576    BC    *bc = BASE_DATA(obj);
 577
 578    if ((bd->bd_Flags & BDF_SYSIMAGE) && bd->bd_Image)
 579       DisposeObject(bd->bd_Image);
 580
 581    if(bd->bd_Flags & BDF_STORED_FRAME)
 582       bc->bc_Frame = bd->bd_StoreFrame;
 583
 584    if (bd->bd_Vector)
 585       DisposeObject(bd->bd_Vector);
 586
 587    if (bd->bd_SelVector)
 588       DisposeObject(bd->bd_SelVector);
 589
 590    return AsmDoSuperMethodA(cl, obj, msg);
 591 }
 592 METHOD_END
 593 ///
 594 /// WM_KEYACTIVE
 595 /*
 596  * We are activated by a key.
 597  */
 598 METHOD(ButtonClassKeyActive, struct wmKeyInput *, wmki)
 599 {
 600    ULONG              rc = WMKF_MEACTIVE;
 601    struct GadgetInfo *gi = wmki->wmki_GInfo;
 602    BD                *bd = INST_DATA(cl, obj);
 603    /*
 604     * If we are toggle-select we do not
 605     * need to go active.
 606     */
 607    if (GADGET(obj)->Activation & GACT_TOGGLESELECT)
 608    {
 609       /*
 610        * Toggle-select buttons do not
 611        * respond to repeated keys.
 612        */
 613       if ((!(wmki->wmki_IEvent->ie_Qualifier & IEQUALIFIER_REPEAT)
 614       && (!(bd->bd_Flags & BDF_NO_DESELECT)))
 615       || !(GADGET(obj)->Flags & GFLG_SELECTED))
 616       {
 617          /*
 618           * Flip selected bit.
 619           */
 620          GADGET(obj)->Flags ^= GFLG_SELECTED;
 621
 622          /*
 623           * Re-render.
 624           */
 625          DoRenderMethod(obj, gi, GREDRAW_REDRAW );
 626
 627          /*
 628           * Notify our state change.
 629           */
 630          DoNotifyMethod(obj, gi, 0, GA_ID, GADGET( obj )->GadgetID, GA_Selected, GADGET( obj )->Flags & GFLG_SELECTED ? TRUE : FALSE, GA_UserData, GADGET( obj )->UserData, TAG_END );
 631
 632          /*
 633           * Setup our ID.
 634           */
 635          *(wmki->wmki_ID) = GADGET(obj)->GadgetID;
 636
 637          rc = WMKF_VERIFY;
 638       }
 639       else
 640          rc = WMKF_CANCEL;
 641    }
 642    else
 643    {
 644       /*
 645        * Flip to selected.
 646        */
 647       GADGET(obj)->Flags |= GFLG_SELECTED;
 648
 649       /*
 650        * Re-render.
 651        */
 652       DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 653    }
 654    return rc;
 655 }
 656 METHOD_END
 657 ///
 658 /// WM_KEYINPUT
 659 /*
 660  * Handle key input messages.
 661  */
 662 METHOD(ButtonClassKeyInput, struct wmKeyInput *, wmki)
 663 {
 664    ULONG              rc   = WMKF_MEACTIVE;
 665    UWORD              qual = wmki->wmki_IEvent->ie_Qualifier;
 666    UWORD              code = wmki->wmki_IEvent->ie_Code, key;
 667    struct GadgetInfo *gi   = wmki->wmki_GInfo;
 668
 669    /*
 670     * Repeat mode?
 671     */
 672    if (!(qual & IEQUALIFIER_REPEAT))
 673    {
 674       /*
 675        * A key released?
 676        */
 677       if (code & IECODE_UP_PREFIX)
 678       {
 679          /*
 680           * Check which key is released.
 681           */
 682          key = MapKey(code & ~IECODE_UP_PREFIX, qual, &wmki->wmki_IEvent->ie_EventAddress);
 683
 684          /*
 685           * Is it the one that activated us?
 686           */
 687          if (*wmki->wmki_Key == key || *wmki->wmki_Key == tolower(key))
 688          {
 689             /*
 690              * Notify our target.
 691              */
 692             DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, GA_UserData, GADGET(obj)->UserData, TAG_END );
 693
 694             /*
 695              * Setup our ID.
 696              */
 697             *(wmki->wmki_ID) = GADGET(obj)->GadgetID;
 698             rc = WMKF_VERIFY;
 699          }
 700       }
 701       else if ((qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) || wmki->wmki_IEvent->ie_Code == 0x45)
 702       {
 703          /*
 704           * We have been cancelled by either a SHIFT key
 705           * or the ESC key.
 706           */
 707          rc = WMKF_CANCEL;
 708       }
 709    }
 710    else
 711       /*
 712        * Repeated key messages will trigger
 713        * an interim notification.
 714        */
 715       DoNotifyMethod( obj, gi, OPUF_INTERIM, GA_ID, GADGET(obj)->GadgetID, GA_Selected, GADGET(obj)->Flags & GFLG_SELECTED ? TRUE : FALSE, GA_UserData, GADGET( obj )->UserData, TAG_END );
 716
 717    return rc;
 718 }
 719 METHOD_END
 720 ///
 721 /// WM_KEYINACTIVE
 722 /*
 723  * We are forced to de-activate.
 724  */
 725 METHOD(ButtonClassKeyInActive, struct wmKeyInActive *, wmkia)
 726 {
 727    /*
 728     * Change visuals to un-selected when
 729     * necessary.
 730     */
 731    if (!(GADGET(obj)->Activation & GACT_TOGGLESELECT))
 732    {
 733       if (GADGET(obj)->Flags & GFLG_SELECTED)
 734       {
 735          GADGET(obj)->Flags &= ~GFLG_SELECTED;
 736          DoRenderMethod( obj, wmkia->wmkia_GInfo, GREDRAW_REDRAW );
 737       }
 738    }
 739
 740    return 0;
 741 }
 742 METHOD_END
 743 ///
 744 /// BASE_DIMENSIONS
 745 /*
 746  * They want our minimum dimensions.
 747  */
 748 METHOD(ButtonClassDimensions, struct bmDimensions *, bmd)
 749 {
 750    BD                   *bd = INST_DATA(cl, obj);
 751    struct BaseInfo      *bi = bmd->bmd_BInfo;
 752    Object               *temp;
 753    int                   rx, ry;
 754    UWORD                 mx = 1, my = 1;
 755    IPTR                  tmp;
 756
 757    if (bd->bd_Image || bd->bd_SelImage)
 758    {
 759       /*
 760        * Get minimum sizes of the available images.
 761        */
 762       if (bd->bd_Image)
 763       {
 764          if (mx < bd->bd_Image->Width)  mx = bd->bd_Image->Width;
 765          if (my < bd->bd_Image->Height) my = bd->bd_Image->Height;
 766       };
 767
 768       /*
 769        * Did we get a selected image?
 770        */
 771       if (bd->bd_SelImage)
 772       {
 773          if (mx < bd->bd_SelImage->Width)  mx = bd->bd_SelImage->Width;
 774          if (my < bd->bd_SelImage->Height) my = bd->bd_SelImage->Height;
 775       };
 776
 777       if (!(bd->bd_Flags & BDF_ENCLOSE))
 778       {
 779          mx += 4;
 780          my += 2;
 781       };
 782
 783       if (bd->bd_Flags & BDF_SYSIMAGE)
 784       {
 785          mx = my = 8;
 786
 787          Get_Attr((Object *)bd->bd_Image, SYSIA_Which, &tmp);
 788
 789          temp = NewObject(NULL, "sysiclass", SYSIA_Which, tmp, SYSIA_DrawInfo, bi->bi_DrInfo,
 790                    SYSIA_Size, (bi->bi_IScreen->Flags & SCREENHIRES) ? SYSISIZE_MEDRES : SYSISIZE_LOWRES, TAG_DONE);
 791
 792          if (temp)
 793          {
 794             if (mx < IMAGE(temp)->Width)  mx = IMAGE(temp)->Width;
 795             if (my < IMAGE(temp)->Height) my = IMAGE(temp)->Height;
 796
 797             DisposeObject(temp);
 798          };
 799       };
 800    }
 801    else if (bd->bd_Vector || bd->bd_SelVector)
 802    {
 803       /*
 804        * Scaled button?
 805        */
 806       if (bd->bd_ScaleWidth && bd->bd_ScaleHeight)
 807       {
 808          if (bi->bi_DrInfo)
 809          {
 810             rx = bi->bi_DrInfo->dri_Resolution.X;
 811             ry = bi->bi_DrInfo->dri_Resolution.Y;
 812          }
 813          else
 814          {
 815             rx = ry = 22;
 816          };
 817
 818          my = bi->bi_RPort->TxHeight;
 819          mx = (my * ry * bd->bd_ScaleWidth) / (rx * bd->bd_ScaleHeight);
 820       }
 821       else
 822       {
 823          /*
 824           * Get minimum vector sizes.
 825           */
 826          if (bd->bd_Vector)
 827          {
 828             Get_Attr(bd->bd_Vector, VIT_MinWidth, &tmp);
 829             if (mx < tmp) mx = tmp;
 830             Get_Attr(bd->bd_Vector, VIT_MinHeight, &tmp);
 831             if (my < tmp) my = tmp;
 832          };
 833
 834          if (bd->bd_SelVector)
 835          {
 836             Get_Attr(bd->bd_SelVector, VIT_MinWidth, &tmp);
 837             if (mx < tmp) mx = tmp;
 838             Get_Attr(bd->bd_SelVector, VIT_MinHeight, &tmp);
 839             if (my < tmp) my = tmp;
 840          };
 841          mx -= 2;
 842          my -= 2;
 843       };
 844    }
 845    else
 846    {
 847       /*
 848        * Normal button. When BUTTON_EncloseImage is
 849        * specified we make the label enclosed in the frame.
 850        */
 851       mx = (bd->bd_Flags & BDF_ENCLOSE) ? 0 : 4;
 852       my = (bd->bd_Flags & BDF_ENCLOSE) ? 0 : 2;
 853    };
 854
 855    /*
 856     * Compute dimensions and add our values.
 857     */
 858    return CalcDimensions(cl, obj, bmd, mx, my);
 859 }
 860 METHOD_END
 861 ///
 862 /// BASE_FINDKEY
 863 METHOD(ButtonClassFindKey, struct bmFindKey *, bmfk)
 864 {
 865    if (bmfk->bmfk_Key.Qual & IEQUALIFIER_REPEAT)
 866       return 0;
 867    else
 868       return AsmDoSuperMethodA(cl, obj, (Msg)bmfk);
 869 }
 870 METHOD_END
 871 ///
 872 /// Class initialization.
 873 /*
 874  * Class function table.
 875  */
 876 STATIC DPFUNC ClassFunc[] = {
 877    { BASE_RENDER,            ButtonClassRender, },
 878    { GM_GOACTIVE,            ButtonClassGoActive, },
 879    { GM_HANDLEINPUT,         ButtonClassHandleInput, },
 880
 881    { OM_SET,                 ButtonClassSetUpdate, },
 882    { OM_UPDATE,              ButtonClassSetUpdate, },
 883    { OM_GET,                 ButtonClassGet, },
 884    { OM_NEW,                 ButtonClassNew, },
 885    { OM_DISPOSE,             ButtonClassDispose, },
 886
 887    { WM_KEYACTIVE,           ButtonClassKeyActive, },
 888    { WM_KEYINPUT,            ButtonClassKeyInput, },
 889    { WM_KEYINACTIVE,         ButtonClassKeyInActive, },
 890
 891    { BASE_DIMENSIONS,        ButtonClassDimensions, },
 892    { BASE_FINDKEY,           ButtonClassFindKey, },
 893    { DF_END,                 NULL, },
 894 };
 895
 896 /*
 897  * Simple class initialization.
 898  */
 899 makeproto Class *InitButtonClass(void)
 900 {
 901    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
 902                          CLASS_ObjectSize,     sizeof(BD),
 903                          CLASS_DFTable,        ClassFunc,
 904                          TAG_DONE);
 905 }
 906 ///