workbench/libs/muimaster/classes/listview.c

   1 /*
   2     Copyright © 2002-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #include <graphics/gfx.h>
   9 #include <graphics/view.h>
  10 #include <devices/rawkeycodes.h>
  11 #include <clib/alib_protos.h>
  12 #include <proto/exec.h>
  13 #include <proto/graphics.h>
  14 #include <proto/utility.h>
  15 #include <proto/intuition.h>
  16 #include <proto/muimaster.h>
  17
  18 #include "mui.h"
  19 #include "muimaster_intern.h"
  20 #include "support.h"
  21 #include "window.h"
  22 #include "list.h"
  23 #include "prefs.h"
  24
  25 extern struct Library *MUIMasterBase;
  26
  27 struct MUI_ListviewData
  28 {
  29     Object *list, *group, *vert;
  30     struct Hook *layout_hook;
  31     struct Hook hook;
  32     struct Hook selfnotify_hook;
  33     BOOL noforward;
  34     BOOL read_only;
  35     IPTR multiselect;
  36     struct MUI_EventHandlerNode ehn;
  37
  38     int mouse_click;            /* see below if mouse is held down */
  39     BOOL range_select;
  40
  41     /* double click */
  42     ULONG last_secs;
  43     ULONG last_mics;
  44     ULONG last_active;
  45     BOOL doubleclick;
  46
  47     /* clicked column */
  48     LONG click_column;
  49     LONG def_click_column;
  50
  51     /* user prefs */
  52     ListviewMulti prefs_multi;
  53 };
  54
  55 #define MOUSE_CLICK_ENTRY 1     /* on entry clicked */
  56 #define MOUSE_CLICK_TITLE 2     /* on title clicked */
  57
  58 static void DoWheelMove(struct IClass *cl, Object *obj, LONG wheely,
  59     UWORD qual);
  60
  61 ULONG Listview_Layout_Function(struct Hook *hook, Object *obj,
  62     struct MUI_LayoutMsg *lm)
  63 {
  64     struct MUI_ListviewData *data = (struct MUI_ListviewData *)hook->h_Data;
  65
  66     switch (lm->lm_Type)
  67     {
  68     case MUILM_MINMAX:
  69         {
  70             /* Calculate the minmax dimension of the group,
  71              ** We only have a fixed number of children, so we need
  72              ** no NextObject()
  73              */
  74             lm->lm_MinMax.MinWidth =
  75                 _minwidth(data->list) + _minwidth(data->vert);
  76             lm->lm_MinMax.DefWidth =
  77                 _defwidth(data->list) + _defwidth(data->vert);
  78             lm->lm_MinMax.MaxWidth =
  79                 _maxwidth(data->list) + _maxwidth(data->vert);
  80             lm->lm_MinMax.MaxWidth =
  81                 MIN(lm->lm_MinMax.MaxWidth, MUI_MAXMAX);
  82
  83             lm->lm_MinMax.MinHeight =
  84                 MAX(_minheight(data->list), _minheight(data->vert));
  85             lm->lm_MinMax.DefHeight =
  86                 MAX(_defheight(data->list), lm->lm_MinMax.MinHeight);
  87             lm->lm_MinMax.MaxHeight =
  88                 MIN(_maxheight(data->list), _maxheight(data->vert));
  89             lm->lm_MinMax.MaxHeight =
  90                 MIN(lm->lm_MinMax.MaxHeight, MUI_MAXMAX);
  91             return 0;
  92         }
  93
  94     case MUILM_LAYOUT:
  95         {
  96             /* Now place the objects between
  97              * (0, 0, lm->lm_Layout.Width - 1, lm->lm_Layout.Height - 1)
  98              */
  99
 100             LONG vert_width = _minwidth(data->vert);
 101             LONG lay_width = lm->lm_Layout.Width;
 102             LONG lay_height = lm->lm_Layout.Height;
 103             LONG cont_width;
 104             LONG cont_height;
 105
 106             /* We need all scrollbars and the button */
 107             set(data->vert, MUIA_ShowMe, TRUE);
 108                 /* We could also overload MUIM_Show... */
 109             cont_width = lay_width - vert_width;
 110             cont_height = lay_height;
 111
 112             MUI_Layout(data->vert, cont_width, 0, vert_width, cont_height,
 113                 0);
 114
 115             /* Layout the group a second time, note that setting _mwidth() and
 116                _mheight() should be enough, or we invent a new flag */
 117             MUI_Layout(data->list, 0, 0, cont_width, cont_height, 0);
 118             return 1;
 119         }
 120     }
 121     return 0;
 122 }
 123
 124 #define PROP_VERT_FIRST   1
 125 #define LIST_VERT_FIRST   4
 126 #define LIST_VERT_VISIBLE 5
 127 #define LIST_VERT_ENTRIES 6
 128
 129 ULONG Listview_Function(struct Hook *hook, APTR dummyobj, void **msg)
 130 {
 131     struct MUI_ListviewData *data = (struct MUI_ListviewData *)hook->h_Data;
 132     SIPTR type = (SIPTR) msg[0];
 133     SIPTR val = (SIPTR) msg[1];
 134
 135     D(bug("[ListView] List 0x%p, Event %d, value %ld\n", data->list, type,
 136             val));
 137
 138     switch (type)
 139     {
 140     case PROP_VERT_FIRST:
 141         get(data->vert, MUIA_Prop_First, &val);
 142         nnset(data->list, MUIA_List_VertProp_First, val);
 143         break;
 144
 145     case LIST_VERT_FIRST:
 146         nnset(data->vert, MUIA_Prop_First, val);
 147         break;
 148     case LIST_VERT_VISIBLE:
 149         nnset(data->vert, MUIA_Prop_Visible, val);
 150         break;
 151     case LIST_VERT_ENTRIES:
 152         nnset(data->vert, MUIA_Prop_Entries, val);
 153         break;
 154     }
 155     return 0;
 156 }
 157
 158 ULONG SelfNotify_Function(struct Hook *hook, APTR obj, void **msg)
 159 {
 160     struct MUI_ListviewData *data = (struct MUI_ListviewData *)hook->h_Data;
 161     SIPTR attribute = (SIPTR) msg[0];
 162     SIPTR value = (SIPTR) msg[1];
 163
 164     /* This allows avoiding notify loops */
 165     data->noforward = TRUE;
 166     SetAttrs(obj, MUIA_Group_Forward, FALSE, attribute, value, TAG_DONE);
 167     data->noforward = FALSE;
 168
 169     return 0;
 170 }
 171
 172 /**************************************************************************
 173  OM_NEW
 174 **************************************************************************/
 175 IPTR Listview__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 176 {
 177     struct MUI_ListviewData *data;
 178     struct TagItem *tag, *tags;
 179     struct Hook *layout_hook;
 180     Object *group, *vert;
 181     Object *list =
 182         (Object *) GetTagData(MUIA_Listview_List, (IPTR) NULL,
 183         msg->ops_AttrList);
 184     IPTR cyclechain =
 185         (IPTR) GetTagData(MUIA_CycleChain, (IPTR) 0, msg->ops_AttrList);
 186     LONG entries = 0, first = 0, visible = 0;
 187
 188     if (!list)
 189         return (IPTR) NULL;
 190
 191     layout_hook = mui_alloc_struct(struct Hook);
 192     if (!layout_hook)
 193         return (IPTR) NULL;
 194
 195     layout_hook->h_Entry = HookEntry;
 196     layout_hook->h_SubEntry = (HOOKFUNC) Listview_Layout_Function;
 197
 198     obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 199         MUIA_Group_Horiz, FALSE,
 200         MUIA_CycleChain, cyclechain,
 201         MUIA_InnerLeft, 0,
 202         MUIA_InnerRight, 0,
 203         Child, (IPTR) (group = GroupObject,
 204             MUIA_InnerLeft, 0,
 205             MUIA_InnerRight, 0,
 206             MUIA_Group_LayoutHook, (IPTR) layout_hook,
 207             Child, (IPTR) list,
 208             Child, (IPTR) (vert =
 209                 ScrollbarObject, MUIA_Group_Horiz, FALSE, End), End),
 210         TAG_DONE);
 211
 212     if (!obj)
 213     {
 214         mui_free(layout_hook);
 215         return (IPTR) NULL;
 216     }
 217
 218     data = INST_DATA(cl, obj);
 219     layout_hook->h_Data = data;
 220     data->list = list;
 221     data->vert = vert;
 222     data->group = group;
 223     data->layout_hook = layout_hook;
 224
 225     data->hook.h_Entry = HookEntry;
 226     data->hook.h_SubEntry = (HOOKFUNC) Listview_Function;
 227     data->hook.h_Data = data;
 228
 229     data->selfnotify_hook.h_Entry = HookEntry;
 230     data->selfnotify_hook.h_SubEntry = (HOOKFUNC) SelfNotify_Function;
 231     data->selfnotify_hook.h_Data = data;
 232     data->noforward = FALSE;
 233
 234     data->last_active = -1;
 235
 236     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
 237     data->ehn.ehn_Priority = 0;
 238     data->ehn.ehn_Flags = 0;
 239     data->ehn.ehn_Object = obj;
 240     data->ehn.ehn_Class = cl;
 241
 242     /* parse initial taglist */
 243     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 244     {
 245         switch (tag->ti_Tag)
 246         {
 247             case MUIA_Listview_DoubleClick:
 248                 data->doubleclick = tag->ti_Data != 0;
 249                 break;
 250             case MUIA_Listview_Input:
 251                 data->read_only = !tag->ti_Data;
 252                 break;
 253             case MUIA_Listview_MultiSelect:
 254                 data->multiselect = tag->ti_Data;
 255                 break;
 256         }
 257     }
 258
 259     get(list, MUIA_List_VertProp_First, &first);
 260     get(list, MUIA_List_VertProp_Visible, &visible);
 261     get(list, MUIA_List_VertProp_Entries, &entries);
 262
 263     D(bug
 264         ("[ListView 0x%p] List 0x%p, First %ld, Visible %ld, Entries %ld\n",
 265             obj, list, first, visible, entries));
 266
 267     SetAttrs(data->vert,
 268         MUIA_Prop_First, first,
 269         MUIA_Prop_Visible, visible, MUIA_Prop_Entries, entries, TAG_DONE);
 270
 271     DoMethod(vert, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, (IPTR) obj,
 272         4, MUIM_CallHook, (IPTR) &data->hook, PROP_VERT_FIRST,
 273         MUIV_TriggerValue);
 274     DoMethod(list, MUIM_Notify, MUIA_List_VertProp_First, MUIV_EveryTime,
 275         (IPTR) obj, 4, MUIM_CallHook, (IPTR) &data->hook, LIST_VERT_FIRST,
 276         MUIV_TriggerValue);
 277     DoMethod(list, MUIM_Notify, MUIA_List_VertProp_Visible, MUIV_EveryTime,
 278         (IPTR) obj, 4, MUIM_CallHook, (IPTR) &data->hook,
 279         LIST_VERT_VISIBLE, MUIV_TriggerValue);
 280     DoMethod(list, MUIM_Notify, MUIA_List_VertProp_Entries, MUIV_EveryTime,
 281         (IPTR) obj, 4, MUIM_CallHook, (IPTR) &data->hook,
 282         LIST_VERT_ENTRIES, MUIV_TriggerValue);
 283     DoMethod(list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
 284         (IPTR) obj, 4, MUIM_CallHook, (IPTR) &data->selfnotify_hook,
 285         MUIA_List_Active, MUIV_TriggerValue);
 286
 287     return (IPTR) obj;
 288 }
 289
 290 /**************************************************************************
 291  OM_DISPOSE
 292 **************************************************************************/
 293 IPTR Listview__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 294 {
 295     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 296
 297     mui_free(data->layout_hook);        /* is always here */
 298     return DoSuperMethodA(cl, obj, msg);
 299 }
 300
 301 /**************************************************************************
 302  OM_SET
 303 **************************************************************************/
 304 void Listview__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 305 {
 306     struct TagItem *tag, *tags;
 307     IPTR no_notify = GetTagData(MUIA_NoNotify, FALSE, msg->ops_AttrList);
 308     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 309
 310     if (data->noforward)
 311     {
 312         DoSuperMethodA(cl, obj, (Msg) msg);
 313         return;
 314     }
 315
 316     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 317     {
 318         switch (tag->ti_Tag)
 319         {
 320         case MUIA_List_CompareHook:
 321         case MUIA_List_ConstructHook:
 322         case MUIA_List_DestructHook:
 323         case MUIA_List_DisplayHook:
 324         case MUIA_List_VertProp_First:
 325         case MUIA_List_Format:
 326         case MUIA_List_VertProp_Entries:
 327         case MUIA_List_VertProp_Visible:
 328         case MUIA_List_Active:
 329         case MUIA_List_First:
 330         case MUIA_List_Visible:
 331         case MUIA_List_Entries:
 332         case MUIA_List_Quiet:
 333             SetAttrs(data->list, MUIA_NoNotify, no_notify, tag->ti_Tag,
 334                 tag->ti_Data, TAG_DONE);
 335             break;
 336         case MUIA_Listview_DoubleClick:
 337             data->doubleclick = tag->ti_Data != 0;
 338             break;
 339         }
 340     }
 341 }
 342
 343 /**************************************************************************
 344  OM_GET
 345 **************************************************************************/
 346 IPTR Listview__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 347 {
 348 /* small macro to simplify return value storage */
 349 #define STORE *(msg->opg_Storage)
 350     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 351
 352     switch (msg->opg_AttrID)
 353     {
 354     case MUIA_List_CompareHook:
 355     case MUIA_List_ConstructHook:
 356     case MUIA_List_DestructHook:
 357     case MUIA_List_DisplayHook:
 358     case MUIA_List_VertProp_First:
 359     case MUIA_List_Format:
 360     case MUIA_List_VertProp_Entries:
 361     case MUIA_List_VertProp_Visible:
 362     case MUIA_List_Active:
 363     case MUIA_List_First:
 364     case MUIA_List_Visible:
 365     case MUIA_List_Entries:
 366     case MUIA_List_Quiet:
 367         return GetAttr(msg->opg_AttrID, data->list, msg->opg_Storage);
 368     case MUIA_Listview_DoubleClick:
 369         STORE = data->doubleclick;
 370         return 1;
 371     case MUIA_Listview_ClickColumn:
 372         STORE = data->click_column;
 373         return 1;
 374     case MUIA_Listview_List:
 375         STORE = (IPTR) data->list;
 376         return 1;
 377     }
 378
 379     return DoSuperMethodA(cl, obj, (Msg) msg);
 380 #undef STORE
 381 }
 382
 383 /**************************************************************************
 384  MUIM_Setup
 385 **************************************************************************/
 386 IPTR Listview__MUIM_Setup(struct IClass *cl, Object *obj,
 387     struct MUIP_Setup *msg)
 388 {
 389     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 390
 391     if (!DoSuperMethodA(cl, obj, (Msg) msg))
 392         return 0;
 393
 394     data->prefs_multi = muiGlobalInfo(obj)->mgi_Prefs->list_multi;
 395     if (data->multiselect == MUIV_Listview_MultiSelect_Default)
 396     {
 397         if (data->prefs_multi == LISTVIEW_MULTI_SHIFTED)
 398             data->multiselect = MUIV_Listview_MultiSelect_Shifted;
 399         else
 400             data->multiselect = MUIV_Listview_MultiSelect_Always;
 401     }
 402
 403     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) &data->ehn);
 404
 405     return 1;
 406 }
 407
 408 /**************************************************************************
 409  MUIM_Cleanup
 410 **************************************************************************/
 411 IPTR Listview__MUIM_Cleanup(struct IClass *cl, Object *obj,
 412     struct MUIP_Cleanup *msg)
 413 {
 414     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 415
 416     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) &data->ehn);
 417     data->mouse_click = 0;
 418
 419     return DoSuperMethodA(cl, obj, (Msg) msg);
 420 }
 421
 422 /**************************************************************************
 423  MUIM_HandleEvent
 424 **************************************************************************/
 425 IPTR Listview__MUIM_HandleEvent(struct IClass *cl, Object *obj,
 426     struct MUIP_HandleEvent *msg)
 427 {
 428     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 429     Object *list = data->list;
 430     struct MUI_List_TestPos_Result pos;
 431     LONG seltype, new_active = 0;
 432     IPTR result = 0;
 433     BOOL select = FALSE, multiselect = FALSE, clear = FALSE;
 434
 435     if (msg->imsg)
 436     {
 437         DoMethod(list, MUIM_List_TestPos, msg->imsg->MouseX,
 438             msg->imsg->MouseY, (IPTR) &pos);
 439
 440         switch (msg->imsg->Class)
 441         {
 442         case IDCMP_MOUSEBUTTONS:
 443             if (msg->imsg->Code == SELECTDOWN)
 444             {
 445                 if (_isinobject(list, msg->imsg->MouseX, msg->imsg->MouseY))
 446                 {
 447                     data->mouse_click = MOUSE_CLICK_ENTRY;
 448
 449                     new_active = pos.entry;
 450
 451                     select = TRUE;
 452                     clear =
 453                         data->multiselect == MUIV_Listview_MultiSelect_None
 454                         || (data->multiselect
 455                         == MUIV_Listview_MultiSelect_Shifted
 456                         && (msg->imsg->Qualifier
 457                         & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) == 0);
 458                     seltype = clear ?
 459                         MUIV_List_Select_On: MUIV_List_Select_Toggle;
 460                     data->range_select = FALSE;
 461
 462                     /* Handle MUIA_Listview_ClickColumn */
 463                     data->click_column = pos.column;
 464
 465                     if (data->last_active == pos.entry
 466                         && DoubleClick(data->last_secs, data->last_mics,
 467                             msg->imsg->Seconds, msg->imsg->Micros))
 468                     {
 469                         set(obj, MUIA_Listview_DoubleClick, TRUE);
 470                         data->last_active = -1;
 471                         data->last_secs = data->last_mics = 0;
 472                     }
 473                     else
 474                     {
 475                         data->last_active = pos.entry;
 476                         data->last_secs = msg->imsg->Seconds;
 477                         data->last_mics = msg->imsg->Micros;
 478                     }
 479                 }
 480             }
 481             else
 482             {
 483                 if (_isinobject(list, msg->imsg->MouseX, msg->imsg->MouseY))
 484                 {
 485                     data->range_select = FALSE;
 486                     result = MUI_EventHandlerRC_Eat;
 487                 }
 488
 489                 if (msg->imsg->Code == SELECTUP && data->mouse_click)
 490                 {
 491                     set(_win(obj), MUIA_Window_ActiveObject, (IPTR)obj);
 492                     data->mouse_click = 0;
 493                 }
 494             }
 495             break;
 496
 497         case IDCMP_RAWKEY:
 498             if (XGET(_win(obj), MUIA_Window_ActiveObject) == (IPTR)obj)
 499             {
 500                 switch (msg->imsg->Code)
 501                 {
 502                 case RAWKEY_UP:
 503                     new_active = MUIV_List_Active_Up;
 504                     select = clear =
 505                         data->multiselect == MUIV_Listview_MultiSelect_None;
 506                     seltype = MUIV_List_Select_On;
 507                     break;
 508
 509                 case RAWKEY_DOWN:
 510                     new_active = MUIV_List_Active_Down;
 511                     select = clear =
 512                         data->multiselect == MUIV_Listview_MultiSelect_None;
 513                     seltype = MUIV_List_Select_On;
 514                     break;
 515
 516                 case RAWKEY_SPACE:
 517                     if (data->multiselect != MUIV_Listview_MultiSelect_None)
 518                     {
 519                         select = TRUE;
 520                         multiselect = TRUE;
 521                         seltype = MUIV_List_Select_Toggle;
 522                         data->click_column = data->def_click_column;
 523                     }
 524                     break;
 525
 526                 case RAWKEY_NM_WHEEL_UP:
 527                     DoWheelMove(cl, obj, -1, msg->imsg->Qualifier);
 528                     break;
 529
 530                 case RAWKEY_NM_WHEEL_DOWN:
 531                     DoWheelMove(cl, obj, 1, msg->imsg->Qualifier);
 532                     break;
 533                 }
 534                 result = MUI_EventHandlerRC_Eat;
 535             }
 536             break;
 537         }
 538
 539         if (select)
 540         {
 541             multiselect = multiselect ||
 542                 data->multiselect == MUIV_Listview_MultiSelect_Always
 543                 || (data->multiselect == MUIV_Listview_MultiSelect_Shifted
 544                 && (msg->imsg->Qualifier
 545                 & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) != 0);
 546
 547             if (clear)
 548             {
 549                 DoMethod(list, MUIM_List_Select, multiselect ?
 550                     MUIV_List_Select_All : MUIV_List_Select_Active,
 551                     MUIV_List_Select_Off, NULL);
 552             }
 553
 554             if (new_active != XGET(list, MUIA_List_Active))
 555                 set(list, MUIA_List_Active, new_active);
 556
 557             DoMethod(list, MUIM_List_Select,
 558                 MUIV_List_Select_Active,
 559                 seltype, NULL);
 560         }
 561     }
 562
 563     return result;
 564 }
 565
 566 static void DoWheelMove(struct IClass *cl, Object *obj, LONG wheely,
 567     UWORD qual)
 568 {
 569     struct MUI_ListviewData *data = INST_DATA(cl, obj);
 570     LONG new, first, entries, visible;
 571
 572     new = first = XGET(data->list, MUIA_List_First);
 573     entries = XGET(data->list, MUIA_List_Entries);
 574     visible = XGET(data->list, MUIA_List_Visible);
 575
 576     if (qual & IEQUALIFIER_CONTROL)
 577     {
 578         if (wheely < 0)
 579             new = 0;
 580         if (wheely > 0)
 581             new = entries;
 582     }
 583     else if (qual & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
 584     {
 585         new += wheely * visible;
 586     }
 587     else
 588     {
 589         new += wheely * 3;
 590     }
 591
 592     if (new > entries - visible)
 593     {
 594         new = entries - visible;
 595     }
 596
 597     if (new < 0)
 598     {
 599         new = 0;
 600     }
 601
 602     if (new != first)
 603     {
 604         set(data->list, MUIA_List_First, new);
 605     }
 606 }
 607
 608 BOOPSI_DISPATCHER(IPTR, Listview_Dispatcher, cl, obj, msg)
 609 {
 610     switch (msg->MethodID)
 611     {
 612     case OM_SET:
 613         Listview__OM_SET(cl, obj, (struct opSet *)msg);
 614         break;
 615     case OM_GET:
 616         return Listview__OM_GET(cl, obj, (struct opGet *)msg);
 617     case OM_NEW:
 618         return Listview__OM_NEW(cl, obj, (struct opSet *)msg);
 619     case OM_DISPOSE:
 620         return Listview__OM_DISPOSE(cl, obj, msg);
 621     case MUIM_Setup:
 622         return Listview__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 623     case MUIM_Cleanup:
 624         return Listview__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 625     case MUIM_HandleEvent:
 626         return Listview__MUIM_HandleEvent(cl, obj,
 627             (struct MUIP_HandleEvent *)msg);
 628     case MUIM_List_Clear:
 629     case MUIM_List_CreateImage:
 630     case MUIM_List_DeleteImage:
 631     case MUIM_List_Exchange:
 632     case MUIM_List_GetEntry:
 633     case MUIM_List_Insert:
 634     case MUIM_List_InsertSingle:
 635     case MUIM_List_Jump:
 636     case MUIM_List_NextSelected:
 637     case MUIM_List_Redraw:
 638     case MUIM_List_Remove:
 639     case MUIM_List_Select:
 640     case MUIM_List_Sort:
 641     case MUIM_List_TestPos:
 642         {
 643             struct MUI_ListviewData *data = INST_DATA(cl, obj);
 644
 645             return DoMethodA(data->list, msg);
 646         }
 647
 648     }
 649
 650     return DoSuperMethodA(cl, obj, msg);
 651 }
 652 BOOPSI_DISPATCHER_END
 653
 654 /*
 655  * Class descriptor.
 656  */
 657 const struct __MUIBuiltinClass _MUI_Listview_desc =
 658 {
 659     MUIC_Listview,
 660     MUIC_Group,
 661     sizeof(struct MUI_ListviewData),
 662     (void *) Listview_Dispatcher
 663 };