开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PTDLGS.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：35k
源码类别：

Windows编程

开发平台：

Visual C++

PTDLGS.C：源码内容
  1. #include "porttool.h"
  2. #include "port.h"
  4. int DLGOFFSET = 100;
  6. RESULT rIssue;
  8. HANDLE    hBkFileHeap;
  9. extern HWND    hDlgPort;
  10. extern HWND    hDlgPortStatus;
  13. /* function prototypes for helper functions */
  14. void WINAPI GrowDialog (HWND, BOOL);
  15. BOOL WINAPI GetHelpFileName (char *);
  16. BOOL WINAPI BuildFileList (char *, LPBKFILELIST *);
  17. BOOL WINAPI AddFile (char *, char *, BKFILELIST *);
  18. BOOL WINAPI RemoveFile (char *, LPBKFILELIST *);
  19. BOOL WINAPI FreeFileList (BKFILELIST *);
  21. BOOL MySetEvent (HWND hWnd, HANDLE hEvent);
  22. BOOL MyResetEvent (HWND hWnd, HANDLE hEvent);
  24. /* port options dialog */
  25. BOOL WINAPI OptionsDlgProc (
  26.     HWND    hDlg,
  27.     UINT    uMsg,
  28.     UINT    uParam,
  29.     LONG    lParam)
  30. {
  31. BOOL       bRet = TRUE;
  32. static  DWORD      *dwPTFlags;
  33. static  HFONT      hStrikeoutFont;
  34. static  HFONT      hSystemFont;
  35. LOGFONT    lf;
  37.     switch (uMsg)
  38. {
  39. case WM_INITDIALOG:
  40.     /* create strikeout font for ignored tokens */
  41.     hSystemFont = GetStockObject (SYSTEM_FONT);
  42.     GetObject (hSystemFont, sizeof (LOGFONT), &lf);
  43.     lf.lfStrikeOut = TRUE;
  44.     hStrikeoutFont = CreateFontIndirect (&lf);
  46.     /* initialize token control with stock system font */
  47.     SendMessage (GetDlgItem (hDlg, IDC_CURTOKEN),
  48.  WM_SETFONT,
  49.  (UINT)hSystemFont,
  50.  FALSE);
  52.     /* save dwPTFlags from lParam */
  53.     dwPTFlags = (DWORD *)lParam;
  55.     /* initialize current token if any */
  56.     if (*(WORD *)rIssue.lpszToken != MAXTOKENLEN)
  57. SetDlgItemText (hDlg, IDC_CURTOKEN, rIssue.lpszToken);
  58.     else
  59. EnableWindow (GetDlgItem (hDlg, IDC_IGNORETOKEN), FALSE);
  61.     /* initialize search flag check boxes */
  62.     CheckDlgButton (hDlg, IDC_NOAPIS, (*dwPTFlags & PT_NOAPIS));
  63.     CheckDlgButton (hDlg, IDC_NOMESSAGES, (*dwPTFlags & PT_NOMESSAGES));
  64.     CheckDlgButton (hDlg, IDC_NOSTRUCTURES, (*dwPTFlags & PT_NOSTRUCTURES));
  65.     CheckDlgButton (hDlg, IDC_NOMACROS, (*dwPTFlags & PT_NOMACROS));
  66.     CheckDlgButton (hDlg, IDC_NOCONSTANTS, (*dwPTFlags & PT_NOCONSTANTS));
  67.     CheckDlgButton (hDlg, IDC_NOTYPES, (*dwPTFlags & PT_NOTYPES));
  68.     CheckDlgButton (hDlg, IDC_NOCUSTOM, (*dwPTFlags & PT_NOCUSTOM));
  69.     CheckDlgButton (hDlg, IDC_IGNORECASE, (*dwPTFlags & PT_IGNORECASE));
  71.     /* set focus to first check box, return FALSE */
  72.     SetFocus (GetDlgItem (hDlg, IDC_NOAPIS));
  73.     bRet = FALSE;
  74.     break;
  76. case WM_COMMAND:
  77.     switch (LOWORD (uParam))
  78. {
  79. case IDOK:
  80.     /* get check box states and return as FLAGS in UM_PORT message */
  81.     *dwPTFlags = (*dwPTFlags & ~PT_IGNORECASE) ^
  82. (IsDlgButtonChecked (hDlg, IDC_IGNORECASE) ? PT_IGNORECASE : 0);
  83.     *dwPTFlags = (*dwPTFlags & ~PT_NOAPIS) ^
  84. (IsDlgButtonChecked (hDlg, IDC_NOAPIS) ? PT_NOAPIS : 0);
  85.     *dwPTFlags = (*dwPTFlags & ~PT_NOMESSAGES) ^
  86. (IsDlgButtonChecked (hDlg, IDC_NOMESSAGES) ? PT_NOMESSAGES : 0);
  87.     *dwPTFlags = (*dwPTFlags & ~PT_NOSTRUCTURES) ^
  88. (IsDlgButtonChecked (hDlg, IDC_NOSTRUCTURES) ? PT_NOSTRUCTURES : 0);
  89.     *dwPTFlags = (*dwPTFlags & ~PT_NOMACROS) ^
  90. (IsDlgButtonChecked (hDlg, IDC_NOMACROS) ? PT_NOMACROS : 0);
  91.     *dwPTFlags = (*dwPTFlags & ~PT_NOCONSTANTS) ^
  92. (IsDlgButtonChecked (hDlg, IDC_NOCONSTANTS) ? PT_NOCONSTANTS : 0);
  93.     *dwPTFlags = (*dwPTFlags & ~PT_NOTYPES) ^
  94. (IsDlgButtonChecked (hDlg, IDC_NOTYPES) ? PT_NOTYPES : 0);
  95.     *dwPTFlags = (*dwPTFlags & ~PT_NOCUSTOM) ^
  96. (IsDlgButtonChecked (hDlg, IDC_NOCUSTOM) ? PT_NOCUSTOM : 0);
  98. case IDCANCEL:
  99.     SendMessage (GetDlgItem (hDlg, IDC_CURTOKEN), WM_SETFONT, 0, FALSE);
  100.     DeleteObject (hStrikeoutFont);
  101.     EndDialog (hDlg, LOWORD (uParam) == IDOK);
  102.     break;
  104. case IDC_IGNORETOKEN:
  105.     /* toggle ignore bit */
  106.     *dwPTFlags ^= PT_IGNORETOKEN;
  108.     /* have control draw in strikeout if ignored */
  109.     if (*dwPTFlags & PT_IGNORETOKEN)
  110. SendMessage (GetDlgItem (hDlg, IDC_CURTOKEN),
  111.      WM_SETFONT,
  112.      (UINT)hStrikeoutFont,
  113.      TRUE);
  114.     /* else draw in system font */
  115.     else
  116. SendMessage (GetDlgItem (hDlg, IDC_CURTOKEN),
  117.      WM_SETFONT,
  118.      (UINT)hSystemFont,
  119.      TRUE);
  120.     break;
  121. }
  122.     break;
  124. default:
  125.     bRet = FALSE;
  126.     break;
  127. }
  129.     /* return (message was processed); */
  130.     return bRet;
  131. }
  135. /* port options dialog */
  136. BOOL WINAPI PortDlgProc (
  137.     HWND    hDlg,
  138.     UINT    uMsg,
  139.     UINT    uParam,
  140.     LONG    lParam)
  141. {
  142. BOOL    bRet = TRUE;
  143. static  DWORD   dwPTFlags;
  144. static  BOOL    bSearching = TRUE;
  145. static  BOOL    bHelpActive = FALSE, bIsHelpFile = FALSE;
  146. static  HBRUSH  hBkBrush;
  147. static  HWND    hWndEdit;
  148. static  HANDLE  hEditData = NULL;
  149. static  int     nIssues = 0;
  150. static  int     iLineNo, iStartPos;
  151. static  HLOCAL  hToken, hHelp, hIssue, hSuggest;
  152. static  HLOCAL  hEditLine;
  154. static  UINT    uLen = 0;
  157.     switch (uMsg)
  158. {
  159. case WM_INITDIALOG:
  160.     {
  161.     char    lpszTitle[MAX_PATH];
  162.     char    lpszFilename[MAX_PATH];
  163.     RECT    rc;
  165.     HDC     hDC;
  166.     HFONT   hFont;
  167.     TEXTMETRIC tm;
  169.     hFont = GetStockObject(SYSTEM_FONT);
  170.     hDC = GetDC(NULL);
  171.     hFont = SelectObject(hDC, hFont);
  172.     GetTextMetrics(hDC, &tm);
  173.     SelectObject(hDC, hFont);
  174.     ReleaseDC(NULL, hDC);
  175.     DLGOFFSET = tm.tmHeight * 5;
  177.     /* reposition self on bottom of screen */
  178.     GetWindowRect (hDlg, &rc);
  179.     SetWindowPos (hDlg,
  180.   NULL,
  181.   rc.left,
  182.   GetSystemMetrics (SM_CYSCREEN) -
  183.    (rc.bottom - rc.top + DLGOFFSET),
  184.   rc.right-rc.left,
  185.   rc.bottom-rc.top,
  186.   SWP_NOZORDER | SWP_NOSIZE);
  188.     /* set help available flag */
  189.     if (GetHelpFileName (lpszTitle))
  190. {
  191. EnableWindow (GetDlgItem (hDlg, IDC_HELPM), TRUE);
  192. bIsHelpFile = TRUE;
  193. }
  195.     /* allocate strings for Issue struct from local heap to reduce stack overhead */
  196.     if (!(rIssue.lpszToken = LocalLock (hToken = LocalAlloc (LHND, MAXTOKENLEN))) ||
  197. !(rIssue.lpszHelpStr = LocalLock (hHelp = LocalAlloc (LHND, MAXHELPLEN))) ||
  198. !(rIssue.lpszIssue = LocalLock (hIssue = LocalAlloc (LHND, MAXISSUELEN))) ||
  199. !(rIssue.lpszSuggest = LocalLock (hSuggest = LocalAlloc (LHND, MAXSUGGESTLEN))))
  200. {
  201. ErrorNotify (hDlg, IDS_MEMORYFAILED);
  202. PostMessage (hDlg, WM_COMMAND, IDC_DONE, 0);
  203. break;
  204. }
  205.     /* initialize line and token offset position stuff */
  206.     iLineNo = 0;
  207.     iStartPos = 0;
  208.     rIssue.nPosToken = 0;
  210.     /* initialize background brush for use in WM_CTLCOLOR message */
  211.     hBkBrush = (HBRUSH)GetClassLong (hDlg, GCL_HBRBACKGROUND);
  213.     /* set initial search flags to default */
  214.     dwPTFlags = 0;
  216.     /* initialize filename in caption */
  217.     LoadString (GetModuleHandle (NULL), IDS_PORTFILE, lpszTitle, MAX_PATH);
  218.     GetFileFromPath (lpszFilePath, lpszFilename);
  219.     strcat (lpszTitle, lpszFilename);
  220.     SetWindowText (hDlg, lpszTitle);
  222.     /* IDC_SUGGESTION to SW_HIDE */
  223.     ShowWindow (GetDlgItem (hDlg, IDC_SUGGESTION), SW_HIDE);
  224.     ShowWindow (GetDlgItem (hDlg, IDC_SUGGESTLABEL), SW_HIDE);
  226.     /* get edit window and data handle */
  227.     hWndEdit = (HWND)GetWindowLong (GetParent (hDlg), WL_HWNDEDIT);
  229. #if !defined (WIN32)
  231.     hEditData = (HANDLE)SendMessage (hWndEdit, EM_GETHANDLE, 0, 0);
  233. #else
  234.     {
  235. char    *lpEditData;
  236. char    sz[80];
  237. MEMORYSTATUS memstat;
  239. uLen = GetWindowTextLength (hWndEdit);
  240. hEditData = LocalAlloc (LHND, uLen+1);
  241. if (hEditData == NULL) {
  242.     memstat.dwLength = sizeof(MEMORYSTATUS);
  243.     GlobalMemoryStatus (&memstat);
  244.     wsprintf (sz, "Failed Allocation: %u | %u (%u%%)", (UINT)uLen+1, (UINT)memstat.dwAvailPhys, memstat.dwMemoryLoad);
  245.     //MessageBox (GetFocus(), sz, "PortTool", MB_OK);
  246.     uLen = 500000;
  247.     while (hEditData == NULL && uLen > 1000) {
  248. uLen -= 1000;
  249. hEditData = LocalAlloc (LHND, uLen+1);
  250.     }
  251.     wsprintf (sz, "hEditData = %u : uLen = %u", (UINT)hEditData, (UINT)uLen);
  252.     //MessageBox (GetFocus(), sz, "PortTool", MB_OK);
  253. }
  254. lpEditData = LocalLock (hEditData);
  255. if (lpEditData == NULL) {
  256.     MessageBox (GetFocus(), "Unalble To Lock Memory!", "PortTool", MB_OK);
  257. } else {
  258.     UINT i;
  259.     i = GetWindowText (hWndEdit, lpEditData, uLen+1);
  260.     wsprintf (sz, "length: %u", i);
  261.     //MessageBox (GetFocus(), sz, "PortTool", MB_OK);
  262. }
  263. LocalUnlock (hEditData);
  264.     }
  265. #endif
  267.     /* allocate here, reallocate later when needed */
  268.     hEditLine = LocalAlloc (LHND, 1);
  270.     /* post message to start ball rolling */
  271.     PostMessage (hDlg, WM_COMMAND, (UINT)IDC_CONTINUE, 0);
  273.     /* don't worry about focus here since were going to drive the search anyway */
  274.     bRet = TRUE;
  275.     }
  276.     //MessageBox (GetFocus(), "End Of Init", "PortTool", MB_OK);
  277.     break;
  279. case WM_COMMAND:
  280.     switch (LOWORD (uParam))
  281. {
  282. case IDC_CONTINUE:
  283.     {
  284.     int     iLastLine, nCharOffset, nLineLen;
  285.     MSG     msg;
  286.     char    lpszBuff[MAXTOKENLEN];
  287.     char    *lpszLine;
  288.     char    *lpLine;
  289.     char    *lpEditData;
  291.     /* disable continue button */
  292.     EnableWindow (GetDlgItem (hDlg, IDC_CONTINUE), FALSE);
  293.     EnableWindow (GetDlgItem (hDlg, IDC_OPTIONS), FALSE);
  294.     EnableWindow (GetDlgItem (hDlg, IDCANCEL), TRUE);
  296.     /* set IDC_SEARCHFOUND to green searching */
  297.     LoadString (GetModuleHandle (NULL), IDS_SEARCHING,
  298. lpszBuff,
  299. sizeof (lpszBuff));
  300.     SetWindowText (GetDlgItem (hDlg, IDC_SEARCHFOUND), lpszBuff);
  301.     bSearching = TRUE;
  303.     /* set last line */
  304.     iLastLine = (int)SendMessage (hWndEdit, EM_GETLINECOUNT, 0, 0);
  306.     /* find next port issue */
  307.     while (TRUE)
  308. {
  309. if (iLineNo >= iLastLine)
  310.     {
  311.     /* no more issues found, so clean up and go away */
  312.     ErrorNotify (hDlg, IDS_NOMOREPORTISSUES);
  314.     /* nullify any selection in line edit control */
  315.     SendMessage (GetDlgItem (hDlg, IDC_LINE), EM_SETSEL, 0, 0);
  316.     break;
  317.     }
  319. /* increment line no */
  320. SetWindowText (GetDlgItem (hDlg, IDC_LINENO),
  321.        itoa (iLineNo, lpszBuff, 10));
  323. /* get length and number of edit line */
  324. nCharOffset = SendMessage (hWndEdit, EM_LINEINDEX, iLineNo, 0);
  325. if ((nLineLen = SendMessage (hWndEdit, EM_LINELENGTH, nCharOffset, 0)) <= 2)
  326.     goto NEXT_LINE;
  328. /* allocate enough memory for edit line */
  329. if (!(hEditLine = LocalReAlloc (hEditLine,
  330. nLineLen+1,
  331. LHND)))
  332.     {
  333.     /* no more issues found, so clean up and go away */
  334.     ErrorNotify (hDlg, IDS_MEMORYFAILED);
  335.     PostMessage (hDlg, WM_COMMAND, IDC_DONE, 0);
  336.     break;
  337.     }
  339. /* get line from edit control, and null terminate */
  341. /* get edit window and data handle */
  343. lpEditData = LocalLock (hEditData);
  345. lpLine = lpszLine = LocalLock (hEditLine);
  347. strncpy (lpszLine, lpEditData+nCharOffset, nLineLen);
  348. lpszLine[nLineLen] = 0;
  350. /* increment the token position for multiple errors in a line */
  351. lpLine += iStartPos;
  352. LocalUnlock (hEditData);
  354. /* initialize line and hilight token */
  355. SetWindowText (GetDlgItem (hDlg, IDC_LINE), lpszLine);
  357. /* reinitialize rIssue strings lengths */
  358. *(WORD *)rIssue.lpszToken = MAXTOKENLEN;
  359. *(WORD *)rIssue.lpszHelpStr = MAXHELPLEN;
  360. *(WORD *)rIssue.lpszIssue = MAXISSUELEN;
  361. *(WORD *)rIssue.lpszSuggest = MAXSUGGESTLEN;
  363. /* search next line */
  364. if (CheckString (lpLine, dwPTFlags, &rIssue))
  365.     {
  366.     /* set SEARCHFOUND string to found */
  367.     LoadString (GetModuleHandle (NULL),
  368. IDS_FOUND,
  369. lpszBuff,
  370. sizeof (lpszBuff));
  371.     strcat (lpszBuff, rIssue.lpszToken);
  372.     SetWindowText (GetDlgItem (hDlg, IDC_SEARCHFOUND), lpszBuff);
  374.     /* reenable options button */
  375.     EnableWindow (GetDlgItem (hDlg, IDC_OPTIONS), TRUE);
  377.     /* set searching flag off */
  378.     bSearching = FALSE;
  380.     /* increment issue cnt */
  381.     SetWindowText (GetDlgItem (hDlg, IDC_ISSUECNT),
  382.    itoa (++nIssues, lpszBuff, 10));
  384.     /* initialize Issue */
  385.     SetWindowText (GetDlgItem (hDlg, IDC_ISSUE), rIssue.lpszIssue);
  387.     /* if help, enble button */
  388.     EnableWindow (GetDlgItem (hDlg, IDC_HELPM),
  389.   ((*(rIssue.lpszSuggest) != 0) && bIsHelpFile));
  391.     /* if suggest, show suggestion */
  392.     if (*(rIssue.lpszSuggest))
  393. {
  394. SetWindowText (GetDlgItem (hDlg, IDC_SUGGESTION),
  395.        rIssue.lpszSuggest);
  396. if (!IsWindowVisible (GetDlgItem (hDlg, IDC_SUGGESTION)))
  397.     GrowDialog (hDlg, TRUE);
  398. }
  400.     else if (IsWindowVisible (GetDlgItem (hDlg, IDC_SUGGESTION)))
  401. GrowDialog (hDlg, FALSE);
  403.     /* scroll parent edit control and select offending text */
  404.     SendMessage (hWndEdit, EM_LINESCROLL, 0, iLineNo -
  405.     SendMessage (hWndEdit, EM_GETFIRSTVISIBLELINE, 0, 0));
  406.     SendMessage (hWndEdit,
  407.  EM_SETSEL,
  408.  iStartPos + nCharOffset + rIssue.nPosToken,
  409.  iStartPos + nCharOffset + rIssue.nPosToken +
  410.      strlen (rIssue.lpszToken));
  412.     /* select text in line edit control */
  413.     SendMessage (GetDlgItem (hDlg, IDC_LINE),
  414.  EM_SETSEL,
  415.  iStartPos + rIssue.nPosToken,
  416.  iStartPos + rIssue.nPosToken +
  417.      strlen (rIssue.lpszToken));
  419.     /* reset nPosToken to check rest of line */
  420.     iStartPos += (rIssue.nPosToken + strlen (rIssue.lpszToken));
  421.     LocalUnlock (hEditLine);
  422.     break;
  423.     }
  425. /* call peek message to let user cancel if they choose */
  426. if (PeekMessage (&msg,
  427.  GetDlgItem (hDlg, IDCANCEL),
  428.  WM_LBUTTONDOWN,
  429.  WM_LBUTTONDOWN,
  430.  PM_REMOVE))
  431.     {
  432.     /* reset appropriate buttons */
  433.     EnableWindow (GetDlgItem (hDlg, IDCANCEL), FALSE);
  434.     EnableWindow (GetDlgItem (hDlg, IDC_HELPM), FALSE);
  435.     EnableWindow (GetDlgItem (hDlg, IDC_OPTIONS), TRUE);
  437.     /* break to let message get delivered */
  438.     break;
  439.     }
  441. /* also let the user exit from searching */
  442. if (PeekMessage (&msg,
  443.  GetDlgItem (hDlg, IDC_DONE),
  444.  WM_LBUTTONDOWN,
  445.  WM_LBUTTONDOWN,
  446.  PM_REMOVE))
  447.     {
  448.     PostMessage (hDlg, WM_COMMAND, IDC_DONE, 0);
  449.     break;
  450.     }
  452. /* unlock local edit line */
  453. LocalUnlock (hEditLine);
  455. /* reset token position */
  456. rIssue.nPosToken = 0;
  457. iStartPos = 0;
  458. NEXT_LINE:
  459. /* increment line and continue */
  460. iLineNo++;
  461. }
  463.     /* enable continue button unless at end of file */
  464.     if (iLineNo < iLastLine)
  465. {
  466. EnableWindow (GetDlgItem (hDlg, IDC_CONTINUE), TRUE);
  467. SetFocus (GetDlgItem (hDlg, IDC_CONTINUE));
  468. }
  469.     else
  470. {
  471. EnableWindow (GetDlgItem (hDlg, IDC_CONTINUE), FALSE);
  472. EnableWindow (GetDlgItem (hDlg, IDCANCEL), FALSE);
  473. SetFocus (GetDlgItem (hDlg, IDC_DONE));
  474. }
  475.     }
  476.     break;
  478. case WM_CLOSE:
  479. case IDC_DONE:
  480.     {
  481.     char    lpszFile[MAX_PATH];
  483.     if (bHelpActive &&
  484. GetHelpFileName (lpszFile))
  485. WinHelp (hDlg, lpszFile, HELP_QUIT, 0);
  487.     /* clean up and go away */
  488.     LocalUnlock (hToken); LocalFree (hToken);
  489.     LocalUnlock (hHelp); LocalFree (hHelp);
  490.     LocalUnlock (hIssue); LocalFree (hIssue);
  491.     LocalUnlock (hSuggest); LocalFree (hSuggest);
  492.     LocalFree (hEditLine);
  493. DestroyWindow (hDlg);
  494. hDlgPort = NULL;
  496.     }
  497.     break;
  499. case IDC_OPTIONS:
  500.     {
  501.     DWORD    dwOptions = dwPTFlags;
  503.     /* call dialog to start port process */
  504.     if (DialogBoxParam (GetModuleHandle (NULL),
  505. IDD_OPTIONSDLG,
  506. hDlg,
  507. OptionsDlgProc,
  508. (LPARAM)&dwOptions))
  509. {
  510. dwPTFlags = dwOptions;
  512. /* if PT_IGNORETOKEN, call CheckString */
  513. if (dwOptions & PT_IGNORETOKEN)
  514.     {
  515.     CheckString (rIssue.lpszToken, dwPTFlags, NULL);
  516.     dwPTFlags ^= PT_IGNORETOKEN;
  517.     }
  518. }
  520.     }
  521.     break;
  523. case IDC_HELPM:
  524.     {
  525.     char    lpszFile[MAX_PATH];
  527.     if (bIsHelpFile && GetHelpFileName (lpszFile))
  528. {
  529. WinHelp (hDlg, lpszFile, HELP_KEY, (DWORD)rIssue.lpszHelpStr);
  530. bHelpActive = TRUE;
  531. }
  532.     }
  533.     break;
  535. case IDC_RESTART:
  536.     iLineNo = 0;
  537.     rIssue.nPosToken = 0;
  538.     iStartPos = 0;
  539.     PostMessage (hDlg, WM_COMMAND, IDC_CONTINUE, 0);
  540.     break;
  541. }
  542.     break;
  544. default:
  545.     bRet = FALSE;
  546.     break;
  547. }
  549.     /* return (message was processed); */
  550.     return bRet;
  551. }
  556. /* background porting status dialog */
  557. BOOL WINAPI BkPortDlgProc (
  558.     HWND    hDlg,
  559.     UINT    uMsg,
  560.     UINT    uParam,
  561.     LONG    lParam)
  562. {
  563.   BOOL          bRet = TRUE;
  564.   char          szFileName[MAX_PATH];
  565.   char          szFilePath[MAX_PATH];
  566. static    BKFILELIST    *lpbkFiles;
  567. static    int           iCurThread;
  568. static    BOOL          bStarted = FALSE;
  569.   BKFILELIST    *lpNode;
  571. // char szDebug[80];
  573. // wsprintf (szDebug, "%i : [0x%X - 0x%X]", uMsg, uParam, lParam);
  574. // OutputDebugString (szDebug);
  576.     switch (uMsg)
  577. {
  578. case WM_INITDIALOG:
  579.     {
  580.     HWND          hIssues = GetDlgItem (hDlg, IDC_ISSUES);
  581.     HWND          hLines = GetDlgItem (hDlg, IDC_LINES);
  582.     HWND          hComplete = GetDlgItem (hDlg, IDC_COMPLETE);
  584.     /* set background icon to porttool background icon and start minimized */
  585.     SetClassLong (hDlg,
  586.   GCL_HICON,
  587.   (LONG)LoadIcon (GetModuleHandle (NULL), IDBkPort));
  589.     lpbkFiles = NULL;
  590.     iCurThread = -1;
  592.     /* build list of files to port from lParam */
  593.     if (lParam)
  594. {
  595. if (!BuildFileList ((char *)lParam, &lpbkFiles))
  596.     {
  597.     lpbkFiles = NULL;
  598.     break;
  599.     }
  600. }
  602.     else
  603. {
  604. /* get file from user first */
  605. *szFileName = 0;
  606. *szFilePath = 0;
  608. GetFileName (hDlg, szFileName, szFilePath);
  609. if (!BuildFileList (szFilePath, &lpbkFiles))
  610.     {
  611.     lpbkFiles = NULL;
  612.     break;
  613.     }
  614. }
  616.     lpNode = lpbkFiles;
  617.     /* initialize each file in list */
  618.     while (lpNode)
  619. {
  620. /* add filename to listbox */
  621. SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  622.      LB_ADDSTRING,
  623.      0,
  624.      (LPARAM)lpNode->bkFile.szFile);
  626. /* initialize some stuff */
  627. lpNode->bkFile.hDlg = hDlg;
  628. lpNode->bkFile.dwPTFlags = PT_DEFAULT;
  630. /* start background thread on each file */
  631. if (!StartBkPortThread (&lpNode->bkFile)) {
  632.     MessageBox(GetFocus(), "Failed to spawn background porting thread", "PortTool", MB_OK);
  633. }
  635. /* traverse list */
  636. lpNode = lpNode->Next;
  637. }
  639.     /* select first thread in listbox */
  640.     SendMessage (GetDlgItem (hDlg, IDC_FILELIST), LB_SETCURSEL, 0, 0);
  641.     SetDlgItemText (hDlg, IDC_FILEPATH, lpbkFiles->bkFile.szFilePath);
  643.     /* if started with /b switch */
  644.     if (!GetParent (hDlg))
  645. ShowWindow (hDlg, SW_SHOWMINIMIZED);
  646.     else
  647. MySetEvent (hDlg, lpbkFiles->hEvents[BKPORT_STATUS]);
  649.     iCurThread = 0;
  650.     bStarted = TRUE;
  651. }
  652.     break;
  654. case WM_SHOWWINDOW:
  655.     if (bStarted)
  656. {
  657. int    i = 0;
  659. lpNode = lpbkFiles;
  660. while (i++ < iCurThread)
  661.     lpNode = lpNode->Next;
  663. if (!uParam && lpNode)
  664.     MyResetEvent (hDlg, lpNode->hEvents[BKPORT_STATUS]);
  665. else if(lpNode)
  666.     MySetEvent (hDlg, lpNode->hEvents[BKPORT_STATUS]);
  667. }
  668.     break;
  670. case WM_SIZE:
  671.     if (bStarted) {
  672.     int    i = 0;
  674.      lpNode = lpbkFiles;
  675.     
  676.      while (i++ < iCurThread) {
  677.          lpNode = lpNode->Next;
  678.      }
  680.      if (uParam == SIZEICONIC && lpNode) {
  681.          MyResetEvent (hDlg, lpNode->hEvents[BKPORT_STATUS]);
  682.      } else if(lpNode) {
  683.          MySetEvent (hDlg, lpNode->hEvents[BKPORT_STATUS]);
  684.      }
  685.     }
  686.     break;
  688. case UM_STATUSUPDATE:
  689.     {
  690.     char    Buff[10];
  692.     /* update status info controls */
  693.     SetDlgItemText (hDlg, IDC_ISSUES, itoa (LOWORD (uParam), Buff, 10));
  694.     SetDlgItemText (hDlg, IDC_COMPLETE, itoa (HIWORD (uParam), Buff, 10));
  695.     SetDlgItemText (hDlg, IDC_LINES, itoa (lParam, Buff, 10));
  696.     }
  697.     break;
  699. case UM_THREADCOMPLETE:
  700.     {
  701.     int    iThread = 0;
  703.     /* find handle in list */
  704.     lpNode = lpbkFiles;
  705.     while (lpNode)
  706. {
  707. if ((HANDLE)uParam == lpNode->bkFile.hThread)
  708.     break;
  709. lpNode = lpNode->Next;
  710. iThread++;
  711. }
  713.     if (lpNode)
  714. {
  715. /* remove file list item */
  716. RemoveFile (lpNode->bkFile.szFilePath, &lpbkFiles);
  718. /* remove item from list box */
  719. SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  720.      LB_DELETESTRING,
  721.      iThread,
  722.      0);
  724. /* if current thread ended and more threads exist */
  725. if (iThread == iCurThread &&
  726.     lpbkFiles             &&
  727.     SendMessage (GetDlgItem (hDlg, IDC_FILELIST), LB_GETCOUNT, 0, 0))
  728.     {
  729.     SendMessage (GetDlgItem (hDlg, IDC_FILELIST), LB_SETCURSEL, 0, 0);
  730.     MySetEvent (hDlg, lpbkFiles->hEvents[BKPORT_STATUS]);
  731.     iCurThread = 0;
  732.     }
  734. else if (iThread == iCurThread)
  735.     {
  736.     iCurThread = -1;
  737.     PostMessage (hDlg, WM_COMMAND, IDC_BKDONE, 0);
  738.     }
  740. /* clean up controls */
  741. SetDlgItemText (hDlg, IDC_FILEPATH, "");
  742. PostMessage (hDlg, UM_STATUSUPDATE, 0, 0);
  743. }
  745.     else
  746. {
  747.                 CHAR szBuf[MAX_PATH];
  748.                 LoadString((HANDLE)GetModuleHandle(NULL),
  749.                     IDS_ERR_INVALID_THREADHND,
  750.                     szBuf,sizeof(szBuf));
  751. MessageBox (hDlg, szBuf, NULL, MB_ICONSTOP | MB_OK);
  752. ExitProcess (FALSE);
  753. }
  755.     }
  756.     break;
  758. case WM_COMMAND:
  759.     switch (LOWORD (uParam))
  760. {
  761. case IDC_FILELIST:
  762.     /* if new file selected change update signal to active thread */
  763.     if (HIWORD (uParam) == LBN_SELCHANGE)
  764. {
  765. int    i = 0;
  766. int    iNewThread = SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  767.  LB_GETCURSEL,
  768.  0,
  769.  0);
  771. /* reset current thread */
  772. lpNode = lpbkFiles;
  773. while (lpNode)
  774.     {
  775.     if (i == iCurThread)
  776. MyResetEvent (hDlg, lpNode->hEvents[BKPORT_STATUS]);
  778.     if (i == iNewThread)
  779. {
  780. MySetEvent (hDlg, lpNode->hEvents[BKPORT_STATUS]);
  781. SetDlgItemText (hDlg,
  782. IDC_FILEPATH,
  783. lpNode->bkFile.szFilePath);
  784. }
  786.     lpNode = lpNode->Next;
  787.     i++;
  788.     }
  790. iCurThread = iNewThread;
  791. }
  792.     break;
  794. case IDC_ABORTFILE:
  795.     {
  796.     int        i = 0;
  797.     HCURSOR    hOldCursor;
  799.     /* reset current thread */
  800.     lpNode = lpbkFiles;
  801.     while (lpNode)
  802. {
  803. if (i == iCurThread)
  804.     {
  805.     /* put hourglass cursor up */
  806.     hOldCursor = (HCURSOR)SetClassLong (hDlg, GCL_HCURSOR, 0);
  807.     SetCursor (LoadCursor (NULL, IDC_WAIT));
  809.     /* abort porting file where it is */
  810.     MySetEvent (hDlg, lpNode->hEvents[BKPORT_ABORT]);
  812.     /* remove file from list when thread is dead */
  813.     WaitForSingleObject (lpNode->bkFile.hThread, INFINITE);
  814.     RemoveFile (lpNode->bkFile.szFilePath, &lpbkFiles);
  816.     /* replace original cursor */
  817.     SetClassLong (hDlg, GCL_HCURSOR, (LONG)hOldCursor);
  818.     SetCursor (hOldCursor);
  820.     /* update listbox */
  821.     SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  822.  LB_DELETESTRING,
  823.  iCurThread,
  824.  0);
  826.     /* select new event if any in listbox */
  827.     if (SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  828.      LB_GETCOUNT,
  829.      0,
  830.      0))
  831. {
  832. SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  833.      LB_SETCURSEL,
  834.      0,
  835.      0);
  836. MySetEvent (hDlg, lpbkFiles->hEvents[BKPORT_STATUS]);
  837. iCurThread = 0;
  838. }
  840.     else
  841. {
  842. iCurThread = -1;
  843. PostMessage (hDlg, WM_COMMAND, IDC_DONE, 0);
  844. }
  846.     /* clean up controls */
  847.     SetDlgItemText (hDlg, IDC_FILEPATH, "");
  848.     PostMessage (hDlg, UM_STATUSUPDATE, 0, 0);
  849.     break;
  850.     }
  852. lpNode = lpNode->Next;
  853. i++;
  854. }
  855.     }
  856.     break;
  858. case IDC_ADDFILE:
  859.     {
  860.     /* get file from user first */
  861.     *szFileName = 0;
  862.     *szFilePath = 0;
  864.     /* add a file to the list */
  865.     if (GetFileName (hDlg, szFileName, szFilePath))
  866. {
  867. /* if new list */
  868.             if (!lpbkFiles)
  869.             {
  870.                 if (!BuildFileList (szFilePath, &lpbkFiles))
  871.                 {
  872.                     lpbkFiles = NULL;
  873.                     break;
  874.                 }
  875.             }
  876. else if (!AddFile (szFilePath, szFileName, lpbkFiles))
  877.     break;
  879. /* find node in list */
  880. lpNode = lpbkFiles;
  881. while (lpNode)
  882.     {
  883.     if (!strcmp (lpNode->bkFile.szFilePath, szFilePath))
  884. break;
  885.     lpNode = lpNode->Next;
  886.     }
  888. if (lpNode)
  889.     {
  890.     /* add filename to listbox */
  891.     SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  892.  LB_ADDSTRING,
  893.  0,
  894.  (LPARAM)lpNode->bkFile.szFile);
  896.     /* initialize some stuff */
  897.     lpNode->bkFile.hDlg = hDlg;
  898.     lpNode->bkFile.dwPTFlags = PT_DEFAULT;
  900.     /* start background thread on this file */
  901.     StartBkPortThread (&lpNode->bkFile);
  903.     /* if first thread */
  904.     if (iCurThread == -1 ||
  905. SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  906.      LB_GETCOUNT, 0, 0) == 1)
  907. {
  908. iCurThread = 0;
  909. SendMessage (GetDlgItem (hDlg, IDC_FILELIST),
  910.      LB_SETCURSEL,
  911.      0,
  912.      0);
  913. SendMessage (hDlg,
  914.      WM_COMMAND,
  915.      MAKELONG (IDC_FILELIST, LBN_SELCHANGE),
  916.      0);
  917. }
  918.     }
  919. }
  920.     }
  921.     break;
  923. case IDC_CHANGEOPTIONS:
  924.     {
  925.     DWORD    dwFlags;
  927. dwFlags = 0L;
  928.     dwFlags = (dwFlags & ~PT_IGNORECASE) ^
  929. (IsDlgButtonChecked (hDlg, IDC_BKIGNORECASE) ? PT_IGNORECASE : 0);
  930.     dwFlags = (dwFlags & ~PT_NOAPIS) ^
  931. (IsDlgButtonChecked (hDlg, IDC_BKNOAPIS) ? PT_NOAPIS : 0);
  932.     dwFlags = (dwFlags & ~PT_NOMESSAGES) ^
  933. (IsDlgButtonChecked (hDlg, IDC_BKNOMESSAGES) ? PT_NOMESSAGES : 0);
  934.     dwFlags = (dwFlags & ~PT_NOSTRUCTURES) ^
  935. (IsDlgButtonChecked (hDlg, IDC_BKNOSTRUCTURES) ? PT_NOSTRUCTURES : 0);
  936.     dwFlags = (dwFlags & ~PT_NOMACROS) ^
  937. (IsDlgButtonChecked (hDlg, IDC_BKNOMACROS) ? PT_NOMACROS : 0);
  938.     dwFlags = (dwFlags & ~PT_NOCONSTANTS) ^
  939. (IsDlgButtonChecked (hDlg, IDC_BKNOCONSTANTS) ? PT_NOCONSTANTS : 0);
  940.     dwFlags = (dwFlags & ~PT_NOTYPES) ^
  941. (IsDlgButtonChecked (hDlg, IDC_BKNOTYPES) ? PT_NOTYPES : 0);
  942.     dwFlags = (dwFlags & ~PT_NOCUSTOM) ^
  943. (IsDlgButtonChecked (hDlg, IDC_BKNOCUSTOM) ? PT_NOCUSTOM : 0);
  945.     /* change the options for the file being ported */
  946.     lpbkFiles->bkFile.dwPTFlags = dwFlags;
  947.     }
  948.     break;
  950. case IDCANCEL:
  951.     {
  952.     HCURSOR    hOldCursor;
  953.     HANDLE     hThreads[MAXBKTHREADS];
  954.     int        i = 0;
  955.                     CHAR       szText[MAX_PATH]; // for LoadString()
  956.                     CHAR       szTitle[MAX_PATH]; // for LoadString()
  957.                     HMODULE    hModule = GetModuleHandle(NULL);
  959.     /* put up confirm message */
  960.                     LoadString((HANDLE)hModule,
  961.                         IDS_CANCEL_BKGND_PROCESS,
  962.                         szText,sizeof(szText));
  963.                     LoadString((HANDLE)hModule,
  964.                         IDS_ABORT_TITLE,
  965.                         szTitle,sizeof(szTitle));
  966.     if (MessageBox (hDlg,
  967.     szText, szTitle,
  968.     MB_ICONQUESTION | MB_OKCANCEL) == IDOK)
  969. {
  970. /* put hourglass cursor up */
  971. hOldCursor = (HCURSOR)SetClassLong (hDlg, GCL_HCURSOR, 0);
  972. SetCursor (LoadCursor (NULL, IDC_WAIT));
  974. /* if any files in list */
  975. if (lpbkFiles)
  976.     {
  977.     /* abort all background threads and build thread handle array */
  978.     lpNode = lpbkFiles;
  979.     while (lpNode)
  980. {
  981. MySetEvent (hDlg, lpNode->hEvents[BKPORT_ABORT]);
  982. hThreads[i++] = lpNode->bkFile.hThread;
  983. lpNode = lpNode->Next;
  984. }
  986.     /* wait on completion of background threads */
  987.     WaitForMultipleObjects (i, hThreads, TRUE, INFINITE);
  989.     /* free background port resources */
  990.     FreeFileList (lpbkFiles);
  991.     }
  993. SetClassLong (hDlg, GCL_HCURSOR, (LONG)hOldCursor);
  994. SetCursor (hOldCursor);
  995. DestroyWindow (hDlg);
  996. hDlgPortStatus = NULL;
  998. }
  999.     }
  1000.     break;
  1002. case IDC_BKDONE:
  1003.     /* if file list post message to cancel */
  1004.     if (lpbkFiles)
  1005. PostMessage (hDlg, WM_COMMAND, IDCANCEL, 0);
  1006.     else
  1007. DestroyWindow (hDlg);
  1008. hDlgPortStatus = NULL;
  1009.     break;
  1011. default:
  1012.     bRet = FALSE;
  1013.     break;
  1014. }
  1015.     break;
  1017. case WM_DESTROY:
  1018.     /* if no parent, post quit message */
  1019.     if (GetParent (hDlg) == NULL)
  1020. PostQuitMessage (1);
  1021.     break;
  1023. default:
  1024.     bRet = FALSE;
  1025.     break;
  1026. }
  1028.     return bRet;
  1029. }
  1033. /* funtion retrieves the help filename from the ini file */
  1034. BOOL WINAPI GetHelpFileName (
  1035.     char    *lpszFile)
  1036. {
  1037.     char        szAppName[30];
  1038.     char        szWinHelp[30];
  1039.     char        szDefault[] = "Default";
  1040.     OFSTRUCT    of;
  1042.     /* get help filename from ini file */
  1043.     LoadString (GetModuleHandle (NULL), IDS_APPNAME, szAppName, 30);
  1044.     LoadString (GetModuleHandle (NULL), IDS_WINHELP, szWinHelp, 30);
  1045.     GetPrivateProfileString (szAppName,
  1046.      szWinHelp,
  1047.      szDefault,
  1048.      lpszFile,
  1049.      MAX_PATH,
  1050.  lpszPortIniFilePath);
  1052.     /* test to see if help file exists */
  1053.     return (OpenFile (lpszFile, &of, OF_EXIST) != -1);
  1054. }
  1059. /* rearrange dialog and controls */
  1060. void WINAPI GrowDialog (
  1061.     HWND    hDlg,
  1062.     BOOL    bBigger)
  1063. {
  1064.     RECT    rc;
  1065.     int     nChange = (bBigger ? DLGOFFSET : -DLGOFFSET);
  1067.     /* grow main dialog */
  1068.     GetWindowRect (hDlg, &rc);
  1069.     SetWindowPos (hDlg,
  1070.   NULL,
  1071.   rc.left,
  1072.   rc.top,
  1073.   rc.right-rc.left,
  1074.   rc.bottom-rc.top + nChange,
  1075.   SWP_NOMOVE | SWP_NOZORDER);
  1077.     /* move stop button down */
  1078.     GetWindowRect (GetDlgItem (hDlg, IDCANCEL), &rc);
  1079.     ScreenToClient (hDlg, (LPPOINT)&rc);
  1080.     ScreenToClient (hDlg, (LPPOINT)&rc.right);
  1081.     SetWindowPos (GetDlgItem (hDlg, IDCANCEL),
  1082.   NULL,
  1083.   rc.left,
  1084.   rc.top + nChange,
  1085.   rc.right-rc.left,
  1086.   rc.bottom-rc.top,
  1087.   SWP_NOSIZE | SWP_NOZORDER);
  1089.     /* move CONTINUE button down */
  1090.     GetWindowRect (GetDlgItem (hDlg, IDC_CONTINUE), &rc);
  1091.     ScreenToClient (hDlg, (LPPOINT)&rc);
  1092.     ScreenToClient (hDlg, (LPPOINT)&rc.right);
  1093.     SetWindowPos (GetDlgItem (hDlg, IDC_CONTINUE),
  1094.   NULL,
  1095.   rc.left,
  1096.   rc.top + nChange,
  1097.   rc.right-rc.left,
  1098.   rc.bottom-rc.top,
  1099.   SWP_NOSIZE | SWP_NOZORDER);
  1101.     /* move restart button down */
  1102.     GetWindowRect (GetDlgItem (hDlg, IDC_RESTART), &rc);
  1103.     ScreenToClient (hDlg, (LPPOINT)&rc);
  1104.     ScreenToClient (hDlg, (LPPOINT)&rc.right);
  1105.     SetWindowPos (GetDlgItem (hDlg, IDC_RESTART),
  1106.   NULL,
  1107.   rc.left,
  1108.   rc.top + nChange,
  1109.   rc.right-rc.left,
  1110.   rc.bottom-rc.top,
  1111.   SWP_NOSIZE | SWP_NOZORDER);
  1113.     /* move options button down */
  1114.     GetWindowRect (GetDlgItem (hDlg, IDC_OPTIONS), &rc);
  1115.     ScreenToClient (hDlg, (LPPOINT)&rc);
  1116.     ScreenToClient (hDlg, (LPPOINT)&rc.right);
  1117.     SetWindowPos (GetDlgItem (hDlg, IDC_OPTIONS),
  1118.   NULL,
  1119.   rc.left,
  1120.   rc.top + nChange,
  1121.   rc.right-rc.left,
  1122.   rc.bottom-rc.top,
  1123.   SWP_NOSIZE | SWP_NOZORDER);
  1125.     /* move help button down */
  1126.     GetWindowRect (GetDlgItem (hDlg, IDC_HELPM), &rc);
  1127.     ScreenToClient (hDlg, (LPPOINT)&rc);
  1128.     ScreenToClient (hDlg, (LPPOINT)&rc.right);
  1129.     SetWindowPos (GetDlgItem (hDlg, IDC_HELPM),
  1130.   NULL,
  1131.   rc.left,
  1132.   rc.top + nChange,
  1133.   rc.right-rc.left,
  1134.   rc.bottom-rc.top,
  1135.   SWP_NOSIZE | SWP_NOZORDER);
  1137.     /* move done button down */
  1138.     GetWindowRect (GetDlgItem (hDlg, IDC_DONE), &rc);
  1139.     ScreenToClient (hDlg, (LPPOINT)&rc);
  1140.     ScreenToClient (hDlg, (LPPOINT)&rc.right);
  1141.     SetWindowPos (GetDlgItem (hDlg, IDC_DONE),
  1142.   NULL,
  1143.   rc.left,
  1144.   rc.top + nChange,
  1145.   rc.right-rc.left,
  1146.   rc.bottom-rc.top,
  1147.   SWP_NOSIZE | SWP_NOZORDER);
  1149.     /* show suggestion edit control and label when appropriate */
  1150.     ShowWindow (GetDlgItem (hDlg, IDC_SUGGESTION), (bBigger ? SW_SHOW : SW_HIDE));
  1151.     ShowWindow (GetDlgItem (hDlg, IDC_SUGGESTLABEL), (bBigger ? SW_SHOW : SW_HIDE));
  1152. }
  1157. BOOL WINAPI BuildFileList (
  1158.     char          *lpFileList,
  1159.     LPBKFILELIST  *lpList)
  1160. {
  1161.     char        *lpFile;
  1162.     char        szFilePath[MAX_PATH];
  1163.     char        szFile[MAX_PATH];
  1164.     HFILE       hFile;
  1165.     OFSTRUCT    of;
  1166.     BOOL        bList = FALSE;
  1168.     /* create heap for up to 50 files at a time */
  1169.     if (!(hBkFileHeap = HeapCreate (HEAP_NO_SERIALIZE,
  1170.     sizeof (BKFILELIST),
  1171.     MAXBKTHREADS * sizeof (BKFILELIST))))
  1172. return FALSE;
  1174.     /* allocate first node in list */
  1175.     *lpList = (BKFILELIST *)HeapAlloc (hBkFileHeap, 0, sizeof (BKFILELIST));
  1176.     (*lpList)->hEvents[BKPORT_ABORT] = NULL;
  1178.     /* parse first file in list */
  1179.     lpFile = strtok (lpFileList, " ");
  1181.     /* loop through all files in list */
  1182.     while (lpFile)
  1183. {
  1184. strcpy (szFilePath, lpFile);
  1186. /* if no path, add current directory as path */
  1187. if (!GetFileFromPath (szFilePath, szFile))
  1188.     {
  1189.     strcpy (szFile, szFilePath);
  1190.     GetCurrentDirectory (MAX_PATH, szFilePath);
  1191.     strcat (szFilePath, "\");
  1192.     strcat (szFilePath, szFile);
  1193.     }
  1195. /* verify file is available */
  1196. hFile = OpenFile (szFilePath, &of, OF_READWRITE);
  1197. if (hFile != -1)
  1198.     {
  1199.     /* added at least one file */
  1200.     bList = TRUE;
  1202.     /* close file */
  1203.     CloseHandle ((HANDLE)hFile);
  1205.     /* add file to list */
  1206.     AddFile (szFilePath, szFile, *lpList);
  1207.     }
  1209. /* get next file in list */
  1210. lpFile = strtok (NULL, " ");
  1211. }
  1213.     /* if no valid files, cleanup */
  1214.     if (!bList)
  1215. {
  1216. HeapDestroy (hBkFileHeap);
  1217. return FALSE;
  1218. }
  1220.     return TRUE;
  1221. }
  1226. BOOL WINAPI AddFile (
  1227.     char        *lpFilePath,
  1228.     char        *lpFile,
  1229.     BKFILELIST  *lpbkFiles)
  1230. {
  1231.     BKFILELIST    *lpNode;
  1234.     /* if first item in list don't need to allocate */
  1235.     if (!lpbkFiles->hEvents[BKPORT_ABORT])
  1236. lpNode = lpbkFiles;
  1237.     else
  1238. {
  1239. lpNode = (BKFILELIST *)HeapAlloc (hBkFileHeap, 0, sizeof (BKFILELIST));
  1240. if (!lpNode)
  1241.     return FALSE;
  1243. /* find end of list then add new node */
  1244. while (lpbkFiles->Next)
  1245.     lpbkFiles = lpbkFiles->Next;
  1246. lpbkFiles->Next = lpNode;
  1247. }
  1249.     /* initialize node structure */
  1250.     strcpy (lpNode->bkFile.szFile, lpFile);
  1251.     strcpy (lpNode->bkFile.szFilePath, lpFilePath);
  1252.     CreateEvents (lpNode->hEvents, &lpNode->bkFile);
  1253.     lpNode->Next = NULL;
  1255.     return TRUE;
  1256. }
  1261. BOOL WINAPI RemoveFile (
  1262.     char          *lpFilePath,
  1263.     LPBKFILELIST  *lpbkFiles)
  1264. {
  1265.     BKFILELIST    *pHead = *lpbkFiles;
  1266.     BKFILELIST    *pTail = *lpbkFiles;
  1268.     /* loop thru list until file name matches */
  1269.     while (pHead)
  1270. {
  1271. if (!strcmp (lpFilePath, pHead->bkFile.szFilePath))
  1272.     {
  1273.     /* special case remove first node */
  1274.     if (pTail == pHead)
  1275. {
  1276. *lpbkFiles = pHead->Next;
  1277. DestroyEvents (pHead->hEvents);
  1278. HeapFree (hBkFileHeap, 0, (char *)(pHead));
  1280. /* if no more nodes, destroy heap */
  1281. if (!*lpbkFiles)
  1282.     HeapDestroy (hBkFileHeap);
  1283. }
  1285.     else
  1286. {
  1287. pTail->Next = pHead->Next;
  1288. DestroyEvents (pHead->hEvents);
  1289. HeapFree (hBkFileHeap, 0, (char *)pHead);
  1290. }
  1292.     return TRUE;
  1293.     }
  1295. pTail = pHead;
  1296. pHead = pHead->Next;
  1297. }
  1299.     return FALSE;
  1300. }
  1305. BOOL WINAPI FreeFileList (
  1306.     BKFILELIST  *lpbkFiles)
  1307. {
  1308.     /* loop thru each list item */
  1309.     while (lpbkFiles)
  1310. {
  1311. /* destroy event handles */
  1312. DestroyEvents (lpbkFiles->hEvents);
  1314. lpbkFiles = lpbkFiles->Next;
  1315. }
  1317.     /* release entire heap */
  1318.     HeapDestroy (hBkFileHeap);
  1320.     return TRUE;
  1321. }
  1324. BOOL MySetEvent (HWND hWnd, HANDLE hEvent)
  1325. {
  1326.     if (SetEvent(hEvent)) {
  1327. return TRUE;
  1328.     } else {
  1329. return PostMessage (hWnd, (UINT)hEvent, 0, 0L);
  1330.     }
  1331. }
  1333. BOOL MyResetEvent (HWND hWnd, HANDLE hEvent)
  1334. {
  1335.     MSG msg;
  1337.     if (ResetEvent(hEvent)) {
  1338. return TRUE;
  1339.     } else {
  1340. PeekMessage (&msg, hWnd, (UINT)hEvent, (UINT)hEvent, TRUE);
  1341. return TRUE;
  1342.     }
  1343. }