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

Diff for /np2/win9xc/dialog/d_disk.cpp between versions 1.1.1.1 and 1.7

version 1.1.1.1, 2003/10/16 17:59:29 version 1.7, 2011/02/15 00:51:51
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "resource.h"  
 #include        "strres.h"  #include        "strres.h"
   #include        "resource.h"
 #include        "np2.h"  #include        "np2.h"
 #include        "dosio.h"  #include        "dosio.h"
   #include        "sysmng.h"
 #include        "dialog.h"  #include        "dialog.h"
 #include        "dialogs.h"  #include        "dialogs.h"
 #include        "ini.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "fddfile.h"  
 #include        "diskdrv.h"  #include        "diskdrv.h"
   #include        "fddfile.h"
 #include        "newdisk.h"  #include        "newdisk.h"
   
   
 static const char fddui_title[] = "Select floppy image";  static const TCHAR fddui_title[] = _T("Select floppy image");
 static const char fddui_filter[] =                                                                              \  static const TCHAR fddui_filter[] =                                                                             \
                                         "D88 image files (*.D88;*.D98)\0"                                       \                                  _T("D88 image files (*.D88;*.D98)\0")                                   \
                                                                         "*.d88;*.88d;*.d98;*.98d\0"                     \                                                                  _T("*.d88;*.88d;*.d98;*.98d\0")                 \
                                         "Floppy disk images (*.XDF;*.HDM;*.DUP;*.2HD)\0"        \                                  _T("Floppy disk images (*.XDF;*.HDM;*.DUP;*.2HD)\0")    \
                                                                         "*.xdf;*.hdm;*.dup;*.2hd;*.tfd\0"       \                                                                  _T("*.xdf;*.hdm;*.dup;*.2hd;*.tfd\0")   \
                                         "All supported Files\0"                                                         \                                  _T("All supported Files\0")                                                             \
                                                                         "*.d88;*.88d;*.d98;*.98d;"                      \                                                                  _T("*.d88;*.88d;*.d98;*.98d;*.fdi;")    \
                                                                         "*.xdf;*.hdm;*.dup;*.2hd;*.tfd\0"       \                                                                  _T("*.xdf;*.hdm;*.dup;*.2hd;*.tfd\0")   \
                                         "All files (*.*)\0*.*\0";                                  _T("All files (*.*)\0*.*\0");
 static const FILESEL fddui = {fddui_title, str_d88, fddui_filter, 3};  static const FILESEL fddui = {fddui_title, str_d88, fddui_filter, 3};
   
 static const char hddui_title[] = "Select HDD image";  #if defined(SUPPORT_SASI)
 static const char hddui_filter[] =                                                                              \  static const TCHAR sasiui_title[] = _T("Select SASI/IDE HDD image");
                                         "T98 harddisk image files (*.THD)\0"                            \  #else
                                                                         "*.thd\0"                                                       \  static const TCHAR sasiui_title[] = _T("Select HDD image");
                                         "Anex86 harddisk image files (*.HDI)\0"                         \  #endif
                                                                         "*.hdi\0"                                                       \  static const TCHAR sasiui_filter[] =                                                                    \
                                         "All supported Files\0"                                                         \                                  _T("Anex86 harddisk image files (*.HDI)\0")                             \
                                                                         "*.thd;*.hdi\0";                                                                  _T("*.hdi\0")                                                   \
 static const FILESEL hddui = {hddui_title, str_thd, hddui_filter, 3};                                  _T("T98 harddisk image files (*.THD)\0")                                \
                                                                   _T("*.thd\0")                                                   \
 static const char newdisk_title[] = "Create disk image";                                  _T("T98-Next harddisk image files (*.NHD)\0")                   \
 static const char newdisk_filter[] =                                                                    \                                                                  _T("*.nhd\0")                                                   \
                                         "D88 image files (*.D88;*.88D)\0"                                       \                                  _T("All supported Files\0")                                                             \
                                                                                 "*.d88;*.88d\0"                                 \                                                                  _T("*.thd;*.nhd;*.hdi\0");
                                         "T98 harddisk image files (*.THD)\0"                            \  static const FILESEL sasiui = {sasiui_title, str_thd, sasiui_filter, 4};
                                                                                 "*.thd\0";  
   #if defined(SUPPORT_SCSI)
   static const TCHAR scsiui_title[] = _T("Select SCSI HDD image");
   static const TCHAR scsiui_filter[] =                                                                    \
                                   _T("Virtual98 harddisk image files (*.HDD)\0")                  \
                                                                   _T("*.hdd\0");
   static const FILESEL scsiui = {scsiui_title, str_hdd, scsiui_filter, 1};
   #endif
   
   static const TCHAR newdisk_title[] = _T("Create disk image");
   #if defined(SUPPORT_SCSI)
   static const TCHAR newdisk_filter[] =                                                                   \
                                   _T("D88 image files (*.D88;*.88D)\0")                                   \
                                                                   _T("*.d88;*.88d;*.d98;*.98d\0")                 \
                                   _T("Anex86 harddisk image files (*.HDI)\0")                             \
                                                                   _T("*.hdi\0")                                                   \
                                   _T("T98 harddisk image files (*.THD)\0")                                \
                                                                   _T("*.thd\0")                                                   \
                                   _T("T98-Next harddisk image files (*.NHD)\0")                   \
                                                                   _T("*.nhd\0")                                                   \
                                   _T("Virtual98 harddisk image files (*.HDD)\0")                  \
                                                                   _T("*.hdd\0");
   #else
   static const TCHAR newdisk_filter[] =                                                                   \
                                   _T("D88 image files (*.D88;*.88D)\0")                                   \
                                                                   _T("*.d88;*.88d;*.d98;*.98d\0")                 \
                                   _T("Anex86 harddisk image files (*.HDI)\0")                             \
                                                                   _T("*.hdi\0")                                                   \
                                   _T("T98 harddisk image files (*.THD)\0")                                \
                                                                   _T("*.thd\0")                                                   \
                                   _T("T98-Next harddisk image files (*.NHD)\0")                   \
                                                                   _T("*.nhd\0");
   #endif
 static const FILESEL newdiskui = {newdisk_title, str_d88, newdisk_filter, 1};  static const FILESEL newdiskui = {newdisk_title, str_d88, newdisk_filter, 1};
   
   
 // ----  // ----
   
 void dialog_changefdd(HWND hWnd, BYTE drv) {  void dialog_changefdd(HWND hWnd, REG8 drv) {
   
 const char      *p;  const TCHAR     *p;
           TCHAR   path[MAX_PATH];
         int             readonly;          int             readonly;
   
         if (drv < 4) {          if (drv < 4) {
                 p = dlgs_selectfile(hWnd, &fddui, fdd_diskname(drv),                  p = fdd_diskname(drv);
                                                                         fddfolder, sizeof(fddfolder), &readonly);                  if ((p == NULL) || (p[0] == '\0')) {
                 if (p != NULL) {                          p = fddfolder;
                         diskdrv_setfdd(drv, p, readonly);                  }
                   file_cpyname(path, p, NELEMENTS(path));
                   if (dlgs_selectfile(hWnd, &fddui, path, NELEMENTS(path), &readonly)) {
                           file_cpyname(fddfolder, path, NELEMENTS(fddfolder));
                           sysmng_update(SYS_UPDATEOSCFG);
                           diskdrv_setfdd(drv, path, readonly);
                 }                  }
         }          }
 }  }
   
 void dialog_changehdd(HWND hWnd, BYTE drv) {  void dialog_changehdd(HWND hWnd, REG8 drv) {
   
 const char *p;  
   
         if (drv < 2) {          UINT            num;
                 p = dlgs_selectfile(hWnd, &hddui, np2cfg.hddfile[drv],  const TCHAR             *p;
                                                                         hddfolder, sizeof(hddfolder), NULL);  const FILESEL   *hddui;
                 if (p != NULL) {          TCHAR           path[MAX_PATH];
                         diskdrv_sethdd(drv, p);  
           num = drv & 0x0f;
           p = NULL;
           hddui = NULL;
           if (!(drv & 0x20)) {            // SASI/IDE
                   if (num < 2) {
                           p = np2cfg.sasihdd[num];
                           hddui = &sasiui;
                   }
           }
   #if defined(SUPPORT_SCSI)
           else {                                          // SCSI
                   if (num < 4) {
                           p = np2cfg.scsihdd[num];
                           hddui = &scsiui;
                 }                  }
         }          }
   #endif
           if (hddui == NULL) {
                   return;
           }
           if (p[0] == '\0') {
                   p = hddfolder;
           }
           file_cpyname(path, p, NELEMENTS(path));
           if (dlgs_selectfile(hWnd, hddui, path, NELEMENTS(path), NULL)) {
                   file_cpyname(hddfolder, path, NELEMENTS(hddfolder));
                   sysmng_update(SYS_UPDATEOSCFG);
                   diskdrv_sethdd(drv, path);
           }
 }  }
   
   
 // ---- newdisk  // ---- newdisk
   
 static const char str_newdisk[] = "newdisk";  static const TCHAR str_newdisk[] = _T("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] = {
                                   IDC_NEWSASI5MB, IDC_NEWSASI10MB,
                                   IDC_NEWSASI15MB, IDC_NEWSASI20MB,
                                   IDC_NEWSASI30MB, IDC_NEWSASI40MB};
   
 static  BYTE    makefdtype = DISKTYPE_2HD << 4;  static  BYTE    makefdtype = DISKTYPE_2HD << 4;
 static  char    disklabel[16+1];  static  TCHAR   disklabel[16+1];
 static  UINT    hddsize;  static  UINT    hddsize;
   static  UINT    hddminsize;
   static  UINT    hddmaxsize;
   
 static LRESULT CALLBACK NewHddDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK NewHddDlgProc(HWND hWnd, UINT msg,
                                                                                                         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);
                           wsprintf(work, _T("(%d-%dMB)"), hddminsize, hddmaxsize);
                           SetWindowText(GetDlgItem(hWnd, IDC_HDDLIMIT), work);
                         SetFocus(GetDlgItem(hWnd, IDC_HDDSIZE));                          SetFocus(GetDlgItem(hWnd, IDC_HDDSIZE));
                         return(FALSE);                          return(FALSE);
   
