Subversion Repositories pentevo

#include "std.h"

#include "resource.h"

#include "emul.h"

#include "vars.h"

#include "snapshot.h"

#include "tape.h"

#include "memory.h"

#include "opendlg.h"

#include "draw.h"

#include "config.h"

#include "z80.h"

#include "sshot_png.h"

#include "funcs.h"

#include "util.h"

int readSP();

int readSNA48();

int readSNA128();

int readZ80();

int writeSNA(FILE*);

int load_arc(char *fname);

SNAP what_is(char *filename)

{

   FILE *ff = fopen(filename, "rb");

   if (!ff) return snNOFILE;

   snapsize = unsigned(fread(snbuf, 1, sizeof snbuf, ff));

   fclose(ff);

   if (snapsize == sizeof snbuf) return snTOOLARGE;

   SNAP type = snUNKNOWN;

   char *ptr = strrchr(filename, '.');

   unsigned ext = ptr? (*(unsigned*)(ptr+1) | 0x20202020U) : 0;

   if (snapsize < 32) return type;

   if (snapsize == 131103 || snapsize == 147487) type = snSNA_128;

   if (snapsize == 49179) type = snSNA_48;

   if (ext == WORD4('t','a','p',' ')) type = snTAP;

   if (ext == WORD4('z','8','0',' ')) type = snZ80;

   if(ext == WORD4('p', 'a', 'l', ' ') && (snapsize == sizeof(comp.comp_pal)))

   {

       type = snPAL;

       return type;

   }

   if (conf.trdos_present)

   {

      if (!snbuf[13] && snbuf[14] && (int)snapsize == snbuf[14]*256+17) type = snHOB;

      if (snapsize >= 8192 && !(snapsize & 0xFF) && ext == WORD4('t','r','d',' ')) type = snTRD;

      if (snapsize >= 8192 && ext == WORD4('i','s','d',' '))

          type = snISD;

      if (snapsize >= 8192 && ext == WORD4('p','r','o',' '))

          type = snPRO;

      if(snapsize >= 8192 && ext == WORD4('d', 's', 'k', ' '))

          type = snDSK;

      if(snapsize >= 8192 && ext == WORD4('i', 'p', 'f', ' '))

          type = snIPF;

      if (!memcmp(snbuf, "SINCLAIR", 8))

      {

          unsigned nfiles = snbuf[8];

          unsigned nsec = 0;

          for(unsigned i = 0; i < nfiles; i++)

          {

              nsec += snbuf[9+14*i+13];

          }

          if(snapsize >= 9 + nfiles * 14 + nsec * 0x100)

              type = snSCL;

      }

      if (!memcmp(snbuf, "FDI", 3) && *(unsigned short*)(snbuf+4) <= MAX_CYLS && *(unsigned short*)(snbuf+6) <= 2) type = snFDI;

      if (((*(short*)snbuf|0x2020) == WORD2('t','d')) && snbuf[4] >= 10 && snbuf[4] <= 21 && snbuf[9] <= 2) type = snTD0;

      if (*(unsigned*)snbuf == WORD4('U','D','I','!') && *(unsigned*)(snbuf+4)==snapsize-4 && snbuf[9] < MAX_CYLS && snbuf[10]<2 && !snbuf[8]) type = snUDI;

   }

   if (snapsize > 10 && !memcmp(snbuf, "ZXTape!\x1A", 8))

   {

       type = snTZX;

   }

   if (snapsize > 0x22 && !memcmp(snbuf, "Compressed Square Wave\x1A", 23)) type = snCSW;

   if (*(unsigned short*)snbuf == WORD2('S','P') && *(unsigned short*)(snbuf+2)+0x26 == (int)snapsize) type = snSP;

   return type;

}

static int readPAL();

int loadsnap(char *filename)

