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    IPTR            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    ULONG               oact = cd->cd_Active;
 169    IPTR                data;
 170    struct TagItem *tstate = opu->opu_AttrList;
 171    struct TagItem     *tag;
 172    WORD                dis = GADGET(obj)->Flags & GFLG_DISABLED;
 173    UBYTE             **new_labels = NULL;
 174    int                 num_labels;
 175    BOOL                render = FALSE;
 176    struct GadgetInfo  *gi = opu->opu_GInfo;
 177
 178    /*
 179     * First let the superclass do its thing.
 180     */
 181    AsmDoSuperMethodA(cl, obj, (Msg)opu);
 182
 183    /*
 184     * Force the correct activation method.
 185     */
 186    GADGET(obj)->Activation |= GACT_RELVERIFY;
 187    GADGET(obj)->Activation &= ~GACT_IMMEDIATE;
 188
 189    while ((tag = NextTagItem(&tstate)))
 190    {
 191       data = tag->ti_Data;
 192       switch (tag->ti_Tag)
 193       {
 194       case BT_TextAttr:
 195          cd->cd_PopupFont = (struct TextAttr *)data;
 196          /*
 197           * Let the label know.
 198           */
 199          DoSetMethodNG(cd->cd_ArrayLabel, LAB_TextAttr, data, TAG_DONE);
 200          break;
 201
 202       case FRM_ThinFrame:
 203          if (data) cd->cd_Flags |= CDF_THIN;
 204          else      cd->cd_Flags &= ~CDF_THIN;
 205          break;
 206
 207       case CYC_Active:
 208          cd->cd_Active = data;
 209          break;
 210
 211       case CYC_Labels:
 212          /*
 213           * Count the number of labels in the array (offset by 1).
 214           */
 215          num_labels = data ? CountLabels((UBYTE **)data) : -1;
 216
 217          if (num_labels >= 0)
 218          {
 219             if ((new_labels = BGUI_AllocPoolMem((num_labels + 2) * sizeof(UBYTE *))))
 220             {
 221                if (cd->cd_Labels) BGUI_FreePoolMem(cd->cd_Labels);
 222                cd->cd_Labels    = new_labels;
 223                cd->cd_NumLabels = num_labels;
 224                CopyMem((UBYTE *)data, (UBYTE *)new_labels, (num_labels + 1) * sizeof(UBYTE *));
 225             };
 226          };
 227          render = TRUE;
 228          break;
 229
 230       case CYC_Popup:
 231          if (data) cd->cd_Flags |= CDF_POPUP;
 232          else      cd->cd_Flags &= ~CDF_POPUP;
 233          break;
 234
 235       case CYC_PopActive:
 236          if (data) cd->cd_Flags |= CDF_POPACTIVE;
 237          else      cd->cd_Flags &= ~CDF_POPACTIVE;
 238          break;
 239       };
 240    };
 241
 242    if ((GADGET(obj)->Flags & GFLG_DISABLED) != dis)
 243       /*
 244        * Re-render when the gadget disabled state changed.
 245        */
 246       render = TRUE;
 247
 248    /*
 249     * Here's that sanity check again.
 250     */
 251    if (cd->cd_Active > cd->cd_NumLabels)
 252        cd->cd_Active = cd->cd_NumLabels;
 253
 254    if ((oact != cd->cd_Active) || new_labels)
 255    {
 256       /*
 257        * Setup new text.
 258        */
 259       DoSetMethodNG(cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[cd->cd_Active], LAB_Place, PLACE_IN, TAG_DONE);
 260       render = TRUE;
 261    };
 262
 263    if (render) DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 264
 265    /*
 266     * Notify the target when necessary.
 267     */
 268    if (oact != cd->cd_Active)
 269    {
 270       DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, CYC_Active, cd->cd_Active, TAG_DONE);
 271    }
 272    return 1;
 273 }
 274 METHOD_END
 275 ///
 276
 277 /// RenderArrow
 278 /*
 279  * Render the cycle arrow.
 280  */
 281 STATIC VOID RenderArrow(struct BaseInfo *bi, struct IBox *ib, ULONG state, CD *cd)
 282 {
 283    Object   *image = cd->cd_Image;
 284    ULONG     type;
 285
 286    /*
 287     * Get coords.
 288     */
 289    int w = cd->cd_ImageWidth;
 290    int h = ib->Height;
 291    int l = ib->Left - w;
 292    int t = ib->Top;
 293
 294    /*
 295     * Render the small seperator.
 296     */
 297    BSetDrMd(bi, JAM1);
 298
 299    BSetDPenA(bi, (state != IDS_SELECTED) ? SHINEPEN : SHADOWPEN);
 300    VLine(bi->bi_RPort, l + w + 1, t + 2, t + h - 3);
 301
 302    BSetDPenA(bi, (state != IDS_SELECTED) ? SHADOWPEN : SHINEPEN);
 303    VLine(bi->bi_RPort, l + w, t + 2, t + h - 3);
 304
 305    if (state == IDS_SELECTED)
 306    {
 307       type = BUILTIN_CYCLE2;
 308    }
 309    else
 310    {
 311       type = (cd->cd_Flags & CDF_POPUP) ? BUILTIN_POPUP : BUILTIN_CYCLE;
 312    };
 313
 314    /*
 315     * Setup and render the image.
 316     */
 317    DoSetMethodNG(image, VIT_BuiltIn, type, IA_Left, l, IA_Top, t, IA_Width, w, IA_Height, h, TAG_END);
 318    BDrawImageState(bi, image, 0, 0, state);
 319 }
 320 ///
 321 /// RenderPopupEntry
 322 /*
 323  * Render an entry in the popup-list.
 324  */
 325 STATIC VOID RenderPopupEntry(struct BaseInfo *bi, CD *cd, ULONG num, BOOL sel)
 326 {
 327    UWORD            ypos, xpos, tlen, pix = cd->cd_Flags & CDF_THIN ? 2 : 4;
 328    UBYTE           *name = cd->cd_Labels[num];
 329    struct RastPort *rp = bi->bi_RPort;
 330
 331    /*
 332     * Compute text length.
 333     */
 334    tlen = TextWidth(rp, name);
 335
 336    /*
 337     * Compute positions.
 338     */
 339    xpos = (cd->cd_PopWindow->Width - tlen) >> 1;
 340    ypos = (num * rp->TxHeight)  + 2;
 341
 342    /*
 343     * Setup pens for filling.
 344     */
 345    #ifdef ENHANCED
 346    BSetDPenA(bi, sel ? BARDETAILPEN : BARBLOCKPEN);
 347    #else
 348    if (OS30) BSetDPenA(bi, sel ? BARDETAILPEN : BARBLOCKPEN);
 349    else      BSetDPenA(bi, BLOCKPEN);
 350    #endif
 351
 352    /*
 353     * RectFill entry.
 354     */
 355    BSetDrMd(bi, JAM1);
 356    BRectFill(bi, pix, ypos, cd->cd_PopWindow->Width - pix - 1, ypos + rp->TxHeight - 1);
 357
 358    /*
 359     * Setup drawmode.
 360     */
 361    #ifdef ENHANCED
 362    BSetDrMd(bi, sel ? JAM2|INVERSVID : JAM2);
 363    #else
 364    if (OS30) BSetDrMd(bi, sel ? JAM2|INVERSVID : JAM2);
 365    else      BSetDrMd(bi, JAM2);
 366    #endif
 367
 368    /*
 369     * Setup pens for text.
 370     */
 371    BSetDPenA(bi, BARDETAILPEN);
 372    BSetDPenB(bi, BARBLOCKPEN);
 373
 374    /*
 375     * Move to the desired location and render.
 376     */
 377    Move(rp, xpos, ypos + rp->TxBaseline);
 378    Text(rp, name, strlen(name));
 379
 380    #ifndef ENHANCED
 381    /*
 382     * < OS 3.0 will get the entry
 383     * complemented if it is selected.
 384     */
 385    if (!OS30 && sel)
 386    {
 387       BSetDrMd(bi, JAM2|COMPLEMENT);
 388       BRectFill(bi, pix, ypos, cd->cd_PopWindow->Width - pix - 1, ypos + rp->TxHeight - 1);
 389    }
 390    #endif
 391 }
 392 ///
 393 /// GM_RENDER
 394 /*
 395  * Render the object.
 396  */
 397 METHOD(CycleClassRenderX, struct gpRender *, gpr)
 398 {
 399    CD              *cd = INST_DATA(cl, obj);
 400
 401    DoSuperSetMethodNG(cl, obj, BT_LeftOffset, cd->cd_ImageWidth, TAG_DONE);
 402
 403    return AsmDoSuperMethodA(cl, obj, (Msg)gpr);
 404 }
 405 METHOD_END
 406 ///
 407 /// BASE_RENDER
 408 /*
 409  * Render the object.
 410  */
 411 METHOD(CycleClassRender, struct bmRender *, bmr)
 412 {
 413    CD              *cd = INST_DATA(cl, obj);
 414    BC              *bc = BASE_DATA(obj);
 415    struct BaseInfo *bi = bmr->bmr_BInfo;
 416    int              state = GADGET(obj)->Flags & GFLG_SELECTED ? IDS_SELECTED : IDS_NORMAL;
 417
 418    /*
 419     * Render the baseclass.
 420     */
 421    AsmDoSuperMethodA(cl, obj, (Msg)bmr);
 422
 423    /*
 424     * Setup array label.
 425     */
 426    *IMAGEBOX(cd->cd_ArrayLabel) = bc->bc_InnerBox;
 427
 428    /*
 429     * Render the arrow.
 430     */
 431    RenderArrow(bi, &bc->bc_InnerBox, state, cd);
 432
 433    /*
 434     * We always render the active gadget label.
 435     */
 436    BDrawImageState(bi, cd->cd_ArrayLabel, 0, 0, state);
 437
 438    /*
 439     * Ghost the gadget when it is disabled.
 440     */
 441    if (GADGET(obj)->Flags & GFLG_DISABLED)
 442       BDisableBox(bi, &bc->bc_HitBox);
 443
 444    return 1;
 445 }
 446 METHOD_END
 447 ///
 448
 449 /// OpenPopupWindow
 450 /*
 451  * Open the popup-window.
 452  */
 453 STATIC ASM IPTR OpenPopupWindow(REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct gpInput *gpi)
 454 {
 455    CD                   *cd = INST_DATA(cl, obj);
 456    BC                   *bc = BASE_DATA(obj);
 457    UWORD                 max_items, num_items, wleft, wtop, wwi, wwh, i;
 458    struct IBox          *ibox;
 459    struct RastPort      *rp;
 460    struct GadgetInfo    *gi = gpi->gpi_GInfo;
 461    struct BaseInfo      *bi;
 462    int                   ysize;
 463    ULONG                 rc = GMR_NOREUSE;
 464
 465    /*
 466     * Get the gadget hitbox bounds.
 467     */
 468    Get_SuperAttr(cl, obj, BT_HitBox, (IPTR *)&ibox);
 469
 470    /*
 471     * Open the font.
 472     */
 473    if (cd->cd_PopupFont)
 474       cd->cd_Font = BGUI_OpenFont(cd->cd_PopupFont);
 475
 476    /* BAD CODE! Does not check OpenFont result! */
 477
 478    ysize = cd->cd_Font->tf_YSize;
 479
 480    /*
 481     * How many items will fit?
 482     */
 483    max_items = (gi->gi_Screen->Height - 4) / ysize;
 484
 485    /*
 486     * How many do we have?
 487     */
 488    num_items = (cd->cd_NumLabels + 1) > max_items ? max_items : (cd->cd_NumLabels + 1);
 489
 490    /*
 491     * Compute window position and dimensions.
 492     */
 493    wleft = bc->bc_HitBox.Left + gi->gi_Window->LeftEdge;
 494    wwi   = bc->bc_HitBox.Width;
 495    wwh   = (num_items * ysize) + 4;
 496
 497    if (cd->cd_Flags & CDF_POPACTIVE)
 498       wtop = gi->gi_Screen->MouseY - (2 + ((cd->cd_Active * ysize) + (ysize >> 1)));
 499    else
 500       wtop = bc->bc_HitBox.Top + bc->bc_HitBox.Height + gi->gi_Window->TopEdge;
 501
 502    /*
 503     * Pop the window.
 504     */
 505    cd->cd_PopWindow = OpenWindowTags(NULL, WA_Left,           wleft,   WA_Top,            wtop,
 506                                            WA_Width,          wwi,     WA_Height,         wwh,
 507                                            WA_Flags,          0,       WA_IDCMP,          0,
 508                                            WA_Borderless,     TRUE,    WA_AutoAdjust,     TRUE,
 509                                            WA_SmartRefresh,   TRUE,    WA_NoCareRefresh,  TRUE,
 510                                            WA_RMBTrap,        TRUE,    WA_CustomScreen,   gi->gi_Screen,
 511                                            TAG_DONE);
 512    /*
 513     * success?
 514     */
 515    if (cd->cd_PopWindow)
 516    {
 517       /*
 518        * No previous selected item.
 519        */
 520       cd->cd_Previous = (UWORD)~0;
 521
 522       /* AROS BUGFIX --> AMIGAOS BUGFIX: TAG_DONE missed in both AllocBaseInfoDebug and AllocBaseInfo call below */
 523 #ifdef DEBUG_BGUI
 524       if ((bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_Screen, gi->gi_Screen, BI_RastPort, rp = cd->cd_PopWindow->RPort, TAG_DONE)))
 525 #else
 526       if ((bi = AllocBaseInfo(BI_Screen, gi->gi_Screen, BI_RastPort, rp = cd->cd_PopWindow->RPort, TAG_DONE)))
 527 #endif
 528       {
 529          /*
 530           * Setup the font.
 531           */
 532          if (cd->cd_Font) BSetFont(bi, cd->cd_Font);
 533
 534          /*
 535           * Setup pop window rastport.
 536           */
 537          BSetDPenA(bi, BARBLOCKPEN);
 538          BSetDrMd(bi, JAM1);
 539
 540          /*
 541           * Fill...
 542           */
 543          BBoxFill(bi, 0, 0, wwi, wwh);
 544
 545          /*
 546           * Setup pop window rastport.
 547           */
 548          BSetDPenA(bi, BARDETAILPEN);
 549
 550          /*
 551           * Render border.
 552           */
 553          Move(rp, 0, 0 );
 554          Draw(rp, wwi - 1, 0);
 555          Draw(rp, wwi - 1, wwh - 1 );
 556          Draw(rp, 0, wwh - 1 );
 557          Draw(rp, 0, 0 );
 558
 559          if (!(cd->cd_Flags & CDF_THIN))
 560          {
 561             Move(rp, 1, 0 );
 562             Draw(rp, 1, wwh - 1 );
 563             Move(rp, wwi - 2, 0 );
 564             Draw(rp, wwi - 2, wwh - 1 );
 565          }
 566
 567          /*
 568           * Render list-entries.
 569           */
 570          for (i = 0; i < num_items; i++)
 571             RenderPopupEntry(bi, cd, i, FALSE);
 572
 573          FreeBaseInfo(bi);
 574
 575          rc = GMR_MEACTIVE;
 576       };
 577    }
 578    return rc;
 579 }
 580 ///
 581
 582 /// GM_GOACTIVE
 583 /*
 584  * Go in active mode.
 585  */
 586 METHOD(CycleClassGoActive, struct gpInput *, gpi)
 587 {
 588    CD          *cd = INST_DATA(cl, obj);
 589    BC          *bc = BASE_DATA(obj);
 590    ULONG        rc = GMR_NOREUSE;
 591
 592    /*
 593     * We don't go active when we are disabled.
 594     */
 595    if ( GADGET( obj )->Flags & GFLG_DISABLED )
 596       return( GMR_NOREUSE );
 597
 598    /*
 599     * We only go active when triggered by a mouse click.
 600     */
 601    if (gpi->gpi_IEvent)
 602    {
 603       /*
 604        * Let the superclass have a go...
 605        */
 606       AsmDoSuperMethodA(cl, obj, (Msg)gpi);
 607
 608       /*
 609        * Popup mode?
 610        */
 611       if (cd->cd_Flags & CDF_POPUP)
 612       {
 613          if (gpi->gpi_GInfo->gi_Window->MouseX > (bc->bc_HitBox.Left + cd->cd_ImageWidth))
 614          {
 615             /*
 616              * Open the popup window.
 617              * Do normal selection if the popup window will not open.
 618              */
 619             if (OpenPopupWindow(cl, obj, gpi) == 0) return 0;
 620          };
 621       };
 622       GADGET(obj)->Flags |= GFLG_SELECTED;
 623       DoRenderMethod(obj, gpi->gpi_GInfo, GREDRAW_REDRAW);
 624       rc = GMR_MEACTIVE;
 625    }
 626    return rc;
 627 }
 628 METHOD_END
 629 ///
 630
 631 /*
 632  * Which entry is selected?
 633  */
 634 STATIC ASM UWORD Selected(REG(a0) CD *cd, REG(a1) struct RastPort *rp)
 635 {
 636    WORD        mx = cd->cd_PopWindow->MouseX, my = cd->cd_PopWindow->MouseY;
 637    LONG        item = ~0;
 638
 639    /*
 640     *  Mouse in the window?
 641     */
 642    if ( mx >= 4 && mx < ( cd->cd_PopWindow->Width - 4 ) && my >= 2 && my < ( cd->cd_PopWindow->Height - 2 )) {
 643       /*
 644        * Find the entry the mouse is over.
 645        */
 646       item = ( my - 2 ) / rp->TxHeight;
 647
 648       if ( item > cd->cd_NumLabels ) item = ~0;
 649    }
 650    return(( UWORD )item );
 651 }
 652
 653 /// GM_HANDLEINPUT
 654 /*
 655  * Handle the gadget input.
 656  */
 657 METHOD(CycleClassHandleInput, struct gpInput *, gpi)
 658 {
 659    CD                   *cd = INST_DATA(cl, obj);
 660    struct gpHitTest      gph;
 661    WORD                  sel = 0, item;
 662    struct GadgetInfo    *gi = gpi->gpi_GInfo;
 663    struct BaseInfo      *bi;
 664    ULONG                 rc = GMR_MEACTIVE;
 665
 666    /*
 667     * Window up?
 668     */
 669    if (cd->cd_PopWindow)
 670    {
 671       /*
 672        * Is the parent window still activated?
 673        * If not we return immediatly.
 674        *
 675        * Security. Intuition should do this already.
 676        */
 677       if (!(gi->gi_Window->Flags & WFLG_WINDOWACTIVE))
 678          return GMR_NOREUSE;
 679
 680 #ifdef DEBUG_BGUI
 681       if ((bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, cd->cd_PopWindow->RPort, TAG_DONE)))
 682 #else
 683       if ((bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, cd->cd_PopWindow->RPort, TAG_DONE)))
 684 #endif
 685       {
 686          /*
 687           * Where is the mouse?
 688           */
 689          item = Selected(cd, bi->bi_RPort);
 690
 691          /*
 692           * Changed?
 693           */
 694          if (item != cd->cd_Previous)
 695          {
 696             /*
 697              * Previous selected item?
 698              */
 699             if (cd->cd_Previous != (UWORD)~0) RenderPopupEntry(bi, cd, cd->cd_Previous, FALSE);
 700
 701             /*
 702              * Render current entry.
 703              */
 704             if (item != ~0) RenderPopupEntry(bi, cd, item, TRUE);
 705
 706             /*
 707              * Setup item.
 708              */
 709             cd->cd_Previous = item;
 710          }
 711          FreeBaseInfo(bi);
 712
 713          /*
 714           * What's the event?
 715           */
 716          if (gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
 717          {
 718             switch (gpi->gpi_IEvent->ie_Code)
 719             {
 720             case SELECTUP:
 721                /*
 722                 * Setup the new label and return VERIFY.
 723                 */
 724                if (cd->cd_Previous != (UWORD)~0)
 725                {
 726                   if (cd->cd_Active != cd->cd_Previous)
 727                   {
 728                      /*
 729                       * We need notification.
 730                       */
 731                      cd->cd_Flags |= CDF_NOTIFY;
 732
 733                      /*
 734                       * New active entry.
 735                       */
 736                      cd->cd_Active = cd->cd_Previous;
 737
 738                      /*
 739                       * Setup the new label.
 740                       */
 741                      DoSetMethodNG(cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[cd->cd_Active], LAB_Place, PLACE_IN, TAG_END);
 742
 743                      /*
 744                       * Re-render to show the change.
 745                       */
 746                      DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 747
 748                      /*
 749                       * We want to notify about the attribute change.
 750                       */
 751                      rc = GMR_NOREUSE | GMR_VERIFY;
 752                   } else
 753                      rc = GMR_NOREUSE;
 754                } else
 755                   rc = GMR_NOREUSE;
 756                break;
 757
 758             case MENUDOWN:
 759                rc = GMR_NOREUSE;
 760                break;
 761             }
 762          }
 763       }
 764    }
 765    else
 766    {
 767       /*
 768        * Mouse over the object?
 769        */
 770       gph.MethodID      = GM_HITTEST;
 771       gph.gpht_GInfo    = gpi->gpi_GInfo;
 772       gph.gpht_Mouse.X  = gpi->gpi_Mouse.X;
 773       gph.gpht_Mouse.Y  = gpi->gpi_Mouse.Y;
 774
 775       if ( AsmDoMethodA( obj, ( Msg )&gph ) == GMR_GADGETHIT )
 776          sel = GFLG_SELECTED;
 777
 778       if ( gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE ) {
 779          switch ( gpi->gpi_IEvent->ie_Code ) {
 780
 781             case  SELECTUP:
 782                /*
 783                 * When we are selected we setup a new label
 784                 * and return VERIFY.
 785                 */
 786                if ( sel ) {
 787                   /*
 788                    * Clicked with the shift key down cycles backward.
 789                    */
 790                   if ( gpi->gpi_IEvent->ie_Qualifier & ( IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT )) {
 791                      if ( cd->cd_Active )       cd->cd_Active--;
 792                      else              cd->cd_Active = cd->cd_NumLabels;
 793                   } else {
 794                      if ( cd->cd_Active < cd->cd_NumLabels ) cd->cd_Active++;
 795                      else              cd->cd_Active = 0;
 796                   }
 797
 798                   /*
 799                    * Setup the new label.
 800                    */
 801                   DoSetMethodNG( cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[ cd->cd_Active ], LAB_Place, PLACE_IN, TAG_END  );
 802
 803                   /*
 804                    * We want to notify about the attribute change.
 805                    */
 806                   rc = GMR_NOREUSE | GMR_VERIFY;
 807                   cd->cd_Flags |= CDF_NOTIFY;
 808                } else
 809                   /*
 810                    * We are not selected anymore.
 811                    */
 812                   rc = GMR_NOREUSE;
 813
 814                sel = 0;
 815                break;
 816
 817             case  MENUDOWN:
 818                sel = 0;
 819                rc = GMR_REUSE;
 820                break;
 821          }
 822       }
 823
 824       /*
 825        * Do we need a visual change?
 826        */
 827       if ((GADGET(obj)->Flags & GFLG_SELECTED) != sel)
 828       {
 829          /*
 830           * Toggle the selected bit.
 831           */
 832          GADGET(obj)->Flags ^= GFLG_SELECTED;
 833
 834          /*
 835           * Re-render the gadget.
 836           */
 837          DoRenderMethod(obj, gi, GREDRAW_REDRAW);
 838       };
 839    };
 840    return rc;
 841 }
 842 METHOD_END
 843 ///
 844 /// GM_GOINACTIVE
 845
 846 METHOD(CycleClassGoInactive, struct gpGoInactive *, gpgi)
 847 {
 848    CD          *cd = INST_DATA( cl, obj );
 849
 850    /*
 851     * Popup window open?
 852     */
 853    if ( cd->cd_PopWindow ) {
 854       /*
 855        * Close the window.
 856        */
 857       CloseWindow( cd->cd_PopWindow );
 858       cd->cd_PopWindow = NULL;
 859    }
 860
 861    /*
 862     * Close the font.
 863     */
 864    if ( cd->cd_Font ) {
 865       BGUI_CloseFont( cd->cd_Font );
 866       cd->cd_Font = NULL;
 867    }
 868
 869    /*
 870     * Notify?
 871     */
 872    if ( cd->cd_Flags & CDF_NOTIFY ) {
 873       DoNotifyMethod( obj, gpgi->gpgi_GInfo, 0L, GA_ID, GADGET( obj )->GadgetID, CYC_Active, cd->cd_Active, TAG_END  );
 874       cd->cd_Flags &= ~CDF_NOTIFY;
 875    }
 876
 877    return( AsmDoSuperMethodA( cl, obj, ( Msg )gpgi ));
 878 }
 879 METHOD_END
 880 /// OM_GET
 881 /// OM_GET
 882 /*
 883  * Get an attribute.
 884  */
 885 METHOD(CycleClassGet, struct opGet *, opg)
 886 {
 887    CD        *cd = INST_DATA(cl, obj);
 888    ULONG      rc = 1;
 889    IPTR      *store = opg->opg_Storage;
 890
 891    switch (opg->opg_AttrID)
 892    {
 893    case CYC_Active:
 894       STORE cd->cd_Active;
 895       break;
 896
 897    case CYC_Popup:
 898       STORE cd->cd_Flags & CDF_POPUP;
 899       break;
 900
 901    case CYC_PopActive:
 902       STORE cd->cd_Flags & CDF_POPACTIVE;
 903       break;
 904
 905    default:
 906       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 907       break;
 908    }
 909    return rc;
 910 }
 911 METHOD_END
 912 ///
 913 /// OM_DISPOSE
 914 /*
 915  * Dispose of the object.
 916  */
 917 METHOD(CycleClassDispose, Msg, msg)
 918 {
 919    CD       *cd = INST_DATA(cl, obj);
 920
 921    if (cd->cd_ArrayLabel)
 922       DisposeObject(cd->cd_ArrayLabel);
 923    if (cd->cd_Image)
 924       DisposeObject(cd->cd_Image);
 925
 926    if (cd->cd_Labels)
 927       BGUI_FreePoolMem(cd->cd_Labels);
 928
 929    return AsmDoSuperMethodA(cl, obj, msg);
 930 }
 931 METHOD_END
 932 ///
 933 /// BASE_DIMENSIONS
 934 /*
 935  * The object size is requested.
 936  */
 937 METHOD(CycleClassDimensions, struct bmDimensions *, bmd)
 938 {
 939    CD                *cd = INST_DATA(cl, obj);
 940    struct BaseInfo   *bi = bmd->bmd_BInfo;
 941    UBYTE            **labels = cd->cd_Labels, *label;
 942    int                mw = 0, mh = 0;
 943    struct TextExtent  te;
 944
 945    /*
 946     * Find out the size of the largest label.
 947     */
 948    while ((label = *labels++))
 949    {
 950       /*
 951        * Call TextExtent to find out the text width.
 952        */
 953       TextExtent(bi->bi_RPort, label, strlen(label), &te);
 954       if (te.te_Width  > mw) mw = te.te_Width;
 955       if (te.te_Height > mh) mh = te.te_Height;
 956    };
 957
 958    /*
 959     * Include cycle/popup image width.
 960     */
 961    return CalcDimensions(cl, obj, bmd, mw + 30, mh + 2);
 962 }
 963 METHOD_END
 964 ///
 965 /// WM_KEYACTIVE
 966 /*
 967  * Key activation.
 968  */
 969 METHOD(CycleClassKeyActive, struct wmKeyInput *, wmki)
 970 {
 971    CD       *cd = INST_DATA(cl, obj);
 972    UWORD     qual = wmki->wmki_IEvent->ie_Qualifier;
 973
 974    /*
 975     * Shifted is backwards, normal is forward.
 976     */
 977    if (qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
 978       cd->cd_Active--;
 979    else
 980       cd->cd_Active++;
 981
 982    if (cd->cd_Active < 0) cd->cd_Active = cd->cd_NumLabels;
 983    if (cd->cd_Active > cd->cd_NumLabels) cd->cd_Active = 0;
 984
 985    /*
 986     * Setup and re-render.
 987     */
 988    DoSetMethodNG(cd->cd_ArrayLabel, LAB_Label, cd->cd_Labels[cd->cd_Active], LAB_Place, PLACE_IN, TAG_END);
 989    DoNotifyMethod(obj, wmki->wmki_GInfo, 0, GA_ID, GADGET(obj)->GadgetID, CYC_Active, cd->cd_Active, TAG_END);
 990    DoRenderMethod(obj, wmki->wmki_GInfo, GREDRAW_REDRAW);
 991
 992    /*
 993     * Setup object ID.
 994     */
 995    *(wmki->wmki_ID) = GADGET(obj)->GadgetID;
 996
 997    return WMKF_VERIFY;
 998 }
 999 METHOD_END
1000 ///
1001
1002 /// Class initialization.
1003 /*
1004  * Function table.
1005  */
1006 STATIC DPFUNC ClassFunc[] = {
1007    { BASE_RENDER,      CycleClassRender, },
1008    { GM_RENDER,        CycleClassRenderX, },
1009    { BASE_DIMENSIONS,  CycleClassDimensions, },
1010
1011    { OM_NEW,           CycleClassNew, },
1012    { OM_SET,           CycleClassSetUpdate, },
1013    { OM_UPDATE,        CycleClassSetUpdate, },
1014    { OM_GET,           CycleClassGet, },
1015    { OM_DISPOSE,       CycleClassDispose, },
1016    { GM_GOACTIVE,      CycleClassGoActive, },
1017    { GM_HANDLEINPUT,   CycleClassHandleInput, },
1018    { GM_GOINACTIVE,    CycleClassGoInactive, },
1019    { WM_KEYACTIVE,     CycleClassKeyActive, },
1020    { DF_END,           NULL, },
1021 };
1022
1023 /*
1024  * Simple class initialization.
1025  */
1026 makeproto Class *InitCycleClass(void)
1027 {
1028    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
1029                          CLASS_ObjectSize,     sizeof(CD),
1030                          CLASS_DFTable,        ClassFunc,
1031                          TAG_DONE);
1032 }
1033 ///