Line 98  static LRESULT CALLBACK NewHddDlgProc(HW Line 170  static LRESULT CALLBACK NewHddDlgProc(HW
                         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)milstr_solveINT(work);
                                         if (val < 0) {                                          if (val < hddminsize) {
                                                 val = 0;                                                  val = hddminsize;
                                         }                                          }
                                         else if (val > 512) {                                          else if (val > hddmaxsize) {
                                                 val = 512;                                                  val = hddmaxsize;
                                           }
                                           hddsize = val;
                                           EndDialog(hWnd, IDOK);
                                           break;
   
                                   case IDCANCEL:
                                           EndDialog(hWnd, IDCANCEL);
                                           break;
   
                                   default:
                                           return(FALSE);
                           }
                           break;
   
                   case WM_CLOSE:
                           PostMessage(hWnd, WM_COMMAND, IDCANCEL, 0);
                           break;
   
                   default:
                           return(FALSE);
           }
           return(TRUE);
   }
   
   static LRESULT CALLBACK NewSASIDlgProc(HWND hWnd, UINT msg,
                                                                                                           WPARAM wp, LPARAM lp) {
   
           UINT    val;
   
           switch (msg) {
                   case WM_INITDIALOG:
                           SetFocus(GetDlgItem(hWnd, IDC_NEWSASI5MB));
                           return(FALSE);
   
                   case WM_COMMAND:
                           switch (LOWORD(wp)) {
                                   case IDOK:
                                           for (val=0; val<6; val++) {
                                                   if (GetDlgItemCheck(hWnd, sasires[val])) {
                                                           break;
                                                   }
                                           }
                                           if (val > 3) {
                                                   val++;
                                         }                                          }
                                         hddsize = val;                                          hddsize = val;
                                         EndDialog(hWnd, IDOK);                                          EndDialog(hWnd, IDOK);
Line 132  static LRESULT CALLBACK NewHddDlgProc(HW Line 248  static LRESULT CALLBACK NewHddDlgProc(HW
 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;
   
         switch (msg) {          switch (msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
Line 157  static LRESULT CALLBACK NewdiskDlgProc(H Line 273  static LRESULT CALLBACK NewdiskDlgProc(H
                         switch (LOWORD(wp)) {                          switch (LOWORD(wp)) {
                                 case IDOK:                                  case IDOK:
                                         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';
                                         }                                          }
                                         if (GetDlgItemCheck(hWnd, IDC_MAKE2DD)) {                                          if (GetDlgItemCheck(hWnd, IDC_MAKE2DD)) {
                                                 makefdtype = (DISKTYPE_2DD << 4);                                                  makefdtype = (DISKTYPE_2DD << 4);
Line 194  static LRESULT CALLBACK NewdiskDlgProc(H Line 310  static LRESULT CALLBACK NewdiskDlgProc(H
   
 void dialog_newdisk(HWND hWnd) {  void dialog_newdisk(HWND hWnd) {
   
         char            path[MAX_PATH];          TCHAR           path[MAX_PATH];
 const char              *p;  
         HINSTANCE       hinst;          HINSTANCE       hinst;
   const TCHAR             *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));
   
         p = dlgs_selectwritefile(hWnd, &newdiskui, path, NULL, 0);          if (!dlgs_selectwritefile(hWnd, &newdiskui, path, NELEMENTS(path))) {
         if (p == NULL) {  
                 return;                  return;
         }          }
         hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);  
         if (!file_cmpname(file_getext((char *)p), str_thd)) {  #if defined(_WIN64)
           hinst = reinterpret_cast<HINSTANCE>(::GetWindowLongPtr(hWnd, GWLP_HINSTANCE));
   #else
           hinst = reinterpret_cast<HINSTANCE>(::GetWindowLong(hWnd, GWL_HINSTANCE));
   #endif
   
           ext = file_getext(path);
           if (!file_cmpname(ext, str_thd)) {
                   hddsize = 0;
                   hddminsize = 5;
                   hddmaxsize = 256;
                   if (DialogBox(hinst, MAKEINTRESOURCE(IDD_NEWHDDDISK),
                                                                           hWnd, (DLGPROC)NewHddDlgProc) == IDOK) {
                           newdisk_thd(path, hddsize);
                   }
           }
           else if (!file_cmpname(ext, str_nhd)) {
                   hddsize = 0;
                   hddminsize = 5;
                   hddmaxsize = 512;
                   if (DialogBox(hinst, MAKEINTRESOURCE(IDD_NEWHDDDISK),
                                                                           hWnd, (DLGPROC)NewHddDlgProc) == IDOK) {
                           newdisk_nhd(path, hddsize);
                   }
           }
           else if (!file_cmpname(ext, str_hdi)) {
                   hddsize = 7;
                   if (DialogBox(hinst, MAKEINTRESOURCE(IDD_NEWSASI),
                                                                           hWnd, (DLGPROC)NewSASIDlgProc) == IDOK) {
                           newdisk_hdi(path, hddsize);
                   }
           }
   #if defined(SUPPORT_SCSI)
           else if (!file_cmpname(ext, str_hdd)) {
                 hddsize = 0;                  hddsize = 0;
                   hddminsize = 2;
                   hddmaxsize = 512;
                 if (DialogBox(hinst, MAKEINTRESOURCE(IDD_NEWHDDDISK),                  if (DialogBox(hinst, MAKEINTRESOURCE(IDD_NEWHDDDISK),
                                                                         hWnd, (DLGPROC)NewHddDlgProc) == IDOK) {                                                                          hWnd, (DLGPROC)NewHddDlgProc) == IDOK) {
                         newdisk_hdd(p, hddsize);        // (hddsize < 5) || (hddsize > 256)                          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) {
                         newdisk_fdd(p, makefdtype, disklabel);                          newdisk_fdd(path, makefdtype, disklabel);
                 }                  }
         }          }
 }  }
Removed from v.1.1.1.1  
changed lines
  Added in v.1.7

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