home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / sdktools / winnt / perfmon / logoptns.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-13  |  16.5 KB  |  555 lines
  1.  
  2. //==========================================================================//
  3. //                                  Includes                                //
  4. //==========================================================================//
  5.  
  6.  
  7. #include "perfmon.h"       // basic defns, windows.h
  8. #include "logoptns.h"      // external declarations for this file
  9.  
  10. #include "dlgs.h"          // common dialog control IDs
  11. #include "log.h"           // for StartLog, SetLogTimer, CloseLog
  12. #include "fileutil.h"      // file utilities
  13. #include "utils.h"         // various utilities
  14. #include "playback.h"      // for PlayingBackLog
  15. #include "pmhelpid.h"      // Help IDs
  16.  
  17.  
  18.  
  19. //==========================================================================//
  20. //                                Local Data                                //
  21. //==========================================================================//
  22.  
  23.  
  24. DWORD          iIntervalMSecs ;
  25. BOOL           bNeedToRelogData ;
  26. BOOL           bNeedToStartLog ;
  27. BOOL           bNeedToSetTimer ;
  28.  
  29. extern BOOL    LocalManualRefresh ;
  30. static BOOL    bStopButtonClicked ;
  31. extern HWND    hWndLogEntries ;
  32.  
  33. // This is a counter that is init. to 0.  It is incremened by 1
  34. // when the user click the cancel button.
  35. // It is set to -1 when we sent the cancell msg internally.
  36. int            bCancelled ;
  37. TCHAR          szmsgFILEOK[] = FILEOKSTRING ;
  38. DWORD          msgFILEOK ;
  39.  
  40. //==========================================================================//
  41. //                                   Macros                                 //
  42. //==========================================================================//
  43.  
  44.  
  45. #define LogOptionsOFNStyle                      \
  46.    (OFN_ENABLETEMPLATE | OFN_HIDEREADONLY |     \
  47.     OFN_SHOWHELP | OFN_ENABLEHOOK)
  48.  
  49.  
  50.  
  51. //==========================================================================//
  52. //                              Local Functions                             //
  53. //==========================================================================//
  54.  
  55. void EnableFileControls (HDLG hDlg, BOOL bEnable)
  56.    {
  57.    DialogEnable (hDlg, stc3, bEnable) ;
  58.    DialogEnable (hDlg, lst1, bEnable) ;
  59.    DialogEnable (hDlg, stc1, bEnable) ;
  60.    DialogEnable (hDlg, lst2, bEnable) ;
  61.    DialogEnable (hDlg, stc2, bEnable) ;
  62.    DialogEnable (hDlg, cmb1, bEnable) ;
  63.    DialogEnable (hDlg, stc4, bEnable) ;
  64.    DialogEnable (hDlg, cmb2, bEnable) ;
  65.    DialogEnable (hDlg, edt1, bEnable) ;
  66.    }
  67.  
  68.  
  69. //==========================================================================//
  70. //                              Message Handlers                            //
  71. //==========================================================================//
  72.  
  73.  
  74. void static OnInitDialog (HDLG hDlg)
  75.    {
  76.    PLOG           pLog ;
  77.    int            i ;
  78.    BOOL           DisplayManualRefresh ;
  79.    pLog = LogData (hWndLog) ;
  80.  
  81.    if (msgFILEOK == 0)
  82.       {
  83.       msgFILEOK = RegisterWindowMessage(szmsgFILEOK);
  84.       }
  85.  
  86.    bCancelled = 0 ;
  87.  
  88.    switch (pLog->iStatus)
  89.       {  // switch
  90.       case iPMStatusClosed:
  91. //         DialogEnable (hDlg, IDD_LOGOPTPAUSE, FALSE) ;
  92.          break ;
  93.  
  94.       case iPMStatusPaused:
  95.          EnableFileControls (hDlg, FALSE) ;
  96.          DialogSetText (hDlg, IDD_LOGOPTSTART, IDS_STOP) ;
  97. //         DialogSetText (hDlg, IDD_LOGOPTPAUSE, IDS_RESUME) ;
  98.          break ;
  99.  
  100.       case iPMStatusCollecting:
  101.          EnableFileControls (hDlg, FALSE) ;
  102.          DialogSetText (hDlg, IDD_LOGOPTSTART, IDS_STOP) ;
  103.          break ;
  104.       }  // switch
  105.  
  106.    for (i = 0 ;
  107.         i < NumIntervals ;
  108.         i++)
  109.       CBAddInt (DialogControl (hDlg, IDD_LOGOPTINTERVAL), aiIntervals [i]) ;
  110.    DialogSetInterval (hDlg, IDD_LOGOPTINTERVAL, pLog->iIntervalMSecs) ;
  111.    iIntervalMSecs = pLog->iIntervalMSecs ;
  112.  
  113.    LocalManualRefresh = pLog->bManualRefresh ;
  114.    DisplayManualRefresh = TRUE ;
  115.  
  116.    if (PlayingBackLog ())
  117.       {
  118.       DialogSetText (hDlg, IDD_LOGOPTSTART, IDS_CREATELOGFILE) ;
  119.       DisplayManualRefresh = FALSE ;
  120.       }
  121.    
  122.    if (LBNumItems (hWndLogEntries) == 0)
  123.       {
  124.       DialogEnable (hDlg, IDD_LOGOPTSTART, FALSE) ;
  125. //      DialogEnable (hDlg, IDD_LOGOPTPAUSE, FALSE) ;
  126.       }
  127.  
  128.    if (DisplayManualRefresh)
  129.       {
  130.       if (LocalManualRefresh)
  131.          {
  132.          DialogEnable (hDlg, IDD_LOGOPTINTERVAL, FALSE) ;
  133.          DialogEnable (hDlg, IDD_LOGOPTINTERVALTEXT, FALSE) ;
  134.          }
  135.  
  136.       CheckRadioButton (hDlg,
  137.          IDD_LOGOPTIONSMANUALREFRESH,
  138.          IDD_LOGOPTIONSPERIODIC,
  139.          LocalManualRefresh ? IDD_LOGOPTIONSMANUALREFRESH : 
  140.          IDD_LOGOPTIONSPERIODIC) ;
  141.       }
  142.    else
  143.       {
  144.       DialogEnable (hDlg, IDD_LOGOPTIONSMANUALREFRESH, FALSE) ;
  145.       CheckRadioButton (hDlg,
  146.          IDD_LOGOPTIONSMANUALREFRESH,
  147.          IDD_LOGOPTIONSPERIODIC,
  148.          IDD_LOGOPTIONSPERIODIC) ;
  149.       }
  150.    
  151.  
  152.    dwCurrentDlgID = HC_PM_idDlgOptionLog ;
  153.    
  154.    WindowCenter (hDlg) ;
  155.    }  // OnInitDialog
  156.  
  157.  
  158. void OnStart (HDLG hDlg)
  159. /*
  160.    Effect:        Handle any actions necessary when the user clicks on
  161.                   the "Start/Stop" button.
  162.  
  163.    Note:          This button could be displaying start or stop, depending
  164.                   on the situation.
  165. */     
  166.    {
  167.    PLOG           pLog ;
  168.  
  169.    pLog = LogData (hDlg) ;
  170.   
  171.    bStopButtonClicked = FALSE ;
  172.    switch (pLog->iStatus)
  173.       {  // switch
  174.       case iPMStatusClosed:
  175.          if (PlayingBackLog ())
  176.             {
  177.             bNeedToRelogData = TRUE ;
  178.             }
  179.          else
  180.             {
  181.             FLOAT eTimeInterval ;
  182.  
  183.             eTimeInterval = DialogFloat (hDlg, IDD_LOGOPTINTERVAL, NULL) ;
  184.             if (eTimeInterval > MAX_INTERVALSEC ||
  185.                 eTimeInterval < MIN_INTERVALSEC)
  186.                {
  187.                DlgErrorBox (hDlg, ERR_BADTIMEINTERVAL) ;
  188.                SetFocus (DialogControl (hDlg, IDD_LOGOPTINTERVAL)) ;
  189.                EditSetTextEndPos (hDlg, IDD_LOGOPTINTERVAL) ;
  190.                return ;
  191.                break ;
  192.                }
  193.  
  194.             eTimeInterval = eTimeInterval * (FLOAT) 1000.0 + (FLOAT) 0.5 ;
  195.             pLog->iIntervalMSecs = (DWORD) eTimeInterval ;
  196.  
  197.             iIntervalMSecs = pLog->iIntervalMSecs ;
  198.             bNeedToStartLog = TRUE ;
  199.             }
  200.          break ;
  201.  
  202.       case iPMStatusCollecting:
  203.       case iPMStatusPaused:
  204.          CloseLog (hWndLog, pLog) ;
  205.          bStopButtonClicked = TRUE ;
  206.          break ;
  207.       }  // switch
  208.  
  209.  
  210.    SimulateButtonPush (hDlg, IDD_OK) ;
  211.    }
  212.  
  213.  
  214. BOOL static OnOK (HDLG hDlg)
  215. /*
  216.    Effect:        Perform any hooked actions needed when the user selects
  217.                   OK in the log options dialog. In particular, if we are
  218.                   currently logging, record the need to relog and CANCEL 
  219.                   the dialog, never letting the real dialog proc get the
  220.                   OK. Remember, this is actually a file open dialog that
  221.                   we have perverted. If we let the OK through, the common
  222.                   dialog manager will try to open it and it will inform
  223.                   the user that the file is locked. This way, we let the
  224.                   user click OK, but the dialog thinks we cancelled.
  225.  
  226.    Called By:     LogOptionsHookProc only.
  227.  
  228.    Returns:       Whether the message was handled by this function or not.
  229. */
  230.    {  // OnOK
  231.    PLOG           pLog ;
  232.  
  233.  
  234.    pLog = LogData (hWndLog) ;
  235.    if (pLog->iStatus == iPMStatusCollecting ||  
  236.        pLog->iStatus == iPMStatusPaused)
  237.       {
  238.       if (LocalManualRefresh != pLog->bManualRefresh)
  239.          {
  240.          if (!LocalManualRefresh)
  241.             {
  242.             FLOAT eTimeInterval ;
  243.  
  244.             eTimeInterval = DialogFloat (hDlg, IDD_LOGOPTINTERVAL, NULL) ;
  245.  
  246.             if (eTimeInterval > MAX_INTERVALSEC ||
  247.                 eTimeInterval < MIN_INTERVALSEC)
  248.                {
  249.                DlgErrorBox (hDlg, ERR_BADTIMEINTERVAL) ;
  250.                SetFocus (DialogControl (hDlg, IDD_LOGOPTINTERVAL)) ;
  251.                EditSetTextEndPos (hDlg, IDD_LOGOPTINTERVAL) ;
  252.                return (FALSE) ;
  253.                }
  254.  
  255.             eTimeInterval = eTimeInterval * (FLOAT) 1000.0 + (FLOAT) 0.5 ;
  256.             pLog->iIntervalMSecs = (DWORD) eTimeInterval ;
  257.             iIntervalMSecs = pLog->iIntervalMSecs ;
  258.             UpdateLogDisplay (hWndLog) ;
  259.             }
  260.          ToggleLogRefresh (hWndLog) ;
  261.          }
  262.       else
  263.          {
  264.          bNeedToSetTimer = TRUE ;
  265.          bCancelled = -1 ;
  266.          }
  267.       SimulateButtonPush (hDlg, IDD_CANCEL) ;
  268.       return TRUE ;
  269.       }
  270.    else
  271.       {
  272.       if (!LocalManualRefresh)
  273.          {
  274.          FLOAT eTimeInterval ;
  275.  
  276.          eTimeInterval = DialogFloat (hDlg, IDD_LOGOPTINTERVAL, NULL) ;
  277.  
  278.          if (eTimeInterval > MAX_INTERVALSEC ||
  279.              eTimeInterval < MIN_INTERVALSEC)
  280.             {
  281.             DlgErrorBox (hDlg, ERR_BADTIMEINTERVAL) ;
  282.             SetFocus (DialogControl (hDlg, IDD_LOGOPTINTERVAL)) ;
  283.             EditSetTextEndPos (hDlg, IDD_LOGOPTINTERVAL) ;
  284.             return (TRUE) ;
  285.             }
  286.          }
  287.       }
  288.       return FALSE ;
  289.    }  // OnOK
  290.  
  291.  
  292.          
  293. void OnPause (HDLG hDlg)
  294.    {
  295.    }
  296.  
  297.  
  298.  
  299. BOOL APIENTRY LogOptionsHookProc (HWND hDlg, 
  300.                                   UINT iMessage, 
  301.                                   WPARAM wParam, 
  302.                                   LPARAM lParam)
  303.    {
  304.    BOOL           bHandled ;
  305.  
  306.    bHandled = TRUE ;
  307.  
  308.    if (iMessage == msgFILEOK)
  309.       {
  310.       bHandled = OnOK (hDlg) ;
  311.       return (bHandled) ;
  312.       }
  313.  
  314.    switch (iMessage)
  315.       {
  316.       case WM_INITDIALOG:
  317.          OnInitDialog (hDlg) ;
  318.          break ;
  319.  
  320.       case WM_DESTROY:
  321.  
  322.          {
  323.          FLOAT eTimeInterval ;
  324.  
  325.          if (!bCancelled)
  326.             {
  327.             eTimeInterval = DialogFloat (hDlg, IDD_LOGOPTINTERVAL, NULL) ;
  328.             if (eTimeInterval > MAX_INTERVALSEC ||
  329.                 eTimeInterval < MIN_INTERVALSEC)
  330.                {
  331.                DlgErrorBox (hDlg, ERR_BADTIMEINTERVAL) ;
  332.                }
  333.             else
  334.                {
  335.                eTimeInterval = eTimeInterval * (FLOAT) 1000.0 + (FLOAT) 0.5 ;
  336.                iIntervalMSecs = (DWORD) eTimeInterval ;
  337.                }
  338.             }
  339.  
  340.          dwCurrentDlgID = 0 ;
  341.          bHandled = FALSE ;
  342.          }
  343.          break ;
  344.  
  345.       case WM_COMMAND:
  346.          switch (wParam)
  347.             {  // switch
  348.             case IDD_LOGOPTSTART:
  349.                OnStart (hDlg) ;
  350.                break ;
  351.  
  352.             case IDD_LOGOPTPAUSE:
  353.                OnPause (hDlg) ;
  354.                break ;
  355.  
  356.             case IDD_OK:
  357.                bHandled = OnOK (hDlg) ;
  358.                break ;
  359.  
  360.             case IDD_CANCEL:
  361.                bCancelled += 1 ;
  362.                bHandled = FALSE ;
  363.                break ;
  364.  
  365.             case IDD_LOGOPTIONSPERIODIC:
  366.                if (PlayingBackLog())
  367.                   {
  368.                   break ;
  369.                   }
  370.                // else fall thru to the following case...
  371.             case IDD_LOGOPTIONSMANUALREFRESH:
  372.                // check if the Manual refresh is currently checked.
  373.                // Then toggle the ManualRefresh button
  374.                LocalManualRefresh =
  375.                   (wParam == IDD_LOGOPTIONSMANUALREFRESH) ;
  376.  
  377.                CheckRadioButton (hDlg,
  378.                   IDD_LOGOPTIONSMANUALREFRESH,
  379.                   IDD_LOGOPTIONSPERIODIC,
  380.                   LocalManualRefresh ? IDD_LOGOPTIONSMANUALREFRESH :
  381.                   IDD_LOGOPTIONSPERIODIC) ;
  382.  
  383.                DialogEnable (hDlg, IDD_LOGOPTINTERVAL, !LocalManualRefresh) ;
  384.                DialogEnable (hDlg, IDD_LOGOPTINTERVALTEXT, !LocalManualRefresh) ;
  385.                break ;
  386.  
  387.             case ID_HELP:
  388.                CallWinHelp (dwCurrentDlgID) ;
  389.                break ;
  390.  
  391.             default:
  392.                bHandled = FALSE ;
  393.                break ;
  394.             }  // switch
  395.          break;
  396.  
  397.       default:
  398.          bHandled = FALSE ;
  399.          break;            
  400.       }  // switch
  401.  
  402.    return (bHandled) ;
  403.    }  // LogOptionsHookProc
  404.  
  405.  
  406. BOOL DisplayLogOptions (HWND hWndParent,
  407.                         HWND hWndLog)
  408.  
  409.    {  // DisplayLogOptions
  410.    TCHAR          szFilePath [FilePathLen + 1] ;
  411.    TCHAR          szFileTitle [FilePathLen + 1] ;
  412.    TCHAR          szFileDirectory [FilePathLen + 1] ;
  413.    TCHAR          szCaption [WindowCaptionLen + 1] ;
  414.    OPENFILENAME   ofn ;
  415.    PLOG           pLog ;
  416.    int            RetCode ;
  417.    int            PrevLogSize ;
  418.    BOOL           bSameFile ;
  419.  
  420.    TCHAR szFilter[LongTextLen] ;
  421.    int   StringLength ;
  422.  
  423.    StringLoad (IDS_SAVELOGFILE, szFilter) ;
  424.    StringLength = lstrlen (szFilter) + 1 ;
  425.    LoadString (hInstance, IDS_SAVELOGFILEEXT,
  426.       &szFilter[StringLength], sizeof(szFilter)-StringLength) ;
  427.    StringLength += lstrlen (&szFilter[StringLength]) ;
  428.    szFilter[StringLength+1] = szFilter[StringLength+2] = TEXT('\0') ;
  429.  
  430.    // This dialog is used to change attributes for an existing log file,
  431.    // and to select the name of a log file to open. Therefore we have 
  432.    // different options in these cases.
  433.  
  434.    pLog = LogData (hWndLog) ;
  435.    if (!strempty (pLog->szFilePath))
  436.       {
  437.       FileNameExtension (pLog->szFilePath, szFileTitle) ;
  438.       FileDriveDirectory (pLog->szFilePath, szFileDirectory) ;
  439.       lstrcpy (szFilePath, szFileTitle) ;
  440.       }
  441.    else
  442.       {
  443.       szFileTitle[0] = szFileDirectory[0] = TEXT('\0') ;
  444.       StringLoad (IDS_SAVELOGFILEEXT, szFilePath) ;
  445.       }
  446.  
  447.    StringLoad (IDS_LOGOPTIONS, szCaption) ;
  448.  
  449.    ofn.lStructSize = sizeof(OPENFILENAME) ; 
  450.    ofn.hwndOwner = hWndParent ;
  451.    ofn.hInstance = hInstance ;
  452.    ofn.lpstrFilter = szFilter;
  453.    ofn.lpstrCustomFilter = (LPTSTR) NULL;
  454.    ofn.nMaxCustFilter = 0L;
  455.    ofn.nFilterIndex = 1L;
  456.    ofn.lpstrFile = szFilePath ;
  457.    ofn.nMaxFile = FilePathLen ;
  458.    ofn.lpstrFileTitle = szFileTitle ;
  459.    ofn.nMaxFileTitle = FilePathLen ;
  460.    ofn.lpstrInitialDir = szFileDirectory ;
  461.    ofn.lpstrTitle = (LPTSTR) szCaption ;
  462.    ofn.Flags = LogOptionsOFNStyle  ;
  463.    ofn.nFileOffset = 0;
  464.    ofn.nFileExtension = 0;
  465.    ofn.lpstrDefExt = (LPTSTR) NULL;
  466.    ofn.lpfnHook = (LPOFNHOOKPROC) LogOptionsHookProc ;
  467.    ofn.lpTemplateName = idDlgLogOptions ;
  468.  
  469.    bNeedToRelogData = FALSE;
  470.    bNeedToStartLog = FALSE ;
  471.    bNeedToSetTimer = FALSE ;
  472.    bStopButtonClicked = FALSE ;
  473.  
  474.    if (GetSaveFileName(&ofn) && !bStopButtonClicked)
  475.       {
  476.       pLog = LogData (hWndLog) ;
  477.  
  478.       // save previous log file name & size
  479.       // so we can reset if error 
  480.       PrevLogSize = pLog->lFileSize ;
  481.       
  482.       lstrcpy (szFileTitle, pLog->szFilePath) ;
  483.  
  484.       bSameFile = pstrsamei (pLog->szFilePath, ofn.lpstrFile) ;
  485.  
  486.       if (!bSameFile)
  487.          {
  488.          lstrcpy (pLog->szFilePath, ofn.lpstrFile) ;
  489.          }
  490.  
  491.       pLog->iIntervalMSecs = iIntervalMSecs ;
  492.       
  493.       if (bNeedToStartLog)
  494.          {
  495.          pLog->bManualRefresh = LocalManualRefresh ;
  496.          StartLog (hWndLog, pLog, bSameFile) ;
  497.          }
  498.       else if (bNeedToRelogData)
  499.          {
  500.          bNeedToRelogData = FALSE ;
  501.          SetHourglassCursor() ;
  502.          ReLog (hWndLog, bSameFile) ;
  503.          SetArrowCursor() ;
  504.          }
  505.       else if (LocalManualRefresh != pLog->bManualRefresh)
  506.          {
  507.          ToggleLogRefresh (hWndLog) ;
  508.          }
  509.  
  510.       if (!pLog->hFile)
  511.          {
  512.          if (bNeedToStartLog)
  513.             {
  514.             // if we get here, that means StartLog has detected
  515.             // problem, just restore the old stuff..
  516.             pLog->lFileSize = PrevLogSize ;
  517.             lstrcpy (pLog->szFilePath, szFileTitle) ;
  518.             }
  519.          // verify if this is a good log file and setup the file size
  520.          else if ((RetCode = CreateLogFile (pLog, FALSE, bSameFile)) != 0)
  521.             {
  522.             DlgErrorBox (hWndLog, RetCode, pLog->szFilePath);
  523.             pLog->lFileSize = PrevLogSize ;
  524.             lstrcpy (pLog->szFilePath, szFileTitle) ;
  525.             }
  526.          else
  527.             {
  528.             // unfortunately, we have to close this file.
  529.             // Otherwise, when we do StartLog, the common dialog
  530.             // will complain that this file is already in-used.
  531.             CloseHandle (pLog->hFile) ;
  532.             }
  533.          pLog->hFile = 0 ;
  534.          }
  535.  
  536. //      UpdateLogDisplay (hWndLog) ;
  537.       }
  538.  
  539.  
  540.    // Remember, we faked out GetSaveFileName to return FALSE. See OnOK doc.
  541.    if (bNeedToSetTimer)
  542.       {
  543.       SetLogTimer (hWndLog, iIntervalMSecs) ;
  544. //      UpdateLogDisplay (hWndLog) ;
  545.       }
  546.  
  547.    UpdateLogDisplay (hWndLog) ;
  548.  
  549.    return (TRUE) ;
  550.    }  // DisplayLogOptions
  551.  
  552.  
  553.  
  554. 
  555.