/* Auf id's ändern !! */

#define ASL_V38_NAMES_ONLY
#define KOSTSTRING "%5d %8d %5d %7d"
#define KOSTSTRING_OHNEANZ "      %8d %5d %7d"
#define FIRSTCOL_STRING "%6d"
#define FREQ 0

#include "structs.h"
#include "Designer2.h"
#include "Designer2.c"
#include "ListviewLists.c"
#include <libraries/asl.h>
#include <clib/asl_protos.h>
#include <clib/exec_protos.h>

#define MAXDESIGNS 50

struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;
struct Library *GadToolsBase;
struct Library *AslBase;

struct FileRequester *request;

struct ship designs[MAXDESIGNS][5];
struct ship design =
{
  -1, "", 
  -1, 
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 
  -1,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0
};

struct ship emptydesign =
{
  -1, "", -1, 
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 
  -1,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0
};

struct ship sparedesign =
{
  -1, "", -1, 
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 
  -1,
  -1, 0,
  -1, 0,
  -1, 0,
  -1, 0
};

char jumpcosts[30];
char compcosts[30];
char priwpcosts[30];
char secwpcosts[30];
char terwpcosts[30];
char untercosts[30];
char senscosts[30];
char normalcosts[30];
char hullcosts[30];
char sgcosts[30];
char cargocosts[30];
char repcosts[30];
char labcosts[30];
char jumprange[4];
char mr[12];  
char shieldstrength[10];
char troops[10];
char cargonum[10];
char d2tanz[10];
char d7tanz[10];
char d11tanz[10];
char fighteranz[10];
char pdrate[10];
char comb[10];
int val1, val2, shieldstr, designok=0, designclass;
float moverate, size, shiptonage, pds;
BOOL res, ok;
char dirname[256], filename[256];
FILE *desfile;
int desnum=0, i, j;

int openlibs()
{
  if (GfxBase = (struct GfxBase *)OpenLibrary((UBYTE*)"graphics.library", 0)) 
  {
    if (IntuitionBase = (struct IntuitionBase *)OpenLibrary((UBYTE*)"intuition.library", 0))
    {
      if (GadToolsBase = OpenLibrary((UBYTE*)"gadtools.library", 37))
      {
        if (AslBase=OpenLibrary((UBYTE *)AslName, 38L))
        {
          return 1;
        }
        else
        {
          printf("Cannot open asl.library Version 38.\n");
          return 0;
        }
      }
      else
      {
        printf("Cannot open gadtools.library.\n");
        return 0;
      }
    }
    else
    {
      printf("Cannot open intuition.library!!!!????\n");
      return 0;
    }
  }
  else
  {
    printf("Cannot open graphics.library!!!!????\n");
    return 0;
  }
}

closelibs()
{
  if (AslBase) CloseLibrary(AslBase);
  if (GadToolsBase) CloseLibrary(GadToolsBase);
  if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  if (GfxBase) CloseLibrary((struct Library *)GfxBase);
}

LoadDesigns (char dirname[256])
{

  desfile=fopen(dirname, "r");
  if (desfile) {
    i=0; j=0;
    while (!feof(desfile)&&(i<MAXDESIGNS))
    {
      fread(&design, sizeof(struct ship), 1, desfile);
      memcpy(&(designs[i][j++]), &design, sizeof(struct ship));
      
      if (j==5)
      {
        j=0; i++;
      }
    }
    for (i; i<MAXDESIGNS; i++)
      for (j=0; j<5; j++)
      {
        designs[i][j]=emptydesign;
        designs[i][j].class=i;
      }
    fclose(desfile);
    if (designclass!=-1)
    {
      design.class=designclass;
      memcpy( &design, &(designs[design.class][desnum]), sizeof(struct ship));
    }
  }
  else
  {
    fprintf(stderr,"ERROR: File not found.\n");
    abort();
  }
}

desload(int reqornot)
{
  if (reqornot)  {
    res=AslRequestTags(request,   ASLFR_PositiveText, "Load",
                                  ASLFR_DoSaveMode, FALSE,
                                  TAG_DONE);
  
    if (res)
      if (request->fr_File)
      {
        strcpy(dirname, (char *)request->fr_Drawer);
        strcpy(filename, (char *)request->fr_File);
      
        designclass=design.class;
        ok=AddPart((UBYTE *)dirname, (UBYTE *)filename, 256);
        LoadDesigns(dirname);
      }
  }
  else 
        LoadDesigns("designs.snh");
  
}

StringRequest(char *retval)
{
  struct IntuiMessage *im;
  short notDone = 1;
 
  StrReqLeft=(SNII1Wnd->Width-StrReqWidth)/2;
  StrReqTop=(SNII1Wnd->Height-StrReqHeight)/2;
  OpenStrReqWindow();
  
  while (notDone) {
    ActivateGadget(StrReqGadgets[GDX_TEXT], StrReqWnd, NULL);
    WaitPort(StrReqWnd->UserPort);
    while (im = GT_GetIMsg(StrReqWnd->UserPort)) {
      switch(im->Class) {
        case IDCMP_REFRESHWINDOW:
          GT_BeginRefresh(SNII1Wnd);
          GT_EndRefresh(SNII1Wnd, TRUE);
          break;
        case IDCMP_GADGETUP:
          switch(((struct Gadget *)im->IAddress)->GadgetID) 
          {
          case GD_TEXT:
            strcpy(retval, 
                 (char *)((struct StringInfo *)(StrReqGadgets[GDX_TEXT]->SpecialInfo))->Buffer);
            notDone=0;
            break;
          default:
            break;
          }
          break;
        default:
	  break;
      }
      GT_ReplyIMsg(im);
    }
  }
  CloseStrReqWindow();
}