{

   if (load_arc(filename))

       return 1;

   SNAP type = what_is(filename);

   if (type >= snHOB)

   {

      if (trd_toload == -1U)

      {

         unsigned last = -1U;

         for (unsigned i = 0; i < 4; i++) if (trd_loaded[i]) last = i;

         trd_toload = (last == -1U)? 0 : ((type == snHOB)? last : (last+1) & 3);

      }

      for (unsigned k = 0; k < 4; k++)

      {

         if (k != trd_toload && !stricmp(comp.fdd[k].name, filename))

         {

            static char err[] = "This disk image is already loaded to drive X:\n"

                                "Do you still want to load it to drive Y:?";

            err[43] = char(k+'A');

            err[84] = char(trd_toload+'A');

            if (MessageBox(GetForegroundWindow(), err, "Warning", MB_YESNO | MB_ICONWARNING) == IDNO) return 1;

         }

      }

      FDD *drive = comp.fdd + trd_toload;

      if (!drive->test())

          return 0;

      comp.wd.Eject(trd_toload);

      int ok = drive->read(type);

      if (ok)

      {

         if (*conf.appendboot)

             drive->addboot();

         strcpy(drive->name, filename);

         if (GetFileAttributes(filename) & FILE_ATTRIBUTE_READONLY)

            conf.trdos_wp[trd_toload] = 1;

         drive->snaptype = (type == snHOB || type == snSCL)? snTRD : type;

         trd_loaded[trd_toload] = 1;

//---------Alone Coder

         char *name = filename;

         for (char *x = name; *x; x++)

             if (*x == '\\') name = x+1;

         strcpy(temp.LastSnapName, name);

         char *p = strrchr(temp.LastSnapName, '.');

         if(p)

         {

             *p = 0;

         }

         char wintitle[0x200];

         strcpy(wintitle,name);

         strcat(wintitle," - UnrealSpeccy");

         SetWindowText(wnd, wintitle);

//~---------Alone Coder

      }

      return ok;

   }

   if (type == snSP) return readSP();

   if (type == snSNA_48) return readSNA48();

   if (type == snSNA_128) return readSNA128();

   if (type == snZ80) return readZ80();

   if (type == snTAP) return readTAP();

   if (type == snTZX) return readTZX();

   if (type == snCSW) return readCSW();

   if(type == snPAL)

   {

       return readPAL();

   }

   return 0;

}

int readSNA128()

{

   if(conf.mem_model == MM_PENTAGON && conf.Sna128Lock)

   {

       conf.ramsize = 128;

       temp.ram_mask = u8((conf.ramsize-1) >> 4);

   }

   hdrSNA128 *hdr = (hdrSNA128*)snbuf;

   reset(hdr->trdos? RM_DOS : RM_SOS);

   cpu.alt.af = hdr->altaf;

   cpu.alt.bc = hdr->altbc;

   cpu.alt.de = hdr->altde;

   cpu.alt.hl = hdr->althl;

   cpu.af = hdr->af;

   cpu.bc = hdr->bc;

   cpu.de = hdr->de;

   cpu.hl = hdr->hl;

   cpu.ix = hdr->ix;

   cpu.iy = hdr->iy;

   cpu.sp = hdr->sp;

   cpu.pc = hdr->pc;

   cpu.i = hdr->i;

   cpu.r_low = hdr->r;

   cpu.r_hi = hdr->r & 0x80;

   cpu.im = hdr->im;

   cpu.iff1 = cpu.iff2 = (hdr->iff >> 2) & 1;

   comp.p7FFD = hdr->p7FFD;

   comp.pFE = hdr->pFE;

   comp.border_attr = comp.pFE & 7;

   memcpy(memory+PAGE*5, hdr->page5, PAGE);

   memcpy(memory+PAGE*2, hdr->page2, PAGE);

   memcpy(memory+PAGE*(hdr->p7FFD & 7), hdr->active_page, PAGE);

   unsigned char *newpage = snbuf+0xC01F;

   unsigned char mapped = u8(0x24U | (1 << (hdr->p7FFD & 7)));

   for (unsigned char i = 0; i < 8; i++)

   {

      if (!(mapped & (1 << i)))

      {

         memcpy(memory + PAGE*i, newpage, PAGE);

         newpage += PAGE;

      }

   }

   set_banks();

   return 1;

}

