workbench/libs/muimaster/classes/cycle.c

   1 /*
   2     Copyright © 2002-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <graphics/gfx.h>
   7 #include <graphics/view.h>
   8 #include <clib/alib_protos.h>
   9 #include <proto/exec.h>
  10 #include <proto/graphics.h>
  11 #include <proto/utility.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14
  15 #include <string.h>
  16
  17 #include "debug.h"
  18
  19 #include "mui.h"
  20 #include "imspec.h"
  21 #include "muimaster_intern.h"
  22 #include "support.h"
  23 #include "prefs.h"
  24 #include "textengine.h"
  25
  26 extern struct Library *MUIMasterBase;
  27
  28 struct MUI_CycleData
  29 {
  30     const char **entries;
  31     int entries_active;
  32     int entries_num;
  33     int entries_width;
  34     int entries_height;
  35     int cycle_width;
  36     int cycle_height;
  37     Object *pageobj;
  38     Object *imgobj;
  39     struct MUI_EventHandlerNode ehn;
  40     struct Hook pressedhook;
  41     struct MUI_ImageSpec_intern *popbg;
  42     struct Window *popwin;
  43     WORD popitemwidth;
  44     WORD popitemheight;
  45     WORD popitemoffx;
  46     WORD popitemoffy;
  47     WORD activepopitem;
  48
  49 };
  50
  51 #define POPITEM_EXTRAWIDTH 4
  52 #define POPITEM_EXTRAHEIGHT 2
  53
  54 CONST_STRPTR default_entries[] =
  55 {
  56     (CONST_STRPTR) "",
  57     (CONST_STRPTR) NULL
  58 };
  59
  60 static void UpdateEntries(Object *obj, struct MUI_CycleData *data);
  61 static void KillPopupWin(Object *obj, struct MUI_CycleData *data);
  62
  63 void PressedHookFunc(struct Hook *hook, Object *obj, APTR msg)
  64 {
  65     struct MUI_CycleData *data;
  66     Class *cl = (Class *) hook->h_Data;
  67     LONG act;
  68
  69     data = INST_DATA(cl, obj);
  70
  71     act = ++data->entries_active;
  72     if (act >= data->entries_num)
  73         act = 0;
  74
  75     set(obj, MUIA_Cycle_Active, act);
  76 }
  77
  78 /**************************************************************************
  79 OM_NEW
  80 **************************************************************************/
  81 IPTR Cycle__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  82 {
  83     struct MUI_CycleData *data;
  84     struct TagItem *tag, *tags;
  85     Object *pageobj, *imgobj;
  86
  87     obj = (Object *) DoSuperNewTags
  88         (cl, obj, NULL,
  89         ButtonFrame,
  90         MUIA_Background, MUII_ButtonBack,
  91         MUIA_InputMode, MUIV_InputMode_RelVerify,
  92         MUIA_InnerTop, 1,
  93         MUIA_InnerBottom, 1,
  94         MUIA_Group_Horiz, TRUE,
  95         Child, (IPTR) (imgobj = ImageObject,
  96             MUIA_InnerLeft, 2,
  97             MUIA_Image_Spec, (IPTR) "6:17",
  98             MUIA_Image_FreeVert, TRUE,
  99             End),
 100         Child, (IPTR) (pageobj = PageGroup, End),
 101         TAG_MORE, (IPTR) msg->ops_AttrList);
 102
 103     if (!obj)
 104         return FALSE;
 105
 106     data = INST_DATA(cl, obj);
 107
 108     data->pageobj = pageobj;
 109     data->imgobj = imgobj;
 110
 111     data->pressedhook.h_Entry = HookEntry;
 112     data->pressedhook.h_SubEntry = (HOOKFUNC) PressedHookFunc;
 113     data->pressedhook.h_Data = cl;
 114
 115     data->entries = (const char **)default_entries;
 116
 117     /* parse initial taglist */
 118
 119     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 120     {
 121         switch (tag->ti_Tag)
 122         {
 123         case MUIA_Cycle_Entries:
 124             data->entries = (const char **)tag->ti_Data;
 125             break;
 126
 127         case MUIA_Cycle_Active:
 128             data->entries_active = tag->ti_Data;
 129             break;
 130         }
 131     }
 132
 133     UpdateEntries(obj, data);
 134
 135     if ((data->entries_active >= 0)
 136         && (data->entries_active < data->entries_num))
 137     {
 138         set(pageobj, MUIA_Group_ActivePage, data->entries_active);
 139     }
 140     else
 141     {
 142         data->entries_active = 0;
 143     }
 144
 145 #if 1
 146     DoMethod(obj, MUIM_Notify, MUIA_Pressed, FALSE,
 147         (IPTR) obj, 2, MUIM_CallHook, (IPTR) & data->pressedhook);
 148 #else
 149     DoMethod(imgobj, MUIM_Notify, MUIA_Pressed, FALSE,
 150         (IPTR) obj, 3, MUIM_Set, MUIA_Cycle_Active, MUIV_Cycle_Active_Next);
 151 #endif
 152
 153     return (IPTR) obj;
 154 }
 155
 156 /**************************************************************************
 157 OM_SET
 158 **************************************************************************/
 159 IPTR Cycle__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 160 {
 161     struct MUI_CycleData *data;
 162     struct TagItem *tag, *tags;
 163     struct opSet supMsg;
 164     BOOL noforward = TRUE;
 165     LONG l;
 166
 167     data = INST_DATA(cl, obj);
 168
 169     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 170     {
 171         switch (tag->ti_Tag)
 172         {
 173         case MUIA_Cycle_Entries:
 174             data->entries = (const char **)tag->ti_Data;
 175             DoMethod(data->pageobj, MUIM_Group_InitChange);
 176             UpdateEntries(obj, data);
 177             DoMethod(data->pageobj, MUIM_Group_ExitChange);
 178
 179             data->entries_active = 0;
 180             set(data->pageobj, MUIA_Group_ActivePage,
 181                 data->entries_active);
 182             break;
 183
 184         case MUIA_Cycle_Active:
 185             l = (LONG) tag->ti_Data;
 186
 187             if (l == MUIV_Cycle_Active_Next)
 188             {
 189                 l = data->entries_active + 1;
 190                 if (l >= data->entries_num)
 191                     l = 0;
 192             }
 193             else if (l == MUIV_Cycle_Active_Prev)
 194             {
 195                 l = data->entries_active - 1;
 196                 if (l < 0)
 197                     l = data->entries_num - 1;
 198             }
 199
 200             if (l >= 0 && l < data->entries_num)
 201             {
 202                 data->entries_active = l;
 203                 set(data->pageobj, MUIA_Group_ActivePage,
 204                     data->entries_active);
 205             }
 206             break;
 207
 208         default:
 209             noforward = FALSE;
 210             break;
 211         }
 212     }
 213
 214     if (noforward)
 215     {
 216         struct TagItem tags[] = {
 217             {MUIA_Group_Forward,        FALSE                   },
 218             {TAG_MORE,                  (IPTR)msg->ops_AttrList }
 219         };
 220         supMsg.MethodID = msg->MethodID;
 221         supMsg.ops_AttrList = tags;
 222         supMsg.ops_GInfo = msg->ops_GInfo;
 223
 224         return DoSuperMethodA(cl, obj, (Msg) & supMsg);
 225     }
 226     else
 227     {
 228         return DoSuperMethodA(cl, obj, (Msg) msg);
 229     }
 230 }
 231
 232 /**************************************************************************
 233 OM_GET
 234 **************************************************************************/
 235 IPTR Cycle__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 236 {
 237     struct MUI_CycleData *data = INST_DATA(cl, obj);
 238 #define STORE *(msg->opg_Storage)
 239
 240     switch (msg->opg_AttrID)
 241     {
 242     case MUIA_Cycle_Active:
 243         STORE = data->entries_active;
 244         return 1;
 245     }
 246
 247     return DoSuperMethodA(cl, obj, (Msg) msg);
 248 }
 249
 250 /**************************************************************************
 251 MUIM_Setup
 252 **************************************************************************/
 253 IPTR Cycle__MUIM_Setup(struct IClass *cl, Object *obj,
 254     struct MUIP_Setup *msg)
 255 {
 256     struct MUI_CycleData *data;
 257
 258     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 259         return 0;
 260
 261     data = INST_DATA(cl, obj);
 262
 263     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
 264     data->ehn.ehn_Priority = 1;
 265     data->ehn.ehn_Flags = 0;
 266     data->ehn.ehn_Object = obj;
 267     data->ehn.ehn_Class = cl;
 268
 269     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
 270
 271     return 1;
 272 }
 273
 274 /**************************************************************************
 275 MUIM_Cleanup
 276 **************************************************************************/
 277 IPTR Cycle__MUIM_Cleanup(struct IClass *cl, Object *obj,
 278     struct MUIP_Cleanup *msg)
 279 {
 280     struct MUI_CycleData *data = INST_DATA(cl, obj);
 281
 282     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
 283
 284     return DoSuperMethodA(cl, obj, (Msg) msg);
 285 }
 286
 287 static void UpdateEntries(Object *obj, struct MUI_CycleData *data)
 288 {
 289     struct MinList *childlist = NULL;
 290     Object *page, *cstate;
 291     UWORD i;
 292
 293     /* Ensure list isn't displayed while we update it */
 294     KillPopupWin(obj, data);
 295
 296     /* Destroy old entries */
 297     get(data->pageobj, MUIA_Group_ChildList, &childlist);
 298
 299     cstate = (Object *) childlist->mlh_Head;
 300     while ((page = NextObject(&cstate)))
 301     {
 302         DoMethod(data->pageobj, OM_REMMEMBER, (IPTR) page);
 303         DoMethod(page, OM_DISPOSE);
 304     }
 305
 306     /* Count the number of entries */
 307     for (i = 0; data->entries && data->entries[i]; i++)
 308     {
 309         page = TextObject,
 310             MUIA_Text_Contents, (IPTR) data->entries[i],
 311             MUIA_Text_PreParse, (IPTR) "\033c", End;
 312
 313         if (!page)
 314         {
 315             D(bug("Cycle_New: Could not create page object specified!\n"));
 316             break;
 317         }
 318
 319         DoMethod(data->pageobj, OM_ADDMEMBER, (IPTR) page);
 320     }
 321     data->entries_num = i;
 322 }
 323
 324 static void KillPopupWin(Object *obj, struct MUI_CycleData *data)
 325 {
 326     struct MinList *childlist = NULL;
 327     Object *child, *cstate;
 328
 329     if (data->popwin)
 330     {
 331         CloseWindow(data->popwin);
 332         data->popwin = NULL;
 333     }
 334
 335     if (data->popbg)
 336     {
 337         zune_imspec_hide(data->popbg);
 338         zune_imspec_cleanup(data->popbg);
 339         data->popbg = NULL;
 340     }
 341
 342     get(data->pageobj, MUIA_Group_ChildList, &childlist);
 343
 344     cstate = (Object *) childlist->mlh_Head;
 345     while ((child = NextObject(&cstate)))
 346     {
 347         ZText *text = NULL;
 348
 349         get(child, MUIA_UserData, &text);
 350         if (!text)
 351             break;
 352
 353         zune_text_destroy(text);
 354
 355         set(child, MUIA_UserData, 0);
 356     }
 357
 358     if (data->ehn.ehn_Events & IDCMP_MOUSEMOVE)
 359     {
 360         DoMethod(_win(obj), MUIM_Window_RemEventHandler,
 361             (IPTR) & data->ehn);
 362         data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
 363         DoMethod(_win(obj), MUIM_Window_AddEventHandler,
 364             (IPTR) & data->ehn);
 365     }
 366
 367 }
 368
 369 static void RenderPopupItem(Object *obj, struct MUI_CycleData *data,
 370     WORD which)
 371 {
 372     struct MinList *childlist = NULL;
 373     struct RastPort *saverp;
 374     Object *child, *cstate;
 375     ZText *text = NULL;
 376     WORD x1, y1, x2, y2, i = which;
 377
 378     get(data->pageobj, MUIA_Group_ChildList, &childlist);
 379     cstate = (Object *) childlist->mlh_Head;
 380
 381     while ((child = NextObject(&cstate)) && i--)
 382     {
 383     }
 384
 385     if (!child)
 386         return;
 387
 388     get(child, MUIA_UserData, &text);
 389     if (!text)
 390         return;                 /* paranoia */
 391
 392     saverp = _rp(obj);
 393     _rp(obj) = data->popwin->RPort;
 394
 395     x1 = data->popitemoffx;
 396     x2 = x1 + data->popitemwidth - 1;
 397     y1 = data->popitemoffy + which * data->popitemheight;
 398     y2 = y1 + data->popitemheight - 1;
 399
 400     if (which == data->activepopitem)
 401     {
 402         WORD off = 0;
 403
 404         if (muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_recessed_entries)
 405         {
 406             SetAPen(data->popwin->RPort, _pens(obj)[MPEN_SHADOW]);
 407             RectFill(data->popwin->RPort, x1, y1, x1, y2);
 408             RectFill(data->popwin->RPort, x1 + 1, y1, x2 - 1, y1);
 409             SetAPen(data->popwin->RPort, _pens(obj)[MPEN_SHINE]);
 410             RectFill(data->popwin->RPort, x2, y1, x2, y2);
 411             RectFill(data->popwin->RPort, x1 + 1, y2, x2 - 1, y2);
 412
 413             off = 1;
 414         }
 415
 416         SetAPen(data->popwin->RPort, _pens(obj)[MPEN_FILL]);
 417         RectFill(data->popwin->RPort, x1 + off, y1 + off, x2 - off,
 418             y2 - off);
 419     }
 420     else
 421     {
 422         if (data->popbg)
 423         {
 424             zune_imspec_draw(data->popbg, muiRenderInfo(obj),
 425                 x1, y1, x2 - x1 + 1, y2 - y1 + 1, x1, y1, 0);
 426         }
 427         else
 428         {
 429             SetAPen(data->popwin->RPort, 0);
 430             RectFill(data->popwin->RPort, x1, y1, x2, y2);
 431         }
 432     }
 433
 434     SetAPen(data->popwin->RPort, _pens(obj)[MPEN_TEXT]);
 435
 436     y1 += POPITEM_EXTRAHEIGHT / 2;
 437     if (muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_recessed_entries)
 438     {
 439         y1++;
 440     }
 441
 442     zune_text_draw(text, obj, x1, x2, y1);
 443
 444     _rp(obj) = saverp;
 445
 446 }
 447
 448 static BOOL MakePopupWin(Object *obj, struct MUI_CycleData *data)
 449 {
 450     const struct ZuneFrameGfx *zframe;
 451     struct MinList *childlist = NULL;
 452     struct RastPort *rp, *saverp;
 453     Object *child, *cstate;
 454     WORD x, y, winx, winy, winw, winh, i;
 455
 456     data->popitemwidth = 0;
 457     data->popitemheight = 0;
 458
 459     get(data->pageobj, MUIA_Group_ChildList, &childlist);
 460     cstate = (Object *) childlist->mlh_Head;
 461     while ((child = NextObject(&cstate)))
 462     {
 463         set(child, MUIA_UserData, 0);
 464     }
 465
 466     data->popitemwidth = _width(data->pageobj);
 467     data->popitemheight = _height(data->pageobj);
 468
 469     data->popitemwidth += POPITEM_EXTRAWIDTH;
 470     data->popitemheight += POPITEM_EXTRAHEIGHT;
 471
 472     if (muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_recessed_entries)
 473     {
 474         data->popitemwidth += 2;
 475         data->popitemheight += 2;
 476     }
 477
 478     zframe =
 479         zune_zframe_get(obj,
 480         &muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_PopUp]);
 481
 482     data->popitemoffx =
 483         muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_PopUp].innerLeft +
 484         zframe->ileft;
 485
 486     data->popitemoffy =
 487         muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_PopUp].innerTop +
 488         zframe->itop;
 489
 490     winw = data->popitemwidth + data->popitemoffx +
 491         muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_PopUp].innerRight +
 492         zframe->iright;
 493
 494     winh = data->popitemheight * data->entries_num + data->popitemoffy +
 495         muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_PopUp].
 496         innerBottom + zframe->ibottom;
 497
 498     if ((winw > _screen(obj)->Width) || (winh > _screen(obj)->Height))
 499     {
 500         return FALSE;
 501     }
 502
 503     i = 0;
 504     cstate = (Object *) childlist->mlh_Head;
 505     while ((child = NextObject(&cstate)))
 506     {
 507         ZText *text;
 508
 509         text = zune_text_new("\33c", data->entries[i++], ZTEXT_ARG_NONE, 0);
 510         if (!text)
 511             break;
 512
 513         zune_text_get_bounds(text, obj);
 514         set(child, MUIA_UserData, (IPTR) text);
 515     }
 516
 517     if (i != data->entries_num)
 518     {
 519         KillPopupWin(obj, data);
 520         return FALSE;
 521     }
 522
 523     data->popbg = zune_imspec_setup(MUII_PopupBack, muiRenderInfo(obj));
 524     if (data->popbg)
 525         zune_imspec_show(data->popbg, obj);
 526
 527     winx = _window(obj)->LeftEdge + _mleft(data->pageobj) -
 528         data->popitemoffx - POPITEM_EXTRAWIDTH / 2;
 529
 530     if (muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_position ==
 531         CYCLE_MENU_POSITION_BELOW)
 532     {
 533         winy = _window(obj)->TopEdge + _bottom(obj) + 1;
 534     }
 535     else
 536     {
 537         winy =
 538             _window(obj)->TopEdge + _mtop(data->pageobj) -
 539             data->popitemoffy - POPITEM_EXTRAHEIGHT / 2 -
 540             data->entries_active * data->popitemheight;
 541     }
 542
 543     data->popwin =
 544         OpenWindowTags(NULL, WA_CustomScreen, (IPTR) _screen(obj), WA_Left,
 545         winx, WA_Top, winy, WA_Width, winw, WA_Height, winh, WA_AutoAdjust,
 546         TRUE, WA_Borderless, TRUE, WA_Activate, FALSE, WA_BackFill,
 547         (IPTR) LAYERS_NOBACKFILL, TAG_DONE);
 548
 549     if (!data->popwin)
 550     {
 551         return FALSE;
 552     }
 553
 554     rp = data->popwin->RPort;
 555
 556     saverp = _rp(obj);
 557     _rp(obj) = rp;
 558     zframe->draw(zframe->customframe, muiRenderInfo(obj), 0, 0, winw, winh,
 559         0, 0, winw, winh);
 560
 561     /* FIXME: Render with popup background */
 562
 563     if (data->popbg)
 564     {
 565         zune_imspec_draw(data->popbg, muiRenderInfo(obj),
 566             zframe->ileft, zframe->itop,
 567             winw - zframe->ileft - zframe->iright,
 568             winh - zframe->itop - zframe->ibottom,
 569             zframe->ileft, zframe->itop, 0);
 570     }
 571     else
 572     {
 573         SetAPen(rp, 0);
 574         RectFill(rp, zframe->ileft, zframe->itop,
 575             winw - 1 - zframe->iright, winh - 1 - zframe->ibottom);
 576     }
 577
 578     x = data->popitemoffx;
 579     y = data->popitemoffy + POPITEM_EXTRAHEIGHT / 2;
 580
 581     if (muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_recessed_entries)
 582     {
 583         y++;
 584     }
 585
 586     i = 0;
 587     cstate = (Object *) childlist->mlh_Head;
 588     while ((child = NextObject(&cstate)))
 589     {
 590         ZText *text = NULL;
 591
 592         get(child, MUIA_UserData, &text);
 593
 594         SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
 595         if (text)               /* paranoia */
 596         {
 597             zune_text_draw(text, obj, x, x + data->popitemwidth - 1, y);
 598         }
 599
 600         y += data->popitemheight;
 601     }
 602
 603     _rp(obj) = saverp;
 604
 605     data->activepopitem = -1;
 606
 607     return TRUE;
 608
 609 }
 610
 611 /**************************************************************************
 612 MUIM_HandleEvent
 613 **************************************************************************/
 614 IPTR Cycle__MUIM_HandleEvent(struct IClass *cl, Object *obj,
 615     struct MUIP_HandleEvent *msg)
 616 {
 617     struct MUI_CycleData *data = INST_DATA(cl, obj);
 618     BOOL fallthroughtomousemove = FALSE;
 619
 620     if (msg->muikey != MUIKEY_NONE)
 621     {
 622         int old_active =
 623             data->popwin ? data->activepopitem : data->entries_active;
 624         int new_active = old_active;
 625         BOOL eat = FALSE;
 626
 627         switch (msg->muikey)
 628         {
 629         case MUIKEY_WINDOW_CLOSE:
 630             if (data->popwin)
 631             {
 632                 KillPopupWin(obj, data);
 633                 eat = TRUE;
 634             }
 635             break;
 636
 637         case MUIKEY_PRESS:
 638             if (data->entries_num <
 639                 muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_min_entries)
 640             {
 641                 /* fall through to MUIKEY_DOWN */
 642             }
 643             else if (!data->popwin)
 644             {
 645                 if (MakePopupWin(obj, data))
 646                 {
 647                     DoMethod(_win(obj), MUIM_Window_RemEventHandler,
 648                         (IPTR) & data->ehn);
 649                     data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
 650                     DoMethod(_win(obj), MUIM_Window_AddEventHandler,
 651                         (IPTR) & data->ehn);
 652                     eat = TRUE;
 653                     break;
 654                 }
 655                 else
 656                 {
 657                     /* fall through to MUIKEY_DOWN */
 658                 }
 659             }
 660             else if (data->popwin)
 661             {
 662                 KillPopupWin(obj, data);
 663                 if (new_active != -1)
 664                 {
 665                     set(obj, MUIA_Cycle_Active, new_active);
 666                 }
 667                 eat = TRUE;
 668                 break;
 669             }
 670             /* no break here, because of fall-throughs above */
 671
 672         case MUIKEY_DOWN:
 673             if (new_active < data->entries_num - 1)
 674             {
 675                 new_active++;
 676             }
 677             else if (!data->popwin)
 678             {
 679                 new_active = 0;
 680             }
 681
 682             eat = TRUE;
 683             break;
 684
 685         case MUIKEY_UP:
 686             if (new_active)
 687             {
 688                 new_active--;
 689             }
 690             else if (!data->popwin)
 691             {
 692                 new_active = data->entries_num - 1;
 693             }
 694
 695             eat = TRUE;
 696             break;
 697
 698         case MUIKEY_PAGEUP:
 699         case MUIKEY_TOP:
 700             new_active = 0;
 701             eat = TRUE;
 702             break;
 703
 704         case MUIKEY_PAGEDOWN:
 705         case MUIKEY_BOTTOM:
 706             new_active = data->entries_num - 1;
 707             eat = TRUE;
 708             break;
 709         }
 710
 711         if (new_active != old_active)
 712         {
 713             if (data->popwin)
 714             {
 715                 data->activepopitem = new_active;
 716
 717                 if (old_active != -1)
 718                     RenderPopupItem(obj, data, old_active);
 719                 if (new_active != -1)
 720                     RenderPopupItem(obj, data, new_active);
 721
 722             }
 723             else
 724             {
 725                 set(obj, MUIA_Cycle_Active, new_active);
 726             }
 727
 728         }
 729
 730         if (eat)
 731             return MUI_EventHandlerRC_Eat;
 732
 733     }
 734
 735     if (!msg->imsg ||
 736         data->entries_num <
 737         muiGlobalInfo(obj)->mgi_Prefs->cycle_menu_min_entries)
 738     {
 739         return 0;
 740     }
 741
 742     switch (msg->imsg->Class)
 743     {
 744     case IDCMP_MOUSEBUTTONS:
 745         switch (msg->imsg->Code)
 746         {
 747         case SELECTDOWN:
 748             if (_between(_right(data->imgobj) + 1, msg->imsg->MouseX,
 749                     _right(obj))
 750                 && _between(_top(obj), msg->imsg->MouseY, _bottom(obj))
 751                 && (muiAreaData(obj)->mad_Flags & MADF_CANDRAW)
 752                 && !data->popwin)
 753             {
 754                 if (MakePopupWin(obj, data))
 755                 {
 756                     DoMethod(_win(obj), MUIM_Window_RemEventHandler,
 757                         (IPTR) & data->ehn);
 758                     data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
 759                     DoMethod(_win(obj), MUIM_Window_AddEventHandler,
 760                         (IPTR) & data->ehn);
 761
 762                     fallthroughtomousemove = TRUE;
 763                 }
 764                 break;
 765             }
 766             else if (data->popwin)
 767             {
 768                 /* fall through to SELECTUP/MENUUP/MIDDLEUP */
 769             }
 770             else
 771             {
 772                 break;
 773             }
 774             /* no break here! */
 775
 776         case SELECTUP:
 777         case MENUUP:
 778         case MIDDLEUP:
 779         default:
 780             if (data->popwin)
 781             {
 782                 KillPopupWin(obj, data);
 783                 if ((data->activepopitem != -1) &&
 784                     ((msg->imsg->Code == SELECTUP)
 785                         || (msg->imsg->Code == SELECTDOWN)))
 786                 {
 787                     set(obj, MUIA_Cycle_Active, data->activepopitem);
 788                 }
 789                 return MUI_EventHandlerRC_Eat;
 790             }
 791             break;
 792
 793
 794         }
 795
 796         if (!fallthroughtomousemove)
 797         {
 798             break;
 799         }
 800
 801     case IDCMP_MOUSEMOVE:
 802         if (data->popwin)
 803         {
 804             WORD x = data->popwin->MouseX;
 805             WORD y = data->popwin->MouseY - data->popitemoffy;
 806             WORD newactive = -1;
 807
 808             if ((x >= 0) && (y >= 0) &&
 809                 (x < data->popwin->Width)
 810                 && (y < data->popitemheight * data->entries_num))
 811             {
 812                 newactive = y / data->popitemheight;
 813             }
 814
 815             if (newactive != data->activepopitem)
 816             {
 817                 WORD oldactive = data->activepopitem;
 818
 819                 data->activepopitem = newactive;
 820
 821                 if (oldactive != -1)
 822                     RenderPopupItem(obj, data, oldactive);
 823                 if (newactive != -1)
 824                     RenderPopupItem(obj, data, newactive);
 825
 826             }
 827
 828             return MUI_EventHandlerRC_Eat;
 829         }
 830         break;
 831
 832     }
 833
 834     return 0;
 835 }
 836
 837 /**************************************************************************
 838 MUIM_Hide
 839 **************************************************************************/
 840 IPTR Cycle__MUIM_Hide(struct IClass *cl, Object *obj,
 841     struct MUIP_Hide *msg)
 842 {
 843     struct MUI_CycleData *data = INST_DATA(cl, obj);
 844
 845     if (data->popwin)
 846     {
 847         KillPopupWin(obj, data);
 848     }
 849
 850     return DoSuperMethodA(cl, obj, (Msg) msg);
 851 }
 852
 853 /**************************************************************************
 854  MUIM_Export - to export an object's "contents" to a dataspace object.
 855 **************************************************************************/
 856 IPTR Cycle__MUIM_Export(struct IClass *cl, Object *obj,
 857     struct MUIP_Export *msg)
 858 {
 859     struct MUI_CycleData *data = INST_DATA(cl, obj);
 860     ULONG id;
 861
 862     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 863     {
 864         LONG value = data->entries_active;
 865         DoMethod(msg->dataspace, MUIM_Dataspace_Add,
 866             (IPTR) & value, sizeof(value), (IPTR) id);
 867     }
 868     return 0;
 869 }
 870
 871 /**************************************************************************
 872  MUIM_Import - to import an object's "contents" from a dataspace object.
 873 **************************************************************************/
 874 IPTR Cycle__MUIM_Import(struct IClass *cl, Object *obj,
 875     struct MUIP_Import *msg)
 876 {
 877     ULONG id;
 878     LONG *s;
 879
 880     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 881     {
 882         if ((s = (LONG *) DoMethod(msg->dataspace, MUIM_Dataspace_Find,
 883             (IPTR) id)))
 884         {
 885             set(obj, MUIA_Cycle_Active, *s);
 886         }
 887     }
 888     return 0;
 889 }
 890
 891 BOOPSI_DISPATCHER(IPTR, Cycle_Dispatcher, cl, obj, msg)
 892 {
 893     switch (msg->MethodID)
 894     {
 895     case OM_NEW:
 896         return Cycle__OM_NEW(cl, obj, (struct opSet *)msg);
 897     case OM_SET:
 898         return Cycle__OM_SET(cl, obj, (struct opSet *)msg);
 899     case OM_GET:
 900         return Cycle__OM_GET(cl, obj, (struct opGet *)msg);
 901     case MUIM_Setup:
 902         return Cycle__MUIM_Setup(cl, obj, (APTR) msg);
 903     case MUIM_Cleanup:
 904         return Cycle__MUIM_Cleanup(cl, obj, (APTR) msg);
 905     case MUIM_Hide:
 906         return Cycle__MUIM_Hide(cl, obj, (APTR) msg);
 907     case MUIM_HandleEvent:
 908         return Cycle__MUIM_HandleEvent(cl, obj, (APTR) msg);
 909     case MUIM_Export:
 910         return Cycle__MUIM_Export(cl, obj, (APTR) msg);
 911     case MUIM_Import:
 912         return Cycle__MUIM_Import(cl, obj, (APTR) msg);
 913     }
 914
 915     return DoSuperMethodA(cl, obj, msg);
 916 }
 917 BOOPSI_DISPATCHER_END
 918
 919 /*
 920 * Class descriptor.
 921 */
 922 const struct __MUIBuiltinClass _MUI_Cycle_desc =
 923 {
 924     MUIC_Cycle,
 925     MUIC_Group,
 926     sizeof(struct MUI_CycleData),
 927     (void *) Cycle_Dispatcher
 928 };