home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quake_src / gui / main.c
Encoding:
C/C++ Source or Header  |  2000-06-19  |  46.4 KB  |  1,957 lines
  1. /*
  2.     QuakeGUI V1.0 (12th March 2000) © Martin McKenzie
  3.                                                 marty@cadtech.demon.co.uk
  4.                                                 http://www.cadtech.demon.co.uk/
  5.  
  6.     Designed for the Amiga Quake port of:
  7.                                                 Frank Wille            frank@phoenix.owl.de
  8.                                                 Steffen Häuser        magicsn@birdland.es.bawue.de
  9.  
  10.  
  11.     This code has been released to the public as a demonstration of using, amongst
  12.     other things:
  13.     StormWizard interface, ENV: variables, tooltypes, etc...
  14.     No guarantee is given to the correctness or efficiency of the code.
  15.  
  16.     Future possible updates:
  17.     1.    Add menus; this will allow the user to "save as" the current
  18.         configuration as an icon for later use (rather than using WB to
  19.         copy the icon).
  20.     2.    Enhance the tooltype read/save code to preserve "newicons" data
  21.         if present.
  22. */
  23.  
  24.  
  25. /*
  26.     Includes
  27. */
  28.  
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include <string.h>
  32. #include <exec/memory.h>
  33. #include <dos/dos.h>
  34. #include <dos/dostags.h>
  35. #ifdef __STORM__
  36. #include    <pragma/wizard_lib.h>
  37. #else
  38. #include <clib/wizard_protos.h>
  39. #include <pragmas/wizard_pragmas.h>
  40. #endif
  41. #include <workbench/workbench.h>
  42. #include <workbench/startup.h>
  43. #ifdef __STORM__
  44. #include <wbstartup.h>
  45. #endif
  46. #include <intuition/gadgetclass.h>
  47. #include <intuition/intuition.h>
  48. #include <libraries/wizard.h>
  49. #include <pragma/dos_lib.h>
  50. #include    <pragma/exec_lib.h>
  51. #include    <pragma/intuition_lib.h>
  52. #include    <pragma/utility_lib.h>
  53. #include    <pragma/wizard_lib.h>
  54. #include <clib/icon_protos.h>
  55. #include "quakegui.h"
  56.  
  57. /*
  58.     Defines
  59. */
  60. //#define GUI_Debug            // Set to enable (some) debug info
  61.  
  62. #define MaxNoTooltypes 50
  63. #define TooltypeLength 128
  64.  
  65. #ifdef __STORM__
  66. #define Storm_FixToolType (unsigned char *const*)
  67. #else
  68. #define Storm_FixToolType
  69. #endif
  70.  
  71.  
  72. /*
  73.     Function Prototypes
  74. */
  75. void my_main (struct WBArg *, ULONG);
  76. BOOL CheckShowGUI(struct WBArg *, BOOL *);
  77. void BuildArgString(BOOL, struct WBArg *);
  78. void InitGadgets(struct WBArg *);
  79. void DisableChunkyGads(void);
  80. void EnableChunkyGads(void);
  81. void StartGame(void);
  82. void ShowError(char *errormsg);
  83.  
  84. /*
  85.     Global Variables
  86. */
  87.     // This structure is used for ENV: variable data
  88.     struct msg {
  89.         char *gfxmode;
  90.         char *wb;
  91.         char *pubscreenname;
  92.         char *pip;
  93.         char *pipscale;
  94.         char *dbuf;
  95.         char *oldstyle;
  96.         char *cdunit;
  97.         char *cddevice;
  98.     } myptrs;
  99.  
  100.     // This structure is used for tooltype string data
  101.     struct temp {
  102.         char *showgui;
  103.         char *quakename;
  104.         char *defpsname;
  105.         char *gfxname;
  106.         char *gfxname1;
  107.         char *gfxname2;
  108.         char *gfxname3;
  109.         char *wbwindow;
  110.         char *pubscr;
  111.         char *pubscrname;
  112.         char *p96pip;
  113.         char *p96resize;
  114.         char *defpipscale;
  115.         char *dbuf;
  116.         char *tribuf;
  117.         char *wpa8;
  118.         char *particle;
  119.         char *showparticle;
  120.         char *dissnd;
  121.         char *nocdaud;
  122.         char *cdunit;
  123.         char *cddevice;
  124.         char *nomouse;
  125.         char *mmuhack;
  126.         char *nostdout;
  127.         char *lc040;
  128.         char *minmem;
  129.         char *mem;
  130.         char *surfcache;
  131.         char *zonemem;
  132.         char *dislan;
  133.         char *disserial;
  134.         char *distcp;
  135.         char *disipx;
  136.         char *ipxport;
  137.         char *listen;
  138.         char *dedicated;
  139.         char *playback;
  140.         char *record;
  141.         char *rogue;
  142.         char *hypnotic;
  143.         char *gamedir;
  144.         char *search;
  145.         char *miscopts;
  146.     } TTnames = {"SHOWGUI=","QUAKENAME=","workbench","GFXMODE=","CHUNKYPPC","CYBERGFX","AGAC2P",
  147.                         "WB=","PUBSCR=","PUBSCREENNAME=","PIP=","RESIZE=","1",
  148.                         "DBUF=","OLDSTYLE=","FORCEWPA8=","PARTICLE=","SHOWPARTICLE=",
  149.                         "NOSOUND=","NOCDAUDIO=","CDUNIT=","CDDEVICE=",
  150.                         "NOMOUSE=","HACK=","NOSTDOUT=","NO68KFPU=","MINMEM=","MEM=",
  151.                         "SURFCACHEMEM=","ZONEMEM=",
  152.                         "NOLAN=","NOSERIAL=","NOTCP=","NOIPX=","IPXPORT=","LISTEN=",
  153.                         "DEDICATED=",
  154.                         "PLAYBACK=","RECORD=","ROGUE=","HYPNOTIC=",
  155.                         "GAMEDIR=","SEARCHPATH=","MISCOPTIONS="};
  156.  
  157.     // This structure is used for error message data
  158.     struct temp2 {
  159.         char *winhan;
  160.         char *lockscrn;
  161.         char *winobj;
  162.         char *openwin;
  163.         char *iconlib;
  164.         char *nolock;
  165.         char *nowizlib;
  166.         char *notemp;
  167.         char *noGDO;
  168.         char *noram;
  169.         char *nofsize;
  170.         char *nofile;
  171.     } Errors = {"Failed to allocate window handle",
  172.                 "Failed to lock publicscreen",
  173.                 "Failed to create window objects",
  174.                 "Failed to open window",
  175.                 "Failed to open icon.library",
  176.                 "Failed to lock icon file",
  177.                 "Failed to open quakegui.wizard",
  178.                 "Failed to create temp file",
  179.                 "Failed to GetDiskObject",
  180.                 "Failed to Allocate RAM",
  181.                 "Failed to get filesize",
  182.                 "Failed to open temp file"};
  183.  
  184.  
  185.    char buffer[100];
  186.    char TrueFalse_buf[]="FALSE";
  187.     UBYTE qfname[255];
  188.     struct Gadget *gads[QUAKEWIN_GADGETS];
  189.     struct Window   *windowXX;
  190.  
  191.     static BPTR old_stdout = 0;
  192.     static BPTR new_stdout = 0;
  193.     static BPTR old_stdinp = 0;
  194.     static BPTR new_stdinp = 0;
  195.  
  196.     LONG olddir = -1;
  197.     struct Library *IconBase = NULL;
  198.     APTR    surface;
  199.     ULONG StackSize = 300000L;
  200.  
  201. /*
  202.     Functions
  203. */
  204.  
  205. // INIT_4... and EXIT_4... are used under StormC to setup a CON: window for stdio
  206. void INIT_4_MyOwnCout(void)
  207. {
  208.    if (!((struct Process *) FindTask(NULL))->pr_CLI)
  209.    {
  210.       if ( (new_stdout = Open("CON:0/0/640/200/QuakeGUI/AUTO/WAIT", MODE_NEWFILE)) )
  211.          old_stdout = SelectOutput(new_stdout);
  212.  
  213.       if ( (new_stdinp = Open("*", MODE_NEWFILE)) )
  214.          old_stdinp = SelectInput(new_stdinp);
  215.    }
  216. }
  217.  
  218. void EXIT_4_MyOwnCout(void)
  219. {
  220.    if (new_stdout)
  221.       Close(SelectOutput(old_stdout));
  222.  
  223.    if (new_stdinp)
  224.       Close(SelectInput(old_stdinp));
  225. }
  226.  
  227. void wbmain(struct WBStartup *wb)
  228. {
  229.     struct WBArg *wbarg;
  230.     SHORT i;
  231.     LONG oldWBdir = -1;
  232.     BOOL ShowGUI, retval;
  233.     // Put version string here so Storm doesnt optimize it out
  234.     const char Version[] = "$VER: QuakeGUI 1.0 (12.3.2000) © Martin McKenzie\0";
  235.  
  236.     if(!(IconBase = OpenLibrary("icon.library",33)))
  237.     {
  238.         ShowError(Errors.iconlib);
  239.         goto mywbexit;
  240.     }
  241.  
  242.     if((wb->sm_ArgList->wa_Lock)&&(*wb->sm_ArgList->wa_Name))
  243.     {
  244.         oldWBdir = CurrentDir(wb->sm_ArgList->wa_Lock);
  245.  
  246.         if ((surface=WZ_OpenSurface("quakegui.wizard",0L,TAG_DONE)))
  247.         {
  248.             for(i=0, wbarg=wb->sm_ArgList;
  249.                     i < wb->sm_NumArgs;
  250.                     i++, wbarg++)
  251.             {
  252.                 /* if there's a directory lock for this wbarg, CD there */
  253.                 olddir = -1;
  254.                 if((wbarg->wa_Lock)&&(*wbarg->wa_Name))
  255.                     olddir = CurrentDir(wbarg->wa_Lock);
  256.  
  257.                 retval = CheckShowGUI(wbarg, &ShowGUI);
  258.                 if (retval == TRUE)
  259.                     my_main(wbarg, ShowGUI);
  260.  
  261.                 if(olddir != -1)
  262.                     CurrentDir(olddir); /* CD back where we were */
  263.             }
  264.  
  265.             WZ_CloseSurface(surface);
  266.         } /* End WZ_OpenSurface... */
  267.         else
  268.         {
  269.             ShowError(Errors.nowizlib);
  270.         }
  271.  
  272.         if(oldWBdir != -1)
  273.             CurrentDir(oldWBdir); /* CD back where we were */
  274.     }
  275.     else
  276.     {
  277.         ShowError(Errors.nolock);
  278.     }
  279.  
  280. mywbexit:
  281.     ;
  282. }
  283.  
  284. void main (int argc, char **argv)
  285. {
  286.     printf("This program must be started from a quakeGUI icon.\n");
  287. }
  288.  
  289. void my_main (struct WBArg *wbarg, ULONG ShowGUI)
  290. {
  291.     int ok = TRUE;
  292.     BOOL Flag, SaveTT;
  293.     ULONG IntField;
  294.     struct Screen    *screen;
  295.     struct NewWindow *newwin;
  296.     struct WizardWindowHandle *winhandle;
  297.     struct IntuiMessage *msg;
  298.  
  299.     myptrs.gfxmode = "quake1/gfxmode";
  300.     myptrs.wb = "quake1/wb";
  301.     myptrs.pubscreenname = "quake1/pubscreenname";
  302.     myptrs.pip = "quake1/pip";
  303.     myptrs.pipscale = "quake1/resize";
  304.     myptrs.dbuf = "quake1/dbuf";
  305.     myptrs.oldstyle = "quake1/oldstyle";
  306.     myptrs.cdunit = "quake1/cdunit";
  307.     myptrs.cddevice = "quake1/cddevice";
  308.  
  309.  
  310.     screen=LockPubScreen(NULL);
  311.     if (screen)
  312.     {
  313.         if ((winhandle=WZ_AllocWindowHandle(screen,0L,surface,TAG_DONE)))
  314.         {
  315.             if ((newwin=WZ_CreateWindowObj(winhandle,QUAKEWIN,WWH_GadgetArray,gads,
  316.                                                           WWH_GadgetArraySize,sizeof(gads),
  317.                                                           TAG_DONE)))
  318.             {
  319.                 /* Set WizardWindow to minimum width and height */
  320.                 newwin->Width=newwin->MinWidth;
  321.                 newwin->Height=newwin->MinHeight;
  322.                 newwin->MaxHeight=newwin->MinHeight;
  323.  
  324.                 InitGadgets(wbarg);
  325.  
  326.                 if (!ShowGUI)
  327.                 {
  328.                     BuildArgString(FALSE,NULL);
  329.                     goto SkipGUI;
  330.                 }
  331.  
  332.                 if ((windowXX=WZ_OpenWindow(winhandle,newwin,WA_AutoAdjust,TRUE,
  333.                                                      TAG_DONE)))
  334.                 {
  335.                     HelpControl(windowXX,HC_GADGETHELP);
  336.  
  337.                     Flag=TRUE;
  338.  
  339.                     do
  340.                     {
  341.                         WaitPort(windowXX->UserPort);
  342.  
  343.                         if ((msg=(struct IntuiMessage *)GetMsg(windowXX->UserPort)))
  344.                         {
  345.                             switch(msg->Class)
  346.                             {
  347.                                 case IDCMP_GADGETHELP:
  348.                                 {
  349.                                     if (msg->IAddress)
  350.                                     {
  351.                                         SetWindowTitles(windowXX,WZ_GadgetHelp(winhandle,msg->IAddress),(STRPTR)-1L);
  352.                                     }
  353.                                     else
  354.                                     {
  355.                                         SetWindowTitles(windowXX,"Quake GUI by Martin McKenzie",(STRPTR)-1L);
  356.                                     }
  357.                                 }
  358.                                 break;
  359.  
  360.                                 case IDCMP_VANILLAKEY:
  361.                                 {
  362.                                     WZ_GadgetKey( winhandle, msg->Code, msg->Qualifier, TAG_DONE );
  363.                                 }
  364.                                 break;
  365.  
  366.                                 case IDCMP_IDCMPUPDATE:
  367.                                 {
  368.                                     switch(GetTagData(GA_ID,0,(struct TagItem *)msg->IAddress))
  369.                                     {
  370.                                         case QR_SAVE_BUT:
  371.                                         {
  372.                                             ok = TRUE;
  373.                                             Flag = FALSE;
  374.                                             SaveTT = TRUE;
  375.                                         }
  376.                                         break;
  377.  
  378.                                         case QR_USE_BUT:
  379.                                         {
  380.                                             ok = TRUE;
  381.                                             Flag = FALSE;
  382.                                             SaveTT = FALSE;
  383.                                         }
  384.                                         break;
  385.  
  386.                                         case QR_CANCEL_BUT:
  387.                                         {
  388.                                             ok = FALSE;
  389.                                             Flag = FALSE;
  390.                                         }
  391.                                         break;
  392.  
  393.                                         case QU_GFXTYPE_CYC:
  394.                                         {
  395.                                             GetAttr(WCYCLEA_Active,gads[QU_GFXTYPE_CYC],(ULONG *) &IntField);
  396.                                             if (IntField >= 1)
  397.                                             {
  398.                                                 DisableChunkyGads();
  399.                                             }
  400.                                             else
  401.                                             {
  402.                                                 EnableChunkyGads();
  403.                                             }
  404.                                         }
  405.                                         break;
  406.  
  407.                                     } /* End switch */
  408.                                 } /* End IDCMP_IDCMPUPDATE */
  409.                                 break;
  410.                             } /* End Switch */
  411.                             ReplyMsg((struct Message *)msg);
  412.                         } /* End If msg=... */
  413.                     }
  414.                     while (Flag);  /* End do */
  415.  
  416.                     if ( ok == TRUE )
  417.                     {
  418.                         BuildArgString(SaveTT, wbarg);
  419.                     }
  420.  
  421.                     WZ_CloseWindow(winhandle);
  422.                 } /* End WZ_OpenWindow... */
  423.                 else
  424.                 {
  425.                     ShowError(Errors.openwin);
  426.                     ok = FALSE;
  427.                 }
  428.             } /* End WZ_CreateWindowObj... */
  429.             else
  430.             {
  431.                 ShowError(Errors.winobj);
  432.                 ok = FALSE;
  433.             }
  434. SkipGUI:
  435.             WZ_FreeWindowHandle(winhandle);
  436.  
  437.             // Start the game here after freeing up (most of) our resources
  438.             if ( ok == TRUE )
  439.             {
  440.                 StartGame();
  441.             }
  442.         } /* End WZ_AllocWindowHandle... */
  443.         else
  444.         {
  445.             ShowError(Errors.winhan);
  446.             ok = FALSE;
  447.         }
  448.         UnlockPubScreen(0L,screen);
  449.     }
  450.     else
  451.     {
  452.         ShowError(Errors.lockscrn);
  453.     }
  454. }
  455.  
  456. BOOL CheckShowGUI(struct WBArg *wbarg, BOOL *ShowGUI)
  457. {
  458.     struct DiskObject *dobj;
  459.     char **toolarray;
  460.     char *buffer;
  461.     int ret_int;
  462.     BOOL success = FALSE;
  463.  
  464.     *ShowGUI = FALSE;
  465.     if((*wbarg->wa_Name) && (dobj=GetDiskObject(wbarg->wa_Name)))
  466.     {
  467.         toolarray = (char **)dobj->do_ToolTypes;
  468.  
  469.         if(buffer=FindToolType(Storm_FixToolType toolarray,"SHOWGUI"))
  470.         {
  471.             ret_int = strcmp(buffer,"TRUE");
  472.             if (ret_int == 0)
  473.             {
  474.                 *ShowGUI = TRUE;
  475.             }
  476.             else
  477.             {
  478.                 *ShowGUI = FALSE;
  479.             }
  480.         }
  481.  
  482.         FreeDiskObject(dobj);
  483.         success = TRUE;
  484.     }
  485. #ifdef GUI_Debug
  486.     else
  487.     if(!(*wbarg->wa_Name))
  488.         printf("  Must be a disk or drawer icon\n");
  489.     else
  490.         printf("  Can't find any DiskObject (icon) for this WBArg\n");
  491. #endif
  492.     return(success);
  493. }
  494.  
  495.  
  496. void BuildArgString(BOOL SaveTT, struct WBArg *wbarg)
  497. {
  498.     FILE *fp;
  499.     ULONG IntField, IntField2, IntField3, IntField4, IntField5, len;
  500.    ULONG ttype_count, SaveTT_count;
  501.     char CycleBuffer[10];
  502.    char **oldttypes;
  503.    char **newtt;
  504.    struct DiskObject *diskObj = NULL;
  505.     BOOL success;
  506.  
  507.     fp = fopen ("t:qguitemp","w");
  508.     if (!fp)
  509.     {
  510.         ShowError(Errors.notemp);
  511.         goto BailOut;
  512.     }
  513.  
  514.     ttype_count = 44L;            // 1 tooltype per GUI item (need to dynamically size this...)
  515.     SaveTT_count = 0L;
  516.  
  517.     if (SaveTT)
  518.     {
  519.         if((*wbarg->wa_Name) && (diskObj=GetDiskObject(wbarg->wa_Name)))
  520.         {
  521.             oldttypes = diskObj->do_ToolTypes;
  522.  
  523.           newtt = (char**)AllocVec((ttype_count + 1)* 4, MEMF_CLEAR | MEMF_ANY);
  524.             if (!newtt)
  525.             {
  526.                 ShowError(Errors.noram);
  527.             }
  528.         }
  529.         else
  530.         {
  531.             ShowError(Errors.noGDO);
  532.             SaveTT = FALSE;
  533.         }
  534.     }
  535.  
  536. //    SaveStdTtypes();    /* Toolpri, stack, donotwait... */
  537. // if FindTooltype finds it in the old icon, copy and paste it into the new one
  538.  
  539.     IntField = 1L;
  540.     if (SaveTT)
  541.     {
  542.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  543.         len += strlen(TTnames.showgui);
  544.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  545.         {
  546.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.showgui, TrueFalse_buf);
  547.             SaveTT_count++;
  548.         }
  549.     }
  550.  
  551.  
  552.     if (*qfname)
  553.     {
  554.         fprintf(fp, qfname);
  555.         len = strlen(qfname);
  556.     }
  557.     else
  558.     {
  559.         fprintf(fp, "quakeWOS");
  560.         len = 8L;
  561.     }
  562.     if (SaveTT)
  563.     {
  564.         len += strlen(TTnames.quakename);
  565.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  566.         {
  567.             strncpy(newtt[SaveTT_count], TTnames.quakename, len);
  568.             if (*qfname)
  569.             {
  570.                 strcat(newtt[SaveTT_count], qfname);
  571.             }
  572.             else
  573.             {
  574.                 strcat(newtt[SaveTT_count], "quakeWOS");
  575.             }
  576.             SaveTT_count++;
  577.         }
  578.     }
  579.  
  580.     GetAttr(WCYCLEA_Active, gads[QU_GFXTYPE_CYC],(ULONG *) &IntField);
  581.     switch (IntField)
  582.     {
  583.         case 0:                                    // This option is handled with an ENV: var!
  584.         {
  585.             strcpy(CycleBuffer,"CHUNKYPPC");
  586.             success = SetVar ((STRPTR)myptrs.gfxmode,(STRPTR)&CycleBuffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  587.             len = strlen(TTnames.gfxname1);
  588.         }
  589.         break;
  590.  
  591.         case 1:
  592.         {
  593.             fprintf(fp," -cgfx");
  594.             len = strlen(TTnames.gfxname2);
  595.         }
  596.         break;
  597.  
  598.         case 2:
  599.         {
  600.             fprintf(fp," -aga");
  601.             len = strlen(TTnames.gfxname3);
  602.         }
  603.         break;
  604.     }
  605.     if (SaveTT)
  606.     {
  607.         len += strlen(TTnames.gfxname);
  608.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  609.         {
  610.             strncpy(newtt[SaveTT_count], TTnames.gfxname, len);
  611.             switch (IntField)
  612.             {
  613.                 case 0:
  614.                 {
  615.                     strcat(newtt[SaveTT_count], TTnames.gfxname1);
  616.                 }
  617.                 break;
  618.  
  619.                 case 1:
  620.                 {
  621.                     strcat(newtt[SaveTT_count], TTnames.gfxname2);
  622.                 }
  623.                 break;
  624.  
  625.                 case 2:
  626.                 {
  627.                     strcat(newtt[SaveTT_count], TTnames.gfxname3);
  628.                 }
  629.                 break;
  630.             }
  631.             SaveTT_count++;
  632.         }
  633.     }
  634.  
  635.     GetAttr(WCHECKBOXA_Checked, gads[QU_WBWINDOW_TICK],(ULONG *) &IntField);
  636.     sprintf(buffer,"%ld",IntField);
  637.     success = SetVar ((STRPTR)myptrs.wb,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  638.     if (SaveTT)
  639.     {
  640.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  641.         len += strlen(TTnames.wbwindow);
  642.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  643.         {
  644.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.wbwindow, TrueFalse_buf);
  645.             SaveTT_count++;
  646.         }
  647.     }
  648.  
  649.     GetAttr(WCHECKBOXA_Checked, gads[QU_PUBSCREEN_TICK],(ULONG *) &IntField);
  650.     if (IntField == 1)
  651.     {
  652.         sprintf(buffer,"%ld",IntField);
  653.         success = SetVar ((STRPTR)myptrs.wb,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  654.  
  655.         GetAttr(WSTRINGA_String, gads[QU_PUBSCREEN_STR],(ULONG *) &IntField2);
  656.         len = sprintf(buffer,"%s",IntField2);
  657.         // if the string is blank, fill it with a default name
  658.         if (len == 0)
  659.             sprintf(buffer,"%s",TTnames.defpsname);
  660.         success = SetVar ((STRPTR)myptrs.pubscreenname,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  661.     }
  662.     else
  663.     {    // required so that the "SaveTT" code can work for both true/false cases...
  664.         GetAttr(WSTRINGA_String, gads[QU_PUBSCREEN_STR],(ULONG *) &IntField2);
  665.         len = sprintf(buffer,"%s",IntField2);
  666.         if (len == 0)
  667.             sprintf(buffer,"%s",TTnames.defpsname);
  668.     }
  669.     if (SaveTT)
  670.     {
  671.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  672.         len += strlen(TTnames.pubscr);
  673.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  674.         {
  675.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.pubscr, TrueFalse_buf);
  676.             SaveTT_count++;
  677.         }
  678.  
  679.         len = strlen(buffer);
  680.         len += strlen(TTnames.pubscrname);
  681.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  682.         {
  683.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.pubscrname, buffer);
  684.             SaveTT_count++;
  685.         }
  686.     }
  687.  
  688.     GetAttr(WCHECKBOXA_Checked, gads[QU_P96PIP_TICK],(ULONG *) &IntField);
  689.     sprintf(buffer,"%ld",IntField);
  690.     success = SetVar ((STRPTR)myptrs.pip,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  691.     if (IntField == 1)
  692.     {
  693.         GetAttr(WSTRINGA_String, gads[QU_PIPSCALE_STR],(ULONG *) &IntField2);
  694.         len = sprintf(buffer,"%s",IntField2);
  695.         // if the string is blank, fill it with a default value
  696.         if (len == 0)
  697.             sprintf(buffer,"%s",TTnames.defpipscale);
  698.         success = SetVar ((STRPTR)myptrs.pipscale,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  699.     }
  700.     else
  701.     {    // required so that the "SaveTT" code can work for both true/false cases...
  702.         GetAttr(WSTRINGA_String, gads[QU_PIPSCALE_STR],(ULONG *) &IntField2);
  703.         len = sprintf(buffer,"%s",IntField2);
  704.         if (len == 0)
  705.             sprintf(buffer,"%s",TTnames.defpipscale);
  706.     }
  707.     if (SaveTT)
  708.     {
  709.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  710.         len += strlen(TTnames.p96pip);
  711.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  712.         {
  713.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.p96pip, TrueFalse_buf);
  714.             SaveTT_count++;
  715.         }
  716.  
  717.         len = strlen(buffer);
  718.         len += strlen(TTnames.p96resize);
  719.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  720.         {
  721.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.p96resize, buffer);
  722.             SaveTT_count++;
  723.         }
  724.     }
  725.  
  726.     IntField2 = 0;
  727.     GetAttr(WCHECKBOXA_Checked, gads[QU_DBLBUF_TICK],(ULONG *) &IntField);
  728.     sprintf(buffer,"%ld",IntField);
  729.     success = SetVar ((STRPTR)myptrs.dbuf,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  730.     success = SetVar ((STRPTR)myptrs.oldstyle,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  731.     if (!IntField)
  732.     {
  733.         GetAttr(WCHECKBOXA_Checked, gads[QU_TRIBUF_TICK],(ULONG *) &IntField2);
  734.         sprintf(buffer,"%ld",IntField2);
  735.         success = SetVar ((STRPTR)myptrs.dbuf,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  736.         IntField = 0;
  737.         sprintf(buffer,"%ld",IntField);
  738.         success = SetVar ((STRPTR)myptrs.oldstyle,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  739.     }
  740.     if (SaveTT)
  741.     {
  742.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  743.         len += strlen(TTnames.dbuf);
  744.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  745.         {
  746.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.dbuf, TrueFalse_buf);
  747.             SaveTT_count++;
  748.         }
  749.  
  750.         len = sprintf(TrueFalse_buf,"%s",(IntField2 == 1 ? "TRUE" : "FALSE"));
  751.         len += strlen(TTnames.tribuf);
  752.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  753.         {
  754.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.tribuf, TrueFalse_buf);
  755.             SaveTT_count++;
  756.         }
  757.     }
  758.  
  759.     GetAttr(WCHECKBOXA_Checked, gads[QU_WPA8_TICK],(ULONG *) &IntField);
  760.     if (IntField == 1)
  761.     {
  762.         fprintf(fp," -forcewpa8");
  763.     }
  764.     if (SaveTT)
  765.     {
  766.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  767.         len += strlen(TTnames.wpa8);
  768.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  769.         {
  770.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.wpa8, TrueFalse_buf);
  771.             SaveTT_count++;
  772.         }
  773.     }
  774.  
  775.     // If paticles enabled (and value > 0), add parameter to list.
  776.     GetAttr(WCHECKBOXA_Checked, gads[QU_PART_TICK],(ULONG *) &IntField);
  777.     if (IntField == 1)
  778.     {
  779.         GetAttr(WINTEGERA_Long, gads[QU_PARTICLE_INT],(ULONG *) &IntField2);
  780.         if (IntField2 != 0)
  781.         {
  782.             fprintf(fp," -particle=%ld",IntField2);
  783.         }
  784.     }
  785.     else
  786.     {
  787.         fprintf(fp," -particle=%ld",0L);
  788.     }
  789.     if (SaveTT)
  790.     {
  791.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  792.         len += strlen(TTnames.showparticle);
  793.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  794.         {
  795.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.showparticle, TrueFalse_buf);
  796.             SaveTT_count++;
  797.         }
  798.  
  799.         if (IntField == 0)
  800.         {
  801.             GetAttr(WINTEGERA_Long, gads[QU_PARTICLE_INT],(ULONG *) &IntField2);
  802.         }
  803.         len = sprintf(buffer,"%ld",IntField2);
  804.         len += strlen(TTnames.particle);
  805.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  806.         {
  807.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.particle, buffer);
  808.             SaveTT_count++;
  809.         }
  810.     }
  811.  
  812.     GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLESND_TICK],(ULONG *) &IntField);
  813.     if (IntField == 1)
  814.     {
  815.         fprintf(fp," -nosound");
  816.     }
  817.     if (SaveTT)
  818.     {
  819.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  820.         len += strlen(TTnames.dissnd);
  821.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  822.         {
  823.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.dissnd, TrueFalse_buf);
  824.             SaveTT_count++;
  825.         }
  826.     }
  827.  
  828.     GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLECD_TICK],(ULONG *) &IntField);
  829.     if (IntField == 1)
  830.     {
  831.         fprintf(fp," -nocdaudio");
  832.     }
  833.     else
  834.     {
  835.         GetAttr(WINTEGERA_Long, gads[QU_CDUNIT_INT],(ULONG *) &IntField2);
  836.         sprintf(buffer,"%ld",IntField2);
  837.         success = SetVar ((STRPTR)myptrs.cdunit,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  838.  
  839.         GetAttr(WSTRINGA_String, gads[QU_DEVICE_STR],(ULONG *) &IntField3);
  840.         sprintf(buffer,"%s",IntField3);
  841.         success = SetVar ((STRPTR)myptrs.cddevice,(STRPTR)&buffer,-1L,(ULONG)GVF_GLOBAL_ONLY);
  842.     }
  843.     if (SaveTT)
  844.     {
  845.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  846.         len += strlen(TTnames.nocdaud);
  847.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  848.         {
  849.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.nocdaud, TrueFalse_buf);
  850.             SaveTT_count++;
  851.         }
  852.  
  853.         if (IntField)
  854.         {
  855.             GetAttr(WINTEGERA_Long, gads[QU_CDUNIT_INT],(ULONG *) &IntField2);
  856.             GetAttr(WSTRINGA_String, gads[QU_DEVICE_STR],(ULONG *) &IntField3);
  857.         }
  858.  
  859.         sprintf(buffer,"%ld",IntField2);
  860.         len = sprintf(buffer,"%ld",IntField2);
  861.         len += strlen(TTnames.cdunit);
  862.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  863.         {
  864.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.cdunit, buffer);
  865.             SaveTT_count++;
  866.         }
  867.  
  868.         sprintf(buffer,"%s",IntField3);
  869.         len = sprintf(buffer,"%s",IntField3);
  870.         len += strlen(TTnames.cddevice);
  871.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  872.         {
  873.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.cddevice, buffer);
  874.             SaveTT_count++;
  875.         }
  876.     }
  877.  
  878.     GetAttr(WCHECKBOXA_Checked, gads[QU_USEMOUSE_TICK],(ULONG *) &IntField);
  879.     if (IntField == 1)
  880.     {
  881.         fprintf(fp," -nomouse");
  882.     }
  883.     if (SaveTT)
  884.     {
  885.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  886.         len += strlen(TTnames.nomouse);
  887.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  888.         {
  889.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.nomouse, TrueFalse_buf);
  890.             SaveTT_count++;
  891.         }
  892.     }
  893.  
  894.     GetAttr(WCHECKBOXA_Checked, gads[QU_MMUHACK_TICK],(ULONG *) &IntField);
  895.     if (IntField == 1)
  896.     {
  897.         fprintf(fp," -hack");
  898.     }
  899.     if (SaveTT)
  900.     {
  901.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  902.         len += strlen(TTnames.mmuhack);
  903.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  904.         {
  905.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.mmuhack, TrueFalse_buf);
  906.             SaveTT_count++;
  907.         }
  908.     }
  909.  
  910.     GetAttr(WCHECKBOXA_Checked, gads[QU_STDOUT_TICK],(ULONG *) &IntField);
  911.     if (IntField == 1)
  912.     {
  913.         fprintf(fp," -nostdout");
  914.     }
  915.     if (SaveTT)
  916.     {
  917.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  918.         len += strlen(TTnames.nostdout);
  919.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  920.         {
  921.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.nostdout, TrueFalse_buf);
  922.             SaveTT_count++;
  923.         }
  924.     }
  925.  
  926.     GetAttr(WCHECKBOXA_Checked, gads[QU_LC040_TICK],(ULONG *) &IntField);
  927.     if (IntField == 1)
  928.     {
  929.         fprintf(fp," -no68kfpu");
  930.     }
  931.     if (SaveTT)
  932.     {
  933.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  934.         len += strlen(TTnames.lc040);
  935.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  936.         {
  937.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.lc040, TrueFalse_buf);
  938.             SaveTT_count++;
  939.         }
  940.     }
  941.  
  942.     GetAttr(WCHECKBOXA_Checked, gads[QU_MINMEM_TICK],(ULONG *) &IntField);
  943.     if (IntField == 1)
  944.     {
  945.         fprintf(fp," -minmem");
  946.     }
  947.     else
  948.     {
  949.         GetAttr(WINTEGERA_Long, gads[QU_MEMORY_INT],(ULONG *) &IntField2);
  950.         fprintf(fp," -mem=%ld",IntField2);
  951.  
  952.         GetAttr(WINTEGERA_Long, gads[QU_SURFCACHEMEM_INT],(ULONG *) &IntField3);
  953.         if (IntField3 != 0)
  954.         {
  955.             fprintf(fp," -surfcachemem=%ld",IntField3);
  956.         }
  957.  
  958.         GetAttr(WINTEGERA_Long, gads[QU_ZONEMEM_INT],(ULONG *) &IntField4);
  959.         if (IntField4 != 0)
  960.         {
  961.             fprintf(fp," -zonemem=%ld",IntField4);
  962.         }
  963.     }
  964.     if (SaveTT)
  965.     {
  966.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  967.         len += strlen(TTnames.minmem);
  968.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  969.         {
  970.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.minmem, TrueFalse_buf);
  971.             SaveTT_count++;
  972.         }
  973.  
  974.         if (IntField)
  975.         {
  976.             GetAttr(WINTEGERA_Long, gads[QU_MEMORY_INT],(ULONG *) &IntField2);
  977.             GetAttr(WINTEGERA_Long, gads[QU_SURFCACHEMEM_INT],(ULONG *) &IntField3);
  978.             GetAttr(WINTEGERA_Long, gads[QU_ZONEMEM_INT],(ULONG *) &IntField4);
  979.         }
  980.  
  981.         len = sprintf(buffer,"%ld",IntField2);
  982.         len += strlen(TTnames.mem);
  983.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  984.         {
  985.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.mem, buffer);
  986.             SaveTT_count++;
  987.         }
  988.  
  989.         len = sprintf(buffer,"%ld",IntField3);
  990.         len += strlen(TTnames.surfcache);
  991.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  992.         {
  993.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.surfcache, buffer);
  994.             SaveTT_count++;
  995.         }
  996.  
  997.         len = sprintf(buffer,"%ld",IntField4);
  998.         len += strlen(TTnames.zonemem);
  999.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1000.         {
  1001.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.zonemem, buffer);
  1002.             SaveTT_count++;
  1003.         }
  1004.     }
  1005.  
  1006.  
  1007.     GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLELAN_TICK],(ULONG *) &IntField);
  1008.     if (IntField == 1)
  1009.     {
  1010.         fprintf(fp," -nolan");
  1011.     }
  1012.     else
  1013.     {
  1014.         GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLESER_TICK],(ULONG *) &IntField2);
  1015.         if (IntField == 1)
  1016.         {
  1017.             fprintf(fp," -noserial");
  1018.         }
  1019.  
  1020.         GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLETCP_TICK],(ULONG *) &IntField3);
  1021.         if (IntField == 1)
  1022.         {
  1023.             fprintf(fp," -notcp");
  1024.         }
  1025.  
  1026.         GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLEIPX_TICK],(ULONG *) &IntField4);
  1027.         if (IntField == 1)
  1028.         {
  1029.             fprintf(fp," -noipx");
  1030.         }
  1031.  
  1032.         GetAttr(WINTEGERA_Long, gads[QU_IPXPORT_INT],(ULONG *) &IntField5);
  1033.         fprintf(fp," -ipxport=%ld",IntField);
  1034.     }
  1035.     if (SaveTT)
  1036.     {
  1037.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1038.         len += strlen(TTnames.dislan);
  1039.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1040.         {
  1041.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.dislan, TrueFalse_buf);
  1042.             SaveTT_count++;
  1043.         }
  1044.  
  1045.         if (IntField)
  1046.         {
  1047.             GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLESER_TICK],(ULONG *) &IntField2);
  1048.             GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLETCP_TICK],(ULONG *) &IntField3);
  1049.             GetAttr(WCHECKBOXA_Checked, gads[QU_DISABLEIPX_TICK],(ULONG *) &IntField4);
  1050.             GetAttr(WINTEGERA_Long, gads[QU_IPXPORT_INT],(ULONG *) &IntField5);
  1051.         }
  1052.  
  1053.         len = sprintf(TrueFalse_buf,"%s",(IntField2 == 1 ? "TRUE" : "FALSE"));
  1054.         len += strlen(TTnames.disserial);
  1055.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1056.         {
  1057.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.disserial, TrueFalse_buf);
  1058.             SaveTT_count++;
  1059.         }
  1060.  
  1061.         len = sprintf(TrueFalse_buf,"%s",(IntField3 == 1 ? "TRUE" : "FALSE"));
  1062.         len += strlen(TTnames.distcp);
  1063.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1064.         {
  1065.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.distcp, TrueFalse_buf);
  1066.             SaveTT_count++;
  1067.         }
  1068.  
  1069.         len = sprintf(TrueFalse_buf,"%s",(IntField4 == 1 ? "TRUE" : "FALSE"));
  1070.         len += strlen(TTnames.disipx);
  1071.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1072.         {
  1073.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.disipx, TrueFalse_buf);
  1074.             SaveTT_count++;
  1075.         }
  1076.  
  1077.         len = sprintf(buffer,"%ld",IntField5);
  1078.         len += strlen(TTnames.ipxport);
  1079.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1080.         {
  1081.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.ipxport, buffer);
  1082.             SaveTT_count++;
  1083.         }
  1084.     }
  1085.  
  1086.     GetAttr(WCHECKBOXA_Checked, gads[QU_ENABLELISTEN_TICK],(ULONG *) &IntField);
  1087.     if (IntField == 1)
  1088.     {
  1089.         fprintf(fp," -listen");
  1090.     }
  1091.     if (SaveTT)
  1092.     {
  1093.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1094.         len += strlen(TTnames.listen);
  1095.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1096.         {
  1097.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.listen, TrueFalse_buf);
  1098.             SaveTT_count++;
  1099.         }
  1100.     }
  1101.  
  1102.     GetAttr(WCHECKBOXA_Checked, gads[QU_ENABLEDEDICATED_TICK],(ULONG *) &IntField);
  1103.     if (IntField == 1)
  1104.     {
  1105.         fprintf(fp," -dedicated");
  1106.     }
  1107.     if (SaveTT)
  1108.     {
  1109.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1110.         len += strlen(TTnames.dedicated);
  1111.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1112.         {
  1113.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.dedicated, TrueFalse_buf);
  1114.             SaveTT_count++;
  1115.         }
  1116.     }
  1117.  
  1118.  
  1119.     GetAttr(WCHECKBOXA_Checked, gads[QU_PLAYBACKMODE_TICK],(ULONG *) &IntField);
  1120.     if (IntField == 1)
  1121.     {
  1122.         fprintf(fp," -playback");
  1123.     }
  1124.     if (SaveTT)
  1125.     {
  1126.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1127.         len += strlen(TTnames.playback);
  1128.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1129.         {
  1130.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.playback, TrueFalse_buf);
  1131.             SaveTT_count++;
  1132.         }
  1133.     }
  1134.  
  1135.     GetAttr(WCHECKBOXA_Checked, gads[QU_RECORDMODE_TICK],(ULONG *) &IntField);
  1136.     if (IntField == 1)
  1137.     {
  1138.         fprintf(fp," -record");
  1139.     }
  1140.     if (SaveTT)
  1141.     {
  1142.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1143.         len += strlen(TTnames.record);
  1144.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1145.         {
  1146.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.record, TrueFalse_buf);
  1147.             SaveTT_count++;
  1148.         }
  1149.     }
  1150.  
  1151.     GetAttr(WCHECKBOXA_Checked, gads[QU_ROGUE_TICK],(ULONG *) &IntField);
  1152.     if (IntField == 1)
  1153.     {
  1154.         fprintf(fp," -rogue");
  1155.     }
  1156.     if (SaveTT)
  1157.     {
  1158.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1159.         len += strlen(TTnames.rogue);
  1160.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1161.         {
  1162.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.rogue, TrueFalse_buf);
  1163.             SaveTT_count++;
  1164.         }
  1165.     }
  1166.  
  1167.     GetAttr(WCHECKBOXA_Checked, gads[QU_HYPNOTIC_TICK],(ULONG *) &IntField);
  1168.     if (IntField == 1)
  1169.     {
  1170.         fprintf(fp," -hypnotic");
  1171.     }
  1172.     if (SaveTT)
  1173.     {
  1174.         len = sprintf(TrueFalse_buf,"%s",(IntField == 1 ? "TRUE" : "FALSE"));
  1175.         len += strlen(TTnames.hypnotic);
  1176.         if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1177.         {
  1178.             sprintf(newtt[SaveTT_count],"%s%s",TTnames.hypnotic, TrueFalse_buf);
  1179.             SaveTT_count++;
  1180.         }
  1181.     }
  1182.  
  1183.  
  1184.     /* Only write these options if the string > 0 characters */
  1185.     GetAttr(WSTRINGA_String, gads[QU_GAMEDIR_STR],(ULONG *) &IntField);
  1186.     if (strlen ((const char *)IntField))
  1187.     {
  1188.         fprintf(fp," -game %s",IntField);
  1189.     }
  1190.     if (SaveTT)
  1191.     {
  1192.         len = sprintf(buffer,"%s",IntField);
  1193.         if (len)
  1194.         {
  1195.             len += strlen(TTnames.gamedir);
  1196.             if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1197.             {
  1198.                 sprintf(newtt[SaveTT_count],"%s%s",TTnames.gamedir, buffer);
  1199.                 SaveTT_count++;
  1200.             }
  1201.         }
  1202.     }
  1203.  
  1204.     GetAttr(WSTRINGA_String, gads[QU_GAMESEARCH_STR],(ULONG *) &IntField);
  1205.     if (strlen ((const char *)IntField))
  1206.     {
  1207.         fprintf(fp," -path %s",IntField);
  1208.     }
  1209.     if (SaveTT)
  1210.     {
  1211.         len = sprintf(buffer,"%s",IntField);
  1212.         if (len)
  1213.         {
  1214.             len += strlen(TTnames.search);
  1215.             if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1216.             {
  1217.                 sprintf(newtt[SaveTT_count],"%s%s",TTnames.search, buffer);
  1218.                 SaveTT_count++;
  1219.             }
  1220.         }
  1221.     }
  1222.  
  1223.     GetAttr(WSTRINGA_String, gads[QU_GAMEMISC_STR],(ULONG *) &IntField);
  1224.     if (strlen ((const char *)IntField))
  1225.     {
  1226.         fprintf(fp," %s",IntField);
  1227.     }
  1228.     if (SaveTT)
  1229.     {
  1230.         len = sprintf(buffer,"%s",IntField);
  1231.         if (len)
  1232.         {
  1233.             len += strlen(TTnames.miscopts);
  1234.             if(newtt[SaveTT_count] = (char*)AllocVec(len+1, MEMF_CLEAR | MEMF_ANY))
  1235.             {
  1236.                 sprintf(newtt[SaveTT_count],"%s%s",TTnames.miscopts, buffer);
  1237.                 SaveTT_count++;
  1238.             }
  1239.         }
  1240.     }
  1241.  
  1242.  
  1243.     if (SaveTT)
  1244.     {
  1245.         SaveTT_count++;
  1246.         newtt[SaveTT_count] = 0;
  1247.  
  1248.         diskObj->do_ToolTypes = newtt;
  1249.         PutDiskObject(wbarg->wa_Name, diskObj);
  1250.         diskObj->do_ToolTypes = oldttypes;
  1251.  
  1252.         FreeDiskObject(diskObj);
  1253.     }
  1254.  
  1255.     fclose (fp);
  1256. BailOut:
  1257.     ;
  1258. }
  1259.  
  1260.  
  1261. void InitGadgets(struct WBArg *wbarg)
  1262. {
  1263.     ULONG gfxmode_cyc, StackTT;
  1264.     LONG ret_long;
  1265.     int ret_int;
  1266.     BOOL BoolValue, DisableGad;
  1267.     BOOL DisablePubStr, TriBufOk;
  1268.  
  1269.     struct DiskObject *dobj;
  1270.     char **toolarray;
  1271.     char *buffer;
  1272.  
  1273.  
  1274.     DisableGad = FALSE;
  1275.  
  1276.     if((*wbarg->wa_Name) && (dobj=GetDiskObject(wbarg->wa_Name)))
  1277.     {
  1278.         toolarray = (char **)dobj->do_ToolTypes;
  1279.  
  1280.         if(buffer=FindToolType(Storm_FixToolType toolarray,"QUAKENAME"))
  1281.         {
  1282.             strcpy((char *)qfname,buffer);
  1283.         }
  1284.  
  1285.         if(buffer=FindToolType(Storm_FixToolType toolarray,"STACK"))
  1286.         {
  1287.             StackTT = atol(buffer);
  1288.             if (StackTT)
  1289.             {
  1290.                 StackSize = StackTT;
  1291.             }
  1292.         }
  1293.  
  1294.         if(buffer=FindToolType(Storm_FixToolType toolarray,"GFXMODE"))
  1295.         {
  1296.             ret_int = strcmp(buffer,"CHUNKYPPC");
  1297.             if (ret_int == 0)
  1298.             {
  1299.                 gfxmode_cyc = 0L;
  1300.             }
  1301.             else
  1302.             {
  1303.                 ret_int = strcmp(buffer,"CYBERGFX");
  1304.                 if (ret_int == 0)
  1305.                 {
  1306.                     gfxmode_cyc = 1L;
  1307.                     DisableGad = TRUE;
  1308.                 }
  1309.                 else
  1310.                 {
  1311.                     ret_int = strcmp(buffer,"AGAC2P");
  1312.                     if (ret_int == 0)
  1313.                     {
  1314.                         gfxmode_cyc = 2L;
  1315.                         DisableGad = TRUE;
  1316.                     }
  1317.                 }
  1318.             }
  1319.             SetGadgetAttrs(gads[QU_GFXTYPE_CYC],0L,0L,WCYCLEA_Active,(ULONG)gfxmode_cyc,
  1320.                                                                     TAG_DONE);
  1321.         }
  1322.  
  1323.         if(buffer=FindToolType(Storm_FixToolType toolarray,"FORCEWPA8"))
  1324.         {
  1325.             ret_int = strcmp(buffer,"TRUE");
  1326.             if (ret_int == 0)
  1327.             {
  1328.                 BoolValue = TRUE;
  1329.             }
  1330.             else
  1331.             {
  1332.                 BoolValue = FALSE;
  1333.             }
  1334.             SetGadgetAttrs(gads[QU_WPA8_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1335.                                                                     TAG_DONE);
  1336.         }
  1337.  
  1338.         if(buffer=FindToolType(Storm_FixToolType toolarray,"SHOWPARTICLE"))
  1339.         {
  1340.             ret_int = strcmp(buffer,"TRUE");
  1341.             if (ret_int == 0)
  1342.             {
  1343.                 BoolValue = TRUE;
  1344.             }
  1345.             else
  1346.             {
  1347.                 BoolValue = FALSE;
  1348.                 SetGadgetAttrs(gads[QU_PARTICLE_INT],0L,0L,GA_Disabled,TRUE,
  1349.                                                                         TAG_DONE);
  1350.             }
  1351.             SetGadgetAttrs(gads[QU_PART_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1352.                                                                     TAG_DONE);
  1353.         }
  1354.  
  1355.         if(buffer=FindToolType(Storm_FixToolType toolarray,"PARTICLE"))
  1356.         {
  1357. // change this to atol ??
  1358.             ret_int = atoi(buffer);
  1359.             SetGadgetAttrs(gads[QU_PARTICLE_INT],0L,0L,WINTEGERA_Long,(ULONG)ret_int,
  1360.                                                                         TAG_DONE);
  1361.         }
  1362.  
  1363.         if(buffer=FindToolType(Storm_FixToolType toolarray,"WB"))
  1364.         {
  1365.             ret_int = strcmp(buffer,"TRUE");
  1366.             if (ret_int == 0)
  1367.             {
  1368.                 BoolValue = TRUE;
  1369.             }
  1370.             else
  1371.             {
  1372.                 BoolValue = FALSE;
  1373.             }
  1374.             SetGadgetAttrs(gads[QU_WBWINDOW_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1375.                                                                         GA_Disabled,(ULONG)DisableGad,
  1376.                                                                         TAG_DONE);
  1377.         }
  1378.         else
  1379.         {
  1380.             SetGadgetAttrs(gads[QU_WBWINDOW_TICK],0L,0L, GA_Disabled,(ULONG)DisableGad,
  1381.                                                                         TAG_DONE);
  1382.         }
  1383.  
  1384.         DisablePubStr = FALSE;
  1385.         if(buffer=FindToolType(Storm_FixToolType toolarray,"PUBSCR"))
  1386.         {
  1387.             ret_int = strcmp(buffer,"TRUE");
  1388.             if (ret_int == 0)
  1389.             {
  1390.                 BoolValue = TRUE;
  1391.             }
  1392.             else
  1393.             {
  1394.                 BoolValue = FALSE;
  1395.                 DisablePubStr = TRUE;
  1396.             }
  1397.  
  1398.             if (DisableGad  == TRUE)
  1399.             {
  1400.                 SetGadgetAttrs(gads[QU_PUBSCREEN_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1401.                                                                             GA_Disabled,(ULONG)DisableGad,
  1402.                                                                             TAG_DONE);
  1403.             }
  1404.             else
  1405.             {
  1406.                 SetGadgetAttrs(gads[QU_PUBSCREEN_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1407.                                                                             TAG_DONE);
  1408.             }
  1409.         }
  1410.  
  1411.         if(buffer=FindToolType(Storm_FixToolType toolarray,"PUBSCREENNAME"))
  1412.         {
  1413.             SetGadgetAttrs(gads[QU_PUBSCREEN_STR],0L,0L,WSTRINGA_String,buffer,
  1414.                                                                         GA_Disabled,(ULONG)DisablePubStr,
  1415.                                                                         TAG_DONE);
  1416.  
  1417.             if (DisableGad == TRUE)
  1418.             {
  1419.                 SetGadgetAttrs(gads[QU_PUBSCREEN_STR],0L,0L,GA_Disabled,(ULONG)TRUE,
  1420.                                                                         TAG_DONE);
  1421.             }
  1422.         }
  1423.  
  1424.         if(buffer=FindToolType(Storm_FixToolType toolarray,"RESIZE"))
  1425.         {
  1426.             SetGadgetAttrs(gads[QU_PIPSCALE_STR],0L,0L,WSTRINGA_String,buffer,
  1427.                                                                         TAG_DONE);
  1428.         }
  1429.  
  1430.         if(buffer=FindToolType(Storm_FixToolType toolarray,"PIP"))
  1431.         {
  1432.             ret_int = strcmp(buffer,"TRUE");
  1433.             if (ret_int == 0)
  1434.             {
  1435.                 BoolValue = TRUE;
  1436.             }
  1437.             else
  1438.             {
  1439.                 BoolValue = FALSE;
  1440.             }
  1441.  
  1442.             if (DisableGad == TRUE)
  1443.             {
  1444.                 SetGadgetAttrs(gads[QU_P96PIP_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1445.                                                                         GA_Disabled,(ULONG)DisableGad,
  1446.                                                                         TAG_DONE);
  1447.             }
  1448.             else
  1449.             {
  1450.                 SetGadgetAttrs(gads[QU_P96PIP_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1451.                                                                         TAG_DONE);
  1452.                 SetGadgetAttrs(gads[QU_PIPSCALE_STR],0L,0L,GA_Disabled,(ULONG)FALSE,
  1453.                                                                         TAG_DONE);
  1454.             }
  1455.         }
  1456.  
  1457.         TriBufOk = FALSE;
  1458.         if(buffer=FindToolType(Storm_FixToolType toolarray,"DBUF"))
  1459.         {
  1460.             ret_int = strcmp(buffer,"TRUE");
  1461.             if (ret_int == 0)
  1462.             {
  1463.                 BoolValue = TRUE;
  1464.                 TriBufOk = TRUE;
  1465.             }
  1466.             else
  1467.             {
  1468.                 BoolValue = FALSE;
  1469.             }
  1470.             SetGadgetAttrs(gads[QU_TRIBUF_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1471.                                                                     GA_Disabled,(ULONG)DisableGad,
  1472.                                                                     TAG_DONE);
  1473.         }
  1474.         else
  1475.         {
  1476.             SetGadgetAttrs(gads[QU_TRIBUF_TICK],0L,0L, GA_Disabled,(ULONG)DisableGad,
  1477.                                                                         TAG_DONE);
  1478.         }
  1479.  
  1480.         if(buffer=FindToolType(Storm_FixToolType toolarray,"OLDSTYLE"))
  1481.         {
  1482.             ret_int = strcmp(buffer,"TRUE");
  1483.             if (ret_int == 0)
  1484.             {
  1485.                 BoolValue = TRUE;
  1486.                 if (TriBufOk == TRUE)
  1487.                 {
  1488.                     SetGadgetAttrs(gads[QU_TRIBUF_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)FALSE,
  1489.                                                                             GA_Disabled,(ULONG)DisableGad,
  1490.                                                                             TAG_DONE);
  1491.                 }
  1492.             }
  1493.             else
  1494.             {
  1495.                 BoolValue = FALSE;
  1496.             }
  1497.             SetGadgetAttrs(gads[QU_DBLBUF_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1498.                                                                     GA_Disabled,(ULONG)DisableGad,
  1499.                                                                     TAG_DONE);
  1500.         }
  1501.         else
  1502.         {
  1503.             SetGadgetAttrs(gads[QU_DBLBUF_TICK],0L,0L, GA_Disabled,(ULONG)DisableGad,
  1504.                                                                         TAG_DONE);
  1505.         }
  1506.  
  1507.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOSOUND"))
  1508.         {
  1509.             ret_int = strcmp(buffer,"TRUE");
  1510.             if (ret_int == 0)
  1511.             {
  1512.                 BoolValue = TRUE;
  1513.             }
  1514.             else
  1515.             {
  1516.                 BoolValue = FALSE;
  1517.             }
  1518.             SetGadgetAttrs(gads[QU_DISABLESND_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1519.                                                                             TAG_DONE);
  1520.         }
  1521.  
  1522.         DisableGad = FALSE;
  1523.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOCDAUDIO"))
  1524.         {
  1525.             ret_int = strcmp(buffer,"TRUE");
  1526.             if (ret_int == 0)
  1527.             {
  1528.                 BoolValue = TRUE;
  1529.                 DisableGad = TRUE;
  1530.             }
  1531.             else
  1532.             {
  1533.                 BoolValue = FALSE;
  1534.             }
  1535.             SetGadgetAttrs(gads[QU_DISABLECD_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1536.                                                                         TAG_DONE);
  1537.         }
  1538.  
  1539.         if(buffer=FindToolType(Storm_FixToolType toolarray,"CDUNIT"))
  1540.         {
  1541.             ret_int = atoi(buffer);
  1542.             SetGadgetAttrs(gads[QU_CDUNIT_INT],0L,0L,WINTEGERA_Long,(ULONG)ret_int,
  1543.                                                                     GA_Disabled,(ULONG)DisableGad,
  1544.                                                                     TAG_DONE);
  1545.         }
  1546.  
  1547.         if(buffer=FindToolType(Storm_FixToolType toolarray,"CDDEVICE"))
  1548.         {
  1549.             SetGadgetAttrs(gads[QU_DEVICE_STR],0L,0L,WSTRINGA_String,buffer,
  1550.                                                                     GA_Disabled,(ULONG)DisableGad,
  1551.                                                                     TAG_DONE);
  1552.         }
  1553.  
  1554.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOMOUSE"))
  1555.         {
  1556.             ret_int = strcmp(buffer,"TRUE");
  1557.             if (ret_int == 0)
  1558.             {
  1559.                 BoolValue = TRUE;
  1560.             }
  1561.             else
  1562.             {
  1563.                 BoolValue = FALSE;
  1564.             }
  1565.             SetGadgetAttrs(gads[QU_USEMOUSE_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1566.                                                                         TAG_DONE);
  1567.         }
  1568.  
  1569.         if(buffer=FindToolType(Storm_FixToolType toolarray,"HACK"))
  1570.         {
  1571.             ret_int = strcmp(buffer,"TRUE");
  1572.             if (ret_int == 0)
  1573.             {
  1574.                 BoolValue = TRUE;
  1575.             }
  1576.             else
  1577.             {
  1578.                 BoolValue = FALSE;
  1579.             }
  1580.             SetGadgetAttrs(gads[QU_MMUHACK_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1581.                                                                         TAG_DONE);
  1582.         }
  1583.  
  1584.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOSTDOUT"))
  1585.         {
  1586.             ret_int = strcmp(buffer,"TRUE");
  1587.             if (ret_int == 0)
  1588.             {
  1589.                 BoolValue = TRUE;
  1590.             }
  1591.             else
  1592.             {
  1593.                 BoolValue = FALSE;
  1594.             }
  1595.             SetGadgetAttrs(gads[QU_STDOUT_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1596.                                                                     TAG_DONE);
  1597.         }
  1598.  
  1599.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NO68KFPU"))
  1600.         {
  1601.             ret_int = strcmp(buffer,"TRUE");
  1602.             if (ret_int == 0)
  1603.             {
  1604.                 BoolValue = TRUE;
  1605.             }
  1606.             else
  1607.             {
  1608.                 BoolValue = FALSE;
  1609.             }
  1610.             SetGadgetAttrs(gads[QU_LC040_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1611.                                                                     TAG_DONE);
  1612.         }
  1613.  
  1614.         DisableGad = FALSE;
  1615.         if(buffer=FindToolType(Storm_FixToolType toolarray,"MINMEM"))
  1616.         {
  1617.             ret_int = strcmp(buffer,"TRUE");
  1618.             if (ret_int == 0)
  1619.             {
  1620.                 BoolValue = TRUE;
  1621.                 DisableGad = TRUE;
  1622.             }
  1623.             else
  1624.             {
  1625.                 BoolValue = FALSE;
  1626.             }
  1627.             SetGadgetAttrs(gads[QU_MINMEM_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1628.                                                                     TAG_DONE);
  1629.         }
  1630.  
  1631.         if(buffer=FindToolType(Storm_FixToolType toolarray,"MEM"))
  1632.         {
  1633.             ret_long = atol(buffer);
  1634.             SetGadgetAttrs(gads[QU_MEMORY_INT],0L,0L,WINTEGERA_Long,(ULONG)ret_long,
  1635.                                                                     GA_Disabled,(ULONG)DisableGad,
  1636.                                                                     TAG_DONE);
  1637.         }
  1638.  
  1639.         if(buffer=FindToolType(Storm_FixToolType toolarray,"SURFCACHEMEM"))
  1640.         {
  1641.             ret_long = atol(buffer);
  1642.             SetGadgetAttrs(gads[QU_SURFCACHEMEM_INT],0L,0L,WINTEGERA_Long,(ULONG)ret_long,
  1643.                                                                             GA_Disabled,(ULONG)DisableGad,
  1644.                                                                             TAG_DONE);
  1645.         }
  1646.  
  1647.         if(buffer=FindToolType(Storm_FixToolType toolarray,"ZONEMEM"))
  1648.         {
  1649.             ret_long = atol(buffer);
  1650.             SetGadgetAttrs(gads[QU_ZONEMEM_INT],0L,0L,WINTEGERA_Long,(ULONG)ret_long,
  1651.                                                                     GA_Disabled,(ULONG)DisableGad,
  1652.                                                                     TAG_DONE);
  1653.         }
  1654.  
  1655.         DisableGad = FALSE;
  1656.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOLAN"))
  1657.         {
  1658.             ret_int = strcmp(buffer,"TRUE");
  1659.             if (ret_int == 0)
  1660.             {
  1661.                 BoolValue = TRUE;
  1662.                 DisableGad = TRUE;
  1663.             }
  1664.             else
  1665.             {
  1666.                 BoolValue = FALSE;
  1667.             }
  1668.             SetGadgetAttrs(gads[QU_DISABLELAN_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1669.                                                                             TAG_DONE);
  1670.         }
  1671.  
  1672.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOSERIAL"))
  1673.         {
  1674.             ret_int = strcmp(buffer,"TRUE");
  1675.             if (ret_int == 0)
  1676.             {
  1677.                 BoolValue = TRUE;
  1678.             }
  1679.             else
  1680.             {
  1681.                 BoolValue = FALSE;
  1682.             }
  1683.             SetGadgetAttrs(gads[QU_DISABLESER_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1684.                                                                             GA_Disabled,(ULONG)DisableGad,
  1685.                                                                             TAG_DONE);
  1686.         }
  1687.  
  1688.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOTCP"))
  1689.         {
  1690.             ret_int = strcmp(buffer,"TRUE");
  1691.             if (ret_int == 0)
  1692.             {
  1693.                 BoolValue = TRUE;
  1694.             }
  1695.             else
  1696.             {
  1697.                 BoolValue = FALSE;
  1698.             }
  1699.             SetGadgetAttrs(gads[QU_DISABLETCP_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1700.                                                                             GA_Disabled,(ULONG)DisableGad,
  1701.                                                                             TAG_DONE);
  1702.         }
  1703.  
  1704.         if(buffer=FindToolType(Storm_FixToolType toolarray,"NOIPX"))
  1705.         {
  1706.             ret_int = strcmp(buffer,"TRUE");
  1707.             if (ret_int == 0)
  1708.             {
  1709.                 BoolValue = TRUE;
  1710.             }
  1711.             else
  1712.             {
  1713.                 BoolValue = FALSE;
  1714.             }
  1715.             SetGadgetAttrs(gads[QU_DISABLEIPX_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1716.                                                                             GA_Disabled,(ULONG)DisableGad,
  1717.                                                                             TAG_DONE);
  1718.         }
  1719.  
  1720.         if(buffer=FindToolType(Storm_FixToolType toolarray,"IPXPORT"))
  1721.         {
  1722.             ret_long = atol(buffer);
  1723.             SetGadgetAttrs(gads[QU_IPXPORT_INT],0L,0L,WINTEGERA_Long,(ULONG)ret_long,
  1724.                                                                     GA_Disabled,(ULONG)DisableGad,
  1725.                                                                     TAG_DONE);
  1726.         }
  1727.  
  1728.         if(buffer=FindToolType(Storm_FixToolType toolarray,"LISTEN"))
  1729.         {
  1730.             ret_int = strcmp(buffer,"TRUE");
  1731.             if (ret_int == 0)
  1732.             {
  1733.                 BoolValue = TRUE;
  1734.             }
  1735.             else
  1736.             {
  1737.                 BoolValue = FALSE;
  1738.             }
  1739.             SetGadgetAttrs(gads[QU_ENABLELISTEN_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1740.                                                                             TAG_DONE);
  1741.         }
  1742.  
  1743.         if(buffer=FindToolType(Storm_FixToolType toolarray,"DEDICATED"))
  1744.         {
  1745.             ret_int = strcmp(buffer,"TRUE");
  1746.             if (ret_int == 0)
  1747.             {
  1748.                 BoolValue = TRUE;
  1749.             }
  1750.             else
  1751.             {
  1752.                 BoolValue = FALSE;
  1753.             }
  1754.             SetGadgetAttrs(gads[QU_ENABLEDEDICATED_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1755.                                                                                 TAG_DONE);
  1756.         }
  1757.  
  1758.         if(buffer=FindToolType(Storm_FixToolType toolarray,"PLAYBACK"))
  1759.         {
  1760.             ret_int = strcmp(buffer,"TRUE");
  1761.             if (ret_int == 0)
  1762.             {
  1763.                 BoolValue = TRUE;
  1764.             }
  1765.             else
  1766.             {
  1767.                 BoolValue = FALSE;
  1768.             }
  1769.             SetGadgetAttrs(gads[QU_PLAYBACKMODE_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1770.                                                                             TAG_DONE);
  1771.         }
  1772.  
  1773.         if(buffer=FindToolType(Storm_FixToolType toolarray,"RECORD"))
  1774.         {
  1775.             ret_int = strcmp(buffer,"TRUE");
  1776.             if (ret_int == 0)
  1777.             {
  1778.                 BoolValue = TRUE;
  1779.             }
  1780.             else
  1781.             {
  1782.                 BoolValue = FALSE;
  1783.             }
  1784.             SetGadgetAttrs(gads[QU_RECORDMODE_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1785.                                                                         TAG_DONE);
  1786.         }
  1787.  
  1788.         if(buffer=FindToolType(Storm_FixToolType toolarray,"ROGUE"))
  1789.         {
  1790.             ret_int = strcmp(buffer,"TRUE");
  1791.             if (ret_int == 0)
  1792.             {
  1793.                 BoolValue = TRUE;
  1794.             }
  1795.             else
  1796.             {
  1797.                 BoolValue = FALSE;
  1798.             }
  1799.             SetGadgetAttrs(gads[QU_ROGUE_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1800.                                                                     TAG_DONE);
  1801.         }
  1802.  
  1803.         if(buffer=FindToolType(Storm_FixToolType toolarray,"HYPNOTIC"))
  1804.         {
  1805.             ret_int = strcmp(buffer,"TRUE");
  1806.             if (ret_int == 0)
  1807.             {
  1808.                 BoolValue = TRUE;
  1809.             }
  1810.             else
  1811.             {
  1812.                 BoolValue = FALSE;
  1813.             }
  1814.             SetGadgetAttrs(gads[QU_HYPNOTIC_TICK],0L,0L,WCHECKBOXA_Checked,(ULONG)BoolValue,
  1815.                                                                         TAG_DONE);
  1816.         }
  1817.  
  1818. /* We require to dynamically allocate RAM for this, rather than use a 100 byte buffer. What if
  1819.    these strings are longer than 100 bytes?... */
  1820.         if(buffer=FindToolType(Storm_FixToolType toolarray,"GAMEDIR"))
  1821.         {
  1822.             SetGadgetAttrs(gads[QU_GAMEDIR_STR],0L,0L,WSTRINGA_String,buffer,
  1823.                                                                     TAG_DONE);
  1824.         }
  1825.  
  1826.         if(buffer=FindToolType(Storm_FixToolType toolarray,"SEARCHPATH"))
  1827.         {
  1828.             SetGadgetAttrs(gads[QU_GAMESEARCH_STR],0L,0L,WSTRINGA_String,buffer,
  1829.                                                                         TAG_DONE);
  1830.         }
  1831.  
  1832.         if(buffer=FindToolType(Storm_FixToolType toolarray,"MISCOPTIONS"))
  1833.         {
  1834.             SetGadgetAttrs(gads[QU_GAMEMISC_STR],0L,0L,WSTRINGA_String,buffer,
  1835.                                                                         TAG_DONE);
  1836.         }
  1837.  
  1838.     }
  1839.     else
  1840.     {
  1841.         ShowError(Errors.noGDO);
  1842.     }
  1843. }
  1844.  
  1845. void DisableChunkyGads(void)
  1846. {
  1847.     SetGadgetAttrs(gads[QU_WBWINDOW_TICK],windowXX,0L,GA_Disabled,TRUE,
  1848.                                                                 TAG_DONE);
  1849.     SetGadgetAttrs(gads[QU_PUBSCREEN_TICK],windowXX,0L,GA_Disabled,TRUE,
  1850.                                                                 TAG_DONE);
  1851.     SetGadgetAttrs(gads[QU_PUBSCREEN_STR],windowXX,0L,GA_Disabled,TRUE,
  1852.                                                                 TAG_DONE);
  1853.     SetGadgetAttrs(gads[QU_P96PIP_TICK],windowXX,0L,GA_Disabled,TRUE,
  1854.                                                                 TAG_DONE);
  1855.     SetGadgetAttrs(gads[QU_DBLBUF_TICK],windowXX,0L,GA_Disabled,TRUE,
  1856.                                                                 TAG_DONE);
  1857.     SetGadgetAttrs(gads[QU_TRIBUF_TICK],windowXX,0L,GA_Disabled,TRUE,
  1858.                                                                 TAG_DONE);
  1859. }
  1860.  
  1861.  
  1862. void EnableChunkyGads(void)
  1863. {
  1864.     ULONG IntField;
  1865.  
  1866.     SetGadgetAttrs(gads[QU_WBWINDOW_TICK],windowXX,0L,GA_Disabled,FALSE,
  1867.                                                                 TAG_DONE);
  1868.     SetGadgetAttrs(gads[QU_PUBSCREEN_TICK],windowXX,0L,GA_Disabled,FALSE,
  1869.                                                                 TAG_DONE);
  1870.  
  1871.     GetAttr(WCHECKBOXA_Checked, gads[QU_PUBSCREEN_TICK],(ULONG *) &IntField);
  1872.     if (IntField == TRUE)
  1873.     {
  1874.         SetGadgetAttrs(gads[QU_PUBSCREEN_STR],windowXX,0L,GA_Disabled,FALSE,
  1875.                                                                     TAG_DONE);
  1876.     }
  1877.     SetGadgetAttrs(gads[QU_P96PIP_TICK],windowXX,0L,GA_Disabled,FALSE,
  1878.                                                                 TAG_DONE);
  1879.     SetGadgetAttrs(gads[QU_DBLBUF_TICK],windowXX,0L,GA_Disabled,FALSE,
  1880.                                                                 TAG_DONE);
  1881.     SetGadgetAttrs(gads[QU_TRIBUF_TICK],windowXX,0L,GA_Disabled,FALSE,
  1882.                                                                 TAG_DONE);
  1883. }
  1884.  
  1885. void StartGame(void)
  1886. {
  1887.     FILE *fp;
  1888.     char *file_name="t:qguitemp";
  1889.     char *mem_ptr;
  1890.     struct FileInfoBlock *My_fib;
  1891.  
  1892.     BPTR MyFileLock;
  1893.     LONG Filesize = 0;
  1894.  
  1895.     // One way of detecting a filesize.
  1896.     My_fib = AllocDosObject(DOS_FIB,NULL);
  1897.     MyFileLock = Lock((STRPTR)file_name,ACCESS_READ);
  1898.     if (MyFileLock != 0)
  1899.     {
  1900.         if (Examine(MyFileLock,My_fib))
  1901.         {
  1902.             Filesize = My_fib->fib_Size;
  1903.         }
  1904.         UnLock(MyFileLock);
  1905.     }
  1906.     FreeDosObject(DOS_FIB,My_fib);
  1907.  
  1908.     if (Filesize)
  1909.     {
  1910.         mem_ptr = AllocVec(Filesize+1, MEMF_CLEAR | MEMF_ANY);
  1911.         if (mem_ptr)
  1912.         {
  1913.             fp = fopen (file_name,"r");
  1914.             if (fp)
  1915.             {
  1916.                 fread(mem_ptr, Filesize, 1, fp);
  1917.                 mem_ptr[Filesize] = 0;
  1918.  
  1919.                 SystemTags(mem_ptr,
  1920.                                 SYS_Input,    new_stdout,
  1921.                                 SYS_Output,    NULL,
  1922.                                 NP_StackSize, StackSize,
  1923.                                 TAG_DONE);
  1924.                 fclose(fp);
  1925.             }
  1926.             else
  1927.             {
  1928.                 ShowError(Errors.nofile);
  1929.             }
  1930.             FreeVec(mem_ptr);
  1931.         }
  1932.         else
  1933.         {
  1934.             ShowError(Errors.noram);
  1935.         }
  1936.     }
  1937.     else
  1938.     {
  1939.         ShowError(Errors.nofsize);
  1940.     }
  1941. }
  1942.  
  1943. void ShowError(char *errormsg)
  1944. {
  1945.     static struct EasyStruct es = {
  1946.         sizeof(struct EasyStruct),
  1947.         0,
  1948.         "QuakeGUI",
  1949.         NULL,
  1950.         NULL
  1951.     };
  1952.  
  1953.     es.es_TextFormat    = errormsg;
  1954.     es.es_GadgetFormat    = "OK";
  1955.     EasyRequestArgs(NULL, &es, 0, (&errormsg)+1);
  1956. }
  1957.