int readSNA48()

{

   //conf.mem_model = MM_PENTAGON; conf.ramsize = 128;  // molodcov_alex

   reset(RM_SOS);

   hdrSNA128 *hdr = (hdrSNA128*)snbuf;

   cpu.alt.af = hdr->altaf; cpu.alt.bc = hdr->altbc;

   cpu.alt.de = hdr->altde; cpu.alt.hl = hdr->althl;

   cpu.af = hdr->af; cpu.bc = hdr->bc; cpu.de = hdr->de; cpu.hl = hdr->hl;

   cpu.ix = hdr->ix; cpu.iy = hdr->iy; cpu.sp = hdr->sp;

   cpu.i = hdr->i; cpu.r_low = hdr->r; cpu.r_hi = hdr->r & 0x80; cpu.im = hdr->im;

   cpu.iff1 = cpu.iff2 = (hdr->iff >> 2) & 1; comp.p7FFD = 0x30;

   comp.pEFF7 |= EFF7_LOCKMEM; //Alone Coder

   comp.pFE = hdr->pFE; comp.border_attr = comp.pFE & 7;

   memcpy(memory+PAGE*5, hdr->page5, PAGE);

   memcpy(memory+PAGE*2, hdr->page2, PAGE);

   memcpy(memory+PAGE*0, hdr->active_page, PAGE);

   cpu.pc = cpu.DirectRm(cpu.sp)+0x100*cpu.DirectRm(cpu.sp+1); cpu.sp += 2;

   set_banks(); return 1;

}

int readSP()

{

   //conf.mem_model = MM_PENTAGON; conf.ramsize = 128;  // molodcov_alex

   reset(RM_SOS);

   hdrSP *hdr = (hdrSP*)snbuf;

   cpu.alt.af = hdr->altaf; cpu.alt.bc = hdr->altbc;

   cpu.alt.de = hdr->altde; cpu.alt.hl = hdr->althl;

   cpu.af = hdr->af; cpu.bc = hdr->bc; cpu.de = hdr->de; cpu.hl = hdr->hl;

   cpu.ix = hdr->ix; cpu.iy = hdr->iy; cpu.sp = hdr->sp; cpu.pc = hdr->pc;

   cpu.i = hdr->i; cpu.r_low = hdr->r; cpu.r_hi = hdr->r & 0x80;

   cpu.iff1 = (hdr->flags & 1);

   cpu.im = 1 + ((hdr->flags >> 1) & 1);

   cpu.iff2 = (hdr->flags >> 2) & 1;

   comp.p7FFD = 0x30;

   comp.pEFF7 |= EFF7_LOCKMEM; //Alone Coder

   comp.pFE = hdr->pFE; comp.border_attr = comp.pFE & 7;

   for (unsigned i = 0; i < hdr->len; i++)

      cpu.DirectWm(hdr->start + i, snbuf[i + 0x26]);

   set_banks(); return 1;

}

int writeSNA(FILE *ff)

