workbench/system/Wanderer/wandererprefs.c

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