ListIntRequest(int *val1, int *val2, struct List *liste)
{
  struct IntuiMessage *im;
  short notDone = 1;
 
  ListIntReqLeft=(SNII1Wnd->Width-ListIntReqWidth)/2;
  ListIntReqTop=(SNII1Wnd->Height-ListIntReqHeight)/2;
  OpenListIntReqWindow();
  
  GT_SetGadgetAttrs(ListIntReqGadgets[GDX_LIST], ListIntReqWnd, NULL, GTLV_Labels, liste, TAG_END);
  while (notDone) {
    WaitPort(ListIntReqWnd->UserPort);
    while (im = GT_GetIMsg(ListIntReqWnd->UserPort)) {
      switch(im->Class) {
        case IDCMP_REFRESHWINDOW:
          GT_BeginRefresh(ListIntReqWnd);
          GT_EndRefresh(ListIntReqWnd, TRUE);
          break;
        case IDCMP_GADGETUP:
          switch(((struct Gadget *)im->IAddress)->GadgetID) 
          {
          case GD_LIST:
            *val1=im->Code;
            ActivateGadget(ListIntReqGadgets[GDX_ANZ], ListIntReqWnd, NULL);
            break;
          case GD_ANZ:
            *val2=((struct StringInfo *)(ListIntReqGadgets[GDX_ANZ]->SpecialInfo))->LongInt;
            notDone=0;
            break;
          default:
            break;
          }
          break;
        default:
	  break;
      }
      GT_ReplyIMsg(im);
    }
  }
  GT_SetGadgetAttrs(ListIntReqGadgets[GDX_LIST], ListIntReqWnd, NULL, GTLV_Labels, NULL, TAG_END);
  CloseListIntReqWindow();
}

ListRequest(int *val1, struct List *liste)
{
  struct IntuiMessage *im;
  short notDone = 1;
 
  ListReqLeft=(SNII1Wnd->Width-ListReqWidth)/2;
  ListReqTop=(SNII1Wnd->Height-ListReqHeight)/2;
  OpenListReqWindow();
  
  GT_SetGadgetAttrs(ListReqGadgets[GDX_LIST], ListReqWnd, NULL, GTLV_Labels, liste, TAG_END);
  while (notDone) {
    WaitPort(ListReqWnd->UserPort);
    while (im = GT_GetIMsg(ListReqWnd->UserPort)) {
      switch(im->Class) {
        case IDCMP_REFRESHWINDOW:
          GT_BeginRefresh(ListReqWnd);
          GT_EndRefresh(ListReqWnd, TRUE);
          break;
        case IDCMP_GADGETUP:
          switch(((struct Gadget *)im->IAddress)->GadgetID) 
          {
          case GD_LIST:
            *val1=im->Code;
            notDone=0;
            break;
          default:
            break;
          }
          break;
        default:
	  break;
      }
      GT_ReplyIMsg(im);
    }
  }
  GT_SetGadgetAttrs(ListReqGadgets[GDX_LIST], ListReqWnd, NULL, GTLV_Labels, NULL, TAG_END);
  CloseListReqWindow();
}

disablegadgets()
{
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_JUMP], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_DESNAME], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_HULL], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_NORMAL], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_PRIWP], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_SEKWP], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_TERWP], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_SG], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMP], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_SENS], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_UNTER], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_FRACHT], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_REP], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_LAB], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);

  GT_SetGadgetAttrs(SNII1Gadgets[GDX_DESNUM], SNII1Wnd, NULL, GA_Disabled, TRUE, TAG_END);
}

enablegadgets()
{
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_JUMP], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_DESNAME], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_HULL], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_NORMAL], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_PRIWP], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_SEKWP], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_TERWP], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_SG], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMP], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_SENS], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_UNTER], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_FRACHT], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_REP], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
  GT_SetGadgetAttrs(SNII1Gadgets[GDX_LAB], SNII1Wnd, NULL, GA_Disabled, FALSE, TAG_END);
}