{

/*   if (conf.ramsize != 128) {

      MessageBox(GetForegroundWindow(), "SNA format can hold only\r\n128kb memory models", "Save", MB_ICONERROR);

      return 0;

   }*/ //Alone Coder

   hdrSNA128 *hdr = (hdrSNA128*)snbuf;

   hdr->trdos = (comp.flags & CF_TRDOS)? 1 : 0;

   hdr->altaf = u16(cpu.alt.af); hdr->altbc = u16(cpu.alt.bc);

   hdr->altde = u16(cpu.alt.de); hdr->althl = u16(cpu.alt.hl);

   hdr->af = u16(cpu.af); hdr->bc = u16(cpu.bc); hdr->de = u16(cpu.de); hdr->hl = u16(cpu.hl);

   hdr->ix = u16(cpu.ix); hdr->iy = u16(cpu.iy); hdr->sp = u16(cpu.sp); hdr->pc = u16(cpu.pc);

   hdr->i = cpu.i; hdr->r = (cpu.r_low & 0x7F)+cpu.r_hi; hdr->im = cpu.im;

   hdr->iff = cpu.iff2 ? 4 : 0;

   hdr->p7FFD = comp.p7FFD;

   hdr->pFE = comp.pFE; comp.border_attr = comp.pFE & 7;

   unsigned savesize = sizeof(hdrSNA128);

   unsigned char mapped = u8(0x24U | (1 << (comp.p7FFD & 7)));

   if (comp.p7FFD == 0x30)

   { // save 48k

      mapped = 0xFF;

      savesize = 0xC01B;

      hdr->sp -= 2;

      cpu.DirectWm(hdr->sp, cpu.pcl);

      cpu.DirectWm(hdr->sp+1, cpu.pch);

   }

   memcpy(hdr->page5, memory+PAGE*5, PAGE);

   memcpy(hdr->page2, memory+PAGE*2, PAGE);

   memcpy(hdr->active_page, memory+PAGE*(comp.p7FFD & 7), PAGE);

   if (fwrite(hdr, 1, savesize, ff) != savesize) return 0;

   for (unsigned char i = 0; i < 8; i++)

      if (!(mapped & (1 << i))) {

         if (fwrite(memory + PAGE*i, 1, PAGE, ff) != PAGE) return 0;

      }

   return 1;

}

static void unpack_page(unsigned char *dst, unsigned dstlen, unsigned char *src, unsigned srclen)

{

   memset(dst, 0, dstlen);

   while (srclen > 0 && dstlen > 0)

   {

      if (srclen >= 4 && src[0] == 0xED && src[1] == 0xED)

      {

         size_t len = src[2];

         memset(dst, src[3], len);

         dstlen -= len;

         srclen -= 4;

         src += 4;

         dst += len;

      }

      else

      {

          *dst++ = *src++;

          dstlen--;

          srclen--;

      }

   }

}

int readZ80()

{

   //conf.mem_model = MM_PENTAGON; conf.ramsize = 128;  // molodcov_alex

   hdrZ80 *hdr = (hdrZ80*)snbuf;

   unsigned char *ptr = snbuf + 30;

   unsigned char model48k = (hdr->model < 3);

   reset((model48k|(hdr->p7FFD & 0x10)) ? RM_SOS : RM_128);

   if (hdr->flags == 0xFF)

       hdr->flags = 1;

   if (hdr->pc == 0)

   { // 2.01

      ptr += 2 + hdr->len;

      hdr->pc = hdr->newpc;

      memset(RAM_BASE_M, 0, PAGE*8); // clear 128k - first 8 pages

      unsigned char * const p48[] =

      {

             base_sos_rom, nullptr, nullptr, nullptr,

             RAM_BASE_M+2*PAGE, RAM_BASE_M+0*PAGE, nullptr, nullptr,

             RAM_BASE_M+5*PAGE, nullptr, nullptr, nullptr

      };

      unsigned char * const p128[] =

      {

             base_sos_rom, base_dos_rom, base_128_rom, RAM_BASE_M+0*PAGE,

             RAM_BASE_M+1*PAGE, RAM_BASE_M+2*PAGE, RAM_BASE_M+3*PAGE, RAM_BASE_M+4*PAGE,

             RAM_BASE_M+5*PAGE, RAM_BASE_M+6*PAGE, RAM_BASE_M+7*PAGE, nullptr

      };

      while (ptr < snbuf+snapsize)

      {

         unsigned len = *(unsigned short*)ptr;

         if (ptr[2] > 11)

             return 0;

         unsigned char *dstpage = model48k ? p48[ptr[2]] : p128[ptr[2]];

         if (!dstpage)

             return 0;

         ptr += 3;

         if (len == 0xFFFF)

         {

             len = PAGE;

             memcpy(dstpage, ptr, len);

         }

         else

             unpack_page(dstpage, PAGE, ptr, len);

         ptr += len;

      }

   }

   else

   {

      unsigned len = snapsize - 30;

      unsigned char *mem48 = ptr;

      if (hdr->flags & 0x20)

         unpack_page(mem48 = snbuf + 4*PAGE, 3*PAGE, ptr, len);

      memcpy(memory + PAGE*5, mem48, PAGE);

      memcpy(memory + PAGE*2, mem48 + PAGE, PAGE);

      memcpy(memory + PAGE*0, mem48 + 2*PAGE, PAGE);

      model48k = 1;

   }

   cpu.a = hdr->a; cpu.f = hdr->f;

   cpu.bc = hdr->bc; cpu.de = hdr->de; cpu.hl = hdr->hl;

   cpu.alt.bc = hdr->bc1; cpu.alt.de = hdr->de1; cpu.alt.hl = hdr->hl1;

   cpu.alt.a = hdr->a1; cpu.alt.f = hdr->f1;

   cpu.pc = hdr->pc; cpu.sp = hdr->sp; cpu.ix = hdr->ix; cpu.iy = hdr->iy;

   cpu.i = hdr->i; cpu.r_low = hdr->r & 0x7F;

   cpu.r_hi = u8((hdr->flags & 1U) << 7U);

   comp.pFE = (hdr->flags >> 1) & 7;

   comp.border_attr = comp.pFE;

   cpu.iff1 = hdr->iff1; cpu.iff2 = hdr->iff2; cpu.im = (hdr->im & 3);

   comp.p7FFD = (model48k) ? 0x30 : hdr->p7FFD;

   if(hdr->len == 55) // version 3.0 (with 1ffd)

       comp.p1FFD = hdr->p1FFD;

   if (model48k)

       comp.pEFF7 |= EFF7_LOCKMEM; //Alone Coder

   set_banks();

   return 1;

}

