Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
chkdsk.c
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 171k
Category:

Windows Kernel

Development Platform:

Visual C++

chkdsk.c：Code Content
  1. //
  2. // chkdsk.c : Control Panel Applet for Windows Disk Manager
  3. //
  5. #include "shprv.h"
  7. #include <dskmaint.h>
  8. #include <prsht.h>
  9. #include <regstr.h>
  10. #include <winerror.h>
  12. #include <memory.h>
  13. #include "util.h"
  14. #include "format.h"
  15. #include <help.h>
  17. #ifdef FROSTING
  18. #ifndef REGSTR_PATH_SCANDSKW_SAGESET
  19. #define REGSTR_PATH_SCANDSKW_SAGESET "Software\Microsoft\Plus!\System Agent\SAGE\ScanDisk for Windows\Set%lu"
  20. #endif
  22. #ifndef REGSTR_PATH_CHECKDISKDRIVES
  23. #define REGSTR_PATH_CHECKDISKDRIVES   "DrivesToCheck"
  24. #endif
  25. #endif
  27. //#define DOSETUPCHK 1
  29. #ifdef DOSETUPCHK
  30. typedef DWORD (WINAPI *DMaint_CheckDriveSetupPROC)(UINT Drive, DWORD Options, DSKUTILCBPROC lpfnCallBack, LPARAM lRefData);
  31. #endif
  33. #define g_hInstance g_hinst
  34. static  char g_szNULL[] = "";   // c_szNull
  36. HIMAGELIST g_himlIconsSmall = NULL;
  37. int g_cxIcon;
  38. int g_cyIcon;
  39. HWND g_ChkWndPar = NULL;
  40. ATOM g_ChkWndClass = 0;
  42. static DWORD FORMATSEG ChkaIds[]={DLGCHK_START,   IDH_WINDISK_MAIN_START,
  43.   DLGCHK_CANCEL,  IDH_WINDISK_MAIN_CLOSE,
  44.   DLGCHK_PBAR,   0xFFFFFFFFL,
  45.   DLGCHK_STATTXT, 0xFFFFFFFFL,
  46.   DLGCHK_STATTXT2,0xFFFFFFFFL,
  47.   DLGCHK_ADVANCED,IDH_WINDISK_MAIN_ADVANCED,
  48.   DLGCHK_DRVLIST, IDH_WINDISK_MAIN_LIST,
  49.   DLGCHK_DOBAD,   IDH_WINDISK_MAIN_THOROUGH,
  50.   DLGCHK_BADOPT,  IDH_WINDISK_MAIN_OPTIONS,
  51.   DLGCHK_AUTOFIX, IDH_WINDISK_MAIN_AUTOFIX,
  52.   DLGCHK_NOBADB,  IDH_WINDISK_MAIN_STANDARD,
  53.   DLGCHK_DTXT1,   IDH_WINDISK_MAIN_STANDARD,
  54.   DLGCHK_DTXT2,   IDH_WINDISK_MAIN_THOROUGH,
  55.   IDC_ICON_1,     0xFFFFFFFFL,
  56.   IDC_TEXT,       IDH_WINDISK_MAIN_LIST,
  57.   IDC_GROUPBOX_1, IDH_COMM_GROUPBOX,
  58.   0,0};
  60. #ifdef OPK2
  61. static DWORD FORMATSEG ChkaIdsSage[]={DLGCHK_START,   IDH_OK,
  62.       DLGCHK_CANCEL,  IDH_CANCEL,
  63.       DLGCHK_PBAR,    0xFFFFFFFFL,
  64.       DLGCHK_STATTXT, 0xFFFFFFFFL,
  65.       DLGCHK_STATTXT2,0xFFFFFFFFL,
  66.       DLGCHK_ADVANCED,IDH_WINDISK_MAIN_ADVANCED,
  67.       DLGCHK_DRVLIST, IDH_WINDISK_MAIN_LIST,
  68.       DLGCHK_DOBAD,   IDH_WINDISK_MAIN_THOROUGH,
  69.       DLGCHK_BADOPT,  IDH_WINDISK_MAIN_OPTIONS,
  70.       DLGCHK_AUTOFIX, IDH_WINDISK_MAIN_AUTOFIX,
  71.       DLGCHK_NOBADB,  IDH_WINDISK_MAIN_STANDARD,
  72.       DLGCHK_DTXT1,   IDH_WINDISK_MAIN_STANDARD,
  73.       DLGCHK_DTXT2,   IDH_WINDISK_MAIN_THOROUGH,
  74.       IDC_ICON_1,     0xFFFFFFFFL,
  75.       IDC_TEXT,       IDH_WINDISK_MAIN_LIST,
  76.       IDC_GROUPBOX_1, IDH_COMM_GROUPBOX,
  77.       0,0};
  78. #endif
  80. static DWORD FORMATSEG ChkAdvaIds[]={DLGCHKADV_OK,  IDH_OK,
  81.      DLGCHKADV_CANCEL,  IDH_CANCEL,
  82.      DLGCHKADV_LSTF,  IDH_WINDISK_ADV_FREE,
  83.      DLGCHKADV_LSTMF,  IDH_WINDISK_ADV_CONVERT,
  84.      DLGCHKADV_XLDEL,  IDH_WINDISK_ADV_DELETE,
  85.      DLGCHKADV_XLCPY,  IDH_WINDISK_ADV_MAKE_COPIES,
  86.      DLGCHKADV_XLIGN,  IDH_WINDISK_ADV_IGNORE,
  87.      DLGCHKADV_CHKDT,  IDH_WINDISK_ADV_DATE_TIME,
  88.      DLGCHKADV_CHKNM,  IDH_WINDISK_ADV_FILENAME,
  89.      DLGCHKADV_CHKHST,  IDH_WINDISK_ADV_CHECK_HOST,
  90.      DLGCHKADV_REPALWAYS,IDH_WINDISK_ADV_ALWAYS,
  91.      DLGCHKADV_NOREP,  IDH_WINDISK_ADV_NEVER,
  92.      DLGCHKADV_REPIFERR, IDH_WINDISK_ADV_ONLY_IF_FOUND,
  93.      DLGCHKADV_LOGREP,  IDH_WINDISK_REPLACE_LOG,
  94.      DLGCHKADV_LOGAPPND, IDH_WINDISK_APPEND_LOG,
  95.      DLGCHKADV_NOLOG,  IDH_WINDISK_NO_LOG,
  96.      IDC_GROUPBOX_1,     IDH_COMM_GROUPBOX,
  97.      IDC_GROUPBOX_2,     IDH_COMM_GROUPBOX,
  98.      IDC_GROUPBOX_3,     IDH_COMM_GROUPBOX,
  99.      IDC_GROUPBOX_4,     IDH_COMM_GROUPBOX,
  100.      IDC_GROUPBOX_5,  IDH_COMM_GROUPBOX,
  101.      0,0};
  103. static DWORD FORMATSEG ChkSAOaIds[]={DLGCHKSAO_OK,  IDH_OK,
  104.      DLGCHKSAO_CANCEL,  IDH_CANCEL,
  105.      DLGCHKSAO_NOWRTTST, IDH_WINDISK_OPTIONS_NO_WRITE_TEST,
  106.      DLGCHKSAO_ALLHIDSYS,IDH_WINDISK_OPTIONS_NO_HID_SYS,
  107.      DLGCHKSAO_DOALL,  IDH_WINDISK_OPTIONS_SYS_AND_DATA,
  108.      DLGCHKSAO_NOSYS,  IDH_WINDISK_OPTIONS_DATA_ONLY,
  109.      DLGCHKSAO_NODATA,  IDH_WINDISK_OPTIONS_SYS_ONLY,
  110.      IDC_GROUPBOX_1,  IDH_COMM_GROUPBOX,
  111.      IDC_TEXT,          0xFFFFFFFFL,
  112.      0,0};
  114. DWORD WINAPI SHGetFileInfo(LPCTSTR pszPath, DWORD dwFileAttributes, SHFILEINFO FAR * hfi, UINT cbFileInfo, UINT uFlags);
  116. // convert a file spec to make it look a bit better
  117. // if it is all upper case chars
  119. typedef struct _SHCHECKDISKINFO
  120. {
  121. DMAINTINFO sDMaint;
  122. LPMYCHKINFOSTRUCT lpMyChkInf;
  123. } SHCHECKDISKINFO, FAR *LPSHCHECKDISKINFO;
  126. #pragma optimize("lge",off)
  128. BOOL NEAR PASCAL SaveTimeInReg(HKEY hkRoot, LPCSTR pszSubKey,
  129.        LPCSTR pszValName, WORD ResultCode,
  130.        BOOL IsSysTime)
  131. {
  132.     DSKTLSYSTEMTIME systime;
  133.     BOOL     bRet;
  134.     HKEY     hk;
  136.     _asm {
  137. // Get the date information
  139. mov ah,2ah
  140. int 21h
  141. xor bx,bx
  143. mov systime.wYear,cx
  145. mov bl,dh
  146. mov systime.wMonth,bx
  148. mov bl,al
  149. mov systime.wDayOfWeek,bx
  151. mov bl,dl
  152. mov systime.wDay,bx
  154. // Get the time information
  156. mov ah,2ch
  157. int 21h
  158. xor bx,bx
  160. mov bl,ch
  161. mov systime.wHour,bx
  163. mov bl,cl
  164. mov systime.wMinute,bx
  166. mov bl,dh
  167. mov systime.wSecond,bx
  169. mov bl,dl
  170. mov systime.wMilliseconds,bx
  171.     }
  173.     systime.wResult = ResultCode;
  175.     // Convert from 1/100 second to 1/1000 second
  177.     systime.wMilliseconds *= 10;
  179.     if (RegCreateKey(hkRoot, pszSubKey, &hk) != ERROR_SUCCESS)
  180.     {
  181. return(FALSE);
  182.     }
  183.     if(IsSysTime)
  184.     {
  185. bRet = RegSetValueEx(hk, pszValName, 0, REG_BINARY,
  186.      (LPBYTE)&systime, (sizeof(systime) - 2)) == ERROR_SUCCESS;
  187.     } else {
  188. bRet = RegSetValueEx(hk, pszValName, 0, REG_BINARY,
  189.      (LPBYTE)&systime, sizeof(systime)) == ERROR_SUCCESS;
  190.     }
  191.     RegCloseKey(hk);
  193.     return(bRet);
  194. }
  196. //
  197. // Get the basic DBL/DRVSPACE info, in particular, what is the host drive
  198. // (return from function), and what is the extension of the volume CVF on
  199. // the host volume (returned in lpext).
  200. //
  201. WORD NEAR PASCAL GetCompInfo(UINT Drive, LPWORD lpext)
  202. {
  203.     WORD  HostDrive = 0xFFFF;
  204.     WORD  ext;
  206.     _asm {
  207. mov ax, 0x4A11
  208. xor bx, bx // 0 = check_version
  209. int 0x2F // Is DoubleSpace around?
  211. or ax, ax
  212. jnz notdouble // Nope.
  214. mov ax, 0x4A11 // DBLSPACE.BIN INT 2F number
  215. mov bx, 1 // 1 = GetDriveMap function
  216. mov dx, Drive
  217. int 0x2F // (bl AND 80h) == DS drive flag
  218. // (bl AND 7Fh) == host drive
  220. or ax, ax // Success?
  221. jnz notdouble // Nope.
  223. test bl, 0x80 // Is the drive compressed?
  224. jz notdouble //    NO
  226. // We have a DoubleSpace Drive, need to figure out host drive.
  227. //
  228. // This is tricky because of the manner in which DRV/DBLSPACE.BIN
  229. // keeps track of drives.
  230. //
  231. // For a swapped CVF, the current drive number of the host
  232. // drive is returned by the first GetDriveMap call.  But for
  233. // an unswapped CVF, we must make a second GetDriveMap call
  234. // on the "host" drive returned by the first call.  But, to
  235. // distinguish between swapped and unswapped CVFs, we must
  236. // make both of these calls.  So, we make them, and then check
  237. // the results.
  239. mov cl, bh
  240. xor ch, ch
  241. mov ext, cx  // Save the drive's extension
  242. and bl, 0x7F // bl = "host" drive number
  243. xor bh, bh
  244. mov HostDrive, bx // Save 1st host drive
  245. mov dl, bl // Set up for query of "host" drive
  247. mov ax, 0x4A11 // DBLSPACE.BIN INT 2F number
  248. mov bx, 1 // 1 = GetDriveMap function
  249. int 0x2F // (bl AND 7Fh) == 2nd host drive
  251. test bl, 80h  // Is the host a hard drive?
  252. jz gdiExit  // if so, it's the real host.
  254. and bx, 007Fh // Otherwise, this thing is swapped
  255. mov HostDrive, bx // with the host.
  256.       gdiExit:
  257.     }
  259.     *lpext = ext;
  261. notdouble:
  262.     return(HostDrive);
  263. }
  265. #pragma optimize("",on)
  268. BOOL NEAR SetDriveTitle(LPMYCHKINFOSTRUCT lpMyChkInf, HWND hwnd)
  269. {
  270.     int i;
  271.     PSTR        pMsgBuf;
  272.     LPSTR lpszReturn;
  273.     LPSTR lpszTemp;
  275. #ifdef FROSTING
  276.     if (lpMyChkInf->fSageSet)
  277.        return TRUE;
  278. #endif
  280. #define SZTEMPORARY 512
  281.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,sizeof(char) * SZTEMPORARY);
  282.     if (!pMsgBuf)
  283.         return FALSE;
  284.     
  285.     lpszTemp = (LPSTR)(pMsgBuf + (SZTEMPORARY/2));
  286.     lpszReturn = (LPSTR)pMsgBuf;
  287.     
  288.     // This dialog does not do the split drive title
  290.     if(lpMyChkInf->MyFixOpt & DLGCHK_RO)
  291.     {
  292.         i = IDS_CHKTIT3;
  293.     } else {
  294.         i = IDS_CHKTIT2;
  295.     }
  296.     LoadString(g_hInstance, i, lpszTemp, (SZTEMPORARY/2));
  298.     if((lpMyChkInf->IsSplitDrv) && (!(lpMyChkInf->DoingCompDrv)))
  299.     {
  300.         wsprintf(lpszReturn,lpszTemp,(LPSTR)lpMyChkInf->CompdriveNameStr);
  301.     } else {
  302.         wsprintf(lpszReturn,lpszTemp,(LPSTR)lpMyChkInf->lpwddi->driveNameStr);
  303.     }
  304.     
  305.     SetWindowText(hwnd,lpszReturn);
  306.     LocalFree((HANDLE)pMsgBuf);
  307.     return TRUE;
  308. }
  310. VOID NEAR SetStdChkTitle(LPMYCHKINFOSTRUCT lpMyChkInf, 
  311.  LPSTR lpszFormat,LPSTR lpszReturn,int cReturn)
  312. {
  313.     if((lpMyChkInf->IsSplitDrv) && (!(lpMyChkInf->DoingCompDrv)))
  314.     {
  315.         char szBuffer[128];
  316.         
  317. LoadString(g_hInstance, IDS_COMPDISKH, lpszReturn, cReturn);
  318. wsprintf((LPSTR)szBuffer,(LPSTR)lpszReturn,(LPSTR)lpMyChkInf->CompdriveNameStr);
  319. wsprintf((LPSTR)lpszReturn,(LPSTR)lpszFormat,(LPSTR)szBuffer);
  320.     } else {
  321. wsprintf((LPSTR)lpszReturn,(LPSTR)lpszFormat,
  322.                  (LPSTR)lpMyChkInf->lpwddi->driveNameStr);
  323.     }
  324. }
  326. #if 0 // unused
  327. WORD FAR  MyChkdskMessageBoxBuf(LPMYCHKINFOSTRUCT lpMyChkInf,
  328. LPSTR lpMsgBuf, WORD BoxStyle)
  329. {
  330.     PSTR       pMsgBuf;
  331.     WORD       j;
  333. #define SZTYPBUF11     120
  334. #define SZTITBUF11     120
  335. #define SZFMTBUF11     128
  336. #define TOTMSZ11       (SZTYPBUF11+SZTITBUF11+SZFMTBUF11)
  338. #define TypeBuf11 (&(pMsgBuf[0]))
  339. #define TitBuf11  (&(pMsgBuf[SZTYPBUF11]))
  340. #define FmtBuf11  (&(pMsgBuf[SZTYPBUF11+SZTITBUF11]))
  342.     if(lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND))
  343.     {
  344. switch(BoxStyle & MB_TYPEMASK)
  345. {
  346.     case MB_ABORTRETRYIGNORE:
  347. switch(BoxStyle & MB_DEFMASK)
  348. {
  349.     case MB_DEFBUTTON3:
  350. return(IDIGNORE);
  351. break;
  353.     case MB_DEFBUTTON2:
  354. return(IDRETRY);
  355. break;
  357.     case MB_DEFBUTTON1:
  358.     default:
  359. return(IDABORT);
  360. break;
  361. }
  362. break;
  364.     case MB_YESNOCANCEL:
  365. switch(BoxStyle & MB_DEFMASK)
  366. {
  367.     case MB_DEFBUTTON3:
  368. return(IDCANCEL);
  369. break;
  371.     case MB_DEFBUTTON2:
  372. return(IDNO);
  373. break;
  375.     case MB_DEFBUTTON1:
  376.     default:
  377. return(IDYES);
  378. break;
  379. }
  380. break;
  382.     case MB_YESNO:
  383. if((BoxStyle & MB_DEFMASK) == MB_DEFBUTTON1)
  384.     return(IDYES);
  385. else
  386.     return(IDNO);
  387. break;
  389.     case MB_RETRYCANCEL:
  390. if((BoxStyle & MB_DEFMASK) == MB_DEFBUTTON1)
  391.     return(IDRETRY);
  392. else
  393.     return(IDCANCEL);
  394. break;
  396.     case MB_OKCANCEL:
  397. if((BoxStyle & MB_DEFMASK) == MB_DEFBUTTON1)
  398.     return(IDOK);
  399. else
  400.     return(IDCANCEL);
  401. break;
  403.     case MB_OK:
  404.     default:
  405. return(IDOK);
  406. break;
  407. }
  408.     }
  409.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ11);
  410.     if(!pMsgBuf)
  411.     {
  412. // BUG BUG
  413. return(IDCANCEL);
  414.     }
  416.     LoadString(g_hInstance, IDS_DRIVETITLEC, FmtBuf11, SZFMTBUF11);
  417.     SetStdChkTitle(lpMyChkInf, FmtBuf11, TitBuf11, SZFMTBUF11);
  418.     j = MessageBox(lpMyChkInf->hProgDlgWnd,lpMsgBuf,TitBuf11,BoxStyle);
  420.     LocalFree((HANDLE)pMsgBuf);
  422.     return(j);
  423. }
  424. #endif
  426. WORD FAR  MyChkdskMessageBox(LPMYCHKINFOSTRUCT lpMyChkInf,
  427.      WORD MsgID, WORD BoxStyle)
  428. {
  429.     PSTR       pMsgBuf;
  430.     WORD       j;
  432. #define SZMSGBUF12     256
  433. #define SZTYPBUF12     120
  434. #define SZTITBUF12     120
  435. #define SZFMTBUF12     128
  436. #define TOTMSZ12       (SZMSGBUF12+SZTYPBUF12+SZTITBUF12+SZFMTBUF12)
  438. #define MsgBuf12  (&(pMsgBuf[0]))
  439. //#define TypeBuf12 (&(pMsgBuf[SZMSGBUF12]))
  440. #define TitBuf12  (&(pMsgBuf[SZMSGBUF12+SZTYPBUF12]))
  441. #define FmtBuf12  (&(pMsgBuf[SZMSGBUF12+SZTYPBUF12+SZTITBUF12]))
  443.     if(lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND))
  444.     {
  445. switch(BoxStyle & MB_TYPEMASK)
  446. {
  447.     case MB_ABORTRETRYIGNORE:
  448. switch(BoxStyle & MB_DEFMASK)
  449. {
  450.     case MB_DEFBUTTON3:
  451. return(IDIGNORE);
  452. break;
  454.     case MB_DEFBUTTON2:
  455. return(IDRETRY);
  456. break;
  458.     case MB_DEFBUTTON1:
  459.     default:
  460. return(IDABORT);
  461. break;
  462. }
  463. break;
  465.     case MB_YESNOCANCEL:
  466. switch(BoxStyle & MB_DEFMASK)
  467. {
  468.     case MB_DEFBUTTON3:
  469. return(IDCANCEL);
  470. break;
  472.     case MB_DEFBUTTON2:
  473. return(IDNO);
  474. break;
  476.     case MB_DEFBUTTON1:
  477.     default:
  478. return(IDYES);
  479. break;
  480. }
  481. break;
  483.     case MB_YESNO:
  484. if((BoxStyle & MB_DEFMASK) == MB_DEFBUTTON1)
  485.     return(IDYES);
  486. else
  487.     return(IDNO);
  488. break;
  490.     case MB_RETRYCANCEL:
  491. if((BoxStyle & MB_DEFMASK) == MB_DEFBUTTON1)
  492.     return(IDRETRY);
  493. else
  494.     return(IDCANCEL);
  495. break;
  497.     case MB_OKCANCEL:
  498. if((BoxStyle & MB_DEFMASK) == MB_DEFBUTTON1)
  499.     return(IDOK);
  500. else
  501.     return(IDCANCEL);
  502. break;
  504.     case MB_OK:
  505.     default:
  506. return(IDOK);
  507. break;
  508. }
  509.     }
  510.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ12);
  511.     if(!pMsgBuf)
  512.     {
  513. // BUG BUG
  514. return(IDCANCEL);
  515.     }
  517.     if((MsgID == IDS_CANTCHKALL) || (MsgID == IDS_NOSEL) || (MsgID == IDS_NOMEM2))
  518.     {
  519. LoadString(g_hInstance, IDS_CHKTIT, TitBuf12, SZTITBUF12);
  520.     } else {
  521. LoadString(g_hInstance, IDS_DRIVETITLEC, FmtBuf12, SZFMTBUF12);
  522.         
  523.         SetStdChkTitle(lpMyChkInf, FmtBuf12, TitBuf12, SZTITBUF12);
  524.     }
  526.     LoadString(g_hInstance, MsgID, MsgBuf12, SZMSGBUF12);
  528.     j = MessageBox(lpMyChkInf->hProgDlgWnd,MsgBuf12,TitBuf12,BoxStyle);
  530.     LocalFree((HANDLE)pMsgBuf);
  532.     return(j);
  533. }
  535. #ifdef FROSTING
  536. DWORD NEAR ChkFindHiddenDrives (VOID)
  537. {
  538.     HKEY   hKey;
  539.     DWORD  typ;
  540.     DWORD  sz;
  541.     DWORD  HiddenDrives = 0L;
  542.     char   RegKey[80];
  544.     lstrcpy(RegKey, REGSTR_PATH_POLICIES);
  545.     lstrcat(RegKey, "\Explorer");
  547.     if(RegOpenKey(HKEY_CURRENT_USER,RegKey,&hKey) == ERROR_SUCCESS)
  548.     {
  549. sz = sizeof(DWORD);
  550. if((RegQueryValueEx(hKey,"NoDrives",NULL,&typ,(LPBYTE)&HiddenDrives, &sz) != ERROR_SUCCESS) ||
  551.    (typ != REG_DWORD)  ||
  552.    (sz != 4L))
  553. {
  554.     HiddenDrives = 0L;
  555. }
  556. RegCloseKey(hKey);
  557.     }
  559.     return HiddenDrives;
  560. }
  562. DWORD NEAR ChkFindAllFixedDrives (VOID)
  563. {
  564.     DWORD FixedDrives = 0L;
  565.     DWORD HiddenDrives;
  566.     WORD  i;
  568.     HiddenDrives = ChkFindHiddenDrives();
  570.     for(i = 0; i < 26; i++)
  571.     {
  572. if(HiddenDrives & (0x00000001L << i))
  573.     continue;
  575. if((DriveType(i) == DRIVE_FIXED) || (DriveType(i) == DRIVE_RAMDRIVE))
  576. {
  577.     FixedDrives |= (0x00000001L << i);
  578. }
  579.     }
  581.     return FixedDrives;
  582. }
  584. BOOL NEAR ChkAreAllFixedDrivesSelected (DWORD DrivesToChk)
  585. {
  586.     DWORD FixedDrives;
  587.     WORD  i;
  589.     FixedDrives = ChkFindAllFixedDrives();
  591.     for(i = 0; i < 26; i++)
  592.     {
  593. if(FixedDrives & (0x00000001L << i))
  594. {
  595.     if(!(DrivesToChk & (0x00000001L << i)))
  596.         return FALSE;
  597. }
  598.     }
  600.     return TRUE;
  601. }
  602. #endif
  604. #ifndef cbMaxREGPATH
  605. #define cbMaxREGPATH     256
  606. #endif
  608. VOID NEAR GetChkRegOptions(LPMYCHKINFOSTRUCT lpMyChkInf)
  609. {
  610.     DWORD dwi;
  611.     DWORD typ;
  612.     DWORD sz;
  613.     HKEY  hKey;
  614. #ifdef FROSTING
  615.     char  keyname[ cbMaxREGPATH ];
  616.     LONG  rc;
  617. #endif
  620.     lpMyChkInf->RegOptions = MAKELONG((DLGCHK_NOBAD | DLGCHK_XLCPY   |
  621.        DLGCHK_INTER | DLGCHK_NOCHKDT |
  622.        DLGCHK_LSTMF | DLGCHK_REP),
  623.       0);
  624. #ifdef OPK2
  625. #ifdef FROSTING
  626.     if(lpMyChkInf->fSageSet)
  627. lpMyChkInf->RegOptions |= MAKELONG(0,DLGCHK_REPONLYERR);
  628. #endif
  629. #endif
  630.     lpMyChkInf->NoUnsupDrvs = 0L;
  631.     if(RegOpenKey(HKEY_CURRENT_USER,REGSTR_PATH_CHECKDISK,&hKey) == ERROR_SUCCESS)
  632.     {
  633. #ifndef FROSTING
  634.       sz = sizeof(DWORD);
  635.       if((RegQueryValueEx(hKey,REGSTR_PATH_CHECKDISKSET,NULL,&typ,(LPBYTE)&dwi, &sz) == ERROR_SUCCESS) &&
  636.  (typ == REG_BINARY)  &&
  637.  (sz == 4L))
  638.       {
  639.   lpMyChkInf->RegOptions = dwi;
  640.       }
  641. #endif
  642.       sz = sizeof(DWORD);
  643.       if((RegQueryValueEx(hKey,REGSTR_PATH_CHECKDISKUDRVS,NULL,&typ,(LPBYTE)&dwi, &sz) == ERROR_SUCCESS) &&
  644.  (typ == REG_BINARY)  &&
  645.  (sz == 4L))
  646.       {
  647.   lpMyChkInf->NoUnsupDrvs = dwi;
  648.       }
  649.       RegCloseKey(hKey);
  650.     }
  652. #ifdef FROSTING
  653.     if (lpMyChkInf->idxSettings == (DWORD)0xFFFFFFFF) {
  654. rc = RegOpenKey(HKEY_CURRENT_USER,REGSTR_PATH_CHECKDISK,&hKey);
  655.     } else {
  656. lpMyChkInf->DrivesToChk = 0L;
  657. wsprintf (keyname, REGSTR_PATH_SCANDSKW_SAGESET, lpMyChkInf->idxSettings);
  658. rc = RegOpenKey(HKEY_LOCAL_MACHINE,keyname,&hKey);
  659.     }
  661.     if(rc == ERROR_SUCCESS)
  662.     {
  663. sz = sizeof(DWORD);
  664. rc = RegQueryValueEx(hKey,REGSTR_PATH_CHECKDISKSET,NULL,
  665. &typ,(LPBYTE)&dwi, &sz);
  666. if((rc == ERROR_SUCCESS) && (typ == REG_BINARY)  && (sz == 4L))
  667. {
  668.     lpMyChkInf->RegOptions = dwi;
  669. }
  671. if(lpMyChkInf->idxSettings != (DWORD)0xFFFFFFFF)
  672. {
  673.     sz = sizeof(DWORD);
  674.     rc = RegQueryValueEx(hKey,REGSTR_PATH_CHECKDISKDRIVES,NULL,
  675.     &typ,(LPBYTE)&dwi, &sz);
  676.     if((rc == ERROR_SUCCESS) && (typ == REG_BINARY) && (sz == 4L))
  677.     {
  678. lpMyChkInf->DrivesToChk = dwi;
  680. if (lpMyChkInf->DrivesToChk & DTC_ALLFIXEDDRIVES)
  681. {
  682.     lpMyChkInf->DrivesToChk &= ~DTC_ALLFIXEDDRIVES;
  683.     lpMyChkInf->DrivesToChk |= ChkFindAllFixedDrives();
  684. }
  685.     }
  686. }
  688. RegCloseKey(hKey);
  689.     }
  691.     if((lpMyChkInf->idxSettings != (DWORD)0xFFFFFFFF) && (lpMyChkInf->DrivesToChk == 0L))
  692.     {
  693. lpMyChkInf->DrivesToChk = ChkFindAllFixedDrives();
  694.     }
  695. #endif
  697.     return;
  698. }
  700. #ifdef FROSTING
  701. VOID NEAR SetChkRegOptions(DWORD options, DWORD NoUnsupDrvs,
  702.    DWORD DrivesToChk, DWORD idxSettings)
  703. #else
  704. VOID NEAR SetChkRegOptions(DWORD options, DWORD NoUnsupDrvs)
  705. #endif
  706. {
  707.     HKEY  hKey;
  709. #ifndef FROSTING
  710.     if(RegOpenKey(HKEY_CURRENT_USER,REGSTR_PATH_CHECKDISK,&hKey) == ERROR_SUCCESS)
  711.     {
  712. SetIt:
  713.       RegSetValueEx(hKey,REGSTR_PATH_CHECKDISKSET,NULL,REG_BINARY,(LPBYTE)&options,sizeof(DWORD));
  714.       RegSetValueEx(hKey,REGSTR_PATH_CHECKDISKUDRVS,NULL,REG_BINARY,(LPBYTE)&NoUnsupDrvs,sizeof(DWORD));
  715.       RegCloseKey(hKey);
  716.     } else {
  717.       if(RegCreateKey(HKEY_CURRENT_USER,REGSTR_PATH_CHECKDISK,&hKey) == ERROR_SUCCESS)
  718.       {
  719.   goto SetIt;
  720.       }
  721.     }
  722. #else
  723.     char  keyname[ cbMaxREGPATH ];
  724.     LONG  rc;
  726.     rc = RegCreateKey(HKEY_CURRENT_USER,REGSTR_PATH_CHECKDISK,&hKey);
  727.     if(rc == ERROR_SUCCESS)
  728.     {
  729. RegSetValueEx(hKey,REGSTR_PATH_CHECKDISKUDRVS,NULL,
  730.       REG_BINARY,(LPBYTE)&NoUnsupDrvs,sizeof(DWORD));
  731. RegCloseKey(hKey);
  732.     }
  734.     if (idxSettings == (DWORD)0xFFFFFFFF) {
  735. rc = RegCreateKey(HKEY_CURRENT_USER,REGSTR_PATH_CHECKDISK,&hKey);
  736.     } else {
  737. wsprintf(keyname, REGSTR_PATH_SCANDSKW_SAGESET, idxSettings);
  738. rc = RegCreateKey(HKEY_LOCAL_MACHINE,keyname,&hKey);
  739.     }
  741.     if(rc == ERROR_SUCCESS)
  742.     {
  743. options &= ~(SHCHK_OPT_SAGESET | SHCHK_OPT_SAGERUN);
  744. RegSetValueEx(hKey,REGSTR_PATH_CHECKDISKSET,NULL,
  745.       REG_BINARY,(LPBYTE)&options,sizeof(DWORD));
  747. if (idxSettings != (DWORD)0xFFFFFFFF)
  748. {
  749.     if(ChkAreAllFixedDrivesSelected (DrivesToChk))
  750.         DrivesToChk |= DTC_ALLFIXEDDRIVES;
  751.     RegSetValueEx(hKey,REGSTR_PATH_CHECKDISKDRIVES,NULL,
  752.   REG_BINARY,(LPBYTE)&DrivesToChk,sizeof(DWORD));
  753. }
  754. RegCloseKey(hKey);
  755.     }
  756. #endif
  758.     return;
  759. }
  761. #define SZBUFA3       256
  762. #define SZBUFB3       256
  763. #define SZBUFC3       256
  764. #define SZBUFD3       256
  765. #define SZBUFE3       256
  766. #define TOTMSZ3       (SZBUFA3+SZBUFB3+SZBUFC3+SZBUFD3+SZBUFE3)
  768. #define bBuf1 (&(pMsgBuf[0]))
  769. #define bBuf2 (&(pMsgBuf[SZBUFA3]))
  770. #define bBuf3 (&(pMsgBuf[SZBUFA3+SZBUFB3]))
  771. #define bBuf4 (&(pMsgBuf[SZBUFA3+SZBUFB3+SZBUFC3]))
  772. #define bBuf5 (&(pMsgBuf[SZBUFA3+SZBUFB3+SZBUFC3+SZBUFD3]))
  775. LRESULT CALLBACK ChkCBProc(UINT msg, LPARAM lRefData, LPARAM lParam1,
  776.    LPARAM lParam2, LPARAM lParam3,
  777.    LPARAM lParam4, LPARAM lParam5)
  778. {
  779.     LPMYCHKINFOSTRUCT  lpMyChkInf;
  780.     DLGPROC        lpfnDlgProc;
  781.     DWORD        dwi;
  782.     BOOL        PMRet;
  783.     MSG         wmsg;
  784.     WORD        i;
  785.     WORD        j;
  786.     PSTR        pMsgBuf;
  787.     BYTE        LabBuf[20];
  788. #ifdef FROSTING
  789.     DWORD              LockWrtRestartMax;
  790. #endif
  793. #define SZBUFA4       128
  794. #define SZBUFB4       128
  795. #define SZBUFC4       512
  796. #define TOTMSZ4       (SZBUFC4+SZBUFA4+SZBUFB4)
  798. #define dBuf3 (&(pMsgBuf[0]))
  799. #define dBuf1 (&(pMsgBuf[SZBUFC4]))
  800. #define dBuf2 (&(pMsgBuf[SZBUFC4+SZBUFA4]))
  802.     lpMyChkInf   = (LPMYCHKINFOSTRUCT)lRefData;
  803.     lpMyChkInf->lpFixFDisp   = (LPFIXFATDISP)lParam1;
  804.     pMsgBuf   = 0;
  805.     lpMyChkInf->lParam1    = lParam1;
  806.     lpMyChkInf->lParam2    = lParam2;
  807.     lpMyChkInf->lParam3    = lParam3;
  808.     lpMyChkInf->lParam4    = lParam4;
  809.     lpMyChkInf->lParam5    = lParam5;
  810.     lpMyChkInf->IsFolder   = FALSE;
  811.     lpMyChkInf->IsRootFolder   = FALSE;
  812.     lpMyChkInf->UseAltDlgTxt   = FALSE;
  813.     lpMyChkInf->UseAltDefBut   = FALSE;
  814.     lpMyChkInf->CancelIsDefault   = FALSE;
  815.     lpMyChkInf->AltDefButIndx   = 0;
  816.     lpMyChkInf->UseAltCantFix   = FALSE;
  817.     lpMyChkInf->AltCantFixTstFlag = 0;
  818.     lpMyChkInf->AltCantFixHID   = 0xFFFFFFFFL;
  819.     lpMyChkInf->AltCantFixRepHID  = 0xFFFFFFFFL;
  821.     switch(msg)
  822.     {
  823. case DU_ERRORDETECTED:
  824.     SEAddToLogRCS(lpMyChkInf,IDL_CRLF,NULL);
  826.     if((LOWORD(lpMyChkInf->lParam2) != WRITEERROR) &&
  827.        (LOWORD(lpMyChkInf->lParam2) != READERROR)    )
  828.     {
  829. lpMyChkInf->RWRstsrtCnt   = 0;
  830.     }
  832.     switch(LOWORD(lpMyChkInf->lParam2)) {
  834. case ERRLOCKV: // This will get logged on engine return
  835.     return(0L);
  836.     break;
  838. case WRITEERROR:
  839.     if(HIWORD(lpMyChkInf->lParam2) & FILCOLL)
  840.     {
  841. //
  842. // We will handle this on DU_ERRORCORRECTED
  843. //
  844. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN);
  845. return(lpMyChkInf->FixRet);
  846.     }
  847.     if(HIWORD(lpMyChkInf->lParam3) == 21)
  848.     {
  849. lpMyChkInf->iErr = IERR_READERR1;
  850.     } else if(HIWORD(lpMyChkInf->lParam3) == 19) {
  851. lpMyChkInf->iErr = IERR_WRITEERR1;
  852.     } else {
  853. if(lpMyChkInf->lpwddi->TypeFlags & DT_DBLDISK)
  854. {
  855.     if((!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOCHKHST)) &&
  856.        (!(lpMyChkInf->MyFixOpt & (DLGCHK_NOBAD |
  857.   DLGCHK_NODATA |
  858.   DLGCHK_NOSYS)  ))    )
  859.     {
  860. lpMyChkInf->iErr = IERR_WRITEERR2;
  861. if(!(LOWORD(lpMyChkInf->lParam3) & RETRY))
  862. {
  863.     lpMyChkInf->RWRstsrtCnt++;
  864.     if(lpMyChkInf->RWRstsrtCnt > 1)
  865.     {
  866. goto DontRestrt1;
  867.     }
  868.     lpMyChkInf->FixRet = MAKELONG(0,ERETRETRY);
  869.     goto LogAutoErr;
  870. }
  871. DontRestrt1:
  872. ;
  873.     } else {
  874. if(HIWORD(lpMyChkInf->lParam2) & ERRDATA)
  875. {
  876.     lpMyChkInf->iErr = IERR_WRITEERR6;
  877. } else {
  878.     lpMyChkInf->iErr = IERR_WRITEERR5;
  879. }
  880.     }
  881. } else {
  882.     if(!(lpMyChkInf->MyFixOpt & (DLGCHK_NOBAD |
  883.  DLGCHK_NODATA |
  884.  DLGCHK_NOSYS) ))
  885.     {
  886. lpMyChkInf->iErr = IERR_WRITEERR2;
  887. if(!(LOWORD(lpMyChkInf->lParam3) & RETRY))
  888. {
  889.     lpMyChkInf->RWRstsrtCnt++;
  890.     if(lpMyChkInf->RWRstsrtCnt > 1)
  891.     {
  892. goto DontRestrt2;
  893.     }
  894.     lpMyChkInf->FixRet = MAKELONG(0,ERETRETRY);
  895.     goto LogAutoErr;
  896. }
  897. DontRestrt2:
  898. ;
  899.     } else {
  900. if(HIWORD(lpMyChkInf->lParam2) & ERRDATA)
  901. {
  902.     lpMyChkInf->iErr = IERR_WRITEERR4;
  903. } else {
  904.     lpMyChkInf->iErr = IERR_WRITEERR3;
  905. }
  906.     }
  907. }
  908.     }
  909.     goto DoNFErrFIgn;
  910.     break;
  912. case READERROR:
  913.     if(HIWORD(lpMyChkInf->lParam3) == 21)
  914.     {
  915. lpMyChkInf->iErr = IERR_READERR1;
  916.     } else {
  917. if(lpMyChkInf->lpwddi->TypeFlags & DT_DBLDISK)
  918. {
  919.     if((!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOCHKHST)) &&
  920.        (!(lpMyChkInf->MyFixOpt & (DLGCHK_NOBAD |
  921.   DLGCHK_NODATA |
  922.   DLGCHK_NOSYS)  ))    )
  923.     {
  924. lpMyChkInf->iErr = IERR_READERR2;
  925. if(!(LOWORD(lpMyChkInf->lParam3) & RETRY))
  926. {
  927.     lpMyChkInf->RWRstsrtCnt++;
  928.     if(lpMyChkInf->RWRstsrtCnt > 1)
  929.     {
  930. goto DontRestrt3;
  931.     }
  932.     lpMyChkInf->FixRet = MAKELONG(0,ERETRETRY);
  933.     goto LogAutoErr;
  934. }
  935. DontRestrt3:
  936. ;
  937.     } else {
  938. if(HIWORD(lpMyChkInf->lParam2) & ERRDATA)
  939. {
  940.     lpMyChkInf->iErr = IERR_READERR6;
  941. } else {
  942.     lpMyChkInf->iErr = IERR_READERR5;
  943. }
  944.     }
  945. } else {
  946.     if(!(lpMyChkInf->MyFixOpt & (DLGCHK_NOBAD |
  947.  DLGCHK_NODATA |
  948.  DLGCHK_NOSYS) ))
  949.     {
  950. lpMyChkInf->iErr = IERR_READERR2;
  951. if(!(LOWORD(lpMyChkInf->lParam3) & RETRY))
  952. {
  953.     lpMyChkInf->RWRstsrtCnt++;
  954.     if(lpMyChkInf->RWRstsrtCnt > 1)
  955.     {
  956. goto DontRestrt4;
  957.     }
  958.     lpMyChkInf->FixRet = MAKELONG(0,ERETRETRY);
  959.     goto LogAutoErr;
  960. }
  961. DontRestrt4:
  962. ;
  963.     } else {
  964. if(HIWORD(lpMyChkInf->lParam2) & ERRDATA)
  965. {
  966.     lpMyChkInf->iErr = IERR_READERR4;
  967. } else {
  968.     lpMyChkInf->iErr = IERR_READERR3;
  969. }
  970.     }
  971. }
  972.     }
  973.     goto DoNFErrFIgn;
  974.     break;
  976. case MEMORYERROR:
  977.     if(HIWORD(lpMyChkInf->lParam2) & LOCMEM)
  978.     {
  979. lpMyChkInf->UseAltDlgTxt = TRUE;
  980.     }
  981.     lpMyChkInf->iErr = IERR_ERRMEM;
  982. DoNFErrFIgn:
  983.     if(lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND))
  984.     {
  985. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN);
  986. goto LogAutoErr;
  987.     }
  988.     // This error is displayed even in non interactive
  989.     // mode.
  991.     goto DoNFErr;
  992.     break;
  994. case FATERRXLNK:
  995.     if(lpMyChkInf->MyFixOpt & DLGCHK_XLDEL)
  996.     {
  997. lpMyChkInf->UseAltDefBut = TRUE;
  998. lpMyChkInf->AltDefButIndx = 1;
  999.     } else if(!(lpMyChkInf->MyFixOpt & DLGCHK_XLCPY)) {
  1000. lpMyChkInf->UseAltDefBut = TRUE;
  1001. lpMyChkInf->AltDefButIndx = 5;
  1002.     }
  1004.     lpMyChkInf->iErr = IERR_FATXLNK;
  1005. DoXLDlg:
  1006.     lpfnDlgProc = SEXLDlgProc;
  1007.     i = IDD_XL_DLG;
  1009.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1010.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1011.     {
  1012. if(lpMyChkInf->MyFixOpt & DLGCHK_XLCPY)
  1013. {
  1014.     lpMyChkInf->FixRet = MAKELONG(0,ERETMKCPY);
  1015. } else if(lpMyChkInf->MyFixOpt & DLGCHK_XLDEL) {
  1016.     lpMyChkInf->FixRet = MAKELONG(0,ERETDELALL);
  1017. } else {
  1018.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN);
  1019. }
  1020. goto LogAutoErr;
  1021.     }
  1022. DoErrDlg:
  1023.     SEAddErrToLog(lpMyChkInf);
  1024.     if(lpfnDlgProc == 0L)
  1025.     {
  1026. NoMem:
  1027. SEAddToLogRCS(lpMyChkInf,IDL_NOMEMCAN,NULL);
  1028. MyChkdskMessageBox(lpMyChkInf, IDS_NOMEM2,
  1029.    MB_ICONINFORMATION | MB_OK);
  1030. return(MAKELONG(0,ERETCAN));
  1031.     }
  1032.     i = DialogBoxParam(g_hInstance,
  1033.        MAKEINTRESOURCE(i),
  1034.        lpMyChkInf->hProgDlgWnd,
  1035.        lpfnDlgProc,
  1036.        (LPARAM)lpMyChkInf);
  1037. #ifdef FROSTING
  1038. DontDoErrDlg:
  1039. #endif
  1040.     if(pMsgBuf)
  1041. LocalFree((HANDLE)pMsgBuf);
  1042.     pMsgBuf = 0;
  1043.     if(i == 0xFFFF)
  1044.     {
  1045. goto NoMem;
  1046.     }
  1047.     if(HIWORD(lpMyChkInf->FixRet) == RESTARTWITHCH)
  1048.     {
  1049. lpMyChkInf->DoCHRestart = TRUE;
  1050. lpMyChkInf->FixRet = MAKELONG(0,ERETCAN);
  1051.     }
  1052.     if(HIWORD(lpMyChkInf->FixRet) == RESTARTWITHSA)
  1053.     {
  1054. lpMyChkInf->DoSARestart = TRUE;
  1055. lpMyChkInf->FixRet = MAKELONG(0,ERETCAN);
  1056.     }
  1057. LogErrRet:
  1058.     SEAddRetToLog(lpMyChkInf);
  1059.     return(lpMyChkInf->FixRet);
  1060.     break;
  1062. case FATERRRESVAL:
  1063.     if(lpMyChkInf->lParam3 != 0L)
  1064.     {
  1065. lpMyChkInf->UseAltDlgTxt = TRUE;
  1066.     }
  1067.     lpMyChkInf->iErr = IERR_FATRESVAL;
  1068. DoNFErrFAfx:
  1069.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1070.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1071.     {
  1072. lpMyChkInf->FixRet = MAKELONG(0,ERETAFIX);
  1073. goto LogAutoErr;
  1074.     }
  1075. DoNFErr:
  1076.     lpfnDlgProc = SEDlgProc;
  1077.     i = IDD_SE_DLG;
  1078.     goto DoErrDlg;
  1079.     break;
  1081. case FATERRMISMAT:
  1082.     lpMyChkInf->iErr = IERR_FATFMISMAT;
  1083.     goto DoNFErrFAfx;
  1084.     break;
  1086. case FATERRLSTCLUS:
  1087.     lpMyChkInf->rgdwArgs[0]=((LPFATLOSTCLUSERR)lpMyChkInf->lParam3)->LostClusCnt * lpMyChkInf->ChkDPms.drvprm.FatFS.SecPerClus * lpMyChkInf->ChkDPms.drvprm.FatFS.BytPerSec;
  1088.     lpMyChkInf->rgdwArgs[1]=((LPFATLOSTCLUSERR)lpMyChkInf->lParam3)->LostClusChainCnt;
  1089.     lpMyChkInf->MIrgdwArgs[0]=((LPFATLOSTCLUSERR)lpMyChkInf->lParam3)->LostClusCnt;
  1090.     lpMyChkInf->MIrgdwArgs[1]=((LPFATLOSTCLUSERR)lpMyChkInf->lParam3)->LostClusChainCnt;
  1091.     lpMyChkInf->iErr = IERR_FATLSTCLUS;
  1092. DoLstErr:
  1093.     if(lpMyChkInf->MyFixOpt & DLGCHK_LSTMF)
  1094.     {
  1095. lpMyChkInf->UseAltDefBut = TRUE;
  1096. lpMyChkInf->AltDefButIndx = 1;
  1097.     }
  1098.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1099.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1100.     {
  1101. if(lpMyChkInf->MyFixOpt & DLGCHK_LSTMF)
  1102. {
  1103.     lpMyChkInf->FixRet = MAKELONG(0,ERETMKFILS);
  1104. } else {
  1105.     lpMyChkInf->FixRet = MAKELONG(0,ERETFREE);
  1106. }
  1107. goto LogAutoErr;
  1108.     }
  1109.     goto DoNFErr;
  1110.     break;
  1112. case FATERRFILE:
  1113.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->FileAttribute & 0x10)
  1114.     {
  1115. i = IDS_DIR;
  1116. j = IDS_DIRS;
  1117. lpMyChkInf->IsFolder = TRUE;
  1118.     } else {
  1119. i = IDS_FILEM;
  1120. j = IDS_FILEMS;
  1121.     }
  1122.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1123.     if(!pMsgBuf)
  1124.     {
  1125. goto NoMem;
  1126.     }
  1128.     OemToAnsi((((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName),dBuf3);
  1130.     LoadString(g_hInstance, i, dBuf1, SZBUFA4);
  1131.     LoadString(g_hInstance, j, dBuf2, SZBUFB4);
  1133.     lpMyChkInf->rgdwArgs[0]=(DWORD)(((LPFATFILEERR)(lpMyChkInf->lParam3))->lpDirName);
  1134.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName == NULL)
  1135. lpMyChkInf->rgdwArgs[1]=(DWORD)(LPSTR)dBuf3;
  1136.     else
  1137. lpMyChkInf->rgdwArgs[1]=(DWORD)(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName);
  1138.     lpMyChkInf->rgdwArgs[2]=(DWORD)(LPSTR)dBuf1;
  1139.     lpMyChkInf->rgdwArgs[3]=(DWORD)(LPSTR)dBuf3;
  1140.     lpMyChkInf->rgdwArgs[4]=(DWORD)(LPSTR)dBuf2;
  1142.     for(i = 0; i < MAXMULTSTRNGS; i++)
  1143.     {
  1144. lpMyChkInf->MErgdwArgs[i][0] = (DWORD)(LPSTR)dBuf2;
  1145. lpMyChkInf->MErgdwArgs[i][1] = (DWORD)(LPSTR)dBuf1;
  1146. lpMyChkInf->MErgdwArgs[i][2] = (DWORD)(LPSTR)dBuf3;
  1147. if(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName == NULL)
  1148.     lpMyChkInf->MErgdwArgs[i][3]=(DWORD)(LPSTR)dBuf3;
  1149. else
  1150.     lpMyChkInf->MErgdwArgs[i][3]=(DWORD)(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName);
  1151.     }
  1152.     i = 0;
  1153.     j = 0;
  1154.     if(HIWORD(lpMyChkInf->lParam2) & ERRINVNM)
  1155.     {
  1156. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_INVNM1;
  1157. i++;
  1158. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_INVNM2;
  1159. i++;
  1160. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_INVNM;
  1161. j++;
  1162.     }
  1163.     if(HIWORD(lpMyChkInf->lParam2) & ERRINVLFN)
  1164.     {
  1165. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_INVLFN1;
  1166. i++;
  1167. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_INVLFN2;
  1168. i++;
  1169. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_INVLFN;
  1170. j++;
  1171.     }
  1172.     if(HIWORD(lpMyChkInf->lParam2) & ERRLFNSTR)
  1173.     {
  1174. lpMyChkInf->UseAltDlgTxt = TRUE;
  1176. // we now have to go back and do ALT form of
  1177. // ERRINVNM and ERRINVLFN. NOTE that the LOG does
  1178. // not have an ALT form.
  1180. i = 0;
  1181. if(HIWORD(lpMyChkInf->lParam2) & ERRINVNM)
  1182. {
  1183.     lpMyChkInf->MltEStrings[i] = ALTISTR_FATERRFILE_INVNM1;
  1184.     i++;
  1185.     lpMyChkInf->MltEStrings[i] = ALTISTR_FATERRFILE_INVNM2;
  1186.     i++;
  1187. }
  1188. if(HIWORD(lpMyChkInf->lParam2) & ERRINVLFN)
  1189. {
  1190.     lpMyChkInf->MltEStrings[i] = ALTISTR_FATERRFILE_INVLFN1;
  1191.     i++;
  1192.     lpMyChkInf->MltEStrings[i] = ALTISTR_FATERRFILE_INVLFN2;
  1193.     i++;
  1194. }
  1195. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_LFNSTR1;
  1196. i++;
  1197. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_LFNSTR2;
  1198. i++;
  1199. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_LFNSTR;
  1200. j++;
  1201.     }
  1202.     if(HIWORD(lpMyChkInf->lParam2) & ERRLFNLEN)
  1203.     {
  1204. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_LFNLEN;
  1205. i++;
  1206. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_LFNLEN;
  1207. j++;
  1208.     }
  1209.     if(HIWORD(lpMyChkInf->lParam2) & ERRDEVNM)
  1210.     {
  1211. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DEVNM1;
  1212. i++;
  1213. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DEVNM2;
  1214. i++;
  1215. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_DEVNM;
  1216. j++;
  1217.     }
  1218.     if(HIWORD(lpMyChkInf->lParam2) & ERRSIZE)
  1219.     {
  1220. if(lpMyChkInf->IsFolder)
  1221. {
  1222. #ifdef OPK2
  1223.     if(HIWORD(lpMyChkInf->lParam2) & ERRCHNLEN)
  1224.     {
  1225. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZEDTB1;
  1226. i++;
  1227. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZEDTB2;
  1228. i++;
  1229. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_SIZETBD;
  1230. j++;
  1231.     } else {
  1232. #endif
  1233. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZED1;
  1234. i++;
  1235. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZED2;
  1236. i++;
  1237. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_SIZED;
  1238. j++;
  1239. #ifdef OPK2
  1240.     }
  1241. #endif
  1242. } else {
  1243. #ifdef OPK2
  1244.     if(HIWORD(lpMyChkInf->lParam2) & ERRCHNLEN)
  1245.     {
  1246. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZETB1;
  1247. i++;
  1248. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZETB2;
  1249. i++;
  1250. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_SIZETB;
  1251. j++;
  1252.     } else {
  1253. #endif
  1254. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZE1;
  1255. i++;
  1256. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_SIZE2;
  1257. i++;
  1258. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_SIZE;
  1259. j++;
  1260. #ifdef OPK2
  1261.     }
  1262. #endif
  1263. }
  1264.     }
  1265.     if(HIWORD(lpMyChkInf->lParam2) & ERRDTTM1)
  1266.     {
  1267. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DTTM11;
  1268. i++;
  1269. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DTTM12;
  1270. i++;
  1271. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_DTTM1;
  1272. j++;
  1273.     }
  1274.     if(HIWORD(lpMyChkInf->lParam2) & ERRDTTM2)
  1275.     {
  1276. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DTTM21;
  1277. i++;
  1278. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DTTM22;
  1279. i++;
  1280. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_DTTM2;
  1281. j++;
  1282.     }
  1283.     if(HIWORD(lpMyChkInf->lParam2) & ERRDTTM3)
  1284.     {
  1285. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DTTM31;
  1286. i++;
  1287. lpMyChkInf->MltEStrings[i] = ISTR_FATERRFILE_DTTM32;
  1288. i++;
  1289. lpMyChkInf->MltELogStrings[j] = IDL_FATERRFILE_DTTM3;
  1290. j++;
  1291.     }
  1292.     for(;i < MAXMULTSTRNGS;i++)
  1293. lpMyChkInf->MltEStrings[i] = 0;
  1294.     for(;j < MAXMULTSTRNGS;j++)
  1295. lpMyChkInf->MltELogStrings[j] = 0;
  1296.     lpMyChkInf->iErr = IERR_FATERRFILE;
  1297.     goto DoNFErrFAfx;
  1298.     break;
  1300. case FATERRCIRCC:
  1301.     lpMyChkInf->iErr = IERR_FATCIRCC;
  1302. DoFFErr:
  1303.     if(!pMsgBuf)
  1304.     {
  1305.        pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1306.        if(!pMsgBuf)
  1307.        {
  1308.    goto NoMem;
  1309.        }
  1310.     }
  1311.     OemToAnsi((((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName),dBuf3);
  1312.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->FileAttribute & 0x10)
  1313. lpMyChkInf->IsFolder = TRUE;
  1314.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName == NULL)
  1315. lpMyChkInf->rgdwArgs[0]=(DWORD)(LPSTR)dBuf3;
  1316.     else
  1317. lpMyChkInf->rgdwArgs[0]=(DWORD)(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName);
  1318.     lpMyChkInf->rgdwArgs[1]=(DWORD)(((LPFATFILEERR)lpMyChkInf->lParam3)->lpDirName);
  1319.     goto DoNFErrFAfx;
  1320.     break;
  1322. case FATERRINVCLUS:
  1323.     lpMyChkInf->iErr = IERR_FATINVCLUS;
  1324.     goto DoFFErr;
  1325.     break;
  1327. case FATERRVOLLAB:
  1328.     if(!(HIWORD(lpMyChkInf->lParam2) & ISFRST))
  1329.     {
  1330. lpMyChkInf->UseAltDlgTxt = TRUE;
  1332. i = j = 0;
  1333. while(((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName[i] != '')
  1334. {
  1335.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName[i] != '.')
  1336.     {
  1337. LabBuf[j] = ((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName[i];
  1338. j++;
  1339.     }
  1340.     i++;
  1341. }
  1342. LabBuf[j] = '';
  1343. OemToAnsi(LabBuf,LabBuf);
  1344.     } else {
  1345. OemToAnsi((((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName),LabBuf);
  1346.     }
  1347.     lpMyChkInf->rgdwArgs[0]=(DWORD)(LPSTR)LabBuf;
  1348.     lpMyChkInf->rgdwArgs[1]=(DWORD)(((LPFATFILEERR)(lpMyChkInf->lParam3))->lpDirName);
  1349.     lpMyChkInf->iErr = IERR_FATERRVOLLAB;
  1350.     goto DoNFErrFAfx;
  1351.     break;
  1353. case FATERRDIR:
  1354.     i = 0;
  1355.     j = 0;
  1356.     if(HIWORD(lpMyChkInf->lParam2) & ERRZRLEN)
  1357.     {
  1358. lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_ZRLEN;
  1359. i++;
  1360. lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_ZRLENC;
  1361. i++;
  1362. lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_ZRLEN;
  1363. j++;
  1364.     } else if(HIWORD(lpMyChkInf->lParam2) & ERRBAD) {
  1365. lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_BAD;
  1366. i++;
  1367. lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_BADC;
  1368. i++;
  1369. lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_BAD;
  1370. j++;
  1371.     } else {
  1372. if(HIWORD(lpMyChkInf->lParam2) & ERRPNOTD)
  1373. {
  1374.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_PNOTD;
  1375.     i++;
  1376.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_PNOTDC;
  1377.     i++;
  1378.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_PNOTD;
  1379.     j++;
  1380. }
  1381. if(HIWORD(lpMyChkInf->lParam2) & ERRBADENTS)
  1382. {
  1383.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_BDENTS;
  1384.     i++;
  1385.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_BDENTSC;
  1386.     i++;
  1387.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_BDENTS;
  1388.     j++;
  1389. }
  1390. if(HIWORD(lpMyChkInf->lParam2) & ERRDOTS)
  1391. {
  1392.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_DOTS;
  1393.     i++;
  1394.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_DOTS;
  1395.     j++;
  1396. }
  1397. if(HIWORD(lpMyChkInf->lParam2) & ERRDUPNM)
  1398. {
  1399.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_DUPNM;
  1400.     i++;
  1401.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_DUPNMC;
  1402.     i++;
  1403.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_DUPNM;
  1404.     j++;
  1405. }
  1406. // if(HIWORD(lpMyChkInf->lParam2) & ERRLFNSRT)
  1407. // {
  1408. // }
  1409. if(HIWORD(lpMyChkInf->lParam2) & ERRLOSTFILE)
  1410. {
  1411.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_LOSTFIL;
  1412.     i++;
  1413.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_LOSTFIL;
  1414.     j++;
  1415. }
  1416. if(HIWORD(lpMyChkInf->lParam2) & ERRLFNLST)
  1417. {
  1418.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRDIR_LFNLST;
  1419.     i++;
  1420.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRDIR_LFNLST;
  1421.     j++;
  1422. }
  1423.     }
  1424.     for(;i < MAXMULTSTRNGS;i++)
  1425. lpMyChkInf->MltEStrings[i] = 0;
  1426.     for(;j < MAXMULTSTRNGS;j++)
  1427. lpMyChkInf->MltELogStrings[j] = 0;
  1429.     lpMyChkInf->IsFolder = TRUE;
  1430.     if(((LPFATDIRERR)(lpMyChkInf->lParam3))->DirFirstCluster == 0xFFFFFFFF)
  1431.     {
  1432. lpMyChkInf->IsRootFolder = TRUE;
  1433.     }
  1434.     lpfnDlgProc = SEDlgProc;
  1435.     lpMyChkInf->rgdwArgs[0]=(DWORD)(((LPFATDIRERR)(lpMyChkInf->lParam3))->lpDirName);
  1436.     lpMyChkInf->iErr=IERR_FATERRDIR;
  1437.     goto DoNFErrFAfx;
  1438.     break;
  1439. #ifdef OPK2
  1440. case FATERRROOTDIR:
  1441.     i = 0;
  1442.     j = 0;
  1443.     if(HIWORD(lpMyChkInf->lParam2) & ERRINVFC)
  1444.     {
  1445. lpMyChkInf->UseAltDlgTxt = TRUE;
  1446. lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_INVFC;
  1447. i++;
  1448. lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_INVFC;
  1449. j++;
  1450. goto ChkLkly;
  1451.     } else if(HIWORD(lpMyChkInf->lParam2) & ERRPNOTD) {
  1452. lpMyChkInf->UseAltDlgTxt = TRUE;
  1453. lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_PNOTD;
  1454. i++;
  1455. lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_PNOTD;
  1456. j++;
  1457. ChkLkly:
  1458. if(lpMyChkInf->lParam3 == 0xFFFFFFFFL)
  1459. {
  1460.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_RECRT;
  1461.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_RECRT;
  1462. } else if(HIWORD(lpMyChkInf->lParam2) & ISLIKELYROOT) {
  1463.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_FND;
  1464.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_FND;
  1465. } else {
  1466.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_MBYFND;
  1467.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_MBYFND;
  1468. }
  1469. i++;
  1470. j++;
  1471.     } else {
  1472. if(HIWORD(lpMyChkInf->lParam2) & ERRINVC)
  1473. {
  1474.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_INVC;
  1475.     i++;
  1476.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_INVC;
  1477.     j++;
  1478. }
  1479. if(HIWORD(lpMyChkInf->lParam2) & ERRCIRCC)
  1480. {
  1481.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_CIRCC;
  1482.     i++;
  1483.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_CIRCC;
  1484.     j++;
  1485. }
  1486. if(HIWORD(lpMyChkInf->lParam2) & ERRTOOBIG)
  1487. {
  1488.     lpMyChkInf->MltEStrings[i] = ISTR_FATERRRTDIR_TOOBIG;
  1489.     i++;
  1490.     lpMyChkInf->MltELogStrings[j] = IDL_FATERRRTDIR_TOOBIG;
  1491.     j++;
  1492. }
  1493.     }
  1494.     for(;i < MAXMULTSTRNGS;i++)
  1495. lpMyChkInf->MltEStrings[i] = 0;
  1496.     for(;j < MAXMULTSTRNGS;j++)
  1497. lpMyChkInf->MltELogStrings[j] = 0;
  1499.     lpMyChkInf->IsFolder = TRUE;
  1500.     lpMyChkInf->IsRootFolder = TRUE;
  1501.     lpfnDlgProc = SEDlgProc;
  1502.     LabBuf[0] = LOBYTE(lpMyChkInf->lpwddi->iDrive) + 'A';
  1503.     LabBuf[1] = ':';
  1504.     LabBuf[2] = '\';
  1505.     LabBuf[3] = '';
  1506.     OemToAnsi(LabBuf,LabBuf);
  1507.     lpMyChkInf->rgdwArgs[0]=(DWORD)(LPSTR)LabBuf;
  1508.     lpMyChkInf->iErr=IERR_FATERRROOTDIR;
  1509.     goto DoNFErrFAfx;
  1510.     break;
  1512. case FATERRSHDSURF:
  1513.     lpMyChkInf->iErr = IERR_FATERRSHDSURF;
  1514.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1515.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1516.     {
  1517. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1518. goto LogAutoErr;
  1519.     }
  1520.     goto DoNFErr;
  1521.     break;
  1523. case FATERRBOOT:
  1524.     lpMyChkInf->iErr = IERR_FATERRBOOT;
  1525.     goto DoNFErrFAfx;
  1526.     break;
  1527. #endif
  1528. case FATERRMXPLEN:
  1529.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->FileAttribute & 0x10)
  1530.     {
  1531. lpMyChkInf->IsFolder = TRUE;
  1532. lpMyChkInf->UseAltDlgTxt = TRUE;
  1533.     }
  1534.     if(!pMsgBuf)
  1535.     {
  1536.        pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1537.        if(!pMsgBuf)
  1538.        {
  1539.    goto NoMem;
  1540.        }
  1541.     }
  1542.     OemToAnsi((LPSTR)(((LPFATFILEERR)lpMyChkInf->lParam3)->lParam3),dBuf3);
  1543.     lpMyChkInf->rgdwArgs[0]=(DWORD)(((LPFATFILEERR)lpMyChkInf->lParam3)->lParam2);
  1544.     lpMyChkInf->rgdwArgs[1]=(DWORD)(LPSTR)dBuf3;
  1545.     if(lpMyChkInf->lParam2 & MAKELONG(0,ERRRMWRN))
  1546.     {
  1547. lpMyChkInf->iErr=IERR_FATERRMXPLENS;
  1548. #ifdef FROSTING
  1549. if(lpMyChkInf->fSageRun)
  1550. {
  1551.     // ProbCnt is never incremented for these errors, if
  1552.     // the problem is ignored.  So there's no need to
  1553.     // increase SilentProbCnt.
  1554.     // lpMyChkInf->SilentProbCnt++; // ignore problem
  1555.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN);
  1556.     goto DontDoErrDlg;
  1557. }
  1558. #endif
  1559.     } else {
  1560. lpMyChkInf->iErr=IERR_FATERRMXPLENL;
  1561.     }
  1562.     goto DoNFErrFAfx;
  1563.     break;
  1565. case FATERRCDLIMIT:
  1566.     lpMyChkInf->IsFolder = TRUE;
  1567.     if(!pMsgBuf)
  1568.     {
  1569.        pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1570.        if(!pMsgBuf)
  1571.        {
  1572.    goto NoMem;
  1573.        }
  1574.     }
  1575.     OemToAnsi((((LPFATDIRERR)(lpMyChkInf->lParam3))->lpDirName),dBuf3);
  1576.     lpMyChkInf->rgdwArgs[0]=(DWORD)(LPSTR)dBuf3;
  1577.     lpMyChkInf->iErr=IERR_FATERRCDLIMIT;
  1579. #ifdef FROSTING
  1580.     if(lpMyChkInf->fSageRun)
  1581.     {
  1582. // ProbCnt is never incremented for these errors, if
  1583. // the problem is ignored.  So there's no need to
  1584. // increase SilentProbCnt.
  1585. // lpMyChkInf->SilentProbCnt++; // ignore problem
  1586. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN);
  1587. goto DontDoErrDlg;
  1588.     }
  1589. #endif
  1591.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1592.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1593.     {
  1594. if(HIWORD(lpMyChkInf->lParam2) & ERRRMWRN)
  1595. {
  1596.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN);
  1597. } else {
  1598.     lpMyChkInf->FixRet = MAKELONG(0,ERETMVDIR);
  1599. }
  1600. goto LogAutoErr;
  1601.     } else {
  1602. if(!(HIWORD(lpMyChkInf->lParam2) & ERRRMWRN))
  1603. {
  1604.     lpMyChkInf->UseAltDefBut = TRUE;
  1605.     lpMyChkInf->AltDefButIndx = 1;
  1606. }
  1607.     }
  1608.     goto DoNFErr;
  1609.     break;
  1611. #ifdef OPK2
  1612. case ERRISBAD2:
  1613.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1614.     if(!pMsgBuf)
  1615.     {
  1616. goto NoMem;
  1617.     }
  1618.     lpMyChkInf->iErr = IERR_ERRISBAD7;
  1619.     if(!(HIWORD(lpMyChkInf->lParam2) & ERRDATA))
  1620.     {
  1621. lpMyChkInf->UseAltDlgTxt = TRUE;
  1622. if(HIWORD(lpMyChkInf->lParam2) & ERRFBOOT)
  1623. {
  1624.     i = IDS_BOOT;
  1625. } else if(HIWORD(lpMyChkInf->lParam2) & ERRFAT) {
  1626.     i = IDS_FAT;
  1627. } else {
  1628.     i = IDS_ROOTD;
  1629. }
  1630. LoadString(g_hInstance, i, dBuf1, SZBUFA4);
  1631.     }
  1632.     lpMyChkInf->rgdwArgs[0] = lpMyChkInf->lParam3;
  1633.     lpMyChkInf->rgdwArgs[1] = lpMyChkInf->lParam5;
  1634.     lpMyChkInf->rgdwArgs[2] = (DWORD)(LPSTR)dBuf1;
  1635.     goto BadErr;
  1636.     break;
  1637. #endif
  1639. case ERRISBAD:
  1640.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1641.     if(!pMsgBuf)
  1642.     {
  1643. goto NoMem;
  1644.     }
  1645.     if((lpMyChkInf->lpwddi->TypeFlags & DT_DBLDISK) &&
  1646.        (lpMyChkInf->MyFixOpt2 & DLGCHK_NOCHKHST)      )
  1647.     {
  1648. if(HIWORD(lpMyChkInf->lParam2) & ERRDATA)
  1649. {
  1650.     lpMyChkInf->iErr = IERR_ERRISBAD2;
  1651. } else {
  1652.     lpMyChkInf->iErr = IERR_ERRISBAD1;
  1653. }
  1654.     } else {
  1655. if(!(HIWORD(lpMyChkInf->lParam2) & ERRDATA))
  1656. {
  1657.     lpMyChkInf->iErr = IERR_ERRISBAD3;
  1658. } else {
  1659.     if(lpMyChkInf->lpwddi->TypeFlags & DT_DBLDISK)
  1660.     {
  1661. lpMyChkInf->iErr = IERR_ERRISBAD4;
  1662.     } else {
  1663. lpMyChkInf->iErr = IERR_ERRISBAD5;
  1664.     }
  1665. }
  1666.     }
  1667.     if((HIWORD(lpMyChkInf->lParam2) & ERRDATA) &&
  1668.        (lpMyChkInf->lParam5 == 0L)  )
  1669.     {
  1670. lpMyChkInf->iErr = IERR_ERRISBAD6;
  1671.     } else if((HIWORD(lpMyChkInf->lParam2) & ERRDATA) &&
  1672.       (lpMyChkInf->lParam5 != 0L) ) {
  1674. if(HIWORD(lpMyChkInf->lParam2) & ISADIR)
  1675. {
  1676.     lpMyChkInf->IsFolder = TRUE;
  1677.     i = IDS_DIR;
  1678. } else {
  1679.     i = IDS_FILEM;
  1680. }
  1681. LoadString(g_hInstance, i, dBuf1, SZBUFA4);
  1682. if(HIWORD(lpMyChkInf->lParam2) & FULLDISK)
  1683. {
  1684.     lpMyChkInf->UseAltCantFix = TRUE;
  1685.     lpMyChkInf->AltCantFixTstFlag = FULLDISK;
  1686.     lpMyChkInf->AltCantFixHID = IDH_WASTE_FREEING_DISK_SPACE;
  1687.     lpMyChkInf->AltCantFixRepHID = IDH_WINDISK_ISBAD_NO_FREE_CLUSTER;
  1688. }
  1689.     } else if(!(HIWORD(lpMyChkInf->lParam2) & ERRDATA)) {
  1691. if(HIWORD(lpMyChkInf->lParam2) & ERRFBOOT)
  1692. {
  1693.     i = IDS_BOOT;
  1694. } else if(HIWORD(lpMyChkInf->lParam2) & ERRFAT) {
  1695.     i = IDS_FAT;
  1696. } else {
  1697.     i = IDS_ROOTD;
  1698. }
  1699. LoadString(g_hInstance, i, dBuf1, SZBUFA4);
  1700.     }
  1701.     lpMyChkInf->rgdwArgs[0] = lpMyChkInf->lParam3;
  1702.     lpMyChkInf->rgdwArgs[1] = lpMyChkInf->lParam5;
  1703.     lpMyChkInf->rgdwArgs[2] = (DWORD)(LPSTR)dBuf1;
  1704. BadErr:
  1705.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1706.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1707.     {
  1708. AutoBad:
  1709. if(!(HIWORD(lpMyChkInf->lParam2) & ERRDATA))
  1710. {
  1711.     // error in system area
  1712.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1713. }
  1714. if(!(HIWORD(lpMyChkInf->lParam2) & RECOV))
  1715. {
  1716.     // Bad sector is uncorrectable (unmovable file)
  1717.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1718. }
  1719. if(LOWORD(lpMyChkInf->lParam2) == ERRISNTBAD)
  1720. {
  1721.     // Do NOT clear bad marks
  1722.     // except under USER control
  1724.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1725. #ifdef OPK2
  1726. } else if(LOWORD(lpMyChkInf->lParam2) == ERRISBAD2) {
  1727.     lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1728. #endif
  1729. } else {
  1730.     lpMyChkInf->FixRet = MAKELONG(0,ERETMRKBAD);
  1731. }
  1732. LogAutoErr:
  1733. SEAddErrToLog(lpMyChkInf);
  1734. if(pMsgBuf)
  1735.     LocalFree((HANDLE)pMsgBuf);
  1736. pMsgBuf = 0;
  1737. goto LogErrRet;
  1738.     } else {
  1739. if((LOWORD(lpMyChkInf->lParam2) == ERRISNTBAD) &&
  1740.    (!(lpMyChkInf->MyFixOpt2 & DLGCHK_DOBADISNTBAD)))
  1741. {
  1742.     goto AutoBad;
  1743. }
  1744.     }
  1745.     goto DoNFErr;
  1746.     break;
  1748. case ERRISNTBAD:
  1749.     lpMyChkInf->rgdwArgs[0] = lpMyChkInf->lParam3;
  1750.     lpMyChkInf->iErr = IERR_ERRISNTBAD;
  1751.     goto BadErr;
  1752.     break;
  1754. case ERRCANTDEL:
  1755.     lpMyChkInf->rgdwArgs[0] = lpMyChkInf->lParam3;
  1756.     lpMyChkInf->iErr = IERR_ERRCANTDEL;
  1757. DoNFErrFIgn2Int:
  1758.     if((!(lpMyChkInf->MyFixOpt & DLGCHK_INTER)) ||
  1759.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1760.     {
  1761. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1762. goto LogAutoErr;
  1763.     }
  1764.     goto DoNFErr;
  1765.     break;
  1767. case DDERRMOUNT:
  1768.     lpMyChkInf->CancelIsDefault = TRUE;
  1769.     lpMyChkInf->rgdwArgs[0]=(DWORD)(LPSTR)(lpMyChkInf->lpwddi->driveNameStr);
  1770.     lpMyChkInf->iErr = IERR_DDERRMOUNT;
  1771.     goto DoNFErrFIgn2Int;
  1772.     break;
  1774. case DDERRSIZE1:
  1775.     lpMyChkInf->iErr = IERR_DDERRSIZE1;
  1776. DoNFErrFIgn2:
  1777.     if(lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND))
  1778.     {
  1779. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1780. goto LogAutoErr;
  1781.     }
  1782.     // This error is displayed even in non interactive
  1783.     // mode.
  1785.     goto DoNFErr;
  1786.     break;
  1788. case DDERRFRAG:
  1789.     lpMyChkInf->iErr = IERR_DDERRFRAG;
  1790.     goto DoNFErrFIgn2;
  1791.     break;
  1793. case DDERRALIGN:
  1794.     lpMyChkInf->iErr = IERR_DDERRALIGN;
  1795.     goto DoNFErrFIgn2;
  1796.     break;
  1798. case DDERRNOXLCHK:
  1799.     lpMyChkInf->iErr = IERR_DDERRNOXLCHK;
  1800. #ifdef FROSTING
  1801.     if (lpMyChkInf->fSageRun)
  1802.     {
  1803. lpMyChkInf->SilentProbCnt++; // ignore problem
  1804. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1805. goto DontDoErrDlg;
  1806.     }
  1807. #endif
  1808.     goto DoNFErrFIgn2Int;
  1809.     break;
  1811. case DDERRUNSUP:
  1812.     lpMyChkInf->iErr = IERR_DDERRUNSUP;
  1813.     dwi = 0x00000001L << lpMyChkInf->lpwddi->iDrive;
  1814. #ifdef FROSTING
  1815.                     if (lpMyChkInf->fSageRun)
  1816.     {
  1817. lpMyChkInf->SilentProbCnt++; // ignore this problem
  1818. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1819. goto DontDoErrDlg;
  1820.     }
  1821. #endif
  1822.     if((lpMyChkInf->NoUnsupDrvs & dwi) ||
  1823.        (lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND)))
  1824.     {
  1825. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1826. goto LogAutoErr;
  1827.     }
  1828. #ifdef OPK2
  1829.     // Do not do this warning again if already done (restarts)
  1831.     if(lpMyChkInf->Done3PtyCompWrn)
  1832.     {
  1833. lpMyChkInf->FixRet = MAKELONG(0,ERETIGN2);
  1834. goto LogAutoErr;
  1835.     } else {
  1836. lpMyChkInf->Done3PtyCompWrn = TRUE;
  1837.     }
  1838. #endif
  1839.     // This error is displayed even in non interactive
  1840.     // mode.
  1842.     goto DoNFErr;
  1843.     break;
  1845. case DDERRCVFNM:
  1846.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1847.     if(!pMsgBuf)
  1848.     {
  1849. goto NoMem;
  1850.     }
  1851.     LoadString(g_hInstance, IDS_DBLSPACE, dBuf1, SZBUFA4);
  1852.     LoadString(g_hInstance, IDS_DRVSPACE, dBuf2, SZBUFB4);
  1853.     if(HIWORD(lpMyChkInf->lParam2) & CHNGTONEW)
  1854.     {
  1855. lpMyChkInf->rgdwArgs[0]=(DWORD)((LPSTR)dBuf2);
  1856. lpMyChkInf->rgdwArgs[1]=(DWORD)((LPSTR)dBuf1);
  1857.     } else {
  1858. lpMyChkInf->rgdwArgs[0]=(DWORD)((LPSTR)dBuf1);
  1859. lpMyChkInf->rgdwArgs[1]=(DWORD)((LPSTR)dBuf2);
  1860.     }
  1861.     lpMyChkInf->iErr = IERR_DDERRCVFNM;
  1862.     goto DoNFErrFAfx;
  1863.     break;
  1865. case DDERRSIG:
  1866.     lpMyChkInf->iErr = IERR_DDERRSIG;
  1867.     goto DoNFErrFAfx;
  1868.     break;
  1870. case DDERRBOOT:
  1871.     lpMyChkInf->iErr = IERR_DDERRBOOT;
  1872.     goto DoNFErrFAfx;
  1873.     break;
  1875. case DDERRMDBPB:
  1876.     lpMyChkInf->iErr = IERR_DDERRMDBPB;
  1877.     goto DoNFErrFAfx;
  1878.     break;
  1880. case DDERRSIZE2:
  1881.     if(lpMyChkInf->MyFixOpt2 & DLGCHK_NOCHKHST)
  1882.     {
  1883. lpMyChkInf->iErr = IERR_DDERRSIZE2A;
  1884.     } else {
  1885. lpMyChkInf->iErr = IERR_DDERRSIZE2B;
  1886.     }
  1887.     goto DoNFErrFAfx;
  1888.     break;
  1890. case DDERRMDFAT:
  1891.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  1892.     if(!pMsgBuf)
  1893.     {
  1894. goto NoMem;
  1895.     }
  1896.     lpMyChkInf->rgdwArgs[0]=(DWORD)(((LPXLNKFILE)(lpMyChkInf->lParam3))->FileName);
  1897.     if(lpMyChkInf->rgdwArgs[0] == 0L)
  1898.     {
  1899. lpMyChkInf->UseAltDlgTxt = TRUE;
  1900.     } else {
  1901. if(((LPXLNKFILE)(lpMyChkInf->lParam3))->FileAttributes & 0x10)
  1902. {
  1903.     lpMyChkInf->IsFolder = TRUE;
  1904.     i = IDS_DIR;
  1905. } else {
  1906.     i = IDS_FILEM;
  1907. }
  1908. LoadString(g_hInstance, i, dBuf1, SZBUFA4);
  1909. lpMyChkInf->rgdwArgs[1]=(DWORD)(LPSTR)dBuf1;
  1910.     }
  1911.     lpMyChkInf->iErr = IERR_DDERRMDFAT;
  1912.     goto DoNFErrFAfx;
  1913.     break;
  1915. case DDERRLSTSQZ:
  1916.     lpMyChkInf->rgdwArgs[0]=MAKELONG(LOWORD(lpMyChkInf->lParam3),0);
  1917.     lpMyChkInf->iErr = IERR_DDERRLSTSQZ;
  1918.     goto DoLstErr;
  1919.     break;
  1921. case DDERRXLSQZ:
  1922.     lpMyChkInf->UseAltDlgTxt = TRUE;
  1923.     if(lpMyChkInf->MyFixOpt & DLGCHK_XLDEL)
  1924.     {
  1925. lpMyChkInf->UseAltDefBut = TRUE;
  1926. lpMyChkInf->AltDefButIndx = 1;
  1927.     } else if(!(lpMyChkInf->MyFixOpt & DLGCHK_XLCPY)) {
  1928. lpMyChkInf->UseAltDefBut = TRUE;
  1929. lpMyChkInf->AltDefButIndx = 2;
  1930.     }
  1931.     lpMyChkInf->iErr = IERR_DDERRXLSQZ;
  1932.     goto DoXLDlg;
  1933.     break;
  1935. default:
  1936.     SEAddToLogRCS(lpMyChkInf,IDL_ERUNKNO,NULL);
  1937.     return(0L);
  1938.     break;
  1939.     }
  1940.     break;
  1942. case DU_ERRORCORRECTED:
  1943.     if(LOWORD(lpMyChkInf->lParam4) == FULLCORR)
  1944.     {
  1945. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECFULLCORR);
  1946. goto DoYld;
  1947.     } else if(LOWORD(lpMyChkInf->lParam4) == CANTFIX) {
  1948. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECCANTFIX);
  1949. goto DoYld;
  1950.     } else if(LOWORD(lpMyChkInf->lParam4) == NOCORR) {
  1951. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECNOCORR);
  1952.     } else if(LOWORD(lpMyChkInf->lParam4) == PCORROK) {
  1953. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECPCORROK);
  1954.     } else if(LOWORD(lpMyChkInf->lParam4) == PCORRBAD) {
  1955. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECPCORRBAD);
  1956.     }
  1958.     if(HIWORD(lpMyChkInf->lParam4) & OTHERWRT)
  1959.     {
  1960. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECOTHERWRT);
  1961. if(lpMyChkInf->MyFixOpt & DLGCHK_INTER)
  1962. {
  1963.     lpMyChkInf->iErr = IERR_ECORROTHWRT;
  1964.     lpMyChkInf->AlrdyRestartWrn = TRUE;
  1965.     goto DoErr;
  1966. } else {
  1967.     goto DoYld;
  1968. }
  1969.     }
  1971.     if(HIWORD(lpMyChkInf->lParam4) & NOMEM)
  1972.     {
  1973. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECNOMEM);
  1974. lpMyChkInf->iErr = IERR_ECORRMEM;
  1975. goto DoErr;
  1976.     }
  1977.     if(HIWORD(lpMyChkInf->lParam4) & UNEXP)
  1978.     {
  1979. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECUNEXP);
  1980. lpMyChkInf->iErr = IERR_ECORRUNEXP;
  1981. goto DoErr;
  1982.     }
  1984.     switch(LOWORD(lpMyChkInf->lParam2)) {
  1986. case FATERRRESVAL:
  1987. case FATERRMISMAT:
  1988. case FATERRCIRCC:
  1989. case FATERRINVCLUS:
  1990.     if(HIWORD(lpMyChkInf->lParam4) & DISKERR)
  1991.     {
  1992. goto DskErr;
  1993.     }
  1994.     goto HmmmErr;
  1995.     break;
  1997. case FATERRCDLIMIT:
  1998. case FATERRMXPLEN:
  1999.     if(HIWORD(lpMyChkInf->lParam4) & DISKERR)
  2000.     {
  2001. goto DskErr;
  2002.     }
  2003.     if(HIWORD(lpMyChkInf->lParam4) & FILCRT)
  2004.     {
  2005. pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ4);
  2006. if(!pMsgBuf)
  2007. {
  2008.     goto NoMem2;
  2009. }
  2010. if(LOWORD(lpMyChkInf->lParam2) == FATERRMXPLEN)
  2011. {
  2012.     OemToAnsi((((LPFATFILEERR)lpMyChkInf->lParam3)->lpShortFileName),dBuf3);
  2013.     if(((LPXLNKFILE)(lpMyChkInf->lParam3))->FileAttributes & 0x10)
  2014.     {
  2015. lpMyChkInf->IsFolder = TRUE;
  2016. i = IDS_DIR;
  2017.     } else {
  2018. i = IDS_FILEM;
  2019.     }
  2020.     if(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName == NULL)
  2021. lpMyChkInf->rgdwArgs[1]=(DWORD)(LPSTR)dBuf3;
  2022.     else
  2023. lpMyChkInf->rgdwArgs[1]=(DWORD)(((LPFATFILEERR)lpMyChkInf->lParam3)->lpLFNFileName);
  2024. } else {
  2025.     lpMyChkInf->IsFolder = TRUE;
  2026.     i = IDS_DIR;
  2027.     lpMyChkInf->rgdwArgs[1]=((LPFATDIRERR)(lpMyChkInf->lParam3))->lParam2;
  2028. }
  2029. LoadString(g_hInstance, i, dBuf1, SZBUFA4);
  2030. lpMyChkInf->rgdwArgs[0]=(DWORD)(LPSTR)dBuf1;
  2031. if(HIWORD(lpMyChkInf->lParam4) & FILCOLL)
  2032. {
  2033.     SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECFILCOL);
  2034.     lpMyChkInf->iErr = IERR_ECORRFILCOL;
  2035. } else {
  2036.     SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECFILCRT);
  2037.     lpMyChkInf->iErr = IERR_ECORRFILCRT;
  2038. }
  2039.     } else {
  2040. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECUNEXP);
  2041. lpMyChkInf->iErr = IERR_ECORRUNEXP;
  2042.     }
  2043.     goto DoErr;
  2044.     break;
  2046. #ifdef OPK2
  2047. case FATERRROOTDIR:
  2048. #endif
  2049. case FATERRDIR:
  2050. case DDERRXLSQZ:
  2051. case FATERRXLNK:
  2052.     if(HIWORD(lpMyChkInf->lParam4) & CLUSALLO)
  2053.     {
  2054. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECCLUSA);
  2055. lpMyChkInf->iErr = IERR_ECORRCLUSA;
  2056. goto DoErr;
  2057.     } else if(HIWORD(lpMyChkInf->lParam4) & DISKERR) {
  2058. DskErr:
  2059. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECDISKE);
  2060. lpMyChkInf->iErr = IERR_ECORRDISK;
  2061. if(lpMyChkInf->MyFixOpt & (DLGCHK_NOBAD |
  2062.    DLGCHK_NODATA |
  2063.    DLGCHK_NOSYS)  )
  2064. {
  2065.     lpMyChkInf->UseAltDlgTxt = TRUE;
  2066. }
  2067. goto DoErr;
  2068.     }
  2070.     // NOTE FALL THROUGH
  2072. #ifdef OPK2
  2073. case FATERRBOOT:
  2074. #endif
  2075. case DDERRCVFNM:
  2076. case DDERRSIZE2:
  2077. case DDERRSIG:
  2078. case DDERRBOOT:
  2079. case DDERRMDBPB:
  2080. case DDERRMDFAT:
  2081. case DDERRLSTSQZ:
  2082. case FATERRVOLLAB:
  2083. case FATERRFILE:
  2084. case FATERRLSTCLUS:
  2085.     if(HIWORD(lpMyChkInf->lParam4) & DISKERR)
  2086.     {
  2087. goto DskErr;
  2088.     }
  2089.     if(HIWORD(lpMyChkInf->lParam4) & FILCRT)
  2090.     {
  2091. lpMyChkInf->UseAltDlgTxt = TRUE;
  2092. if(HIWORD(lpMyChkInf->lParam4) & FILCOLL)
  2093. {
  2094.     SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECFILCOL);
  2095.     lpMyChkInf->iErr = IERR_ECORRFILCOL;
  2096. } else {
  2097.     SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECFILCRT);
  2098.     lpMyChkInf->iErr = IERR_ECORRFILCRT;
  2099. }
  2100.     } else {
  2101. HmmmErr:
  2102. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECUNEXP);
  2103. lpMyChkInf->iErr = IERR_ECORRUNEXP;
  2104.     }
  2105. DoErr:
  2106.     if(lpMyChkInf->MyFixOpt2 & (DLGCHK_PROGONLY | DLGCHK_NOWND))
  2107.     {
  2108. if(pMsgBuf)
  2109.     LocalFree((HANDLE)pMsgBuf);
  2110. pMsgBuf = 0;
  2111. goto DoYld;
  2112.     }
  2113.     lpfnDlgProc = SEDlgProc;
  2114.     i = IDD_SE_DLG;
  2115.     i = DialogBoxParam(g_hInstance,
  2116.        MAKEINTRESOURCE(i),
  2117.        lpMyChkInf->hProgDlgWnd,
  2118.        lpfnDlgProc,
  2119.        (LPARAM)lpMyChkInf);
  2120.     if(pMsgBuf)
  2121. LocalFree((HANDLE)pMsgBuf);
  2122.     pMsgBuf = 0;
  2123.     if(i == 0xFFFF)
  2124.     {
  2125. NoMem2:
  2126. SEAddToLogRCS(lpMyChkInf,IDL_NOMEMCAN,NULL);
  2127. MyChkdskMessageBox(lpMyChkInf, IDS_NOMEM2,
  2128.    MB_ICONINFORMATION | MB_OK);
  2129. return(1L);
  2130.     }
  2131.     if(HIWORD(lpMyChkInf->FixRet) == ERETCAN)
  2132. return(1L);
  2133.     goto DoYld;
  2134.     break;
  2136. case ERRISBAD:
  2137. BadErr2:
  2138.     if(HIWORD(lpMyChkInf->lParam4) & CLUSALLO)
  2139.     {
  2140. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECCLUSA);
  2141. lpMyChkInf->iErr = IERR_ECORRCLUSA;
  2142. goto DoErr;
  2143.     } else if(HIWORD(lpMyChkInf->lParam4) & DISKERR) {
  2144. SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECDISKE);
  2145. lpMyChkInf->iErr = IERR_ECORRDISK;
  2146. lpMyChkInf->UseAltDlgTxt = TRUE;
  2147. goto DoErr;
  2148.     }
  2149.     goto DoYld;
  2150.     break;
  2152. case ERRISNTBAD:
  2153.     if(lpMyChkInf->MyFixOpt & DLGCHK_INTER)
  2154.     {
  2155. goto BadErr2;
  2156.     }
  2157.     goto DoYld;
  2158.     break;
  2160. case ERRCANTDEL: // These are all CANTFIX
  2161. case DDERRSIZE1:
  2162. case DDERRMOUNT:
  2163. case DDERRFRAG:
  2164. case DDERRALIGN:
  2165. case DDERRUNSUP:
  2166. case DDERRNOXLCHK:
  2167. #ifdef OPK2
  2168. case ERRISBAD2:
  2169. #endif
  2170.     SEAddToLogRCS(lpMyChkInf,IDL_ECPRE,IDL_ECCANTFIX);
  2172.     // Note fall through
  2174. #ifdef OPK2
  2175. case FATERRSHDSURF:
  2176. #endif
  2177. case ERRLOCKV:     // This will get logged on engine return
  2178. case MEMORYERROR:   // Rest are all "retry ignore or cancel"
  2179. case READERROR:
  2180. case WRITEERROR:
  2181.     goto DoYld;
  2182.     break;
  2184. default:
  2185.     return(0L);
  2186.     break;
  2187.     }
  2188.     goto DoYld;
  2189.     break;
  2191. case DU_OPCOMPLETE:
  2192.     lpMyChkInf->lpFixRep = (LPFATFIXREPORT)lpMyChkInf->lParam2;
  2193.     lpMyChkInf->OpCmpltRet = lpMyChkInf->lParam3;
  2195. #ifdef FROSTING
  2196.     if(lpMyChkInf->lpFixRep != 0L)
  2197.     {
  2198. if(lpMyChkInf->lpFixRep->ProbCnt >= lpMyChkInf->SilentProbCnt)
  2199.     lpMyChkInf->lpFixRep->ProbCnt -= lpMyChkInf->SilentProbCnt;
  2200. else
  2201.     lpMyChkInf->lpFixRep->ProbCnt = 0L;
  2202.     }
  2203.     lpMyChkInf->SilentProbCnt = 0; // Re-init to 0 for next drive
  2204. #endif
  2206.     switch(HIWORD(lpMyChkInf->OpCmpltRet))
  2207.     {
  2208. case ERR_FSUNCORRECTED:
  2209. case ERR_FSCORRECTED:
  2210. case NOERROR:
  2211.     if(lpMyChkInf->lpFixRep != 0L)
  2212.     {
  2213. if(lpMyChkInf->lpFixRep->ProbCnt == 0L)
  2214.     i = IDL_NOERROR;
  2215. else if(lpMyChkInf->MyFixOpt & DLGCHK_RO)
  2216.     i = IDL_NONEFIXED;
  2217. else if(lpMyChkInf->lpFixRep->ProbCnt == lpMyChkInf->lpFixRep->ProbFixedCnt)
  2218.     i = IDL_ALLFIXED;
  2219. else
  2220.     i = IDL_SOMEFIXED;
  2221. SEAddToLogRCS(lpMyChkInf,i,NULL);
  2222.     }
  2223.     break;
  2225. // case ERR_OSERR:
  2226. // case ERR_NOTWRITABLE:
  2227. // case ERR_NOTSUPPORTED:
  2228. // case ERR_INSUFMEM:
  2229. // case ERR_EXCLVIOLATION:
  2230. // case ERR_LOCKVIOLATION:
  2231. // case ERR_FSACTIVE:
  2232. // case ERR_FSERR:
  2233. // case ERR_BADOPTIONS:
  2234. // case OPCANCEL:
  2235. default:
  2236.     break;
  2237.     }
  2239.     if(!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOWND))
  2240.     {
  2241. SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+3, 0, 0L);
  2242.     }
  2243.     return(0L);
  2244.     break;
  2246. case DU_INITENGINE:
  2247.     if(!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOWND))
  2248.     {
  2249. SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+4, TRUE, 0L);
  2250.     }
  2251.     return(0L);
  2252.     break;
  2254. case DU_ENGINERESTART:
  2255. #ifdef FROSTING
  2256.     if(lpMyChkInf->fSageRun)
  2257. LockWrtRestartMax = CHKLOCKRESTARTLIM_SAGE;
  2258.     else
  2259. LockWrtRestartMax = CHKLOCKRESTARTLIM;
  2260. #else
  2261. #define LockWrtRestartMax CHKLOCKRESTARTLIM
  2262. #endif
  2264.     if((HIWORD(lpMyChkInf->lParam2) & OTHERWRT)  &&
  2265.        (lpMyChkInf->NoRstrtWarn == FALSE) &&
  2266.        (lpMyChkInf->lpFixFDisp->LockWrtRestartCnt >= LockWrtRestartMax) &&
  2267.        ((lpMyChkInf->lpFixFDisp->LockWrtRestartCnt % LockWrtRestartMax) == 0) )
  2268.     {
  2269. SEAddToLogRCS(lpMyChkInf,IDL_RSTLOCKLIM,NULL);
  2270. #ifdef FROSTING
  2271. if(lpMyChkInf->fSageRun) // If /SAGERUN, just cancel.
  2272. {
  2273.     lpMyChkInf->ChkCancelBool = TRUE;
  2274.     lpMyChkInf->fShouldRerun = TRUE;
  2275.     return(1L);
  2276. }
  2277. #endif
  2278. switch(MyChkdskMessageBox(lpMyChkInf, IDS_LOCKRSTART,
  2279.   MB_ICONQUESTION | MB_YESNOCANCEL))
  2280. {
  2281.     case IDNO:
  2282. lpMyChkInf->NoRstrtWarn = TRUE;
  2283. break;
  2285.     case IDCANCEL:
  2286. lpMyChkInf->ChkCancelBool = TRUE;
  2287. return(1L);
  2288. break;
  2290.     case IDYES:
  2291.     default:
  2292. break;
  2293. }
  2294.     }
  2295.     if((HIWORD(lpMyChkInf->lParam2) & UNFIXEDERRS) &&
  2296.        (HIWORD(lpMyChkInf->lParam2) & OTHERWRT)    &&
  2297.        (!lpMyChkInf->AlrdyRestartWrn)      )
  2298.     {
  2299. SEAddToLogRCS(lpMyChkInf,IDL_RSTUNFERR,NULL);
  2300. #ifdef FROSTING
  2301. if(!lpMyChkInf->fSageRun)
  2302. {
  2303. #endif
  2304.     switch(MyChkdskMessageBox(lpMyChkInf, IDS_ERRRSTART,
  2305.       MB_ICONQUESTION | MB_OKCANCEL))
  2306.     {
  2307. case IDCANCEL:
  2308.     lpMyChkInf->ChkCancelBool = TRUE;
  2309.     return(1L);
  2310.     break;
  2312. case IDOK:
  2313. default:
  2314.     break;
  2315.     }
  2316. #ifdef FROSTING
  2317. }
  2318. #endif
  2319.     }
  2320.     lpMyChkInf->AlrdyRestartWrn = FALSE;
  2321. #ifdef OPK2
  2322.     if(HIWORD(lpMyChkInf->lParam2) & DOSURFAN)
  2323.     {
  2324. lpMyChkInf->MyFixOpt &= ~DLGCHK_NOBAD;
  2325. SendMessage(GetDlgItem(lpMyChkInf->hProgDlgWnd,DLGCHK_NOBADB),BM_SETCHECK,0,0);
  2326. SendMessage(GetDlgItem(lpMyChkInf->hProgDlgWnd,DLGCHK_DOBAD),BM_SETCHECK,1,0);
  2327. UpdateWindow(GetDlgItem(lpMyChkInf->hProgDlgWnd,DLGCHK_NOBADB));
  2328. UpdateWindow(GetDlgItem(lpMyChkInf->hProgDlgWnd,DLGCHK_DOBAD));
  2329.     }
  2330. #endif
  2331.     // NOTE FALL THROUGH
  2333. case DU_YIELD:
  2334. case DU_ENGINESTART:
  2335. case DU_OPUPDATE:
  2336.     if(lpMyChkInf->ChkIsActive)
  2337.     {
  2338. lpMyChkInf->lpFixFDisp->Options &= ~FDO_LOWPRIORITY;
  2339.     } else {
  2340. lpMyChkInf->lpFixFDisp->Options |= FDO_LOWPRIORITY;
  2341.     }
  2342.     if((lpMyChkInf->hTimer == 0)  &&
  2343.        (!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOWND)) &&
  2344.        (lpMyChkInf->hProgDlgWnd != 0)     )
  2345.     {
  2346. lpMyChkInf->hTimer = SetTimer(lpMyChkInf->hProgDlgWnd,1,500,NULL);
  2347.     }
  2348.     if(!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOWND))
  2349.     {
  2350. SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+4, TRUE, 0L);
  2351.     }
  2352. DoYld:
  2353. #ifdef OPK2
  2354.     if(!(lpMyChkInf->MyFixOpt2 & DLGCHK_NOWND))
  2355.     {
  2356. SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+5, 0, 0L);
  2357.     }
  2358. DoYld2:
  2359. #endif
  2361. #define YLDCNTDIVH  25L
  2362. #define YLDCNTDIVL  50L
  2364.     lpMyChkInf->YldCnt++;
  2365.     if(lpMyChkInf->MyFixOpt2 & DLGCHK_NOWND)
  2366.     {
  2367. Yield();
  2368.     } else {
  2369. if(lpMyChkInf->hTimer != 0)
  2370. {
  2371.     if(lpMyChkInf->ChkIsActive)
  2372.     {
  2373. if((lpMyChkInf->YldCnt % YLDCNTDIVH) == 0)
  2374. {
  2375.     goto DoWait;
  2376. }
  2377.     } else {
  2378. if((lpMyChkInf->YldCnt % YLDCNTDIVL) == 0)
  2379. {
  2380. DoWait:
  2381.     WaitMessage();
  2382. }
  2383.     }
  2384. }
  2385. PMRet = PeekMessage((LPMSG)&wmsg, NULL, 0, 0, PM_REMOVE);
  2386. if(PMRet)
  2387. {
  2388.     if(lpMyChkInf->ChkIsActive &&
  2389.        (wmsg.message == WM_KEYDOWN))
  2390.     {
  2391. //
  2392. // Because this Message Loop is not USERS dialog
  2393. //  message loop we must do all the keyboard API
  2394. //  mapping ourselves. Mouse works OK.
  2395. //
  2396. // Only thing that's enabled is the CANCEL button,
  2397. //  so all of ESC RETURN and SPACE will cancel.
  2398. //
  2399. if((wmsg.wParam == VK_ESCAPE) ||
  2400.    (wmsg.wParam == VK_SPACE)  ||
  2401.    (wmsg.wParam == VK_RETURN)  )
  2402. {
  2403.     lpMyChkInf->ChkCancelBool = TRUE;
  2404.     SendDlgItemMessage(lpMyChkInf->hProgDlgWnd,
  2405.        DLGCHK_CANCEL,BM_SETSTATE,
  2406.        TRUE,0L);
  2407. }
  2408.     }
  2409.     TranslateMessage((LPMSG)&wmsg);
  2410.     DispatchMessage((LPMSG)&wmsg);
  2412.     if((wmsg.message == WM_KEYDOWN)    ||
  2413.        (wmsg.message == WM_KEYUP)      ||
  2414.        (wmsg.message == WM_SYSKEYDOWN) ||
  2415.        (wmsg.message == WM_SYSKEYUP)  )
  2416.     {
  2417. goto DoWait;
  2418.     }
  2419. #ifdef OPK2
  2420.     goto DoYld2;
  2421. #else
  2422.     goto DoYld;
  2423. #endif
  2424. }
  2425.     }
  2426.     if(lpMyChkInf->ChkCancelBool)
  2427. return(1L);
  2428.     else
  2429. return(0L);
  2430.     break;
  2432. default:
  2433.     return(0L);
  2434.     break;
  2436.     }
  2437. }
  2439. #ifdef DOSETUPCHK
  2441. LRESULT CALLBACK ChkSetupCBProc(UINT msg, LPARAM lRefData, LPARAM lParam1,
  2442. LPARAM lParam2, LPARAM lParam3,
  2443. LPARAM lParam4, LPARAM lParam5)
  2444. {
  2445.     LPMYCHKINFOSTRUCT  lpMyChkInf;
  2446.     BOOL        PMRet;
  2447.     MSG         wmsg;
  2450.     lpMyChkInf   = (LPMYCHKINFOSTRUCT)lRefData;
  2451.     lpMyChkInf->lpFixFDisp   = (LPFIXFATDISP)lParam1;
  2452.     lpMyChkInf->lParam1    = lParam1;
  2453.     lpMyChkInf->lParam2    = lParam2;
  2454.     lpMyChkInf->lParam3    = lParam3;
  2455.     lpMyChkInf->lParam4    = lParam4;
  2456.     lpMyChkInf->lParam5    = lParam5;
  2457.     lpMyChkInf->IsFolder   = FALSE;
  2458.     lpMyChkInf->IsRootFolder   = FALSE;
  2459.     lpMyChkInf->UseAltDlgTxt   = FALSE;
  2460.     lpMyChkInf->UseAltDefBut   = FALSE;
  2461.     lpMyChkInf->CancelIsDefault   = FALSE;
  2462.     lpMyChkInf->AltDefButIndx   = 0;
  2463.     lpMyChkInf->UseAltCantFix   = FALSE;
  2464.     lpMyChkInf->AltCantFixTstFlag = 0;
  2465.     lpMyChkInf->AltCantFixHID   = 0xFFFFFFFFL;
  2466.     lpMyChkInf->AltCantFixRepHID  = 0xFFFFFFFFL;
  2468.     switch(msg)
  2469.     {
  2470. case DU_ERRORDETECTED:
  2471.     switch(LOWORD(lpMyChkInf->lParam2)) {
  2473. case FATERRXLNK:
  2474.     MessageBox(lpMyChkInf->hProgDlgWnd,
  2475.        "Setup Check detected a Cross Link.",
  2476.        "ScanDisk for SETUP",
  2477.        MB_ICONINFORMATION | MB_OK);
  2478.     return(0L);
  2479.     break;
  2481. default:
  2482.     return(0L);
  2483.     break;
  2484.     }
  2485.     break;
  2487. case DU_OPCOMPLETE:
  2488.     return(0L);
  2489.     break;
  2491. case DU_INITENGINE:
  2492.     SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+4, TRUE, lpMyChkInf->lParam1);
  2493.     return(0L);
  2494.     break;
  2496. case DU_YIELD:
  2497. case DU_OPUPDATE:
  2498.     SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+4, TRUE, lpMyChkInf->lParam1);
  2499. DoYld:
  2500. #ifdef OPK2
  2501.     SendMessage(lpMyChkInf->hProgDlgWnd, WM_APP+5, 0, 0L);
  2502. #endif
  2503.     PMRet = PeekMessage((LPMSG)&wmsg, NULL, 0, 0, PM_REMOVE);
  2504.     if(PMRet)
  2505.     {
  2506. if(lpMyChkInf->ChkIsActive &&
  2507.    (wmsg.message == WM_KEYDOWN))
  2508. {
  2509.     //
  2510.     // Because this Message Loop is not USERS dialog
  2511.     // message loop we must do all the keyboard API
  2512.     // mapping ourselves. Mouse works OK.
  2513.     //
  2514.     // Only thing that's enabled is the CANCEL button,
  2515.     // so all of ESC RETURN and SPACE will cancel.
  2516.     //
  2517.     if((wmsg.wParam == VK_ESCAPE) ||
  2518.        (wmsg.wParam == VK_SPACE)  ||
  2519.        (wmsg.wParam == VK_RETURN)    )
  2520.     {
  2521. lpMyChkInf->ChkCancelBool = TRUE;
  2522. SendDlgItemMessage(lpMyChkInf->hProgDlgWnd,
  2523.    DLGCHK_CANCEL,BM_SETSTATE,
  2524.    TRUE,0L);
  2525.     }
  2526. }
  2527. TranslateMessage((LPMSG)&wmsg);
  2528. DispatchMessage((LPMSG)&wmsg);
  2530. if((wmsg.message == WM_KEYDOWN)    ||
  2531.    (wmsg.message == WM_KEYUP)    ||
  2532.    (wmsg.message == WM_SYSKEYDOWN) ||
  2533.    (wmsg.message == WM_SYSKEYUP)     )
  2534. {
  2535.     WaitMessage();
  2536. }
  2537. goto DoYld;
  2538.     }
  2539.     if(lpMyChkInf->ChkCancelBool)
  2540. return(1L);
  2541.     else
  2542. return(0L);
  2543.     break;
  2545. default:
  2546.     return(0L);
  2547.     break;
  2548.     }
  2549. }
  2551. #endif // DOSETUPCHK
  2553. BOOL WINAPI ChkSADlgWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  2554. {
  2555.     LPMYCHKINFOSTRUCT lpMyChkInf;
  2557.     lpMyChkInf = (LPMYCHKINFOSTRUCT)GetWindowLong(hwnd,DWL_USER);
  2559.     switch (msg) {
  2561. case  WM_INITDIALOG:
  2562.     SetWindowLong(hwnd,DWL_USER,lParam);
  2563.     lpMyChkInf = (LPMYCHKINFOSTRUCT)lParam;
  2565.     if(lpMyChkInf->MyFixOpt & DLGCHK_NOSYS)
  2566. CheckRadioButton(hwnd, DLGCHKSAO_DOALL, DLGCHKSAO_NODATA, DLGCHKSAO_NOSYS);
  2567.     else if(lpMyChkInf->MyFixOpt & DLGCHK_NODATA)
  2568. CheckRadioButton(hwnd, DLGCHKSAO_DOALL, DLGCHKSAO_NODATA, DLGCHKSAO_NODATA);
  2569.     else
  2570. CheckRadioButton(hwnd, DLGCHKSAO_DOALL, DLGCHKSAO_NODATA, DLGCHKSAO_DOALL);
  2572.     if(lpMyChkInf->MyFixOpt & DLGCHK_NOWRTTST)
  2573. CheckDlgButton(hwnd, DLGCHKSAO_NOWRTTST , TRUE);
  2574.     else
  2575. CheckDlgButton(hwnd, DLGCHKSAO_NOWRTTST , FALSE);
  2577.     if(lpMyChkInf->MyFixOpt & DLGCHK_ALLHIDSYS)
  2578. CheckDlgButton(hwnd, DLGCHKSAO_ALLHIDSYS , TRUE);
  2579.     else
  2580. CheckDlgButton(hwnd, DLGCHKSAO_ALLHIDSYS , FALSE);
  2582.     return(TRUE);
  2583.     break;
  2585. case WM_COMMAND:
  2586.     switch  (wParam) {
  2588. case DLGCHKSAO_OK:
  2589.     if(IsDlgButtonChecked(hwnd, DLGCHKSAO_ALLHIDSYS))
  2590. lpMyChkInf->MyFixOpt |= DLGCHK_ALLHIDSYS;
  2591.     else
  2592. lpMyChkInf->MyFixOpt &= ~DLGCHK_ALLHIDSYS;
  2594.     if(IsDlgButtonChecked(hwnd, DLGCHKSAO_NOWRTTST))
  2595. lpMyChkInf->MyFixOpt |= DLGCHK_NOWRTTST;
  2596.     else
  2597. lpMyChkInf->MyFixOpt &= ~DLGCHK_NOWRTTST;
  2599.     lpMyChkInf->MyFixOpt &= ~(DLGCHK_NOSYS | DLGCHK_NODATA);
  2600.     if(IsDlgButtonChecked(hwnd, DLGCHKSAO_NOSYS))
  2601. lpMyChkInf->MyFixOpt |= DLGCHK_NOSYS;
  2602.     else if(IsDlgButtonChecked(hwnd, DLGCHKSAO_NODATA))
  2603. lpMyChkInf->MyFixOpt |= DLGCHK_NODATA;
  2605.     EndDialog(hwnd, IDOK);
  2606.     return(TRUE);
  2607.     break;
  2609. case DLGCHKSAO_CANCEL:
  2610.     EndDialog(hwnd, IDCANCEL);
  2611.     return(TRUE);
  2612.     break;
  2614. case DLGCHKSAO_DOALL:
  2615. case DLGCHKSAO_NOSYS:
  2616. case DLGCHKSAO_NODATA:
  2617.     CheckRadioButton(hwnd, DLGCHKSAO_DOALL, DLGCHKSAO_NODATA, wParam);
  2618.     return(TRUE);
  2619.     break;
  2621. case DLGCHKSAO_NOWRTTST:
  2622. case DLGCHKSAO_ALLHIDSYS:
  2623.     CheckDlgButton(hwnd, wParam, !IsDlgButtonChecked(hwnd, wParam));
  2624.     return(TRUE);
  2625.     break;
  2627. default:
  2628.     return(FALSE);
  2630.     }
  2631.     break;
  2633. case WM_HELP:
  2634.     WinHelp((HWND) ((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP,
  2635.     (DWORD) (LPSTR) ChkSAOaIds);
  2636.     return(TRUE);
  2637.     break;
  2639. case WM_CONTEXTMENU:
  2640.     WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
  2641.     (DWORD) (LPSTR) ChkSAOaIds);
  2642.     return(TRUE);
  2643.     break;
  2645. default:
  2646.     return(FALSE);
  2647.     break;
  2648.     }
  2649.     return(FALSE);
  2650. }
  2652. BOOL WINAPI ChkAdvDlgWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  2653. {
  2654.     LPMYCHKINFOSTRUCT lpMyChkInf;
  2655.     PSTR       pMsgBuf;
  2657. #define SZBUFA2       128
  2658. #define SZBUFB2       128
  2659. #define SZBUFC2       128
  2660. #define TOTMSZ2       (SZBUFA2+SZBUFB2+SZBUFC2)
  2662. #define aBuf1 (&(pMsgBuf[0]))
  2663. #define aBuf2 (&(pMsgBuf[SZBUFA2]))
  2664. #define aBuf3 (&(pMsgBuf[SZBUFA2+SZBUFB2]))
  2666.     lpMyChkInf = (LPMYCHKINFOSTRUCT)GetWindowLong(hwnd,DWL_USER);
  2668.     switch (msg) {
  2670. case  WM_INITDIALOG:
  2671.     SetWindowLong(hwnd,DWL_USER,lParam);
  2672.     lpMyChkInf = (LPMYCHKINFOSTRUCT)lParam;
  2674.     pMsgBuf = (PSTR)LocalAlloc(LMEM_FIXED,TOTMSZ2);
  2675.     if(!pMsgBuf)
  2676.     {
  2677. MyChkdskMessageBox(lpMyChkInf, IDS_NOMEM2,
  2678.    MB_ICONINFORMATION | MB_OK);
  2679. EndDialog(hwnd, IDCANCEL);
  2680. return(TRUE);
  2681.     }
  2683.     if(lpMyChkInf->MyFixOpt & DLGCHK_XLDEL)
  2684. CheckRadioButton(hwnd, DLGCHKADV_XLDEL, DLGCHKADV_XLIGN, DLGCHKADV_XLDEL);
  2685.     else if(lpMyChkInf->MyFixOpt & DLGCHK_XLCPY)
  2686. CheckRadioButton(hwnd, DLGCHKADV_XLDEL, DLGCHKADV_XLIGN, DLGCHKADV_XLCPY);
  2687.     else
  2688. CheckRadioButton(hwnd, DLGCHKADV_XLDEL, DLGCHKADV_XLIGN, DLGCHKADV_XLIGN);
  2690.     if(lpMyChkInf->MyFixOpt & DLGCHK_LSTMF)
  2691. CheckRadioButton(hwnd, DLGCHKADV_LSTF, DLGCHKADV_LSTMF, DLGCHKADV_LSTMF);
  2692.     else
  2693. CheckRadioButton(hwnd, DLGCHKADV_LSTF, DLGCHKADV_LSTMF, DLGCHKADV_LSTF);
  2695.     if(lpMyChkInf->MyFixOpt & DLGCHK_NOCHKDT)
  2696. CheckDlgButton(hwnd, DLGCHKADV_CHKDT , FALSE);
  2697.     else
  2698. CheckDlgButton(hwnd, DLGCHKADV_CHKDT , TRUE);
  2700.     if(lpMyChkInf->MyFixOpt2 & DLGCHK_NOCHKHST)
  2701. CheckDlgButton(hwnd, DLGCHKADV_CHKHST , FALSE);
  2702.     else
  2703. CheckDlgButton(hwnd, DLGCHKADV_CHKHST , TRUE);
  2705.     if(lpMyChkInf->MyFixOpt & DLGCHK_NOCHKNM)
  2706. CheckDlgButton(hwnd, DLGCHKADV_CHKNM , FALSE);
  2707.     else
  2708. CheckDlgButton(hwnd, DLGCHKADV_CHKNM , TRUE);
  2710.     if(lpMyChkInf->MyFixOpt & DLGCHK_REP)
  2711.     {
  2712. if(lpMyChkInf->MyFixOpt2 & DLGCHK_REPONLYERR)
  2713. {
  2714.     CheckRadioButton(hwnd, DLGCHKADV_REPALWAYS, DLGCHKADV_REPIFERR, DLGCHKADV_REPIFERR);
  2715. } else {
  2716.     CheckRadioButton(hwnd, DLGCHKADV_REPALWAYS, DLGCHKADV_REPIFERR, DLGCHKADV_REPALWAYS);
  2717. }
  2718.     } else {
  2719. CheckRadioButton(hwnd, DLGCHKADV_REPALWAYS, DLGCHKADV_REPIFERR, DLGCHKADV_NOREP);
  2720.     }
  2722.     if(lpMyChkInf->MyFixOpt2 & DLGCHK_NOLOG)
  2723.     {
  2724. CheckRadioButton(hwnd, DLGCHKADV_LOGREP, DLGCHKADV_NOLOG, DLGCHKADV_NOLOG);
  2725.     } else {
  2726. if(lpMyChkInf->MyFixOpt2 & DLGCHK_LOGAPPEND)
  2727. {
  2728.     CheckRadioButton(hwnd, DLGCHKADV_LOGREP, DLGCHKADV_NOLOG, DLGCHKADV_LOGAPPND);
  2729. } else {
  2730.     CheckRadioButton(hwnd, DLGCHKADV_LOGREP, DLGCHKADV_NOLOG, DLGCHKADV_LOGREP);
  2731. }
  2732.     }
  2734.     return(TRUE);
  2735.     break;
  2737. case WM_COMMAND:
  2738.     switch  (wParam) {
  2740. case DLGCHKADV_OK:
  2741.     if(IsDlgButtonChecked(hwnd, DLGCHKADV_CHKDT))
  2742. lpMyChkInf->MyFixOpt &= ~DLGCHK_NOCHKDT;
  2743.     else
  2744. lpMyChkInf->MyFixOpt |= DLGCHK_NOCHKDT;
  2746.     if(IsDlgButtonChecked(hwnd, DLGCHKADV_CHKHST))
  2747. lpMyChkInf->MyFixOpt2 &= ~DLGCHK_NOCHKHST;
  2748.     else
  2749. lpMyChkInf->MyFixOpt2 |= DLGCHK_NOCHKHST;
  2751.     if(IsDlgButtonChecked(hwnd, DLGCHKADV_CHKNM))
  2752. lpMyChkInf->MyFixOpt &= ~DLGCHK_NOCHKNM;
  2753.     else
  2754. lpMyChkInf->MyFixOpt |= DLGCHK_NOCHKNM;
  2756.     if(IsDlgButtonChecked(hwnd, DLGCHKADV_LSTMF))
  2757. lpMyChkInf->MyFixOpt |= DLGCHK_LSTMF;
  2758.     else
  2759. lpMyChkInf->MyFixOpt &= ~DLGCHK_LSTMF;
  2761.     lpMyChkInf->MyFixOpt &= ~(DLGCHK_XLDEL | DLGCHK_XLCPY);
  2762.     if(IsDlgButtonChecked(hwnd, DLGCHKADV_XLDEL))
  2763. lpMyChkInf->MyFixOpt |= DLGCHK_XLDEL;
  2764.     else if(IsDlgButtonChecked(hwnd, DLGCHKADV_XLCPY))
  2765. lpMyChkInf->MyFixOpt |= DLGCHK_XLCPY;
  2767.     lpMyChkInf->MyFixOpt2 &= ~(DLGCHK_NOLOG | DLGCHK_LOGAPPEND);
  2768.     if(IsDlgButtonChecked(hwnd, DLGCHKADV_NOLOG))
  2769. lpMyChkInf->MyFixOpt2 |= DLGCHK_NOLOG;
  2770.     else if(IsDlgButtonChecked(hwnd, DLGCHKADV_LOGAPPND))
  2771. lpMyChkInf->MyFixOpt2 |= DLGCHK_LOGAPPEND;
  2773.     lpMyChkInf->MyFixOpt &= ~(DLGCHK_REP);
  2774.     lpMyChkInf->MyFixOpt2 &= ~(DLGCHK_REPONLYERR);
  2775.     if(!IsDlgButtonChecked(hwnd, DLGCHKADV_NOREP))
  2776.     {
  2777. lpMyChkInf->MyFixOpt |= DLGCHK_REP;
  2778. if(IsDlgButtonChecked(hwnd, DLGCHKADV_REPIFERR))
  2779. {
  2780.     lpMyChkInf->MyFixOpt2 |= DLGCHK_REPONLYERR;
  2781. }
  2782.     }
  2783.     EndDialog(hwnd, IDOK);
  2784.     return(TRUE);
  2785.     break;
  2787. case DLGCHKADV_CANCEL:
  2788.     EndDialog(hwnd, IDCANCEL);
  2789.     return(TRUE);
  2790.     break;
  2792. case DLGCHKADV_LSTF:
  2793. case DLGCHKADV_LSTMF:
  2794.     CheckRadioButton(hwnd, DLGCHKADV_LSTF, DLGCHKADV_LSTMF, wParam);
  2795.     return(TRUE);
  2796.     break;
  2798. case DLGCHKADV_XLDEL:
  2799. case DLGCHKADV_XLCPY:
  2800. case DLGCHKADV_XLIGN:
  2801.     CheckRadioButton(hwnd, DLGCHKADV_XLDEL, DLGCHKADV_XLIGN, wParam);
  2802.     return(TRUE);
  2803.     break;
  2805. case DLGCHKADV_LOGREP:
  2806. case DLGCHKADV_LOGAPPND:
  2807. case DLGCHKADV_NOLOG:
  2808.     CheckRadioButton(hwnd, DLGCHKADV_LOGREP, DLGCHKADV_NOLOG, wParam);
  2809.     return(TRUE);
  2810.     break;
  2812. case DLGCHKADV_REPALWAYS:
  2813. case DLGCHKADV_NOREP:
  2814. case DLGCHKADV_REPIFERR:
  2815.     CheckRadioButton(hwnd, DLGCHKADV_REPALWAYS, DLGCHKADV_REPIFERR, wParam);
  2816.     return(TRUE);
  2817.     break;
  2819. case DLGCHKADV_CHKDT:
  2820. case DLGCHKADV_CHKNM:
  2821. case DLGCHKADV_CHKHST:
  2822.     CheckDlgButton(hwnd, wParam, !IsDlgButtonChecked(hwnd, wParam));
  2823.     return(TRUE);
  2824.     break;
  2826. default:
  2827.     return(FALSE);
  2829.     }
  2830.     break;
  2832. case WM_HELP:
  2833.     WinHelp((HWND) ((LPHELPINFO) lParam)->hItemHandle, NULL, HELP_WM_HELP,
  2834.     (DWORD) (LPSTR) ChkAdvaIds);
  2835.     return(TRUE);
  2836.     break;
  2838. case WM_CONTEXTMENU:
  2839.     WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
  2840.     (DWORD) (LPSTR) ChkAdvaIds);
  2841.     return(TRUE);
  2842.     break;
  2844. default:
  2845.     return(FALSE);
  2846.     break;
  2847.     }
  2848.     return(FALSE);
  2849. }
  2851. #ifdef OPK2
  2853. // this right aligns the numbers to dxNum1 width and pretty's it up 
  2854. void FAR PASCAL BeutifyNumberOutput(HWND hwnd, HDC hDC,
  2855.     WORD dxNum1, int id, int AltSRcID,
  2856.     DWORD dwInput, DWORD dwInput2)
  2857. {
  2858.     char szBuf1[128];
  2859.     char szBuf2[128];
  2860.     char szBuf3[128];
  2861.     char szBuf4[128];
  2862.     DWORD pdw[2] = { (DWORD)(LPSTR)szBuf2, (DWORD)(LPSTR)szBuf4};
  2863.     int j;
  2864.     
  2865.     if(AltSRcID)
  2866.     {
  2867. LoadString(g_hInstance, AltSRcID,szBuf1,sizeof(szBuf1));
  2868.     } else {
  2869. GetDlgItemText(hwnd,id,szBuf1,sizeof(szBuf1));
  2870.     }
  2871.     AddCommas(dwInput,szBuf2,sizeof(szBuf2),FALSE);
  2872.     j = lstrlen(szBuf2);
  2873.     while(LOWORD(GetTextExtent(hDC,(LPSTR)szBuf2,j)) < (dxNum1 - 2))
  2874.     {
  2875.         hmemcpy(szBuf2+1, szBuf2, j+1);
  2876.         szBuf2[0] = ' ';
  2877.         j++;
  2878.     }
  2879.     
  2880.     AddCommas(dwInput2,szBuf4,sizeof(szBuf4),FALSE);
  2881.     
  2882.     FormatMessage( FORMAT_MESSAGE_FROM_STRING, // | FORMAT_MESSAGE_ARGUMENT_ARRAY,
  2883.                   szBuf1, 0, 0, szBuf3, sizeof(szBuf3), pdw);
  2884.     //wsprintf(szBuf3,szBuf1,(LPSTR)szBuf2,(LPSTR)szBuf4);
  2885.     SetDlgItemText(hwnd,id,szBuf3);
  2886. }
  2888. void ChkRepInit(LPMYCHKINFOSTRUCT lpMyChkInf, HWND hwnd)
  2889. {
  2890.     LPFATFIXREPORT    lpChkRep;
  2891.     DWORD       dwi;
  2892.     HFONT       hTxtFnt;
  2893.     HFONT       hFnt;
  2894.     HWND       hCtrl;
  2895.     HDC        hDC;
  2896.     WORD       dxNum1;
  2897.     WORD       i;
  2898.     char       Buf1[128];
  2899.     char       Buf2[128];
  2900.     
  2901.     lpChkRep = lpMyChkInf->lpFixRep;
  2903.     GetWindowText(hwnd,Buf1,sizeof(Buf1));
  2904.     SetStdChkTitle(lpMyChkInf, Buf1, Buf2, sizeof(Buf2));
  2905.     SetWindowText(hwnd,Buf2);
  2907.     if(lpChkRep->ProbCnt == 0L)
  2908.         i = IDS_NOERROR;
  2909.     else if(lpMyChkInf->MyFixOpt & DLGCHK_RO)
  2910.         i = IDS_NONEFIXED;
  2911.     else if(lpChkRep->ProbCnt == lpChkRep->ProbFixedCnt)
  2912.         i = IDS_ALLFIXED;
  2913.     else
  2914.         i = IDS_SOMEFIXED;
  2915.     LoadString(g_hInstance, i, Buf2, sizeof(Buf2));
  2916.     SetDlgItemText(hwnd,DLGCHKREP_ESTAT,Buf2);
  2918.     hCtrl = GetDlgItem(hwnd,DLGCHKREP_TOT);
  2919.     hTxtFnt = (HFONT)SendMessage(hCtrl,WM_GETFONT,0,0L);
  2920.     if(!hTxtFnt)
  2921.         hTxtFnt = GetStockObject(SYSTEM_FONT);
  2922.     hDC = GetDC(hCtrl);
  2923.     hFnt = SelectObject(hDC,hTxtFnt);
  2924.     dxNum1 = LOWORD(GetTextExtent(hDC,(LPSTR)"100,000,000,000",15));
  2926.     if((lpChkRep->TotDiskSzByte == 0L) &&
  2927.        ((lpChkRep->TotDiskSzK != 0L) || (lpChkRep->TotDiskSzM != 0L)))
  2928.     {
  2929. if(lpChkRep->TotDiskSzK == 0L)
  2930. {
  2931.     i = IDS_REP_TOTM;
  2932.     dwi = lpChkRep->TotDiskSzM;
  2933. } else {
  2934.     i = IDS_REP_TOTK;
  2935.     dwi = lpChkRep->TotDiskSzK;
  2936. }
  2937.     } else {
  2938. i = 0;
  2939. dwi = lpChkRep->TotDiskSzByte;
  2940.     }
  2941.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_TOT, i, dwi, 0);
  2943.     if((lpChkRep->AvailSzByte == 0L) &&
  2944.        ((lpChkRep->AvailSzK != 0L) || (lpChkRep->AvailSzM != 0L)))
  2945.     {
  2946. if(lpChkRep->AvailSzK == 0L)
  2947. {
  2948.     i = IDS_REP_AVAILM;
  2949.     dwi = lpChkRep->AvailSzM;
  2950. } else {
  2951.     i = IDS_REP_AVAILK;
  2952.     dwi = lpChkRep->AvailSzK;
  2953. }
  2954.     } else {
  2955. i = 0;
  2956. dwi = lpChkRep->AvailSzByte;
  2957.     }
  2958.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_AVAIL, i, dwi, 0);
  2960.     if((lpChkRep->BadSzDataByte == 0L) &&
  2961.        ((lpChkRep->BadSzDataK != 0L) || (lpChkRep->BadSzDataM != 0L)))
  2962.     {
  2963. if(lpChkRep->BadSzDataK == 0L)
  2964. {
  2965.     i = IDS_REP_BADM;
  2966.     dwi = lpChkRep->BadSzDataM;
  2967. } else {
  2968.     i = IDS_REP_BADK;
  2969.     dwi = lpChkRep->BadSzDataK;
  2970. }
  2971.     } else {
  2972. i = 0;
  2973. dwi = lpChkRep->BadSzDataByte;
  2974.     }
  2975.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_BAD, i, dwi, 0);
  2977.     if((lpChkRep->DirSzByte == 0L) &&
  2978.        ((lpChkRep->DirSzK != 0L) || (lpChkRep->DirSzM != 0L)))
  2979.     {
  2980. if(lpChkRep->DirSzK == 0L)
  2981. {
  2982.     i = IDS_REP_DIRM;
  2983.     dwi = lpChkRep->DirSzM;
  2984. } else {
  2985.     i = IDS_REP_DIRK;
  2986.     dwi = lpChkRep->DirSzK;
  2987. }
  2988.     } else {
  2989. i = 0;
  2990. dwi = lpChkRep->DirSzByte;
  2991.     }
  2992.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_DIR, i, dwi, lpChkRep->DirFileCnt);
  2994.     if((lpChkRep->UserSzByte == 0L) &&
  2995.        ((lpChkRep->UserSzK != 0L) || (lpChkRep->UserSzM != 0L)))
  2996.     {
  2997. if(lpChkRep->UserSzK == 0L)
  2998. {
  2999.     i = IDS_REP_USERM;
  3000.     dwi = lpChkRep->UserSzM;
  3001. } else {
  3002.     i = IDS_REP_USERK;
  3003.     dwi = lpChkRep->UserSzK;
  3004. }
  3005.     } else {
  3006. i = 0;
  3007. dwi = lpChkRep->UserSzByte;
  3008.     }
  3009.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_USER, i, dwi, lpChkRep->UserFileCnt);
  3011.     if((lpChkRep->HidSzByte == 0L) &&
  3012.        ((lpChkRep->HidSzK != 0L) || (lpChkRep->HidSzM != 0L)))
  3013.     {
  3014. if(lpChkRep->HidSzK == 0L)
  3015. {
  3016.     i = IDS_REP_HIDM;
  3017.     dwi = lpChkRep->HidSzM;
  3018. } else {
  3019.     i = IDS_REP_HIDK;
  3020.     dwi = lpChkRep->HidSzK;
  3021. }
  3022.     } else {
  3023. i = 0;
  3024. dwi = lpChkRep->HidSzByte;
  3025.     }
  3026.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_HID, i,dwi, lpChkRep->HidFileCnt);
  3028.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_BCLUS, 0,lpChkRep->BytesPerClus, 0);
  3029.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_TCLUS, 0,lpChkRep->TotDataClus, 0);
  3030.     BeutifyNumberOutput(hwnd, hDC, dxNum1, DLGCHKREP_ACLUS, 0,lpChkRep->AvailDataClus, 0);
  3032.     SelectObject(hDC,hFnt);
  3033.     ReleaseDC(hCtrl,hDC);
  3034. }
  3035. #else
  3036. // this right aligns the numbers to dxNum1 width and pretty's it up 
  3037. void FAR PASCAL SomeRandomMagic(HWND hwnd, HDC hDC, WORD dxNum1, int id, DWORD dwInput, DWORD dwInput2)
  3038. {
  3039.     char szBuf1[128];
  3040.     char szBuf2[128];
  3041.     char szBuf3[128];
  3042.     char szBuf4[128];
  3043.     DWORD pdw[2] = { (DWORD)(LPSTR)szBuf2, (DWORD)(LPSTR)szBuf4};
  3044.     int j;
  3045.     
  3046.     GetDlgItemText(hwnd,id,szBuf1,sizeof(szBuf1));
  3047.     AddCommas(dwInput,szBuf2,sizeof(szBuf2),FALSE);
  3048.     j = lstrlen(szBuf2);
  3049.     while(LOWORD(GetTextExtent(hDC,(LPSTR)szBuf2,j)) < (dxNum1 - 2))
  3050.     {
  3051.         hmemcpy(szBuf2+1, szBuf2, j+1);
  3052.         szBuf2[0] = ' ';
  3053.         j++;
  3054.     }
  3055.     
  3056.     AddCommas(dwInput2,szBuf4,sizeof(szBuf4),FALSE);
  3057.     
  3058.     FormatMessage( FORMAT_MESSAGE_FROM_STRING, // | FORMAT_MESSAGE_ARGUMENT_ARRAY,
  3059.                   szBuf1, 0, 0, szBuf3, sizeof(szBuf3), pdw);
  3060.     //wsprintf(szBuf3,szBuf1,(LPSTR)szBuf2,(LPSTR)szBuf4);
  3061.     SetDlgItemText(hwnd,id,szBuf3);
  3062. }
  3064. void ChkRepInit(LPMYCHKINFOSTRUCT lpMyChkInf, HWND hwnd)
  3065. {
  3066.     LPFATFIXREPORT    lpChkRep;
  3067.     HFONT       hTxtFnt;
  3068.     HFONT       hFnt;
  3069.     HWND       hCtrl;
  3070.     HDC        hDC;
  3071.     WORD       dxNum1;
  3072.     WORD i;
  3073.     char Buf1[128];
  3074.     char Buf2[128];
  3075.     
  3076.     lpChkRep = lpMyChkInf->lpFixRep;
  3078.     GetWindowText(hwnd,Buf1,sizeof(Buf1));
  3079.     SetStdChkTitle(lpMyChkInf, Buf1, Buf2, sizeof(Buf2));
  3080.     SetWindowText(hwnd,Buf2);
  3082.     if(lpChkRep->ProbCnt == 0L)
  3083.         i = IDS_NOERROR;
  3084.     else if(lpMyChkInf->MyFixOpt & DLGCHK_RO)
  3085.         i = IDS_NONEFIXED;
  3086.     else if(lpChkRep->ProbCnt == lpChkRep->ProbFixedCnt)
  3087.         i = IDS_ALLFIXED;
  3088.     else
  3089.         i = IDS_SOMEFIXED;
  3090.     LoadString(g_hInstance, i, Buf2, sizeof(Buf2));
  3091.     SetDlgItemText(hwnd,DLGCHKREP_ESTAT,Buf2);
  3093.     hCtrl = GetDlgItem(hwnd,DLGCHKREP_TOT);
  3094.     hTxtFnt = (HFONT)SendMessage(hCtrl,WM_GETFONT,0,0L);
  3095.     if(!hTxtFnt)
  3096.         hTxtFnt = GetStockObject(SYSTEM_FONT);
  3097.     hDC = GetDC(hCtrl);
  3098.     hFnt = SelectObject(hDC,hTxtFnt);
  3099.     dxNum1 = LOWORD(GetTextExtent(hDC,(LPSTR)"100,000,000,000",15));
  3101.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_TOT, lpChkRep->TotDiskSzByte, 0);
  3102.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_AVAIL, lpChkRep->AvailSzByte, 0);
  3103.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_BAD, lpChkRep->BadSzDataByte, 0);
  3104.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_BCLUS, lpChkRep->BytesPerClus, 0);
  3105.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_TCLUS, lpChkRep->TotDataClus, 0);
  3106.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_ACLUS, lpChkRep->AvailDataClus, 0);
  3107.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_DIR, lpChkRep->DirSzByte, lpChkRep->DirFileCnt);
  3108.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_USER, lpChkRep->UserSzByte, lpChkRep->UserFileCnt);
  3109.     SomeRandomMagic(hwnd, hDC, dxNum1, DLGCHKREP_HID, lpChkRep->HidSzByte, lpChkRep->HidFileCnt);
  3111.     SelectObject(hDC,hFnt);
  3112.     ReleaseDC(hCtrl,hDC);
  3113. }
  3114. #endif
  3116. BOOL WINAPI ChkRepDlgWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  3117. {
  3118.     switch (msg) {
  3120. case  WM_INITDIALOG:
  3121.             ChkRepInit((LPMYCHKINFOSTRUCT)lParam, hwnd);
  3122.     return(TRUE);
  3124. case WM_COMMAND:
  3125.     switch  (wParam) {
  3127. case DLGCHKREP_CLOSE:
  3128.     EndDialog(hwnd, IDOK);
  3129.     return(TRUE);
  3130.     break;
  3132. default:
  3133.     return(FALSE);
  3135.     }
  3136.     break;
  3138. default:
  3139.     return(FALSE);
  3140.     break;
  3141.     }
  3142. }
  3144. #define MAX_DRIVELIST_STRING_LEN (64+4)
  3145. #define MINIDRIVE_MARGIN 4
  3146. #define DRIVELIST_BORDER 3
  3148. BOOL NEAR MyDrawItem(HWND hwnd, WORD wParam, LPDRAWITEMSTRUCT lpdis)
  3149. {
  3150.     HDC hdc;
  3151.     RECT rc;
  3152.     char szText[MAX_DRIVELIST_STRING_LEN];
  3153.     int xString, yString, xMiniDrive, dyString;
  3154.     SIZE siz;
  3156.     if(lpdis->CtlID != DLGCHK_DRVLIST)
  3157. return(FALSE);
  3159.     hdc = lpdis->hDC;
  3160.     rc = lpdis->rcItem;
  3162.     SendMessage(lpdis->hwndItem,LB_GETTEXT,lpdis->itemID,(LPARAM)(LPSTR)szText);
  3164.     xMiniDrive = rc.left + DRIVELIST_BORDER;
  3165.     rc.left = xString = xMiniDrive + g_cxIcon + MINIDRIVE_MARGIN;
  3166.     GetTextExtentPoint(hdc, szText, lstrlen(szText), &siz);
  3168.     dyString = siz.cy;
  3169.     rc.right = rc.left + siz.cx;
  3170.     rc.left--;
  3171.     rc.right++;
  3173.     if(lpdis->itemAction != ODA_FOCUS)
  3174.     {
  3175. yString = rc.top + (rc.bottom - rc.top - dyString)/2;
  3177. SetBkColor(hdc, GetSysColor((lpdis->itemState & ODS_SELECTED) ?
  3178. COLOR_HIGHLIGHT : COLOR_WINDOW));
  3179. SetTextColor(hdc, GetSysColor((lpdis->itemState & ODS_SELECTED) ?
  3180. COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT));
  3182. ExtTextOut(hdc, xString, yString, ETO_OPAQUE,
  3183.     &rc, szText, lstrlen(szText), NULL);
  3185. ImageList_Draw(g_himlIconsSmall,
  3186.        (int)HIWORD(lpdis->itemData),
  3187.                        hdc, xMiniDrive,
  3188.        rc.top + (rc.bottom - rc.top - g_cyIcon)/2,
  3189.                        (lpdis->itemState & ODS_SELECTED) ? (ILD_SELECTED | ILD_FOCUS) : ILD_NORMAL);
  3190.     }
  3192.     if (lpdis->itemAction == ODA_FOCUS ||
  3193. (lpdis->itemState & ODS_FOCUS))
  3194.     {
  3195. DrawFocusRect(hdc, &rc);
  3196.     }
  3197.     return(TRUE);
  3198. }
  3200. //---------------------------------------------------------------------------
  3201. // Returns TRUE if the given string is a UNC path.
  3202. //
  3203. // TRUE
  3204. // "\foobar"
  3205. // "\foo" <- careful
  3206. // "\"
  3207. // FALSE
  3208. // "foo"
  3209. // "foo"
  3210. BOOL NEAR MyPathIsUNC(LPSTR lpsz)
  3211. {
  3212.     if (lpsz[0] == '\' && lpsz[1] == '\')
  3213. return TRUE;
  3214.     else
  3215. return FALSE;
  3216. }
  3218. VOID NEAR MakeThisDriveVisible(HWND hwndDlg, LPMYCHKINFOSTRUCT lpMyChkInf)
  3219. {
  3220.     HWND  hDrv;
  3221.     WORD  ThisDrv;
  3222.     int   i;
  3223.     int   cnt;
  3225.     if(!lpMyChkInf->IsDrvList)
  3226. return;
  3228.     hDrv = GetDlgItem(hwndDlg,DLGCHK_DRVLIST);
  3230.     if((lpMyChkInf->IsSplitDrv) && (!(lpMyChkInf->DoingCompDrv)))
  3231.     {
  3232. ThisDrv = lpMyChkInf->CompDrv;
  3233.     } else {
  3234. ThisDrv = lpMyChkInf->lpwddi->iDrive;
  3235.     }
  3236.     cnt = (int)SendMessage(hDrv,LB_GETCOUNT,0,0L);
  3237.     for(i = 0; i < cnt; i++)
  3238.     {
  3239. if(LOWORD(SendMessage(hDrv,LB_GETITEMDATA,i,0L)) == ThisDrv)
  3240.     break;
  3241.     }
  3242.     if(i < cnt)
  3243. SendMessage(hDrv,LB_SETTOPINDEX,i,0L);
  3244.     return;
  3245. }
  3247. BOOL NEAR InitDriveList(HWND hwndDlg, LPSHCHECKDISKINFO  lpSHChkInfo)
  3248. {
  3249.     SHFILEINFO       shfi;
  3250.     LPMYCHKINFOSTRUCT lpMyChkInf;
  3251.     DWORD       EngFlags[26];
  3252. #ifndef FROSTING
  3253.     DWORD       typ;
  3254.     DWORD       sz;
  3255. #endif
  3256.     int        ThisDrv = 0;
  3257. #ifndef FROSTING
  3258.     HKEY       hKey;
  3259. #endif
  3260.     BOOL       LastDrvValid;
  3261.     HWND       hDrv;
  3262.     int        i;
  3263.     int        j;
  3264.     int        iIndex;
  3265.     BOOL       FndValidDrv = FALSE;
  3266.     char       Drv[] = "A:\";
  3267. #ifndef FROSTING
  3268.     char       RegKey[80];
  3269. #endif