DIALOGS.C
上传用户:bangxh
上传日期:2007-01-31
资源大小:42235k
文件大小:26k
源码类别:

Windows编程

开发平台:

Visual C++

  1. /****************************************************************************
  2.  *
  3.  *   dialogs.c: Code for dialog procs of CapTest Sample Program
  4.  *
  5.  *   Microsoft Video for Windows Capture Class Test Program
  6.  *
  7.  ***************************************************************************/
  8. /**************************************************************************
  9.  *
  10.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  11.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  12.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  13.  *  PURPOSE.
  14.  *
  15.  *  Copyright (C) 1992 - 1997 Microsoft Corporation.  All Rights Reserved.
  16.  *
  17.  **************************************************************************/
  18. #define INC_OLE2
  19. #include <windows.h>
  20. #include <windowsx.h>
  21. #include <commdlg.h>
  22. #include <vfw.h>
  23. #include <mmreg.h>
  24. #include <io.h>
  25. #include <fcntl.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <memory.h>
  29. #include <dos.h>
  30. #include "captest.h"
  31. static long GetFreeDiskSpace(WORD) ;
  32. static int  CountMCIDevices(WORD) ;
  33. //
  34. // AboutProc: About Dialog Box Procedure
  35. //
  36. int FAR PASCAL AboutProc(HWND hDlg, UINT Message, UINT wParam, LONG lParam)
  37. {
  38.     switch (Message) {
  39.         case WM_INITDIALOG :
  40.              return TRUE ;
  41.         case WM_COMMAND :
  42.             switch (wParam) {
  43.                 case IDOK :
  44.                     EndDialog(hDlg, TRUE) ;
  45.                     return TRUE ;
  46.                 case IDCANCEL :
  47.                     EndDialog(hDlg, FALSE) ;
  48.                     return TRUE ;
  49.             }
  50.             break ;
  51.     }
  52.     return FALSE ;
  53. }
  54. //
  55. // AudioFormatProc: Audio Format Setting Dialog Box Procedure
  56. //
  57. int FAR PASCAL AudioFormatProc(HWND hDlg, UINT Message, UINT wParam, LONG lParam)
  58. {
  59.     static int                nChannels ;
  60.     static WORD               wSample ;
  61.     static DWORD              dwFrequency ;
  62.     switch (Message) {
  63.         case WM_INITDIALOG :
  64.             nChannels = IDD_ChannelIDs + glpwfex->nChannels ;
  65.             CheckRadioButton(hDlg, IDD_ChannelMono, IDD_ChannelStereo, nChannels) ;
  66.             wSample = IDD_SampleIDs + glpwfex->wBitsPerSample / 8 ;
  67.             CheckRadioButton(hDlg, IDD_Sample8Bit, IDD_Sample16Bit, wSample) ;
  68.             dwFrequency = IDD_FreqIDs + glpwfex->nSamplesPerSec / 11025 ;
  69.             CheckRadioButton(hDlg, IDD_Freq11kHz, IDD_Freq44kHz, (WORD)dwFrequency) ;
  70.             return TRUE ;
  71.         case WM_COMMAND :
  72.             switch (wParam) {
  73.                 case IDOK :
  74.                     if (IsDlgButtonChecked(hDlg, IDD_ChannelMono))
  75.                         nChannels = 1 ;
  76.                     else
  77.                         if (IsDlgButtonChecked(hDlg, IDD_ChannelStereo))
  78.                             nChannels = 2 ;
  79.                         else {
  80.                             MessageBeep(MB_ICONEXCLAMATION) ;
  81.                             return FALSE ;
  82.                         }
  83.                     if (IsDlgButtonChecked(hDlg, IDD_Sample8Bit))
  84.                         wSample = 8 ;
  85.                     else
  86.                         if (IsDlgButtonChecked(hDlg, IDD_Sample16Bit))
  87.                             wSample = 16 ;
  88.                         else {
  89.                             MessageBeep(MB_ICONEXCLAMATION) ;
  90.                             return FALSE ;
  91.                         }
  92.                     if (IsDlgButtonChecked(hDlg, IDD_Freq11kHz))
  93.                         dwFrequency = 11025 ;
  94.                     else
  95.                         if (IsDlgButtonChecked(hDlg, IDD_Freq22kHz))
  96.                             dwFrequency = 22050 ;
  97.                         else
  98.                             if (IsDlgButtonChecked(hDlg, IDD_Freq44kHz))
  99.                                 dwFrequency = 44100 ;
  100.                             else {
  101.                                 MessageBeep(MB_ICONEXCLAMATION) ;
  102.                                 return FALSE ;
  103.                             }
  104.                     // All the entries verfied OK -- save them now
  105.                     glpwfex->nChannels = nChannels ;
  106.                     glpwfex->wBitsPerSample = wSample ;
  107.                     glpwfex->nSamplesPerSec = dwFrequency ;
  108.                     glpwfex->nBlockAlign =  glpwfex->nChannels * (glpwfex->wBitsPerSample / 8) ;
  109.                     glpwfex->nAvgBytesPerSec = (long) glpwfex->nSamplesPerSec *
  110.                                                       glpwfex->nBlockAlign ;
  111.                     glpwfex->cbSize = 0 ;
  112.                     glpwfex->wFormatTag = WAVE_FORMAT_PCM ;
  113.                     EndDialog(hDlg, TRUE) ;
  114.                     return TRUE ;
  115.                 case IDCANCEL :
  116.                     EndDialog(hDlg, FALSE) ;
  117.                     return TRUE ;
  118.             }
  119.             break ;
  120.     }
  121.     return FALSE ;
  122. }
  123. //
  124. // GetFreeDiskSpaceInKB: Function to Measure Available Disk Space
  125. //
  126. static long GetFreeDiskSpaceInKB(LPTSTR pFile)
  127. {
  128.     DWORD dwFreeClusters, dwBytesPerSector, dwSectorsPerCluster, dwClusters;
  129.     char RootName[MAX_PATH];
  130.     LPSTR ptmp;    //required arg
  131.     // need to find path for root directory on drive containing
  132.     // this file.
  133.     GetFullPathName(pFile, sizeof(RootName)/sizeof(RootName[0]), RootName, &ptmp);
  134.     // truncate this to the name of the root directory (god how tedious)
  135.     if ((RootName[0] == TEXT('\')) && (RootName[1] == TEXT('\'))) {
  136.         // path begins with  \serversharepath so skip the first
  137.         // three backslashes
  138.         ptmp = &RootName[2];
  139.         while (*ptmp && (*ptmp != TEXT('\'))) {
  140.             ptmp++;
  141.         }
  142.         if (*ptmp) {
  143.             // advance past the third backslash
  144.             ptmp++;
  145.         }
  146.     } else {
  147.         // path must be drv:path
  148.         ptmp = RootName;
  149.     }
  150.     // find next backslash and put a null after it
  151.     while (*ptmp && (*ptmp != TEXT('\'))) {
  152.         ptmp++;
  153.     }
  154.     // found a backslash ?
  155.     if (*ptmp) {
  156.         // skip it and insert null
  157.         ptmp++;
  158.         *ptmp = TEXT('');
  159.     }
  160.     if (!GetDiskFreeSpace(RootName,
  161. &dwSectorsPerCluster,
  162. &dwBytesPerSector,
  163. &dwFreeClusters,
  164. &dwClusters)) {
  165.     MessageBox(NULL, TEXT("Can't measure free disk space."), TEXT("Error"),
  166.      MB_OK | MB_ICONINFORMATION);
  167.     return (-1);
  168.     }
  169.     return(MulDiv (dwSectorsPerCluster * dwBytesPerSector,
  170.    dwFreeClusters,
  171.    1024));
  172. }
  173. //
  174. // AllocCapFileProc: Capture file Space Allocation Dialog Box Procedure
  175. //
  176. int FAR PASCAL AllocCapFileProc(HWND hDlg, UINT Message, UINT wParam, LONG lParam)
  177. {
  178.     static int      nFreeMBs = 0 ;
  179.     switch (Message) {
  180.         case WM_INITDIALOG :
  181.         {
  182.             long             lFileSize = 0 ;
  183.             long             lFreeSpaceInKB ;
  184.             TCHAR      achCapFile[_MAX_PATH] ;
  185.             HANDLE           hFile;
  186.             // Get current capture file name and measure its size
  187.             capFileGetCaptureFile(ghWndCap, achCapFile, sizeof(achCapFile) / sizeof(TCHAR)) ;
  188.             hFile = CreateFile(
  189.                             achCapFile,
  190.                             GENERIC_READ,
  191.                             0,
  192.                             NULL,
  193.                             OPEN_EXISTING,
  194.                             FILE_ATTRIBUTE_NORMAL,
  195.                             NULL);
  196.             if (hFile != INVALID_HANDLE_VALUE) {
  197.                 if ((lFileSize = GetFileSize(hFile, NULL)) == -1) {
  198.                     MessageBox(NULL, TEXT("Couldn't find size of current capture file"),
  199.                             TEXT("ERROR"),
  200.                             MB_OK | MB_ICONEXCLAMATION);
  201.                     lFileSize = 0;
  202.                 }
  203.                 CloseHandle(hFile);
  204.             }
  205.             // Get free disk space and add current capture file size to that.
  206.             // Convert the available space to MBs.
  207.             if ((lFreeSpaceInKB = GetFreeDiskSpaceInKB(achCapFile)) != -1L) {
  208.                 lFreeSpaceInKB += lFileSize / 1024 ;
  209.                 nFreeMBs = lFreeSpaceInKB / 1024 ;
  210.                 SetDlgItemInt(hDlg, IDD_SetCapFileFree, nFreeMBs, TRUE) ;
  211.             } else {
  212.                 EnableWindow(GetDlgItem(hDlg, IDD_SetCapFileFree), FALSE);
  213.             }
  214.             gwCapFileSize = (WORD) (lFileSize / ONEMEG);
  215.             SetDlgItemInt(hDlg, IDD_SetCapFileSize, gwCapFileSize, TRUE) ;
  216.             return TRUE ;
  217.         }
  218.         case WM_COMMAND :
  219.             switch (GET_WM_COMMAND_ID(wParam, lParam)) {
  220.                 case IDOK :
  221.                 {
  222.                     int         iCapFileSize ;
  223.                     iCapFileSize = (int) GetDlgItemInt(hDlg, IDD_SetCapFileSize, NULL, TRUE) ;
  224.                     if (iCapFileSize <= 0 || iCapFileSize > nFreeMBs) {
  225.                         // You are asking for more than we have !! Sorry, ...
  226.                         SetDlgItemInt(hDlg, IDD_SetCapFileSize, iCapFileSize, TRUE) ;
  227.                         SetFocus(GetDlgItem(hDlg, IDD_SetCapFileSize)) ;
  228.                         MessageBeep(MB_ICONEXCLAMATION) ;
  229.                         return FALSE ;
  230.                     }
  231.                     gwCapFileSize = iCapFileSize ;
  232.                     EndDialog(hDlg, TRUE) ;
  233.                     return TRUE ;
  234.                 }
  235.                 case IDCANCEL :
  236.                     EndDialog(hDlg, FALSE) ;
  237.                     return TRUE ;
  238.                 case IDD_SetCapFileSize:
  239.                 {
  240.                     long l;
  241.                     BOOL bchanged;
  242.                     char achBuffer[21];
  243.                     // check that entered size is a valid number
  244.                     GetDlgItemText(hDlg, IDD_SetCapFileSize, achBuffer, sizeof(achBuffer));
  245.                     l = atol(achBuffer);
  246.                     bchanged = FALSE;
  247.                     if (l < 1) {
  248.                         l = 1;
  249.                         bchanged = TRUE;
  250.                     } else if (l > nFreeMBs) {
  251.                         l = nFreeMBs;
  252.                         bchanged = TRUE;
  253.                     } else {
  254.                         // make sure there are no non-digit chars
  255.                         // atol() will ignore trailing non-digit characters
  256.                         int c = 0;
  257.                         while (achBuffer[c]) {
  258.                             if (IsCharAlpha(achBuffer[c]) ||
  259.                                 !IsCharAlphaNumeric(achBuffer[c])) {
  260.                                 // string contains non-digit chars - reset
  261.                                 l = 1;
  262.                                 bchanged = TRUE;
  263.                                 break;
  264.                             }
  265.                             c++;
  266.                         }
  267.                     }
  268.                     if (bchanged) {
  269.                         wsprintf(achBuffer, "%ld", l);
  270.                         SetDlgItemText(hDlg, IDD_SetCapFileSize, achBuffer);
  271.                     }
  272.                     break;
  273.                 }
  274.             }
  275.             break ;
  276.     }
  277.     return FALSE ;
  278. }
  279. //
  280. // MakePaletteProc: Palette Details Dialog Box Procedure
  281. //
  282. BOOL CALLBACK MakePaletteProc(HWND hDlg, UINT Message, UINT wParam, LONG lParam)
  283. {
  284.     switch (Message) {
  285.         case WM_INITDIALOG :
  286.             SetDlgItemInt(hDlg, IDD_MakePalColors, gwPalColors, FALSE) ;
  287.             SetDlgItemInt(hDlg, IDD_MakePalFrames, gwPalFrames, FALSE) ;
  288.             return TRUE ;
  289.         case WM_COMMAND :
  290.             switch (wParam) {
  291.                 case IDOK :
  292.                 {
  293.                     int         iColors ;
  294.                     int         iFrames ;
  295.                     iColors = (int) GetDlgItemInt(hDlg, IDD_MakePalColors, NULL, TRUE) ;
  296.                     if (! (iColors > 0 && iColors <= 236 || iColors == 256)) {
  297.                         // invalid number of palette colors
  298.                         SetDlgItemInt(hDlg, IDD_MakePalColors, iColors, TRUE) ;
  299.                         SetFocus(GetDlgItem(hDlg, IDD_MakePalColors)) ;
  300.                         MessageBeep(MB_ICONEXCLAMATION) ;
  301.                         return FALSE ;
  302.                     }
  303.                     iFrames = (int) GetDlgItemInt(hDlg, IDD_MakePalFrames, NULL, TRUE) ;
  304.                     if (iFrames <= 0 || iFrames > 10000) {
  305.                         // no frame or way t-o-o many frames !!!
  306.                         SetDlgItemInt(hDlg, IDD_MakePalFrames, iFrames, TRUE) ;
  307.                         SetFocus(GetDlgItem(hDlg, IDD_MakePalFrames)) ;
  308.                         MessageBeep(MB_ICONEXCLAMATION) ;
  309.                         return FALSE ;
  310.                     }
  311.                     gwPalColors = iColors ;
  312.                     gwPalFrames = iFrames ;
  313.                     EndDialog(hDlg, TRUE) ;
  314.                     return TRUE ;
  315.                 }
  316.                 case IDCANCEL :
  317.                     EndDialog(hDlg, FALSE) ;
  318.                     return TRUE ;
  319.             }
  320.             break ;
  321.     }
  322.     return FALSE ;
  323. }
  324. //
  325. // CountMCIDevices: Function to Find the Number of MCI Devices of a Type
  326. //
  327. static int CountMCIDevices(WORD wType)
  328. {
  329.     int               nTotal = 0 ;
  330.     DWORD             dwCount ;
  331.     MCI_SYSINFO_PARMS mciSIP ;
  332.     mciSIP.dwCallback = 0 ;
  333.     mciSIP.lpstrReturn = (LPTSTR)(LPVOID) &dwCount ;
  334.     mciSIP.dwRetSize = sizeof(DWORD) ;
  335.     mciSIP.wDeviceType = wType ;
  336.     // Use an MCI command to get the info
  337.     if (! mciSendCommand(0, MCI_SYSINFO, MCI_SYSINFO_QUANTITY,
  338.                          (DWORD)(LPVOID) &mciSIP))
  339.         nTotal = (int) *((LPDWORD) mciSIP.lpstrReturn) ;
  340.     return nTotal ;
  341. }
  342. //
  343. // CapSetUpProc: Capture SetUp Details Dialog Box Procedure
  344. //
  345. int FAR PASCAL CapSetUpProc(HWND hDlg, UINT Message, UINT wParam, LONG lParam)
  346. {
  347.     BOOL            fValue ;
  348.     static TCHAR     achBuffer[21] ;
  349.     switch (Message) {
  350.         case WM_INITDIALOG :
  351.         {
  352.             WORD        wValue ;
  353.             // Convert from MicroSecPerFrame to FPS -- that's easier !!
  354.             wValue = (int) (1E+6 / gCapParms.dwRequestMicroSecPerFrame + 0.5) ;
  355.             SetDlgItemInt(hDlg, IDD_FrameRateData, wValue, FALSE) ;
  356.             if (gCapParms.fAbortLeftMouse)
  357.                 wValue = IDD_AbortLeftFlag ;
  358.             else
  359.                 if (gCapParms.fAbortRightMouse)
  360.                     wValue = IDD_AbortRightFlag ;
  361.                 else
  362.                     wValue = 0 ;  // none of the mouse-buttons !!!
  363.             CheckRadioButton(hDlg, IDD_AbortLeftFlag, IDD_AbortRightFlag, wValue) ;
  364.             if (gCapParms.vKeyAbort == VK_ESCAPE)
  365.                 wValue = IDD_AbortEscFlag ;
  366.             else
  367.                 if (gCapParms.vKeyAbort == VK_SPACE)
  368.                     wValue = IDD_AbortSpaceFlag ;
  369.                 else
  370.                     if (gCapParms.vKeyAbort == VK_F8)
  371.                         wValue = IDD_AbortF8Flag ;
  372.                     else
  373.                         wValue = 0 ;  // none of the keys !!!
  374.             CheckRadioButton(hDlg, IDD_AbortEscFlag, IDD_AbortF8Flag, wValue) ;
  375.             // If time limit isn't anabled, disable the time data part
  376.             CheckDlgButton(hDlg, IDD_TimeLimitFlag, (fValue = gCapParms.fLimitEnabled)) ;
  377.             EnableWindow(GetDlgItem(hDlg, IDD_SecondsText), fValue) ;
  378.             EnableWindow(GetDlgItem(hDlg, IDD_SecondsData), fValue) ;
  379.             if (fValue)
  380.                 SetDlgItemInt(hDlg, IDD_SecondsData, gCapParms.wTimeLimit, FALSE) ;
  381.             EnableWindow(GetDlgItem(hDlg, IDD_CapAudioFlag), gCapStatus.fAudioHardware) ;
  382.             CheckDlgButton(hDlg, IDD_CapAudioFlag, gCapParms.fCaptureAudio) ;
  383.             CheckDlgButton(hDlg, IDD_UseDOSMemFlag, gCapParms.fUsingDOSMemory) ;
  384.             CheckDlgButton(hDlg, IDD_CaptureOKFlag, gCapParms.fMakeUserHitOKToCapture) ;
  385.             // Find out how many MCI devices can source video
  386.             if (CountMCIDevices(MCI_DEVTYPE_VCR) +
  387.                 CountMCIDevices(MCI_DEVTYPE_VIDEODISC) == 0)
  388.                 // if no VCRs or Videodiscs, disable the controls
  389.                 fValue = FALSE ;
  390.             else
  391.                 fValue = TRUE ;
  392.             // If no MCI device or MCI Control not enabled, disable MCI
  393.             // device name, start and stop time, step capture etc
  394.             EnableWindow(GetDlgItem(hDlg, IDD_MCIControlFlag), fValue) ;
  395.             CheckDlgButton(hDlg, IDD_MCIControlFlag,
  396.                            (fValue &= gCapParms.fMCIControl)) ;
  397.             EnableWindow(GetDlgItem(hDlg, IDD_MCIDeviceText), fValue) ;
  398.             EnableWindow(GetDlgItem(hDlg, IDD_MCIDeviceData), fValue) ;
  399.             SetDlgItemText(hDlg, IDD_MCIDeviceData, (LPTSTR)gachMCIDeviceName) ;
  400.             EnableWindow(GetDlgItem(hDlg, IDD_MCIStartText), fValue) ;
  401.             EnableWindow(GetDlgItem(hDlg, IDD_MCIStartData), fValue) ;
  402.             EnableWindow(GetDlgItem(hDlg, IDD_MCIStopText), fValue) ;
  403.             EnableWindow(GetDlgItem(hDlg, IDD_MCIStopData), fValue) ;
  404.             if (fValue) {
  405.                 wsprintf((LPTSTR)achBuffer, TEXT("%lu"), gCapParms.dwMCIStartTime) ;
  406.                 SetDlgItemText(hDlg, IDD_MCIStartData, (LPTSTR)achBuffer) ;
  407.                 wsprintf((LPTSTR)achBuffer, TEXT("%lu"), gCapParms.dwMCIStopTime) ;
  408.                 SetDlgItemText(hDlg, IDD_MCIStopData, (LPTSTR)achBuffer) ;
  409.             }
  410.             EnableWindow(GetDlgItem(hDlg, IDD_MCIStepCapFlag), fValue) ;
  411.             CheckDlgButton(hDlg, IDD_MCIStepCapFlag, gCapParms.fStepMCIDevice) ;
  412.             SetDlgItemInt(hDlg, IDD_MaxDropData, gCapParms.wPercentDropForError, FALSE) ;
  413.             SetDlgItemInt(hDlg, IDD_VideoBuffData, gCapParms.wNumVideoRequested, FALSE) ;
  414.             return TRUE ;
  415.         }
  416.         case WM_COMMAND :
  417.             switch (wParam) {
  418.                 case IDD_TimeLimitFlag :
  419.                     // If this flag changes, en/dis-able time limit data part
  420.                     fValue = IsDlgButtonChecked(hDlg, IDD_TimeLimitFlag) ;
  421.                     EnableWindow(GetDlgItem(hDlg, IDD_SecondsText), fValue) ;
  422.                     EnableWindow(GetDlgItem(hDlg, IDD_SecondsData), fValue) ;
  423.                     return TRUE ;
  424.                 case IDD_MCIControlFlag :
  425.                     // If this flag changes, en/dis-able MCI times data part
  426.                     fValue = IsDlgButtonChecked(hDlg, IDD_MCIControlFlag) ;
  427.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIDeviceText), fValue) ;
  428.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIDeviceData), fValue) ;
  429.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIStartText), fValue) ;
  430.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIStartData), fValue) ;
  431.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIStopText), fValue) ;
  432.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIStopData), fValue) ;
  433.                     EnableWindow(GetDlgItem(hDlg, IDD_MCIStepCapFlag), fValue) ;
  434.                     CheckDlgButton(hDlg, IDD_MCIStepCapFlag,
  435.                             gCapParms.fStepMCIDevice |
  436.                             IsDlgButtonChecked(hDlg, IDD_MCIStepCapFlag)) ;
  437.                     return TRUE ;
  438.                 case IDOK :
  439.                 {
  440.                     int         iFrameRate ;
  441.                     int         iTimeLimit ;
  442.                     int         iMaxDropRate ;
  443.                     int         iVideoBuffers ;
  444.                     long        lMCIStart ;
  445.                     long        lMCIStop ;
  446.                     if ((iFrameRate = (int) GetDlgItemInt(hDlg, IDD_FrameRateData, NULL,
  447.                                       TRUE)) <= 0 || iFrameRate >= 100) {
  448.                         // No frame at all or more than 100 FPS !!
  449.                         SetDlgItemInt(hDlg, IDD_FrameRateData, iFrameRate, TRUE) ;
  450.                         SetFocus(GetDlgItem(hDlg, IDD_FrameRateData)) ;
  451.                         MessageBeep(MB_ICONQUESTION) ;
  452.                         return FALSE ;
  453.                     }
  454.                     if (IsDlgButtonChecked(hDlg, IDD_TimeLimitFlag)) {
  455.                         if ((iTimeLimit = (int) GetDlgItemInt(hDlg, IDD_SecondsData, NULL,
  456.                                           TRUE)) <= 0 || iTimeLimit > 3600) {
  457.                             // No capture or more than 1 hour !!
  458.                             SetDlgItemInt(hDlg, IDD_SecondsData, iTimeLimit, TRUE) ;
  459.                             SetFocus(GetDlgItem(hDlg, IDD_SecondsData)) ;
  460.                             MessageBeep(MB_ICONQUESTION) ;
  461.                             return FALSE ;
  462.                         }
  463.                     }
  464.                     if (IsDlgButtonChecked(hDlg, IDD_MCIControlFlag)) {
  465.                         GetDlgItemText(hDlg, IDD_MCIStartData, (LPTSTR)achBuffer, 20) ;
  466. #ifdef UNICODE
  467.                         lMCIStart = wcstol(achBuffer, NULL, 10);
  468. #else
  469.                         lMCIStart = atol(achBuffer) ;
  470. #endif
  471.                         if (lMCIStart < 0 ||             // negative time !!!
  472.                             lMCIStart >= 2000000000L) {  // or too high !!!
  473.                             SetDlgItemText(hDlg, IDD_MCIStartData, achBuffer) ;
  474.                             SetFocus(GetDlgItem(hDlg, IDD_MCIStartData)) ;
  475.                             MessageBeep(MB_ICONQUESTION) ;
  476.                             return FALSE ;
  477.                         }
  478.                         GetDlgItemText(hDlg, IDD_MCIStopData, (LPTSTR)achBuffer, 20) ;
  479. #ifdef UNICODE
  480.                         lMCIStop = wcstol(achBuffer, NULL, 10);
  481. #else
  482.                         lMCIStop = atol(achBuffer) ;
  483. #endif
  484.                         if (lMCIStop < 0 ||            // negative time !!!
  485.                             lMCIStop >= 2000000000L || // or too high !!!
  486.                             lMCIStop < lMCIStart) {    // or Stop before Start !!!
  487.                             SetDlgItemText(hDlg, IDD_MCIStopData, achBuffer) ;
  488.                             SetFocus(GetDlgItem(hDlg, IDD_MCIStopData)) ;
  489.                             MessageBeep(MB_ICONQUESTION) ;
  490.                             return FALSE ;
  491.                         }
  492.                     }
  493.                     if ((iMaxDropRate = (int) GetDlgItemInt(hDlg, IDD_MaxDropData, NULL,
  494.                                             TRUE)) < 0 || iMaxDropRate >= 100) {
  495.                         // Negative drop limit or more than 100% !!
  496.                         SetDlgItemInt(hDlg, IDD_MaxDropData, iMaxDropRate, TRUE) ;
  497.                         SetFocus(GetDlgItem(hDlg, IDD_MaxDropData)) ;
  498.                         MessageBeep(0) ;
  499.                         return FALSE ;
  500.                     }
  501.                     if ((iVideoBuffers = (int) GetDlgItemInt(hDlg, IDD_VideoBuffData, NULL,
  502.                                              TRUE)) <= 0 || iVideoBuffers >= 32767) {
  503.                         // Can't capture with too many or without video buffers
  504.                         SetDlgItemInt(hDlg, IDD_VideoBuffData, iVideoBuffers, TRUE) ;
  505.                         SetFocus(GetDlgItem(hDlg, IDD_VideoBuffData)) ;
  506.                         MessageBeep(MB_ICONQUESTION) ;
  507.                         return FALSE ;
  508.                     }
  509.                     // All the Cap params are correct. So set them now...
  510.                     gCapParms.dwRequestMicroSecPerFrame = (DWORD)(1E+6 / iFrameRate + 0.5) ;
  511.                     gCapParms.fLimitEnabled = IsDlgButtonChecked(hDlg, IDD_TimeLimitFlag) ;
  512.                     gCapParms.wTimeLimit = iTimeLimit ;
  513.                     if (gCapParms.fMCIControl =
  514.                             IsDlgButtonChecked(hDlg, IDD_MCIControlFlag)) {
  515.                         gCapParms.dwMCIStartTime = lMCIStart ;
  516.                         gCapParms.dwMCIStopTime  = lMCIStop ;
  517.                         GetDlgItemText(hDlg, IDD_MCIDeviceData, (LPTSTR)achBuffer, 20) ;
  518.                         lstrcpy(gachMCIDeviceName, achBuffer) ;
  519.                         capSetMCIDeviceName(ghWndCap, gachMCIDeviceName) ;
  520.                         gCapParms.fStepMCIDevice = IsDlgButtonChecked(hDlg, IDD_MCIStepCapFlag) ;
  521.                     }
  522.                     else {
  523.                         gCapParms.dwMCIStartTime = gCapParms.dwMCIStopTime = 0 ;
  524.                         gCapParms.fStepMCIDevice = FALSE ;
  525.                     }
  526.                     gCapParms.wPercentDropForError = iMaxDropRate ;
  527.                     gCapParms.wNumVideoRequested = iVideoBuffers ;
  528.                     gCapParms.fAbortLeftMouse = IsDlgButtonChecked(hDlg, IDD_AbortLeftFlag) ;
  529.                     gCapParms.fAbortRightMouse = IsDlgButtonChecked(hDlg, IDD_AbortRightFlag) ;
  530.                     if (IsDlgButtonChecked(hDlg, IDD_AbortEscFlag))
  531.                         gCapParms.vKeyAbort = VK_ESCAPE ;
  532.                     else
  533.                         if (IsDlgButtonChecked(hDlg, IDD_AbortSpaceFlag))
  534.                             gCapParms.vKeyAbort = VK_SPACE ;
  535.                         else
  536.                             if (IsDlgButtonChecked(hDlg, IDD_AbortF8Flag))
  537.                                 gCapParms.vKeyAbort = VK_F8 ;
  538.                             else
  539.                                 gCapParms.vKeyAbort = 0 ;
  540.                     gCapParms.fCaptureAudio =
  541.                                 IsDlgButtonChecked(hDlg, IDD_CapAudioFlag) ;
  542.                     gCapParms.fUsingDOSMemory =
  543.                                 IsDlgButtonChecked(hDlg, IDD_UseDOSMemFlag) ;
  544.                     gCapParms.fMakeUserHitOKToCapture =
  545.                                 IsDlgButtonChecked(hDlg, IDD_CaptureOKFlag) ;
  546.                     EndDialog(hDlg, TRUE) ;
  547.                     return TRUE ;
  548.                 }
  549.                 case IDCANCEL :
  550.                     EndDialog(hDlg, FALSE) ;
  551.                     return TRUE ;
  552.             }
  553.             break ;
  554.     }
  555.     return FALSE ;
  556. }