static int readPAL()

{

    memcpy(comp.comp_pal, snbuf, snapsize);

    temp.comp_pal_changed = 1;

    if(conf.ula_plus)

    {

        comp.ula_plus_en = true; // ���� ������������ ULA+, �� ����� � ���������� �� (����� ��������� ������� ���� �����)

    }

    return 1;

}

static int writePAL(FILE *ff)

{

    if(fwrite(comp.comp_pal, 1, sizeof(comp.comp_pal), ff) != sizeof(comp.comp_pal))

    {

        return 0;

    }

    return 1;

}

#define arctmp ((char*)rbuf)

static char *arc_fname;

static INT_PTR CALLBACK ArcDlg(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)

{

   (void)lp;

   if (msg == WM_INITDIALOG) {

      for (char *dst = arctmp; *dst; dst += strlen(dst)+1)

         SendDlgItemMessage(dlg, IDC_ARCLIST, LB_ADDSTRING, 0, (LPARAM)dst);

      SendDlgItemMessage(dlg, IDC_ARCLIST, LB_SETCURSEL, 0, 0);

      return 1;

   }

   if ((msg == WM_COMMAND && wp == IDCANCEL) ||

       (msg == WM_SYSCOMMAND && (wp & 0xFFF0) == SC_CLOSE)) EndDialog(dlg, 0);

   if (msg == WM_COMMAND && (LOWORD(wp) == IDOK || (HIWORD(wp)==LBN_DBLCLK && LOWORD(wp) == IDC_ARCLIST)))

   {

      int n = int(SendDlgItemMessage(dlg, IDC_ARCLIST, LB_GETCURSEL, 0, 0));

      char *dst = arctmp;

      for (int q = 0; q < n; q++) dst += strlen(dst)+1;

      arc_fname = dst;

      EndDialog(dlg, 0);

   }

   return 0;

}

static bool filename_ok(char *fname)

{

   for (char *wc = skiparc; *wc; wc += strlen(wc)+1)

      if (wcmatch(fname, wc)) return 0;

   return 1;

}

int load_arc(char *fname)

