workbench/classes/zune/nlist/nlistview_mcc/NListview.c

   1 /***************************************************************************
   2
   3  NListview.mcc - New Listview MUI Custom Class
   4  Registered MUI class, Serial Number: 1d51 (0x9d510020 to 0x9d51002F)
   5
   6  Copyright (C) 1996-2001 by Gilles Masson
   7  Copyright (C) 2001-2014 NList Open Source Team
   8
   9  This library is free software; you can redistribute it and/or
  10  modify it under the terms of the GNU Lesser General Public
  11  License as published by the Free Software Foundation; either
  12  version 2.1 of the License, or (at your option) any later version.
  13
  14  This library is distributed in the hope that it will be useful,
  15  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  Lesser General Public License for more details.
  18
  19  NList classes Support Site:  http://www.sf.net/projects/nlist-classes
  20
  21  $Id$
  22
  23 ***************************************************************************/
  24
  25 #include <string.h>
  26
  27 #include <clib/alib_protos.h>
  28 #include <proto/muimaster.h>
  29 #include <proto/intuition.h>
  30 #include <proto/utility.h>
  31 #include <proto/keymap.h>
  32
  33 #include "private.h"
  34 #include "version.h"
  35
  36 #include "NListviews_mcp.h"
  37
  38 #include "muiextra.h"
  39
  40 #include "Debug.h"
  41
  42 #ifndef MUI_EHF_GUIMODE
  43 #define MUI_EHF_GUIMODE     (1<<1)  /* set this if you dont want your handler to be called */
  44                                     /* when your object is disabled or invisible */
  45 #endif
  46
  47 static LONG IMsgToChar(struct IntuiMessage *imsg, ULONG dccode, ULONG dcquali)
  48 {
  49   struct InputEvent ie;
  50   LONG key = -1;
  51
  52   ENTER();
  53
  54   memset(&ie, 0, sizeof(struct InputEvent));
  55   ie.ie_Class = IECLASS_RAWKEY;
  56
  57   if(imsg->Class == IDCMP_RAWKEY)
  58   {
  59     TEXT buf[4];
  60
  61     ie.ie_Code         = imsg->Code & ~dccode;
  62     ie.ie_Qualifier    = imsg->Qualifier & ~dcquali;
  63     ie.ie_EventAddress = (APTR *)*((IPTR *)imsg->IAddress);
  64
  65     #if defined(__amigaos4__)
  66     ie.ie_TimeStamp.Seconds = imsg->Seconds;
  67     ie.ie_TimeStamp.Microseconds = imsg->Micros;
  68     #else
  69     ie.ie_TimeStamp.tv_secs = imsg->Seconds;
  70     ie.ie_TimeStamp.tv_micro = imsg->Micros;
  71     #endif
  72
  73     if(MapRawKey(&ie, buf , 3, 0) > 0)
  74       key = (LONG)buf[0];
  75   }
  76
  77   RETURN(key);
  78   return key;
  79 }
  80
  81 static IPTR mNLV_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
  82 {
  83   struct NLVData *data = INST_DATA(cl, obj);
  84   struct IntuiMessage *imsg = msg->imsg;
  85   IPTR result = 0;
  86
  87   ENTER();
  88
  89   if(data->LI_NList != NULL)
  90   {
  91     #if !defined(__amigaos4__) && !defined(__MORPHOS__) && !defined(__AROS__)
  92     // with MUI 3.8 the embedded list object doesn't get this method,
  93     // hence we must forward it ourself.
  94     if(MUIMasterBase != NULL && MUIMasterBase->lib_Version <= 19 && msg->muikey != MUIKEY_NONE)
  95     {
  96       result = DoMethodA(data->LI_NList, (Msg)msg);
  97     }
  98     #endif
  99     if(imsg != NULL)
 100     {
 101       switch(imsg->Class)
 102       {
 103         case IDCMP_RAWKEY:
 104         {
 105           if(data->ControlChar != '\0' && IMsgToChar(imsg, 0, (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) == data->ControlChar)
 106           {
 107             set(data->LI_NList, MUIA_NList_Active, imsg->Qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT) ? MUIV_NList_Active_Up: MUIV_NList_Active_Down);
 108           }
 109         }
 110         break;
 111       }
 112     }
 113   }
 114
 115   RETURN(result);
 116   return result;
 117 }
 118
 119 static IPTR mNLV_HandleInput(struct IClass *cl, Object *obj, struct MUIP_HandleInput *msg)
 120 {
 121   struct NLVData *data = INST_DATA(cl, obj);
 122   IPTR result = 0;
 123
 124   ENTER();
 125
 126   if(data->LI_NList != NULL && msg->muikey != MUIKEY_NONE)
 127     result = DoMethodA(data->LI_NList, (Msg)msg);
 128   else
 129     result = DoSuperMethodA(cl, obj, (Msg)msg);
 130
 131   RETURN(result);
 132   return result;
 133 }
 134
 135 static void AddVerticalScroller(Object *obj, struct NLVData *data)
 136 {
 137   ENTER();
 138
 139   if(data->Vert_Attached == FALSE)
 140   {
 141     ULONG entries;
 142     ULONG visible;
 143     ULONG first;
 144     ULONG deltaFactor;
 145
 146     D(DBF_STARTUP, "adding vertical scrollbar");
 147
 148     // restore the list's current disabled state, because the scrollbar might
 149     // have been removed in disabled state and the list has been reactivated
 150     // in the meantime
 151     set(data->PR_Vert, MUIA_Disabled, xget(data->LI_NList, MUIA_Disabled));
 152     DoMethod(obj, OM_ADDMEMBER, data->PR_Vert);
 153
 154     // add notifications
 155     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_Prop_Entries,    MUIV_EveryTime,  data->PR_Vert,  3, MUIM_NoNotifySet, MUIA_Prop_Entries, MUIV_TriggerValue);
 156     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_Prop_Visible,    MUIV_EveryTime,  data->PR_Vert,  3, MUIM_NoNotifySet, MUIA_Prop_Visible, MUIV_TriggerValue);
 157     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_Prop_First,      MUIV_EveryTime,  data->PR_Vert,  3, MUIM_NoNotifySet, MUIA_Prop_First, MUIV_TriggerValue);
 158     DoMethod(data->PR_Vert,  MUIM_Notify, MUIA_Prop_First,            MUIV_EveryTime,  data->LI_NList, 3, MUIM_NoNotifySet, MUIA_NList_Prop_First, MUIV_TriggerValue);
 159     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_VertDeltaFactor, MUIV_EveryTime,  data->PR_Vert,  3, MUIM_NoNotifySet, MUIA_Prop_DeltaFactor, MUIV_TriggerValue);
 160
 161     // Get and set the attributes we just have installed the notifications for to
 162     // immediately trigger them. Otherwise hiding and showing again the scrollbar
 163     // while the number of entries changed in the meantime will result in wrong
 164     // scrollbar dimensions (i.e. when switching folders in YAM).
 165     entries     = xget(data->LI_NList, MUIA_NList_Prop_Entries);
 166     visible     = xget(data->LI_NList, MUIA_NList_Prop_Visible);
 167     first       = xget(data->LI_NList, MUIA_NList_Prop_First);
 168     deltaFactor = xget(data->LI_NList, MUIA_NList_VertDeltaFactor);
 169     SetAttrs(data->LI_NList,
 170       MUIA_NList_Prop_Entries,    entries,
 171       MUIA_NList_Prop_Visible,    visible,
 172       MUIA_NList_Prop_First,      first,
 173       MUIA_NList_VertDeltaFactor, deltaFactor,
 174       TAG_DONE);
 175
 176     data->Vert_Attached = TRUE;
 177
 178     D(DBF_STARTUP, "vertical scrollbar added");
 179   }
 180
 181   LEAVE();
 182 }
 183
 184 static void RemoveVerticalScroller(Object *obj, struct NLVData *data)
 185 {
 186   ENTER();
 187
 188   if(data->Vert_Attached == TRUE)
 189   {
 190     D(DBF_STARTUP, "removing vertical scrollbar");
 191
 192     // remove notifications
 193     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_Prop_Entries,    data->PR_Vert);
 194     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_Prop_Visible,    data->PR_Vert);
 195     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_Prop_First,      data->PR_Vert);
 196     DoMethod(data->PR_Vert,  MUIM_KillNotifyObj, MUIA_Prop_First,            data->LI_NList);
 197     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_VertDeltaFactor, data->PR_Vert);
 198
 199     DoMethod(obj, OM_REMMEMBER, data->PR_Vert);
 200
 201     data->Vert_Attached = FALSE;
 202
 203     D(DBF_STARTUP, "vertical scrollbar removed");
 204   }
 205
 206   LEAVE();
 207 }
 208
 209 static void AddHorizontalScroller(Object *obj, struct NLVData *data)
 210 {
 211   ENTER();
 212
 213   if(data->Horiz_Attached == FALSE)
 214   {
 215     ULONG active;
 216     ULONG entries;
 217     ULONG visible;
 218     ULONG first;
 219     ULONG deltaFactor;
 220
 221     D(DBF_STARTUP, "adding horizontal scrollbar");
 222
 223     // restore the list's current disabled state, because the scrollbar might
 224     // have been removed in disabled state and the list has been reactivated
 225     // in the meantime
 226     set(data->PR_Horiz, MUIA_Disabled, xget(data->LI_NList, MUIA_Disabled));
 227     DoMethod(obj, OM_ADDMEMBER, data->PR_Horiz);
 228
 229     // add notifications
 230     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_Horiz_Entries,    MUIV_EveryTime, data->PR_Horiz, 3, MUIM_NoNotifySet, MUIA_Prop_Entries, MUIV_TriggerValue);
 231     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_Horiz_Visible,    MUIV_EveryTime, data->PR_Horiz, 3, MUIM_NoNotifySet, MUIA_Prop_Visible, MUIV_TriggerValue);
 232     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_Horiz_First,      MUIV_EveryTime, data->PR_Horiz, 3, MUIM_NoNotifySet, MUIA_Prop_First, MUIV_TriggerValue);
 233     DoMethod(data->PR_Horiz, MUIM_Notify, MUIA_Prop_First,             MUIV_EveryTime, data->LI_NList, 3, MUIM_NoNotifySet, MUIA_NList_Horiz_First, MUIV_TriggerValue);
 234     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NList_HorizDeltaFactor, MUIV_EveryTime, data->PR_Horiz, 3, MUIM_NoNotifySet, MUIA_Prop_DeltaFactor, MUIV_TriggerValue);
 235
 236     // Get and set the attributes we just have installed the notifications for to
 237     // immediately trigger them. Otherwise hiding and showing again the scrollbar
 238     // while the number of entries changed in the meantime will result in wrong
 239     // scrollbar dimensions (i.e. when switching folders in YAM).
 240     active      = xget(data->LI_NList, MUIA_NList_Active);
 241     entries     = xget(data->LI_NList, MUIA_NList_Horiz_Entries);
 242     visible     = xget(data->LI_NList, MUIA_NList_Horiz_Visible);
 243     first       = xget(data->LI_NList, MUIA_NList_Horiz_First);
 244     deltaFactor = xget(data->LI_NList, MUIA_NList_HorizDeltaFactor);
 245     SetAttrs(data->LI_NList,
 246       MUIA_NList_Horiz_Entries,    entries,
 247       MUIA_NList_Horiz_Visible,    visible,
 248       MUIA_NList_Horiz_First,      first,
 249       MUIA_NList_HorizDeltaFactor, deltaFactor,
 250       TAG_DONE);
 251
 252     // make sure the active entry is still visible after adding the scrollbar
 253     // since the scrollbar is added at the bottom we only have to check for the
 254     // last visible item
 255     entries = xget(data->LI_NList, MUIA_NList_Entries);
 256     visible = xget(data->LI_NList, MUIA_NList_Visible);
 257     first   = xget(data->LI_NList, MUIA_NList_First);
 258     if(active == first+visible-1)
 259     {
 260       // the method must be pushed because we are currently inside a InitChange/ExitChange pair
 261       // and the final height of the list cannot yet be determined correctly
 262       // Additionally we must have completed the MUIM_Setup method to have a valid application pointer
 263       if(data->SETUP == TRUE)
 264         DoMethod(_app(obj), MUIM_Application_PushMethod, data->LI_NList, 2, MUIM_NList_Jump, active);
 265     }
 266
 267     data->Horiz_Attached = TRUE;
 268
 269     D(DBF_STARTUP, "horizontal scrollbar added");
 270   }
 271
 272   LEAVE();
 273 }
 274
 275 static void RemoveHorizontalScroller(Object *obj, struct NLVData *data)
 276 {
 277   ENTER();
 278
 279   if(data->Horiz_Attached == TRUE)
 280   {
 281     D(DBF_STARTUP, "removing horizontal scrollbar");
 282
 283     // remove notifications
 284     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_Horiz_Entries,    data->PR_Horiz);
 285     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_Horiz_Visible,    data->PR_Horiz);
 286     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_Horiz_First,      data->PR_Horiz);
 287     DoMethod(data->PR_Horiz, MUIM_KillNotifyObj, MUIA_Prop_First,             data->LI_NList);
 288     DoMethod(data->LI_NList, MUIM_KillNotifyObj, MUIA_NList_HorizDeltaFactor, data->PR_Horiz);
 289
 290     DoMethod(obj, OM_REMMEMBER, data->PR_Horiz);
 291
 292     data->Horiz_Attached = FALSE;
 293
 294     D(DBF_STARTUP, "horizontal scrollbar removed");
 295   }
 296
 297   LEAVE();
 298 }
 299
 300 static void NLV_Scrollers(Object *obj, struct NLVData *data, LONG vert, LONG horiz)
 301 {
 302   LONG scrollers = 0;
 303   BOOL safeNotifies;
 304
 305   ENTER();
 306
 307   #if defined(__amigaos3__) || defined(__amigaos4__)
 308   if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 5824))
 309   {
 310     // MUI4 for AmigaOS is safe for V20.5824+
 311     safeNotifies = TRUE;
 312   }
 313   else if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 2346) && LIBREV(MUIMasterBase) < 5000)
 314   {
 315     // MUI3.9 for AmigaOS is safe for V20.2346+
 316     safeNotifies = TRUE;
 317   }
 318   else
 319   {
 320     // MUI 3.8 and older version of MUI 3.9 or MUI4 are definitely unsafe
 321     safeNotifies = FALSE;
 322   }
 323   #else
 324   // MorphOS and AROS must be considered unsafe unless someone from the
 325   // MorphOS/AROS team confirms that removing notifies in nested OM_SET
 326   // calls is safe.
 327   safeNotifies = FALSE;
 328   #endif
 329
 330   if(vert & 0x0F)
 331   {
 332     data->Vert_ScrollBar = vert & 0x0F;
 333
 334     if(data->Vert_ScrollBar == MUIV_NListview_VSB_Default)
 335     {
 336       LONG *scrollbar;
 337
 338       if(DoMethod(obj, MUIM_GetConfigItem, MUICFG_NListview_VSB, (IPTR)&scrollbar))
 339         data->VertSB = *scrollbar;
 340       else
 341         data->VertSB = MUIV_NListview_VSB_Always;
 342     }
 343     else
 344       data->VertSB = data->Vert_ScrollBar;
 345
 346     // switch to always visible scrollbars if removing notifies is unsafe
 347     if(safeNotifies == FALSE)
 348       data->VertSB = MUIV_NListview_VSB_Always;
 349
 350     switch(data->VertSB)
 351     {
 352       case MUIV_NListview_VSB_Always:
 353       case MUIV_NListview_VSB_Left:
 354       {
 355         scrollers |= MUIV_NListview_VSB_On;
 356       }
 357       break;
 358
 359       case MUIV_NListview_VSB_Auto:
 360       case MUIV_NListview_VSB_FullAuto:
 361       {
 362         // nothing
 363       }
 364       break;
 365
 366       case MUIV_NListview_VSB_None:
 367       {
 368         scrollers |= MUIV_NListview_VSB_Off;
 369       }
 370       break;
 371     }
 372   }
 373
 374   if(horiz & 0x0F)
 375   {
 376     data->Horiz_ScrollBar = horiz & 0x0F;
 377
 378     if(data->Horiz_ScrollBar == MUIV_NListview_HSB_Default)
 379     {
 380       LONG *scrollbar;
 381
 382       if(DoMethod(obj, MUIM_GetConfigItem, MUICFG_NListview_HSB, (IPTR)&scrollbar))
 383         data->HorizSB = *scrollbar;
 384       else
 385         data->HorizSB = DEFAULT_HSB;
 386     }
 387     else
 388       data->HorizSB = data->Horiz_ScrollBar;
 389
 390     // switch to always visible scrollbars if removing notifies is unsafe
 391     if(safeNotifies == FALSE)
 392       data->HorizSB = MUIV_NListview_VSB_Always;
 393
 394     switch (data->HorizSB)
 395     {
 396       case MUIV_NListview_HSB_Always:
 397       {
 398         scrollers |= MUIV_NListview_HSB_On;
 399       }
 400       break;
 401
 402       case MUIV_NListview_HSB_Auto:
 403       case MUIV_NListview_HSB_FullAuto:
 404       {
 405         // nothing
 406       }
 407       break;
 408
 409       case MUIV_NListview_HSB_None:
 410       {
 411         scrollers |= MUIV_NListview_HSB_Off;
 412       }
 413       break;
 414     }
 415   }
 416
 417   scrollers |= ((vert | horiz) & (MUIV_NListview_VSB_On | MUIV_NListview_HSB_On));
 418
 419   if(((data->VertSB == MUIV_NListview_VSB_Auto || data->VertSB == MUIV_NListview_VSB_Always) && (scrollers & MUIV_NListview_VSB_On) == MUIV_NListview_VSB_Off) ||
 420      (data->VertSB == MUIV_NListview_VSB_None && (scrollers & MUIV_NListview_VSB_On) == MUIV_NListview_VSB_On) ||
 421      (data->Vert_Attached == TRUE && (scrollers & MUIV_NListview_VSB_On) == MUIV_NListview_VSB_On) ||
 422      (data->Vert_Attached == FALSE && (scrollers & MUIV_NListview_VSB_On) == MUIV_NListview_VSB_Off))
 423   {
 424     scrollers &= ~MUIV_NListview_VSB_On;
 425   }
 426
 427   if(((data->HorizSB == MUIV_NListview_HSB_Auto || data->HorizSB == MUIV_NListview_HSB_Always) && (scrollers & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_Off) ||
 428       (data->HorizSB == MUIV_NListview_HSB_None && (scrollers & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_On) ||
 429       (data->Horiz_Attached == TRUE && (scrollers & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_On) ||
 430       (data->Horiz_Attached == FALSE && (scrollers & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_Off))
 431   {
 432     scrollers &= ~MUIV_NListview_HSB_On;
 433   }
 434
 435   // Don't do the dirty work of adding/removing the scrollbars here directly,
 436   // but delay this until the application is idle again. This is necessary,
 437   // because the OM_SET method calling this function can be called from within
 438   // an OM_SET method of our group object. Removing any scrollbar in this
 439   // situation will cause an access to the just removed object (or better its
 440   // Exec node structure) which has become invalid due to the removal.
 441   // The AmigaOS4 debug kernel shows this very good, because an access to the
 442   // address 0xcccccccc happens which definitely proves the invalid access.
 443   if(scrollers & (MUIV_NListview_VSB_On|MUIV_NListview_HSB_On))
 444   {
 445     // we must have completed the MUIM_Setup method to have a valid application pointer
 446     if(data->SETUP == TRUE)
 447       DoMethod(_app(obj), MUIM_Application_PushMethod, obj, 2, MUIM_NListview_SetScrollers, scrollers);
 448   }
 449
 450   LEAVE();
 451 }
 452
 453 #if !defined(__MORPHOS__)
 454 #ifdef __AROS__
 455 static __attribute__ ((noinline)) Object * VARARGS68K DoSuperNew(struct IClass *cl, Object *obj, Tag tag1, ...)
 456 {
 457     AROS_SLOWSTACKTAGS_PRE_AS(tag1, Object *)
 458     retval = (Object *)DoSuperMethod(cl, obj, OM_NEW, AROS_SLOWSTACKTAGS_ARG(tag1), NULL);
 459     AROS_SLOWSTACKTAGS_POST
 460 }
 461 #else
 462 static Object * VARARGS68K DoSuperNew(struct IClass *cl, Object *obj, ...)
 463 {
 464   Object *rc;
 465   VA_LIST args;
 466
 467   ENTER();
 468
 469   VA_START(args, obj);
 470   rc = (Object *)DoSuperMethod(cl, obj, OM_NEW, VA_ARG(args, ULONG), NULL);
 471   VA_END(args);
 472
 473   RETURN(rc);
 474   return rc;
 475 }
 476 #endif
 477 #endif // !__MORPHOS__
 478
 479 /* static ULONG mNLV_New(struct IClass *cl,Object *obj,Msg msg) */
 480 static IPTR mNLV_New(struct IClass *cl, Object *obj, struct opSet *msg)
 481 {
 482   struct NLVData *data;
 483   struct TagItem *tag;
 484   Object *nlist = NULL;
 485   Object *vgroup = NULL;
 486   BOOL cyclechain = FALSE;
 487   BOOL dropable = FALSE;
 488
 489   ENTER();
 490
 491   if((tag = FindTagItem(MUIA_Draggable, msg->ops_AttrList)) != NULL)
 492     tag->ti_Tag = TAG_IGNORE;
 493
 494   if((tag = FindTagItem(MUIA_Dropable, msg->ops_AttrList)) != NULL)
 495   {
 496     tag->ti_Tag = TAG_IGNORE;
 497     dropable = tag->ti_Data;
 498   }
 499
 500   if((tag = FindTagItem(MUIA_CycleChain, msg->ops_AttrList)) != NULL)
 501   {
 502     tag->ti_Tag = TAG_IGNORE;
 503     cyclechain = tag->ti_Data;
 504   }
 505
 506   if((tag = FindTagItem(MUIA_NListview_NList, msg->ops_AttrList)) != NULL ||
 507      (tag = FindTagItem(MUIA_Listview_List, msg->ops_AttrList)) != NULL)
 508   {
 509     nlist = (Object *) tag->ti_Data;
 510
 511     if(nlist != NULL)
 512     {
 513       if(dropable)
 514       {
 515         nnset(nlist,MUIA_Dropable, dropable);
 516       }
 517
 518       if((tag = FindTagItem(MUIA_NList_DragType, msg->ops_AttrList)) != NULL ||
 519          (tag = FindTagItem(MUIA_Listview_DragType, msg->ops_AttrList)) != NULL)
 520       {
 521         nnset(nlist,tag->ti_Tag,tag->ti_Data);
 522       }
 523
 524       if((tag = FindTagItem(MUIA_Listview_Input, msg->ops_AttrList)) != NULL ||
 525          (tag = FindTagItem(MUIA_NList_Input, msg->ops_AttrList)) != NULL)
 526       {
 527         nnset(nlist,tag->ti_Tag,tag->ti_Data);
 528       }
 529
 530       if((tag = FindTagItem(MUIA_Listview_MultiSelect, msg->ops_AttrList)) != NULL ||
 531          (tag = FindTagItem(MUIA_NList_MultiSelect, msg->ops_AttrList)) != NULL)
 532       {
 533         nnset(nlist,tag->ti_Tag,tag->ti_Data);
 534       }
 535
 536       if((tag = FindTagItem(MUIA_Listview_DoubleClick, msg->ops_AttrList)) != NULL ||
 537          (tag = FindTagItem(MUIA_NList_DoubleClick, msg->ops_AttrList)) != NULL)
 538       {
 539         nnset(nlist,tag->ti_Tag,tag->ti_Data);
 540       }
 541
 542       if((tag = FindTagItem(MUIA_Listview_DefClickColumn, msg->ops_AttrList)) != NULL ||
 543          (tag = FindTagItem(MUIA_NList_DefClickColumn, msg->ops_AttrList)) != NULL)
 544       {
 545         nnset(nlist,tag->ti_Tag,tag->ti_Data);
 546       }
 547     }
 548     else
 549     {
 550       obj = NULL;
 551       RETURN(obj);
 552       return((IPTR)obj);
 553     }
 554   }
 555   else
 556   {
 557     nlist = MUI_NewObject(MUIC_NList, MUIA_Dropable, dropable, TAG_MORE, msg->ops_AttrList);
 558   }
 559
 560   obj = (Object *)DoSuperNew(cl, obj,
 561     MUIA_Group_Horiz, TRUE,
 562     MUIA_Group_Spacing, 0,
 563     MUIA_CycleChain, cyclechain,
 564     NoFrame,
 565     Child, vgroup = VGroup,
 566       MUIA_Group_Spacing, 0,
 567       Child, nlist,
 568     TAG_DONE),
 569     TAG_MORE, msg->ops_AttrList
 570   );
 571
 572   if(obj)
 573   {
 574     data = INST_DATA(cl,obj);
 575     data->sem = FALSE;
 576     data->SETUP = FALSE;
 577     data->LI_NList = nlist;
 578     data->Group = vgroup;
 579     data->Vert_Attached = FALSE;
 580     data->Horiz_Attached = FALSE;
 581     data->Vert_ScrollBar = MUIV_NListview_VSB_Default;
 582     data->Horiz_ScrollBar = MUIV_NListview_HSB_Default;
 583     if((tag = FindTagItem(MUIA_Listview_ScrollerPos, msg->ops_AttrList)) != NULL)
 584     {
 585       if(tag->ti_Data == MUIV_Listview_ScrollerPos_None)
 586       {
 587         data->Vert_ScrollBar = MUIV_NListview_VSB_None;
 588         data->Horiz_ScrollBar = MUIV_NListview_HSB_None;
 589       }
 590       else if(tag->ti_Data == MUIV_Listview_ScrollerPos_Left)
 591       {
 592         data->Vert_ScrollBar = MUIV_NListview_VSB_Left;
 593       }
 594       else if(tag->ti_Data == MUIV_Listview_ScrollerPos_Right)
 595       {
 596         data->Vert_ScrollBar = MUIV_NListview_VSB_Always;
 597       }
 598     }
 599
 600     if((tag = FindTagItem(MUIA_NListview_Vert_ScrollBar, msg->ops_AttrList)) != NULL)
 601       data->Vert_ScrollBar = tag->ti_Data;
 602
 603     if((tag = FindTagItem(MUIA_NListview_Horiz_ScrollBar, msg->ops_AttrList)) != NULL)
 604       data->Horiz_ScrollBar = tag->ti_Data;
 605
 606     if((tag = FindTagItem(MUIA_ControlChar, msg->ops_AttrList)) != NULL)
 607       data->ControlChar = tag->ti_Data;
 608
 609     data->VertSB = data->Vert_ScrollBar;
 610     data->HorizSB = data->Horiz_ScrollBar;
 611
 612     // create the two scrollbar objects
 613     data->PR_Vert = ScrollbarObject,
 614       MUIA_Group_Horiz, FALSE,
 615     End;
 616
 617     data->PR_Horiz = ScrollbarObject,
 618       MUIA_Group_Horiz, TRUE,
 619     End;
 620
 621     DoMethod(data->LI_NList, MUIM_Notify, MUIA_NListview_Horiz_ScrollBar, MUIV_EveryTime, obj, 3, MUIM_Set, MUIA_NListview_Horiz_ScrollBar, MUIV_TriggerValue);
 622
 623     set(data->LI_NList, MUIA_NList_KeepActive, (IPTR)obj);
 624
 625     // derive the "active border visible" setting from the embedded list
 626     if(xget(data->LI_NList, MUIA_NList_ActiveObjectOnClick) == TRUE)
 627       _flags(obj) |= (1<<7);
 628   }
 629
 630   RETURN(obj);
 631   return((IPTR)obj);
 632 }
 633
 634
 635 static IPTR mNLV_Dispose(struct IClass *cl,Object *obj,Msg msg)
 636 {
 637   struct NLVData *data = INST_DATA(cl, obj);
 638
 639   ENTER();
 640
 641   // dispose the scrollbars if they are not currently part of the layout
 642   if(data->PR_Vert != NULL && data->Vert_Attached == FALSE)
 643   {
 644     MUI_DisposeObject(data->PR_Vert);
 645     data->PR_Vert = NULL;
 646   }
 647   if(data->PR_Horiz != NULL && data->Horiz_Attached == FALSE)
 648   {
 649     MUI_DisposeObject(data->PR_Horiz);
 650     data->PR_Horiz = NULL;
 651   }
 652
 653   LEAVE();
 654   return DoSuperMethodA(cl,obj,msg);
 655 }
 656
 657 static IPTR mNLV_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
 658 {
 659   struct NLVData *data = INST_DATA(cl, obj);
 660   IPTR result = FALSE;
 661
 662   ENTER();
 663
 664   data->SETUP = FALSE;
 665
 666   if(data->sem == FALSE)
 667   {
 668     data->sem = TRUE;
 669     NLV_Scrollers(obj, data, data->Vert_ScrollBar, data->Horiz_ScrollBar);
 670     data->sem = FALSE;
 671   }
 672
 673   // Add the event handler for RAWKEY now
 674   data->eh.ehn_Class  = cl;
 675   data->eh.ehn_Object = obj;
 676   data->eh.ehn_Events = IDCMP_RAWKEY;
 677   data->eh.ehn_Flags  = MUI_EHF_GUIMODE;
 678   data->eh.ehn_Priority = -1;
 679   if(_win(obj) != NULL)
 680     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->eh);
 681
 682   if(DoSuperMethodA(cl, obj, (Msg)msg))
 683   {
 684     result = TRUE;
 685     data->SETUP = TRUE;
 686   }
 687
 688   RETURN(result);
 689   return result;
 690 }
 691
 692
 693 static IPTR mNLV_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
 694 {
 695   struct NLVData *data = INST_DATA(cl, obj);
 696
 697   ENTER();
 698
 699   if(_win(obj) != NULL)
 700     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->eh);
 701
 702   data->SETUP = FALSE;
 703
 704   LEAVE();
 705   return DoSuperMethodA(cl, obj, (Msg)msg);
 706 }
 707
 708
 709 static IPTR mNLV_Notify(struct IClass *cl, Object *obj, struct MUIP_Notify *msg)
 710 {
 711   struct NLVData *data = INST_DATA(cl, obj);
 712
 713   switch(msg->TrigAttr)
 714   {
 715     case MUIA_List_Prop_Entries:
 716     case MUIA_List_Prop_Visible:
 717     case MUIA_List_Prop_First:
 718     case MUIA_NList_Horiz_Entries:
 719     case MUIA_NList_Horiz_Visible:
 720     case MUIA_NList_Horiz_First:
 721     case MUIA_NList_HorizDeltaFactor:
 722     case MUIA_NList_Prop_Entries:
 723     case MUIA_NList_Prop_Visible:
 724     case MUIA_NList_Prop_First:
 725     case MUIA_NList_VertDeltaFactor:
 726     case MUIA_NList_SelectChange:
 727     case MUIA_NList_MultiClick:
 728     case MUIA_NList_DoubleClick:
 729     case MUIA_NList_EntryClick:
 730     case MUIA_NList_Active:
 731     case MUIA_NList_First:
 732     case MUIA_NList_Entries:
 733     case MUIA_NList_TitleClick:
 734     case MUIA_List_Active:
 735     case MUIA_Listview_SelectChange:
 736     case MUIA_Listview_DoubleClick:
 737     {
 738       return DoMethodA(data->LI_NList, (Msg)msg);
 739     }
 740
 741     default:
 742       return DoSuperMethodA(cl, obj, (Msg)msg);
 743   }
 744 }
 745
 746
 747
 748 static IPTR mNLV_Set(struct IClass *cl,Object *obj,Msg msg)
 749 {
 750   struct NLVData *data = INST_DATA(cl, obj);
 751   struct TagItem *tags, *tag;
 752
 753   ENTER();
 754
 755   tags = ((struct opSet *)msg)->ops_AttrList;
 756   while((tag = NextTagItem((APTR)&tags)) != NULL)
 757   {
 758     switch (tag->ti_Tag)
 759     {
 760       case MUIA_Listview_ScrollerPos:
 761       {
 762         if(tag->ti_Data == MUIV_Listview_ScrollerPos_None)
 763           tag->ti_Data = MUIV_NListview_VSB_None;
 764         else if(tag->ti_Data == MUIV_Listview_ScrollerPos_Left)
 765           tag->ti_Data = MUIV_NListview_VSB_Left;
 766         else if(tag->ti_Data == MUIV_Listview_ScrollerPos_Right)
 767           tag->ti_Data = MUIV_NListview_VSB_Always;
 768         else
 769           tag->ti_Data = MUIV_NListview_VSB_Default;
 770       }
 771       // fall through...
 772
 773       case MUIA_NListview_Vert_ScrollBar:
 774       {
 775         tag->ti_Tag = TAG_IGNORE;
 776         if(data->sem == FALSE)
 777         {
 778           data->sem = TRUE;
 779           NLV_Scrollers(obj, data, tag->ti_Data, 0);
 780           data->sem = FALSE;
 781         }
 782       }
 783       break;
 784
 785       case MUIA_NListview_Horiz_ScrollBar:
 786       {
 787         tag->ti_Tag = TAG_IGNORE;
 788         if(data->sem == FALSE)
 789         {
 790           data->sem = TRUE;
 791           NLV_Scrollers(obj, data, 0, tag->ti_Data);
 792           data->sem = FALSE;
 793         }
 794       }
 795       break;
 796
 797       case MUIA_NList_KeyUpFocus:
 798       case MUIA_NList_KeyDownFocus:
 799       case MUIA_NList_KeyLeftFocus:
 800       case MUIA_NList_KeyRightFocus:
 801       {
 802         // forward these to the embedded list object
 803         if(data->LI_NList != NULL)
 804           set(data->LI_NList, tag->ti_Tag, tag->ti_Data);
 805       }
 806       break;
 807     }
 808   }
 809
 810   LEAVE();
 811   return DoSuperMethodA(cl, obj, msg);
 812 }
 813
 814
 815 static IPTR mNLV_Get(struct IClass *cl,Object *obj,Msg msg)
 816 {
 817   struct NLVData *data = INST_DATA(cl, obj);
 818   IPTR *store = ((struct opGet *)msg)->opg_Storage;
 819   IPTR result = FALSE;
 820
 821   ENTER();
 822
 823   switch(((struct opGet *)msg)->opg_AttrID)
 824   {
 825     case MUIA_Listview_List:
 826     case MUIA_NListview_NList:
 827     {
 828       *store = (IPTR)data->LI_NList;
 829       result = TRUE;
 830     }
 831     break;
 832
 833     case MUIA_NListview_Vert_ScrollBar:
 834     {
 835       *store = (IPTR)data->VertSB;
 836       result = TRUE;
 837     }
 838     break;
 839
 840     case MUIA_NListview_Horiz_ScrollBar:
 841     {
 842       *store = (IPTR)data->HorizSB;
 843       result = TRUE;
 844     }
 845     break;
 846
 847     case MUIA_NListview_VSB_Width:
 848     {
 849       if(data->Vert_Attached == TRUE)
 850         *store = (IPTR)_width(data->PR_Vert);
 851       else
 852         *store = (IPTR)0;
 853
 854       result = TRUE;
 855     }
 856     break;
 857
 858     case MUIA_NListview_HSB_Height:
 859     {
 860       if(data->Horiz_Attached == TRUE)
 861         *store = (IPTR)_height(data->PR_Horiz);
 862       else
 863         *store = (IPTR)0;
 864
 865       result = TRUE;
 866     }
 867     break;
 868
 869     case MUIA_Version:
 870     {
 871       *store = LIB_VERSION;
 872       result = TRUE;
 873     }
 874     break;
 875
 876     case MUIA_Revision:
 877     {
 878       *store = LIB_REVISION;
 879       result = TRUE;
 880     }
 881     break;
 882
 883     default:
 884     {
 885       result = DoSuperMethodA(cl, obj, msg);
 886     }
 887     break;
 888   }
 889
 890   RETURN(result);
 891   return result;
 892 }
 893
 894 static IPTR mNLV_GoActive(struct IClass *cl, Object *obj, Msg msg)
 895 {
 896   struct NLVData *data = INST_DATA(cl, obj);
 897
 898   // forward the method to the NList object
 899   D(DBF_ALWAYS, "go active %08lx", obj);
 900   if(data->LI_NList != NULL)
 901     DoMethod(data->LI_NList, MUIM_NList_GoActive);
 902
 903   return DoSuperMethodA(cl, obj, msg);
 904 }
 905
 906 static IPTR mNLV_GoInactive(struct IClass *cl, Object *obj, Msg msg)
 907 {
 908   struct NLVData *data = INST_DATA(cl, obj);
 909
 910   D(DBF_ALWAYS, "go inactive %08lx", obj);
 911   // forward the method to the NList object
 912   if(data->LI_NList != NULL)
 913     DoMethod(data->LI_NList, MUIM_NList_GoInactive);
 914
 915   return DoSuperMethodA(cl, obj, msg);
 916 }
 917
 918 static IPTR mNLV_SetScrollers(struct IClass *cl, Object *obj, struct MUIP_NListview_SetScrollers *msg)
 919 {
 920   struct NLVData *data = INST_DATA(cl, obj);
 921
 922   if(msg->scrollers & MUIV_NListview_VSB_On)
 923   {
 924     if(data->SETUP == FALSE || DoMethod(obj, MUIM_Group_InitChange))
 925     {
 926       if((msg->scrollers & MUIV_NListview_VSB_On) == MUIV_NListview_VSB_On)
 927       {
 928         AddVerticalScroller(obj, data);
 929         if(data->VertSB == MUIV_NListview_VSB_Left)
 930           DoMethod(obj, MUIM_Group_Sort, data->PR_Vert, data->Group, NULL);
 931       }
 932       else
 933       {
 934         RemoveVerticalScroller(obj, data);
 935       }
 936
 937       if(msg->scrollers & MUIV_NListview_HSB_On)
 938       {
 939         if(data->SETUP == FALSE || DoMethod(data->Group, MUIM_Group_InitChange))
 940         {
 941           if((msg->scrollers & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_On)
 942             AddHorizontalScroller(data->Group, data);
 943           else
 944             RemoveHorizontalScroller(data->Group, data);
 945
 946           if(data->SETUP == TRUE)
 947             DoMethod(data->Group, MUIM_Group_ExitChange);
 948         }
 949       }
 950
 951       if(data->SETUP == TRUE)
 952         DoMethod(obj, MUIM_Group_ExitChange);
 953     }
 954   }
 955   else if(msg->scrollers & MUIV_NListview_HSB_On)
 956   {
 957     if(data->SETUP == FALSE || DoMethod(data->Group, MUIM_Group_InitChange))
 958     {
 959       if((msg->scrollers & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_On)
 960         AddHorizontalScroller(data->Group, data);
 961       else
 962         RemoveHorizontalScroller(data->Group, data);
 963
 964       if(data->SETUP == TRUE)
 965         DoMethod(data->Group, MUIM_Group_ExitChange);
 966     }
 967   }
 968
 969   return 0;
 970 }
 971
 972 DISPATCHER(_Dispatcher)
 973 {
 974   switch(msg->MethodID)
 975   {
 976     case OM_NEW                     : return(mNLV_New(cl,obj,(APTR)msg));
 977     case OM_DISPOSE                 : return(mNLV_Dispose(cl,obj,(APTR)msg));
 978     case OM_GET                     : return(mNLV_Get(cl,obj,(APTR)msg));
 979     case OM_SET                     : return(mNLV_Set(cl,obj,(APTR)msg));
 980     case MUIM_Setup                 : return(mNLV_Setup(cl,obj,(APTR)msg));
 981     case MUIM_Cleanup               : return(mNLV_Cleanup(cl,obj,(APTR)msg));
 982     case MUIM_HandleInput           : return(mNLV_HandleInput(cl,obj,(APTR)msg));
 983     case MUIM_HandleEvent           : return(mNLV_HandleEvent(cl,obj,(APTR)msg));
 984     case MUIM_NList_QueryBeginning  : return(0);
 985     case MUIM_DragQuery             : return(MUIV_DragQuery_Refuse);
 986
 987     // we catch all notify relevant method
 988     // calls in one function
 989     case MUIM_KillNotify            :
 990     case MUIM_KillNotifyObj         :
 991     case MUIM_Notify                : return (mNLV_Notify(cl,obj,(APTR)msg));
 992
 993     case MUIM_GoActive              : return mNLV_GoActive(cl, obj, msg);
 994     case MUIM_GoInactive            : return mNLV_GoInactive(cl, obj, msg);
 995
 996     // the following method calls are all forwarded
 997     // to the corresponding NList object
 998     case MUIM_List_Sort             :
 999     case MUIM_List_Insert           :
1000     case MUIM_List_InsertSingle     :
1001     case MUIM_List_GetEntry         :
1002     case MUIM_List_Clear            :
1003     case MUIM_List_Jump             :
1004     case MUIM_List_Select           :
1005     case MUIM_List_TestPos          :
1006     case MUIM_List_Redraw           :
1007     case MUIM_List_Exchange         :
1008     case MUIM_List_Move             :
1009     case MUIM_List_NextSelected     :
1010     case MUIM_List_Remove           :
1011     case MUIM_List_CreateImage      :
1012     case MUIM_List_DeleteImage      :
1013     case MUIM_NList_Sort            :
1014     case MUIM_NList_Sort2           :
1015     case MUIM_NList_Insert          :
1016     case MUIM_NList_InsertSingle    :
1017     case MUIM_NList_GetEntry        :
1018     case MUIM_NList_Clear           :
1019     case MUIM_NList_Jump            :
1020     case MUIM_NList_Select          :
1021     case MUIM_NList_TestPos         :
1022     case MUIM_NList_Redraw          :
1023     case MUIM_NList_RedrawEntry     :
1024     case MUIM_NList_Exchange        :
1025     case MUIM_NList_Move            :
1026     case MUIM_NList_NextSelected    :
1027     case MUIM_NList_Remove          :
1028     case MUIM_NList_CreateImage     :
1029     case MUIM_NList_DeleteImage     :
1030     case MUIM_NList_CopyToClip      :
1031     case MUIM_NList_UseImage        :
1032     case MUIM_NList_ReplaceSingle   :
1033     case MUIM_NList_InsertWrap      :
1034     case MUIM_NList_InsertSingleWrap:
1035     case MUIM_NList_GetEntryInfo    :
1036     case MUIM_NList_GetSelectInfo   :
1037     case MUIM_NList_CopyTo          :
1038     case MUIM_NList_DropType        :
1039     case MUIM_NList_DropDraw        :
1040     case MUIM_NList_DoMethod        :
1041     case MUIM_NList_ColWidth        :
1042     case MUIM_NList_ColToColumn     :
1043     case MUIM_NList_ColumnToCol     :
1044     {
1045       struct NLVData *data = INST_DATA(cl, obj);
1046
1047       if(data->LI_NList != NULL)
1048         return DoMethodA(data->LI_NList, msg);
1049       else
1050         return 0;
1051     }
1052
1053     case MUIM_NListview_SetScrollers: return mNLV_SetScrollers(cl, obj, (APTR)msg);
1054
1055     default: return DoSuperMethodA(cl, obj, msg);
1056   }
1057 }