Kosten()
{
  int iep=0, mcr=0, tmp1, tmp2;
  int d2tflag=0, d7tflag=0, d11tflag=0, jflag=0, pdflag=0;
  char allcosts[30];
  
  designok=1;
  pds=0;
  
  if (design.class!=-1)
  {
    GT_SetGadgetAttrs(SNII1Gadgets[GDX_DESNAMEOUT], SNII1Wnd, NULL,
                                GTTX_Text, design.desname, 
                                TAG_END);
    GT_SetGadgetAttrs(SNII1Gadgets[GDX_CLASSOUT], SNII1Wnd, NULL, GTTX_Text, classarray[design.class], TAG_END);
    if (design.hull>-1) 
    {
      if (strcmp(shipclasses[design.class].abr,"SF"))
      {
      iep+=(shipclasses[design.class].tonage/500)*(components[design.hull].iep);
      mcr+=(shipclasses[design.class].tonage/500)*(components[design.hull].mcr);
      tmp1=shipclasses[design.class].tonage/(5*components[design.hull].iep*100);
      sprintf(hullcosts, KOSTSTRING, tmp1, 
                       100*tmp1*components[design.hull].iep,
                       tmp1*components[design.hull].iep,
                       tmp1*components[design.hull].mcr);
      }
      else
      {
      iep+=(shipclasses[design.class].tonage/1000)*(components[design.hull].iep);
      mcr+=(shipclasses[design.class].tonage/1000)*(components[design.hull].mcr);
      tmp1=shipclasses[design.class].tonage/(10*components[design.hull].iep*100);
      sprintf(hullcosts, KOSTSTRING, tmp1, 
                       100*tmp1*components[design.hull].iep,
                       tmp1*components[design.hull].iep,
                       tmp1*components[design.hull].mcr);
      }
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_HULLANZ], SNII1Wnd, NULL,
                           GTTX_Text, hullcosts, 
                           TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_HUELLOUT], SNII1Wnd, NULL, 
                           GTTX_Text, components[design.hull].name, 
                           TAG_END);
    }
    else
    {
      designok=0;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_HUELLOUT], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_HULLANZ], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
    }
    if (design.jump>-1) 
    {
      iep+=design.jumpanz*(components[design.jump].iep);
      mcr+=design.jumpanz*(components[design.jump].mcr);
      sprintf(jumpcosts, KOSTSTRING, design.jumpanz, 
                         100*design.jumpanz*components[design.jump].iep,
                         design.jumpanz*components[design.jump].iep,
                         design.jumpanz*components[design.jump].mcr);
      sprintf(jumprange, FIRSTCOL_STRING, (design.jumpanz*components[design.jump].extra)/(shipclasses[design.class].tonage));
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_JUMPANZ], SNII1Wnd, NULL,
                             GTTX_Text, jumpcosts, 
                             TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_JUMPRANGE], SNII1Wnd, NULL,
                             GTTX_Text, jumprange, 
                             TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SPRUNGOUT], SNII1Wnd, NULL,
                             GTTX_Text, components[design.jump].name, 
                             TAG_END);
      if (shipclasses[design.class].sb<
           ((components[design.jump].iep*10000*design.jumpanz)
             /shipclasses[design.class].tonage))
       designok=0;
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SPRUNGOUT], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_JUMPANZ], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_JUMPRANGE], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
    }
    if (design.normal>-1) 
    {
      iep+=design.normalanz*(components[design.normal].iep);
      mcr+=design.normalanz*(components[design.normal].mcr);
      if (shipclasses[design.class].rmax==0) designok=0;
      if (shipclasses[design.class].rmin>
           ((components[design.normal].iep*10000*design.normalanz)
             /shipclasses[design.class].tonage))
        designok=0;
      sprintf(normalcosts, KOSTSTRING, design.normalanz, 
                         100*design.normalanz*components[design.normal].iep,
                         design.normalanz*components[design.normal].iep,
                         design.normalanz*components[design.normal].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_RUECKOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.normal].name, 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_NORMALANZ], SNII1Wnd, NULL,
                                  GTTX_Text, normalcosts, 
                                  TAG_END);
      size=design.normalanz*components[design.normal].extra;
      shiptonage=shipclasses[design.class].tonage;
      moverate=size/shiptonage;
      sprintf(mr, "%11.8f", moverate);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_MR], SNII1Wnd, NULL,
                                  GTTX_Text, mr, 
                                  TAG_END);
    }
    else
    {
      if (shipclasses[design.class].rmax!=0) designok=0;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_RUECKOUT], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_NORMALANZ], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_MR], SNII1Wnd, NULL, GTTX_Text, "", TAG_END);
    }
    if (design.priwp>-1) 
    {
      iep+=design.priwpanz*(components[design.priwp].iep);
      mcr+=design.priwpanz*(components[design.priwp].mcr);
      sprintf(priwpcosts, KOSTSTRING, design.priwpanz, 
                         100*design.priwpanz*components[design.priwp].iep,
                         design.priwpanz*components[design.priwp].iep,
                         design.priwpanz*components[design.priwp].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_PRIWPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.priwp].name, 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_PRIWPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, priwpcosts, 
                                  TAG_END);
      if (!strcmp(components[design.priwp].abr, "D2T"))
      {
        sprintf(d2tanz, FIRSTCOL_STRING, design.priwpanz*components[design.priwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESI], SNII1Wnd, NULL,
                                  GTTX_Text, d2tanz, 
                                  TAG_END);
        d2tflag=1;
      }
    
      if (!strcmp(components[design.priwp].abr, "D7T"))
      {
        sprintf(d7tanz, FIRSTCOL_STRING, design.priwpanz*components[design.priwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESII], SNII1Wnd, NULL,
                                  GTTX_Text, d7tanz, 
                                  TAG_END);
        d7tflag=1;
      }

      if (!strcmp(components[design.priwp].abr, "D11T"))
      {
        sprintf(d11tanz, FIRSTCOL_STRING, design.priwpanz*components[design.priwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESIII], SNII1Wnd, NULL,
                                  GTTX_Text, d11tanz, 
                                  TAG_END);
        d11tflag=1;
      }
              
      if (!strcmp(components[design.priwp].abr, "RJD"))
      {
        sprintf(fighteranz, FIRSTCOL_STRING, design.priwpanz*components[design.priwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_FIGHTER], SNII1Wnd, NULL,
                                  GTTX_Text, fighteranz, 
                                  TAG_END);
        jflag=1;
      }

      if (!strncmp(components[design.priwp].abr, "NV", 2))
      {
        pds=design.priwpanz*200*components[design.priwp].iep;
        pds=pds/shipclasses[design.class].tonage;
        sprintf(pdrate, "%6.2f", pds);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_PDRATE], SNII1Wnd, NULL,
                                  GTTX_Text, pdrate, 
                                  TAG_END);
        if (pds>0.2) pds=0.2;
        sprintf(pdrate, "%6.2f", pds*design.priwpanz);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_KILLSHOT], SNII1Wnd, NULL,
                                  GTTX_Text, pdrate, 
                                  TAG_END);
        pdflag=1;
      }
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_PRIWPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_PRIWPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }    
    if (design.secwp>-1) 
    {
      iep+=design.secwpanz*(components[design.secwp].iep);
      mcr+=design.secwpanz*(components[design.secwp].mcr);
      sprintf(secwpcosts, KOSTSTRING, design.secwpanz, 
                         100*design.secwpanz*components[design.secwp].iep,
                         design.secwpanz*components[design.secwp].iep,
                         design.secwpanz*components[design.secwp].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SECWPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.secwp].name, 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SEKWPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, secwpcosts, 
                                  TAG_END);
      if (!strcmp(components[design.secwp].abr, "D2T"))
      {
        sprintf(d2tanz, FIRSTCOL_STRING, design.secwpanz*components[design.secwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESI], SNII1Wnd, NULL,
                                  GTTX_Text, d2tanz, 
                                  TAG_END);
          d2tflag=1;
      }
  
      if (!strcmp(components[design.secwp].abr, "D7T"))
      {
        sprintf(d7tanz, FIRSTCOL_STRING, design.secwpanz*components[design.secwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESII], SNII1Wnd, NULL,
                                  GTTX_Text, d7tanz, 
                                  TAG_END);
        d7tflag=1;
      }
    
      if (!strcmp(components[design.secwp].abr, "D11T"))
      {
        sprintf(d11tanz, FIRSTCOL_STRING, design.secwpanz*components[design.secwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESIII], SNII1Wnd, NULL,
                                  GTTX_Text, d11tanz, 
                                  TAG_END);
        d11tflag=1;
      }
                                  
      if (!strcmp(components[design.secwp].abr, "RJD"))
      {
        sprintf(fighteranz, FIRSTCOL_STRING, design.secwpanz*components[design.secwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_FIGHTER], SNII1Wnd, NULL,
                                  GTTX_Text, fighteranz, 
                                  TAG_END);
        jflag=1;
      }
      if (!strncmp(components[design.secwp].abr, "NV", 2))
      {
        pds=design.secwpanz*200*components[design.secwp].iep;
        pds=pds/shipclasses[design.class].tonage;
        sprintf(pdrate, "%6.2f", pds);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_PDRATE], SNII1Wnd, NULL,
                                  GTTX_Text, pdrate, 
                                  TAG_END);
        if (pds>0.2) pds=0.2;
        sprintf(pdrate, "%6.2f", pds*design.secwpanz);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_KILLSHOT], SNII1Wnd, NULL,
                                  GTTX_Text, pdrate, 
                                  TAG_END);
        pdflag=1;
      }
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SECWPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SEKWPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }    
    if (design.terwp>-1) 
    {
      iep+=design.terwpanz*(components[design.terwp].iep);
      mcr+=design.terwpanz*(components[design.terwp].mcr);
      sprintf(terwpcosts, KOSTSTRING, design.terwpanz, 
                         100*design.terwpanz*components[design.terwp].iep,
                         design.terwpanz*components[design.terwp].iep,
                         design.terwpanz*components[design.terwp].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_TERWPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.terwp].name, 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_TERWPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, terwpcosts, 
                                  TAG_END);
      if (!strcmp(components[design.terwp].abr, "D2T"))
      {
        sprintf(d2tanz, FIRSTCOL_STRING, design.terwpanz*components[design.terwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESI], SNII1Wnd, NULL,
                                  GTTX_Text, d2tanz, 
                                  TAG_END);
        d2tflag=1;
      }
  
      if (!strcmp(components[design.terwp].abr, "D7T"))
      {
        sprintf(d7tanz, FIRSTCOL_STRING, design.terwpanz*components[design.terwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESII], SNII1Wnd, NULL,
                                  GTTX_Text, d7tanz, 
                                  TAG_END);
        d7tflag=1;
      }
    
      if (!strcmp(components[design.terwp].abr, "D11T"))
      {
        sprintf(d11tanz, FIRSTCOL_STRING, design.terwpanz*components[design.terwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESIII], SNII1Wnd, NULL,
                                  GTTX_Text, d11tanz, 
                                  TAG_END);
        d11tflag=1;
      }
      if (!strcmp(components[design.terwp].abr, "RJD"))
      {
        sprintf(fighteranz, FIRSTCOL_STRING, design.terwpanz*components[design.terwp].extra);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_FIGHTER], SNII1Wnd, NULL,
                                  GTTX_Text, fighteranz, 
                                  TAG_END);
        jflag=1;
      }
      if (!strncmp(components[design.terwp].abr, "NV", 2))
      {
        pds=design.terwpanz*200*components[design.terwp].iep;
        pds=pds/shipclasses[design.class].tonage;
        sprintf(pdrate, "%6.2f", pds);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_PDRATE], SNII1Wnd, NULL,
                                  GTTX_Text, pdrate, 
                                  TAG_END);
        if (pds>0.2) pds=0.2;
        sprintf(pdrate, "%6.2f", pds*design.terwpanz);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_KILLSHOT], SNII1Wnd, NULL,
                                  GTTX_Text, pdrate, 
                                  TAG_END);
        pdflag=1;
      }
  }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_TERWPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_TERWPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }    
    if (design.shield>-1) 
    {
      iep+=design.shieldanz*(components[design.shield].iep);
      mcr+=design.shieldanz*(components[design.shield].mcr);
      sprintf(sgcosts, KOSTSTRING, design.shieldanz, 
                         100*design.shieldanz*components[design.shield].iep,
                         design.shieldanz*components[design.shield].iep,
                         design.shieldanz*components[design.shield].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SGDOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.shield].name, 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SGANZ], SNII1Wnd, NULL,
                                  GTTX_Text, sgcosts, 
                                  TAG_END);
      shieldstr=design.shieldanz*components[design.shield].extra;
      sprintf(shieldstrength, "%8d", shieldstr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SHILDSTR], SNII1Wnd, NULL,
                                  GTTX_Text, shieldstrength, 
                                  TAG_END);
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SGDOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SGANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SHILDSTR], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (design.fracht>-1) 
    {
      iep+=design.frachtanz*(components[design.fracht].iep);
      mcr+=design.frachtanz*(components[design.fracht].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_FROUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.fracht].name, 
                                  TAG_END);
      sprintf(cargocosts, KOSTSTRING, design.frachtanz, 
                         100*design.frachtanz*components[design.fracht].iep,
                         design.frachtanz*components[design.fracht].iep,
                         design.frachtanz*components[design.fracht].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_FRACHTANZ], SNII1Wnd, NULL,
                                  GTTX_Text, cargocosts, 
                                  TAG_END);
      sprintf(cargonum, FIRSTCOL_STRING, design.frachtanz);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_CARGO], SNII1Wnd, NULL,
                                  GTTX_Text, cargonum, 
                                  TAG_END);
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_FROUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_FRACHTANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_CARGO], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (design.comp>-1) 
    {
      iep+=components[design.comp].iep;
      mcr+=components[design.comp].mcr;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.comp].name, 
                                  TAG_END);
      sprintf(compcosts, KOSTSTRING, 1, 
                         100*components[design.comp].iep,
                         components[design.comp].iep,
                         components[design.comp].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, compcosts, 
                                  TAG_END);
    }
    else
    {
      designok=0;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (design.sens>-1) 
    {
      iep+=components[design.sens].iep;
      mcr+=components[design.sens].mcr;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SENSOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.sens].name, 
                                  TAG_END);
      sprintf(senscosts, KOSTSTRING, 1, 
                         100*components[design.sens].iep,
                         components[design.sens].iep,
                         components[design.sens].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SENSANZ], SNII1Wnd, NULL,
                                  GTTX_Text, senscosts, 
                                  TAG_END);
    }
    else
    {
      designok=0;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SENSOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_SENSANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (design.unter>-1) 
    {
      iep+=design.unteranz*(components[design.unter].iep);
      mcr+=design.unteranz*(components[design.unter].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_UNOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.unter].name, 
                                  TAG_END);
      sprintf(untercosts, KOSTSTRING, design.unteranz, 
                         100*design.unteranz*components[design.unter].iep,
                         design.unteranz*components[design.unter].iep,
                         design.unteranz*components[design.unter].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_UNTERANZ], SNII1Wnd, NULL,
                                  GTTX_Text, untercosts, 
                                  TAG_END);
      shieldstr=design.unteranz*components[design.unter].extra;
      sprintf(troops, FIRSTCOL_STRING, shieldstr);
      if (strncmp(components[design.unter].abr, "TR", 2))
      {
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_TROOPS], SNII1Wnd, NULL,
                                  GTTX_Text, troops, 
                                  TAG_END);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_COLONISTS], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      }
      else
      {
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_COLONISTS], SNII1Wnd, NULL,
                                  GTTX_Text, troops, 
                                  TAG_END);
        GT_SetGadgetAttrs(SNII1Gadgets[GDX_TROOPS], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      }
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_UNOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_UNTERANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_TROOPS], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_COLONISTS], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (design.rep>-1) 
    {
      iep+=design.repanz*(components[design.rep].iep);
      mcr+=design.repanz*(components[design.rep].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_REPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.rep].name, 
                                  TAG_END);
      sprintf(repcosts, KOSTSTRING, design.repanz, 
                         100*design.repanz*components[design.rep].iep,
                         design.repanz*components[design.rep].iep,
                         design.repanz*components[design.rep].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_REPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, repcosts, 
                                  TAG_END);
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_REPOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_REPANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (design.lab>-1) 
    {
      iep+=design.labanz*components[design.lab].iep;
      mcr+=design.labanz*components[design.lab].mcr;
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_LABOUT], SNII1Wnd, NULL,
                                  GTTX_Text, components[design.lab].name, 
                                  TAG_END);
      sprintf(labcosts, KOSTSTRING, design.labanz, 
                         100*design.labanz*components[design.lab].iep,
                         design.labanz*components[design.lab].iep,
                         design.labanz*components[design.lab].mcr);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_LABANZ], SNII1Wnd, NULL,
                                  GTTX_Text, labcosts, 
                                  TAG_END);
    }
    else
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_LABOUT], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_LABANZ], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);
    }
    if (!d2tflag) GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESI], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);

    if (!d7tflag) GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESII], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);

    if (!d11tflag) GT_SetGadgetAttrs(SNII1Gadgets[GDX_DRONESIII], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);

    if (!jflag) GT_SetGadgetAttrs(SNII1Gadgets[GDX_FIGHTER], SNII1Wnd, NULL,
                                  GTTX_Text, "", 
                                  TAG_END);

    if (!pdflag)
    {
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_PDRATE], SNII1Wnd, NULL,
                                  GTTX_Text, "    0", 
                                  TAG_END);
      GT_SetGadgetAttrs(SNII1Gadgets[GDX_KILLSHOT], SNII1Wnd, NULL,
                                  GTTX_Text, "    0", 
                                  TAG_END);
    }

    sprintf(allcosts, KOSTSTRING_OHNEANZ, 100*iep, iep, mcr);
    GT_SetGadgetAttrs(SNII1Gadgets[GDX_GESAMT], SNII1Wnd, NULL,
                         GTTX_Text, allcosts, 
                         TAG_END);

    sprintf(comb, FIRSTCOL_STRING, components[design.comp].extra+components[design.sens].extra);
    GT_SetGadgetAttrs(SNII1Gadgets[GDX_COMB], SNII1Wnd, NULL,
                                GTTX_Text, comb, 
                                TAG_END);
    if ((100*iep)>shipclasses[design.class].tonage) designok=0;
    if (!designok) 
      OffMenu(SNII1Wnd, 2<<4);
    else
      OnMenu(SNII1Wnd, 2<<4);
  }
}