{

   char *ext = strrchr(fname, '.'); if (!ext) return 0;

   ext++;

   char *cmdtmp;

   char done = 0;

   for (char *x = arcbuffer; *x; x = cmdtmp + strlen(cmdtmp)+1) {

      cmdtmp = x + strlen(x)+1;

      if (stricmp(ext, x)) continue;

      char dir[0x200]; GetCurrentDirectory(sizeof dir, dir);

      char tmp[0x200]; GetTempPath(sizeof tmp, tmp);

      char d1[0x20]; sprintf(d1, "us%08lX", GetTickCount());

      SetCurrentDirectory(tmp);

      CreateDirectory(d1, nullptr);

      SetCurrentDirectory(d1);

      color();

      char cmdln[0x200]; sprintf(cmdln, cmdtmp, fname);

      STARTUPINFO si = { sizeof si };

      si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE;

      PROCESS_INFORMATION pi;

      unsigned flags = CREATE_NEW_CONSOLE;

      HANDLE hc = CreateFile("CONOUT$", GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);

      if(hc != INVALID_HANDLE_VALUE)

      {

          CloseHandle(hc);

          flags = 0;

      }

      if (CreateProcess(nullptr, cmdln, nullptr, nullptr, 0, flags, nullptr, nullptr, &si, &pi)) {

         WaitForSingleObject(pi.hProcess, INFINITE);

         DWORD code; GetExitCodeProcess(pi.hProcess, &code);

         CloseHandle(pi.hThread);

         CloseHandle(pi.hProcess);

         if (!code || MessageBox(GetForegroundWindow(), "Broken archive", nullptr, MB_ICONERROR | MB_OKCANCEL) == IDOK) {

            WIN32_FIND_DATA fd; HANDLE h;

            char *dst = arctmp; unsigned nfiles = 0;

            if ((h = FindFirstFile("*.*", &fd)) != INVALID_HANDLE_VALUE) {

               do {

                  if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && filename_ok(fd.cFileName)) {

                     strcpy(dst, fd.cFileName); dst += strlen(dst)+1;

                     nfiles++;

                  }

               } while (FindNextFile(h, &fd));

               FindClose(h);

            }

            *dst = 0; arc_fname = nullptr;

            if (nfiles == 1) arc_fname = arctmp;

            if (nfiles > 1)

                DialogBox(hIn, MAKEINTRESOURCE(IDD_ARC), GetForegroundWindow(), ArcDlg);

            if (!nfiles) MessageBox(GetForegroundWindow(), "Empty archive!", nullptr, MB_ICONERROR | MB_OK);

            char buf[0x200]; strcpy(buf, tmp); strcat(buf, "\\");

            strcat(buf, d1);

            strcat(buf, "\\");

            if(arc_fname)

            {

                strcat(buf, arc_fname);

                arc_fname = buf;

            }

            if (arc_fname && !(done = (char)loadsnap(arc_fname))) MessageBox(GetForegroundWindow(), "loading error", arc_fname, MB_ICONERROR);

            if (!done) done = -1;

         }

         // delete junk

         SetCurrentDirectory(tmp);

         SetCurrentDirectory(d1);

         WIN32_FIND_DATA fd; HANDLE h;

         if ((h = FindFirstFile("*.*", &fd)) != INVALID_HANDLE_VALUE) {

            do { DeleteFile(fd.cFileName); } while (FindNextFile(h, &fd));

            FindClose(h);

         }

      }

      SetCurrentDirectory(tmp);

      RemoveDirectory(d1);

      SetCurrentDirectory(dir);

      eat(); if (done) return done > 0 ? 1 : 0;

   }

   eat(); return 0;

}

void opensnap(unsigned index)

