[BACK]Return to d_disk.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / win9x / dialog

Diff for /np2/win9x/dialog/d_disk.cpp between versions 1.9 and 1.19

version 1.9, 2004/02/13 20:31:55 version 1.19, 2007/11/11 07:11:28
Line 2 Line 2
 #include        "strres.h"  #include        "strres.h"
 #include        "resource.h"  #include        "resource.h"
 #include        "np2.h"  #include        "np2.h"
   #include        "oemtext.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "toolwin.h"  #include        "toolwin.h"
Line 12 Line 13
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "newdisk.h"  #include        "newdisk.h"
   
   static const FSPARAM fpFDD =
 static const char fddui_title[] = "Select floppy image";  {
 static const char fddui_filter[] =                                                                              \          MAKEINTRESOURCE(IDS_FDDTITLE),
                                         "D88 image files (*.D88;*.D98)\0"                                       \          MAKEINTRESOURCE(IDS_FDDEXT),
                                                                         "*.d88;*.88d;*.d98;*.98d\0"                     \          MAKEINTRESOURCE(IDS_FDDFILTER),
                                         "Floppy disk images (*.XDF;*.HDM;*.DUP;*.2HD)\0"        \          3
                                                                         "*.xdf;*.hdm;*.dup;*.2hd;*.tfd\0"       \  };
                                         "All supported Files\0"                                                         \  
                                                                         "*.d88;*.88d;*.d98;*.98d;*.fdi;"        \  #if defined(SUPPORT_SASI)
                                                                         "*.xdf;*.hdm;*.dup;*.2hd;*.tfd\0"       \  static const FSPARAM fpSASI =
                                         "All files (*.*)\0*.*\0";  {
 static const FILESEL fddui = {fddui_title, str_d88, fddui_filter, 3};          MAKEINTRESOURCE(IDS_SASITITLE),
           MAKEINTRESOURCE(IDS_HDDEXT),
 static const char sasiui_title[] = "Select SASI/IDE HDD image";          MAKEINTRESOURCE(IDS_HDDFILTER),
 static const char sasiui_filter[] =                                                                             \          4
                                         "Anex86 harddisk image files (*.HDI)\0"                         \  };
                                                                         "*.hdi\0"                                                       \  #else   // defined(SUPPORT_SASI)
                                         "T98 harddisk image files (*.THD)\0"                            \  static const FSPARAM fpSASI =
                                                                         "*.thd\0"                                                       \  {
                                         "T98-Next harddisk image files (*.NHD)\0"                       \          MAKEINTRESOURCE(IDS_HDDTITLE),
                                                                         "*.nhd\0"                                                       \          MAKEINTRESOURCE(IDS_HDDEXT),
                                         "All supported Files\0"                                                         \          MAKEINTRESOURCE(IDS_HDDFILTER),
                                                                         "*.thd;*.nhd;*.hdi\0";          4
 static const FILESEL sasiui = {sasiui_title, str_thd, sasiui_filter, 4};  };
   #endif  // defined(SUPPORT_SASI)
 static const char scsiui_title[] = "Select SCSI HDD image";  
 static const char scsiui_filter[] =                                                                             \  #if defined(SUPPORT_IDEIO)
                                         "Virtual98 harddisk image files (*.HDD)\0"                      \  static const FSPARAM fpISO =
                                                                         "*.hdd\0";  {
 static const FILESEL scsiui = {scsiui_title, str_hdd, scsiui_filter, 1};          MAKEINTRESOURCE(IDS_ISOTITLE),
           MAKEINTRESOURCE(IDS_ISOEXT),
 static const char newdisk_title[] = "Create disk image";          MAKEINTRESOURCE(IDS_ISOFILTER),
 static const char newdisk_filter[] =                                                                    \          3
                                         "D88 image files (*.D88;*.88D)\0"                                       \  };
                                                                         "*.d88;*.88d\0"                                         \  #endif  // defined(SUPPORT_IDEIO)
                                         "Anex86 harddisk image files (*.HDI)\0"                         \  
                                                                         "*.hdi\0"                                                       \  #if defined(SUPPORT_SCSI)
                                         "T98 harddisk image files (*.THD)\0"                            \  static const FSPARAM fpSCSI =
                                                                         "*.thd\0"                                                       \  {
                                         "T98-Next harddisk image files (*.NHD)\0"                       \          MAKEINTRESOURCE(IDS_SCSITITLE),
                                                                         "*.nhd\0"                                                       \          MAKEINTRESOURCE(IDS_SCSIEXT),
                                         "Virtual98 harddisk image files (*.HDD)\0"                      \          MAKEINTRESOURCE(IDS_SCSIFILTER),
                                                                         "*.hdd\0";          1
 static const FILESEL newdiskui = {newdisk_title, str_d88, newdisk_filter, 1};  };
   #endif  // defined(SUPPORT_SCSI)
   
   #if defined(SUPPORT_SCSI)
   static const FSPARAM fpNewDisk =
   {
           MAKEINTRESOURCE(IDS_NEWDISKTITLE),
           MAKEINTRESOURCE(IDS_NEWDISKEXT),
           MAKEINTRESOURCE(IDS_NEWDISKFILTER),
           1
   };
   #else   // defined(SUPPORT_SCSI)
   static const FSPARAM fpNewDisk =
   {
           MAKEINTRESOURCE(IDS_NEWDISKTITLE),
           MAKEINTRESOURCE(IDS_NEWDISKEXT),
           MAKEINTRESOURCE(IDS_NEWDISKFILTER2),
           1
   };
   #endif  // defined(SUPPORT_SCSI)
   
   
 // ----  // ----
   
 void dialog_changefdd(HWND hWnd, REG8 drv) {  void dialog_changefdd(HWND hWnd, REG8 drv) {
   
 const char      *p;  const OEMCHAR   *p;
         char    path[MAX_PATH];          OEMCHAR         path[MAX_PATH];
         int             readonly;          int                     readonly;
   
         if (drv < 4) {          if (drv < 4) {
                 p = fdd_diskname(drv);                  p = fdd_diskname(drv);
                 if ((p == NULL) || (p[0] == '\0')) {                  if ((p == NULL) || (p[0] == '\0')) {
                         p = fddfolder;                          p = fddfolder;
                 }                  }
                 file_cpyname(path, p, sizeof(path));                  file_cpyname(path, p, NELEMENTS(path));
                 if (dlgs_selectfile(hWnd, &fddui, path, sizeof(path), &readonly)) {                  if (dlgs_openfile(hWnd, &fpFDD, path, NELEMENTS(path), &readonly))
                         file_cpyname(fddfolder, path, sizeof(fddfolder));                  {
                           file_cpyname(fddfolder, path, NELEMENTS(fddfolder));
                         sysmng_update(SYS_UPDATEOSCFG);                          sysmng_update(SYS_UPDATEOSCFG);
                         diskdrv_setfdd(drv, path, readonly);                          diskdrv_setfdd(drv, path, readonly);
                         toolwin_setfdd(drv, path);                          toolwin_setfdd(drv, path);
Line 84  const char *p; Line 105  const char *p;
 void dialog_changehdd(HWND hWnd, REG8 drv) {  void dialog_changehdd(HWND hWnd, REG8 drv) {
   
         UINT            num;          UINT            num;
 const char              *p;  const OEMCHAR   *p;
         char            path[MAX_PATH];          PCFSPARAM       pfp;
 const FILESEL   *hddui;          OEMCHAR         path[MAX_PATH];
   
           p = diskdrv_getsxsi(drv);
         num = drv & 0x0f;          num = drv & 0x0f;
         if (!(drv & 0x20)) {            // SASI/IDE          pfp = NULL;
                 if (num >= 2) {          if (!(drv & 0x20))                      // SASI/IDE
                         return;          {
                   if (num < 2)
                   {
                           pfp = &fpSASI;
                   }
   #if defined(SUPPORT_IDEIO)
                   else if (num == 2)
                   {
                           pfp = &fpISO;
                 }                  }
                 p = np2cfg.sasihdd[num];  #endif
                 hddui = &sasiui;  
         }          }
         else {                                          // SCSI  #if defined(SUPPORT_SCSI)
                 if (num >= 4) {          else                                            // SCSI
                         return;          {
                   if (num < 4)
                   {
                           pfp = &fpSCSI;
                 }                  }
                 p = np2cfg.scsihdd[num];  
                 hddui = &scsiui;  
         }          }
         if ((p == NULL) || (p[0] == '\0')) {  #endif
           if (pfp == NULL)
           {
                   return;
           }
           if ((p == NULL) || (p[0] == '\0'))
           {
                 p = hddfolder;                  p = hddfolder;
         }          }
         file_cpyname(path, p, sizeof(path));          file_cpyname(path, p, NELEMENTS(path));
         if (dlgs_selectfile(hWnd, hddui, path, sizeof(path), NULL)) {          if (dlgs_openfile(hWnd, pfp, path, NELEMENTS(path), NULL))
                 file_cpyname(hddfolder, path, sizeof(hddfolder));          {
                   file_cpyname(hddfolder, path, NELEMENTS(hddfolder));
                 sysmng_update(SYS_UPDATEOSCFG);                  sysmng_update(SYS_UPDATEOSCFG);
                 diskdrv_sethdd(drv, path);                  diskdrv_sethdd(drv, path);
         }          }
Line 117  const FILESEL *hddui; Line 154  const FILESEL *hddui;
   
 // ---- newdisk  // ---- newdisk
   
 static const char str_newdisk[] = "newdisk";  static const OEMCHAR str_newdisk[] = OEMTEXT("newdisk");
 static const UINT32 hddsizetbl[5] = {20, 41, 65, 80, 128};  static const UINT32 hddsizetbl[5] = {20, 41, 65, 80, 128};
   
 static const UINT16 sasires[6] = {  static const UINT16 sasires[6] = {
Line 125  static const UINT16 sasires[6] = { Line 162  static const UINT16 sasires[6] = {
                                 IDC_NEWSASI15MB, IDC_NEWSASI20MB,                                  IDC_NEWSASI15MB, IDC_NEWSASI20MB,
                                 IDC_NEWSASI30MB, IDC_NEWSASI40MB};                                  IDC_NEWSASI30MB, IDC_NEWSASI40MB};
   
 static  BYTE    makefdtype = DISKTYPE_2HD << 4;  static  UINT8   makefdtype = DISKTYPE_2HD << 4;
 static  char    disklabel[16+1];  static  OEMCHAR disklabel[16+1];
 static  UINT    hddsize;  static  UINT    hddsize;
 static  UINT    hddminsize;  static  UINT    hddminsize;
 static  UINT    hddmaxsize;  static  UINT    hddmaxsize;
Line 135  static LRESULT CALLBACK NewHddDlgProc(HW Line 172  static LRESULT CALLBACK NewHddDlgProc(HW
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
   
         UINT    val;          UINT    val;
         char    work[32];          TCHAR   work[32];
   
         switch (msg) {          switch (msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
                         SETLISTUINT32(hWnd, IDC_HDDSIZE, hddsizetbl);                          SETLISTUINT32(hWnd, IDC_HDDSIZE, hddsizetbl);
                         SPRINTF(work, "(%d-%dMB)", hddminsize, hddmaxsize);                          wsprintf(work, _T("(%d-%dMB)"), hddminsize, hddmaxsize);
                         SetWindowText(GetDlgItem(hWnd, IDC_HDDLIMIT), work);                          SetWindowText(GetDlgItem(hWnd, IDC_HDDLIMIT), work);
                         SetFocus(GetDlgItem(hWnd, IDC_HDDSIZE));                          SetFocus(GetDlgItem(hWnd, IDC_HDDSIZE));
                         return(FALSE);                          return(FALSE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDOK:                                  case IDOK:
                                         GetWindowText(GetDlgItem(hWnd, IDC_HDDSIZE),                                          GetWindowText(GetDlgItem(hWnd, IDC_HDDSIZE),
                                                                                                         work, sizeof(work));                                                                                                          work, NELEMENTS(work));
                                         val = (UINT)milstr_solveINT(work);                                          val = (UINT)miltchar_solveINT(work);
                                         if (val < hddminsize) {                                          if (val < hddminsize) {
                                                 val = hddminsize;                                                  val = hddminsize;
                                         }                                          }
Line 191  static LRESULT CALLBACK NewSASIDlgProc(H Line 228  static LRESULT CALLBACK NewSASIDlgProc(H
                         return(FALSE);                          return(FALSE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDOK:                                  case IDOK:
                                         for (val=0; val<6; val++) {                                          for (val=0; val<6; val++) {
                                                 if (GetDlgItemCheck(hWnd, sasires[val])) {                                                  if (GetDlgItemCheck(hWnd, sasires[val])) {
Line 227  static LRESULT CALLBACK NewSASIDlgProc(H Line 264  static LRESULT CALLBACK NewSASIDlgProc(H
 static LRESULT CALLBACK NewdiskDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK NewdiskDlgProc(HWND hWnd, UINT msg,
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
   
         WORD    res;          UINT16  res;
   #if defined(OSLANG_UTF8)
           TCHAR   buf[17];
   #endif
   
         switch (msg) {          switch (msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
Line 249  static LRESULT CALLBACK NewdiskDlgProc(H Line 289  static LRESULT CALLBACK NewdiskDlgProc(H
                         return(FALSE);                          return(FALSE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDOK:                                  case IDOK:
   #if defined(OSLANG_UTF8)
                                           GetWindowText(GetDlgItem(hWnd, IDC_DISKLABEL),
                                                                                                                   buf, NELEMENTS(buf));
                                           tchartooem(disklabel, NELEMENTS(disklabel), buf, -1);
   #else
                                         GetWindowText(GetDlgItem(hWnd, IDC_DISKLABEL),                                          GetWindowText(GetDlgItem(hWnd, IDC_DISKLABEL),
                                                                                         disklabel, sizeof(disklabel));                                                                                          disklabel, NELEMENTS(disklabel));
                                         if (milstr_kanji1st(disklabel, sizeof(disklabel) - 1)) {                                          if (milstr_kanji1st(disklabel, NELEMENTS(disklabel) - 1)) {
                                                 disklabel[sizeof(disklabel) - 1] = '\0';                                                  disklabel[NELEMENTS(disklabel) - 1] = '\0';
                                         }                                          }
   #endif
                                         if (GetDlgItemCheck(hWnd, IDC_MAKE2DD)) {                                          if (GetDlgItemCheck(hWnd, IDC_MAKE2DD)) {
                                                 makefdtype = (DISKTYPE_2DD << 4);                                                  makefdtype = (DISKTYPE_2DD << 4);
                                         }                                          }
Line 289  static LRESULT CALLBACK NewdiskDlgProc(H Line 335  static LRESULT CALLBACK NewdiskDlgProc(H
   
 void dialog_newdisk(HWND hWnd) {  void dialog_newdisk(HWND hWnd) {
   
         char            path[MAX_PATH];          OEMCHAR         path[MAX_PATH];
         HINSTANCE       hinst;          HINSTANCE       hinst;
 const char              *ext;  const OEMCHAR   *ext;
   
         file_cpyname(path, fddfolder, sizeof(path));          file_cpyname(path, fddfolder, NELEMENTS(path));
         file_cutname(path);          file_cutname(path);
         file_catname(path, str_newdisk, sizeof(path));          file_catname(path, str_newdisk, NELEMENTS(path));
   
         if (!dlgs_selectwritefile(hWnd, &newdiskui, path, sizeof(path))) {          if (!dlgs_createfile(hWnd, &fpNewDisk, path, NELEMENTS(path)))
           {
                 return;                  return;
         }          }
         hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);          hinst = (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE);
         ext = file_getext(path);          ext = file_getext(path);
         if (!file_cmpname(ext, str_thd)) {          if (!file_cmpname(ext, str_thd)) {
                 hddsize = 0;                  hddsize = 0;
Line 327  const char  *ext; Line 374  const char  *ext;
                         newdisk_hdi(path, hddsize);                          newdisk_hdi(path, hddsize);
                 }                  }
         }          }
   #if defined(SUPPORT_SCSI)
         else if (!file_cmpname(ext, str_hdd)) {          else if (!file_cmpname(ext, str_hdd)) {
                 hddsize = 0;                  hddsize = 0;
                 hddminsize = 2;                  hddminsize = 2;
Line 336  const char  *ext; Line 384  const char  *ext;
                         newdisk_vhd(path, hddsize);                          newdisk_vhd(path, hddsize);
                 }                  }
         }          }
         else {  #endif
           else if ((!file_cmpname(ext, str_d88)) ||
                           (!file_cmpname(ext, str_d98)) ||
                           (!file_cmpname(ext, str_88d)) ||
                           (!file_cmpname(ext, str_98d))) {
                 if (DialogBox(hinst,                  if (DialogBox(hinst,
                                 MAKEINTRESOURCE((np2cfg.usefd144)?IDD_NEWDISK2:IDD_NEWDISK),                                  MAKEINTRESOURCE((np2cfg.usefd144)?IDD_NEWDISK2:IDD_NEWDISK),
                                                                         hWnd, (DLGPROC)NewdiskDlgProc) == IDOK) {                                                                          hWnd, (DLGPROC)NewdiskDlgProc) == IDOK) {
Removed from v.1.9  
changed lines
  Added in v.1.19

RetroPC.NET-CVS <cvs@retropc.net>