workbench/system/Wanderer/wandererprefs.c

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