bgui/cycleclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * cycleclass.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.8  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.7  2002/09/17 17:11:16  stegerg
  18  * inversvid drawmode together with Text() works now, so no
  19  * workaround needed.
  20  *
  21  * Revision 42.6  2000/08/17 15:09:18  chodorowski
  22  * Fixed compiler warnings.
  23  *
  24  * Revision 42.5  2000/07/18 18:32:38  stegerg
  25  * The AllocBaseInfo/AllocBaseInfoDebug calls in OpenPopUpWindow method
  26  * missed a TAG_DONE. Manuel, if you read this: this is a real (also in AmigaOS)
  27  * bug, not just AROS!!!
  28  *
  29  * Revision 42.4  2000/07/11 17:04:41  stegerg
  30  * temp fix for small gfx bug which happens because of INVERSVID
  31  * drawmode not yet working in AROS.
  32  *
  33  * Revision 42.3  2000/05/29 15:42:49  stegerg
  34  * fixed some "comparison is always 1 due to limited range of data type"
  35  * errors
  36  *
  37  * Revision 42.2  2000/05/15 19:27:01  stegerg
  38  * another hundreds of REG() macro replacements in func headers/protos.
  39  *
  40  * Revision 42.1  2000/05/14 23:32:47  stegerg
  41  * changed over 200 function headers which all use register
  42  * parameters (oh boy ...), because the simple REG() macro
  43  * doesn't work with AROS. And there are still hundreds
  44  * of headers left to be fixed :(
  45  *
  46  * Many of these functions would also work with stack
  47  * params, but since i have fixed every single one
  48  * I encountered up to now, I guess will have to do
  49  * the same for the rest.
  50  *
  51  * Revision 42.0  2000/05/09 22:08:45  mlemos
  52  * Bumped to revision 42.0 before handing BGUI to AROS team
  53  *
  54  * Revision 41.11  2000/05/09 19:54:08  mlemos
  55  * Merged with the branch Manuel_Lemos_fixes.
  56  *
  57  * Revision 41.10.2.3  1998/12/07 03:06:57  mlemos
  58  * Replaced OpenFont and CloseFont calls by the respective BGUI debug macros.
  59  *
  60  * Revision 41.10.2.2  1998/03/01 23:06:01  mlemos
  61  * Corrected RastPort tag where GadgetInfo was being passed.
  62  *
  63  * Revision 41.10.2.1  1998/03/01 15:37:32  mlemos
  64  * Added support to track BaseInfo memory leaks.
  65  *
  66  * Revision 41.10  1998/02/25 21:11:52  mlemos
  67  * Bumping to 41.10
  68  *
  69  * Revision 1.1  1998/02/25 17:07:59  mlemos
  70  * Ian sources
  71  *
  72  *
  73  */
  74
  75 /// Class definitions.
  76
  77 #include "include/classdefs.h"
  78
  79 /*
  80  * Object instance data.
  81  */
  82 typedef struct {
  83    struct Window     *cd_PopWindow;    /* Popup window pointer.            */
  84    Object            *cd_ArrayLabel;   /* Label object for active label.   */
  85    Object            *cd_Image;        /* Image for the popcycle.          */
  86    UBYTE            **cd_Labels;       /* Array of object labels.          */
  87    ULONG              cd_Active;       /* Active label.                    */
  88    ULONG              cd_NumLabels;    /* Amount of labels.                */
  89    struct TextAttr   *cd_PopupFont;    /* Font for pop window.             */
  90    struct TextFont   *cd_Font;         /* General font.                    */
  91    UWORD              cd_Flags;        /* See below.                       */
  92    UWORD              cd_Previous;     /* Previously selected label.       */
  93    UWORD              cd_ImageWidth;   /* Width of area for clicking.      */
  94 }  CD;
  95
  96 #define CDF_POPUP       (1<<0)         /* Popup mode.          */
  97 #define CDF_NOTIFY      (1<<1)         /* Notify change.       */
  98 #define CDF_THIN        (1<<2)         /* Thin frames.         */
  99 #define CDF_POPACTIVE   (1<<3)         /* Pop on active entry. */
 100
 101 ///
 102
 103 /// OM_NEW
 104 /*
 105  * Create a new object.
 106  */
 107 METHOD(CycleClassNew, struct opSet *, ops)
 108 {
 109    CD             *cd;
 110    struct TagItem *tags;
 111    ULONG           rc;
 112
 113    tags = DefTagList(BGUI_CYCLE_GADGET, ops->ops_AttrList);
 114
 115    /*
 116     * First we let the superclass
 117     * create an object.
 118     */
 119    if (rc = NewSuperObject(cl, obj, tags))
 120    {
 121       /*
 122        * Get instance data.
 123        */
 124       cd = INST_DATA(cl, rc);
 125
 126       /*
 127        * Set up imagery.
 128        */
 129       cd->cd_ImageWidth = 18;
 130
 131       cd->cd_Image      = BGUI_NewObject(BGUI_VECTOR_IMAGE, VIT_BuiltIn,     BUILTIN_CYCLE,
 132                                                             TAG_DONE);
 133
 134       /*
 135        * Setup a Label class object used to render the active label.
 136        */
 137       cd->cd_ArrayLabel = BGUI_NewObject(BGUI_LABEL_IMAGE,  LAB_Place,       PLACE_IN,
 138                                                             LAB_Highlight,   FALSE,
 139                                                             LAB_Underscore,  0,
 140                                                             IMAGE_ErasePen,  0,
 141                                                             TAG_DONE);
 142
 143       AsmCoerceMethod(cl, (Object *)rc, OM_SET, tags, NULL);
 144
 145       if (cd->cd_ArrayLabel && cd->cd_Image && cd->cd_Labels)
 146       {
 147          ;
 148       }
 149       else
 150       {
 151          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 152          rc = 0;
 153       };
 154    };
 155    FreeTagItems(tags);
 156
 157    return rc;
 158 }
 159 METHOD_END
 160 ///
 161 /// OM_SET
 162 /*
 163  * Change the object attributes.
 164  */
 165 METHOD(CycleClassSetUpdate, struct opUpdate *, opu)
 166 {
 167    CD                 *cd = INST_DATA(cl, obj);
 168    struct TagItem     *tstate = opu->opu_AttrList, *tag;
 169    ULONG               oact = cd->cd_Active, data;
 170    WORD                dis = GADGET(obj)->Flags & GFLG_DISABLED;
 171    UBYTE             **new_labels = NULL;
 172    int                 num_labels;
 173    BOOL                render = FALSE;
 174    struct GadgetInfo  *gi = opu->opu_GInfo;
 175
 176    /*
 177     * First let the superclass do its thing.
 178     */
 179    AsmDoSuperMethodA(cl, obj, (Msg)opu);
 180
 181    /*
 182     * Force the correct activation method.
 183     */
 184    GADGET(obj)->Activation |= GACT_RELVERIFY;
 185    GADGET(obj)->Activation &= ~GACT_IMMEDIATE;
 186
 187    while (tag = NextTagItem(&tstate))
 188    {
 189       data = tag->ti_Data;
 190       switch (tag->ti_Tag)
 191       {
 192       case BT_TextAttr:
 193          cd->cd_PopupFont = (struct TextAttr *)data;
 194          /*
 195           * Let the label know.
 196           */
 197          DoSetMethodNG(cd->cd_ArrayLabel, LAB_TextAttr, data, TAG_DONE);
 198          break;
 199
 200       case FRM_ThinFrame:
 201          if (data) cd->cd_Flags |= CDF_THIN;
 202          else      cd->cd_Flags &= ~CDF_THIN;
 203          break;
 204
 205       case CYC_Active:
 206          cd->cd_Active = data;
 207          break;
 208
 209       case CYC_Labels:
 210          /*
 211           * Count the number of labels in the array (offset by 1).
 212           */
 213          num_labels = data ? CountLabels((UBYTE **)data) : -1;
 214
 215          if (num_labels >= 0)
 216          {
 217             if (new_labels = BGUI_AllocPoolMem((num_labels + 2) * sizeof(UBYTE *)))
 218             {
 219                if (cd->cd_Labels) BGUI_FreePoolMem(cd->cd_Labels);
 220                cd->cd_Labels    = new_labels;
 221                cd->cd_NumLabels = num_labels;
 222                CopyMem((UBYTE *)data, (UBYTE *)new_labels, (num_labels + 1) * sizeof(UBYTE *));
 223             };
 224          };
 225          render = TRUE;
 226          break;
 227
 228       case CYC_Popup:
 229          if (data) cd->cd_Flags |= CDF_POPUP;
 230          else      cd->cd_Flags &= ~CDF_POPUP;
 231          break;
 232
 233       case CYC_PopActive:
 234          if (data) cd->cd_Flags |= CDF_POPACTIVE;
 235          else      cd->cd_Flags &= ~CDF_POPACTIVE;
 236          break;
 237       };
 238    };
 239
 240    if ((GADGET(obj)->Flags & GFLG_DISABLED) != dis)
 241       /*
 242        * Re-render when the gadget disabled state changed.
 243        */
 244       render = TRUE;
 245
 246    /*
 247     * Here's that sanity check again.
 248     */
 249    if (cd->cd_Active > cd->cd_NumLabels)
 250        cd->cd_Active = cd->cd_NumLabels;
 251
 252    if ((oact != cd->cd_Active) || new_labels)
 253    {
 254       /*
 255        * Setup new text.
 256        */
 257       DoSetMethodNG(cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[cd->cd_Active], LAB_Place, PLACE_IN, TAG_DONE);
 258       render = TRUE;
 259    };
 260
 261    if (render) DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 262
 263    /*
 264     * Notify the target when necessary.
 265     */
 266    if (oact != cd->cd_Active)
 267    {
 268       DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, CYC_Active, cd->cd_Active, TAG_DONE);
 269    }
 270    return 1;
 271 }
 272 METHOD_END
 273 ///
 274
 275 /// RenderArrow
 276 /*
 277  * Render the cycle arrow.
 278  */
 279 STATIC VOID RenderArrow(struct BaseInfo *bi, struct IBox *ib, ULONG state, CD *cd)
 280 {
 281    Object   *image = cd->cd_Image;
 282    ULONG     type;
 283
 284    /*
 285     * Get coords.
 286     */
 287    int w = cd->cd_ImageWidth;
 288    int h = ib->Height;
 289    int l = ib->Left - w;
 290    int t = ib->Top;
 291
 292    /*
 293     * Render the small seperator.
 294     */
 295    BSetDrMd(bi, JAM1);
 296
 297    BSetDPenA(bi, (state != IDS_SELECTED) ? SHINEPEN : SHADOWPEN);
 298    VLine(bi->bi_RPort, l + w + 1, t + 2, t + h - 3);
 299
 300    BSetDPenA(bi, (state != IDS_SELECTED) ? SHADOWPEN : SHINEPEN);
 301    VLine(bi->bi_RPort, l + w, t + 2, t + h - 3);
 302
 303    if (state == IDS_SELECTED)
 304    {
 305       type = BUILTIN_CYCLE2;
 306    }
 307    else
 308    {
 309       type = (cd->cd_Flags & CDF_POPUP) ? BUILTIN_POPUP : BUILTIN_CYCLE;
 310    };
 311
 312    /*
 313     * Setup and render the image.
 314     */
 315    DoSetMethodNG(image, VIT_BuiltIn, type, IA_Left, l, IA_Top, t, IA_Width, w, IA_Height, h, TAG_END);
 316    BDrawImageState(bi, image, 0, 0, state);
 317 }
 318 ///
 319 /// RenderPopupEntry
 320 /*
 321  * Render an entry in the popup-list.
 322  */
 323 STATIC VOID RenderPopupEntry(struct BaseInfo *bi, CD *cd, ULONG num, BOOL sel)
 324 {
 325    UWORD            ypos, xpos, tlen, pix = cd->cd_Flags & CDF_THIN ? 2 : 4;
 326    UBYTE           *name = cd->cd_Labels[num];
 327    struct RastPort *rp = bi->bi_RPort;
 328
 329    /*
 330     * Compute text length.
 331     */
 332    tlen = TextWidth(rp, name);
 333
 334    /*
 335     * Compute positions.
 336     */
 337    xpos = (cd->cd_PopWindow->Width - tlen) >> 1;
 338    ypos = (num * rp->TxHeight)  + 2;
 339
 340    /*
 341     * Setup pens for filling.
 342     */
 343    #ifdef ENHANCED
 344    BSetDPenA(bi, sel ? BARDETAILPEN : BARBLOCKPEN);
 345    #else
 346    if (OS30) BSetDPenA(bi, sel ? BARDETAILPEN : BARBLOCKPEN);
 347    else      BSetDPenA(bi, BLOCKPEN);
 348    #endif
 349
 350    /*
 351     * RectFill entry.
 352     */
 353    BSetDrMd(bi, JAM1);
 354    BRectFill(bi, pix, ypos, cd->cd_PopWindow->Width - pix - 1, ypos + rp->TxHeight - 1);
 355
 356    /*
 357     * Setup drawmode.
 358     */
 359    #ifdef ENHANCED
 360    BSetDrMd(bi, sel ? JAM2|INVERSVID : JAM2);
 361    #else
 362    if (OS30) BSetDrMd(bi, sel ? JAM2|INVERSVID : JAM2);
 363    else      BSetDrMd(bi, JAM2);
 364    #endif
 365
 366    /*
 367     * Setup pens for text.
 368     */
 369    BSetDPenA(bi, BARDETAILPEN);
 370    BSetDPenB(bi, BARBLOCKPEN);
 371
 372    /*
 373     * Move to the desired location and render.
 374     */
 375    Move(rp, xpos, ypos + rp->TxBaseline);
 376    Text(rp, name, strlen(name));
 377
 378    #ifndef ENHANCED
 379    /*
 380     * < OS 3.0 will get the entry
 381     * complemented if it is selected.
 382     */
 383    if (!OS30 && sel)
 384    {
 385       BSetDrMd(bi, JAM2|COMPLEMENT);
 386       BRectFill(bi, pix, ypos, cd->cd_PopWindow->Width - pix - 1, ypos + rp->TxHeight - 1);
 387    }
 388    #endif
 389 }
 390 ///
 391 /// GM_RENDER
 392 /*
 393  * Render the object.
 394  */
 395 METHOD(CycleClassRenderX, struct gpRender *, gpr)
 396 {
 397    CD              *cd = INST_DATA(cl, obj);
 398
 399    DoSuperSetMethodNG(cl, obj, BT_LeftOffset, cd->cd_ImageWidth, TAG_DONE);
 400
 401    return AsmDoSuperMethodA(cl, obj, (Msg)gpr);
 402 }
 403 METHOD_END
 404 ///
 405 /// BASE_RENDER
 406 /*
 407  * Render the object.
 408  */
 409 METHOD(CycleClassRender, struct bmRender *, bmr)
 410 {
 411    CD              *cd = INST_DATA(cl, obj);
 412    BC              *bc = BASE_DATA(obj);
 413    struct BaseInfo *bi = bmr->bmr_BInfo;
 414    int              state = GADGET(obj)->Flags & GFLG_SELECTED ? IDS_SELECTED : IDS_NORMAL;
 415
 416    /*
 417     * Render the baseclass.
 418     */
 419    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
 420
 421    /*
 422     * Setup array label.
 423     */
 424    *IMAGEBOX(cd->cd_ArrayLabel) = bc->bc_InnerBox;
 425
 426    /*
 427     * Render the arrow.
 428     */
 429    RenderArrow(bi, &bc->bc_InnerBox, state, cd);
 430
 431    /*
 432     * We always render the active gadget label.
 433     */
 434    BDrawImageState(bi, cd->cd_ArrayLabel, 0, 0, state);
 435
 436    /*
 437     * Ghost the gadget when it is disabled.
 438     */
 439    if (GADGET(obj)->Flags & GFLG_DISABLED)
 440       BDisableBox(bi, &bc->bc_HitBox);
 441
 442    return 1;
 443 }
 444 METHOD_END
 445 ///
 446
 447 /// OpenPopupWindow
 448 /*
 449  * Open the popup-window.
 450  */
 451 METHOD(OpenPopupWindow, struct gpInput *, gpi)
 452 {
 453    CD                   *cd = INST_DATA(cl, obj);
 454    BC                   *bc = BASE_DATA(obj);
 455    UWORD                 max_items, num_items, wleft, wtop, wwi, wwh, bg, i;
 456    struct IBox          *ibox;
 457    struct RastPort      *rp;
 458    struct GadgetInfo    *gi = gpi->gpi_GInfo;
 459    struct BaseInfo      *bi;
 460    int                   ysize;
 461    ULONG                 rc = GMR_NOREUSE;
 462
 463    /*
 464     * Get the gadget hitbox bounds.
 465     */
 466    Get_SuperAttr(cl, obj, BT_HitBox, &ibox);
 467
 468    /*
 469     * Open the font.
 470     */
 471    if (cd->cd_PopupFont)
 472       cd->cd_Font = BGUI_OpenFont(cd->cd_PopupFont);
 473
 474    /* BAD CODE! Does not check OpenFont result! */
 475
 476    ysize = cd->cd_Font->tf_YSize;
 477
 478    /*
 479     * How many items will fit?
 480     */
 481    max_items = (gi->gi_Screen->Height - 4) / ysize;
 482
 483    /*
 484     * How many do we have?
 485     */
 486    num_items = (cd->cd_NumLabels + 1) > max_items ? max_items : (cd->cd_NumLabels + 1);
 487
 488    /*
 489     * Compute window position and dimensions.
 490     */
 491    wleft = bc->bc_HitBox.Left + gi->gi_Window->LeftEdge;
 492    wwi   = bc->bc_HitBox.Width;
 493    wwh   = (num_items * ysize) + 4;
 494
 495    if (cd->cd_Flags & CDF_POPACTIVE)
 496       wtop = gi->gi_Screen->MouseY - (2 + ((cd->cd_Active * ysize) + (ysize >> 1)));
 497    else
 498       wtop = bc->bc_HitBox.Top + bc->bc_HitBox.Height + gi->gi_Window->TopEdge;
 499
 500    /*
 501     * Pop the window.
 502     */
 503    cd->cd_PopWindow = OpenWindowTags(NULL, WA_Left,           wleft,   WA_Top,            wtop,
 504                                            WA_Width,          wwi,     WA_Height,         wwh,
 505                                            WA_Flags,          0,       WA_IDCMP,          0,
 506                                            WA_Borderless,     TRUE,    WA_AutoAdjust,     TRUE,
 507                                            WA_SmartRefresh,   TRUE,    WA_NoCareRefresh,  TRUE,
 508                                            WA_RMBTrap,        TRUE,    WA_CustomScreen,   gi->gi_Screen,
 509                                            TAG_DONE);
 510    /*
 511     * success?
 512     */
 513    if (cd->cd_PopWindow)
 514    {
 515       /*
 516        * No previous selected item.
 517        */
 518       cd->cd_Previous = (UWORD)~0;
 519
 520       /* AROS BUGFIX --> AMIGAOS BUGFIX: TAG_DONE missed in both AllocBaseInfoDebug and AllocBaseInfo call below */
 521 #ifdef DEBUG_BGUI
 522       if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_Screen, gi->gi_Screen, BI_RastPort, rp = cd->cd_PopWindow->RPort, TAG_DONE))
 523 #else
 524       if (bi = AllocBaseInfo(BI_Screen, gi->gi_Screen, BI_RastPort, rp = cd->cd_PopWindow->RPort, TAG_DONE))
 525 #endif
 526       {
 527          /*
 528           * Setup the font.
 529           */
 530          if (cd->cd_Font) BSetFont(bi, cd->cd_Font);
 531
 532          /*
 533           * Setup pop window rastport.
 534           */
 535          BSetDPenA(bi, BARBLOCKPEN);
 536          BSetDrMd(bi, JAM1);
 537
 538          /*
 539           * Fill...
 540           */
 541          BBoxFill(bi, 0, 0, wwi, wwh);
 542
 543          /*
 544           * Setup pop window rastport.
 545           */
 546          BSetDPenA(bi, BARDETAILPEN);
 547
 548          /*
 549           * Render border.
 550           */
 551          Move(rp, 0, 0 );
 552          Draw(rp, wwi - 1, 0);
 553          Draw(rp, wwi - 1, wwh - 1 );
 554          Draw(rp, 0, wwh - 1 );
 555          Draw(rp, 0, 0 );
 556
 557          if (!(cd->cd_Flags & CDF_THIN))
 558          {
 559             Move(rp, 1, 0 );
 560             Draw(rp, 1, wwh - 1 );
 561             Move(rp, wwi - 2, 0 );
 562             Draw(rp, wwi - 2, wwh - 1 );
 563          }
 564
 565          /*
 566           * Render list-entries.
 567           */
 568          for (i = 0; i < num_items; i++)
 569             RenderPopupEntry(bi, cd, i, FALSE);
 570
 571          FreeBaseInfo(bi);
 572
 573          rc = GMR_MEACTIVE;
 574       };
 575    }
 576    return rc;
 577 }
 578 METHOD_END
 579 ///
 580
 581 /// GM_GOACTIVE
 582 /*
 583  * Go in active mode.
 584  */
 585 METHOD(CycleClassGoActive, struct gpInput *, gpi)
 586 {
 587    CD          *cd = INST_DATA(cl, obj);
 588    BC          *bc = BASE_DATA(obj);
 589    ULONG        rc = GMR_NOREUSE;
 590
 591    /*
 592     * We don't go active when we are disabled.
 593     */
 594    if ( GADGET( obj )->Flags & GFLG_DISABLED )
 595       return( GMR_NOREUSE );
 596
 597    /*
 598     * We only go active when triggered by a mouse click.
 599     */
 600    if (gpi->gpi_IEvent)
 601    {
 602       /*
 603        * Let the superclass have a go...
 604        */
 605       AsmDoSuperMethodA(cl, obj, (Msg)gpi);
 606
 607       /*
 608        * Popup mode?
 609        */
 610       if (cd->cd_Flags & CDF_POPUP)
 611       {
 612          if (gpi->gpi_GInfo->gi_Window->MouseX > (bc->bc_HitBox.Left + cd->cd_ImageWidth))
 613          {
 614             /*
 615              * Open the popup window.
 616              * Do normal selection if the popup window will not open.
 617              */
 618             if (OpenPopupWindow(cl, obj, gpi) == 0) return 0;
 619          };
 620       };
 621       GADGET(obj)->Flags |= GFLG_SELECTED;
 622       DoRenderMethod(obj, gpi->gpi_GInfo, GREDRAW_REDRAW);
 623       rc = GMR_MEACTIVE;
 624    }
 625    return rc;
 626 }
 627 METHOD_END
 628 ///
 629
 630 /*
 631  * Which entry is selected?
 632  */
 633 //STATIC ASM UWORD Selected(REG(a0) CD *cd, REG(a1) struct RastPort *rp)
 634 STATIC ASM REGFUNC2(UWORD, Selected,
 635         REGPARAM(A0, CD *, cd),
 636         REGPARAM(A1, struct RastPort *, rp))
 637 {
 638    WORD        mx = cd->cd_PopWindow->MouseX, my = cd->cd_PopWindow->MouseY;
 639    LONG        item = ~0;
 640
 641    /*
 642     *  Mouse in the window?
 643     */
 644    if ( mx >= 4 && mx < ( cd->cd_PopWindow->Width - 4 ) && my >= 2 && my < ( cd->cd_PopWindow->Height - 2 )) {
 645       /*
 646        * Find the entry the mouse is over.
 647        */
 648       item = ( my - 2 ) / rp->TxHeight;
 649
 650       if ( item > cd->cd_NumLabels ) item = ~0;
 651    }
 652    return(( UWORD )item );
 653 }
 654 REGFUNC_END
 655 /// GM_HANDLEINPUT
 656 /*
 657  * Handle the gadget input.
 658  */
 659 METHOD(CycleClassHandleInput, struct gpInput *, gpi)
 660 {
 661    CD                   *cd = INST_DATA(cl, obj);
 662    struct gpHitTest      gph;
 663    WORD                  sel = 0, item;
 664    struct GadgetInfo    *gi = gpi->gpi_GInfo;
 665    struct BaseInfo      *bi;
 666    ULONG                 rc = GMR_MEACTIVE;
 667
 668    /*
 669     * Window up?
 670     */
 671    if (cd->cd_PopWindow)
 672    {
 673       /*
 674        * Is the parent window still activated?
 675        * If not we return immediatly.
 676        *
 677        * Security. Intuition should do this already.
 678        */
 679       if (!(gi->gi_Window->Flags & WFLG_WINDOWACTIVE))
 680          return GMR_NOREUSE;
 681
 682 #ifdef DEBUG_BGUI
 683       if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, cd->cd_PopWindow->RPort, TAG_DONE))
 684 #else
 685       if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, cd->cd_PopWindow->RPort, TAG_DONE))
 686 #endif
 687       {
 688          /*
 689           * Where is the mouse?
 690           */
 691          item = Selected(cd, bi->bi_RPort);
 692
 693          /*
 694           * Changed?
 695           */
 696          if (item != cd->cd_Previous)
 697          {
 698             /*
 699              * Previous selected item?
 700              */
 701             if (cd->cd_Previous != (UWORD)~0) RenderPopupEntry(bi, cd, cd->cd_Previous, FALSE);
 702
 703             /*
 704              * Render current entry.
 705              */
 706             if (item != ~0) RenderPopupEntry(bi, cd, item, TRUE);
 707
 708             /*
 709              * Setup item.
 710              */
 711             cd->cd_Previous = item;
 712          }
 713          FreeBaseInfo(bi);
 714
 715          /*
 716           * What's the event?
 717           */
 718          if (gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
 719          {
 720             switch (gpi->gpi_IEvent->ie_Code)
 721             {
 722             case SELECTUP:
 723                /*
 724                 * Setup the new label and return VERIFY.
 725                 */
 726                if (cd->cd_Previous != (UWORD)~0)
 727                {
 728                   if (cd->cd_Active != cd->cd_Previous)
 729                   {
 730                      /*
 731                       * We need notification.
 732                       */
 733                      cd->cd_Flags |= CDF_NOTIFY;
 734
 735                      /*
 736                       * New active entry.
 737                       */
 738                      cd->cd_Active = cd->cd_Previous;
 739
 740                      /*
 741                       * Setup the new label.
 742                       */
 743                      DoSetMethodNG(cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[cd->cd_Active], LAB_Place, PLACE_IN, TAG_END);
 744
 745                      /*
 746                       * Re-render to show the change.
 747                       */
 748                      DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 749
 750                      /*
 751                       * We want to notify about the attribute change.
 752                       */
 753                      rc = GMR_NOREUSE | GMR_VERIFY;
 754                   } else
 755                      rc = GMR_NOREUSE;
 756                } else
 757                   rc = GMR_NOREUSE;
 758                break;
 759
 760             case MENUDOWN:
 761                rc = GMR_NOREUSE;
 762                break;
 763             }
 764          }
 765       }
 766    }
 767    else
 768    {
 769       /*
 770        * Mouse over the object?
 771        */
 772       gph.MethodID      = GM_HITTEST;
 773       gph.gpht_GInfo    = gpi->gpi_GInfo;
 774       gph.gpht_Mouse.X  = gpi->gpi_Mouse.X;
 775       gph.gpht_Mouse.Y  = gpi->gpi_Mouse.Y;
 776
 777       if ( AsmDoMethodA( obj, ( Msg )&gph ) == GMR_GADGETHIT )
 778          sel = GFLG_SELECTED;
 779
 780       if ( gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE ) {
 781          switch ( gpi->gpi_IEvent->ie_Code ) {
 782
 783             case  SELECTUP:
 784                /*
 785                 * When we are selected we setup a new label
 786                 * and return VERIFY.
 787                 */
 788                if ( sel ) {
 789                   /*
 790                    * Clicked with the shift key down cycles backward.
 791                    */
 792                   if ( gpi->gpi_IEvent->ie_Qualifier & ( IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT )) {
 793                      if ( cd->cd_Active )       cd->cd_Active--;
 794                      else              cd->cd_Active = cd->cd_NumLabels;
 795                   } else {
 796                      if ( cd->cd_Active < cd->cd_NumLabels ) cd->cd_Active++;
 797                      else              cd->cd_Active = 0;
 798                   }
 799
 800                   /*
 801                    * Setup the new label.
 802                    */
 803                   DoSetMethodNG( cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[ cd->cd_Active ], LAB_Place, PLACE_IN, TAG_END  );
 804
 805                   /*
 806                    * We want to notify about the attribute change.
 807                    */
 808                   rc = GMR_NOREUSE | GMR_VERIFY;
 809                   cd->cd_Flags |= CDF_NOTIFY;
 810                } else
 811                   /*
 812                    * We are not selected anymore.
 813                    */
 814                   rc = GMR_NOREUSE;
 815
 816                sel = 0;
 817                break;
 818
 819             case  MENUDOWN:
 820                sel = 0;
 821                rc = GMR_REUSE;
 822                break;
 823          }
 824       }
 825
 826       /*
 827        * Do we need a visual change?
 828        */
 829       if ((GADGET(obj)->Flags & GFLG_SELECTED) != sel)
 830       {
 831          /*
 832           * Toggle the selected bit.
 833           */
 834          GADGET(obj)->Flags ^= GFLG_SELECTED;
 835
 836          /*
 837           * Re-render the gadget.
 838           */
 839          DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 840       };
 841    };
 842    return rc;
 843 }
 844 METHOD_END
 845 ///
 846 /// GM_GOINACTIVE
 847
 848 METHOD(CycleClassGoInactive, struct gpGoInactive *, gpgi)
 849 {
 850    CD          *cd = INST_DATA( cl, obj );
 851
 852    /*
 853     * Popup window open?
 854     */
 855    if ( cd->cd_PopWindow ) {
 856       /*
 857        * Close the window.
 858        */
 859       CloseWindow( cd->cd_PopWindow );
 860       cd->cd_PopWindow = NULL;
 861    }
 862
 863    /*
 864     * Close the font.
 865     */
 866    if ( cd->cd_Font ) {
 867       BGUI_CloseFont( cd->cd_Font );
 868       cd->cd_Font = NULL;
 869    }
 870
 871    /*
 872     * Notify?
 873     */
 874    if ( cd->cd_Flags & CDF_NOTIFY ) {
 875       DoNotifyMethod( obj, gpgi->gpgi_GInfo, 0L, GA_ID, GADGET( obj )->GadgetID, CYC_Active, cd->cd_Active, TAG_END  );
 876       cd->cd_Flags &= ~CDF_NOTIFY;
 877    }
 878
 879    return( AsmDoSuperMethodA( cl, obj, ( Msg )gpgi ));
 880 }
 881 METHOD_END
 882 /// OM_GET
 883 /// OM_GET
 884 /*
 885  * Get an attribute.
 886  */
 887 METHOD(CycleClassGet, struct opGet *, opg)
 888 {
 889    CD        *cd = INST_DATA(cl, obj);
 890    ULONG      rc = 1, *store = opg->opg_Storage;
 891
 892    switch (opg->opg_AttrID)
 893    {
 894    case CYC_Active:
 895       STORE cd->cd_Active;
 896       break;
 897
 898    case CYC_Popup:
 899       STORE cd->cd_Flags & CDF_POPUP;
 900       break;
 901
 902    case CYC_PopActive:
 903       STORE cd->cd_Flags & CDF_POPACTIVE;
 904       break;
 905
 906    default:
 907       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 908       break;
 909    }
 910    return rc;
 911 }
 912 METHOD_END
 913 ///
 914 /// OM_DISPOSE
 915 /*
 916  * Dispose of the object.
 917  */
 918 METHOD(CycleClassDispose, Msg, msg)
 919 {
 920    CD       *cd = INST_DATA(cl, obj);
 921
 922    if (cd->cd_ArrayLabel)
 923       DisposeObject(cd->cd_ArrayLabel);
 924    if (cd->cd_Image)
 925       DisposeObject(cd->cd_Image);
 926
 927    if (cd->cd_Labels)
 928       BGUI_FreePoolMem(cd->cd_Labels);
 929
 930    return AsmDoSuperMethodA(cl, obj, msg);
 931 }
 932 METHOD_END
 933 ///
 934 /// BASE_DIMENSIONS
 935 /*
 936  * The object size is requested.
 937  */
 938 METHOD(CycleClassDimensions, struct bmDimensions *, bmd)
 939 {
 940    CD                *cd = INST_DATA(cl, obj);
 941    struct BaseInfo   *bi = bmd->bmd_BInfo;
 942    UBYTE            **labels = cd->cd_Labels, *label;
 943    int                mw = 0, mh = 0;
 944    struct TextExtent  te;
 945
 946    /*
 947     * Find out the size of the largest label.
 948     */
 949    while (label = *labels++)
 950    {
 951       /*
 952        * Call TextExtent to find out the text width.
 953        */
 954       TextExtent(bi->bi_RPort, label, strlen(label), &te);
 955       if (te.te_Width  > mw) mw = te.te_Width;
 956       if (te.te_Height > mh) mh = te.te_Height;
 957    };
 958
 959    /*
 960     * Include cycle/popup image width.
 961     */
 962    return CalcDimensions(cl, obj, bmd, mw + 30, mh + 2);
 963 }
 964 METHOD_END
 965 ///
 966 /// WM_KEYACTIVE
 967 /*
 968  * Key activation.
 969  */
 970 METHOD(CycleClassKeyActive, struct wmKeyInput *, wmki)
 971 {
 972    CD       *cd = INST_DATA(cl, obj);
 973    UWORD     qual = wmki->wmki_IEvent->ie_Qualifier;
 974
 975    /*
 976     * Shifted is backwards, normal is forward.
 977     */
 978    if (qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
 979       cd->cd_Active--;
 980    else
 981       cd->cd_Active++;
 982
 983    if (cd->cd_Active < 0) cd->cd_Active = cd->cd_NumLabels;
 984    if (cd->cd_Active > cd->cd_NumLabels) cd->cd_Active = 0;
 985
 986    /*
 987     * Setup and re-render.
 988     */
 989    DoSetMethodNG(cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[cd->cd_Active], LAB_Place, PLACE_IN, TAG_END);
 990    DoNotifyMethod(obj, wmki->wmki_GInfo, 0, GA_ID, GADGET(obj)->GadgetID, CYC_Active, cd->cd_Active, TAG_END);
 991    DoRenderMethod(obj, wmki->wmki_GInfo, GREDRAW_REDRAW);
 992
 993    /*
 994     * Setup object ID.
 995     */
 996    *(wmki->wmki_ID) = GADGET(obj)->GadgetID;
 997
 998    return WMKF_VERIFY;
 999 }
1000 METHOD_END
1001 ///
1002
1003 /// Class initialization.
1004 /*
1005  * Function table.
1006  */
1007 STATIC DPFUNC ClassFunc[] = {
1008    BASE_RENDER,      (FUNCPTR)CycleClassRender,
1009    GM_RENDER,        (FUNCPTR)CycleClassRenderX,
1010    BASE_DIMENSIONS,  (FUNCPTR)CycleClassDimensions,
1011
1012    OM_NEW,           (FUNCPTR)CycleClassNew,
1013    OM_SET,           (FUNCPTR)CycleClassSetUpdate,
1014    OM_UPDATE,        (FUNCPTR)CycleClassSetUpdate,
1015    OM_GET,           (FUNCPTR)CycleClassGet,
1016    OM_DISPOSE,       (FUNCPTR)CycleClassDispose,
1017    GM_GOACTIVE,      (FUNCPTR)CycleClassGoActive,
1018    GM_HANDLEINPUT,   (FUNCPTR)CycleClassHandleInput,
1019    GM_GOINACTIVE,    (FUNCPTR)CycleClassGoInactive,
1020    WM_KEYACTIVE,     (FUNCPTR)CycleClassKeyActive,
1021    DF_END,           NULL,
1022 };
1023
1024 /*
1025  * Simple class initialization.
1026  */
1027 makeproto Class *InitCycleClass(void)
1028 {
1029    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
1030                          CLASS_ObjectSize,     sizeof(CD),
1031                          CLASS_DFTable,        ClassFunc,
1032                          TAG_DONE);
1033 }
1034 ///