workbench/system/Wanderer/wandererprefs.c

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