/* CDesigner by Nicholas Dyson. A program for creating ascii text 
   definitions of intuition structures in C. Written and compiled on a 
   2 Meg Amiga 500 with 90 meg SCSI hard drive, using Lattice C V5.10
   compiler and development tools */

#include "exec/types.h"
#include "proto/all.h"
#include "intuition/intuition.h"
#include "intuition/intuitionbase.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "dos.h"
#include "graphics/gfxbase.h"
int CXBRK(void) {return(0);}

#define HIGHNONE2 0x0200
#define HIGHIMAGE2 0x0400

void openall(void);
void cleanexit(LONG);
void checkpos(void);
void printext(struct Window *,char *,int,int,int,int);
void setsizes(void);
void showsize(void);
BOOL dogadup(struct IntuiMessage *);
void sizewindow(void);
void getflags(void);
void opengadwin(void);
void save(void);
void makewindow(void);
void makescreen(void);
BOOL dosgadup(struct IntuiMessage *);
void opensgadwin(void);
void ssave(void);
void makemenu(void);
BOOL domengadup(struct IntuiMessage *);
void openmenwin(void);
void menup(void);
void mendn(void);
void nameitem(void);
void namemenu(void);
char * pad(char *);
void insitem(void);
void domentext(struct Window *,char *,int,int,int,int);
void drawbox(int);
void dogadsrefresh(void);
void docommseq(void);
void domengaddn(struct IntuiMessage *);
void menrt(void);
void menlt(void);
void insmenu(void);
void movemenu(int);
void mensave(void);
void doremmen(void);
void doremitem(void);
int getwidth(struct mmenu *);
void doaddsub(void);
void doremsub(void);
int cwidth(void);
void remallitems(struct mmenu *);
void drawmenu(struct mmenu *);
void checkflags(USHORT,int);
void entsub(void);
void savemenu(struct mmenu *,FILE *,int,char *,int);
void savementext(struct mmenu *,FILE *,int,char *);
void doselbuttdn(struct IntuiMessage *);
void domenbuttdn(struct IntuiMessage *);
void mennew(void);
void clearmenus(void);
void toksaveallitems(struct mmenu *,BPTR);
void toksavemenus(char *);
struct mitem * tokloadallitems(struct mmenu *,BPTR);
void tokloadmenus(void);
void onmengads(void);
void printextb(struct Window *wn,char *str,int x,int y,int f);
void offgad(struct Gadget *,struct Window *);
void ongad(struct Gadget *,struct Window *);
BOOL getyesno(struct IntuiText *,char *);

int handleugad(struct IntuiMessage *);
void initslider(struct Gadget *g);
void getslider(struct Gadget *,int);
void displayentries(void);
void loadfiles(void);
void printext2(UBYTE *msg,LONG x, LONG y, USHORT f, USHORT b);
void newdir(int);
void dostrgad(void);
int filereq(char *,char *,char *);

struct TextAttr TOPAZ80 =
   {(STRPTR)"topaz.font",TOPAZ_EIGHTY, 0, 0};

struct NewScreen fullhires =
   {
      0,
      0,
      640,
      STDSCREENHEIGHT,
      2,
      4,1,
      HIRES,
      CUSTOMSCREEN,
      &TOPAZ80,
      "C Designer",
      NULL,
      NULL
};

struct NewWindow textwindow =
{
   10,20,
   120,45,
   0,1,
   CLOSEWINDOW,
   WINDOWCLOSE|WINDOWDRAG|NOCAREREFRESH|RMBTRAP,
   NULL,
   NULL,
   "Dimensions",
   NULL,
   NULL,
   10,10,
   -1,-1,
   CUSTOMSCREEN
};

struct NewWindow backwindow =
{
   0,0,
   640,15,
   0,1,
   NULL,
   BORDERLESS|RMBTRAP|NOCAREREFRESH|BACKDROP,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL,
   10,10,
   -1,-1,
   CUSTOMSCREEN
};

struct IntuiText idcmptxt[]=
{
   {1,4,JAM2, 0, 0,&TOPAZ80,"MOUSEBUTTONS",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"MOUSEMOVE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"DELTAMOVE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"GADGETDOWN",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"GADGETUP",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"CLOSEWINDOW",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"MENUPICK",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"MENUVERIFY",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"REQSET",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"REQCLEAR",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"REQVERIFY",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"NEWSIZE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"REFRESHWINDOW",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SIZEVERIFY",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"ACTIVEWINDOW",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"INACTIVEWINDOW",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"VANILLAKEY",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"RAWKEY",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"NEWPREFS",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"DISKINSERTED",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"DISKREMOVED",NULL},   
   {1,4,JAM2, 0, 0,&TOPAZ80,"INTUITICKS",NULL}
};

struct IntuiText flagstxt[]=
{
   {1,4,JAM2, 0, 0,&TOPAZ80,"WINDOWSIZING",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"WINDOWDEPTH",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"WINDOWCLOSE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"WINDOWDRAG",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"GIMMEZEROZERO",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SIMPLE_REFRESH",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SMART_REFRESH",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SUPER_BITMAP",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"BACKDROP",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"BORDERLESS",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"REPORTMOUSE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"ACTIVATE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"NOCAREREFRESH",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"RMBTRAP",NULL}
};

struct IntuiText typetxt[]=
{
   {1,4,JAM2, 0, 0,&TOPAZ80,"CUSTOMSCREEN",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"WBENCHSCREEN",NULL}
};

SHORT bordervectors11a[]=
   {0,11, 0,0, 73,0};
SHORT bordervectors11b[]=
   {73,1, 73,12, 0,12};
struct Border border11b=
   {0,0,2,0,JAM1,3,bordervectors11b,NULL};
struct Border border11a=
   {0,0,1,0,JAM1,3,bordervectors11a,&border11b};
struct IntuiText savetext = {1,0,JAM1,20,2,&TOPAZ80,"Save",NULL};
struct IntuiText quittext = {1,0,JAM1,20,2,&TOPAZ80,"Quit",NULL};
struct IntuiText resizetext = {1,0,JAM1,12,2,&TOPAZ80,"Resize",NULL};
struct Gadget savegad=
{
   NULL,275,185,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&savetext,NULL,NULL,1,NULL
};

struct Gadget quitgad=
{
   &savegad,447,185,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&quittext,NULL,NULL,2,NULL
};

struct Gadget resizegad=
{
   &quitgad,100,185,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&resizetext,NULL,NULL,3,NULL
};

SHORT bordervectors2[] =
   {0,0,57,0,57,10,0,10,0,0};
struct Border border2 =
   {-1,-1,1,0,JAM1,5,bordervectors2,NULL};

