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