bgui/task.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * task.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 42.13  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.12  2003/01/18 19:10:01  chodorowski
  18  * Instead of using the _AROS or __AROS preprocessor symbols, use __AROS__.
  19  *
  20  * Revision 42.11  2001/01/28 04:53:21  bergers
  21  * Fixed some compiler complaints (some casts were missing.).
  22  *
  23  * Revision 42.10  2000/08/09 14:54:19  stegerg
  24  * fixed a bug which was introduced by one of us AROS guys and which caused
  25  * enforcer hits on Amiga.
  26  *
  27  * Revision 42.9  2000/08/09 11:45:57  chodorowski
  28  * Removed a lot of #ifdefs that disabled the AROS_LIB* macros when not building on AROS. This is now handled in contrib/bgui/include/bgui_compilerspecific.h.
  29  *
  30  * Revision 42.8  2000/08/08 18:16:12  stegerg
  31  * bug fix in BGUI_FreePoolMem/FreePoolMemDebug.
  32  *
  33  * Revision 42.7  2000/08/08 14:17:30  chodorowski
  34  * Fixes to compile on Amiga. There was some wrongly nested #ifdefs here,
  35  * around the BGUI_FreePooled and BGUI_FreePooledDebug functions.
  36  * Now it compiles, but I'm a bit dubiuos if it works as it should.
  37  * Could someone have a look please?
  38  *
  39  * Revision 42.6  2000/07/06 16:44:03  stegerg
  40  * AddTaskMember can now be called. Problem was Cli()->cli_CommandName
  41  * which BGUI expected to be a BSTR with size in first byte.
  42  *
  43  * Revision 42.5  2000/06/01 01:41:37  bergers
  44  * Only 2 linker problems left: stch_l & stcu_d. Somebody might want to replace them (embraced by #ifdef __AROS__), please.
  45  *
  46  * Revision 42.4  2000/05/31 01:23:10  bergers
  47  * Changes to make BGUI compilable and linkable.
  48  *
  49  * Revision 42.3  2000/05/29 00:40:24  bergers
  50  * Update to compile with AROS now. Should also still compile with SASC etc since I only made changes that test the define __AROS__. The compilation is still very noisy but it does the trick for the main directory. Maybe members of the BGUI team should also have a look at the compiler warnings because some could also cause problems on other systems... (Comparison always TRUE due to datatype (or something like that)). And please compile it on an Amiga to see whether it still works... Thanks.
  51  *
  52  * Revision 42.2  2000/05/15 19:27:02  stegerg
  53  * another hundreds of REG() macro replacements in func headers/protos.
  54  *
  55  * Revision 42.1  2000/05/14 23:32:48  stegerg
  56  * changed over 200 function headers which all use register
  57  * parameters (oh boy ...), because the simple REG() macro
  58  * doesn't work with AROS. And there are still hundreds
  59  * of headers left to be fixed :(
  60  *
  61  * Many of these functions would also work with stack
  62  * params, but since i have fixed every single one
  63  * I encountered up to now, I guess will have to do
  64  * the same for the rest.
  65  *
  66  * Revision 42.0  2000/05/09 22:10:28  mlemos
  67  * Bumped to revision 42.0 before handing BGUI to AROS team
  68  *
  69  * Revision 41.11  2000/05/09 19:55:18  mlemos
  70  * Merged with the branch Manuel_Lemos_fixes.
  71  *
  72  * Revision 41.10.2.10  1998/12/07 14:47:28  mlemos
  73  * Made font tracking code use a copy of the TextFont structure to allow the
  74  * opened fonts be properly tracked.
  75  *
  76  * Revision 41.10.2.9  1998/12/07 04:30:04  mlemos
  77  * Made the code that lists all unclosed fonts to list all probable source
  78  * locations where the fonts were opened.
  79  *
  80  * Revision 41.10.2.8  1998/12/07 03:04:37  mlemos
  81  * Added conditional debug code to track fonts opened by BGUI classes.
  82  *
  83  * Revision 41.10.2.7  1998/06/18 22:06:36  mlemos
  84  * Made BGUI fetch the preferences from the appropriate file when running from
  85  * CLI.
  86  *
  87  * Revision 41.10.2.6  1998/03/02 03:14:39  mlemos
  88  * Corrected the display of the memory leak address.
  89  *
  90  * Revision 41.10.2.5  1998/03/01 23:09:19  mlemos
  91  * Added code to trash memory allocations before being freed.
  92  * Added code to warn when a NULL pointer is passed to memory release.
  93  *
  94  * Revision 41.10.2.4  1998/03/01 18:42:45  mlemos
  95  * Corrected memory wall address verifications.
  96  *
  97  * Revision 41.10.2.3  1998/03/01 18:25:00  mlemos
  98  * Added support to track memory overwriting outside the allocated space.
  99  *
 100  * Revision 41.10.2.2  1998/03/01 04:25:23  mlemos
 101  * Added support to track memory freeing mismatches and memory leaks.
 102  *
 103  * Revision 41.10.2.1  1998/03/01 02:23:56  mlemos
 104  * Added new memory allocation debugging functions to the library
 105  *
 106  * Revision 41.10  1998/02/25 21:13:21  mlemos
 107  * Bumping to 41.10
 108  *
 109  * Revision 1.1  1998/02/25 17:09:56  mlemos
 110  * Ian sources
 111  *
 112  *
 113  */
 114
 115 #define NO_MEMORY_ALLOCATION_DEBUG_ALIASING
 116
 117 #include "include/classdefs.h"
 118
 119 /*
 120  * Global data.
 121  */
 122
 123 makeproto TL                     TaskList;   /* List of openers.         */
 124 makeproto struct SignalSemaphore TaskLock;   /* For exclusive task-list access. */
 125
 126 static APTR MemPool = NULL;
 127
 128 static void LoadPrefs(UBYTE *name);
 129 static void DefPrefs(void);
 130
 131 #ifdef DEBUG_BGUI
 132
 133 static struct BlockHeader
 134 {
 135         struct BlockHeader *NextBlock;
 136         ULONG BlockSize;
 137         APTR Address;
 138         ULONG Size;
 139         APTR PoolHeader;
 140         STRPTR File;
 141         ULONG Line;
 142 }
 143 *MemoryBlocks=NULL;
 144
 145 union TypesUnion
 146 {
 147         long int LongInteger;
 148         long double LongDouble;
 149         void *DataPointer;
 150         void (*FunctionPointer)(void);
 151 };
 152
 153 #define AlignMemory(offset) (((offset)+sizeof(union TypesUnion)-1)/sizeof(union TypesUnion))*sizeof(union TypesUnion)
 154
 155 #define MEMORY_WALL_SIZE 8
 156
 157 #define MEMORY_WALL_TRASH 'W'
 158 #define MEMORY_FREE_TRASH 'Y'
 159
 160 #define BLOCK_HEADER_OFFSET AlignMemory(sizeof(struct BlockHeader)+MEMORY_WALL_SIZE)
 161
 162 #define TrashMemory(memory,size,character) memset(memory,character,size)
 163
 164 static ASM VOID FreeVecMemDebug(REG(a0) APTR pool, REG(a1) APTR memptr, REG(a2) STRPTR file, REG(d0) ULONG line);
 165
 166 static ASM APTR AllocVecMemDebug(REG(a0) APTR mempool, REG(d0) ULONG size,REG(a1) STRPTR file, REG(d1) ULONG line);
 167
 168 #define AllocVecMem(mempool,size) AllocVecMemDebug(mempool,size,__FILE__,__LINE__)
 169 #define FreeVecMem(pool,memptr) FreeVecMemDebug(pool,memptr,__FILE__,__LINE__)
 170
 171 static BOOL VerifyMemoryWall(char *memory)
 172 {
 173         ULONG size;
 174
 175         for(size=MEMORY_WALL_SIZE;size;size--,memory++)
 176         {
 177                 if(*memory!=MEMORY_WALL_TRASH)
 178                         return(FALSE);
 179         }
 180         return(TRUE);
 181 }
 182
 183 #else
 184 static ASM APTR AllocVecMem(REG(a0) APTR mempool, REG(d0) ULONG size);
 185
 186 static ASM VOID FreeVecMem(REG(a0) APTR pool, REG(a1) APTR memptr);
 187 #endif
 188
 189 static SAVEDS ASM APTR BGUI_CreatePool(REG(d0) ULONG memFlags, REG(d1) ULONG puddleSize, REG(d2) ULONG threshSize);
 190
 191 static SAVEDS ASM VOID BGUI_DeletePool(REG(a0) APTR poolHeader);
 192
 193 /*
 194  * Initialize task list.
 195  */
 196 makeproto void InitTaskList(void)
 197 {
 198    /*
 199     * Initialize task-list.
 200     */
 201    NewList((struct List *)&TaskList);
 202
 203    /*
 204     * And window list.
 205     */
 206    NewList((struct List *)&TaskList.tl_WindowList);
 207
 208    /*
 209     * Initialize task-list access semaphore.
 210     */
 211    InitSemaphore(&TaskLock);
 212
 213    /*
 214     * Create memory pool.
 215     */
 216    MemPool = BGUI_CreatePool(MEMF_PUBLIC | MEMF_CLEAR, 4096, 4096);
 217 }
 218
 219 #ifdef DEBUG_BGUI
 220
 221 static struct FontEntry
 222 {
 223         struct FontEntry *NextFont;
 224         struct TextFont *Font;
 225         BOOL Closed;
 226         STRPTR File;
 227         ULONG Line;
 228         struct TextFont Copy;
 229 }
 230 *FontEntries=NULL;
 231
 232 static void BGUI_CloseAllFonts(void)
 233 {
 234         struct FontEntry *font_entry;
 235
 236         for(font_entry=FontEntries;font_entry;font_entry=font_entry->NextFont)
 237         {
 238                 if(font_entry->Closed==FALSE)
 239                 {
 240             D(bug("***Font leak (%lx) \"%s\" %s,%lu:\n",font_entry->Font,font_entry->Font->tf_Message.mn_Node.ln_Name ? font_entry->Font->tf_Message.mn_Node.ln_Name : "Unnamed font",font_entry->File ? font_entry->File : (STRPTR)"Unknown source",font_entry->Line));
 241                         CloseFont(font_entry->Font);
 242                         font_entry->Closed=TRUE;
 243                 }
 244         }
 245         while((font_entry=FontEntries))
 246         {
 247                 FontEntries=font_entry->NextFont;
 248                 BGUI_FreePoolMemDebug(font_entry,__FILE__,__LINE__);
 249         }
 250 }
 251
 252 makeproto struct TextFont *BGUI_OpenFontDebug(struct TextAttr *textAttr,STRPTR file,ULONG line)
 253 {
 254         struct TextFont *font;
 255
 256         if((font=OpenFont(textAttr)))
 257         {
 258                 struct FontEntry *font_entry;
 259
 260                 if((font_entry=BGUI_AllocPoolMemDebug(sizeof(*font_entry),__FILE__,__LINE__)))
 261                 {
 262                         font_entry->Font=font;
 263                         font_entry->Closed=FALSE;
 264                         font_entry->File=file;
 265                         font_entry->Line=line;
 266                         font_entry->Copy= *font;
 267                         ObtainSemaphore(&TaskLock);
 268                         font_entry->NextFont=FontEntries;
 269                         FontEntries=font_entry;
 270                         ReleaseSemaphore(&TaskLock);
 271                         font= &font_entry->Copy;
 272                 }
 273                 else
 274                 {
 275                         CloseFont(font);
 276                         font=NULL;
 277                 }
 278         }
 279         return(font);
 280 }
 281
 282 makeproto void BGUI_CloseFontDebug(struct TextFont *font,STRPTR file,ULONG line)
 283 {
 284         struct FontEntry **font_entry,*free_font_entry;
 285
 286         if(font==NULL)
 287         {
 288                 D(bug("***Attempt to close an NULL font (%s,%lu)\n",file ? file : (STRPTR)"Unknown source",line));
 289                 return;
 290         }
 291         ObtainSemaphore(&TaskLock);
 292         for(font_entry=&FontEntries;*font_entry && (&((*font_entry)->Copy)!=font || (*font_entry)->Closed);font_entry=&(*font_entry)->NextFont);
 293         if((free_font_entry=*font_entry)
 294         && &free_font_entry->Copy==font)
 295         {
 296                 CloseFont(free_font_entry->Font);
 297                 free_font_entry->Closed=TRUE;
 298         }
 299         else
 300                 D(bug("***Attempt to close an unknown font (%lx) \"%s\" (%s,%lu)\n",font,font->tf_Message.mn_Node.ln_Name ? font->tf_Message.mn_Node.ln_Name : "Unnamed font",file ? file : (STRPTR)"Unknown source",line));
 301         ReleaseSemaphore(&TaskLock);
 302 }
 303
 304 #else
 305 #define BGUI_CloseAllFonts()
 306 #endif
 307
 308 /*
 309  * Free task list.
 310  */
 311 makeproto void FreeTaskList(void)
 312 {
 313    BGUI_CloseAllFonts();
 314    /*
 315     * Delete memory pool.
 316     */
 317    BGUI_DeletePool(MemPool);
 318 }
 319
 320 /*
 321  * Find a task member.
 322  *
 323  * Changes made by T.Herold:
 324  *
 325  * InternalFindTaskMember searches for a certain task in
 326  * the tasklist. FindTaskMember does this with FindTask(NULL)
 327  * as a parameter (just the way it always did). This keeps
 328  * changes to other functions to a minimum.
 329  *
 330  * Only AddIDReport will use InternalFind...
 331  */
 332
 333 makeproto TM *FindTaskMember(void)
 334 {
 335    return InternalFindTaskMember(FindTask(NULL));
 336 }
 337
 338 makeproto TM *InternalFindTaskMember(struct Task *task)
 339 {
 340    TM    *tm;
 341
 342    /*
 343     *  Look through the list for the member.
 344     */
 345    for (tm = TaskList.tl_First; tm->tm_Next; tm = tm->tm_Next)
 346    {
 347       if (tm->tm_TaskAddr == task) return tm;
 348    }
 349    return NULL;
 350 }
 351
 352
 353 /*
 354  * Add a task member to the list.
 355  */
 356 makeproto UWORD AddTaskMember(void)
 357 {
 358    TM       *tm;
 359    UWORD     rc = TASK_FAILED;
 360    UBYTE     buffer[64];
 361
 362    /*
 363     * Lock the list.
 364     */
 365    ObtainSemaphore(&TaskLock);
 366
 367    /*
 368     * Does this task already have the
 369     * library open?
 370     */
 371    if ((tm = FindTaskMember()))
 372    {
 373       /*
 374        * Yes. Increase open counter,
 375        * unlock the semaphore and
 376        * exit.
 377        */
 378       tm->tm_Counter++;
 379       ReleaseSemaphore(&TaskLock);
 380       return TASK_REOPENED;
 381    };
 382
 383    /*
 384     * Allocate a task member structure.
 385     */
 386    if ((tm = AllocVecMem(MemPool, sizeof(TM))))
 387    {
 388       /*
 389        * Setup task address and counter.
 390        */
 391       tm->tm_TaskAddr = FindTask(NULL);
 392       tm->tm_Counter  = 1;
 393
 394       /*
 395        * Initialize lists.
 396        */
 397       NewList((struct List *)&tm->tm_Windows);
 398       NewList((struct List *)&tm->tm_Prefs);
 399       NewList((struct List *)&tm->tm_RID);
 400
 401       /*
 402        * Append it to the list.
 403        */
 404       AddTail((struct List *)&TaskList, (struct Node *)tm);
 405
 406       DefPrefs();
 407       sprintf(buffer, "ENV:BGUI/%s.prefs", "Default");
 408       LoadPrefs(buffer);
 409       if(Cli())
 410       {
 411          STRPTR command_name,insert;
 412          size_t offset;
 413          UWORD command_len;
 414
 415          command_name=BADDR(Cli()->cli_CommandName);
 416          strcpy(buffer,"ENV:BGUI/");
 417          insert=buffer+sizeof("ENV:BGUI/")-1;
 418          #ifdef __AROS__
 419          strcpy(insert,command_name);
 420          command_len = strlen(command_name);
 421          #else
 422          memcpy(insert,command_name+1,*command_name);
 423          command_len = *command_name;
 424          *(insert+ command_len)='\0';
 425          #endif
 426          if((offset=FilePart(insert)-insert)!=0)
 427            memcpy(insert,command_name+1+offset,command_len-offset);
 428          insert+= command_len-offset;
 429          strcpy(insert,".prefs");
 430       }
 431       else
 432          sprintf(buffer, "ENV:BGUI/%s.prefs", FilePart(((struct Node *)(tm->tm_TaskAddr))->ln_Name));
 433       LoadPrefs(buffer);
 434
 435       rc = TASK_ADDED;
 436    }
 437
 438    /*
 439     * Unlock the list.
 440     */
 441    ReleaseSemaphore(&TaskLock);
 442
 443    return rc;
 444 }
 445
 446
 447 static void FreeTL_PI(PI *pi)
 448 {
 449    FreeTagItems(pi->pi_Defaults);
 450    FreeVecMem(MemPool, pi);
 451 }
 452 static void FreeTL_WI(WI *wi)
 453 {
 454    FreeVecMem(MemPool, wi);
 455 }
 456 static void FreeTL_RID(RID *rid)
 457 {
 458    FreeVecMem(MemPool, rid);
 459 }
 460
 461 /*
 462  * Free task member.
 463  */
 464 makeproto BOOL FreeTaskMember( void )
 465 {
 466    TM       *tm;
 467    PI       *pi;
 468    WI       *wi;
 469    RID      *rid;
 470
 471    /*
 472     * Lock the list.
 473     */
 474    ObtainSemaphore(&TaskLock);
 475
 476    /*
 477     * Find the task member.
 478     */
 479    if ((tm = FindTaskMember()))
 480    {
 481       /*
 482        * Last opener?
 483        */
 484       if (--tm->tm_Counter)
 485       {
 486          /*
 487           * No. release the semaphore and exit.
 488           */
 489          ReleaseSemaphore(&TaskLock);
 490          return FALSE;
 491       }
 492
 493       /*
 494        * Remove it from the list.
 495        */
 496       Remove((struct Node *)tm);
 497
 498       /*
 499        * Remove and delete window/id stuff.
 500        */
 501       while ((pi  = (PI *)RemHead((struct List *)&tm->tm_Prefs)))   FreeTL_PI(pi);
 502       while ((wi  = (WI *)RemHead((struct List *)&tm->tm_Windows))) FreeTL_WI(wi);
 503       while ((rid = (RID *)RemHead((struct List *)&tm->tm_RID)))    FreeTL_RID(rid);
 504
 505       FreeVecMem(MemPool, tm);
 506    };
 507
 508    /*
 509     * Unlock the list.
 510     */
 511    ReleaseSemaphore(&TaskLock);
 512
 513    return TRUE;
 514 }
 515
 516 /*
 517  * Look up a window.
 518  */
 519 STATIC WI *FindWindowInfo(ULONG id, WL *wl)
 520 {
 521    WI       *wi;
 522
 523    /*
 524     * Scan the window list.
 525     */
 526    for (wi = wl->wl_First; wi->wi_Next; wi = wi->wi_Next)
 527    {
 528       if (id == wi->wi_WinID)
 529          return wi;
 530    }
 531    return NULL;
 532 }
 533
 534 /*
 535  * Obtain the window bounds.
 536  */
 537 makeproto BOOL GetWindowBounds(ULONG windowID, struct IBox *dest)
 538 {
 539    TM       *tm;
 540    WI       *wi;
 541    BOOL         rc = FALSE;
 542
 543    /*
 544     * No 0 ID!
 545     */
 546    if (!windowID)
 547       return FALSE;
 548
 549    /*
 550     * Gain exclusive access.
 551     */
 552    ObtainSemaphore( &TaskLock );
 553
 554    /*
 555     * Look up the task member.
 556     */
 557    if ((tm = FindTaskMember()))
 558    {
 559       /*
 560        * Window already in the list?
 561        */
 562       if ((wi = FindWindowInfo(windowID, &tm->tm_Windows)))
 563       {
 564          /*
 565           * Copy the data to dest.
 566           */
 567          *dest = wi->wi_Bounds;
 568          rc = TRUE;
 569       }
 570       else
 571       {
 572          /*
 573           * Allocate and append a new one.
 574           */
 575          if ((wi = (WI *)AllocVecMem(MemPool, sizeof(WI))))
 576          {
 577             wi->wi_WinID = windowID;
 578             AddTail((struct List *)&tm->tm_Windows, (struct Node *)wi);
 579          }
 580       }
 581    }
 582
 583    /*
 584     * Release lock.
 585     */
 586    ReleaseSemaphore(&TaskLock);
 587
 588    return rc;
 589 }
 590
 591 /*
 592  * Set the window bounds.
 593  */
 594 makeproto VOID SetWindowBounds(ULONG windowID, struct IBox *set)
 595 {
 596    TM       *tm;
 597    WI       *wi;
 598
 599    /*
 600     * No 0 ID!
 601     */
 602    if (!windowID)
 603       return;
 604
 605    /*
 606     * Gain exclusive access.
 607     */
 608    ObtainSemaphore(&TaskLock);
 609
 610    /*
 611     * Look up the task member.
 612     */
 613    if ((tm = FindTaskMember()))
 614    {
 615       /*
 616        * Window in the list?
 617        */
 618       if ((wi = FindWindowInfo(windowID, &tm->tm_Windows)))
 619       {
 620          /*
 621           * Copy the data.
 622           */
 623          wi->wi_Bounds = *set;
 624       }
 625    }
 626
 627    /*
 628     * Release lock.
 629     */
 630    ReleaseSemaphore( &TaskLock );
 631 }
 632
 633 /*
 634  * Asm stubs for the pool routines.
 635  */
 636 extern ASM APTR AsmCreatePool  ( REG(d0) ULONG, REG(d1) ULONG, REG(d2) ULONG, REG(a6) struct ExecBase * );
 637
 638 extern ASM APTR AsmAllocPooled ( REG(a0) APTR,  REG(d0) ULONG,                REG(a6) struct ExecBase * );
 639
 640 extern ASM APTR AsmFreePooled  ( REG(a0) APTR,  REG(a1) APTR,  REG(d0) ULONG, REG(a6) struct ExecBase * );
 641
 642 extern ASM APTR AsmDeletePool  ( REG(a0) APTR,                                REG(a6) struct ExecBase * );
 643
 644 /*
 645  * Create a memory pool.
 646  */
 647 static SAVEDS ASM APTR BGUI_CreatePool(REG(d0) ULONG memFlags, REG(d1) ULONG puddleSize, REG(d2) ULONG threshSize)
 648 {
 649    #ifdef ENHANCED
 650    /*
 651     * V39 Exec function.
 652     */
 653    return CreatePool(memFlags, puddleSize, threshSize);
 654
 655    #else
 656    /*
 657     * pools.lib function
 658     */
 659    return AsmCreatePool(memFlags, puddleSize, threshSize, SysBase);
 660
 661    #endif
 662 }
 663
 664 /*
 665  * Delete a memory pool.
 666  */
 667 static SAVEDS ASM VOID BGUI_DeletePool(REG(a0) APTR poolHeader)
 668 {
 669 #ifdef DEBUG_BGUI
 670    struct BlockHeader **header;
 671
 672    for(header= &MemoryBlocks;*header;)
 673    {
 674       if((*header)->PoolHeader==poolHeader)
 675       {
 676          D(bug("***Memory leak (%lx) (%s,%lu)\n",(*header)->Address,(*header)->File ? (*header)->File : (STRPTR)"Unknown file", (*header)->Line));
 677          *header=(*header)->NextBlock;
 678       }
 679       else
 680          header= &(*header)->NextBlock;
 681    }
 682 #endif
 683    #ifdef ENHANCED
 684    /*
 685     * V39 Exec function.
 686     */
 687    DeletePool(poolHeader);
 688
 689    #else
 690    /*
 691     * pools.lib function
 692     */
 693    AsmDeletePool(poolHeader, SysBase);
 694
 695    #endif
 696 }
 697
 698 /*
 699  * Allocate pooled memory.
 700  */
 701
 702 #ifdef DEBUG_BGUI
 703 static SAVEDS ASM APTR BGUI_AllocPooledDebug(REG(a0) APTR poolHeader, REG(d0) ULONG memSize,REG(a1) STRPTR file,REG(d1) ULONG line)
 704 #else
 705 static SAVEDS ASM APTR BGUI_AllocPooled(REG(a0) APTR poolHeader, REG(d0) ULONG memSize)
 706 #endif
 707 {
 708    APTR memory;
 709 #ifdef DEBUG_BGUI
 710    ULONG size;
 711
 712    size=memSize;
 713    memSize=AlignMemory(memSize+BLOCK_HEADER_OFFSET+MEMORY_WALL_SIZE);
 714 #endif
 715    #ifdef ENHANCED
 716    /*
 717     * V39 Exec function.
 718     */
 719    memory=AllocPooled(poolHeader, memSize);
 720
 721    #else
 722    /*
 723     * pools.lib function
 724     */
 725    memory=AsmAllocPooled(poolHeader, memSize, SysBase);
 726
 727    #endif
 728
 729 #ifdef DEBUG_BGUI
 730    if(memory)
 731    {
 732                 struct BlockHeader *header=memory;
 733
 734                 memory=((char *)memory)+BLOCK_HEADER_OFFSET;
 735                 header->NextBlock=MemoryBlocks;
 736                 header->Address=memory;
 737                 header->Size=size;
 738                 header->PoolHeader=poolHeader;
 739                 header->File=file;
 740                 header->Line=line;
 741                 MemoryBlocks=header;
 742                 TrashMemory(((char *)memory)-MEMORY_WALL_SIZE,MEMORY_WALL_SIZE,MEMORY_WALL_TRASH);
 743                 TrashMemory(((char *)memory)+size,MEMORY_WALL_SIZE,MEMORY_WALL_TRASH);
 744    }
 745 #endif
 746    return(memory);
 747 }
 748
 749 /*
 750  * Free pooled memory.
 751  */
 752 #ifdef DEBUG_BGUI
 753 static SAVEDS ASM VOID BGUI_FreePooledDebug(REG(a0) APTR poolHeader, REG(a1) APTR memory, REG(d1) ULONG memSize,REG(a2) STRPTR file,REG(d2) ULONG line)
 754 #else
 755 static SAVEDS ASM VOID BGUI_FreePooled(REG(a0) APTR poolHeader, REG(a1) APTR memory, REG(d1) ULONG memSize)
 756 #endif
 757 {
 758 #ifdef DEBUG_BGUI
 759    struct BlockHeader **header;
 760
 761    for(header= &MemoryBlocks;*header;header= &(*header)->NextBlock)
 762    {
 763       if((*header)->Address==memory)
 764         break;
 765    }
 766    if(*header==NULL)
 767    {
 768       D(bug("***Attempt to free an unknown memory block (%s,%lu)\n",file ? file : (STRPTR)"Unknown file", line));
 769       return;
 770    }
 771    else
 772    {
 773           if((*header)->PoolHeader!=poolHeader)
 774       {
 775          D(bug("***Attempt to free a memory block from a wrong memory pool (%lx) (%s,%lu)\n",poolHeader,file ? file : (STRPTR)"Unknown file", line));
 776          D(bug("***The original memory pool was (%lx) (%s,%lu)\n",(*header)->PoolHeader,(*header)->File ? (*header)->File : (STRPTR)"Unknown file", (*header)->Line));
 777       }
 778       if(!VerifyMemoryWall(((char *)(*header)->Address)-MEMORY_WALL_SIZE))
 779       {
 780          D(bug("***Lower memory wall violation (%s,%lu)\n",file ? file : (STRPTR)"Unknown file", line));
 781          D(bug("***Memory originally allocated from (%s,%lu)\n",(*header)->File ? (*header)->File : (STRPTR)"Unknown file", (*header)->Line));
 782       }
 783       if(!VerifyMemoryWall(((char *)(*header)->Address)+(*header)->Size))
 784       {
 785          D(bug("***Upper memory wall violation (%s,%lu)\n",file ? file : (STRPTR)"Unknown file", line));
 786          D(bug("***Memory originally allocated from (%s,%lu)\n",(*header)->File ? (*header)->File : (STRPTR)"Unknown file", (*header)->Line));
 787       }
 788       {
 789          ULONG block_size;
 790
 791          block_size=(*header)->BlockSize;
 792          memory= *header;
 793          *header=(*header)->NextBlock;
 794          TrashMemory(memory,block_size,MEMORY_FREE_TRASH);
 795       }
 796    }
 797 #endif
 798    #ifdef ENHANCED
 799    /*
 800     * V39 Exec function.
 801     */
 802    FreePooled(poolHeader, memory, memSize);
 803
 804    #else
 805    /*
 806     * pools.lib function
 807     */
 808    AsmFreePooled(poolHeader, memory, memSize, SysBase);
 809
 810    #endif
 811 }
 812
 813 /*
 814  * Allocate memory.
 815  */
 816 #ifdef DEBUG_BGUI
 817 static ASM APTR AllocVecMemDebug(REG(a0) APTR mempool, REG(d0) ULONG size,REG(a1) STRPTR file, REG(d1) ULONG line)
 818 #else
 819 static ASM APTR AllocVecMem(REG(a0) APTR mempool, REG(d0) ULONG size)
 820 #endif
 821 {
 822    ULONG    *mem;
 823
 824    /*
 825     * Memory pool valid?
 826     */
 827    if (mempool)
 828    {
 829       size += sizeof(ULONG);
 830       /*
 831        * Allocate memory from the pool.
 832        */
 833 #ifdef DEBUG_BGUI
 834       if ((mem = (ULONG *)BGUI_AllocPooledDebug(mempool, size,file,line)))
 835 #else
 836       if ((mem = (ULONG *)BGUI_AllocPooled(mempool, size)))
 837 #endif
 838       {
 839          /*
 840           * Store size.
 841           */
 842          *mem++ = size;
 843       };
 844    } else
 845       /*
 846        * Normal system allocation.
 847        */
 848       mem = (ULONG *)AllocVec(size, MEMF_PUBLIC | MEMF_CLEAR);
 849
 850    return (APTR)mem;
 851 }
 852
 853 /*
 854  * Free memory.
 855  */
 856 #ifdef DEBUG_BGUI
 857 static ASM VOID FreeVecMemDebug(REG(a0) APTR pool, REG(a1) APTR memptr, REG(a2) STRPTR file, REG(d0) ULONG line)
 858 #else
 859 static ASM VOID FreeVecMem(REG(a0) APTR pool, REG(a1) APTR memptr)
 860 #endif
 861 {
 862    ULONG    *mem = (ULONG *)memptr;
 863
 864    /*
 865     * Memory pool valid?
 866     */
 867    if (pool)
 868    {
 869       /*
 870        * Retrieve original allocation and size.
 871        */
 872       mem--;
 873 #ifdef DEBUG_BGUI
 874       BGUI_FreePooledDebug(pool, (APTR)mem, *mem,file,line);
 875 #else
 876       BGUI_FreePooled(pool, (APTR)mem, *mem);
 877 #endif
 878    } else
 879       /*
 880        * Normal system de-allocation.
 881        */
 882       FreeVec(mem);
 883 }
 884
 885 /*
 886  * Allocate memory from the pool.
 887  */
 888 #ifdef DEBUG_BGUI
 889    #ifdef __AROS__
 890    AROS_LH1(APTR, BGUI_AllocPoolMem,
 891        AROS_LHA(ULONG, size, D0),
 892        struct Library *, BGUIBase, 12, BGUI)
 893    #else
 894    SAVEDS ASM APTR BGUI_AllocPoolMem(REG(d0) ULONG size)
 895    #endif
 896    {
 897       AROS_LIBFUNC_INIT
 898
 899      D(bug("BGUI_AllocPoolMem is being called from unknown location\n"));
 900            return(BGUI_AllocPoolMemDebug(size,__FILE__,__LINE__));
 901
 902       AROS_LIBFUNC_EXIT
 903    }
 904
 905    #ifdef __AROS__
 906    makearosproto
 907    AROS_LH3(APTR, BGUI_AllocPoolMemDebug,
 908        AROS_LHA(ULONG, size, D0),
 909        AROS_LHA(STRPTR, file, A0),
 910        AROS_LHA(ULONG, line, D1),
 911        struct Library *BGUIBase, 31, BGUI)
 912    #else
 913    makeproto SAVEDS ASM APTR BGUI_AllocPoolMemDebug(REG(d0) ULONG size, REG(a0) STRPTR file, REG(d1) ULONG line)
 914    #endif
 915
 916 #else
 917
 918    #ifdef __AROS__
 919    makearosproto
 920    AROS_LH3(APTR, BGUI_AllocPoolMemDebug,
 921        AROS_LHA(ULONG, size, D0),
 922        AROS_LHA(STRPTR, file, A0),
 923        AROS_LHA(ULONG, line, D1),
 924        struct Library *, BGUIBase, 31, BGUI)
 925    #else
 926    SAVEDS ASM APTR BGUI_AllocPoolMemDebug(REG(d0) ULONG size, REG(a0) STRPTR file, REG(d1) ULONG line)
 927    #endif
 928    {
 929       AROS_LIBFUNC_INIT
 930
 931      bug("BGUI_AllocPoolMemDebug is being called from (%s,%lu)\n",file ? file : (STRPTR)"unknown",line);
 932            return(BGUI_AllocPoolMem(size));
 933
 934       AROS_LIBFUNC_EXIT
 935    }
 936
 937    #ifdef __AROS__
 938    makearosproto
 939    AROS_LH1(APTR, BGUI_AllocPoolMem,
 940        AROS_LHA(ULONG, size, D0),
 941        struct Library *, BGUIBase, 12, BGUI)
 942    #else
 943    makeproto SAVEDS ASM APTR BGUI_AllocPoolMem(REG(d0) ULONG size)
 944    #endif
 945 #endif
 946
 947 {
 948    AROS_LIBFUNC_INIT
 949
 950    APTR        memPtr;
 951
 952    /*
 953     * Lock the list.
 954     */
 955    ObtainSemaphore(&TaskLock);
 956
 957    /*
 958     * Allocate memory.
 959     */
 960 #ifdef DEBUG_BGUI
 961    memPtr = AllocVecMemDebug(MemPool, size, file, line);
 962 #else
 963    memPtr = AllocVecMem(MemPool, size);
 964 #endif
 965
 966    /*
 967     * Unlock the list.
 968     */
 969    ReleaseSemaphore(&TaskLock);
 970
 971    return memPtr;
 972
 973    AROS_LIBFUNC_EXIT
 974 }
 975
 976 /*
 977  * Free memory from the pool.
 978  */
 979 #ifdef DEBUG_BGUI
 980    #ifdef __AROS__
 981    AROS_LH1(VOID, BGUI_FreePoolMem,
 982        AROS_LHA(APTR, memPtr, A0),
 983        struct Library *, BGUIBase, 13, BGUI)
 984    #else
 985    SAVEDS ASM VOID BGUI_FreePoolMem(REG(a0) APTR memPtr)
 986    #endif
 987    {
 988       AROS_LIBFUNC_INIT
 989
 990       D(bug("BGUI_FreePoolMem is being called from unknown location\n"));
 991            BGUI_FreePoolMemDebug(memPtr,__FILE__,__LINE__);
 992
 993       AROS_LIBFUNC_EXIT
 994    }
 995
 996    #ifdef __AROS__
 997    makearosproto
 998    AROS_LH3(VOID, BGUI_FreePoolMemDebug,
 999        AROS_LHA(APTR, memPtr, A0),
1000        AROS_LHA(STRPTR, file, A1),
1001        AROS_LHA(ULONG, line, D0),
1002        struct Library *, BGUIBase, 32, BGUI)
1003    #else
1004    makeproto SAVEDS ASM VOID BGUI_FreePoolMemDebug(REG(a0) APTR memPtr, REG(a1) STRPTR file, REG(d0) ULONG line)
1005    #endif
1006
1007 #else
1008
1009    #ifdef __AROS__
1010    makearosproto
1011    AROS_LH3(VOID, BGUI_FreePoolMemDebug,
1012        AROS_LHA(APTR, memPtr, A0),
1013        AROS_LHA(STRPTR, file, A1),
1014        AROS_LHA(ULONG, line, D0),
1015        struct Library *, BGUIBase, 32, BGUI)
1016    #else
1017    makeproto SAVEDS ASM VOID BGUI_FreePoolMemDebug(REG(a0) APTR memPtr, REG(a1) STRPTR file, REG(d0) ULONG line)
1018    #endif
1019    {
1020       AROS_LIBFUNC_INIT
1021
1022       bug("BGUI_FreePoolMemDebug is being called from (%s,%lu)\n",file ? file : (STRPTR)"unknown",line);
1023            BGUI_FreePoolMem(memPtr);
1024
1025       AROS_LIBFUNC_EXIT
1026    }
1027
1028    #ifdef __AROS__
1029    makearosproto
1030    AROS_LH1(VOID, BGUI_FreePoolMem,
1031        AROS_LHA(APTR, memPtr, A0),
1032        struct Library *, BGUIBase, 13, BGUI)
1033    #else
1034    makeproto SAVEDS ASM VOID BGUI_FreePoolMem(REG(a0) APTR memPtr)
1035    #endif
1036
1037 #endif
1038
1039 {
1040    AROS_LIBFUNC_INIT
1041
1042    if (memPtr)
1043    {
1044       /*
1045        * Lock the list.
1046        */
1047       ObtainSemaphore(&TaskLock);
1048
1049       /*
1050        * Free the memory.
1051        */
1052 #ifdef DEBUG_BGUI
1053       FreeVecMemDebug(MemPool, memPtr, file, line);
1054 #else
1055       FreeVecMem(MemPool, memPtr);
1056 #endif
1057
1058       /*
1059        * Unlock the list.
1060        */
1061       ReleaseSemaphore(&TaskLock);
1062    }
1063 #ifdef DEBUG_BGUI
1064    else
1065       D(bug("*** Attempt to free memory with a NULL pointer\n"));
1066 #endif
1067
1068    AROS_LIBFUNC_EXIT
1069 }
1070
1071 /*
1072  *  Add an ID to the list.
1073  *
1074  *  Changes made by T.Herold
1075  *
1076  *  - Added reg(a1) Task param
1077  *  - Uses InternalFindTaskMember to find destination task.
1078  */
1079
1080 makeproto ASM BOOL AddIDReport(REG(a0) struct Window *window, REG(d0) ULONG id, REG(a1) struct Task *task)
1081 {
1082    RID         *rid;
1083    TM          *tm;
1084    BOOL         rc = FALSE;
1085
1086    /*
1087     *  Lock the task list.
1088     */
1089    ObtainSemaphore(&TaskLock);
1090
1091    /*
1092     *  Look up the task.
1093     */
1094    if ((tm = InternalFindTaskMember(task)))
1095    {
1096       /*
1097        *  Allocate an ID.
1098        */
1099       if ((rid = (RID *)AllocVecMem(MemPool, sizeof(RID))))
1100       {
1101          /*
1102           *  Setup and add.
1103           */
1104          rid->rid_ID     = id;
1105          rid->rid_Window = window;
1106          AddTail((struct List *)&tm->tm_RID, (struct Node *)rid);
1107          rc = TRUE;
1108       };
1109    };
1110
1111    /*
1112     *  Release the task list.
1113     */
1114    ReleaseSemaphore(&TaskLock);
1115
1116    return rc;
1117 }
1118
1119 /*
1120  * Get next ID for the window.
1121  */
1122 makeproto ASM ULONG GetIDReport(REG(a0) struct Window *window)
1123 {
1124    RID         *rid;
1125    TM          *tm;
1126    ULONG        rc = ~0;
1127
1128    /*
1129     * Lock the task list.
1130     */
1131    ObtainSemaphore(&TaskLock);
1132
1133    /*
1134     * Find the task.
1135     */
1136    if ((tm = FindTaskMember()))
1137    {
1138       /*
1139        * See if an ID for the window
1140        * exists.
1141        */
1142       for (rid = tm->tm_RID.ril_First; rid->rid_Next; rid = rid->rid_Next)
1143       {
1144          /*
1145           * Is this the one?
1146           */
1147          if (rid->rid_Window == window)
1148          {
1149             /*
1150              * Yes. Get the ID and remove it.
1151              */
1152             rc = rid->rid_ID;
1153             Remove((struct Node *)rid);
1154             FreeTL_RID(rid);
1155             break;
1156          }
1157       }
1158    }
1159
1160    /*
1161     * Release the task list.
1162     */
1163    ReleaseSemaphore(&TaskLock);
1164
1165    return rc;
1166 }
1167
1168 /*
1169  * Get the window of the first
1170  * ID on the stack.
1171  */
1172 makeproto struct Window *GetFirstIDReportWindow(void)
1173 {
1174    TM             *tm;
1175    struct Window  *win = NULL;
1176
1177    /*
1178     * Lock the task list.
1179     */
1180    ObtainSemaphore(&TaskLock);
1181
1182    /*
1183     * Get the task.
1184     */
1185    if ((tm = FindTaskMember()))
1186    {
1187       /*
1188        * Are there any ID's?
1189        */
1190       if (tm->tm_RID.ril_First->rid_Next)
1191          win = tm->tm_RID.ril_First->rid_Window;
1192    }
1193
1194    /*
1195     * Release the task list.
1196     */
1197    ReleaseSemaphore(&TaskLock);
1198
1199    return win;
1200 }
1201
1202 /*
1203  * Remove all ID's of this window.
1204  */
1205 makeproto ASM VOID RemoveIDReport(REG(a0) struct Window *window)
1206 {
1207    RID      *rid, *succ;
1208    TM       *tm;
1209
1210    /*
1211     * Lock task list.
1212     */
1213    ObtainSemaphore(&TaskLock);
1214
1215    /*
1216     * Find the task.
1217     */
1218    if ((tm = FindTaskMember()))
1219    {
1220       rid = tm->tm_RID.ril_First;
1221       while ((succ = rid->rid_Next))
1222       {
1223          if (rid->rid_Window == window)
1224          {
1225             Remove((struct Node *)rid);
1226             FreeTL_RID(rid);
1227          };
1228          rid = succ;
1229       }
1230    }
1231
1232    /*
1233     * Release the task list.
1234     */
1235    ReleaseSemaphore(&TaskLock);
1236 }
1237
1238 /*
1239  * Add an open window to the list.
1240  */
1241 makeproto ASM VOID AddWindow(REG(a0) Object *wo, REG(a1) struct Window *win)
1242 {
1243    WNODE       *wn;
1244
1245    /*
1246     * Lock the list.
1247     */
1248    ObtainSemaphore(&TaskLock);
1249
1250    /*
1251     * Allocate node.
1252     */
1253    if ((wn = (WNODE *)AllocVecMem(MemPool, sizeof(WNODE))))
1254    {
1255       /*
1256        * Set it up.
1257        */
1258       wn->wn_WindowObject = wo;
1259       wn->wn_Window       = win;
1260
1261       /*
1262        * Add it to the list.
1263        */
1264       AddTail((struct List *)&TaskList.tl_WindowList, (struct Node *)wn);
1265    }
1266
1267    /*
1268     * Release the list.
1269     */
1270    ReleaseSemaphore(&TaskLock);
1271 }
1272
1273 /*
1274  * Remove a window from the list.
1275  */
1276 makeproto ASM VOID RemWindow(REG(a0) Object *wo)
1277 {
1278    WNODE       *wn;
1279
1280    /*
1281     * Lock the list.
1282     */
1283    ObtainSemaphore(&TaskLock);
1284
1285    /*
1286     * Locate the node.
1287     */
1288    for (wn = TaskList.tl_WindowList.wnl_First; wn->wn_Next; wn = wn->wn_Next)
1289    {
1290       /*
1291        * Is this the one?
1292        */
1293       if (wn->wn_WindowObject == wo)
1294       {
1295          /*
1296           * Yes. Remove and deallocate it.
1297           */
1298          Remove((struct Node *)wn);
1299          FreeVecMem(MemPool, wn);
1300
1301          /*
1302           * We're done here...
1303           */
1304          break;
1305       };
1306    };
1307
1308    /*
1309     * Release the list.
1310     */
1311    ReleaseSemaphore(&TaskLock);
1312 }
1313
1314 /*
1315  * Find the window located under the mouse.
1316  */
1317 makeproto ASM Object *WhichWindow(REG(a0) struct Screen *screen)
1318 {
1319    Object         *win = NULL;
1320    struct Layer   *layer;
1321    WNODE          *wn;
1322
1323    /*
1324     * Lock the list.
1325     */
1326    ObtainSemaphore(&TaskLock);
1327
1328    /*
1329     * Find out the layer under the mouse pointer.
1330     */
1331    if ((layer = WhichLayer(&screen->LayerInfo, screen->MouseX, screen->MouseY)))
1332    {
1333       for (wn = TaskList.tl_WindowList.wnl_First; wn->wn_Next; wn = wn->wn_Next)
1334       {
1335          /*
1336           * Is this the one?
1337           */
1338          if (wn->wn_Window == layer->Window)
1339          {
1340             /*
1341              * Setup return code and exit loop.
1342              */
1343             win = wn->wn_WindowObject;
1344             break;
1345          };
1346       };
1347    };
1348
1349    /*
1350     * Release the lock.
1351     */
1352    ReleaseSemaphore(&TaskLock);
1353
1354    return win;
1355 }
1356
1357 static PI *FindPrefInfo(TM *tm, ULONG id)
1358 {
1359    PRL   *pl = &tm->tm_Prefs;
1360    PI    *pi;
1361
1362    for (pi = pl->pl_First; pi->pi_Next; pi = pi->pi_Next)
1363    {
1364       if (id == pi->pi_PrefID)
1365       {
1366          return pi;
1367       };
1368    };
1369    return NULL;
1370 }
1371
1372 #define TAG_PREFID (TAG_USER - 1)
1373
1374 static void NewPrefInfo(TM *tm, ULONG id, struct TagItem *tags)
1375 {
1376    PRL        *pl = &tm->tm_Prefs;
1377    PI         *pi = FindPrefInfo(tm, id);
1378
1379    if (!pi)
1380    {
1381       if ((pi = AllocVecMem(MemPool, sizeof(PI))))
1382       {
1383          pi->pi_PrefID   = id;
1384          pi->pi_Defaults = NULL;
1385          AddTail((struct List *)pl, (struct Node *)pi);
1386       };
1387    };
1388    if (pi)
1389    {
1390       tags = BGUI_MergeTagItems(pi->pi_Defaults, tags);
1391       pi->pi_Defaults = BGUI_CleanTagItems(tags, 1);
1392    };
1393 }
1394
1395 static void DefPrefs(void)
1396 {
1397    TM              *tm;
1398    struct TagItem  *t1, *t2;
1399    ULONG            id, type;
1400
1401    static struct TagItem deftags[] =
1402    {
1403       { TAG_PREFID,            BGUI_AREA_GADGET },
1404       { ICA_TARGET,            ICTARGET_IDCMP },
1405       { FRM_EdgesOnly,         TRUE },
1406
1407       { TAG_PREFID,            BGUI_BUTTON_GADGET },
1408       { FRM_Type,              FRTYPE_BUTTON },
1409
1410       { TAG_PREFID,            BGUI_CHECKBOX_GADGET },
1411       { LAB_NoPlaceIn,         TRUE },
1412       { BT_NoRecessed,         TRUE },
1413       { BUTTON_ScaleMinWidth,  14 },
1414       { BUTTON_ScaleMinHeight, 8 },
1415
1416       { TAG_PREFID,            BGUI_CYCLE_GADGET },
1417       { LAB_NoPlaceIn,         TRUE },
1418       { FRM_Type,              FRTYPE_BUTTON },
1419
1420       { TAG_PREFID,            BGUI_GROUP_GADGET },
1421       { LAB_NoPlaceIn,         TRUE },
1422       { FRM_DefaultType,       FRTYPE_NEXT },
1423       { GROUP_DefHSpaceNarrow, 2 },
1424       { GROUP_DefHSpaceNormal, 4 },
1425       { GROUP_DefHSpaceWide,   8 },
1426       { GROUP_DefVSpaceNarrow, 2 },
1427       { GROUP_DefVSpaceNormal, 4 },
1428       { GROUP_DefVSpaceWide,   8 },
1429
1430       { TAG_PREFID,            BGUI_INDICATOR_GADGET },
1431       { BT_Buffer,             TRUE },
1432       { FRM_DefaultType,       FRTYPE_BUTTON },
1433       { FRM_Recessed,          TRUE },
1434
1435       { TAG_PREFID,            BGUI_INFO_GADGET },
1436       { LAB_NoPlaceIn,         TRUE },
1437       { BT_Buffer,             TRUE },
1438       { FRM_DefaultType,       FRTYPE_BUTTON },
1439       { FRM_Recessed,          TRUE },
1440
1441       { TAG_PREFID,            BGUI_LISTVIEW_GADGET },
1442       { LAB_NoPlaceIn,         TRUE },
1443       { FRM_Type,              FRTYPE_BUTTON },
1444
1445       { TAG_PREFID,            BGUI_MX_GADGET },
1446       { LAB_NoPlaceIn,         TRUE },
1447       { LAB_Place,             PLACE_ABOVE },
1448       { MX_Spacing,            GRSPACE_NARROW },
1449       { MX_LabelPlace,         PLACE_RIGHT },
1450
1451       { TAG_PREFID,            BGUI_PAGE_GADGET },
1452       { LAB_NoPlaceIn,         TRUE },
1453       { FRM_Type,              FRTYPE_NONE },
1454       { BT_Buffer,             TRUE },
1455
1456       { TAG_PREFID,            BGUI_PROGRESS_GADGET },
1457       { LAB_NoPlaceIn,         TRUE },
1458       { FRM_Type,              FRTYPE_BUTTON },
1459       { FRM_Recessed,          TRUE },
1460       { BT_LeftOffset,         1 },
1461       { BT_RightOffset,        1 },
1462       { BT_TopOffset,          1 },
1463       { BT_BottomOffset,       1 },
1464
1465       { TAG_PREFID,            BGUI_PROP_GADGET },
1466       { LAB_NoPlaceIn,         TRUE },
1467       { FRM_Type,              FRTYPE_BUTTON },
1468
1469       { TAG_PREFID,            BGUI_RADIOBUTTON_GADGET },
1470       { LAB_NoPlaceIn,         TRUE },
1471       { FRM_Type,              FRTYPE_RADIOBUTTON },
1472       { BUTTON_ScaleMinWidth,  8 },
1473       { BUTTON_ScaleMinHeight, 8 },
1474       { BUTTON_SelectOnly,     TRUE },
1475
1476       { TAG_PREFID,            BGUI_SLIDER_GADGET },
1477       { PGA_Slider,            TRUE },
1478
1479       { TAG_PREFID,            BGUI_STRING_GADGET },
1480       { LAB_NoPlaceIn,         TRUE },
1481       { FRM_Type,              FRTYPE_RIDGE },
1482       { BT_LeftOffset,         1 },
1483       { BT_RightOffset,        1 },
1484       { BT_TopOffset,          1 },
1485       { BT_BottomOffset,       1 },
1486
1487       { TAG_PREFID,            BGUI_VIEW_GADGET },
1488       { LAB_NoPlaceIn,         TRUE },
1489       { FRM_Type,              FRTYPE_BUTTON },
1490       { FRM_Recessed,          TRUE },
1491       { BT_LeftOffset,         1 },
1492       { BT_RightOffset,        1 },
1493       { BT_TopOffset,          1 },
1494       { BT_BottomOffset,       1 },
1495
1496       { TAG_PREFID,            BGUI_WINDOW_OBJECT },
1497       { WINDOW_ToolTicks,      10 },
1498       { WINDOW_PreBufferRP,    FALSE },
1499
1500       { TAG_PREFID,            BGUI_FILEREQ_OBJECT },
1501       { ASLREQ_Type,           ASL_FileRequest },
1502
1503       { TAG_PREFID,            BGUI_FONTREQ_OBJECT },
1504       { ASLREQ_Type,           ASL_FontRequest },
1505
1506       { TAG_PREFID,            BGUI_SCREENREQ_OBJECT },
1507       { ASLREQ_Type,           ASL_ScreenModeRequest },
1508
1509       { TAG_DONE },
1510    };
1511
1512    ObtainSemaphore(&TaskLock);
1513    if ((tm = FindTaskMember()))
1514    {
1515       t1 = deftags;
1516       do
1517       {
1518          id = t1->ti_Data;
1519          t2 = ++t1;
1520          while (t2->ti_Tag & TAG_USER) t2++;
1521
1522          type = t2->ti_Tag;
1523          t2->ti_Tag = TAG_DONE;
1524
1525          NewPrefInfo(tm, id, t1);
1526
1527          t2->ti_Tag = type;
1528          t1 = t2;
1529       }  while (type == TAG_PREFID);
1530    };
1531    ReleaseSemaphore(&TaskLock);
1532 }
1533
1534 static void LoadPrefs(UBYTE *name)
1535 {
1536    struct IFFHandle        *iff;
1537    struct CollectionItem   *ci;
1538    ULONG                   *data, type;
1539    TM                      *tm;
1540
1541    if ((tm = FindTaskMember()))
1542    {
1543       if ((iff = AllocIFF()))
1544       {
1545          if ((iff->iff_Stream = (IPTR)Open((char *)name, MODE_OLDFILE)))
1546          {
1547             InitIFFasDOS(iff);
1548             if (OpenIFF(iff, IFFF_READ) == 0)
1549             {
1550                CollectionChunk(iff, ID_BGUI, ID_DTAG);
1551                StopOnExit(iff, ID_BGUI, ID_FORM);
1552                ParseIFF(iff, IFFPARSE_SCAN);
1553
1554                ci = FindCollection(iff, ID_BGUI, ID_DTAG);
1555                while (ci)
1556                {
1557                   data = ci->ci_Data;
1558                   type = *data++;
1559                   NewPrefInfo(tm, type, (struct TagItem *)data);
1560
1561                   ci = ci->ci_Next;
1562                };
1563             };
1564             Close((BPTR)iff->iff_Stream);
1565          };
1566          FreeIFF(iff);
1567       };
1568    };
1569 }
1570
1571 makeproto struct TagItem *DefTagList(ULONG id, struct TagItem *tags)
1572 {
1573    struct TagItem *deftags, *newtags, *t, *tag;
1574    struct TagItem *tstate1, *tstate2;
1575    int             fr_deftype = 0;
1576
1577    int n1, n2;
1578
1579    if ((deftags = BGUI_GetDefaultTags(id)))
1580    {
1581       tstate1 = deftags, tstate2 = tags;
1582
1583       n1 = BGUI_CountTagItems(deftags);
1584       n2 = BGUI_CountTagItems(tags);
1585
1586       if ((newtags = AllocVec((n1 + n2 + 1) * sizeof(struct TagItem), 0)))
1587       {
1588          t = newtags;
1589
1590          while ((tag = NextTagItem(&tstate1)))
1591          {
1592             if (FindTagItem(tag->ti_Tag, tags))
1593                continue;
1594
1595             if (tag->ti_Tag == FRM_DefaultType)
1596             {
1597                fr_deftype = tag->ti_Data;
1598                continue;
1599             };
1600             *t++ = *tag;
1601          };
1602
1603          while ((tag = NextTagItem(&tstate2)))
1604          {
1605             if (fr_deftype && (tag->ti_Tag == FRM_Type) && (tag->ti_Data == FRTYPE_DEFAULT))
1606             {
1607                tag->ti_Data = fr_deftype;
1608             };
1609             *t++ = *tag;
1610          };
1611
1612          t->ti_Tag = TAG_DONE;
1613
1614          tags = CloneTagItems(newtags);
1615
1616          FreeVec(newtags);
1617
1618          return tags;
1619       };
1620    };
1621    return CloneTagItems(tags);
1622 }
1623
1624 makeproto SAVEDS ASM ULONG BGUI_CountTagItems(REG(a0) struct TagItem *tags)
1625 {
1626    struct TagItem *tstate = tags;
1627    ULONG n = 0;
1628
1629    while (NextTagItem(&tstate)) n++;
1630
1631    return n;
1632 }
1633
1634 makeproto SAVEDS ASM struct TagItem *BGUI_MergeTagItems(REG(a0) struct TagItem *tags1, REG(a1) struct TagItem *tags2)
1635 {
1636    struct TagItem *tags, *t, *tag;
1637    struct TagItem *tstate1 = tags1, *tstate2 = tags2;
1638
1639    int n1 = BGUI_CountTagItems(tags1);
1640    int n2 = BGUI_CountTagItems(tags2);
1641
1642    if ((tags = AllocVec((n1 + n2 + 1) * sizeof(struct TagItem), 0)))
1643    {
1644       t = tags;
1645
1646       while ((tag = NextTagItem(&tstate1))) *t++ = *tag;
1647       while ((tag = NextTagItem(&tstate2))) *t++ = *tag;
1648       t->ti_Tag = TAG_DONE;
1649
1650       t = CloneTagItems(tags);
1651
1652       FreeVec(tags);
1653
1654       return t;
1655    };
1656    return NULL;
1657 }
1658
1659 makeproto SAVEDS ASM struct TagItem *BGUI_CleanTagItems(REG(a0) struct TagItem *tags, REG(d0) LONG dir)
1660 {
1661    struct TagItem *tag, *tag2;
1662    struct TagItem *tstate = tags;
1663
1664    if (dir)
1665    {
1666       while ((tag = NextTagItem(&tstate)))
1667       {
1668          while ((tag2 = FindTagItem(tag->ti_Tag, tag + 1)))
1669          {
1670             if (dir > 0)
1671             {
1672                tag->ti_Tag = TAG_IGNORE;
1673                break;
1674             }
1675             else if (dir < 0)
1676             {
1677                tag2->ti_Tag = TAG_IGNORE;
1678             };
1679          };
1680       };
1681    };
1682    tag = CloneTagItems(tags);
1683    FreeTagItems(tags);
1684    return tag;
1685 }
1686
1687 #ifdef __AROS__
1688 makearosproto
1689 AROS_LH1(struct TagItem *, BGUI_GetDefaultTags,
1690     AROS_LHA(ULONG, id, D0),
1691     struct Library *, BGUIBase, 28, BGUI)
1692 #else
1693 makeproto SAVEDS ASM struct TagItem *BGUI_GetDefaultTags(REG(d0) ULONG id)
1694 #endif
1695 {
1696    AROS_LIBFUNC_INIT
1697
1698    PI             *pi;
1699    TM             *tm;
1700    struct TagItem *tags = NULL;
1701
1702    /*
1703     * Lock the list.
1704     */
1705    ObtainSemaphore(&TaskLock);
1706
1707    if ((tm = FindTaskMember()))
1708    {
1709       if ((pi = FindPrefInfo(tm, id)))
1710          tags = pi->pi_Defaults;
1711    };
1712
1713    /*
1714     * Release the lock.
1715     */
1716    ReleaseSemaphore(&TaskLock);
1717
1718    return tags;
1719
1720    AROS_LIBFUNC_EXIT
1721 }
1722
1723 #ifdef __AROS__
1724 makearosproto
1725 AROS_LH0(VOID, BGUI_DefaultPrefs,
1726     struct Library *, BGUIBase, 29, BGUI)
1727 #else
1728 makeproto SAVEDS ASM VOID BGUI_DefaultPrefs(VOID)
1729 #endif
1730 {
1731    AROS_LIBFUNC_INIT
1732
1733    PI        *pi;
1734    TM        *tm;
1735
1736    ObtainSemaphore(&TaskLock);
1737    if ((tm = FindTaskMember()))
1738    {
1739       while ((pi = (PI *)RemHead((struct List *)&tm->tm_Prefs)))
1740          FreeTL_PI(pi);
1741    };
1742    ReleaseSemaphore(&TaskLock);
1743
1744    DefPrefs();
1745
1746    AROS_LIBFUNC_EXIT
1747 }
1748
1749 #ifdef __AROS__
1750 makearosproto
1751 AROS_LH1(VOID, BGUI_LoadPrefs,
1752     AROS_LHA(UBYTE *, name, A0),
1753     struct Library *, BGUIBase, 30, BGUI)
1754 #else
1755 makeproto SAVEDS ASM VOID BGUI_LoadPrefs(REG(a0) UBYTE *name)
1756 #endif
1757 {
1758    AROS_LIBFUNC_INIT
1759
1760    BGUI_DefaultPrefs();
1761    LoadPrefs(name);
1762
1763    AROS_LIBFUNC_EXIT
1764 }