workbench/classes/gadgets/aroslist/listclass.c

   1 /*
   2     Copyright © 1995-2005, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     AROS specific list class implementation.
   6 */
   7
   8 #include <exec/types.h>
   9
  10 #include <proto/exec.h>
  11 #include <proto/intuition.h>
  12 #include <proto/utility.h>
  13 #include <exec/memory.h>
  14 #include <intuition/classusr.h>
  15 #include <aros/asmcall.h>
  16 #include <string.h>
  17
  18 #include "aroslist_intern.h"
  19 #include <gadgets/aroslist.h>
  20
  21 #define DEBUG 0
  22
  23 #include <aros/debug.h>
  24
  25 #undef AROSListBase
  26 #define AROSListBase ((struct LVBase *)(cl->cl_UserData))
  27
  28
  29 /*****************************************************************************/
  30
  31
  32
  33 #define SETFLAG(flagvar, boolvar, flag) \
  34     if (boolvar)                        \
  35         flagvar |= flag;                \
  36     else                                \
  37         flagvar &= ~flag;
  38
  39
  40
  41 /******************
  42 **  List::Set()  **
  43 ******************/
  44
  45 STATIC VOID SetActive(LONG pos, struct ListData *data)
  46 {
  47     if (data->ld_Active != AROSV_List_Active_None)
  48     {
  49         data->ld_PointerArray[data->ld_Active]->le_Flags &= ~LEFLG_SELECTED;
  50     }
  51
  52     if (pos != AROSV_List_Active_None)
  53     {
  54         data->ld_PointerArray[pos]->le_Flags |= LEFLG_SELECTED;
  55     }
  56     data->ld_Active = pos;
  57     return;
  58 }
  59 STATIC _OM_SET(Class *cl, Object *o,struct opSet *msg)
  60 {
  61     IPTR retval = (IPTR)0;
  62
  63     const struct TagItem *tag, *tstate;
  64     struct ListData *data;
  65
  66     data = INST_DATA(cl, o);
  67     tstate = msg->ops_AttrList;
  68
  69     /* Set to 1 to signal visual changes */
  70     while ((tag = NextTagItem(&tstate)) != NULL)
  71     {
  72         switch (tag->ti_Tag)
  73         {
  74
  75             case AROSA_List_ConstructHook:
  76                 data->ld_ConstructHook = (struct Hook *)tag->ti_Data;
  77                 break;
  78
  79             case AROSA_List_DestructHook:
  80                 data->ld_DestructHook  = (struct Hook *)tag->ti_Data;
  81                 break;
  82
  83
  84             case AROSA_List_Active:
  85                 SetActive((LONG)tag->ti_Data, data);
  86                 break;
  87
  88             default:
  89                 break;
  90
  91         } /* switch (tag->ti_Tag) */
  92
  93     } /* while ((tag = NextTagItem(&tstate)) != NULL) */
  94
  95     ReturnPtr("list_set", IPTR, retval);
  96 }
  97 IPTR AROSList__OM_SET(Class *cl, Object *o,struct opSet *msg)
  98 {
  99     IPTR retval = DoSuperMethodA(cl, o, msg);
 100     retval += _OM_SET(cl, o, msg);
 101     return retval;
 102 }
 103
 104 /*****************
 105 ** List::New()  **
 106 *****************/
 107 IPTR AROSList__OM_NEW(Class *cl, Object *o, struct opSet *msg)
 108 {
 109     o = (Object *)DoSuperMethodA(cl, o, (Msg)msg);
 110
 111     if (o)
 112     {
 113         struct ListData *data;
 114         APTR *srcarray = NULL;
 115         const struct TagItem *tag, *tstate;
 116
 117         ULONG puddlesz = 2008, threshsz = 1024;
 118
 119         D(bug("list, OM_NEW: obj returned from superclass\n"));
 120         data = INST_DATA(cl, o);
 121         memset(data, 0, sizeof (struct ListData));
 122
 123         /* Initialize the object's internal lists */
 124         NewLEList(data->ld_EntryTables);
 125         NewLEList(data->ld_UnusedEntries);
 126
 127         /* Parse for some init only tags */
 128         tstate = msg->ops_AttrList;
 129         while ((tag = NextTagItem(&tstate)) != NULL)
 130         {
 131             switch (tag->ti_Tag)
 132             {
 133                 case AROSA_List_SourceArray:
 134                     srcarray = (APTR *)tag->ti_Data;
 135                     break;
 136
 137                 case AROSA_List_PoolPuddleSize:
 138                     puddlesz = (ULONG)tag->ti_Data;
 139                     break;
 140
 141                 case AROSA_List_PoolThreshSize:
 142                     threshsz = (ULONG)tag->ti_Data;
 143                     break;
 144                 case AROSA_List_Pool:
 145                     data->ld_Pool = (APTR)tag->ti_Data;
 146                     break;
 147
 148             } /* switch (tag->ti_Tag) */
 149
 150         } /* while (more tags in taglist) */
 151
 152
 153         /* User supplied source array ? */
 154         srcarray = (APTR *)GetTagData(AROSA_List_SourceArray, (IPTR) NULL, msg->ops_AttrList);
 155
 156         /* Allocate a bunch of free listentries */
 157         data->ld_PointerArray = AllocEntries( (srcarray != NULL)
 158                                                 ? CountItems(srcarray)
 159                                                 : NUMENTRIES_TO_ADD,
 160                                             data
 161         );
 162
 163         if (!data->ld_Pool)
 164         {
 165             data->ld_Pool = CreatePool(MEMF_ANY, puddlesz, threshsz);
 166         }
 167
 168         D(bug("listclass, OM_NEW: pointerarray = %p, pool = %p\n",
 169                 data->ld_PointerArray, data->ld_Pool));
 170
 171         if (!data->ld_PointerArray || !data->ld_Pool)
 172         {
 173             CoerceMethod(cl, o, OM_DISPOSE);
 174             return (IPTR) NULL;
 175         }
 176
 177         /* As default there is no active entry */
 178         data->ld_Active = AROSV_List_Active_None;
 179
 180         /* Handle our special tags - overrides defaults. This must be done
 181         before the AROSM_List_Insert call, because we must get the ConstructHook and
 182         DestructHook tags */
 183
 184         _OM_SET(cl, o, msg);
 185
 186         if (srcarray)
 187         {
 188             DoMethod(o, AROSM_List_Insert, (IPTR) srcarray, AROSV_List_Insert_Top);
 189         }
 190
 191
 192
 193     } /* if (object created) */
 194     return ((IPTR)o);
 195
 196 }
 197
 198 /*********************
 199 ** List::Dispose()  **
 200 *********************/
 201
 202 VOID AROSList__OM_DISPOSE(Class *cl, Object *o, Msg msg)
 203 {
 204 #warning TODO: Call destructhook too
 205
 206     struct ListData *data;
 207     struct ListEntry *entry, *next;
 208
 209     data = INST_DATA(cl, o);
 210
 211     D(bug("Inside OM_DISPOSE\n"));
 212     DoMethod(o, AROSM_List_Clear);
 213
 214     entry = data->ld_EntryTables;
 215     while (entry)
 216     {
 217         next = entry->le_Next;
 218         FreeVec(entry);
 219         entry = next;
 220     }
 221
 222     if (data->ld_PointerArray)
 223         FreeVec(data->ld_PointerArray);
 224
 225     if (data->ld_Pool)
 226         DeletePool(data->ld_Pool);
 227
 228     DoSuperMethodA(cl, o, msg);
 229 }
 230
 231 /*****************
 232 ** List::Get()  **
 233 *****************/
 234
 235 IPTR AROSList__OM_GET(Class *cl, Object *o, struct opGet *msg)
 236 {
 237     IPTR retval = 1UL;
 238     struct ListData *data;
 239
 240     data = INST_DATA(cl, o);
 241
 242     switch (msg->opg_AttrID)
 243     {
 244         case AROSA_List_Entries:
 245             *(msg->opg_Storage) = (IPTR)data->ld_NumEntries;
 246             break;
 247
 248         case AROSA_List_Active:
 249             *(msg->opg_Storage) = (IPTR)data->ld_Active;
 250             break;
 251
 252         default:
 253             retval = DoSuperMethodA(cl, o, (Msg)msg);
 254             break;
 255     }
 256     return (retval);
 257 }
 258
 259 /********************
 260 ** List::Insert()  **
 261 ********************/
 262 ULONG AROSList__AROSM_List_Insert(Class *cl, Object *o, struct AROSP_List_Insert *msg)
 263 {
 264     struct ListData *data;
 265
 266     register ULONG items2insert;
 267     register ULONG pos;
 268
 269     ULONG numinserted;
 270
 271     ULONG items_below_insertion;
 272
 273
 274     data = INST_DATA(cl, o);
 275
 276     items2insert = CountItems(msg->ItemArray);
 277     pos = msg->Position;
 278
 279     /* Special value ? */
 280     if (pos < 0)
 281     {
 282         switch (pos)
 283         {
 284             case AROSV_List_Insert_Top:
 285                 pos = 0L;
 286                 break;
 287             case AROSV_List_Insert_Bottom:
 288                 pos = data->ld_NumEntries;
 289                 break;
 290
 291             default:
 292                 pos = data->ld_NumEntries;
 293                 break;
 294
 295         } /* switch (pos) */
 296
 297     } /* if (pos < 0) */
 298
 299     else if (pos > data->ld_NumEntries)
 300     {
 301         pos = data->ld_NumEntries;
 302     }
 303
 304     items_below_insertion = data->ld_NumEntries - pos;
 305
 306     /* To little space left ? */
 307     if (items2insert > data->ld_NumAllocated - data->ld_NumEntries)
 308     {
 309         struct ListEntry **newptrarray;
 310
 311         newptrarray = AllocEntries(items2insert, data);
 312         if (!newptrarray)
 313             return (0UL);
 314
 315         /* Copy all old entries BEFORE the new ones, into the new array */
 316         if (pos != AROSV_List_Insert_Top)
 317         {
 318             CopyMem(    data->ld_PointerArray,
 319                         newptrarray,
 320                         UB(newptrarray[pos]) - UB(newptrarray[0]));
 321         }
 322
 323         /* Now insert the entries themselves */
 324         numinserted = InsertItems(msg->ItemArray, newptrarray, pos, data);
 325
 326         /* Copy all the entries BELOW the inserted value */
 327         if (pos != data->ld_NumEntries)
 328         {
 329             CopyMem(&(data->ld_PointerArray[pos]),
 330                 &newptrarray[pos + numinserted],
 331                 UB(newptrarray[items_below_insertion] ) - UB(newptrarray[0]));
 332         }
 333         /* Free the old buffer */
 334         FreeVec(data->ld_PointerArray);
 335
 336         data->ld_PointerArray = newptrarray;
 337
 338     }
 339     else
 340     {
 341
 342         /* Insert at end of array ? */
 343         if (pos == data->ld_NumEntries)
 344         {
 345
 346             numinserted = InsertItems(msg->ItemArray,
 347                                 data->ld_PointerArray,
 348                                 pos,
 349                                 data
 350             );
 351             D(bug("lins: inserted %d entries at end of list\n", numinserted));
 352         }
 353         else
 354         {
 355
 356             /* Insertion in the middle of the array.
 357              We have to move the some items down so we can
 358              to get space for inserting the items */
 359             register ULONG i;
 360             register struct ListEntry **ptr;
 361
 362             ptr = &(data->ld_PointerArray[data->ld_NumEntries - 1]);
 363             for (i = items_below_insertion; i; i -- )
 364             {
 365                 ptr[items2insert] = *ptr;
 366                 ptr --;
 367             }
 368
 369             numinserted = InsertItems(msg->ItemArray, data->ld_PointerArray, pos, data);
 370             if (numinserted < items2insert)
 371             {
 372                 /*
 373                  * Ouch ! Insertion of some (or all) items failed, and we have to move
 374                  * the below items up again
 375                  */
 376
 377                  ULONG delta = items2insert - numinserted;
 378
 379                  ptr = &(data->ld_PointerArray[pos + numinserted /* This is where the items got moved */]);
 380
 381                  for (i = items_below_insertion; i; i --)
 382                  {
 383
 384                      *ptr = ptr[delta];
 385                      ptr ++;
 386
 387                  } /* for (number of items to move) */
 388
 389             } /* if (not all entries inserted successfully) */
 390
 391         } /* if (Insert at end of arry or in middle) */
 392
 393     } /* if (Enough entries left for insertion) */
 394
 395
 396
 397     /* "Refresh" pos of the active entry */
 398     if (pos <= data->ld_Active && data->ld_Active != AROSV_List_Active_None)
 399     {
 400         SetActive(data->ld_Active + numinserted, data);
 401     }
 402
 403     data->ld_NumEntries += numinserted;
 404
 405
 406     return (numinserted);
 407 }
 408
 409 /***************************
 410 **  List::InsertSingle()  **
 411 ***************************/
 412 IPTR AROSList__AROSM_List_InsertSingle(Class *cl, Object *o, struct AROSP_List_InsertSingle *msg)
 413 {
 414
 415     APTR ptrarray[2];
 416     struct AROSP_List_Insert insert_msg;
 417
 418     ptrarray[0] = msg->Item;
 419     ptrarray[1] = NULL;
 420
 421     insert_msg.MethodID     = AROSM_List_Insert;
 422     insert_msg.ItemArray    = ptrarray;
 423     insert_msg.Position     = msg->Position;
 424
 425     return (IPTR)AROSList__AROSM_List_Insert(cl, o, &insert_msg);
 426 }
 427
 428 /*********************
 429 **  List::Remove()  **
 430 *********************/
 431 VOID AROSList__AROSM_List_Remove(Class *cl, Object *o, struct AROSP_List_Remove *msg)
 432 {
 433
 434
 435     struct ListData *data;
 436     LONG pos;
 437     LONG lastpos;
 438     struct ListEntry **ptr;
 439
 440     data = INST_DATA(cl, o);
 441
 442     pos = msg->Position;
 443     lastpos = data->ld_NumEntries - 1;
 444
 445     if (pos < 0) /* Special value ? */
 446     {
 447         switch (pos)
 448         {
 449             case AROSV_List_Remove_First:
 450                 pos = 0;
 451                 break;
 452
 453             case AROSV_List_Remove_Last:
 454                 pos = lastpos;
 455                 break;
 456
 457             default:
 458                 /* No meaning */
 459                 return;
 460         } /* switch (pos) */
 461     }
 462
 463     if (pos > lastpos)
 464     {
 465         /* Cannot remove a non-existing entry */
 466         return;
 467     }
 468
 469
 470     /* Call destructhook for entry */
 471     if (data->ld_DestructHook)
 472     {
 473         CallHookPkt(data->ld_DestructHook,
 474                 data->ld_Pool,
 475                 data->ld_PointerArray[pos]->le_Item);
 476     }
 477     /* Add item to freelist */
 478     AddLEHead(data->ld_UnusedEntries, data->ld_PointerArray[pos]);
 479     data->ld_NumEntries --;
 480
 481     /* "Refresh" pos of the active entry */
 482     if (    pos <= data->ld_Active
 483         &&  data->ld_Active != AROSV_List_Active_None
 484         &&  data->ld_Active != 0)
 485     {
 486         SetActive( ((data->ld_NumEntries)
 487                         ? data->ld_Active - 1 : AROSV_List_Active_None),
 488                     data);
 489     }
 490
 491     /* Skip the specialcase where we remove the last entry */
 492     if (pos < lastpos)
 493     {
 494         register ULONG i;
 495
 496         ptr = &(data->ld_PointerArray[pos]);
 497
 498         /* We remove a entry in the middle of the array and must move
 499         all lower items up to fill the gap */
 500
 501         for (i = lastpos - pos; i; i --)
 502         {
 503            *ptr = ptr[1];
 504            ptr ++;
 505         }
 506     }
 507     return;
 508 }
 509
 510 /********************
 511 **  List::Clear()  **
 512 ********************/
 513 VOID AROSList__AROSM_List_Clear(Class *cl, Object *o, Msg msg)
 514 {
 515     register LONG pos;
 516     struct ListData *data = INST_DATA(cl, o);
 517
 518 D(bug("List::Clear()\n"));
 519
 520     for (pos = 0; pos < data->ld_NumEntries; pos ++)
 521     {
 522 D(bug("\tClearing entry at pos %d\n", pos));
 523
 524         if (data->ld_DestructHook)
 525         {
 526             CallHookPkt(data->ld_DestructHook,
 527                 data->ld_Pool,
 528                 data->ld_PointerArray[pos]->le_Item);
 529         }
 530
 531 D(bug("Addidng to freeentrylist\n"));
 532         /* Add item to freelist */
 533         AddLEHead(data->ld_UnusedEntries, data->ld_PointerArray[pos]);
 534
 535     }
 536     data->ld_NumEntries = 0;
 537     /* "Refresh" pos of the active entry */
 538     SetActive(AROSV_List_Active_None, data);
 539
 540     return;
 541 }
 542
 543
 544 /*********************
 545 **  List::Select()  **
 546 *********************/
 547 VOID AROSList__AROSM_List_Select(Class *cl, Object *o, Msg msg)
 548 {
 549     /* We _could_ put the Select_All stuff together
 550        with the singlemode but that would slow down singlemode a little */
 551 #undef S
 552 #define S(msg) ((struct AROSP_List_Select *)msg)
 553     struct ListData *data = INST_DATA(cl, o);
 554
 555     if (S(msg)->Position != AROSV_List_Select_All)
 556     {
 557         struct ListEntry *le;
 558
 559         le = data->ld_PointerArray[S(msg)->Position];
 560
 561         switch (S(msg)->SelType)
 562         {
 563         case AROSV_List_Select_On:
 564             le->le_Flags |= LEFLG_SELECTED;
 565             break;
 566
 567         case AROSV_List_Select_Off:
 568             le->le_Flags &= ~LEFLG_SELECTED;
 569             break;
 570
 571         case AROSV_List_Select_Toggle:
 572             le->le_Flags ^= LEFLG_SELECTED;
 573             break;
 574
 575         case AROSV_List_Select_Ask:
 576             *(S(msg)->State) = ((le->le_Flags & LEFLG_SELECTED) != 0);
 577             break;
 578         }
 579     }
 580     else
 581     {
 582         register LONG pos;
 583         register struct ListEntry *le;
 584
 585         *(S(msg)->State) = 0;
 586
 587         for (pos = 0; pos < data->ld_NumEntries; pos ++)
 588         {
 589             le = data->ld_PointerArray[S(msg)->Position];
 590             switch (S(msg)->SelType)
 591             {
 592             case AROSV_List_Select_On:
 593                 le->le_Flags |= LEFLG_SELECTED;
 594                 break;
 595
 596             case AROSV_List_Select_Off:
 597                 le->le_Flags &= ~LEFLG_SELECTED;
 598                 break;
 599
 600             case AROSV_List_Select_Toggle:
 601                 le->le_Flags ^= LEFLG_SELECTED;
 602                 break;
 603
 604             case AROSV_List_Select_Ask:
 605                 if (le->le_Flags & LEFLG_SELECTED)
 606                 {
 607                     *(S(msg)->State) += 1;
 608                 }
 609                 break;
 610             }
 611         }
 612     }
 613 }
 614
 615
 616 /***************************
 617 **  List::NextSelected()  **
 618 ***************************/
 619 VOID AROSList__AROSM_List_NextSelected(Class *cl, Object *o, Msg msg)
 620 {
 621 #undef NS
 622 #define NS(msg) ((struct AROSP_List_NextSelected *)msg)
 623
 624     struct ListData *data = INST_DATA(cl, o);
 625     register LONG pos;
 626
 627     pos = *(NS(msg)->Position);
 628
 629     if (pos == AROSV_List_NextSelected_Start)
 630         pos = 0;
 631
 632     for (; pos < data->ld_NumEntries; pos ++)
 633     {
 634         if (data->ld_PointerArray[pos]->le_Flags & LEFLG_SELECTED)
 635         {
 636             *(NS(msg)->Position) = pos;
 637             return;
 638         }
 639     }
 640
 641     *(NS(msg)->Position) = AROSV_List_NextSelected_End;
 642 }
 643
 644
 645 /***********************
 646 **  List::GetEntry()  **
 647 ***********************/
 648 VOID AROSList__AROSM_List_GetEntry(Class *cl, Object *o, Msg msg)
 649 {
 650 #undef GE
 651 #define GE(msg) ((struct AROSP_List_GetEntry *)msg)
 652
 653     struct ListData *data;
 654
 655     data = INST_DATA(cl, o);
 656
 657     if (GE(msg)->Position >= data->ld_NumEntries || GE(msg)->Position < 0)
 658         *(GE(msg)->ItemPtr) = NULL;
 659     else
 660         *(GE(msg)->ItemPtr) = data->ld_PointerArray[GE(msg)->Position]->le_Item;
 661 }
 662