workbench/libs/muimaster/classes/cycle.c

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