workbench/prefs/reqtools/reqtools.c

   1 /********************************************
   2 *                                           *
   3 *  (C) Copyright 92-94 by Nico François     *
   4 *                95-96 by Magnus Holmgren   *
   5 *                                           *
   6 ********************************************/
   7
   8 #include <exec/execbase.h>
   9 #include <proto/dos.h>
  10 #include <proto/gadtools.h>
  11 #include <proto/icon.h>
  12 #include <proto/utility.h>
  13
  14
  15 #include <proto/reqtools.h>
  16 #include <proto/wb.h>
  17 #include <proto/graphics.h>
  18 #include <proto/icon.h>
  19 #include <proto/exec.h>
  20 #include <proto/intuition.h>
  21 #include <proto/gadtools.h>
  22
  23 #include <exec/types.h>
  24 #include <exec/io.h>
  25 #include <exec/memory.h>
  26 #include <exec/lists.h>
  27 #include <dos/stdio.h>
  28 #include <dos/dosextens.h>
  29 #include <utility/tagitem.h>
  30 #include <libraries/gadtools.h>
  31 #include <intuition/intuition.h>
  32 #include <intuition/intuitionbase.h>
  33 #include <intuition/gadgetclass.h>
  34 #include <graphics/gfxbase.h>
  35 #include <workbench/startup.h>
  36 #include <workbench/workbench.h>
  37 #include <libraries/reqtools.h>
  38 #include <libraries/locale.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 #include "gui.h"
  44 #include "misc.h"
  45
  46 #include "reqtools_rev.h"
  47
  48 #ifdef __AROS__
  49 #include <aros/macros.h>
  50 #include <proto/alib.h>
  51 #define __exit exit
  52 #define __main was__main
  53 #define __stdargs
  54 #define _WBenchMsg WBenchMsg
  55 #endif
  56
  57 const char VersTag[] = VERSTAG;
  58
  59 #define CONFIGFILE              "Env:ReqTools.prefs"
  60 #define CONFIGFILE_ARC          "EnvArc:ReqTools.prefs"
  61
  62 #ifndef __AROS__
  63 #pragma libcall ReqToolsBase rtLockPrefs   a8 00
  64 #pragma libcall ReqToolsBase rtUnlockPrefs ae 00
  65 #endif
  66
  67 #define STRGADBUFF(x)           ((struct StringInfo *)(x->SpecialInfo))->Buffer
  68 #define INTGADVALUE(x)          ((struct StringInfo *)(x->SpecialInfo))->LongInt
  69
  70
  71 struct Library *ConsoleDevice;
  72
  73 struct MenuItem *iconitem;
  74
  75 /* Global stuff */
  76
  77 struct Library          *GadToolsBase;
  78 struct Library          *IconBase;
  79 struct GfxBase          *GfxBase;
  80 struct IntuitionBase    *IntuitionBase;
  81 struct ReqToolsBase     *ReqToolsBase;
  82 #ifdef __AROS__
  83 struct UtilityBase      *UtilityBase;
  84 #else
  85 struct Library          *UtilityBase;
  86 #endif
  87 struct Window           *WindowPtr;
  88 struct Screen           *Screen;
  89 struct DrawInfo         *DrawInfo;
  90 struct Menu             *Menus;
  91 APTR                    VisualInfo;
  92 UWORD                   Zoom[ 4 ];
  93
  94 /* Local stuff */
  95
  96 TEXT                    File[ 256 ];
  97
  98 struct ReqToolsPrefs    RTPrefs;
  99 struct ReqToolsPrefs    DefaultPrefs;
 100 struct ReqDefaults      *ReqDefs;
 101
 102 #define PREFSLEN        RTPREFS_SIZE
 103
 104 WORD                    CurrentReq, WheelType;
 105 BOOL                    CreateIcons, UseScreenFont = TRUE;
 106
 107 struct rtFileRequester  *FileReq;
 108
 109 struct RDArgs           *RDArgs;
 110 struct DiskObject       *DiskObject;
 111
 112 struct Hook             IntuiHook;
 113
 114
 115 struct NewMenu NewMenu[] =
 116 {
 117     { NM_TITLE, MSG_PROJECT_MENU,        NULL, 0, 0, 0 },
 118     { NM_ITEM,  MSG_PROJECT_OPEN,        NULL, 0, 0, 0 },
 119     { NM_ITEM,  MSG_PROJECT_SAVEAS,      NULL, 0, 0, 0 },
 120     { NM_ITEM,  NM_BARLABEL,             NULL, 0, 0, 0 },
 121     { NM_ITEM,  MSG_PROJECT_ABOUT,       NULL, 0, 0, 0 },
 122     { NM_ITEM,  NM_BARLABEL,             NULL, 0, 0, 0 },
 123     { NM_ITEM,  MSG_PROJECT_QUIT,        NULL, 0, 0, 0 },
 124     { NM_TITLE, MSG_EDIT_MENU,           NULL, 0, 0, 0 },
 125     { NM_ITEM,  MSG_EDIT_RESET,          NULL, 0, 0, 0 },
 126     { NM_ITEM,  MSG_EDIT_LASTSAVED,      NULL, 0, 0, 0 },
 127     { NM_ITEM,  MSG_EDIT_RESTORE,        NULL, 0, 0, 0 },
 128     { NM_TITLE, MSG_OPTIONS_MENU,        NULL, 0, 0, 0 },
 129     { NM_ITEM,  MSG_OPTIONS_CREATEICONS, NULL, CHECKED|CHECKIT|MENUTOGGLE, 0, 0 },
 130     { NM_END,   NULL,                    NULL, 0, 0, 0 }
 131 };
 132
 133 #define MENU_PROJECT            0
 134 #define MENU_EDIT               1
 135 #define MENU_OPTIONS            2
 136
 137 #define ITEM_OPEN               FULLMENUNUM( MENU_PROJECT, 0, NOSUB )
 138 #define ITEM_SAVEAS             FULLMENUNUM( MENU_PROJECT, 1, NOSUB )
 139 #define ITEM_ABOUT              FULLMENUNUM( MENU_PROJECT, 3, NOSUB )
 140 #define ITEM_QUIT               FULLMENUNUM( MENU_PROJECT, 5, NOSUB )
 141
 142 #define ITEM_RESET              FULLMENUNUM( MENU_EDIT, 0, NOSUB )
 143 #define ITEM_LASTSAVED          FULLMENUNUM( MENU_EDIT, 1, NOSUB )
 144 #define ITEM_RESTORE            FULLMENUNUM( MENU_EDIT, 2, NOSUB )
 145
 146 #define ITEM_CREATEICONS        FULLMENUNUM( MENU_OPTIONS, 0, NOSUB )
 147
 148
 149 /*******
 150 * MISC *
 151 *******/
 152
 153
 154 #define CloseLib(lib)           CloseLibrary( ( struct Library * ) lib )
 155
 156 VOID
 157 FreeExit( LONG rc )
 158 {
 159     if( Menus )
 160     {
 161         if( WindowPtr )
 162         {
 163             ClearMenuStrip( WindowPtr );
 164         }
 165
 166         FreeMenus( Menus );
 167     }
 168
 169     CloseGUI();
 170
 171     if( Screen )
 172     {
 173         FreeScreenDrawInfo( Screen, DrawInfo );
 174         UnlockPubScreen (NULL, Screen );
 175     }
 176
 177     if( GadToolsBase )
 178     {
 179         FreeVisualInfo( VisualInfo );
 180     }
 181
 182     if( FileReq )
 183     {
 184         rtFreeRequest( FileReq );
 185     }
 186
 187     if( DiskObject )
 188     {
 189         FreeDiskObject( DiskObject );
 190     }
 191
 192     FreeArgs( RDArgs );
 193     FreeLocale();
 194
 195     CloseLib( GadToolsBase );
 196     CloseLib( IconBase );
 197     CloseLib( IntuitionBase );
 198     CloseLib( ReqToolsBase );
 199     CloseLib( UtilityBase );
 200
 201     CloseLibrary( ( struct Library * ) GfxBase );
 202     __exit( rc );
 203 }
 204
 205 /*******
 206 * MAIN *
 207 *******/
 208
 209 VOID    WriteErr( VOID );
 210 VOID    OpenFile( VOID );
 211 VOID    SaveAs( VOID );
 212 VOID    CreateIcon( STRPTR );
 213 LONG    GetFilename( STRPTR, CONST_STRPTR, ULONG );
 214 LONG    LoadConfig( STRPTR );
 215 LONG    SaveConfig( STRPTR );
 216
 217
 218 struct Args
 219 {
 220     STRPTR    From;
 221     STRPTR    ScreenFont;
 222     STRPTR    PubScreen;
 223 };
 224
 225
 226 #define TEMPLATE    "FROM,SCREENFONT/K,PUBSCREEN/K"
 227
 228 extern struct WBStartup *_WBenchMsg;
 229
 230
 231 WORD
 232 GetWheelType( ULONG flags )
 233 {
 234     WORD    type = 0;
 235
 236     if( flags & RTPRF_DOWHEEL )
 237     {
 238         type = 1;
 239
 240         if( flags & RTPRF_FANCYWHEEL )
 241         {
 242             type = 2;
 243         }
 244     }
 245
 246     return( type );
 247 }
 248
 249
 250 ULONG
 251 SetWheelType( WORD type )
 252 {
 253     switch( type )
 254     {
 255         case 1:
 256             return( RTPRF_DOWHEEL );
 257
 258         case 2:
 259             return( RTPRF_DOWHEEL | RTPRF_FANCYWHEEL );
 260     }
 261
 262     return( 0 );
 263 }
 264
 265
 266 APTR
 267 OpenLib( STRPTR name, LONG ver )
 268 {
 269     APTR    lib;
 270
 271     if( !( lib = OpenLibrary( name, ver ) ) )
 272     {
 273         LocEZReq( MSG_ERROR_LIBRARY, MSG_ABORT, name, ver );
 274         FreeExit( RETURN_FAIL );
 275     }
 276
 277     return( lib );
 278 }
 279
 280
 281 VOID __stdargs
 282 __main( char *argstring )
 283 {
 284     static struct Args     args;
 285     LONG    rev;
 286
 287     /* Get arguments if started from CLI */
 288     if( !_WBenchMsg )
 289     {
 290         if( !( RDArgs = ReadArgs( TEMPLATE, ( IPTR * ) &args, NULL ) ) )
 291         {
 292             PrintFault( IoErr(), GetString( MSG_ERROR_ARGS ) );
 293             __exit( 0 );
 294         }
 295     }
 296
 297     IntuiHook.h_Entry = ( HOOKFUNC ) IntuiMsgFunc;
 298
 299 //    DefaultPrefs.Flags = 0;
 300     DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ      ].ReqPos = REQPOS_POINTER;
 301     DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].Size = 75;
 302     DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].Size =
 303     DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].Size =
 304     DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].Size = 65;
 305     DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].ReqPos =
 306     DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].ReqPos =
 307     DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].ReqPos =
 308     DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].ReqPos =
 309     DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ    ].ReqPos = REQPOS_TOPLEFTSCR;
 310     DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].LeftOffset =
 311     DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].LeftOffset =
 312     DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].LeftOffset =
 313     DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].LeftOffset =
 314     DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ    ].LeftOffset =
 315     DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ      ].LeftOffset = 25;
 316     DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].TopOffset =
 317     DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].TopOffset =
 318     DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].TopOffset =
 319     DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].TopOffset =
 320     DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ    ].TopOffset =
 321     DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ      ].TopOffset = 18;
 322     DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].MinEntries = 10;
 323     DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].MinEntries =
 324     DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MinEntries =
 325     DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].MinEntries = 6;
 326     DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].MaxEntries = 50;
 327     DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].MaxEntries =
 328     DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MaxEntries =
 329     DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].MaxEntries = 10;
 330
 331     if( !( IntuitionBase = ( struct IntuitionBase * ) OpenLibrary( "intuition.library", 37 ) ) )
 332     {
 333         BPTR    con;
 334
 335         if( ( con = Open( "CON:40/20/320/40/ReqTools 2.8", MODE_NEWFILE ) ) )
 336         {
 337             Write( con, "\nNeed OS 2.04 or better!\n", 25 );
 338             Delay( 120L );
 339             Close( con );
 340         }
 341
 342         FreeExit( 0 );
 343     }
 344
 345     InitLocale();
 346     GfxBase      = OpenLib( "graphics.library", 37 );
 347     UtilityBase  = OpenLib( "utility.library", 36 );
 348     IconBase     = OpenLib( "icon.library", 0 );
 349     GadToolsBase = OpenLib( "gadtools.library", 37 );
 350     ReqToolsBase = OpenLib( "reqtools.library", 38 );
 351
 352     rev = ReqToolsBase->LibNode.lib_Revision;
 353
 354     if( ( rev >= 693 && rev <= 811 ) || ( rev >= 347 && rev <= 363 ) )
 355     {
 356         LocEZReq( MSG_WRONG_REQTOOLS_VERSION, MSG_ABORT );
 357         FreeExit( RETURN_FAIL );
 358     }
 359
 360     if( rtLockPrefs()->PrefsSize != PREFSLEN )
 361     {
 362         LocEZReq( MSG_ALL_PREFS_NOT_SUPPORTED, MSG_OK );
 363     }
 364
 365     rtUnlockPrefs();
 366
 367     if( _WBenchMsg )
 368     {
 369         struct WBArg    *wbarg;
 370         BPTR    oldcd;
 371
 372         CreateIcons = TRUE;
 373         wbarg = &_WBenchMsg->sm_ArgList[ 0 ];
 374         oldcd = CurrentDir( wbarg->wa_Lock );
 375
 376         if( ( DiskObject = GetDiskObject( wbarg->wa_Name ) ) )
 377         {
 378             STRPTR    str;
 379
 380             if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "CREATEICONS" ) ) )
 381             {
 382                 CreateIcons = Stricmp( str, "NO" );
 383             }
 384
 385             if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "SCREENFONT" ) ) )
 386             {
 387                 UseScreenFont = Stricmp( str, "NO" );
 388             }
 389
 390             if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "PUBSCREEN" ) ) )
 391             {
 392                 args.PubScreen = str;
 393             }
 394         }
 395
 396         CurrentDir( oldcd );
 397     }
 398     else
 399     {
 400         if( args.ScreenFont )
 401         {
 402             UseScreenFont = Stricmp( args.ScreenFont, "NO" );
 403         }
 404     }
 405
 406     if( !( FileReq = rtAllocRequestA( RT_FILEREQ, NULL ) ) )
 407     {
 408         FreeExit( RETURN_FAIL );
 409     }
 410
 411         {
 412         struct TagItem tags[] =
 413         {
 414             {RTFI_Dir    , (IPTR)"Presets"    },
 415             {TAG_DONE                }
 416         };
 417
 418         rtChangeReqAttrA( FileReq, tags );
 419     }
 420
 421     /* Get current prefs from ReqTools */
 422     CopyMem( rtLockPrefs(), &RTPrefs, sizeof( struct ReqToolsPrefs ) );
 423     rtUnlockPrefs();
 424
 425     /* If FROM was used load prefs from disk */
 426     if( args.From )
 427     {
 428         if( !LoadConfig( args.From ) )
 429         {
 430             FreeExit( RETURN_ERROR );
 431         }
 432     }
 433
 434     WheelType = GetWheelType( RTPrefs.Flags );
 435
 436     if( !( Screen = LockPubScreen( args.PubScreen ) ) )
 437     {
 438         LocEZReq( MSG_COULDNT_LOCK_PUBSCREEN, MSG_ABORT );
 439         FreeExit( RETURN_ERROR );
 440     }
 441
 442     if( !( DrawInfo = GetScreenDrawInfo( Screen ) ) )
 443     {
 444         LocEZReq( MSG_ERROR_GETSCREENDRAWINFO, MSG_ABORT );
 445         FreeExit( RETURN_ERROR );
 446     }
 447
 448     if( !( VisualInfo = GetVisualInfoA( Screen, NULL ) ) )
 449     {
 450         LocEZReq( MSG_ERROR_GETVISUALINFO, MSG_ABORT );
 451         FreeExit( RETURN_FAIL );
 452     }
 453
 454     if( IntuitionBase->LibNode.lib_Version >= 39 )
 455     {
 456         Zoom[ 0 ] = Zoom[ 1 ] = 65535;
 457     }
 458     else
 459     {
 460         Zoom[ 1 ] = Screen->BarHeight + 1;
 461     }
 462
 463     Zoom[ 2 ] = 250;
 464     Zoom[ 3 ] = Screen->WBorTop + Screen->Font->ta_YSize + 1;
 465     LocalizeMenus( NewMenu );
 466
 467     if( !( Menus = CreateMenusA( NewMenu, NULL ) ) )
 468     {
 469         LocEZReq( MSG_ERROR_MENUS, MSG_ABORT );
 470         FreeExit( RETURN_FAIL );
 471     }
 472
 473     LayoutMenus( Menus, VisualInfo,
 474         GTMN_NewLookMenus,    TRUE,
 475     TAG_END );
 476
 477     if( !OpenGUI() )
 478     {
 479         LocEZReq( MSG_COULDNT_OPEN_WINDOW, MSG_ABORT );
 480         FreeExit( RETURN_FAIL );
 481     }
 482
 483
 484     {
 485         struct MenuItem    *iconItem;
 486
 487         iconItem = ItemAddress( Menus, FULLMENUNUM( OPTIONS_MENU, SAVEICONS_ITEM, NOSUB ) );
 488
 489         if( !CreateIcons )
 490         {
 491             iconItem->Flags &= ~CHECKED;
 492         }
 493     }
 494
 495     CurrentReq = RTPREF_FILEREQ;
 496     ReqDefs = &RTPrefs.ReqDefaults[ CurrentReq ];
 497     LoopGUI();
 498     FreeExit( 0 );
 499 }
 500
 501
 502 BOOL
 503 ProcessGadget( UWORD id, UWORD code )
 504 {
 505     BOOL    run = TRUE;
 506     LONG    val;
 507
 508     switch( id )
 509     {
 510         case NOSCRTOFRONT_GADID:
 511             RTPrefs.Flags ^= RTPRF_NOSCRTOFRONT;
 512             break;
 513
 514         case IMMSORT_GADID:
 515             RTPrefs.Flags ^= RTPRF_IMMSORT;
 516             break;
 517
 518         case DIRSFIRST_GADID:
 519             RTPrefs.Flags ^= RTPRF_DIRSFIRST;
 520
 521             if( RTPrefs.Flags & RTPRF_DIRSMIXED )
 522             {
 523                 SetCheckState( mixdirsgad, FALSE );
 524                 RTPrefs.Flags &= ~RTPRF_DIRSMIXED;
 525             }
 526
 527             break;
 528
 529         case DIRSMIXED_GADID:
 530             RTPrefs.Flags ^= RTPRF_DIRSMIXED;
 531
 532             if( RTPrefs.Flags & RTPRF_DIRSFIRST )
 533             {
 534                 SetCheckState( dirsfirstgad, FALSE );
 535                 RTPrefs.Flags &= ~RTPRF_DIRSFIRST;
 536             }
 537
 538             break;
 539
 540         case NOLED_GADID:
 541             RTPrefs.Flags ^= RTPRF_NOLED;
 542             break;
 543
 544         case MMB_GADID:
 545             RTPrefs.Flags ^= RTPRF_MMBPARENT;
 546             break;
 547
 548         case DEFAULTFONT_GADID:
 549             RTPrefs.Flags ^= RTPRF_DEFAULTFONT;
 550             break;
 551
 552         case DOWHEEL_GADID:
 553             /* First clear all bits */
 554             RTPrefs.Flags &= ~( RTPRF_DOWHEEL | RTPRF_FANCYWHEEL );
 555             /* Then set appropriate ones */
 556             RTPrefs.Flags |= SetWheelType( WheelType = code );
 557             break;
 558
 559         case FKEYS_GADID:
 560             RTPrefs.Flags ^= RTPRF_FKEYS;
 561             break;
 562
 563         case REQTYPE_GADID:
 564             if( CurrentReq != code )
 565             {
 566                 CurrentReq = code;
 567                 UpdatePrefsWindow( TRUE );
 568                 ReqDefs = &RTPrefs.ReqDefaults[ CurrentReq ];
 569             }
 570
 571             break;
 572
 573         case DEFSIZE_GADID:
 574             ReqDefs->Size = code;
 575             break;
 576
 577         case MINENTRIES_GADID:
 578             val = IntGadValue( mingad );
 579
 580             if( val < 3 )
 581             {
 582                 val = 3;
 583             }
 584
 585             if( val > ReqDefs->MaxEntries )
 586             {
 587                 val = ReqDefs->MaxEntries;
 588             }
 589
 590             if( val != IntGadValue( mingad ) )
 591             {
 592                 SetIntGad( mingad, val );
 593             }
 594
 595             ReqDefs->MinEntries = val;
 596             break;
 597
 598         case MAXENTRIES_GADID:
 599             val = IntGadValue( maxgad );
 600
 601             if( val > 50 )
 602             {
 603                 val = 50;
 604             }
 605
 606             if( val < ReqDefs->MinEntries )
 607             {
 608                 val = ReqDefs->MinEntries;
 609             }
 610
 611             if( val != IntGadValue( maxgad ) )
 612             {
 613                 SetIntGad( maxgad, val );
 614             }
 615
 616             ReqDefs->MaxEntries = val;
 617             break;
 618
 619         case POSITION_GADID:
 620             if( ReqDefs->ReqPos != code )
 621             {
 622                 ReqDefs->ReqPos = code;
 623
 624                 if( code <= REQPOS_CENTERSCR )
 625                 {
 626                     GadgetOff( xoffgad );
 627                     GadgetOff( yoffgad );
 628                 }
 629                 else
 630                 {
 631                     GadgetOn( xoffgad );
 632                     GadgetOn( yoffgad );
 633                 }
 634             }
 635
 636             break;
 637
 638         case OFFSETX_GADID:
 639             ReqDefs->LeftOffset = IntGadValue( xoffgad );
 640             break;
 641
 642         case OFFSETY_GADID:
 643             ReqDefs->TopOffset = IntGadValue( yoffgad );
 644             break;
 645
 646         case SAVE_GADID:
 647             SaveConfig( CONFIGFILE_ARC );
 648             /* FALLTHROUGH! */
 649
 650         case USE_GADID:
 651             {
 652                 struct ReqToolsPrefs    *prefs;
 653
 654                 SaveConfig( CONFIGFILE );
 655                 prefs = rtLockPrefs();
 656                 CopyMem( &RTPrefs.Flags, &prefs->Flags, PREFSLEN );
 657                 rtUnlockPrefs();
 658             }
 659
 660             /* FALLTHROUGH! */
 661
 662         case CANCEL_GADID:
 663             run = FALSE;
 664             break;
 665     }
 666
 667     return( run );
 668 }
 669
 670
 671 BOOL
 672 ProcessMenuItem( UWORD id )
 673 {
 674     BOOL    run = TRUE;
 675
 676     switch( id )
 677     {
 678         case ITEM_LASTSAVED:
 679         case ITEM_OPEN:
 680             if( id == ITEM_LASTSAVED )
 681             {
 682                 if( !LoadConfig( CONFIGFILE_ARC ) )
 683                 {
 684                     run = FALSE;
 685                 }
 686             }
 687             else
 688             {
 689                 OpenFile();
 690             }
 691
 692             UpdatePrefsWindow( FALSE );
 693             break;
 694
 695         case ITEM_SAVEAS:
 696             SaveAs();
 697             break;
 698
 699         case ITEM_ABOUT:
 700             {
 701                 struct TagItem tags[] =
 702                 {
 703                     {RT_LockWindow    , TRUE            },
 704                 {RT_Window    , (IPTR)WindowPtr    },
 705                 {RT_ShareIDCMP    , TRUE            },
 706                 {RT_IntuiMsgFunc, (IPTR)&IntuiHook    },
 707                 {RTEZ_Flags    , EZREQF_CENTERTEXT    },
 708                 {TAG_DONE                }
 709                 };
 710
 711                 rtEZRequestA(
 712                 "ReqTools Preferences 2.8\n"
 713                 "\n"
 714                 "Copyright © 1992-1994 Nico François\n"
 715                 "            1995-1996 Magnus Holmgren\n"
 716                 "(Compilation Date: " DATE ")",
 717                 GetString( MSG_OK ), NULL, NULL, tags);
 718             }
 719             break;
 720
 721         case ITEM_QUIT:
 722             run = FALSE;
 723             break;
 724
 725         case ITEM_RESET:
 726             CopyMem( &DefaultPrefs, &RTPrefs, sizeof( struct ReqToolsPrefs ) );
 727             UpdatePrefsWindow( FALSE );
 728             break;
 729
 730         case ITEM_RESTORE:
 731             CopyMem( rtLockPrefs(), &RTPrefs, sizeof( struct ReqToolsPrefs ) );
 732             rtUnlockPrefs();
 733             UpdatePrefsWindow( FALSE );
 734             break;
 735
 736         case ITEM_CREATEICONS:
 737             CreateIcons = !CreateIcons;
 738             break;
 739     }
 740
 741     return( run );
 742 }
 743
 744
 745 /************
 746 * LOAD/SAVE *
 747 ************/
 748
 749 TEXT    FileName[ 108 ];
 750
 751 struct TagItem RTTags[] =
 752 {
 753     {RTFI_Flags,        0},
 754     {RT_Window,        0},
 755     {RT_LockWindow,        TRUE},
 756     {RT_ShareIDCMP,        TRUE},
 757     {RT_IntuiMsgFunc,     (IPTR)&IntuiHook},
 758     {TAG_END}
 759 };
 760
 761 #define TAG_FLAGS    0
 762 #define TAG_WINDOW    1
 763
 764
 765 LONG
 766 GetFilename( STRPTR file, CONST_STRPTR hail, ULONG flags )
 767 {
 768     RTTags[ TAG_FLAGS  ].ti_Data = flags;
 769     RTTags[ TAG_WINDOW ].ti_Data = (IPTR)WindowPtr;
 770
 771     if( rtFileRequestA( FileReq, FileName, hail, RTTags ) )
 772     {
 773         strcpy( file, FileReq->Dir );
 774         return( ( LONG ) AddPart( file, FileName, 256 ) );
 775     }
 776
 777     return( 0 );
 778 }
 779
 780
 781 VOID
 782 OpenFile( VOID )
 783 {
 784     if( GetFilename( File, GetString( MSG_PROJECT_OPEN ) + 2, 0 ) )
 785     {
 786         if( !LoadConfig( File ) )
 787         {
 788             FreeExit( RETURN_ERROR );
 789         }
 790     }
 791 }
 792
 793
 794 VOID
 795 SaveAs( VOID )
 796 {
 797     if( GetFilename( File, GetString( MSG_PROJECT_SAVEAS ) + 2, FREQF_SAVE ) )
 798     {
 799         if( SaveConfig( File ) )
 800         {
 801             if( CreateIcons )
 802             {
 803                 CreateIcon( File );
 804             }
 805         }
 806     }
 807 }
 808
 809 TEXT    FaultBuff[ 100 ];
 810
 811 #ifdef __AROS__
 812 #define LOADSAVETO configbuffer
 813 UBYTE   configbuffer[PREFSLEN];
 814 #else
 815 #define LOADSAVETO &RTPrefs.Flags
 816 #endif
 817
 818 LONG
 819 LoadConfig( STRPTR fname )
 820 {
 821     BPTR    file;
 822
 823     if( !( file = Open( fname, MODE_OLDFILE ) ) )
 824     {
 825         Fault( IoErr(), "", FaultBuff, sizeof( FaultBuff ) );
 826         LocEZReq( MSG_ERROR_ACCESSING_FILE, MSG_OK, fname, FaultBuff + 2 );
 827         return( TRUE );
 828     }
 829
 830     if( Read( file, LOADSAVETO, PREFSLEN ) != PREFSLEN )
 831     {
 832         LocEZReq( MSG_READ_ERROR, MSG_ABORT );
 833         Close( file );
 834         return( FALSE );
 835     }
 836 #ifdef __AROS__
 837 #define READ_ULONG *((ULONG *)configptr); configptr += sizeof(ULONG)
 838 #define READ_UWORD *((UWORD *)configptr); configptr += sizeof(UWORD)
 839
 840     {
 841         UBYTE *configptr = configbuffer;
 842         ULONG val;
 843         WORD  i;
 844
 845         val = READ_ULONG;
 846         RTPrefs.Flags = AROS_LONG2BE(val);
 847
 848         for(i = 0;i < RTPREF_NR_OF_REQ; i++)
 849         {
 850             val = READ_ULONG;
 851             RTPrefs.ReqDefaults[i].Size = AROS_LONG2BE(val);
 852
 853             val = READ_ULONG;
 854             RTPrefs.ReqDefaults[i].ReqPos = AROS_LONG2BE(val);
 855
 856             val = READ_UWORD;
 857             RTPrefs.ReqDefaults[i].LeftOffset = AROS_WORD2BE(val);
 858
 859             val = READ_UWORD;
 860             RTPrefs.ReqDefaults[i].TopOffset = AROS_WORD2BE(val);
 861
 862             val = READ_UWORD;
 863             RTPrefs.ReqDefaults[i].MinEntries = AROS_WORD2BE(val);
 864
 865             val = READ_UWORD;
 866             RTPrefs.ReqDefaults[i].MaxEntries = AROS_WORD2BE(val);
 867         }
 868
 869     }
 870 #endif
 871
 872     Close( file );
 873     WheelType = GetWheelType( RTPrefs.Flags );
 874     return( TRUE );
 875 }
 876
 877
 878 LONG
 879 SaveConfig( STRPTR fname )
 880 {
 881     BPTR    file;
 882
 883     if( !( file = Open( fname, MODE_NEWFILE ) ) )
 884     {
 885         Fault( IoErr(), "", FaultBuff, sizeof( FaultBuff ) );
 886         LocEZReq( MSG_ERROR_ACCESSING_FILE, MSG_OK, fname, FaultBuff + 2 );
 887         return( FALSE );
 888     }
 889
 890 #ifdef __AROS__
 891 #define WRITE_ULONG *((ULONG *)configptr) = AROS_LONG2BE(val); configptr += sizeof(ULONG)
 892 #define WRITE_UWORD *((UWORD *)configptr) = AROS_WORD2BE(val); configptr += sizeof(UWORD)
 893
 894     {
 895         UBYTE *configptr = configbuffer;
 896         ULONG val;
 897         WORD  i;
 898
 899         val = RTPrefs.Flags;
 900         WRITE_ULONG;
 901
 902         for(i = 0;i < RTPREF_NR_OF_REQ; i++)
 903         {
 904             val = RTPrefs.ReqDefaults[i].Size;
 905             WRITE_ULONG;
 906
 907             val = RTPrefs.ReqDefaults[i].ReqPos;
 908             WRITE_ULONG;
 909
 910             val = RTPrefs.ReqDefaults[i].LeftOffset;
 911             WRITE_UWORD;
 912
 913             val = RTPrefs.ReqDefaults[i].TopOffset;
 914             WRITE_UWORD;
 915
 916             val = RTPrefs.ReqDefaults[i].MinEntries;
 917             WRITE_UWORD;
 918
 919             val = RTPrefs.ReqDefaults[i].MaxEntries;
 920             WRITE_UWORD;
 921
 922         }
 923
 924     }
 925 #endif
 926     if( Write( file, LOADSAVETO, PREFSLEN ) != PREFSLEN )
 927     {
 928         LocEZReq( MSG_ERROR_SAVING_PREFS, MSG_OK );
 929         Close( file );
 930         return( FALSE );
 931     }
 932
 933     Close( file );
 934     return( TRUE );
 935 }
 936
 937
 938 /*******
 939 * ICON *
 940 *******/
 941
 942
 943 UWORD IconImageData[ 176 ] =
 944 {
 945     0,0,4,1023,0,0,1,1023,0,2047,32768,17407,0,6144,24576,5119,0,8444,4096,3071,
 946     0,16642,2048,4095,0,16514,2048,4095,0,16514,2048,4095,0,8452,2048,4095,
 947     0,7704,4096,4095,0,96,8192,4095,0,128,49152,4095,0,259,0,4095,0,540,0,4095,
 948     0,264,0,4095,0,240,0,4095,0,264,0,4095,0,264,0,4095,16384,240,0,4095,
 949     4096,0,0,4095,1024,0,0,4095,511,65535,65535,65535,65535,65535,65528,1023,
 950     54613,21845,21846,1023,54613,20480,21845,33791,54613,18431,38229,25599,54613,
 951     24323,58709,21503,54613,15957,62805,21503,54613,16213,62805,21503,54613,
 952     16213,62805,21503,54613,24147,62805,21503,54613,16711,58709,21503,54613,
 953     21791,54613,21503,54613,21887,5461,21503,54613,21756,21845,21503,54613,
 954     21985,21845,21503,54613,21749,21845,21503,54613,21765,21845,21503,54613,
 955     21749,21845,21503,54613,21749,21845,21503,13653,21765,21845,21503,3413,
 956     21845,21845,21503,853,21845,21845,21503,0,0,0,1023
 957 };
 958
 959 struct Image IconImage =
 960 {
 961     0, 0, 54, 22, 2, IconImageData, 3, 0, NULL
 962 };
 963
 964
 965 STRPTR ToolTypes[] =
 966 {
 967     "ACTION=USE",
 968     NULL
 969 };
 970
 971
 972 VOID
 973 CreateIcon( STRPTR fname )
 974 {
 975     struct DiskObject    *dob;
 976     struct Gadget        *gad;
 977
 978     if( ( dob = GetDiskObjectNew( NULL ) ) )
 979     {
 980         gad = &dob->do_Gadget;
 981         gad->Width        = 54;
 982         gad->Height        = 22;
 983         gad->Flags        = GFLG_GADGIMAGE | GFLG_GADGBACKFILL;
 984         gad->GadgetType        = GTYP_BOOLGADGET;
 985         gad->GadgetRender    = ( APTR ) &IconImage;
 986         gad->UserData        = ( APTR ) WB_DISKREVISION;
 987         dob->do_Magic        = WB_DISKMAGIC;
 988         dob->do_Version        = WB_DISKVERSION;
 989         dob->do_Type        = WBPROJECT;
 990         dob->do_DefaultTool    = "ReqTools";
 991         dob->do_ToolTypes    = ToolTypes;
 992         dob->do_CurrentX    = dob->do_CurrentY = NO_ICON_POSITION;
 993         PutDiskObject( fname, dob );
 994         FreeDiskObject( dob );
 995     }
 996 }
 997
 998 #ifdef __AROS__
 999 int main(int argc, char **argv)
1000 {
1001     __main(NULL);
1002     return 0;
1003 }
1004 #endif