main()
{
  struct IntuiMessage *im;
  short notDone = 1;
  USHORT selection, flags;
  ULONG menuNum, itemNum, subNum;
  struct List tmplist;
  struct List classlist;

  for (i=0; i<MAXDESIGNS; i++)
    for (j=0; j<5; j++)
    {
      memcpy(&(designs[i][j]), &emptydesign, sizeof(struct ship));
      designs[i][j].class=i;
    }

  if(!openlibs()) _abort();

  initscanner();
  load("Definitions");
  freescanner(); 

  NewList(&tmplist);
  NewList(&classlist);
  initclassarray();
  CreateList(&classlist, classarray);
  SetupScreen();
  OpenSNII1Window();
  SNII1Render();
  disablegadgets();
  OffMenu(SNII1Wnd, 2<<4);
  request=AllocAslRequestTags(ASL_FileRequest, 
                                ASLFR_TitleText, "Choose a Designfile ...",
                                ASLFR_Window, SNII1Wnd,
                                ASLFR_Screen, Scr,
                                ASLFR_SleepWindow, TRUE,
                                ASLFR_RejectIcons, TRUE,
                                ASLFR_InitialPattern, "#?.snh",
                                ASLFR_InitialFile, "Designs.snh",
                                TAG_DONE);

  if (!request) 
  {
    fprintf(stderr, "Cannot allocate Requester.\n");
    _abort();
  }
  desload(FREQ);
  GT_RefreshWindow(SNII1Wnd, NULL);
  while (notDone) {
    WaitPort(SNII1Wnd->UserPort);
    while (im = GT_GetIMsg(SNII1Wnd->UserPort)) {
      switch(im->Class) {
        case IDCMP_CLOSEWINDOW:
          notDone = 0;
          break;
        case IDCMP_REFRESHWINDOW:
          GT_BeginRefresh(SNII1Wnd);
          SNII1Render();
          GT_EndRefresh(SNII1Wnd, TRUE);
          break;
        case IDCMP_MENUPICK:
          selection=im->Code;
          while(selection!=MENUNULL)
          {
            menuNum = MENUNUM(selection);
            itemNum = ITEMNUM(selection);
            subNum  = SUBNUM (selection);
            switch(menuNum)
            {
              case 0: /* Project Menu */
                switch(itemNum)
                {
                  case 0: /* Load */
                    desload(FREQ);
                    break;
                  case 1: /* Save */
                    res=AslRequestTags(request, 
                                ASLFR_PositiveText, "Save",
                                ASLFR_DoSaveMode, TRUE,
                                TAG_DONE);
                    if (res)
                    {
                      if (request->fr_File)
                      {
                        strcpy(dirname, (char *)request->fr_Drawer);
                        strcpy(filename, (char *)request->fr_File);
                      
                        ok=AddPart((UBYTE *)dirname, (UBYTE *)filename, 256);
                        memcpy(&(designs[design.class][desnum]), &design, sizeof(struct ship));
                        desfile=fopen(filename, "w");
                        for (i=0; i<MAXDESIGNS; i++)
                          for (j=0; j<5; j++)
                            fwrite(&(designs[i][j]), sizeof(struct ship), 1, desfile);
                        fclose(desfile);
                      }
                    }
                    break;
                  case 2: /* Save As ASCII */
                    res=AslRequestTags(request, 
                                ASLFR_PositiveText, "Save",
                                ASLFR_InitialPattern, "#?.ascii",
                                ASLFR_InitialFile, "Designs.ascii",
                                ASLFR_DoSaveMode, TRUE,
                                TAG_DONE);
                    if (res)
                    {
                      if (request->fr_File)
                      {
                        int flag, flag1;

                        strcpy(dirname, (char *)request->fr_Drawer);
                        strcpy(filename, (char *)request->fr_File);
                      
                        ok=AddPart((UBYTE *)dirname, (UBYTE *)filename, 256);
                        memcpy(&(designs[design.class][desnum]), &design, sizeof(struct ship));
                        desfile=fopen(filename, "w");
                        for (i=0; i<MAXDESIGNS; i++)
                        {
                          flag=1; flag1=0;
                          for (j=0; j<5; j++)
                          {
                            if ((designs[i][j].hull>-1)&&(flag))
                            {
                              fprintf(desfile, "CLASS %s {\n", shipclasses[designs[i][0].class].abr);
                              flag1=1; flag=0;
                            }
                            if (designs[i][j].hull>-1)
                            {
                              fprintf(desfile, "  SHIP #%1d \"%s\"\n  {\n", 
                                               j+1,
                                               designs[i][j].desname);
                              fprintf(desfile, "    HULL   : %s\n",
                                              components[designs[i][j].hull].abr);
                              if (designs[i][j].jumpanz>0)
                                fprintf(desfile, "    JUMP   : %s %d\n",
                                              components[designs[i][j].jump].abr,
                                              designs[i][j].jumpanz);
                              if (designs[i][j].normalanz>0)
                                fprintf(desfile, "    ENG    : %s %d\n",
                                              components[designs[i][j].normal].abr,
                                              designs[i][j].normalanz);
                              if (designs[i][j].priwpanz>0)
                                fprintf(desfile, "    PriWP  : %s %d\n",
                                              components[designs[i][j].priwp].abr,
                                              designs[i][j].priwpanz);
                              if (designs[i][j].secwpanz>0)
                                fprintf(desfile, "    SecWP  : %s %d\n",
                                              components[designs[i][j].secwp].abr,
                                              designs[i][j].secwpanz);
                              if (designs[i][j].terwpanz>0)
                                fprintf(desfile, "    TerWP  : %s %d\n",
                                              components[designs[i][j].terwp].abr,
                                              designs[i][j].terwpanz);
                              if (designs[i][j].shieldanz>0)
                                fprintf(desfile, "    SHIELD : %s %d\n",
                                              components[designs[i][j].shield].abr,
                                              designs[i][j].shieldanz);
                              fprintf(desfile, "    COMP   : %s\n",
                                              components[designs[i][j].comp].abr);
                              fprintf(desfile, "    SENS   : %s\n",
                                              components[designs[i][j].sens].abr);
                              if (designs[i][j].unteranz>0)
                                fprintf(desfile, "    BAYS   : %s %d\n",
                                              components[designs[i][j].unter].abr,
                                              designs[i][j].unteranz);
                              if (designs[i][j].frachtanz>0)
                                fprintf(desfile, "    FR     : %s %d\n",
                                              components[designs[i][j].fracht].abr,
                                              designs[i][j].frachtanz);
                              if (designs[i][j].repanz>0)
                                fprintf(desfile, "    SPECIAL: %s %d\n",
                                              components[designs[i][j].rep].abr,
                                              designs[i][j].repanz);
                              if (designs[i][j].labanz>0)
                                fprintf(desfile, "    LABS   : %s %d\n",
                                              components[designs[i][j].lab].abr,
                                              designs[i][j].labanz);
                              fprintf(desfile, "  }\n\n");
                            }
                          }
                          if (flag1)
                          {
                            fprintf(desfile, "}\n\n");
                            flag1=0;
                          }
                        }
			fclose(desfile);
                      }
                    }
                    break;
                  case 4: /* Quit */
                    notDone=0;
                    break;
                  default:
                    break;
                }
                break;
              case 1: /* Utility Menu */
                switch (itemNum)
                {
                  case 0: /* Copy */
                    memcpy(&sparedesign, &design, sizeof(struct ship));                    
                    break;
                  case 1: /* Paste */
                    designclass=design.class;
                    memcpy(&design, &sparedesign, sizeof(struct ship));                    
                    design.class=designclass;
                    break;
                  case 2: /* Clear */
                    designclass=design.class;
                    memcpy(&design, &emptydesign, sizeof(struct ship));                    
                    design.class=designclass;
                    break;
                }
                break;
              default:
                break;
            }
            selection=((struct MenuItem *)ItemAddress(SNII1Menus, (LONG)selection))->NextSelect;
          }
          break;
        case IDCMP_GADGETUP:
          switch(((struct Gadget *)im->IAddress)->GadgetID)
          {
            case GD_CLASS:
              if (designok)
                memcpy(&(designs[design.class][desnum]), &design, sizeof(struct ship));
              else
              {
                designclass=design.class;
                memcpy(&design, &emptydesign, sizeof(struct ship));
                if (designclass!=-1)
                {
                  design.class=designclass;
                  memcpy(&(designs[design.class][desnum]), &design, sizeof(struct ship));
                }
              }
              ListRequest(&val1, &classlist);
              memcpy(&design, &(designs[val1][desnum]), sizeof(struct ship));
              enablegadgets();
              break;
            case GD_DESNUM: break;
            case GD_DESNUMCYCLE:      
              if (designok)
                memcpy(&(designs[design.class][desnum]), &design, sizeof(struct ship));
              else
              {
                designclass=design.class;
                memcpy(&design, &emptydesign, sizeof(struct ship));
                if (designclass!=-1)
                {
                  design.class=designclass;
                  memcpy(&(designs[design.class][desnum]), &design, sizeof(struct ship));
                }
              }
              desnum=(int)((struct Gadget *)im->Code);
/*              GT_SetGadgetAttrs(SNII1Gadgets[GDX_DESNUMCYCLE], SNII1Wnd, NULL,
                                GTCY_Active, desnum, 
                                TAG_END);                              
*/
              if (design.class!=-1)
                memcpy(&design, &(designs[design.class][desnum]), sizeof(struct ship));
              break;
            case GD_DESNAME:
              StringRequest(design.desname);
              GT_SetGadgetAttrs(SNII1Gadgets[GDX_DESNAMEOUT], SNII1Wnd, NULL,
                                GTTX_Text, design.desname, 
                                TAG_END);
              break;
            case GD_HULL:
              initcomparray("H");
              CreateList(&tmplist, comparray);
              ListRequest(&val1, &tmplist);
              design.hull=referenz[val1];
              break;
            case GD_JUMP:
              initcomparray("ST");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.jump=referenz[val1];
                design.jumpanz=val2;
              }
              else
              {
                design.jump=-1;
                design.jumpanz=0;
              }
              break;
            case GD_NORMAL:
              initcomparray("RT");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.normal=referenz[val1];
                design.normalanz=val2;
              }
              else
              {
                design.normal=-1;
                design.normalanz=0;
              }
              break;
            case GD_PRIWP:
              initwparray();
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.priwp=referenz[val1];;
                design.priwpanz=val2;
              }
              else
              {
                design.priwp=-1;
                design.priwpanz=0;
              }
              break;
            case GD_SEKWP:
              initwparray();
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.secwp=referenz[val1];
                design.secwpanz=val2;
              }
              else
              {
                design.secwp=-1;
                design.secwpanz=0;
              }
              break;
            case GD_TERWP:
              initwparray();
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.terwp=referenz[val1];
                design.terwpanz=val2;
              }
              else
              {
                design.terwp=-1;
                design.terwpanz=0;
              }
              break;
            case GD_SG:
              initcomparray("SG");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.shield=referenz[val1];
                design.shieldanz=val2;
              }
              else
              {
                design.shield=-1;
                design.shieldanz=0;
              }
              break;
            case GD_FRACHT:
              initcomparray("FR");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.fracht=referenz[val1];
                design.frachtanz=val2;
              }
              else
              {
                design.fracht=-1;
                design.frachtanz=0;
              }
              break;
            case GD_COMP:
              initcomparray("COM");
              CreateList(&tmplist, comparray);
              ListRequest(&val1, &tmplist);
              design.comp=referenz[val1];
              break;
            case GD_SENS:
              initcomparray("SEN");
              CreateList(&tmplist, comparray);
              ListRequest(&val1, &tmplist);
              design.sens=referenz[val1];
              break;
            case GD_REP:
              initcomparray("RD");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.rep=referenz[val1];
                design.repanz=val2;
              }
              else
              {
                design.rep=-1;
                design.repanz=0;
              }
              break;
            case GD_LAB:
              initcomparray("LAB");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              design.lab=referenz[val1];
              design.labanz=val2;
              break;
            case GD_UNTER:
              initcomparray("TU");
              CreateList(&tmplist, comparray);
              ListIntRequest(&val1, &val2, &tmplist);
              if (val2)
              {
                design.unter=referenz[val1];
                design.unteranz=val2;
              }
              else
              {
                design.unter=-1;
                design.unteranz=0;
              }
              break;
            default:
              break;
          }
          break;
        default:
	    break;
      }
      GT_ReplyIMsg(im);
      Kosten();
    }
  }
  if (request) FreeAslRequest(request);
  CloseListIntReqWindow();
  CloseStrReqWindow();
  CloseSNII1Window();
  CloseDownScreen();
  closelibs();
  return(0);
}

_abort()
{
  if (request) FreeAslRequest(request);
  CloseListIntReqWindow();
  CloseStrReqWindow();
  CloseSNII1Window();
  CloseDownScreen();
  closelibs();
  exit(10);
}