{

   char mask[0x200]; *mask = 0;

   for(char *x = arcbuffer; *x; )

   {

       strcat(mask, ";*.");

       strcat(mask, x);

       x += strlen(x) + 1;

       x += strlen(x) + 1;

   }

   char fline[0x400];

   const char *src = "all (sna,z80,sp,tap,tzx,csw,trd,scl,fdi,td0,udi,isd,pro,dsk,ipf,hobeta,pal)\0"

               "*.sna;*.z80;*.sp;*.tap;*.tzx;*.csw;*.trd;*.scl;*.td0;*.udi;*.fdi;*.isd;*.pro;*.dsk;*.ipf;*.$?;*.!?;*.pal<\0"

               "Disk B (trd,scl,fdi,td0,udi,isd,pro,dsk,ipf,hobeta)\0*.trd;*.scl;*.fdi;*.udi;*.td0;*.isd;*.pro;*.dsk;*.ipf;*.$?<\0"

               "Disk C (trd,scl,fdi,td0,udi,isd,pro,dsk,ipf,hobeta)\0*.trd;*.scl;*.fdi;*.udi;*.td0;*.isd;*.pro;*.dsk;*.ipf;*.$?<\0"

               "Disk D (trd,scl,fdi,td0,udi,isd,pro,dsk,ipf,hobeta)\0*.trd;*.scl;*.fdi;*.udi;*.td0;*.isd;*.pro;*.dsk;*.ipf;*.$?<\0\0>";

   if (!conf.trdos_present)

      src = "ZX files (sna,z80,tap,tzx,csw,pal)\0*.sna;*.z80;*.tap;*.tzx;*.csw;*.pal<\0\0>";

   for(char *dst = fline; *src != '>'; src++)

   {

       if(*src == '<')

       {

           strcpy(dst, mask);

           dst += strlen(dst);

       }

       else

       {

           *dst++ = *src;

       }

   }

   OPENFILENAME ofn = { };

   char fname[0x200]; *fname = 0;

   char dir[0x200]; GetCurrentDirectory(sizeof dir, dir);

   ofn.lStructSize = (WinVerMajor < 5) ? OPENFILENAME_SIZE_VERSION_400 : sizeof(OPENFILENAME);

   ofn.hwndOwner = GetForegroundWindow();

   ofn.lpstrFilter = fline;

   ofn.lpstrFile = fname; ofn.nMaxFile = sizeof fname;

   ofn.lpstrTitle = "Load Snapshot / Disk / Tape";

   ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;

   ofn.nFilterIndex = DWORD(index);

   ofn.lpstrInitialDir = dir;

//   __debugbreak();

   if (GetSnapshotFileName(&ofn, 0))

   {

      trd_toload = ofn.nFilterIndex-1;

      if (!loadsnap(fname))

          MessageBox(GetForegroundWindow(), fname, "loading error", MB_ICONERROR);

   }

   eat();

}

static const int mx_typs = (1+4*6);

static unsigned char snaps[mx_typs];

static unsigned exts[mx_typs];

static unsigned drvs[mx_typs];

static unsigned snp;

static void addref(LPSTR &ptr, unsigned char sntype, const char *ref, unsigned drv, unsigned ext)

{

   strcpy(ptr, ref); ptr += strlen(ptr)+1;

   strcpy(ptr, ref+strlen(ref)+1); ptr += strlen(ptr)+1;

   drvs[snp] = drv; exts[snp] = ext; snaps[snp++] = sntype;

}

void savesnap(int diskindex)

{

again:

   OPENFILENAME ofn = { };

   char fname[0x200]; *fname = 0;

   if (diskindex >= 0) {

      strcpy(fname, comp.fdd[diskindex].name);

      size_t ln = strlen(fname);

      if (ln > 4 && (*(unsigned*)(fname+ln-4) | WORD4(0,0x20,0x20,0x20)) == WORD4('.','s','c','l'))

         *(unsigned*)(fname+ln-4) = WORD4('.','t','r','d');

   }

   snp = 1; char types[600], *ptr = types;

   if (diskindex < 0)

   {

      exts[snp] = WORD4('s','n','a',0); snaps[snp] = snSNA_128; // default

      addref(ptr, snSNA_128, "ZX-Spectrum 128K snapshot (SNA)\0*.sna", -1U, WORD4('s','n','a',0));

      exts[snp] = WORD4('p', 'a', 'l', 0); snaps[snp] = snPAL;

      addref(ptr, snPAL, "Palette (ULA+)\0*.pal", -1U, WORD4('p', 'a', 'l', 0));