UBYTE minwidthbuff[10]="";
struct StringInfo minwidthinfo =
   {minwidthbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget minwidthgad =
{
   &resizegad,90,165,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&minwidthinfo,0,NULL
};

UBYTE minheightbuff[10]="";
struct StringInfo minheightinfo =
   {minheightbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget minheightgad =
{
   &minwidthgad,234,165,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&minheightinfo,0,NULL
};

UBYTE maxwidthbuff[10]="";
struct StringInfo maxwidthinfo =
   {maxwidthbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget maxwidthgad =
{
   &minheightgad,370,165,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&maxwidthinfo,0,NULL
};

UBYTE maxheightbuff[10]="";
struct StringInfo maxheightinfo =
   {maxheightbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget maxheightgad =
{
   &maxwidthgad,514,165,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&maxheightinfo,0,NULL
};

UBYTE detailbuff[10]="";
struct StringInfo detailinfo =
   {detailbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget detailgad =
{
   &maxheightgad,90,150,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&detailinfo,0,NULL
};

UBYTE blockbuff[10]="";
struct StringInfo blockinfo =
   {blockbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget blockgad =
{
   &detailgad,234,150,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&blockinfo,0,NULL
};

SHORT bordervectors1[] =
   {0,0,481,0,481,10,0,10,0,0};
struct Border border1 =
   {-1,-1,1,0,JAM1,5,bordervectors1,NULL};
UBYTE titlebuff[255];
struct StringInfo titleinfo =
   {titlebuff,NULL,0,255,0,0,0,0,0,0,0,0,NULL};
struct Gadget titlegad =
{
   &blockgad,90,135,480,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border1,NULL,NULL,NULL,(APTR)&titleinfo,0,NULL
};

struct NewWindow newwindow =
{
   160,25,
   210,78,
   0,1,
   INTUITICKS|NEWSIZE,
   WINDOWDRAG|WINDOWSIZING|NOCAREREFRESH|RMBTRAP|ACTIVATE,
   NULL,
   NULL,
   titlebuff,
   NULL,
   NULL,
   1,1,
   -1,-1,
   CUSTOMSCREEN
};

struct Gadget typegad=
{
    &titlegad,60,115,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,
    NULL,NULL,&typetxt[0],NULL,NULL,0,NULL
};

struct Gadget flagsgads[]=
{
   {&flagsgads[1],10,75,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[0],NULL,NULL,0,NULL
   },
   {&flagsgads[2],122,75,88,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[1],NULL,NULL,0,NULL
   },
   {&flagsgads[3],226,75,88,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[2],NULL,NULL,0,NULL
   },
   {&flagsgads[4],330,75,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[3],NULL,NULL,0,NULL
   },
   {&flagsgads[5],426,75,104,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[4],NULL,NULL,0,NULL
   },
   {&flagsgads[6],10,85,112,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[5],NULL,NULL,0,NULL
   },
   {&flagsgads[7],138,85,104,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[6],NULL,NULL,0,NULL
   },
   {&flagsgads[8],258,85,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[7],NULL,NULL,0,NULL
   },
   {&flagsgads[9],370,85,64,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[8],NULL,NULL,0,NULL
   },
   {&flagsgads[10],450,85,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[9],NULL,NULL,0,NULL
   },
   {&flagsgads[11],10,95,88,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[10],NULL,NULL,0,NULL
   },
   {&flagsgads[12],114,95,64,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[11],NULL,NULL,0,NULL
   },
   {&flagsgads[13],194,95,104,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[12],NULL,NULL,0,NULL
   },
   {&typegad      ,314,95,56,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &flagstxt[13],NULL,NULL,0,NULL
   }
};

struct Gadget idcmpgads[]=
{
   {&idcmpgads[1],10,15,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[0],NULL,NULL,0,NULL
   },
   {&idcmpgads[2],122,15,72,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[1],NULL,NULL,0,NULL
   },
   {&idcmpgads[3],210,15,72,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[2],NULL,NULL,0,NULL
   },
   {&idcmpgads[4],298,15,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[3],NULL,NULL,0,NULL
   },
   {&idcmpgads[5],394,15,64,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[4],NULL,NULL,0,NULL
   },
   {&idcmpgads[6],474,15,88,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[5],NULL,NULL,0,NULL
   },
   {&idcmpgads[7],10,25,64,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[6],NULL,NULL,0,NULL
   },
   {&idcmpgads[8],90,25,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[7],NULL,NULL,0,NULL
   },
   {&idcmpgads[9],186,25,48,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[8],NULL,NULL,0,NULL
   },
   {&idcmpgads[10],250,25,64,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[9],NULL,NULL,0,NULL
   },
   {&idcmpgads[11],330,25,72,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[10],NULL,NULL,0,NULL
   },
   {&idcmpgads[12],418,25,56,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[11],NULL,NULL,0,NULL
   },
   {&idcmpgads[13],490,25,104,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[12],NULL,NULL,0,NULL
   },
   {&idcmpgads[14],10,35,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[13],NULL,NULL,0,NULL
   },
   {&idcmpgads[15],106,35,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[14],NULL,NULL,0,NULL
   },
   {&idcmpgads[16],218,35,112,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[15],NULL,NULL,0,NULL
   },
   {&idcmpgads[17],346,35,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[16],NULL,NULL,0,NULL
   },
   {&idcmpgads[18],442,35,48,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[17],NULL,NULL,0,NULL
   },
   {&idcmpgads[19],506,35,64,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[18],NULL,NULL,0,NULL
   },
   {&idcmpgads[20],10,45,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[19],NULL,NULL,0,NULL
   },
   {&idcmpgads[21],122,45,88,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[20],NULL,NULL,0,NULL
   },
   {&flagsgads[0],218,45,80,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &idcmptxt[21],NULL,NULL,0,NULL
   }
};

struct NewWindow gadwindow =
{
   10,20,
   620,200,
   0,1,
   GADGETUP,
   NOCAREREFRESH|ACTIVATE|RMBTRAP,
   &idcmpgads[0],
   NULL,
   NULL,
   NULL,
   NULL,
   10,10,
   -1,-1,
   CUSTOMSCREEN
};

struct IntuiText showval=
   {1,4,JAM2, 0, 0,&TOPAZ80,NULL,NULL};

struct IntuiText maintext[] = 
{
   {1,0,JAM1,29,2,&TOPAZ80,"Design a Window",NULL},
   {1,0,JAM1,29,2,&TOPAZ80,"Design a Screen",NULL},
   {1,0,JAM1,37,2,&TOPAZ80,"Design a Menu",NULL},
   {1,0,JAM1,73,2,&TOPAZ80,"Quit",NULL}
};

SHORT bordervectors10a[]=
   {0,11, 0,0, 179,0};
SHORT bordervectors10b[]=
   {179,1, 179,12, 0,12};

struct Border border10b=
   {0,0,2,0,JAM1,3,bordervectors10b,NULL};
struct Border border10a=
   {0,0,1,0,JAM1,3,bordervectors10a,&border10b};

struct Gadget maingads[] =
{
   {
      &maingads[1],5,5,179,12,GADGHCOMP,
      RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
      NULL,&maintext[0],NULL,NULL,10,NULL
   },
   {
      &maingads[2],5,20,179,12,GADGHCOMP,
      RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
      NULL,&maintext[1],NULL,NULL,11,NULL
   },
   {  &maingads[3],5,35,179,12,GADGHCOMP,
      RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
      NULL,&maintext[2],NULL,NULL,12,NULL
   },
   {
      NULL        ,5,50,179,12,GADGHCOMP,
      RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
      NULL,&maintext[3],NULL,NULL,13,NULL
   }
};

struct NewWindow mainwindow =
{
   225,70,
   190,65,
   0,1,
   GADGETUP,
   NOCAREREFRESH|RMBTRAP|BORDERLESS|ACTIVATE,
   &maingads[0],
   NULL,
   NULL,
   NULL,
   NULL,
   0,0,
   0xFFFF,0xFFFF,
   CUSTOMSCREEN
};

/* screen design gadgets */

struct Gadget squitgad=
{
   NULL,337,115,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&quittext,NULL,NULL,1,NULL
};

struct Gadget ssavegad=
{
   &squitgad,100,115,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&savetext,NULL,NULL,2,NULL
};

UBYTE stopbuff[10]="0";
struct StringInfo stopinfo =
   {stopbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget stopgad =
{
   &ssavegad,80,5,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&stopinfo,0,NULL
};

UBYTE sheightbuff[10]="256";
struct StringInfo sheightinfo =
   {sheightbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget sheightgad =
{
   &stopgad,80,20,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&sheightinfo,0,NULL
};

struct IntuiText mhtext = 
   {1,0,JAM1,29,2,&TOPAZ80,"Maximum Height",NULL};

struct Gadget smhgad =
{
   &sheightgad,150,18,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&mhtext,NULL,NULL,3,NULL
};

UBYTE sdepthbuff[10]="2";
struct StringInfo sdepthinfo =
   {sdepthbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget sdepthgad =
{
   &smhgad,80,35,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&sdepthinfo,0,NULL
};

UBYTE sdetailbuff[10]="4";
struct StringInfo sdetailinfo =
   {sdetailbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget sdetailgad =
{
   &sdepthgad,90,50,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&sdetailinfo,0,NULL
};

UBYTE sblockbuff[10]="1";
struct StringInfo sblockinfo =
   {sblockbuff,NULL,0,7,0,0,0,0,0,0,0,0,NULL};
struct Gadget sblockgad =
{
   &sdetailgad,226,50,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&sblockinfo,0,NULL
};

struct IntuiText vmtxt[]=
{
   {1,4,JAM2, 0, 0,&TOPAZ80,"HIRES",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"LACE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SPRITES",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"DUALPF",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"HAM",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"EXTRA_HALFBRITE",NULL}
};

struct Gadget vmgads[]=
{
   {&vmgads[1],90,65,40,8,GADGHCOMP|SELECTED,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &vmtxt[0],NULL,NULL,0,NULL
   },
   {&vmgads[2],146,65,32,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &vmtxt[1],NULL,NULL,0,NULL
   },
   {&vmgads[3],194,65,56,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &vmtxt[2],NULL,NULL,0,NULL
   },
   {&vmgads[4],266,65,48,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &vmtxt[3],NULL,NULL,0,NULL
   },
   {&vmgads[5],330,65,24,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &vmtxt[4],NULL,NULL,0,NULL
   },
   {&sblockgad,370,65,120,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &vmtxt[5],NULL,NULL,0,NULL
   }
};

struct IntuiText stypetxt[]=
{
   {1,4,JAM2, 0, 0,&TOPAZ80,"CUSTOMSCREEN",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SCREENBEHIND",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"SCREENQUIET",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"CUSTOMBITMAP",NULL}
};

struct Gadget stypegads[]=
{
   {&stypegads[1],58,80,96,8,GADGHCOMP|SELECTED,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &stypetxt[0],NULL,NULL,0,NULL
   },
   {&stypegads[2],170,80,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &stypetxt[1],NULL,NULL,0,NULL
   },
   {&stypegads[3],282,80,88,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &stypetxt[2],NULL,NULL,0,NULL
   },
   {&vmgads[0],386,80,96,8,GADGHCOMP,TOGGLESELECT,BOOLGADGET,NULL,NULL,
    &stypetxt[3],NULL,NULL,0,NULL
   }
};

SHORT bordervectors0[] =
   {0,0,401,0,401,10,0,10,0,0};
struct Border border0 =
   {-1,-1,1,0,JAM1,5,bordervectors0,NULL};
UBYTE stitlebuff[255];
struct StringInfo stitleinfo =
   {stitlebuff,NULL,0,255,0,0,0,0,0,0,0,0,NULL};
struct Gadget stitlegad =
{
   &stypegads[0],80,95,400,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border0,NULL,NULL,NULL,(APTR)&stitleinfo,0,NULL
};

struct NewWindow sgadswindow =
{
   65,55,
   519,130,
   0,1,
   GADGETUP,
   NOCAREREFRESH|ACTIVATE|RMBTRAP,
   &stitlegad,
   NULL,
   NULL,
   NULL,
   NULL,
   10,10,
   -1,-1,
   CUSTOMSCREEN
};

/* menu screen gadgets */

USHORT chip darrowdata[]=
{
	0xffff,0xfc00,0x8000,0x0000,0x8000,0x0000,0x8000,
	0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,
	0x8000,0x0000,0x8000,0x0000,0x807c,0x0000,0x807c,
	0x0000,0x807c,0x0000,0x807c,0x0000,0x807c,0x0000,
	0x9fff,0xf000,0x8fff,0xe000,0x87ff,0xc000,0x83ff,
	0x8000,0x81ff,0x0000,0x80fe,0x0000,0x807c,0x0000,
	0x8038,0x0000,0x8010,0x0000,0x8000,0x0000,0x8000,
	0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,
	0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,
	0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,
	/* BitPlane 0x0001 */
	0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,
	0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,
	0x0000,0x0200,0x00fe,0x0200,0x0082,0x0200,0x0082,
	0x0200,0x0082,0x0200,0x0082,0x0200,0x3f83,0xfa00,
	0x2000,0x0a00,0x1000,0x1200,0x0800,0x2200,0x0400,
	0x4200,0x0200,0x8200,0x0101,0x0200,0x0082,0x0200,
	0x0044,0x0200,0x0028,0x0200,0x0010,0x0200,0x0000,
	0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,
	0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,
	0x0200,0x0000,0x0200,0x0000,0x0200,0x7fff,0xfe00
};

USHORT chip uarrowdata[]=
{
	0xffff,0xfc00,0x8000,0x0000,0x8000,0x0000,0x8000,
	0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,
	0x8000,0x0000,0x8000,0x0000,0x8010,0x0000,0x8038,
	0x0000,0x807c,0x0000,0x80fe,0x0000,0x81ff,0x0000,
	0x83ff,0x8000,0x87ff,0xc000,0x8fff,0xe000,0x9fff,
	0xf000,0x807c,0x0000,0x807c,0x0000,0x807c,0x0000,
	0x807c,0x0000,0x807c,0x0000,0x8000,0x0000,0x8000,
	0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,
	0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,
	0x0000,0x8000,0x0000,0x8000,0x0000,0x8000,0x0000,
	/* BitPlane 0x0001 */
	0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,
	0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,
	0x0000,0x0200,0x0010,0x0200,0x0028,0x0200,0x0044,
	0x0200,0x0082,0x0200,0x0101,0x0200,0x0200,0x8200,
	0x0400,0x4200,0x0800,0x2200,0x1000,0x1200,0x2000,
	0x0a00,0x3f83,0xfa00,0x0082,0x0200,0x0082,0x0200,
	0x0082,0x0200,0x0082,0x0200,0x00fe,0x0200,0x0000,
	0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,
	0x0000,0x0200,0x0000,0x0200,0x0000,0x0200,0x0000,
	0x0200,0x0000,0x0200,0x0000,0x0200,0x7fff,0xfe00
};

USHORT chip rarrowdata[]=
{
	0xffff,0xffff,0xffff,0xf800,0x8000,0x0000,0x0000,
	0x0000,0x8000,0x0060,0x0000,0x0000,0x8000,0x007c,
	0x0000,0x0000,0x8000,0x007f,0x8000,0x0000,0x8000,
	0xffff,0xf000,0x0000,0x8000,0xffff,0xfe00,0x0000,
	0x8000,0xffff,0xf000,0x0000,0x8000,0x007f,0x8000,
	0x0000,0x8000,0x007c,0x0000,0x0000,0x8000,0x0060,
	0x0000,0x0000,0x8000,0x0000,0x0000,0x0000,0x8000,
	0x0000,0x0000,0x0000,
	/* BitPlane 0x0001 */
	0x0000,0x0000,0x0000,0x0400,0x0000,0x00e0,0x0000,
	0x0400,0x0000,0x009c,0x0000,0x0400,0x0000,0x0083,
	0x8000,0x0400,0x0001,0xff80,0x7000,0x0400,0x0001,
	0x0000,0x0e00,0x0400,0x0001,0x0000,0x01c0,0x0400,
	0x0001,0x0000,0x0e00,0x0400,0x0001,0xff80,0x7000,
	0x0400,0x0000,0x0083,0x8000,0x0400,0x0000,0x009c,
	0x0000,0x0400,0x0000,0x00e0,0x0000,0x0400,0x7fff,
	0xffff,0xffff,0xfc00
};


USHORT chip larrowdata[]=
{
	0xffff,0xffff,0xffff,0xf800,0x8000,0x0000,0x0000,
	0x0000,0x8000,0x0030,0x0000,0x0000,0x8000,0x01f0,
	0x0000,0x0000,0x8000,0x0ff0,0x0000,0x0000,0x8000,
	0x7fff,0xf800,0x0000,0x8003,0xffff,0xf800,0x0000,
	0x8000,0x7fff,0xf800,0x0000,0x8000,0x0ff0,0x0000,
	0x0000,0x8000,0x01f0,0x0000,0x0000,0x8000,0x0030,
	0x0000,0x0000,0x8000,0x0000,0x0000,0x0000,0x8000,
	0x0000,0x0000,0x0000,
	/* BitPlane 0x0001 */
	0x0000,0x0000,0x0000,0x0400,0x0000,0x0038,0x0000,
	0x0400,0x0000,0x01c8,0x0000,0x0400,0x0000,0x0e08,
	0x0000,0x0400,0x0000,0x700f,0xfc00,0x0400,0x0003,
	0x8000,0x0400,0x0400,0x001c,0x0000,0x0400,0x0400,
	0x0003,0x8000,0x0400,0x0400,0x0000,0x700f,0xfc00,
	0x0400,0x0000,0x0e08,0x0000,0x0400,0x0000,0x01c8,
	0x0000,0x0400,0x0000,0x0038,0x0000,0x0400,0x7fff,
	0xffff,0xffff,0xfc00
};


struct Image arrows[]=
{
   {0,0,23,35,2,uarrowdata,0x0003,0x0000,NULL},
   {0,0,23,35,2,darrowdata,0x0003,0x0000,NULL},
   {0,0,54,13,2,larrowdata,0x0003,0x0000,NULL},
   {0,0,54,13,2,rarrowdata,0x0003,0x0000,NULL},
};

struct IntuiText mentext[]=
{
   {1,4,JAM2, 41, 2,&TOPAZ80,"Add a Menu",NULL},
   {1,4,JAM2, 29, 2,&TOPAZ80,"Add a Menu Item",NULL},
   {1,4,JAM2, 25, 2,&TOPAZ80," Add a Sub Menu ",NULL},
   {1,4,JAM2, 42, 2,&TOPAZ80,"Delete Menu",NULL},
   {1,4,JAM2, 21, 2,&TOPAZ80,"Delete Menu Item",NULL},
   {1,4,JAM2, 29, 2,&TOPAZ80,"Delete Sub Menu",NULL},
   {1,4,JAM2, 20, 2,&TOPAZ80,"Save",NULL},
   {1,4,JAM2, 20, 2,&TOPAZ80,"Quit",NULL},
   {1,4,JAM2, 20, 2,&TOPAZ80,"Load",NULL},
   {1,4,JAM2, 16, 2,&TOPAZ80,"Clear",NULL}
};

struct Gadget addmengad =
{
   NULL,403,130,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&mentext[0],NULL,NULL,1,NULL
};

struct Gadget addmenitgad =
{
   &addmengad,403,145,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&mentext[1],NULL,NULL,2,NULL
};

struct Gadget addsubmengad =
{
   &addmenitgad,403,160,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&mentext[2],NULL,NULL,32,NULL
};

struct Gadget remmengad =
{
   &addsubmengad,403,175,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&mentext[3],NULL,NULL,30,NULL
};

struct Gadget remmenitgad =
{
   &remmengad,403,190,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&mentext[4],NULL,NULL,31,NULL
};

struct Gadget mensavegad =
{
   &remmenitgad,403,205,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&mentext[6],NULL,NULL,3,NULL
};

struct Gadget menloadgad =
{
   &mensavegad,509,205,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&mentext[8],NULL,NULL,33,NULL
};

struct Gadget mencleargad =
{
   &menloadgad,403,220,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&mentext[9],NULL,NULL,34,NULL
};

struct Gadget menquitgad =
{
   &mencleargad,509,220,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&mentext[7],NULL,NULL,4,NULL
};

UBYTE commseqbuff[5];
struct StringInfo commseqinfo =
   {commseqbuff,NULL,0,2,0,0,0,0,0,0,0,0,NULL};
struct Gadget commseqgad =
{
   &menquitgad,412,115,56,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border2,NULL,NULL,NULL,(APTR)&commseqinfo,11,NULL
};

struct IntuiText mflagstxt[]=
{
   {1,4,JAM2, 0, 0,&TOPAZ80,"CHECKIT",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"CHECKED",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"MENUTOGGLE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"ITEMENABLED",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"HIGHCOMP",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"HIGHBOX",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"HIGHIMAGE",NULL},
   {1,4,JAM2, 0, 0,&TOPAZ80,"HIGHNONE",NULL}
};

struct Gadget mflagsgads[]=
{
   {&mflagsgads[1],396,70,56,8,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[0],NULL,NULL,20,NULL
   },
   {&mflagsgads[2],468,70,56,8,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[1],NULL,NULL,21,NULL
   },
   {&mflagsgads[3],540,70,80,8,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[2],NULL,NULL,22,NULL
   },
   {&mflagsgads[4],348,85,88,8,GADGHCOMP|SELECTED,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[3],NULL,NULL,23,NULL
   },
   {&mflagsgads[5],452,85,64,8,GADGHCOMP|SELECTED,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[4],NULL,NULL,24,NULL
   },
   {&mflagsgads[6],532,85,56,8,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[5],NULL,NULL,25,NULL
   },
   {&mflagsgads[7],348,100,72,8,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[6],NULL,NULL,26,NULL
   },
   {&commseqgad   ,436,100,64,8,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,NULL,NULL,
    &mflagstxt[7],NULL,NULL,27,NULL
   }
};

SHORT bordervectors10[] =
   {0,0,202,0,202,9,0,9,0,0};
struct Border border10 =
   {-1,-1,1,0,JAM1,5,bordervectors10,NULL};
UBYTE itnamebuff[40]="";
struct StringInfo itnameinfo =
   {itnamebuff,NULL,0,35,0,0,0,0,0,0,0,0,NULL};
struct Gadget itnamegad =
{
   &mflagsgads[0],428,55,202,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border10,NULL,NULL,NULL,(APTR)&itnameinfo,9,NULL
};

UBYTE mennamebuff[40]="";
struct StringInfo mennameinfo =
   {mennamebuff,NULL,0,35,0,0,0,0,0,0,0,0,NULL};
struct Gadget mennamegad =
{
   &itnamegad,428,40,202,9,NULL,RELVERIFY,STRGADGET,
   (APTR)&border10,NULL,NULL,NULL,(APTR)&mennameinfo,10,NULL
};

struct IntuiText entsubtxt[]=
{
   {1,4,JAM2,7,2,&TOPAZ80,"»",NULL},
   {1,4,JAM2,7,2,&TOPAZ80,"«",NULL}
};

SHORT bordervectors30a[] =
   {0,11,0,0,22,0};
SHORT bordervectors30b[] =
   {22,1,22,12,0,12};
struct Border border30[] =
{
   {0,0,1,0,JAM1,3,bordervectors30a,&border30[1]},
   {0,0,2,0,JAM1,3,bordervectors30b,NULL}
};
struct Gadget entsubgad=
{
   &mennamegad,5,136,23,12,GADGHCOMP,RELVERIFY,
   BOOLGADGET,(APTR)&border30[0],NULL,&entsubtxt[0],NULL,NULL,35,NULL
};

struct Gadget marrowgads[]=
{
   {
      &marrowgads[1],5,100,23,35,GADGHNONE|GADGIMAGE,GADGIMMEDIATE,
      BOOLGADGET,(APTR)&arrows[0],NULL,NULL,NULL,NULL,5,NULL
   },
   {
      &marrowgads[2],5,150,23,35,GADGHNONE|GADGIMAGE,GADGIMMEDIATE,
      BOOLGADGET,(APTR)&arrows[1],NULL,NULL,NULL,NULL,6,NULL
   },
   {
      &marrowgads[3],100,12,54,13,GADGHNONE|GADGIMAGE,GADGIMMEDIATE,
      BOOLGADGET,(APTR)&arrows[2],NULL,NULL,NULL,NULL,7,NULL
   },
   {
      &entsubgad,226,12,54,13,GADGHNONE|GADGIMAGE,GADGIMMEDIATE,
      BOOLGADGET,(APTR)&arrows[3],NULL,NULL,NULL,NULL,8,NULL
   }
};

struct NewWindow menuwindow =
{
   0,11,
   640,245,
   0,1,
   GADGETUP|GADGETDOWN|RAWKEY|MOUSEBUTTONS,
   NOCAREREFRESH|RMBTRAP|BORDERLESS|ACTIVATE,
   &marrowgads[0],
   NULL,
   NULL,
   NULL,
   NULL,
   0,0,
   0xFFFF,0xFFFF,
   CUSTOMSCREEN
};

/* File requester structures */

UBYTE buffer[512];

struct IntuiText messages = 
   {1,0,JAM2,0,0,&TOPAZ80,&buffer[0],NULL};
      
struct Image backimage1=
   {
      0,0,
      267,90,
      0,
      NULL,
      0x0000,0x0002,
      NULL
   };

struct Gadget backdrop =
   {
      NULL,
      5,12,1,1,
      GADGIMAGE,
      NULL,
      BOOLGADGET,
      (APTR)&backimage1,
      NULL,
      NULL,
      NULL,
      NULL,
      0,
      NULL
   };

USHORT chip maskdata2[]=
{
	0x03f0,0x1f00,0x0000,0x0000,0x0e1c,0x0700,0x0000,
	0x0000,0x1806,0x0700,0x0000,0x0000,0x3807,0x0700,
	0x0000,0x0000,0x7003,0x8700,0x0000,0x0000,0x7003,
	0x8700,0x0000,0x0000,0xe001,0xc700,0x0000,0x0000,
	0xe001,0xc71f,0x07e7,0xf1f0,0xe001,0xc704,0x18f1,
	0xc040,0xe001,0xc708,0x1c71,0xe0c0,0xe001,0xc710,
	0x0870,0xe080,0xe001,0xc730,0x0070,0xf180,0x7003,
	0x8778,0x07f0,0x7100,0x7003,0x87bc,0x1c70,0x7b00,
	0x3807,0x071e,0x3870,0x3a00,0x1806,0x070f,0x3870,
	0x3e00,0x0e1c,0x0707,0xbcf4,0x1c00,0x03f0,0x1fcf,
	0xdf38,0x1c00,0x0000,0x0000,0x0000,0x0800,0x0000,
	0x0000,0x0000,0x0800,0x0000,0x0000,0x0000,0x0800,
	0x0000,0x0000,0x0001,0x9000,0x0000,0x0000,0x0001,
	0x9000,0x0000,0x0000,0x0000,0xe000
};

struct Image buttoni1 =
   {
   0,0,61,24,1,maskdata2,0x0001,0x0000,NULL
   };

USHORT chip maskdata3[]=
{
	0x03e2,0x0000,0x0000,0x0000,0x1f00,0x0e1e,0x0000,
	0x0000,0x0000,0x0700,0x1806,0x0000,0x0000,0x0000,
	0x0700,0x3802,0x0000,0x0000,0x0000,0x0700,0x7002,
	0x0000,0x0000,0x0000,0x0700,0x7000,0x0000,0x0000,
	0x0000,0x0700,0xe000,0x0000,0x0000,0x0000,0x0700,
	0xe000,0x1f87,0x9f00,0xf81e,0x0700,0xe000,0x63c1,
	0xe383,0x8473,0x8700,0xe000,0x71c1,0xc1c3,0x0e61,
	0x8700,0xe000,0x21c1,0xc1c7,0x04e1,0xc700,0xe000,
	0x01c1,0xc1c7,0x00e1,0xc700,0x7000,0x1fc1,0xc1c7,
	0x00ff,0xc700,0x7002,0x71c1,0xc1c7,0x00e0,0x0700,
	0x3802,0xe1c1,0xc1c7,0x00e0,0x0700,0x1806,0xe1c1,
	0xc1c3,0x0260,0x4700,0x0e1e,0xf3d1,0xc1c3,0x8470,
	0x8700,0x03e2,0x7ce7,0xf7f0,0xf81f,0x1fc0
};

struct Image buttoni2 =
   {
   0,0,76,18,1,maskdata3,0x0001,0x0000,NULL
   };
   
struct Gadget buttongads[] =
{
   {
      &backdrop,195,130,76,18,GADGHNONE|GADGIMAGE,
      RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&buttoni2,
      NULL,NULL,NULL,NULL,7,NULL
   },
   {
      &buttongads[0],25,130,61,24,GADGHNONE|GADGIMAGE,
      RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&buttoni1,
      NULL,NULL,NULL,NULL,6,NULL
   }
};

SHORT bordervectors3[]=
{
   0,0,
   268,0,
   268,91,
   0,91,
   0,0
};

struct Border border3=
{
   -1,-1,
   1,0,JAM1,
   5,
   bordervectors3,
   NULL
};

struct Gadget entrybox=
{
   &buttongads[1],
   5,12,
   267,90,
   GADGHBOX|GADGHIMAGE,
   RELVERIFY,
   BOOLGADGET,
   (APTR)&border3,
   NULL,
   NULL,
   NULL,
   NULL,
   1,
   NULL
};

SHORT bordervectors4[] =
{
   0,0,
   288,0,
   288,10,
   0,10,
   0,0
};

struct Border border4 =
{
   -1,-1,
   1,0,JAM1,
   5,
   bordervectors4,
   NULL
};

UBYTE UNDOBUFFER[255];
UBYTE namegadsibuff[255];

struct StringInfo namegadsinfo =
{
   namegadsibuff,
   UNDOBUFFER,
   0,
   255,
   0,
   0,
   0,0,0,0,
   0,
   0,
   NULL
};

struct Gadget namegad =
{
   &entrybox,
   5,105,
   287,9,
   NULL,
   RELVERIFY,
   STRGADGET,
   (APTR)&border4,
   NULL,
   NULL,
   NULL,
   (APTR)&namegadsinfo,
   5,
   NULL
};

USHORT chip darrowdata2[]=
{
   0xffff,0xf81f,0xf81f,0xf81f,0xf81f,0x8001,0xe007,0xf81f,0xfe7f
};

USHORT chip uarrowdata2[]=
{
   0xfe7f,0xf81f,0xe007,0x8001,0xf81f,0xf81f,0xf81f,0xf81f,0xffff
};

struct Image arrows2[]=
{
   {0,0,16,9,2,uarrowdata2,0x0001,0x0000,NULL},
   {0,0,16,9,2,darrowdata2,0x0001,0x0000,NULL}
};

struct Gadget arrowgads[]=
{
   {
      &namegad,277,84,16,9,GADGIMAGE,RELVERIFY,
      BOOLGADGET,(APTR)&arrows2[0],NULL,NULL,NULL,NULL,4,NULL
   },
   {
      &arrowgads[0],277,94,16,9,GADGIMAGE,RELVERIFY,
      BOOLGADGET,(APTR)&arrows2[1],NULL,NULL,NULL,NULL,3,NULL
   }
};

struct PropInfo vertslidersinfo=
{
   AUTOKNOB|FREEVERT,
   -1,-1,
   -1,-1
};

struct Image image3 =
   {0,0,7,72,0,NULL,0x0000,0x0000,NULL};

struct Image timage =
   {0,0,7,72,0,NULL,0x0000,0x0000,NULL};

struct Gadget vertslider =
{
   &arrowgads[1],277,11,16,72,NULL,
   RELVERIFY,
   PROPGADGET,
   (APTR)&image3,
   NULL,NULL,NULL,
   (APTR)&vertslidersinfo,
   2,NULL
};

struct NewWindow nw =
{
   171,48,297,160,0,1,
   INTUITICKS|GADGETUP,
   WINDOWDRAG|ACTIVATE|NOCAREREFRESH|RMBTRAP,
   &vertslider,NULL," ",NULL,NULL,0,0,-1,-1,CUSTOMSCREEN
};

struct filestruct 
{
   UBYTE name[40];
   BOOL isdir;
   long size;
};

struct IntuiText reqtext[] =
{
   {1,0,JAM2,24, 2,&TOPAZ80,"Yes",NULL},
   {1,0,JAM2,28, 2,&TOPAZ80,"No",NULL},
   {1,0,JAM2,26, 5,&TOPAZ80,"Okay to Clear?",NULL},
   {1,0,JAM2,30, 5,&TOPAZ80,"Okay to Quit?",NULL}
};

struct Gadget ryesgad=
{
   NULL,5,32,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&reqtext[0],NULL,NULL,1,NULL
};

struct Gadget rnogad=
{
   &ryesgad,88,32,73,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border11a,
   NULL,&reqtext[1],NULL,NULL,0,NULL
};

struct NewWindow rw =
{
   236,65,
   166,50,
   4,1,
   GADGETUP,
   ACTIVATE|NOCAREREFRESH|RMBTRAP,
   &rnogad,
   NULL,
   NULL,
   NULL,
   NULL,
   0,0,
   0xFFFF,0xFFFF,
   CUSTOMSCREEN
};

struct IntuiText svmtext[] =
{
   {1,0,JAM2,17,2,&TOPAZ80,"Lo-Res     320x256",NULL},
   {1,0,JAM2,17,2,&TOPAZ80,"Med-Res    640x256",NULL},
   {1,0,JAM2,17,2,&TOPAZ80,"Interlace  320x512",NULL},
   {1,0,JAM2,17,2,&TOPAZ80,"Hi-Res     640x512",NULL}
};

struct Gadget shigad =
{
   NULL,5,70,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&svmtext[3],NULL,NULL,3,NULL
};

struct Gadget sintgad =
{
   &shigad,5,55,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&svmtext[2],NULL,NULL,2,NULL
};

struct Gadget smedgad =
{
   &sintgad,5,40,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&svmtext[1],NULL,NULL,1,NULL
};

struct Gadget slogad =
{
   &smedgad,5,25,179,12,GADGHCOMP,
   RELVERIFY|BOOLEXTEND,BOOLGADGET,(APTR)&border10a,
   NULL,&svmtext[0],NULL,NULL,0,NULL
};

struct NewWindow sw =
{
   224,65,
   190,85,
   4,1,
   GADGETUP,
   ACTIVATE|NOCAREREFRESH|RMBTRAP,
   &slogad,
   NULL,
   NULL,
   NULL,
   NULL,
   0,0,
   0xFFFF,0xFFFF,
   CUSTOMSCREEN
};

struct NewScreen sscreen =
   {
      0,
      0,
      640,
      STDSCREENHEIGHT,
      2,
      4,4,
      HIRES,
      CUSTOMSCREEN,
      &TOPAZ80,
      NULL,
      NULL,
      NULL
};

struct mitem{
   char name[35];
   char commseq;
   USHORT flags;
   struct mitem *nextitem;
   struct mitem *lastitem;
   struct mmenu *sub;
};

struct mmenu{
   char name[35];
   int noitems;
   int width;
   struct mitem *firstitem;
   struct mmenu *nextmenu;
   struct mmenu *lastmenu;
};

struct mmenu *currentmenu=NULL;
struct mitem *currentitem=NULL;

char *empty="                                  ";
char *mentit="Menu Designer";
char *stit="Screen Designer";
char *wtit="Window Designer";
char *savemess="Save File";

struct Screen *screen1=NULL;
struct Screen *screen2=NULL;
struct Window *win=NULL;
struct Window *twin=NULL;
struct Window *gwin=NULL;
struct Window *bwin=NULL;
struct Window *mwin=NULL;
struct Window *swin=NULL;
struct Window *menwin=NULL;
struct Window *vmwin=NULL;
struct IntuitionBase *IntuitionBase=NULL;
struct GfxBase *GfxBase=NULL;
struct Process *mproc=NULL;
APTR *savewindow=NULL;
BOOL insub=FALSE;
char initxt[]="MENTOKSAVE";
int itnum=0,mnum=0,mennum=1;
int lastvm=10;

/* file requester globals */

LONG numentries;
LONG topentry;
struct filestruct *names;
struct Window *reqwin=NULL;

void main(void)
{
   ULONG signalmask, signals;
   struct IntuiMessage *message;
   BOOL done=FALSE;
   struct Gadget *g;
   USHORT id;
   int num;
   
   openall();
   do{
      signalmask = 1L << mwin->UserPort->mp_SigBit;
      signals = Wait(signalmask);
      if (signals & signalmask){
         while(message = (struct Intuimessage *)GetMsg(mwin->UserPort))
         {
            switch(message->Class){
               case GADGETUP:
                  g=(struct Gadget *)message->IAddress;
                  id=g->GadgetID;
                  switch(id){
                     case 10:
                        makewindow();
                        break;
                     case 11:
                        makescreen();
                        break;
                     case 12:
                        makemenu();
                        break;
                     case 13:
                        RemoveGList(mwin,&maingads[0],-1);
                        num=getyesno(&reqtext[3],fullhires.DefaultTitle);
                        AddGList(mwin,&maingads[0],0,-1,NULL);
                        if(num) done=TRUE;break;
                  }
                  break;
            } 
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   cleanexit(RETURN_OK);
}

void makemenu(void)
{
   ULONG signalmask, signals;
   struct IntuiMessage *message;
   BOOL done=FALSE;
   
   openmenwin();
   do{
      signalmask = 1L << menwin->UserPort->mp_SigBit;
      signals = Wait(signalmask);
      if (signals & signalmask){
         while(message = (struct Intuimessage *)GetMsg(menwin->UserPort))
         {
            switch(message->Class){
               case GADGETUP:
                  done=domengadup(message);
                  break;
               case GADGETDOWN:
                  domengaddn(message);
                  break;
               case MOUSEBUTTONS:
                  if(message->Code==SELECTDOWN)
                     doselbuttdn(message);
                  else
                  if(message->Code==MENUDOWN)
                     domenbuttdn(message);
                  break;
               case RAWKEY:
                  switch(message->Code){
                     case 0x4c:menup();break;
                     case 0x4d:mendn();break;
                     case 0x4f:menlt();break;
                     case 0x4e:menrt();break;
                     case 0x44:entsub();break;
                  }
            } 
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   CloseWindow(menwin);
   menwin=NULL;
}

BOOL getyesno(struct IntuiText *t,char *tit)
{
   ULONG signalmask, signals;
   struct IntuiMessage *message;
   BOOL done=FALSE,ret;
   struct Gadget *g;

   if(!(reqwin = OpenWindow(&rw)))
      cleanexit(RETURN_FAIL);
   SetWindowTitles(reqwin,NULL,tit);
   PrintIText(reqwin->RPort,t,0,0);
   do{
      signalmask = 1L << reqwin->UserPort->mp_SigBit;
      signals = Wait(signalmask);
      if (signals & signalmask){
         while(message = (struct Intuimessage *)GetMsg(reqwin->UserPort))
         {
            if(message->Class==GADGETUP){
               g=(struct Gadget *)message->IAddress;
               ret=g->GadgetID;
               if((ret==0)||(ret==1))
                  done=TRUE;
            } 
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   CloseWindow(reqwin);
   reqwin=NULL;
   return(ret);
}

void doselbuttdn(struct IntuiMessage *m)
{
   register int i;
   int y;
   
   if((m->MouseY>38)&&(m->MouseY<((currentmenu->noitems*10)+38))&&
         (m->MouseX>50)&&(m->MouseX<((currentmenu->width*8)+50))){
      y=m->MouseY-38;
      y=y/10;
      domentext(menwin,currentitem->name,50,(10*itnum)+40,1,4);
      currentitem=currentmenu->firstitem;
      for(i=0;i<y;i++)
         currentitem=currentitem->nextitem;
      itnum=y;
      domentext(menwin,currentitem->name,50,(10*itnum)+40,4,1);
      dogadsrefresh();
   }
}

void clearmenus(void)
{
   struct mmenu *menutemp;
   
   while(currentmenu->lastmenu!=NULL)
      currentmenu=currentmenu->lastmenu;
   while(currentmenu!=NULL){
      menutemp=currentmenu->nextmenu;
      remallitems(currentmenu);
      FreeMem((struct mmenu *)currentmenu,sizeof(struct mmenu));
      currentmenu=menutemp;
   }
}

void mennew(void)
{
   clearmenus();
   mnum=1;
   mennum=1;
   printext(menwin," 1",476,10,1,4);
   printext(menwin," 1",508,25,1,4);
   itnum=0;
   currentmenu=(struct mmenu *)AllocMem(sizeof(struct mmenu),0);
   currentmenu->noitems=1;
   currentmenu->width=5;
   currentmenu->nextmenu=NULL;
   strcpy(currentmenu->name,"");
   currentmenu->lastmenu=NULL;
   currentitem=(struct mitem *)AllocMem(sizeof(struct mitem),0);
   currentitem->commseq=0;
   currentitem->flags=ITEMENABLED|HIGHCOMP;
   currentitem->nextitem=NULL;
   currentitem->lastitem=NULL;
   currentitem->sub=NULL;
   currentmenu->firstitem=currentitem;
   printext(menwin,empty,50,28,1,4);
   strcpy(itnamebuff,currentitem->name);
   strcpy(mennamebuff,currentmenu->name);
   strcpy(commseqbuff,"");
   RefreshGList(&marrowgads[0],menwin,NULL,-1);
   if(insub){
      insub=FALSE;
      onmengads();
   }
   drawmenu(currentmenu);
}

void onmengads(void)
{
   entsubgad.GadgetText=&entsubtxt[0];
   RefreshGList(&entsubgad,menwin,NULL,1);
   ongad(&mennamegad,menwin);
   SetAPen(menwin->RPort,4);
   RectFill(menwin->RPort,403,160,582,172);
   ongad(&addsubmengad,menwin);
   RectFill(menwin->RPort,403,130,582,142);
   ongad(&addmengad,menwin);
   RectFill(menwin->RPort,403,175,582,187);
   ongad(&remmengad,menwin);
}

void domenbuttdn(struct IntuiMessage *m)
{
   register int i;
   int y;
   struct mitem *temp;
   
   if((m->MouseY>38)&&(m->MouseY<((currentmenu->noitems*10)+38))&&
         (m->MouseX>50)&&(m->MouseX<((currentmenu->width*8)+50))){
      y=m->MouseY-38;
      y=y/10;
      temp=currentmenu->firstitem;
      for(i=0;i<y;i++)
         temp=temp->nextitem;
      if(temp->sub!=NULL){
         currentitem=temp;
         entsub();
      }
   }
}

void toksaveallitems(struct mmenu *men,BPTR fh)
{
   struct mitem *itemtemp;
      
   itemtemp=men->firstitem;
   while(itemtemp!=NULL){
      Write(fh,(struct mitem *)itemtemp,sizeof(struct mitem));
      if(itemtemp->sub!=NULL){
         Write(fh,(struct mmenu *)itemtemp->sub,sizeof(struct mmenu));
         toksaveallitems(itemtemp->sub,fh);
      }
      itemtemp=itemtemp->nextitem;
   }
}

void toksavemenus(char *name)
{
   struct mmenu *menutemp;
   BPTR fh=NULL;
   char fname[300];
   
   strcpy(fname,name);
   strcat(fname,".TOK");
   if(fh=Open(fname,MODE_NEWFILE)){
      Write(fh,(char *)&initxt,10);
      menutemp=currentmenu;
      while(menutemp->lastmenu!=NULL)
         menutemp=menutemp->lastmenu;
      while(menutemp!=NULL){
         Write(fh,(struct mmenu *)menutemp,sizeof(struct mmenu));
         toksaveallitems(menutemp,fh);
         menutemp=menutemp->nextmenu;
      }
      Close(fh);
   }
}

struct mitem * tokloadallitems(struct mmenu *men,BPTR fh)
{
   struct mmenu menutemp,*sub;
   struct mitem *last=NULL,*first,*new,itemtemp;
   BOOL done=FALSE;
   
   while(!done){
      Read(fh,(struct mitem *)&itemtemp,sizeof(struct mitem));
      new=(struct mitem *)AllocMem(sizeof(struct mitem),0);
      new->lastitem=last;
      if(last!=NULL)
         last->nextitem=new;
      else
         first=new;
      new->commseq=itemtemp.commseq;
      new->flags=itemtemp.flags;
      strcpy(new->name,itemtemp.name);
      if(itemtemp.sub!=NULL){
         Read(fh,(struct mmenu *)&menutemp,sizeof(struct mmenu));
         new->sub=(struct mmenu *)AllocMem(sizeof(struct mmenu),0);
         sub=new->sub;
         sub->lastmenu=men;
         sub->nextmenu=NULL;
         sub->noitems=menutemp.noitems;
         sub->width=menutemp.width;
         strcpy(sub->name,menutemp.name);
         sub->firstitem=tokloadallitems(men,fh);
      }
      else
         new->sub=NULL;
      last=new;
      if(itemtemp.nextitem==NULL)
         done=TRUE;
   }
   new->nextitem=NULL;
   return(first);
}

void tokloadmenus(void)
{
   struct mmenu menutemp,*last=NULL,*first,*new;
   BPTR fh=NULL;
   char tmp[10];
   char initstr[11],fname[300];
   int error;
   BOOL done=FALSE;
   
   RemoveGList(menwin,&marrowgads[0],-1);
   error=filereq(fname,"Load File",mentit);
   AddGList(menwin,&marrowgads[0],0,-1,NULL);
   if((fh=Open(fname,MODE_OLDFILE))&&(!error)){
      Read(fh,(char *)&initstr,10);
      initstr[10]=NULL;
      if(strcmp(initstr,initxt)==0){
         clearmenus();
         mennum=0;
         while(!done){
            Read(fh,(struct mmenu *)&menutemp,sizeof(struct mmenu));
            new=(struct mmenu *)AllocMem(sizeof(struct mmenu),0);
            new->noitems=menutemp.noitems;
            new->width=menutemp.width;
            strcpy(new->name,menutemp.name);
            new->firstitem=tokloadallitems(new,fh);
            new->lastmenu=last;
            if(last!=NULL)
               last->nextmenu=new;
            else
               first=new;
            last=new;
            mennum++;
            if(menutemp.nextmenu==NULL)
               done=TRUE;
         }
         mnum=1;
         new->nextmenu=NULL;
         currentmenu=first;
         currentitem=currentmenu->firstitem;
         sprintf(tmp,"%.2d",mennum);
         printext(menwin,tmp,476,10,1,4);
         printext(menwin," 1",508,25,1,4);
         itnum=0;
         printext(menwin,empty,50,28,1,4);
         strcpy(itnamebuff,currentitem->name);
         strcpy(mennamebuff,currentmenu->name);
         sprintf(commseqbuff,"%c",currentitem->commseq);
         printext(menwin,currentmenu->name,50,28,1,4);
         RefreshGList(&marrowgads[0],menwin,NULL,-1);
         if(insub){
            insub=FALSE;
            onmengads();
         }
         drawmenu(currentmenu);
      }
      Close(fh);
   }
}

void savemenu(struct mmenu *menutemp,FILE *fh,int i,char *stxt,int ledge)
{
   struct mitem *itemtemp;
   char out[255],str[255];
   int j,width,scnt=0,ded=10;
   
   if(ledge!=0)
      ded=9;
   itemtemp=menutemp->firstitem;
   sprintf(out,"struct MenuItem menu%sitems%d[]=\n{\n",stxt,i);
   fputs(out,fh);
   j=1;
   width=getwidth(menutemp);
   while(itemtemp!=NULL){
      sprintf(out,"   {&menu%sitems%d[%d]",stxt,i,j);
      if(j==menutemp->noitems)
         strcpy(out,"   {NULL");
      sprintf(str,",%d,%d,%d,9,\n",ledge,(j-1)*ded,width);
      strcat(out,str);
      fputs(out,fh);
      strcpy(out,"    ITEMTEXT|");
      if(itemtemp->flags & CHECKIT){
         strcat(out,mflagstxt[0].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & CHECKED){
         strcat(out,mflagstxt[1].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & MENUTOGGLE){
         strcat(out,mflagstxt[2].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & ITEMENABLED){
         strcat(out,mflagstxt[3].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & HIGHCOMP){
         strcat(out,mflagstxt[4].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & HIGHBOX){
         strcat(out,mflagstxt[5].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & HIGHIMAGE2){
         strcat(out,mflagstxt[6].IText);
         strcat(out,"|");
      }
      if(itemtemp->flags & HIGHNONE2){
         strcat(out,mflagstxt[7].IText);
         strcat(out,"|");
      }
      if(itemtemp->commseq!=0)
         strcat(out,"COMMSEQ|");
      out[strlen(out)-1]=NULL;
      strcat(out,",0,\n");
      fputs(out,fh);
      sprintf(out,"    (APTR)&menu%stext%d[%d],NULL,",stxt,i,j-1);
      if(itemtemp->commseq!=0){
         sprintf(str,"'%c',",itemtemp->commseq);
         strcat(out,str);
      }
      else
         strcat(out,"NULL,");
      strcpy(str,"");
      if(itemtemp->sub!=NULL){
         sprintf(str,"&menusub%ditems%d[0]",scnt,i);
         scnt++;
         strcat(out,str);
      }
      else
         strcat(out,"NULL");
      strcat(out,",MENUNULL\n   },\n");
      if(itemtemp->nextitem==NULL){
         out[strlen(out)-2]='\n';
         out[strlen(out)-1]=NULL;
      }
      fputs(out,fh);
      j++;
      itemtemp=itemtemp->nextitem;
   }
   strcpy(out,"};\n\n");
   fputs(out,fh);
}

void savementext(struct mmenu *menutemp,FILE *fh,int i,char *stxt)
{
   struct mitem *itemtemp;
   char out[255],str[255];
   
   sprintf(out,"struct IntuiText menu%stext%d[]=\n{\n",stxt,i);
   fputs(out,fh);
   itemtemp=menutemp->firstitem;
   while(itemtemp!=NULL){
      strcpy(str,"2");
      if(itemtemp->flags & CHECKIT)
         strcpy(str,"CHECKWIDTH");
      sprintf(out,"   {4,1,JAM2,%s,1,&TOPAZ80,\"%s\",NULL},\n",str,itemtemp->name);
      if(itemtemp->nextitem==NULL)
         out[strlen(out)-2]=NULL;
      fputs(out,fh);
      itemtemp=itemtemp->nextitem;
   }
   fputs("\n};\n\n",fh);
}
   
void mensave(void)
{
   struct mmenu *menutemp;
   struct mitem *itemtemp;
   FILE *fh=NULL;
   register int i=0;
   char out[255],str[255],fname[255];
   int j,len,scnt,width,error;
   
   menutemp=currentmenu;
   while(menutemp->lastmenu!=NULL)
      menutemp=menutemp->lastmenu;
   RemoveGList(menwin,&marrowgads[0],-1);
   error=filereq(fname,savemess,mentit);
   AddGList(menwin,&marrowgads[0],0,-1,NULL);
   if(!error)
      fh=fopen(fname,"w");
   if(fh!=NULL){
      fputs("struct TextAttr TOPAZ80 =\n   {(STRPTR)\"topaz.font\",TOPAZ_EIGHTY, 0, 0};\n\n",fh);
      while(menutemp!=NULL){
         scnt=0;
         itemtemp=menutemp->firstitem;
         width=getwidth(menutemp);
         while(itemtemp!=NULL){
            if(itemtemp->sub!=NULL){
               sprintf(str,"sub%d",scnt);
               savementext(itemtemp->sub,fh,i,str);
               savemenu(itemtemp->sub,fh,i,str,width-6);
               scnt++;
            }
            itemtemp=itemtemp->nextitem;
         }
         savementext(menutemp,fh,i,"");
         savemenu(menutemp,fh,i,"",0);
         menutemp=menutemp->nextmenu;
         i++;
      }
      menutemp=currentmenu;
      while(menutemp->lastmenu!=NULL)
         menutemp=menutemp->lastmenu;
      strcpy(out,"struct Menu menus[]=\n{\n");
      fputs(out,fh);
      j=1;
      len=0;
      while(menutemp!=NULL){
         sprintf(out,"   {&menus[%d]",j);
         if(j==mennum)
            strcpy(out,"   {NULL");
         sprintf(str,",%d,0,%d,0,MENUENABLED,\"%s\",&menuitems%d[0]},\n",
               len,(strlen(menutemp->name)*8)+7,menutemp->name,j-1);
         strcat(out,str);
         j++;
         if(menutemp->nextmenu==NULL){
            out[strlen(out)-2]='\n';
            out[strlen(out)-1]=NULL;
         }
         fputs(out,fh);
         len=len+(strlen(menutemp->name)*8)+12;
         menutemp=menutemp->nextmenu;
      }
      strcpy(out,"};\n");
      fputs(out,fh);
      fclose(fh);
      toksavemenus(fname);
   }
}

int getwidth(struct mmenu *men)
{
   struct mitem *temp;
   int currlen=0,commlen=0,ncommlen=0;
   
   temp=men->firstitem;
   while(temp!=NULL){
      currlen=(strlen(temp->name)*8)+5;
      if(temp->flags & CHECKIT)
         currlen+=CHECKWIDTH;
      if(temp->commseq!=0){
         currlen=currlen+COMMWIDTH+10;
         if(currlen>commlen)
            commlen=currlen;
      }
      else
         if(currlen>ncommlen)
            ncommlen=currlen;
      temp=temp->nextitem;
   }
   if(ncommlen>commlen)
      return(ncommlen);
   else
      return(commlen);
}

void domengaddn(struct IntuiMessage *m)
{
   struct Gadget *g;
   USHORT id;
   
   g=(struct Gadget *)m->IAddress;
   id=g->GadgetID;
   switch(id){
      case 5:menup(); break;
      case 6:mendn(); break;
      case 7:menlt(); break;
      case 8:menrt(); break;
      case 20:currentitem->flags^=CHECKIT; break;
      case 21:currentitem->flags^=CHECKED; break;
      case 22:currentitem->flags^=MENUTOGGLE; break;
      case 23:currentitem->flags^=ITEMENABLED; break;
      case 24:currentitem->flags^=HIGHCOMP; break;
      case 25:currentitem->flags^=HIGHBOX; break;   
      case 26:currentitem->flags^=HIGHIMAGE2; break;     
      case 27:currentitem->flags^=HIGHNONE2; break;
   }
}
   
BOOL domengadup(struct IntuiMessage *m)
{
   struct Gadget *g;
   USHORT id;
   int num;
   
   g=(struct Gadget *)m->IAddress;
   id=g->GadgetID;
   switch(id){
      case 1:insmenu(); break;
      case 2:insitem(); break;
      case 3:mensave(); break; 
      case 4:
         entsubgad.GadgetText=&entsubtxt[0];
         ongad(&mennamegad,menwin);
         ongad(&addsubmengad,menwin);
         ongad(&addmengad,menwin);
         ongad(&remmengad,menwin);
         insub=FALSE;
         return(TRUE);
         break;
      case 9:nameitem(); break;
      case 10:namemenu(); break;
      case 11:docommseq(); break;
      case 30:doremmen(); break;
      case 31:doremitem(); break;
      case 32:
         if(currentitem->sub==NULL)
            doaddsub();
         else
            doremsub();
         break;
      case 33:tokloadmenus();break;
      case 34:
         RemoveGList(menwin,&marrowgads[0],-1);
         num=getyesno(&reqtext[2],mentit);
         AddGList(menwin,&marrowgads[0],0,-1,NULL);
         if(num) mennew();break;
      case 35:entsub();break;
   }
   return(FALSE);
}

void doaddsub(void)
{
   struct mmenu *new;
   struct mitem *new2;
   
   new=(struct mmenu *)AllocMem(sizeof(struct mmenu),0);
   new->noitems=1;
   new->width=5;
   strcpy(new->name,"");
   new->nextmenu=NULL;
   new->lastmenu=currentmenu;
   currentitem->sub=new;
   new2=(struct mitem *)AllocMem(sizeof(struct mitem),0);
   new2->commseq=0;
   new2->flags=ITEMENABLED|HIGHCOMP;
   new2->nextitem=NULL;
   new2->lastitem=NULL;
   new2->sub=NULL;
   new->firstitem=new2;
   strcpy(new2->name,"");
   printext(menwin,"»",40,(10*itnum)+40,1,4);
   addsubmengad.GadgetText=&mentext[5];
   RefreshGList(&addsubmengad,menwin,NULL,1);
}

void doremsub(void)
{
   remallitems(currentitem->sub);
   FreeMem((struct mmenu *)currentitem->sub,sizeof(struct mmenu));
   currentitem->sub=NULL;
   printext(menwin," ",40,(10*itnum)+40,1,4);
   addsubmengad.GadgetText=&mentext[2];
   RefreshGList(&addsubmengad,menwin,NULL,1);
}

void entsub(void)
{
   if(!insub){
      if(currentitem->sub!=NULL){
         printext(menwin,empty,50,28,1,4);
         printext(menwin,currentitem->name,50,28,1,4);
         currentmenu=currentitem->sub;
         currentitem=currentmenu->firstitem;
         drawmenu(currentmenu);
         itnum=0;
         dogadsrefresh();
         insub=TRUE;
         entsubgad.GadgetText=&entsubtxt[1];
         RefreshGList(&entsubgad,menwin,NULL,1);
         offgad(&mennamegad,menwin);
         offgad(&addsubmengad,menwin);
         offgad(&addmengad,menwin);
         offgad(&remmengad,menwin);
      }
   }
   else{
      insub=FALSE;
      onmengads();
      movemenu(1);
   }
}

void offgad(struct Gadget *g,struct Window *w)
{
   if(!(g->Flags & GADGDISABLED)){
      g->Flags^=GADGDISABLED;
      RefreshGList(g,w,NULL,1);
   }
}

void ongad(struct Gadget *g,struct Window *w)
{
   if(g->Flags & GADGDISABLED){
      g->Flags^=GADGDISABLED;
      RefreshGList(g,w,NULL,1);
   }
}

void doremmen(void)
{
   struct mmenu *menutemp,*next,*last;
   char tmp[10];
   
   if(mennum!=1){
      menutemp=currentmenu;
      last=menutemp->lastmenu;
      next=menutemp->nextmenu;
      if(currentmenu->nextmenu!=NULL)
         movemenu(0);
      else{
         movemenu(1);
         mnum--;
         sprintf(tmp,"%.2d",mnum);
         printext(menwin,tmp,508,25,1,4);
      }
      if(last!=NULL)
         last->nextmenu=next;
      if(next!=NULL)
         next->lastmenu=last;
      remallitems(menutemp);
      FreeMem((struct mmenu *)menutemp,sizeof(struct mmenu));
      mennum--;
      sprintf(tmp,"%.2d",mennum);
      printext(menwin,tmp,476,10,1,4);
   }
}

void remallitems(struct mmenu *men)
{
   struct mitem *itemtemp,*temp;
   
   itemtemp=men->firstitem;
   while(itemtemp!=NULL){
      temp=itemtemp->nextitem;
      if(itemtemp->sub!=NULL){
         remallitems(itemtemp->sub);
         FreeMem((struct mmenu *)itemtemp->sub,sizeof(struct mmenu));
      }
      FreeMem((struct mitem *)itemtemp,sizeof(struct mitem));
      itemtemp=temp;
   }
}

void doremitem(void)
{
   struct mitem *temp,*next,*last;
   register int i;
   int len;
   
   if(currentmenu->noitems!=1){
      if(currentitem->sub!=NULL)
         doremsub();
      temp=currentitem;
      last=temp->lastitem;
      next=temp->nextitem;
      if(next==NULL)
         menup();
      else{
         currentitem=next;
         dogadsrefresh();
      }
      if(last!=NULL)
         last->nextitem=next;
      else
         currentmenu->firstitem=next;
      FreeMem((struct mitem *)temp,sizeof(struct mitem));
      if(next!=NULL)
         next->lastitem=last;
      drawbox(4);
      len=cwidth();
      if(len<currentmenu->width){
         currentmenu->width=len;
         printext(menwin,empty,50,(10*itnum)+40,1,4);
      }
      temp=currentitem;
      for(i=itnum;temp!=NULL;i++){
         if(i==itnum)
            domentext(menwin,temp->name,50,(10*i)+40,4,1);
         else
            domentext(menwin,temp->name,50,(10*i)+40,1,4);
         if(temp->sub!=NULL){
            printext(menwin,"»",40,(10*i)+40,1,4);
            printext(menwin," ",40,(10*(i+1))+40,1,4);
         }
         temp=temp->nextitem;
      }
      domentext(menwin,empty,50,(10*i)+40,1,4);
      currentmenu->noitems--;
      drawbox(1);
   }
}

void menrt(void)
{
   char tmp[5];
   
   if(currentmenu->nextmenu!=NULL){
      movemenu(0);
      mnum++;
      sprintf(tmp,"%.2d",mnum);
      printext(menwin,tmp,508,25,1,4);
   }
}

void menlt(void)
{
   char tmp[5];
   
   if(currentmenu->lastmenu!=NULL){
      if(insub){
         insub=FALSE;
         onmengads();
      }
      else{
         mnum--;
         sprintf(tmp,"%.2d",mnum);
         printext(menwin,tmp,508,25,1,4);
      }
      movemenu(1);
   }
}

void drawmenu(struct mmenu *men)
{
   struct mitem *temp;
   register int i;
   
   SetAPen(menwin->RPort,4);
   RectFill(menwin->RPort,40,38,342,242);
   temp=men->firstitem;
   for(i=0;temp!=NULL;i++){
      if(i==0)
         domentext(menwin,temp->name,50,40,4,1);
      else
         printext(menwin,temp->name,50,(10*i)+40,1,4);
      if(temp->sub!=NULL)
         printext(menwin,"»",40,(10*i)+40,1,4);
      temp=temp->nextitem;
   }
   drawbox(1);
}

void movemenu(int flg)
{
   SetAPen(menwin->RPort,4);
   RectFill(menwin->RPort,40,38,342,242);
   if(flg==0)
      currentmenu=currentmenu->nextmenu;
   else
      currentmenu=currentmenu->lastmenu;
   drawmenu(currentmenu);
   currentitem=currentmenu->firstitem;
   printext(menwin,empty,50,28,1,4);
   printext(menwin,currentmenu->name,50,28,1,4);
   strcpy(mennamebuff,currentmenu->name);
   itnum=0;
   RefreshGList(&mennamegad,menwin,NULL,1);
   dogadsrefresh();
}

void docommseq(void)
{
   if(strlen(commseqbuff)>0)
      currentitem->commseq=commseqbuff[0];
}

void insmenu(void)
{
   char tmp[10];
   struct mmenu *new,*temp;
   struct mitem *new2;
   
   if((!insub)&&(mennum<99)){
      mennum++;
      new=(struct mmenu *)AllocMem(sizeof(struct mmenu),0);
      new->noitems=1;
      new->width=5;
      new->nextmenu=NULL;
      strcpy(new->name,"");
      temp=currentmenu;
      while(temp->nextmenu!=NULL)
         temp=temp->nextmenu;
      temp->nextmenu=new;
      new->lastmenu=temp;
      new2=(struct mitem *)AllocMem(sizeof(struct mitem),0);
      new2->commseq=0;
      new2->flags=ITEMENABLED|HIGHCOMP;
      new2->nextitem=NULL;
      new2->lastitem=NULL;
      new2->sub=NULL;
      new->firstitem=new2;
      strcpy(new2->name,"");
      sprintf(tmp,"%.2d",mennum);
      printext(menwin,tmp,476,10,1,4);
   }
}

void insitem(void)
{
   struct mitem *new,*temp;
   
   if(currentmenu->noitems<20){
      drawbox(4);
      currentmenu->noitems++;
      drawbox(1);
      new=(struct mitem *)AllocMem(sizeof(struct mitem),0);
      new->commseq=0;
      new->flags=ITEMENABLED|HIGHCOMP;
      new->nextitem=NULL;
      new->sub=NULL;
      strcpy(new->name,"");
      temp=currentitem;
      while(temp->nextitem!=NULL)
         temp=temp->nextitem;
      temp->nextitem=new;
      new->lastitem=temp;
   }
}

void drawbox(int c)
{
   SetAPen(menwin->RPort,c);
   Move(menwin->RPort,48,38);
   Draw(menwin->RPort,48+(8*currentmenu->width)+4,38);
   Draw(menwin->RPort,48+(8*currentmenu->width)+4,38+(10*currentmenu->noitems)+3);
   Draw(menwin->RPort,48,38+(10*currentmenu->noitems)+3);
   Draw(menwin->RPort,48,38);
}

int cwidth(void)
{
   struct mitem *temp;
   int len=5;
   
   temp=currentmenu->firstitem;
   while(temp!=NULL){
      if(strlen(temp->name)>len)
         len=strlen(temp->name);
      temp=temp->nextitem;
   }
   return(len);
}

void nameitem(void)
{
   int len;
   
   strcpy(currentitem->name,itnamebuff);
   if(strlen(itnamebuff)<currentmenu->width){
      len=cwidth();
      if(len<currentmenu->width){
         drawbox(4);
         printext(menwin,empty,50,(10*itnum)+40,1,4);
         currentmenu->width=len;
         drawbox(1);
      }
   }
   else
      if(strlen(itnamebuff)>currentmenu->width){
         drawbox(4);
         currentmenu->width=strlen(itnamebuff);
         drawbox(1);
      }
   domentext(menwin,currentitem->name,50,(10*itnum)+40,4,1);
}

void domentext(struct Window *wn,char *str,int x,int y,int f,int b)
{
   register int j;
   char obuf[40];
   
   strcpy(obuf,str);
   for(j=strlen(obuf);j<currentmenu->width;j++)
      obuf[j]=' ';
   obuf[currentmenu->width]=NULL;
   SetAPen(wn->RPort,f);
   SetBPen(wn->RPort,b);
   Move(wn->RPort,x,y+6);
   Text(wn->RPort,obuf,strlen(obuf));
}

void namemenu(void)
{
   strcpy(currentmenu->name,mennamebuff);
   printext(menwin,empty,50,28,1,4);
   printext(menwin,currentmenu->name,50,28,1,4);
}

void menup(void)
{
   if(currentitem->lastitem!=NULL){
      domentext(menwin,currentitem->name,50,(10*itnum)+40,1,4);
      currentitem=currentitem->lastitem;
      itnum--;
      domentext(menwin,currentitem->name,50,(10*itnum)+40,4,1);
      dogadsrefresh();
   }
}

void checkflags(USHORT flg,int i)
{
   if(currentitem->flags & flg){
      if(mflagsgads[i].Flags!=(GADGHCOMP|SELECTED)){
         mflagsgads[i].Flags=(GADGHCOMP|SELECTED);
         RefreshGList(&mflagsgads[i],menwin,NULL,1);
      }
   }
   else{
      if(mflagsgads[i].Flags!=GADGHCOMP){
         mflagsgads[i].Flags=GADGHCOMP;
         RefreshGList(&mflagsgads[i],menwin,NULL,1);
      }
   }
}

void dogadsrefresh(void)
{
   strcpy(itnamebuff,currentitem->name);
   commseqbuff[0]=currentitem->commseq;
   commseqbuff[1]=NULL;
   checkflags(CHECKIT,0);
   checkflags(CHECKED,1);
   checkflags(MENUTOGGLE,2);
   checkflags(ITEMENABLED,3);
   checkflags(HIGHCOMP,4);
   checkflags(HIGHBOX,5);
   checkflags(HIGHIMAGE2,6);
   checkflags(HIGHNONE2,7);
   if((currentitem->sub!=NULL)&&(addsubmengad.GadgetText==&mentext[2])){
      addsubmengad.GadgetText=&mentext[5];
      RefreshGList(&addsubmengad,menwin,NULL,1);
   }
   else
   if((currentitem->sub==NULL)&&(addsubmengad.GadgetText==&mentext[5])){
      addsubmengad.GadgetText=&mentext[2];
      RefreshGList(&addsubmengad,menwin,NULL,1);
   }
   RefreshGList(&itnamegad,menwin,NULL,1);
   RefreshGList(&commseqgad,menwin,NULL,1);
}

void mendn(void)
{
   if(currentitem->nextitem!=NULL){
      domentext(menwin,currentitem->name,50,(10*itnum)+40,1,4);
      currentitem=currentitem->nextitem;
      itnum++;
      domentext(menwin,currentitem->name,50,(10*itnum)+40,4,1);
      dogadsrefresh();
   }
}

void openmenwin(void)
{
   char tmp[10];
   
   if(!(menwin = OpenWindow(&menuwindow)))
      cleanexit(RETURN_FAIL);
   SetWindowTitles(menwin,NULL,mentit);
   mnum=1;
   printextb(menwin,"Number Of Menus-",348,10,1);
   sprintf(tmp,"%.2d",mennum);
   printext(menwin,tmp,476,10,1,4);
   printextb(menwin,"Current Menu Number-",348,25,1);
   sprintf(tmp,"%.2d",mnum);
   printext(menwin,tmp,508,25,1,4);
   printextb(menwin,"Menu Name-",348,40,1);
   printextb(menwin,"Item Name-",348,55,1);
   printextb(menwin,"Flags-",348,70,1);
   printextb(menwin,"Commseq-",348,115,1);
   itnum=0;
   if(currentmenu==NULL){
      currentmenu=(struct mmenu *)AllocMem(sizeof(struct mmenu),0);
      currentmenu->noitems=1;
      currentmenu->width=5;
      currentmenu->nextmenu=NULL;
      strcpy(currentmenu->name,"");
      currentmenu->lastmenu=NULL;
      currentitem=(struct mitem *)AllocMem(sizeof(struct mitem),0);
      currentitem->commseq=0;
      currentitem->flags=ITEMENABLED|HIGHCOMP;
      currentitem->nextitem=NULL;
      currentitem->lastitem=NULL;
      currentitem->sub=NULL;
      currentmenu->firstitem=currentitem;
   }
   else{
      while(currentmenu->lastmenu!=NULL)
         currentmenu=currentmenu->lastmenu;
      currentitem=currentmenu->firstitem;
      printext(menwin,currentmenu->name,50,28,1,4);
      strcpy(mennamebuff,currentmenu->name);
      RefreshGList(&mennamegad,menwin,NULL,1);
      dogadsrefresh();
   }
   drawmenu(currentmenu);
}

void makescreen(void)
{
   ULONG signalmask, signals;
   struct IntuiMessage *message;
   BOOL done=FALSE;
   
   opensgadwin();
   do{
      signalmask = 1L << swin->UserPort->mp_SigBit;
      signals = Wait(signalmask);
      if (signals & signalmask){
         while(message = (struct Intuimessage *)GetMsg(swin->UserPort))
         {
            switch(message->Class){
               case GADGETUP:
                  done=dosgadup(message);
                  break;
            } 
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   CloseWindow(swin);
   swin=NULL;
}

BOOL dosgadup(struct IntuiMessage *m)
{
   struct Gadget *g;
   USHORT id;
   
   g=(struct Gadget *)m->IAddress;
   id=g->GadgetID;
   switch(id){
      case 1: return(TRUE);break;
      case 2: ssave();break;
      case 3: 
         if(vmgads[1].Flags & SELECTED)
            strcpy(sheightbuff,"512");
         else
            strcpy(sheightbuff,"256");
         RefreshGList(&sheightgad,swin,NULL,1);
         break;
   }
   return(FALSE);
}


void opensgadwin(void)
{
   if(!(swin = OpenWindow(&sgadswindow)))
      cleanexit(RETURN_FAIL);
   SetWindowTitles(swin,NULL,stit);
   printextb(swin,"TopEdge-",10,5,1);
   printextb(swin,"Height-",10,20,1);
   printextb(swin,"Depth-",10,35,1);
   printextb(swin,"Title-",10,95,1);
   printextb(swin,"DetailPen-",10,50,1);
   printextb(swin,"BlockPen-",154,50,1);
   printextb(swin,"ViewModes-",10,65,1);
   printextb(swin,"Types-",10,80,1);
}

void makewindow(void)
{
   ULONG signalmask, signals;
   struct IntuiMessage *message;
   BOOL done=FALSE;
   
   opengadwin();
   do{
      signalmask = 1L << gwin->UserPort->mp_SigBit;
      signals = Wait(signalmask);
      if (signals & signalmask){
         while(message = (struct Intuimessage *)GetMsg(gwin->UserPort))
         {
            switch(message->Class){
               case GADGETUP:
                  done=dogadup(message);
                  break;
            } 
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   CloseWindow(gwin);
   gwin=NULL;
}

void opengadwin(void)
{
   if(!(gwin = OpenWindow(&gadwindow)))
      cleanexit(RETURN_FAIL);
   SetWindowTitles(gwin,NULL,wtit);
   printextb(gwin,"IDCMP Flags-",10,5,1);
   printextb(gwin,"Flags-",10,65,1);
   printextb(gwin,"Type-",10,115,1);
   printextb(gwin,"Title-",10,135,1);
   printextb(gwin,"DetailPen-",10,150,1);
   printextb(gwin,"BlockPen-",154,150,1);
   printextb(gwin,"MinWidth-",10,165,1);
   printextb(gwin,"MinHeight-",154,165,1);
   printextb(gwin,"MaxWidth-",298,165,1);
   printextb(gwin,"MaxHeight-",434,165,1);
}

int getvmode(void)
{
   ULONG signalmask, signals;
   struct IntuiMessage *message;
   BOOL done=FALSE;
   int ret;
   struct Gadget *g;

   if(!(vmwin = OpenWindow(&sw)))
      cleanexit(RETURN_FAIL);
   SetWindowTitles(vmwin,NULL,wtit);
   printext(vmwin,"Screen Format",42,5,1,4);
   do{
      signalmask = 1L << vmwin->UserPort->mp_SigBit;
      signals = Wait(signalmask);
      if (signals & signalmask){
         while(message = (struct Intuimessage *)GetMsg(vmwin->UserPort))
         {
            if(message->Class==GADGETUP){
               g=(struct Gadget *)message->IAddress;
               ret=g->GadgetID;
               if((ret>=0)&&(ret<=3))
                  done=TRUE;
            } 
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   CloseWindow(vmwin);
   vmwin=NULL;
   return(ret);
}

void sizewindow(void)
{
   ULONG signalmask1,signalmask2,signals;
   struct IntuiMessage *message;
   BOOL done=FALSE;
   int num;
   
   RemoveGList(gwin,&idcmpgads[0],-1);
   num=getvmode();
   switch(num){
      case 0:
         sscreen.Width=320;
         backwindow.Width=320;
         sscreen.Height=256;
         sscreen.ViewModes=NULL;
         break;
      case 1:
         sscreen.Width=640;
         backwindow.Width=640;
         sscreen.Height=256;
         sscreen.ViewModes=HIRES;
         break;
      case 2:
         sscreen.Width=320;
         backwindow.Width=320;
         sscreen.Height=512;
         sscreen.ViewModes=LACE;
         break;
      case 3:
         sscreen.Width=640;
         backwindow.Width=640;
         sscreen.Height=512;
         sscreen.ViewModes=HIRES|LACE;
         break;
   }
   screen2 = OpenScreen(&sscreen);
   ShowTitle(screen2,FALSE);
   if (!screen2)
      cleanexit(RETURN_FAIL);
   if(lastvm!=num){
      newwindow.Width=100;
      newwindow.LeftEdge=10;
      newwindow.Height=100;
      newwindow.TopEdge=70;
      textwindow.LeftEdge=10;
      textwindow.TopEdge=10;
      lastvm=num;
   }
   newwindow.Flags=WINDOWDRAG|WINDOWSIZING|NOCAREREFRESH|RMBTRAP|ACTIVATE;
   if(flagsgads[1].Flags & SELECTED)
      newwindow.Flags^=WINDOWDEPTH;
   if(flagsgads[2].Flags & SELECTED)
      newwindow.Flags^=WINDOWCLOSE;
   newwindow.Screen=screen2;
   textwindow.Screen=screen2;
   backwindow.Screen=screen2;
   if(!(win=OpenWindow(&newwindow)))
      cleanexit(RETURN_FAIL);
   if(!(twin=OpenWindow(&textwindow)))
      cleanexit(RETURN_FAIL);
   if(!(bwin=OpenWindow(&backwindow)))
      cleanexit(RETURN_FAIL);
   setsizes();
   showsize();
   do{
      signalmask1 = 1L << win->UserPort->mp_SigBit;
      signalmask2 = 1L << twin->UserPort->mp_SigBit;
      signals = Wait(signalmask1|signalmask2);
      if (signals & signalmask1){
         while(message = (struct Intuimessage *)GetMsg(win->UserPort))
         {
            switch(message->Class){
               case INTUITICKS:
                  checkpos();
                  break;
               case NEWSIZE:
                  showsize();
                  break;
            } 
            ReplyMsg((struct Message *)message);
         }
      }
      if (signals & signalmask2){
         while(message = (struct Intuimessage *)GetMsg(twin->UserPort))
         {
            if(message->Class==CLOSEWINDOW)
                  done=TRUE;
            ReplyMsg((struct Message *)message);
         }
      }
   }while(!done);
   newwindow.LeftEdge=win->LeftEdge;
   newwindow.TopEdge=win->TopEdge;
   newwindow.Height=win->Height;
   newwindow.Width=win->Width;
   textwindow.LeftEdge=twin->LeftEdge;
   textwindow.TopEdge=twin->TopEdge;
   CloseWindow(win);
   win=NULL;
   CloseWindow(twin);
   twin=NULL;
   CloseWindow(bwin);
   bwin=NULL;
   CloseScreen(screen2);
   screen2=NULL;
   AddGList(gwin,&idcmpgads[0],0,-1,NULL);
}

void save(void)
{
   char out[16][255],fname[255];
   FILE *fh=NULL;
   register int i,j;
   int error;
   char null[20]="   NULL,\n";
   
   RemoveGList(gwin,&idcmpgads[0],-1);
   error=filereq(fname,savemess,wtit);
   AddGList(gwin,&idcmpgads[0],0,-1,NULL);
   if(!error)
      fh=fopen(fname,"w");
   if (fh!=NULL){
      sprintf(out[0],"struct NewWindow nw =\n");
      sprintf(out[1],"{\n");
      sprintf(out[2],"   %d,%d,\n",newwindow.LeftEdge,newwindow.TopEdge);
      sprintf(out[3],"   %d,%d,\n",newwindow.Width,newwindow.Height);
      if(strlen(detailbuff)==0)
         strcpy(detailbuff,"4");
      if(strlen(blockbuff)==0)
         strcpy(blockbuff,"1");
      sprintf(out[4],"   %s,%s,\n",detailbuff,blockbuff);
      sprintf(out[5],"   ");
      for(i=0,j=3;i<22;i++)
         if(idcmpgads[i].Flags!=GADGHCOMP){
            if((j+strlen(idcmptxt[i].IText))>70){
               strcat(out[5],"\n   ");
               j=3;
            }
            j=j+strlen(idcmptxt[i].IText)+1;
            strcat(out[5],idcmptxt[i].IText);
            strcat(out[5],"|");
         }
      if(strlen(out[5])==3)
         strcat(out[5],"NULL,\n");
      else{
         out[5][strlen(out[5])-1]=',';
         strcat(out[5],"\n"); 
      }
      sprintf(out[6],"   ");
      for(i=0,j=3;i<14;i++)
         if(flagsgads[i].Flags!=GADGHCOMP){
            if((j+strlen(flagstxt[i].IText))>70){
               strcat(out[6],"\n   ");
               j=3;
            }
            j=j+strlen(flagstxt[i].IText)+1;
            strcat(out[6],flagstxt[i].IText);
            strcat(out[6],"|");
         }
      if(strlen(out[6])==3)
         strcat(out[6],"NULL,\n");
      else{
         out[6][strlen(out[6])-1]=',';
         strcat(out[6],"\n");
      }
      strcpy(out[7],null);
      strcpy(out[8],null);
      if(strlen(titlebuff)>0)
         sprintf(out[9],"   \"%s\",\n",titlebuff);
      else
         strcpy(out[9],null);
      strcpy(out[10],null);
      strcpy(out[11],null);
      if(strlen(minwidthbuff)==0)
         strcpy(minwidthbuff,"0");
      if(strlen(minheightbuff)==0)
         strcpy(minheightbuff,"0");
      if(strlen(maxwidthbuff)==0)
         strcpy(maxwidthbuff,"0xFFFF");
      if(strlen(maxheightbuff)==0)
         strcpy(maxheightbuff,"0xFFFF");
      sprintf(out[12],"   %s,%s,\n",minwidthbuff,minheightbuff);
      sprintf(out[13],"   %s,%s,\n",maxwidthbuff,maxheightbuff);
      if(typegad.Flags!=GADGHCOMP)
         sprintf(out[14],"   CUSTOMSCREEN\n");
      else
         sprintf(out[14],"   WBENCHSCREEN\n");
      sprintf(out[15],"};\n");
      for(i=0;i<16;i++)
         fputs(out[i],fh);
      fclose(fh);
   }
}

void ssave(void)
{
   char out[13][255],fname[255];
   FILE *fh=NULL;
   register int i;
   int error;
   char *null="   NULL,\n";
   
   strcpy(out[0],"struct NewScreen ns =\n");
   strcpy(out[1],"{\n");
   sprintf(out[2],"   0,%s,\n",stopbuff);
   strcpy(out[3],"   ");
   if(vmgads[0].Flags!=GADGHCOMP)
      strcat(out[3],"640,");
   else
      strcat(out[3],"320,");
   strcat(out[3],sheightbuff);
   strcat(out[3],",\n");
   if(strlen(sdepthbuff)>0)
      strcpy(sdepthbuff,"2");
   sprintf(out[4],"   %s,\n",sdepthbuff);
   sprintf(out[5],"   %s,%s,\n",sdetailbuff,sblockbuff);
   sprintf(out[6],"   ");
   for(i=0;i<6;i++)
      if(vmgads[i].Flags!=GADGHCOMP){
         strcat(out[6],vmtxt[i].IText);
         strcat(out[6],"|");
      }
   if(strlen(out[6])==3)
      strcat(out[6],"NULL,\n");
   else{
      out[6][strlen(out[6])-1]=',';
      strcat(out[6],"\n"); 
   }
   sprintf(out[7],"   ");
   for(i=0;i<4;i++)
      if(stypegads[i].Flags!=GADGHCOMP){
         strcat(out[7],stypetxt[i].IText);
         strcat(out[7],"|");
      }
   if(strlen(out[7])==3)
      strcat(out[7],"NULL,\n");
   else{
      out[7][strlen(out[7])-1]=',';
      strcat(out[7],"\n");
   }
   strcpy(out[8],null);
   if(strlen(stitlebuff)>0)
      sprintf(out[9],"   \"%s\",\n",stitlebuff);
   else
      strcpy(out[9],null);
   strcpy(out[10],null);
   strcpy(out[11],null);
   sprintf(out[12],"};\n");
   RemoveGList(swin,&stitlegad,-1);
   error=filereq(fname,savemess,stit);
   AddGList(swin,&stitlegad,0,-1,NULL);
   if(!error)
      fh=fopen(fname,"w");
   if (fh!=NULL){
      for(i=0;i<13;i++)
         fputs(out[i],fh);
      fclose(fh);
   }
}

BOOL dogadup(struct IntuiMessage *m)
{
   struct Gadget *g;
   USHORT id;
   
   g=(struct Gadget *)m->IAddress;
   id=g->GadgetID;
   if(id==2)
      return(TRUE);
   if(id==3)
      sizewindow();
   if(id==1)
      save();
   return(FALSE);
}

void setsizes(void)
{
   char obuf[90];
   
   printextb(twin,"LeftEdge -",5,11,1);
   printextb(twin,"TopEdge  -",5,19,1);
   printextb(twin,"Width    -",5,27,1);
   printextb(twin,"Height   -",5,35,1);
   sprintf(obuf,"%3.d",win->LeftEdge);
   printext(twin,obuf,88,11,1,4);
   sprintf(obuf,"%3.d",win->TopEdge);
   printext(twin,obuf,88,19,1,4);
}

void checkpos(void)
{
   static int oldleft,oldtop;
   char obuf[90];
   
   if(win->LeftEdge!=oldleft){
      oldleft=win->LeftEdge;
      sprintf(obuf,"%3.d",oldleft);
      printext(twin,obuf,88,11,1,4);
   }
   if(win->TopEdge!=oldtop){
      oldtop=win->TopEdge;
      sprintf(obuf,"%3.d",oldtop);
      printext(twin,obuf,88,19,1,4);
   }
}

void showsize(void)
{
   char obuf[90];
   
   sprintf(obuf,"%3.d",win->Width);
   printext(twin,obuf,88,27,1,4);
   sprintf(obuf,"%3.d",win->Height);
   printext(twin,obuf,88,35,1,4);
}

void printext(struct Window *wn,char *str,int x,int y,int f,int b)
{
   showval.FrontPen=f;
   showval.BackPen=b;
   showval.IText=str;
   PrintIText(wn->RPort,&showval, x, y);
}

void printextb(struct Window *wn,char *str,int x,int y,int f)
{
   showval.DrawMode=JAM1;
   showval.FrontPen=2;
   showval.IText=str;
   PrintIText(wn->RPort,&showval,x+1,y+1);
   showval.FrontPen=f;
   showval.IText=str;
   PrintIText(wn->RPort,&showval,x,y);
   showval.DrawMode=JAM2;
}

void openall(void)
{
   if(!(IntuitionBase=(struct Intuition *)
         OpenLibrary("intuition.library",33)))
      cleanexit(RETURN_FAIL);
   if(!(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",33)))
      cleanexit(RETURN_WARN);
   screen1 = OpenScreen(&fullhires);
   if (!screen1)
      cleanexit(RETURN_FAIL);
   gadwindow.Screen=screen1;
   nw.Screen=screen1;
   mainwindow.Screen=screen1;
   sgadswindow.Screen=screen1;
   menuwindow.Screen=screen1;
   rw.Screen=screen1;
   sw.Screen=screen1;
   if(!(mwin=OpenWindow(&mainwindow)))
      cleanexit(RETURN_FAIL);
   mproc=(struct Process *)FindTask(NULL);
   savewindow=(APTR *)mproc->pr_WindowPtr;
   mproc->pr_WindowPtr=(APTR)mwin;
}

void cleanexit(LONG n)
{
   (APTR *)mproc->pr_WindowPtr = savewindow;
   if(currentmenu)
      clearmenus();
   if(swin) CloseWindow(swin);
   if(menwin) CloseWindow(menwin);
   if(mwin) CloseWindow(mwin);
   if(win) CloseWindow(win);
   if(twin) CloseWindow(twin);
   if(gwin) CloseWindow(gwin);
   if(bwin) CloseWindow(bwin);
   if(screen1) CloseScreen(screen1);
   if(screen2) CloseScreen(screen2);
   if(GfxBase) CloseLibrary((struct Library *)GfxBase);
   if(IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
   exit(n);
}

int filereq(char *filename,char *mess,char *tit)
{
   struct IntuiMessage *msg = NULL;
   ULONG class;
   int error=1;
   
   names=(struct filestruct *)AllocMem(sizeof(struct filestruct)*200,0);
   nw.Title=mess;
   if(!(reqwin=OpenWindow(&nw)))
      cleanexit(RETURN_WARN);
   SetWindowTitles(reqwin,mess,tit);
   numentries=0;
   RefreshGList(&vertslider,reqwin,NULL,-1);
   printext2("Dirs:  0 Files:  0 Total:  0",34,117,1,4);
   loadfiles();
   initslider(&vertslider);
   while(error>0){
      Wait(1L << reqwin->UserPort->mp_SigBit);
      while(msg=(struct IntuiMessage *)GetMsg(reqwin->UserPort)){
         class=msg->Class;
         switch(class){
            case INTUITICKS:
               if(arrowgads[0].Flags&SELECTED)
                  while(arrowgads[0].Flags&SELECTED)
                     getslider(&vertslider,-1);
               if(vertslider.Flags&SELECTED) getslider(&vertslider,0);
               if(arrowgads[1].Flags&SELECTED)
                  while(arrowgads[1].Flags&SELECTED)
                     getslider(&vertslider,1);
               break;
            case GADGETUP:
               error=handleugad(msg);
               break;
         }
         ReplyMsg((struct Message *)msg);
      }
   }
   if(reqwin) CloseWindow(reqwin);
   strcpy(filename,namegadsibuff);
   FreeMem((struct filestruct *)names,sizeof(struct filestruct)*200);   
   return(error);
}

void loadfiles(void)
{
   int err=0;
   char wild[10]="#?";
   struct FILEINFO store;
   struct FILEINFO *info=NULL;
   register int i=0,dcnt=0,fcnt=0;
   char obuf[40];
   
   sprintf(names[0].name,"/");
   names[0].isdir=TRUE;
   info=&store;
   if(!(err=dfind(info,wild,1))){
      while((!err)&&(i<199)){
         i++;
         strcpy(names[i].name,info->fib_FileName);
         names[i].size=info->fib_Size;
         if(info->fib_DirEntryType>0){
            names[i].isdir=TRUE;
            dcnt++;
         }
         else{
            names[i].isdir=FALSE;
            fcnt++;
         }
         err=dnext(info);
      }
      sprintf(obuf,"Dirs:%3.d Files:%3.d Total:%3.d",dcnt,fcnt,i);
      printext2(obuf,34,117,1,4);
      numentries=i+1;
   }
}

int handleugad(struct IntuiMessage *m)
{
   struct Gadget *g;
   USHORT id;
   int retval=1;
   USHORT entry;
   
   g=(struct Gadget *)m->IAddress;
   id=g->GadgetID;
   switch(id){
      case 1:
         entry=topentry+((m->MouseY-g->TopEdge +1)/9);
         if(entry<numentries){
            if(names[entry].isdir)
               newdir(entry);
            else{
               strcpy(namegadsibuff,names[entry].name);
               RefreshGList(&namegad,reqwin,NULL,1);
            }
         }
         break;
      case 2:
         getslider(&vertslider,0);
         break;
      case 5:
         dostrgad();
         break;
      case 6:
         retval=0;
         break;
      case 7:
         retval=-1;
         break;
   }
   return(retval);
}

void initslider(struct Gadget *g)
{
   topentry=0;
   if(numentries>10)
   {
      NewModifyProp(g,reqwin,NULL,AUTOKNOB|FREEVERT,
         NULL,((MAXBODY*topentry)/(numentries)),
         MAXBODY,((MAXBODY*10)/numentries),1L);
   }
   else
   {
      NewModifyProp(g,reqwin,NULL,AUTOKNOB|FREEVERT,
         NULL,NULL,MAXBODY,MAXBODY,1L);
   }
   RefreshGList(&backdrop,reqwin,NULL,1);
   displayentries();
}

void getslider(struct Gadget *g,int dir)
{
   USHORT potv;
   struct PropInfo *p;
   static USHORT update=0;
   
   p=(struct PropInfo *)g->SpecialInfo;
   if(dir!=0)
   {
      topentry+=dir;
      if(topentry>0 && topentry<(numentries-10))
      {
         potv=((MAXBODY*topentry)/(numentries-10));
         update=0;
      }
      else
      {
         if(topentry>=(numentries-10))
         {
            potv=MAXBODY;
            topentry=(numentries-10);
            update++;
         }
         if(topentry<=0)
         {
            potv=0;
            topentry=0;
            update++;
         }
      }
      if(numentries>10 && update<3)
      {
         NewModifyProp(g,reqwin,NULL,AUTOKNOB|FREEVERT,
            NULL,potv,MAXBODY,
            ((MAXBODY*10)/numentries-10),1L);
      }
   }
   else
   {
      if(numentries>10)
         topentry=(p->VertPot*(numentries-10))/MAXBODY;
      else
         topentry=0;
   }
   displayentries();
}

void displayentries(void)
{
   UBYTE msg[40],msg2[15];
   register USHORT i;
   register USHORT j;
   int start=0;
   
   if(topentry==0){
      sprintf(msg,"%.25s","/(Parent)");
      for(j=strlen(msg);j<33;j++)
         msg[j]=' ';
      msg[33]=NULL;
      printext2(msg,7,(USHORT)(entrybox.TopEdge),3,2);
      start=1;
   }
   for(i=start;(i<10 && i<numentries);i++){
      sprintf(msg,"%.25s",names[i+topentry].name);
      for(j=strlen(msg);j<26;j++)
         msg[j]=' ';
      msg[26]=NULL;
      if(names[i+topentry].isdir){
         sprintf(msg2,"%7s","");
         strcat(msg,msg2);
         printext2(msg,7,(USHORT)(entrybox.TopEdge+(i*9)),3,2);
      }
      else{
         sprintf(msg2,"%7d",names[i+topentry].size);
         strcat(msg,msg2);
         printext2(msg,7,(USHORT)(entrybox.TopEdge+(i*9)),1,2);
      }
   }
   SetBPen(reqwin->RPort,0);
}

void newdir(int index)
{
   int error;
   
   error=chdir(names[index].name);
   if(!error){
      loadfiles();
      displayentries();
      initslider(&vertslider);
   }
}

void dostrgad(void)
{
   UBYTE path[255];
   UBYTE node[108];
   
   stcgfn(node,namegadsibuff);
   stcgfp(path,namegadsibuff);
   if(!chdir(namegadsibuff)){
      loadfiles();
      displayentries();
      initslider(&vertslider);
      sprintf(namegadsibuff,"");
      RefreshGList(&namegad,reqwin,NULL,1);
   }
   else
   if((!chdir(path))&&(strlen(namegadsibuff)>0)){
      loadfiles();
      displayentries();
      initslider(&vertslider);
      strcpy(namegadsibuff,node);
      RefreshGList(&namegad,reqwin,NULL,1);
   }
}
         
void printext2(UBYTE *msg,LONG x,LONG y,USHORT f, USHORT b)
{
   SetAPen(reqwin->RPort,f);
   SetBPen(reqwin->RPort,b);
   Move(reqwin->RPort,x,y+6);
   Text(reqwin->RPort,msg,strlen(msg));
}
      


