workbench/system/Wanderer/wandererprefs.c

   1 /*
   2   Copyright  2004-2009, The AROS Development Team. All rights reserved.
   3   $Id$
   4 */
   5
   6 #define ZCC_QUIET
   7
   8 #include "portable_macros.h"
   9 #ifdef __AROS__
  10 #define DEBUG 0
  11 #include <aros/debug.h>
  12
  13 #define MUIMASTER_YES_INLINE_STDARG
  14 #endif
  15
  16 #define IFF_CHUNK_BUFFER_SIZE 1024
  17
  18 #include <exec/types.h>
  19 #include <libraries/mui.h>
  20
  21 #ifdef __AROS__
  22 #include <zune/customclasses.h>
  23 #else
  24 #include <zune_AROS/customclasses.h>
  25 #endif
  26
  27 #include <proto/workbench.h>
  28
  29 #include <proto/utility.h>
  30
  31 #include <proto/dos.h>
  32
  33 #ifdef __AROS__
  34 #include <proto/alib.h>
  35 #endif
  36
  37 #include <proto/iffparse.h>
  38
  39 #ifdef __AROS__
  40 #include <proto/aros.h>
  41 #endif
  42
  43 #include <aros/arosbase.h>
  44 #include <aros/inquire.h>
  45
  46 #include <string.h>
  47 #include <stdio.h>
  48
  49
  50 #if defined(__AMIGA__) && !defined(__PPC__)
  51 #define NO_INLINE_STDARG
  52 #endif
  53 #ifndef _PROTO_INTUITION_H
  54 #include <proto/intuition.h>
  55 #endif
  56
  57 #include <proto/muimaster.h>
  58
  59 #include "wanderer.h"
  60 #include "wandererprefs.h"
  61 #include "Classes/iconlist_attributes.h"
  62 #include "iconwindow_attributes.h"
  63 #include "support.h"
  64 #include "locale.h"
  65 #include "version.h"
  66
  67 #ifdef __AROS__
  68 #include <prefs/prefhdr.h>
  69 #include <prefs/wanderer.h>
  70 #else
  71 #include <prefs_AROS/prefhdr.h>
  72 #include <prefs_AROS/wanderer.h>
  73 #endif
  74
  75
  76 #ifndef __AROS__
  77 #define DEBUG 1
  78
  79 #ifdef DEBUG
  80   #define D(x) if (DEBUG) x
  81   #ifdef __amigaos4__
  82   #define bug DebugPrintF
  83   #else
  84   #define bug kprintf
  85   #endif
  86 #else
  87   #define  D(...)
  88 #endif
  89 #endif
  90
  91 static CONST_STRPTR                     wandererPrefs_PrefsFile = "ENV:SYS/Wanderer/global.prefs";
  92 static Object                           *wandererPrefs_PrefsObject;
  93 struct Wanderer_FSHandler               *wandererPrefs_PrefsNotifyHandler = NULL;
  94
  95 struct TagItem32 {
  96     ULONG ti_Tag;
  97     ULONG ti_Data;
  98 };
  99
 100 /*** Instance Data **********************************************************/
 101 struct WandererPrefs_DATA
 102 {
 103     ULONG                       wpd_NavigationMethod;
 104     ULONG                       wpd_ToolbarEnabled;
 105     ULONG                       wpd_ShowNetwork;
 106     ULONG                       wpd_ShowUserFiles;
 107     ULONG                       wpd_ScreenTitleString[IFF_CHUNK_BUFFER_SIZE];
 108
 109     struct List                 wpd_ViewSettings;
 110
 111     struct NotifyRequest        wpd_PrefsNotifyRequest;
 112
 113     BOOL                        wpd_PROCESSING;
 114 };
 115
 116 struct WandererPrefs_ViewSettingsNode
 117 {
 118     struct Node                 wpbn_Node;
 119     char                        *wpbn_Name;
 120     IPTR                        wpbn_Background;
 121     struct TagItem32            *wpbn_Options;
 122     Object                      *wpbn_NotifyObject;
 123 };
 124
 125 /*** Macros *****************************************************************/
 126 #define SETUP_INST_DATA struct WandererPrefs_DATA *data = INST_DATA(CLASS, self)
 127
 128 /*** Utility Functions ******************************************************/
 129 ///SetString()
 130 BOOL SetString(STRPTR *dst, STRPTR src)
 131 {
 132     if (src != NULL)
 133     {
 134         if ((*dst == NULL) || (strcmp(src, *dst) != 0))
 135         {
 136             STRPTR tmp =(STRPTR) StrDup(src);
 137
 138             if (tmp != NULL)
 139             {
 140                 FreeVec(*dst);
 141                 *dst = tmp;
 142
 143                 return TRUE;
 144             }
 145         }
 146     }
 147
 148     return FALSE;
 149 }
 150 ///
 151
 152 ///strtochar()
 153 static unsigned char strtochar(STRPTR st)
 154 {
 155     return *st++;
 156 }
 157 ///
 158 /******** code from workbench/c/Info.c **************************************/
 159 ///fmtlarge()
 160 static void fmtlarge(UBYTE *buf, ULONG num)
 161 {
 162   UQUAD d;
 163   UBYTE ch;
 164   struct
 165   {
 166     IPTR val;
 167     IPTR  dec;
 168   } array =
 169   {
 170     num,
 171     0
 172   };
 173
 174   if (num >= 1073741824)
 175   {
 176     //Gigabytes
 177     array.val = num >> 30;
 178     d = ((UQUAD)num * 10 + 536870912) / 1073741824;
 179     array.dec = d % 10;
 180     ch = strtochar((STRPTR)_(MSG_MEM_G));
 181   }
 182   else if (num >= 1048576)
 183   {
 184     //Megabytes
 185     array.val = num >> 20;
 186     d = ((UQUAD)num * 10 + 524288) / 1048576;
 187     array.dec = d % 10;
 188     ch = strtochar((STRPTR)_(MSG_MEM_M));
 189   }
 190   else if (num >= 1024)
 191   {
 192     //Kilobytes
 193     array.val = num >> 10;
 194     d = (num * 10 + 512) / 1024;
 195     array.dec = d % 10;
 196     ch = strtochar((STRPTR)_(MSG_MEM_K));
 197   }
 198   else
 199   {
 200     //Bytes
 201     array.val = num;
 202     array.dec = 0;
 203     d = 0;
 204     ch = strtochar((STRPTR)_(MSG_MEM_B));
 205   }
 206
 207   if (!array.dec && (d > array.val * 10))
 208   {
 209     array.val++;
 210   }
 211
 212   RawDoFmt(array.dec ? "%lu.%lu" : "%lu", &array, NULL, buf);
 213
 214   while (*buf)
 215   {
 216     buf++;
 217   }
 218
 219   *buf++ = ch;
 220   *buf   = '\0';
 221 }
 222 ///
 223
 224 ///findname()
 225 /* Case-insensitive FindName()
 226  * code from workbench/c/Version.c
 227  */
 228 static
 229 struct Node *findname(struct List *list, CONST_STRPTR name)
 230 {
 231   struct Node *node;
 232   #ifdef __AROS__
 233   ForeachNode(list, node)
 234   #else
 235   Foreach_Node(list, node);
 236   #endif
 237   {
 238     if (!Stricmp(node->ln_Name, (STRPTR) name))
 239     {
 240       return node;
 241     }
 242   }
 243
 244   return NULL;
 245 }
 246 ///
 247
 248 ///ProcessUserScreenTitle()
 249 /*pattern matching of user screentitle...;*/
 250 STRPTR ProcessUserScreenTitle(STRPTR screentitle_Template)
 251 {
 252 /* Work in progress :-) */
 253   int screentitle_TemplateLen;
 254   STATIC char title[256];
 255   char temp[256], buffer[256];
 256   char infostr[10];
 257   int screentitle_curChar;
 258
 259   if (screentitle_Template == NULL)
 260   {
 261 D(bug("[Wanderer:Prefs] ProcessUserScreenTitle(),EXTERN screentitle = NULL\n"));
 262     return screentitle_Template;
 263   }
 264   else
 265   {
 266 D(bug("[Wanderer:Prefs] ProcessUserScreenTitle('%s')\n", screentitle_Template));
 267   }
 268
 269   screentitle_TemplateLen = strlen(screentitle_Template);
 270
 271   if (screentitle_TemplateLen < 1)
 272   {
 273 D(bug("[Wanderer:Prefs] ProcessUserScreenTitle: EXTERN screentitle_TemplateLen = %d\n", screentitle_TemplateLen));
 274     return (STRPTR) screentitle_TemplateLen;
 275   }
 276
 277   strcpy(temp, screentitle_Template);
 278
 279   for (screentitle_curChar = 0; screentitle_curChar < screentitle_TemplateLen; screentitle_curChar++)
 280   {
 281     if (temp[screentitle_curChar]=='%')
 282     {
 283       if (screentitle_TemplateLen >= 3)
 284       {
 285         BOOL found = FALSE;
 286
 287         if (strncmp(temp + screentitle_curChar, "%wv", 3) == 0)
 288         {
 289           struct Library *MyLibrary = NULL;
 290
 291         #ifdef __AROS__
 292           MyLibrary = (struct Library *)findname(&SysBase->LibList, "workbench.library");
 293           //workbench.library is just opened, what is the sense of this istruction?
 294         #else
 295           MyLibrary = WorkbenchBase;
 296         #endif
 297
 298           sprintf(infostr, "%ld.%ld",(long int) MyLibrary->lib_Version,(long int) MyLibrary->lib_Revision);
 299           found = TRUE;
 300         }
 301
 302         if (strncmp(temp + screentitle_curChar, "%ov", 3) == 0)
 303         {
 304           struct Library *AROSBase = OpenLibrary(AROSLIBNAME, AROSLIBVERSION);
 305
 306           if (AROSBase!=NULL)
 307           {
 308             UWORD ver = 0;
 309             //UWORD    kickrev = 0;
 310
 311             ArosInquire
 312               (
 313                 AI_ArosVersion, (IPTR)&ver,
 314                 TAG_DONE
 315               );
 316             sprintf(infostr, "%d", ver);
 317             CloseLibrary(AROSBase);
 318             found = TRUE;
 319           }
 320         }
 321
 322         if (strncmp(temp + screentitle_curChar, "%os", 3) == 0)
 323         {
 324           struct Library *AROSBase = OpenLibrary(AROSLIBNAME, AROSLIBVERSION);
 325
 326           if (AROSBase != NULL)
 327           {
 328             ULONG ver = 0,
 329                 rev = 0;
 330
 331             ArosInquire
 332               (
 333                 AI_ArosReleaseMajor, (IPTR)&ver,
 334                 AI_ArosReleaseMinor, (IPTR)&rev,
 335                 TAG_DONE
 336               );
 337             sprintf(infostr, "%ld.%ld", ver, rev);
 338             CloseLibrary(AROSBase);
 339             found = TRUE;
 340           }
 341         }
 342
 343         if (strncmp(temp + screentitle_curChar, "%wb", 3) == 0)
 344         {
 345           struct Library *AROSBase = OpenLibrary(AROSLIBNAME, AROSLIBVERSION);
 346
 347           if (AROSBase != NULL)
 348           {
 349             ULONG ver = 0;
 350             ULONG    rev = 0;
 351
 352             ArosInquire
 353               (
 354                 AI_ArosReleaseMajor, (IPTR)&ver,
 355                 AI_ArosReleaseMinor, (IPTR)&rev,
 356                 TAG_DONE
 357               );
 358             sprintf(infostr, "%d.%d", WANDERERVERS, WANDERERREV);
 359             CloseLibrary(AROSBase);
 360             found = TRUE;
 361           }
 362         }
 363
 364         if (strncmp(temp + screentitle_curChar, "%pc", 3) == 0)
 365         {
 366           fmtlarge(infostr, AvailMem(MEMF_CHIP));
 367           found = TRUE;
 368         }
 369
 370         if (strncmp(temp + screentitle_curChar, "%pf", 3) == 0)
 371         {
 372           fmtlarge(infostr, AvailMem(MEMF_FAST));
 373           found = TRUE;
 374         }
 375
 376         if (strncmp(temp + screentitle_curChar, "%pt", 3) == 0)
 377         {
 378           fmtlarge(infostr, AvailMem(MEMF_ANY));
 379           found = TRUE;
 380         }
 381
 382         if (strncmp(temp + screentitle_curChar, "%PC", 3) == 0)
 383         {
 384           fmtlarge(infostr, AvailMem(MEMF_CHIP|MEMF_TOTAL));
 385           found = TRUE;
 386         }
 387
 388         if (strncmp(temp + screentitle_curChar, "%PF", 3) == 0)
 389         {
 390           fmtlarge(infostr, AvailMem(MEMF_FAST|MEMF_TOTAL));
 391           found = TRUE;
 392         }
 393
 394         if (strncmp(temp + screentitle_curChar, "%PT", 3) == 0)
 395         {
 396           fmtlarge(infostr, AvailMem(MEMF_ANY|MEMF_TOTAL));
 397           found = TRUE;
 398         }
 399
 400         if (found)
 401         {
 402           temp[screentitle_curChar + 1] = 's';
 403           temp[screentitle_curChar + 2] = ' ';
 404
 405           sprintf(title, temp, infostr);
 406
 407           screentitle_curChar = screentitle_curChar + strlen(infostr);
 408           strncpy(buffer, title, screentitle_curChar);
 409           strcpy(&buffer[screentitle_curChar], &temp[(screentitle_curChar + 3) - strlen(infostr)]);
 410           strcpy(temp, buffer);
 411
 412           screentitle_TemplateLen = screentitle_TemplateLen + strlen(infostr);
 413         }
 414         else
 415         {
 416           temp[screentitle_curChar] = '?';
 417           temp[screentitle_curChar + 1] = '?';
 418           temp[screentitle_curChar + 2] = '?';
 419           sprintf(title, temp);
 420         }
 421       }
 422       else
 423       {
 424         switch (screentitle_TemplateLen)
 425         {
 426           case 2:
 427             temp[screentitle_curChar]= '?';
 428             temp[screentitle_curChar + 1]= '?';
 429             break;
 430           case 1:
 431             temp[screentitle_curChar] = '?';
 432         }
 433         sprintf(title, temp);
 434       }
 435     }
 436   }
 437   sprintf(title, temp);
 438
 439   return title;
 440 }
 441 ///
 442
 443 ///ExpandEnvName()
 444 /* Expand a passed in env: string to its full location */
 445 /* Wanderer doesnt free this mem at the moment but should
 446    incase it is every closed */
 447 static STRPTR ExpandEnvName(STRPTR env_path)
 448 {
 449     BOOL     ok = FALSE;
 450     char     tmp_envbuff[1024];
 451     STRPTR   fullpath = NULL;
 452     BPTR     env_lock = (BPTR) NULL;
 453
 454     env_lock = Lock("ENV:", SHARED_LOCK);
 455     if (env_lock)
 456     {
 457         if (NameFromLock(env_lock, tmp_envbuff, 256)) ok = TRUE;
 458         UnLock(env_lock);
 459     }
 460
 461     if (ok)
 462     {
 463         if ((fullpath = AllocVec(strlen(tmp_envbuff) + strlen(env_path) + 1 + 1 - 4, MEMF_CLEAR | MEMF_PUBLIC)) != NULL)
 464         {
 465             strcpy(fullpath, tmp_envbuff);
 466             AddPart(fullpath, env_path + 4, 1019);
 467             return fullpath;
 468         }
 469     }
 470
 471     //We couldnt expand it so just use as is ..
 472     return env_path;
 473 }
 474 ///
 475
 476
 477 IPTR WandererPrefs__HandleFSUpdate()
 478 {
 479     DoMethod(wandererPrefs_PrefsObject, MUIM_WandererPrefs_Reload);
 480     return NULL;
 481 }
 482
 483 /*** Methods ****************************************************************/
 484
 485 ///OM_NEW()
 486 Object *WandererPrefs__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 487 {
 488     IPTR                _wandererPrefs__FSNotifyPort = 0;
 489     struct List         *_wandererPrefs__FSNotifyList = NULL;
 490     D(bug("[Wanderer:Prefs]:New()\n"));
 491
 492     _wandererPrefs__FSNotifyPort = GetTagData(MUIA_Wanderer_FileSysNotifyPort, (IPTR) NULL, message->ops_AttrList);
 493     _wandererPrefs__FSNotifyList = GetTagData(MUIA_Wanderer_FileSysNotifyList, (IPTR) NULL, message->ops_AttrList);
 494
 495     self = (Object *) DoSuperMethodA(CLASS, self, (Msg) message);
 496
 497     if (self != NULL)
 498     {
 499         SETUP_INST_DATA;
 500
 501         wandererPrefs_PrefsObject = self;
 502
 503         /* Setup notification on prefs file --------------------------------*/
 504         if (_wandererPrefs__FSNotifyList && ((wandererPrefs_PrefsNotifyHandler = AllocMem(sizeof(struct Wanderer_FSHandler), MEMF_CLEAR)) != NULL))
 505         {
 506             wandererPrefs_PrefsNotifyHandler->fshn_Node.ln_Name         = ExpandEnvName(wandererPrefs_PrefsFile);
 507             data->wpd_PrefsNotifyRequest.nr_Name                        = wandererPrefs_PrefsNotifyHandler->fshn_Node.ln_Name;
 508             data->wpd_PrefsNotifyRequest.nr_Flags                       = NRF_SEND_MESSAGE;
 509             data->wpd_PrefsNotifyRequest.nr_stuff.nr_Msg.nr_Port        = _wandererPrefs__FSNotifyPort;
 510             wandererPrefs_PrefsNotifyHandler->HandleFSUpdate            = WandererPrefs__HandleFSUpdate;
 511
 512             if (StartNotify(&data->wpd_PrefsNotifyRequest))
 513             {
 514 D(bug("[Wanderer:Prefs] Wanderer__OM_NEW: Prefs-notification setup on '%s'\n", data->wpd_PrefsNotifyRequest.nr_Name));
 515             }
 516             else
 517             {
 518 D(bug("[Wanderer:Prefs] Wanderer__OM_NEW: FAILED to setup Prefs-notification!\n"));
 519             }
 520             AddTail(_wandererPrefs__FSNotifyList, &wandererPrefs_PrefsNotifyHandler->fshn_Node);
 521         }
 522 D(bug("[Wanderer:Prefs]:New - reloading\n"));
 523
 524         NewList(&data->wpd_ViewSettings);
 525
 526         data->wpd_PROCESSING = FALSE;
 527
 528         DoMethod(self, MUIM_WandererPrefs_Reload);
 529     }
 530 D(bug("[Wanderer:Prefs] obj = %ld\n", self));
 531     return self;
 532 }
 533 ///
 534
 535 ///OM_DISPOSE()
 536 IPTR WandererPrefs__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 537 {
 538   SETUP_INST_DATA;
 539   EndNotify(&data->wpd_PrefsNotifyRequest);
 540   return DoSuperMethodA(CLASS, self, (Msg)message);
 541 }
 542 ///
 543
 544 ///OM_SET()
 545 IPTR WandererPrefs__OM_SET(Class *CLASS, Object *self, struct opSet *message)
 546 {
 547   SETUP_INST_DATA;
 548   const struct TagItem *tstate = message->ops_AttrList;
 549   struct TagItem *tag;
 550
 551   while ((tag = NextTagItem((TAGITEM)&tstate)) != NULL)
 552   {
 553     switch (tag->ti_Tag)
 554     {
 555       case MUIA_WandererPrefs_Processing:
 556         data->wpd_PROCESSING = (BOOL)tag->ti_Data;
 557         break;
 558       case MUIA_IconWindowExt_NetworkBrowser_Show:
 559         data->wpd_ShowNetwork = (LONG)tag->ti_Data;
 560         break;
 561
 562       case MUIA_IconWindowExt_UserFiles_ShowFilesFolder:
 563         data->wpd_ShowUserFiles = (LONG)tag->ti_Data;
 564         break;
 565
 566       case MUIA_IconWindowExt_ScreenTitle_String:
 567         strcpy((STRPTR)data->wpd_ScreenTitleString, (STRPTR)tag->ti_Data);
 568         //data->wpd_ScreenTitleString = (LONG)tag->ti_Data;
 569         break;
 570
 571       case MUIA_IconWindow_WindowNavigationMethod:
 572         data->wpd_NavigationMethod = (LONG)tag->ti_Data;
 573         break;
 574     }
 575   }
 576
 577   return DoSuperMethodA(CLASS, self, (Msg)message);
 578 }
 579 ///
 580
 581 ///OM_GET()
 582 IPTR WandererPrefs__OM_GET(Class *CLASS, Object *self, struct opGet *message)
 583 {
 584   SETUP_INST_DATA;
 585   IPTR *store = message->opg_Storage;
 586   IPTR  rv    = TRUE;
 587
 588   switch (message->opg_AttrID)
 589   {
 590     case MUIA_WandererPrefs_Processing:
 591       *store = (IPTR)data->wpd_PROCESSING;
 592       break;
 593
 594     case MUIA_IconWindowExt_NetworkBrowser_Show:
 595       *store = (IPTR)data->wpd_ShowNetwork;
 596       break;
 597
 598     case MUIA_IconWindowExt_UserFiles_ShowFilesFolder:
 599       *store = (IPTR)data->wpd_ShowUserFiles;
 600       break;
 601
 602   case MUIA_IconWindowExt_ScreenTitle_String:
 603       *store = (IPTR)data->wpd_ScreenTitleString;
 604 D(bug("[Wanderer:Prefs] WandererPrefs__GET: MUIA_IconWindowExt_ScreenTitle_String '%s'\n", data->wpd_ScreenTitleString));
 605       break;
 606
 607     case MUIA_IconWindow_WindowNavigationMethod:
 608       *store = (IPTR)data->wpd_NavigationMethod;
 609       break;
 610
 611     default:
 612       rv = DoSuperMethodA(CLASS, self, (Msg)message);
 613   }
 614
 615   return rv;
 616 }
 617 ///
 618
 619 ///ProcessGlobalChunk()
 620 BOOL WandererPrefs_ProccessGlobalChunk(Class *CLASS, Object *self, struct TagItem32 *global_chunk, IPTR chunk_size)
 621 {
 622   //SETUP_INST_DATA;
 623
 624   int i = 0, tag_count = (chunk_size / sizeof(struct TagItem32));
 625   BOOL cont = TRUE;
 626
 627 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessGlobalChunk()\n"));
 628 #warning "TODO: fix problems with endian-ness?"
 629
 630   for (i = 0; i < tag_count; i++)
 631   {
 632     if (cont)
 633     {
 634       /* prefs file is stored in little endian */
 635       if (AROS_LE2LONG(global_chunk[i].ti_Tag) == TAG_DONE)
 636       {
 637           cont = FALSE;
 638       }
 639       else if (AROS_LE2LONG(global_chunk[i].ti_Tag) == MUIA_WandererPrefs_DefaultStack)
 640       {
 641 #warning "TODO: We should have an option to set the DefaultStackSize in wanderers prefs, and push it onto workbench.library"
 642           struct TagItem wbca_Tags[] =
 643           {
 644                 { WBCTRLA_SetDefaultStackSize, (IPTR)AROS_LE2LONG(global_chunk[i].ti_Data)      },
 645                 { TAG_DONE, 0                                                                   }
 646           };
 647 #warning "TODO: What should we use for the name arg in WorkbenchControlA"
 648           WorkbenchControlA("", wbca_Tags);
 649       }
 650       else
 651       {
 652           SET(self, AROS_LE2LONG(global_chunk[i].ti_Tag), AROS_LE2LONG(global_chunk[i].ti_Data));
 653       }
 654     }
 655   }
 656
 657   return TRUE;
 658 }
 659 ///
 660
 661 ///WPEditor_ProccessNetworkChunk()
 662 BOOL WPEditor_ProccessNetworkChunk(Class *CLASS, Object *self, UBYTE *_viewSettings_Chunk)
 663 {
 664   //SETUP_INST_DATA;
 665
 666   struct TagItem *network_tags = (struct TagItem *)_viewSettings_Chunk;
 667   SET(self, AROS_LE2LONG(network_tags[0].ti_Tag), AROS_LE2LONG(network_tags[0].ti_Data));
 668
 669   return TRUE;
 670 }
 671 ///
 672
 673 ///WPEditor_ProccessScreenTitleChunk()
 674 BOOL WPEditor_ProccessScreenTitleChunk(Class *CLASS, Object *self, UBYTE *_ScreenTitle_Chunk)
 675 {
 676   //SETUP_INST_DATA;
 677   char *displayed_screentitle = _ScreenTitle_Chunk;
 678   char *userscreentitle = NULL;
 679
 680 D(bug("[Wanderer:Prefs] WandererPrefs__ProccessScreenTitleChunk@@@@@@@@@: ScreenTitle Template = '%s'\n", _ScreenTitle_Chunk));
 681
 682   if ((userscreentitle = ProcessUserScreenTitle(_ScreenTitle_Chunk)) != NULL)
 683   {
 684 D(bug("[Wanderer:Prefs] WandererPrefs__ProccessScreenTitleChunk@@@@@@@@@: ProcessUserScreenTitle returns '%s'\n", userscreentitle));
 685     displayed_screentitle = userscreentitle;
 686   }
 687
 688   SET(self, MUIA_IconWindowExt_ScreenTitle_String, displayed_screentitle);
 689 D(bug("[Wanderer:Prefs] WandererPrefs__ProccessScreenTitleChunk@@@@@@@@@: SCREENTITLE set\n"));
 690
 691   return TRUE;
 692 }
 693 ///
 694
 695 ///WandererPrefs_FindViewSettingsNode()
 696 struct WandererPrefs_ViewSettingsNode *WandererPrefs_FindViewSettingsNode(struct WandererPrefs_DATA *data, char *node_Name)
 697 {
 698   struct WandererPrefs_ViewSettingsNode *current_Node = NULL;
 699
 700   #ifdef __AROS__
 701   ForeachNode(&data->wpd_ViewSettings, current_Node)
 702   #else
 703   Foreach_Node(&data->wpd_ViewSettings, current_Node);
 704   #endif
 705   {
 706     if ((strcmp(current_Node->wpbn_Name, node_Name)) == 0) return current_Node;
 707   }
 708   return NULL;
 709 }
 710 ///
 711
 712 ///WandererPrefs_ProccessViewSettingsChunk()
 713 BOOL WandererPrefs_ProccessViewSettingsChunk(Class *CLASS, Object *self, char *_viewSettings_ViewName, UBYTE *_viewSettings_Chunk, IPTR chunk_size)
 714 {
 715   SETUP_INST_DATA;
 716
 717   struct WandererPrefs_ViewSettingsNode  *_viewSettings_Node = NULL;
 718
 719 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk()\n"));
 720
 721   _viewSettings_Node = WandererPrefs_FindViewSettingsNode(data, _viewSettings_ViewName);
 722
 723   if (_viewSettings_Node)
 724   {
 725 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: Updating Existing node @ 0x%p\n", _viewSettings_Node));
 726     if (_viewSettings_Node->wpbn_Background)
 727                 FreeVec((APTR)_viewSettings_Node->wpbn_Background);
 728 #warning "TODO: Free any Cached backgrounds here .."
 729   }
 730   else
 731   {
 732 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: Creating new node for '%s'\n", _viewSettings_ViewName));
 733     _viewSettings_Node = AllocMem(sizeof(struct WandererPrefs_ViewSettingsNode), MEMF_CLEAR|MEMF_PUBLIC);
 734
 735     _viewSettings_Node->wpbn_Name = AllocVec(strlen(_viewSettings_ViewName) + 1, MEMF_CLEAR|MEMF_PUBLIC);
 736     strcpy(_viewSettings_Node->wpbn_Name, _viewSettings_ViewName);
 737     #ifdef __AROS__
 738     _viewSettings_Node->wpbn_NotifyObject = (Object *)NotifyObject, End;
 739     #else
 740     _viewSettings_Node->wpbn_NotifyObject = MUI_NewObject(MUIC_Notify, TAG_DONE);
 741     #endif
 742
 743     AddTail(&data->wpd_ViewSettings, &_viewSettings_Node->wpbn_Node);
 744   }
 745
 746   _viewSettings_Node->wpbn_Background =(IPTR) AllocVec(strlen(_viewSettings_Chunk) + 1, MEMF_CLEAR|MEMF_PUBLIC);
 747   strcpy((char *)_viewSettings_Node->wpbn_Background, _viewSettings_Chunk);
 748 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: NAME BACKGROUND= %s\n",_viewSettings_Chunk));
 749   SET(_viewSettings_Node->wpbn_NotifyObject, MUIA_Background, _viewSettings_Chunk);
 750
 751 #warning "TODO: Cache backgrounds here .."
 752
 753   if (chunk_size > (strlen(_viewSettings_Chunk) + 1))
 754   {
 755     UBYTE _viewSettings_TagOffset = ((strlen(_viewSettings_Chunk)  + 1)/4);
 756     IPTR _viewSettings_TagCount;
 757
 758 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: Chunk has options Tag data ..\n"));
 759
 760     if ((_viewSettings_TagOffset * 4) != (strlen(_viewSettings_Chunk)  + 1))
 761     {
 762       _viewSettings_TagOffset = (_viewSettings_TagOffset + 1) * 4;
 763 D(bug("[WPEditor] WPEditor_ProccessBackgroundChunk: String length unalined - rounding up (length %d, rounded %d) \n", strlen(_viewSettings_Chunk) + 1, _viewSettings_TagOffset ));
 764     }
 765     else
 766     {
 767       _viewSettings_TagOffset = _viewSettings_TagOffset * 4;
 768 D(bug("[WPEditor] WPEditor_ProccessBackgroundChunk: String length doesnt need aligned (length %d) \n", strlen(_viewSettings_Chunk) + 1));
 769     }
 770
 771     _viewSettings_TagCount  = ((chunk_size - _viewSettings_TagOffset)/sizeof(struct TagItem32));
 772
 773 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: %d Tags at offset %d ..\n", _viewSettings_TagCount, _viewSettings_TagOffset));
 774
 775     if (_viewSettings_Node->wpbn_Options != NULL)
 776     {
 777 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: Freeing old background tag's @ 0x%p\n", _viewSettings_Node->wpbn_Options));
 778       FreeVec(_viewSettings_Node->wpbn_Options);
 779       _viewSettings_Node->wpbn_Options = NULL;
 780     }
 781
 782     _viewSettings_Node->wpbn_Options = AllocVec((_viewSettings_TagCount + 1) * sizeof(struct TagItem32), MEMF_CLEAR|MEMF_PUBLIC);
 783 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: New tag storage @ 0x%p\n", _viewSettings_Node->wpbn_Options));
 784
 785     CopyMem(_viewSettings_Chunk + _viewSettings_TagOffset, _viewSettings_Node->wpbn_Options, (_viewSettings_TagCount) * sizeof(struct TagItem32));
 786 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: Tags copied to storage \n"));
 787
 788     _viewSettings_Node->wpbn_Options[_viewSettings_TagCount].ti_Tag = TAG_DONE;
 789
 790     {
 791       int i = 0;
 792       for (i = 0; i < _viewSettings_TagCount; i++)
 793       {
 794 #if AROS_BIG_ENDIAN
 795       _viewSettings_Node->wpbn_Options[i].ti_Tag  = AROS_LE2LONG(_viewSettings_Node->wpbn_Options[i].ti_Tag);
 796       _viewSettings_Node->wpbn_Options[i].ti_Data = AROS_LE2LONG(_viewSettings_Node->wpbn_Options[i].ti_Data);
 797 #endif
 798 D(bug("[Wanderer:Prefs] WandererPrefs_ProccessViewSettingsChunk: Setting Tag 0x%p Value %d\n", _viewSettings_Node->wpbn_Options[i].ti_Tag, _viewSettings_Node->wpbn_Options[i].ti_Data));
 799       SET(_viewSettings_Node->wpbn_NotifyObject, _viewSettings_Node->wpbn_Options[i].ti_Tag, _viewSettings_Node->wpbn_Options[i].ti_Data);
 800       }
 801     }
 802   }
 803   return TRUE;
 804 }
 805 ///
 806
 807 ///WandererPrefs__MUIM_WandererPrefs_Reload()
 808 IPTR WandererPrefs__MUIM_WandererPrefs_Reload
 809 (
 810   Class *CLASS, Object *self, Msg message
 811 )
 812 {
 813   struct ContextNode     *context;
 814   struct IFFHandle       *handle;
 815   BOOL                   success = TRUE;
 816   LONG                   error;
 817   IPTR                   iff_parse_mode = IFFPARSE_SCAN;
 818   UBYTE                  chunk_buffer[IFF_CHUNK_BUFFER_SIZE];
 819
 820 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload()\n"));
 821
 822   if (!(handle = AllocIFF()))
 823     return FALSE;
 824
 825   handle->iff_Stream = (IPTR)Open(wandererPrefs_PrefsFile, MODE_OLDFILE);
 826
 827   if (!handle->iff_Stream)
 828     return FALSE;
 829
 830   InitIFFasDOS(handle);
 831
 832   if ((error = OpenIFF(handle, IFFF_READ)) == 0)
 833   {
 834     if ((error = StopChunk(handle, ID_PREF, ID_WANDR)) == 0)
 835     {
 836       SET(self, MUIA_WandererPrefs_Processing, TRUE);
 837       do
 838       {
 839         if ((error = ParseIFF(handle, iff_parse_mode)) == 0)
 840         {
 841           context = CurrentChunk(handle);
 842           iff_parse_mode = IFFPARSE_STEP;
 843
 844 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: Context 0x%p\n", context));
 845
 846           if ((error=ReadChunkBytes(handle, chunk_buffer, IFF_CHUNK_BUFFER_SIZE)))
 847           {
 848             struct WandererPrefsIFFChunkHeader *this_header =(struct WandererPrefsIFFChunkHeader *) chunk_buffer;
 849             char                               *this_chunk_name = NULL;
 850             IPTR                               this_chunk_size = AROS_LE2LONG(this_header->wpIFFch_ChunkSize);
 851
 852 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: ReadChunkBytes() Chunk matches Prefs Header size ..\n"));
 853
 854             if ((this_chunk_name = AllocVec(strlen(this_header->wpIFFch_ChunkType) +1,MEMF_ANY|MEMF_CLEAR)))
 855             {
 856               strcpy(this_chunk_name, this_header->wpIFFch_ChunkType);
 857 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: Prefs Header for '%s' data size %d bytes\n", this_chunk_name, this_chunk_size));
 858
 859               if ((error = ParseIFF(handle, IFFPARSE_STEP)) == IFFERR_EOC)
 860               {
 861 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: End of header chunk ..\n"));
 862
 863                 if ((error = ParseIFF(handle, IFFPARSE_STEP)) == 0)
 864                 {
 865                   context = CurrentChunk(handle);
 866
 867 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: Context 0x%p\n", context));
 868
 869                   error = ReadChunkBytes
 870                         (
 871                           handle,
 872                           chunk_buffer,
 873                           this_chunk_size
 874                         );
 875
 876                   if (error == this_chunk_size)
 877                   {
 878 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: ReadChunkBytes() Chunk matches Prefs Data size .. (%d)\n", error));
 879                     if ((strcmp(this_chunk_name, "wanderer:global")) == 0)
 880                     {
 881 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: Process data for wanderer global chunk ..\n"));
 882                       WandererPrefs_ProccessGlobalChunk(CLASS, self,(struct TagItem32 *) chunk_buffer, this_chunk_size);
 883                     }
 884                     else if ((strcmp(this_chunk_name, "wanderer:network")) == 0)
 885                     {
 886 D(bug("[WPEditor] WPEditor__MUIM_PrefsEditor_ImportFH: Process data for wanderer network config chunk ..\n"));
 887                       WPEditor_ProccessNetworkChunk(CLASS, self, chunk_buffer);
 888                     }
 889                     else if ((strcmp(this_chunk_name, "wanderer:screentitle")) == 0)
 890                     {
 891 D(bug("[WPEditor] WPEditor__MUIM_PrefsEditor_ImportFH: Process data for wanderer screentitle config chunk ..size=%d\n", error));
 892 D(bug("[WPEditor] WPEditor__MUIM_PrefsEditor_ImportFH: Process data for wanderer screentitle STRING= %s\n", chunk_buffer));
 893                       WPEditor_ProccessScreenTitleChunk(CLASS, self, chunk_buffer);
 894                     }
 895
 896                     else if ((strncmp(this_chunk_name, "wanderer:viewsettings", strlen("wanderer:viewsettings"))) == 0)
 897                     {
 898                       char *view_name = this_chunk_name + strlen("wanderer:viewsettings") + 1;
 899 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: Process data for wanderer background chunk '%s'..\n", view_name));
 900                       WandererPrefs_ProccessViewSettingsChunk(CLASS, self, view_name, chunk_buffer, this_chunk_size);
 901                     }
 902                   }//END if (error == this_chunk_size)
 903                   if ((error = ParseIFF(handle, IFFPARSE_STEP)) == IFFERR_EOC)
 904                   {
 905 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_Reload: TAG_DONE) of Data chunk ..\n"));
 906                   }
 907                 }//END if ((error = ParseIFF(handle, IFFPARSE_STEP)) == 0)
 908               }//END if ((error = ParseIFF(handle, IFFPARSE_STEP)) == IFFERR_EOC)
 909             }//END if ((this_chunk_name = AllocVec(strlen(this_header->wpIFFch_ChunkType) +1,MEMF_ANY|MEMF_CLEAR)))
 910           }//END if ((error=ReadChunkBytes(handle, chunk_buffer, IFF_CHUNK_BUFFER_SIZE)))
 911         }
 912         else
 913         {
 914 D(bug("[Wanderer:Prefs] ParseIFF() failed, returncode %ld!\n", error));
 915           //success = FALSE;
 916         }//END if ((error = ParseIFF(handle, iff_parse_mode)) == 0)
 917
 918       } while (error != IFFERR_EOF);
 919       SET(self, MUIA_WandererPrefs_Processing, FALSE);
 920     }
 921     else
 922     {
 923 D(bug("[Wanderer:Prefs] StopChunk() failed, returncode %ld!\n", error));
 924       //success = FALSE;
 925     }
 926
 927     CloseIFF(handle);
 928   }
 929   else
 930   {
 931 D(bug("[Wanderer:Prefs] Failed to open stream!, returncode %ld!\n", error));
 932     //ShowError(_(MSG_CANT_OPEN_STREAM));
 933     success = FALSE;
 934   }//END if ((error = StopChunk(handle, ID_PREF, ID_WANDR)) == 0)
 935
 936   Close((BPTR)handle->iff_Stream);
 937
 938   FreeIFF(handle);
 939
 940   return success;
 941 }
 942 ///
 943
 944 ///WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetNotifyObject()
 945 IPTR WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetNotifyObject
 946 (
 947   Class *CLASS, Object *self, struct MUIP_WandererPrefs_ViewSettings_GetNotifyObject *message
 948 )
 949 {
 950   SETUP_INST_DATA;
 951   struct WandererPrefs_ViewSettingsNode *current_Node = NULL;
 952
 953 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetNotifyObject()\n"));
 954
 955   if ((current_Node = WandererPrefs_FindViewSettingsNode(data, message->Background_Name)))
 956   {
 957 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetNotifyObject: Returning Object for existing record\n"));
 958     return (IPTR) current_Node->wpbn_NotifyObject;
 959   }
 960
 961   current_Node = AllocMem(sizeof(struct WandererPrefs_ViewSettingsNode), MEMF_CLEAR|MEMF_PUBLIC);
 962 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetNotifyObject: Created new node ..\n"));
 963
 964   current_Node->wpbn_Name = AllocVec(strlen(message->Background_Name) + 1, MEMF_CLEAR|MEMF_PUBLIC);
 965   strcpy(current_Node->wpbn_Name, message->Background_Name);
 966     #ifdef __AROS__
 967     current_Node->wpbn_NotifyObject = (Object *)NotifyObject, End;
 968     #else
 969     current_Node->wpbn_NotifyObject = MUI_NewObject(MUIC_Notify, TAG_DONE);
 970     #endif
 971   AddTail(&data->wpd_ViewSettings, &current_Node->wpbn_Node);
 972
 973 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetNotifyObject: Notify Object @ 0x%p\n", current_Node->wpbn_NotifyObject));
 974
 975   return (IPTR) current_Node->wpbn_NotifyObject;
 976 }
 977 ///
 978
 979 ///NextTag32Item()
 980 #warning "TODO: Replace with propper 64bit check"
 981 /* 32bit replacements for utility.library tag funcs */
 982 struct TagItem32 *  NextTag32Item(struct TagItem32 ** tagListPtr)
 983 {
 984   if(!(*tagListPtr)) return NULL;
 985
 986   while (TRUE)
 987   {
 988     switch ((*tagListPtr)->ti_Tag)
 989     {
 990     case TAG_IGNORE:
 991       break;
 992
 993     case TAG_END:
 994       (*tagListPtr) = NULL;
 995       return NULL;
 996
 997     case TAG_SKIP:
 998       (*tagListPtr) += (*tagListPtr)->ti_Data + 1;
 999       continue;
1000
1001     default:
1002       /* Use post-increment (return will return the current value and
1003       then tagListPtr will be incremented) */
1004       return (struct TagItem32 *)(*tagListPtr)++;
1005     }
1006
1007     (*tagListPtr) ++;
1008   }
1009 }
1010 ///
1011
1012 ///FindTag32Item()
1013 struct TagItem32 * FindTag32Item(ULONG tagValue, struct TagItem32 *tagList)
1014 {
1015   struct TagItem32 *tag;
1016   const struct TagItem32 *tagptr = tagList;
1017
1018   while ((tag = NextTag32Item((struct TagItem32 **)&tagptr)))
1019   {
1020     if (tag->ti_Tag == tagValue) return tag;
1021   }
1022
1023   return NULL;
1024
1025 }
1026 ///
1027
1028 ///GetTag32Data()
1029 ULONG GetTag32Data(ULONG tagValue, ULONG defaultVal, struct TagItem32 *tagList)
1030 {
1031   struct TagItem32 *ti = NULL;
1032
1033   if ((tagList != NULL) && (ti = FindTag32Item(tagValue, tagList)))
1034   return ti->ti_Data;
1035
1036   return defaultVal;
1037 }
1038 ///
1039
1040 ///WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetAttribute()
1041 IPTR WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetAttribute
1042 (
1043   Class *CLASS, Object *self, struct MUIP_WandererPrefs_ViewSettings_GetAttribute *message
1044 )
1045 {
1046   SETUP_INST_DATA;
1047   struct WandererPrefs_ViewSettingsNode *current_Node = NULL;
1048
1049 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetAttribute()\n"));
1050
1051   if ((current_Node = WandererPrefs_FindViewSettingsNode(data, message->Background_Name)) != NULL)
1052   {
1053 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetAttribute: Found Background Record ..\n"));
1054     if (message->AttributeID == MUIA_Background)
1055     {
1056       if (current_Node->wpbn_Background) return current_Node->wpbn_Background;
1057     }
1058     else if (current_Node->wpbn_Options)
1059     {
1060       if (sizeof(IPTR) > 4)
1061       {
1062         ULONG retVal = GetTag32Data(message->AttributeID, (ULONG)-1,(struct TagItem32 *) current_Node->wpbn_Options);
1063
1064 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetAttribute: Using internal GetTag32Data()\n"));
1065
1066         if (retVal != (ULONG)-1)
1067         return (IPTR)retVal;
1068       }
1069       else
1070       {
1071 D(bug("[Wanderer:Prefs] WandererPrefs__MUIM_WandererPrefs_ViewSettings_GetAttribute: Using utility.library->GetTagData()\n"));
1072         return (IPTR)GetTagData(message->AttributeID, (IPTR)-1, (struct TagItem *) current_Node->wpbn_Options);
1073       }
1074     }
1075   }
1076   return (IPTR)-1;
1077 }
1078 ///
1079 /*** Setup ******************************************************************/
1080 ZUNE_CUSTOMCLASS_7
1081 (
1082   WandererPrefs, NULL, MUIC_Notify, NULL,
1083   OM_NEW,                                              struct opSet *,
1084   OM_DISPOSE,                                          Msg,
1085   OM_SET,                                              struct opSet *,
1086   OM_GET,                                              struct opGet *,
1087   MUIM_WandererPrefs_Reload,                           Msg,
1088   MUIM_WandererPrefs_ViewSettings_GetNotifyObject,     struct MUIP_WandererPrefs_ViewSettings_GetNotifyObject *,
1089   MUIM_WandererPrefs_ViewSettings_GetAttribute,        struct MUIP_WandererPrefs_ViewSettings_GetAttribute *
1090 );