1350 lines
39 KiB
C++
1350 lines
39 KiB
C++
// OutPage.cpp : implementation file
|
||
//
|
||
|
||
#include "stdafx.h"
|
||
#include "pdlcnfig.h"
|
||
#include "common.h"
|
||
#include "OutPage.h"
|
||
|
||
#ifndef _tsplitpath
|
||
#if _MBCS
|
||
#define _tsplitpath _splitpath
|
||
#else
|
||
#define _tsplitpath _wsplitpath
|
||
#endif
|
||
#endif
|
||
|
||
#ifdef _DEBUG
|
||
#define new DEBUG_NEW
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[] = __FILE__;
|
||
#endif
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COutputPropPage property page
|
||
|
||
IMPLEMENT_DYNCREATE(COutputPropPage, CPropertyPage)
|
||
|
||
COutputPropPage::COutputPropPage() : CPropertyPage(COutputPropPage::IDD)
|
||
{
|
||
//{{AFX_DATA_INIT(COutputPropPage)
|
||
m_OutputFileName = _T("");
|
||
m_RenameInterval = 0;
|
||
m_BaseFileName = _T("");
|
||
m_AutoNameIndex = -1;
|
||
m_LogFileTypeIndex = -1;
|
||
m_RenameUnitsIndex = -1;
|
||
m_szLogDirectory = _T("");
|
||
m_szCmdFilename = _T("");
|
||
m_ExecuteCmd = 0;
|
||
//}}AFX_DATA_INIT
|
||
m_hKeyLogSettingsDefault = NULL;
|
||
m_hKeyLogSettings = NULL;
|
||
m_hKeyLogService = NULL;
|
||
m_bFileNameChanged = NULL;
|
||
m_bInitialized = FALSE;
|
||
}
|
||
|
||
COutputPropPage::~COutputPropPage()
|
||
{
|
||
if (m_hKeyLogSettingsDefault != NULL) RegCloseKey(m_hKeyLogSettingsDefault);
|
||
if (m_hKeyLogSettings != NULL) RegCloseKey(m_hKeyLogSettings);
|
||
if (m_hKeyLogService != NULL) RegCloseKey(m_hKeyLogService);
|
||
}
|
||
|
||
void COutputPropPage::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
CPropertyPage::DoDataExchange(pDX);
|
||
//{{AFX_DATA_MAP(COutputPropPage)
|
||
DDX_Text(pDX, IDC_OUTPUT_FILE_EDIT, m_OutputFileName);
|
||
DDV_MaxChars(pDX, m_OutputFileName, 260);
|
||
DDX_Text(pDX, IDC_RENAME_INTERVAL, m_RenameInterval);
|
||
DDV_MinMaxDWord(pDX, m_RenameInterval, 0, 99999);
|
||
DDX_Text(pDX, IDC_BASE_FILENAME_EDIT, m_BaseFileName);
|
||
DDV_MaxChars(pDX, m_BaseFileName, 260);
|
||
DDX_CBIndex(pDX, IDC_AUTO_NAME_COMBO, m_AutoNameIndex);
|
||
DDX_CBIndex(pDX, IDC_LOG_FILETYPE, m_LogFileTypeIndex);
|
||
DDX_CBIndex(pDX, IDC_RENAME_UNITS, m_RenameUnitsIndex);
|
||
DDX_Text(pDX, IDC_LOG_DIRECTORY, m_szLogDirectory);
|
||
DDV_MaxChars(pDX, m_szLogDirectory, 260);
|
||
DDX_Text(pDX, IDC_CMD_FILENAME, m_szCmdFilename);
|
||
DDV_MaxChars(pDX, m_szCmdFilename, 260);
|
||
DDX_Check(pDX, IDC_EXECUTE_CHECK, m_ExecuteCmd);
|
||
//}}AFX_DATA_MAP
|
||
}
|
||
|
||
BEGIN_MESSAGE_MAP(COutputPropPage, CPropertyPage)
|
||
//{{AFX_MSG_MAP(COutputPropPage)
|
||
ON_BN_CLICKED(IDC_AUTOMATIC_NAME, OnAutomaticName)
|
||
ON_BN_CLICKED(IDC_MANUAL_NAME, OnManualName)
|
||
ON_CBN_SELCHANGE(IDC_AUTO_NAME_COMBO, OnSelchangeAutoNameCombo)
|
||
ON_EN_CHANGE(IDC_BASE_FILENAME_EDIT, OnChangeBaseFilenameEdit)
|
||
ON_BN_CLICKED(IDC_BROWSE_OUTPUT_FILE, OnBrowseOutputFile)
|
||
ON_CBN_SELCHANGE(IDC_LOG_FILETYPE, OnSelchangeLogFiletype)
|
||
ON_CBN_SELCHANGE(IDC_RENAME_UNITS, OnSelchangeRenameUnits)
|
||
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_RENAME_INTERVAL, OnDeltaposSpinRenameInterval)
|
||
ON_EN_CHANGE(IDC_OUTPUT_FILE_EDIT, OnChangeOutputFileEdit)
|
||
ON_EN_CHANGE(IDC_RENAME_INTERVAL, OnChangeRenameInterval)
|
||
ON_EN_UPDATE(IDC_BASE_FILENAME_EDIT, OnUpdateBaseFilenameEdit)
|
||
ON_BN_CLICKED(IDC_BROWSE_FOLDER, OnBrowseFolder)
|
||
ON_BN_CLICKED(IDC_EXECUTE_CHECK, OnExecuteCheck)
|
||
ON_BN_CLICKED(IDC_BROWSE_CMD_FILE, OnBrowseCmdFile)
|
||
ON_EN_CHANGE(IDC_CMD_FILENAME, OnChangeCmdFilename)
|
||
//}}AFX_MSG_MAP
|
||
ON_MESSAGE (PSM_QUERYSIBLINGS, OnQuerySiblings)
|
||
END_MESSAGE_MAP()
|
||
|
||
void COutputPropPage::InitDialogData (void)
|
||
{
|
||
LONG lStatus = ERROR_INVALID_FUNCTION;
|
||
|
||
DWORD dwRegValType;
|
||
DWORD dwRegValue;
|
||
DWORD dwRegValueSize;
|
||
|
||
CString csTempFilePath;
|
||
|
||
TCHAR szRegString[MAX_PATH];
|
||
TCHAR szDriveName[MAX_PATH];
|
||
|
||
BOOL bAutoMode = FALSE;
|
||
|
||
if (m_bInitialized) return;
|
||
|
||
if (m_hKeyLogService == NULL) {
|
||
// open registry key to service
|
||
lStatus = RegOpenKeyEx (
|
||
HKEY_LOCAL_MACHINE,
|
||
TEXT("SYSTEM\\CurrentControlSet\\Services\\PerfDataLog"),
|
||
0,
|
||
KEY_READ | KEY_WRITE,
|
||
&m_hKeyLogService);
|
||
}
|
||
|
||
if ((m_hKeyLogSettings == NULL) &&
|
||
(m_hKeyLogService != NULL)) {
|
||
// open registry to log query info
|
||
lStatus = RegOpenKeyEx (
|
||
m_hKeyLogService,
|
||
TEXT("Log Queries"),
|
||
0,
|
||
KEY_READ | KEY_WRITE,
|
||
&m_hKeyLogSettings);
|
||
}
|
||
|
||
if ((m_hKeyLogSettingsDefault == NULL) &&
|
||
(m_hKeyLogSettings != NULL)) {
|
||
// open registry to default log query
|
||
lStatus = RegOpenKeyEx (
|
||
m_hKeyLogSettings,
|
||
TEXT("Default"),
|
||
0,
|
||
KEY_READ | KEY_WRITE,
|
||
&m_hKeyLogSettingsDefault);
|
||
}
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
return;
|
||
// display error, close dialog and exit
|
||
}
|
||
// continue
|
||
|
||
if (m_LogFileTypeIndex == -1) {
|
||
// read log file format
|
||
dwRegValType = 0;
|
||
dwRegValue = 0;
|
||
dwRegValueSize = sizeof(DWORD);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log File Type"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&dwRegValue,
|
||
&dwRegValueSize);
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// then apply default value
|
||
dwRegValue = OPD_CSV_FILE;
|
||
}
|
||
|
||
m_LogFileTypeIndex = dwRegValue;
|
||
}
|
||
|
||
if (m_RenameInterval == 0) {
|
||
// set default mode
|
||
dwRegValType = 0;
|
||
dwRegValue = 0;
|
||
dwRegValueSize = sizeof(DWORD);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Auto Name Interval"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&dwRegValue,
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// then apply default value
|
||
dwRegValue = 0; // manual naming is the default
|
||
} else if (dwRegValType != REG_DWORD) {
|
||
// then apply default value
|
||
dwRegValue = 0; // manual naming is the default
|
||
} // else assume it was OK
|
||
|
||
if (dwRegValue == 0) {
|
||
// initialize the rest of the manual name field(s)
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log Filename"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// apply default name
|
||
lstrcpy (szRegString, TEXT("perfdata."));
|
||
switch (m_LogFileTypeIndex) {
|
||
case OPD_TSV_FILE:
|
||
lstrcat (szRegString, TEXT("tsv"));
|
||
break;
|
||
|
||
case OPD_BIN_FILE:
|
||
lstrcat (szRegString, TEXT("blg"));
|
||
break;
|
||
|
||
case (OPD_CSV_FILE):
|
||
default:
|
||
lstrcat (szRegString, TEXT("csv"));
|
||
break;
|
||
}
|
||
}
|
||
// if the filename doesn't specify a directory, then use the
|
||
csTempFilePath = szRegString;
|
||
|
||
_tsplitpath ((LPCTSTR)csTempFilePath, szDriveName, szRegString,
|
||
NULL, NULL);
|
||
if ((lstrlen(szDriveName) == 0) && (lstrlen(szRegString) == 0)) {
|
||
// default log file directory
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log Default Directory"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// try to use the general default
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettings,
|
||
TEXT("Log Default Directory"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// apply the default then since we can't find it
|
||
// in the registry anywhere
|
||
lstrcpy (szRegString, TEXT("c:\\perflogs"));
|
||
}
|
||
}
|
||
// szRegString should have a valid path here
|
||
m_szLogDirectory = szRegString; // load default dir for auto section
|
||
m_OutputFileName = szRegString;
|
||
m_OutputFileName += TEXT ("\\");
|
||
} else {
|
||
m_szLogDirectory = szDriveName;
|
||
// the file parsing function leaves the trailing backslash
|
||
// so remove it before concatenating it.
|
||
if (szRegString[lstrlen(szRegString)-1] == TEXT('\\')) {
|
||
szRegString[lstrlen(szRegString)-1] = 0;
|
||
}
|
||
m_szLogDirectory += szRegString;
|
||
m_OutputFileName.Empty();
|
||
}
|
||
m_OutputFileName += csTempFilePath;
|
||
|
||
// set auto combo boxes to default values
|
||
|
||
m_BaseFileName = TEXT("perfdata");
|
||
m_AutoNameIndex = OPD_NAME_YYMMDD;
|
||
m_RenameUnitsIndex = OPD_RENAME_DAYS;
|
||
m_RenameInterval = 1;
|
||
|
||
bAutoMode = FALSE;
|
||
} else {
|
||
m_RenameInterval = dwRegValue;
|
||
// get values for controls
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log Default Directory"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// try to use the general default
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettings,
|
||
TEXT("Log Default Directory"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// apply the default then since we can't find it
|
||
// in the registry anywhere
|
||
lstrcpy (szRegString, TEXT("c:\\perflogs"));
|
||
}
|
||
}
|
||
// szRegString should have a valid path here
|
||
m_szLogDirectory = szRegString;
|
||
|
||
// base filename
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Base Filename"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// apply default name
|
||
lstrcpy (szRegString, TEXT("perfdata"));
|
||
}
|
||
m_BaseFileName = szRegString;
|
||
|
||
// get auto name format
|
||
dwRegValType = 0;
|
||
dwRegValue = 0;
|
||
dwRegValueSize = sizeof(DWORD);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log File Auto Format"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&dwRegValue,
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// then apply default value
|
||
dwRegValue = OPD_NAME_YYMMDD; // manual naming is the default
|
||
}
|
||
// set update interval information
|
||
m_AutoNameIndex = dwRegValue;
|
||
|
||
dwRegValType = 0;
|
||
dwRegValue = 0;
|
||
dwRegValueSize = sizeof(DWORD);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Auto Rename Units"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&dwRegValue,
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// then apply default value
|
||
dwRegValue = OPD_RENAME_DAYS; // manual naming is the default
|
||
}
|
||
m_RenameUnitsIndex = dwRegValue;
|
||
|
||
dwRegValType = 0;
|
||
dwRegValueSize = MAX_PATH * sizeof(TCHAR);
|
||
memset (szRegString, 0, dwRegValueSize);
|
||
lStatus = RegQueryValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Command File"),
|
||
NULL,
|
||
&dwRegValType,
|
||
(LPBYTE)&szRegString[0],
|
||
&dwRegValueSize);
|
||
|
||
if (lStatus != ERROR_SUCCESS) {
|
||
// then apply default value
|
||
m_ExecuteCmd = 0;
|
||
m_szCmdFilename = _T("");
|
||
} else {
|
||
// else use the one from the registry
|
||
m_ExecuteCmd = 1;
|
||
m_szCmdFilename = szRegString;
|
||
}
|
||
}
|
||
}
|
||
m_bInitialized = TRUE;
|
||
return;
|
||
}
|
||
|
||
afx_msg LRESULT COutputPropPage::OnQuerySiblings (WPARAM wParam, LPARAM lParam)
|
||
{
|
||
switch (wParam) {
|
||
case PDLCNFIG_PSM_QS_WILDCARD_LOG:
|
||
switch (m_LogFileTypeIndex) {
|
||
case -1:
|
||
return PDLCNFIG_WILDCARD_LOG_DONT_KNOW;
|
||
|
||
case OPD_BIN_FILE:
|
||
return PDLCNFIG_WILDCARD_LOG_YES;
|
||
|
||
case OPD_CSV_FILE:
|
||
case OPD_TSV_FILE:
|
||
default:
|
||
return PDLCNFIG_WILDCARD_LOG_NO;
|
||
|
||
}
|
||
|
||
case PDLCNFIG_PSM_QS_ARE_YOU_READY:
|
||
InitDialogData();
|
||
return 0;
|
||
|
||
|
||
default:
|
||
return 0; // to pass to the next property page
|
||
}
|
||
}
|
||
|
||
BOOL COutputPropPage::IsDirPathValid (LPCTSTR szPath,
|
||
BOOL bLastNameIsDirectory,
|
||
BOOL bCreateMissingDirs)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Creates the directory specified in szPath and any other "higher"
|
||
directories in the specified path that don't exist.
|
||
|
||
Arguments:
|
||
|
||
IN LPCTSTR szPath
|
||
directory path to create (assumed to be a DOS path, not a UNC)
|
||
|
||
IN BOOL bLastNameIsDirectory
|
||
TRUE when the last name in the path is a Directory and not a File
|
||
FALSE if the last name is a file
|
||
|
||
IN BOOL bCreateMissingDirs
|
||
TRUE will create any dirs in the path that are not found
|
||
FALSE will only test for existence and not create any
|
||
missing dirs.
|
||
|
||
|
||
Return Value:
|
||
|
||
TRUE if the directory path now exists
|
||
FALSE if error (GetLastError to find out why)
|
||
|
||
--*/
|
||
{
|
||
LPTSTR szLocalPath;
|
||
LPTSTR szEnd;
|
||
LONG lReturn = 0L;
|
||
LPSECURITY_ATTRIBUTES lpSA = NULL;
|
||
DWORD dwAttr;
|
||
TCHAR cBackslash = TEXT('\\');
|
||
|
||
szLocalPath = (LPTSTR)HeapAlloc (GetProcessHeap(),
|
||
HEAP_ZERO_MEMORY,
|
||
MAX_PATH * sizeof(TCHAR));
|
||
|
||
if (szLocalPath == NULL) {
|
||
SetLastError (ERROR_OUTOFMEMORY);
|
||
return FALSE;
|
||
} else {
|
||
// so far so good...
|
||
SetLastError (ERROR_SUCCESS); // initialize error value to SUCCESS
|
||
}
|
||
|
||
if (GetFullPathName (szPath,
|
||
MAX_PATH,
|
||
szLocalPath,
|
||
NULL) > 0) {
|
||
|
||
szEnd = &szLocalPath[3];
|
||
|
||
if (*szEnd != 0) {
|
||
// then there are sub dirs to create
|
||
while (*szEnd != 0) {
|
||
// go to next backslash
|
||
while ((*szEnd != cBackslash) && (*szEnd != 0)) szEnd++;
|
||
if (*szEnd == cBackslash) {
|
||
// terminate path here and create directory
|
||
*szEnd = 0;
|
||
if (bCreateMissingDirs) {
|
||
if (!CreateDirectory (szLocalPath, lpSA)) {
|
||
// see what the error was and "adjust" it if necessary
|
||
if (GetLastError() == ERROR_ALREADY_EXISTS) {
|
||
// this is OK
|
||
SetLastError (ERROR_SUCCESS);
|
||
} else {
|
||
lReturn = 0;
|
||
}
|
||
} else {
|
||
// directory created successfully so update count
|
||
lReturn++;
|
||
}
|
||
} else {
|
||
if ((dwAttr = GetFileAttributes(szLocalPath)) != 0xFFFFFFFF) {
|
||
// make sure it's a dir
|
||
if ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) ==
|
||
FILE_ATTRIBUTE_DIRECTORY) {
|
||
lReturn++;
|
||
} else {
|
||
// if any dirs fail, then clear the return value
|
||
lReturn = 0;
|
||
}
|
||
} else {
|
||
// if any dirs fail, then clear the return value
|
||
lReturn = 0;
|
||
}
|
||
}
|
||
// replace backslash and go to next dir
|
||
*szEnd++ = cBackslash;
|
||
}
|
||
}
|
||
// create last dir in path now if it's a dir name and not a filename
|
||
if (bLastNameIsDirectory) {
|
||
if (bCreateMissingDirs) {
|
||
if (!CreateDirectory (szLocalPath, lpSA)) {
|
||
// see what the error was and "adjust" it if necessary
|
||
if (GetLastError() == ERROR_ALREADY_EXISTS) {
|
||
// this is OK
|
||
SetLastError (ERROR_SUCCESS);
|
||
lReturn++;
|
||
} else {
|
||
lReturn = 0;
|
||
}
|
||
} else {
|
||
// directory created successfully
|
||
lReturn++;
|
||
}
|
||
} else {
|
||
if ((dwAttr = GetFileAttributes(szLocalPath)) != 0xFFFFFFFF) {
|
||
// make sure it's a dir
|
||
if ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) ==
|
||
FILE_ATTRIBUTE_DIRECTORY) {
|
||
lReturn++;
|
||
} else {
|
||
// if any dirs fail, then clear the return value
|
||
lReturn = 0;
|
||
}
|
||
} else {
|
||
// if any dirs fail, then clear the return value
|
||
lReturn = 0;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// else this is a root dir only so return success.
|
||
lReturn = 1;
|
||
}
|
||
}
|
||
if (szLocalPath != NULL) HeapFree (GetProcessHeap(), 0, szLocalPath);
|
||
return lReturn;
|
||
|
||
}
|
||
|
||
void COutputPropPage::AutoManualEnable (BOOL bAutomatic)
|
||
{
|
||
BOOL bShowCmdFile;
|
||
|
||
GetDlgItem(IDC_MANUAL_NAME_GROUP)->EnableWindow(!bAutomatic);
|
||
GetDlgItem(IDC_OUTPUT_FILE_EDIT)->EnableWindow(!bAutomatic);
|
||
GetDlgItem(IDC_BROWSE_OUTPUT_FILE)->EnableWindow(!bAutomatic);
|
||
|
||
GetDlgItem(IDC_AUTO_NAME_GROUP)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_RENAME_INTERVAL)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_SPIN_RENAME_INTERVAL)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_RENAME_UNITS)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_BROWSE_FOLDER)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_LOG_DIRECTORY)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_BASE_NAME_CAPTION)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_BASE_FILENAME_EDIT)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_AUTO_NAME_CAPTION)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_AUTO_NAME_COMBO)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_SAMPLE_NAME)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_SAMPLE_NAME_TEXT)->EnableWindow(bAutomatic);
|
||
GetDlgItem(IDC_EXECUTE_CHECK)->EnableWindow(bAutomatic);
|
||
|
||
bShowCmdFile = bAutomatic && m_ExecuteCmd;
|
||
GetDlgItem(IDC_CMD_FILENAME)->EnableWindow(bShowCmdFile);
|
||
GetDlgItem(IDC_BROWSE_CMD_FILE)->EnableWindow(bShowCmdFile);
|
||
}
|
||
|
||
void COutputPropPage::UpdateSampleFilename()
|
||
{
|
||
CString cCompositeName;
|
||
CString cBaseName;
|
||
CString cDateString;
|
||
CString cFileTypeString;
|
||
CTime cCurrentTime = CTime::GetCurrentTime();
|
||
LONG lAutoNameFormat;
|
||
LONG lFileTypeIndex;
|
||
BOOL bAutoName;
|
||
|
||
bAutoName = IsDlgButtonChecked (IDC_AUTOMATIC_NAME);
|
||
|
||
if (bAutoName) {
|
||
// only update if the automatic button is checked
|
||
// get base name text
|
||
GetDlgItemText (IDC_BASE_FILENAME_EDIT, cBaseName);
|
||
cBaseName += TEXT("_");
|
||
|
||
// get date/time/serial integer format
|
||
cCurrentTime.GetCurrentTime();
|
||
lAutoNameFormat = ((CComboBox *)GetDlgItem(IDC_AUTO_NAME_COMBO))->GetCurSel();
|
||
switch (lAutoNameFormat) {
|
||
case OPD_NAME_NNNNNN:
|
||
cDateString = TEXT("000001");
|
||
break;
|
||
|
||
case OPD_NAME_YYDDD:
|
||
cDateString = cCurrentTime.Format (TEXT("%y%j"));
|
||
break;
|
||
|
||
case OPD_NAME_YYMM:
|
||
cDateString = cCurrentTime.Format (TEXT("%y%m"));
|
||
break;
|
||
|
||
case OPD_NAME_YYMMDDHH:
|
||
cDateString = cCurrentTime.Format (TEXT("%y%m%d%H"));
|
||
break;
|
||
|
||
case OPD_NAME_MMDDHH:
|
||
cDateString = cCurrentTime.Format (TEXT("%m%d%H"));
|
||
break;
|
||
|
||
case OPD_NAME_YYMMDD:
|
||
default:
|
||
cDateString = cCurrentTime.Format (TEXT("%y%m%d"));
|
||
break;
|
||
}
|
||
|
||
cCompositeName = cBaseName;
|
||
cCompositeName += cDateString;
|
||
} else {
|
||
int nExtLoc;
|
||
int nNameLen;
|
||
// with a manual name, just update the extension
|
||
// get the current filename
|
||
if (GetDlgItemText (IDC_OUTPUT_FILE_EDIT, cBaseName) == 0) {
|
||
// no name in the edit control, so make one up to use
|
||
// as a default
|
||
cCompositeName = TEXT("c:\\perflogs");
|
||
cCompositeName += TEXT("\\perfdata");
|
||
|
||
} else {
|
||
//find last "." in string
|
||
nExtLoc = cBaseName.ReverseFind (_T('.'));
|
||
if (nExtLoc > 0) {
|
||
// don't copy the "."
|
||
cCompositeName = cBaseName.Left(nExtLoc);
|
||
}
|
||
}
|
||
}
|
||
|
||
// get file type
|
||
lFileTypeIndex = ((CComboBox *)GetDlgItem(IDC_LOG_FILETYPE))->GetCurSel();
|
||
switch (lFileTypeIndex) {
|
||
case OPD_TSV_FILE:
|
||
cFileTypeString = TEXT(".TSV");
|
||
break;
|
||
|
||
case OPD_BIN_FILE:
|
||
cFileTypeString = TEXT(".BLG");
|
||
break;
|
||
|
||
case OPD_CSV_FILE:
|
||
default:
|
||
cFileTypeString = TEXT(".CSV");
|
||
break;
|
||
}
|
||
cCompositeName += cFileTypeString;
|
||
|
||
if (bAutoName) {
|
||
SetDlgItemText (IDC_SAMPLE_NAME_TEXT, cCompositeName);
|
||
} else {
|
||
SetDlgItemText (IDC_OUTPUT_FILE_EDIT, cCompositeName);
|
||
}
|
||
}
|
||
|
||
BOOL COutputPropPage::IsWildcardLogFileType (void)
|
||
{
|
||
switch (m_LogFileTypeIndex) {
|
||
case OPD_BIN_FILE:
|
||
return TRUE;
|
||
|
||
case OPD_CSV_FILE:
|
||
case OPD_TSV_FILE:
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COutputPropPage message handlers
|
||
|
||
BOOL COutputPropPage::OnInitDialog()
|
||
{
|
||
BOOL bAutoMode;
|
||
|
||
InitDialogData();
|
||
|
||
// now init other pages
|
||
QuerySiblings (PDLCNFIG_PSM_QS_ARE_YOU_READY, 0);
|
||
|
||
if (m_RenameInterval == 0) {
|
||
// then manual naming has been selected:
|
||
CheckRadioButton (IDC_MANUAL_NAME, IDC_AUTOMATIC_NAME, IDC_MANUAL_NAME);
|
||
bAutoMode = FALSE;
|
||
} else {
|
||
CheckRadioButton (IDC_MANUAL_NAME, IDC_AUTOMATIC_NAME, IDC_AUTOMATIC_NAME);
|
||
bAutoMode = TRUE;
|
||
}
|
||
|
||
CPropertyPage::OnInitDialog();
|
||
|
||
// now finish updating the controls in the property page
|
||
UpdateSampleFilename();
|
||
|
||
// update control state to match selection
|
||
AutoManualEnable (bAutoMode);
|
||
|
||
SetModified(FALSE);
|
||
return TRUE; // return TRUE unless you set the focus to a control
|
||
// EXCEPTION: OCX Property Pages should return FALSE
|
||
}
|
||
|
||
void COutputPropPage::OnAutomaticName()
|
||
{
|
||
AutoManualEnable(TRUE);
|
||
UpdateSampleFilename();
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnManualName()
|
||
{
|
||
AutoManualEnable(FALSE);
|
||
UpdateSampleFilename();
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnSelchangeAutoNameCombo()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
UpdateSampleFilename();
|
||
m_bFileNameChanged = TRUE;
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnChangeBaseFilenameEdit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified(TRUE);
|
||
m_bFileNameChanged = TRUE;
|
||
}
|
||
|
||
void COutputPropPage::OnBrowseOutputFile()
|
||
{
|
||
OPENFILENAME ofn;
|
||
CComboBox *cFileTypeCombo;
|
||
CString csInitialDir;
|
||
LONG lLogFileType;
|
||
TCHAR szFileName[MAX_PATH];
|
||
CString csBaseFilename;
|
||
TCHAR szDrive[MAX_PATH];
|
||
TCHAR szDir[MAX_PATH];
|
||
TCHAR szExt[MAX_PATH];
|
||
LPTSTR szDefExt = NULL;
|
||
|
||
cFileTypeCombo = (CComboBox *)GetDlgItem(IDC_LOG_FILETYPE);
|
||
lLogFileType = cFileTypeCombo->GetCurSel();
|
||
if (lLogFileType == CB_ERR) lLogFileType = OPD_NUM_FILE_TYPES;
|
||
|
||
GetDlgItemText (IDC_OUTPUT_FILE_EDIT, csBaseFilename);
|
||
_tsplitpath((LPCTSTR)csBaseFilename,
|
||
szDrive, szDir, szFileName, szExt);
|
||
|
||
csInitialDir = szDrive;
|
||
csInitialDir += szDir;
|
||
|
||
lstrcat (szFileName, szExt);
|
||
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = m_hWnd;
|
||
ofn.hInstance = GetModuleHandle(NULL);
|
||
ofn.lpstrFilter = TEXT("CSV Files (*.csv)\0*.csv\0TSV Files (*.tsv)\0*.tsv\0BLG Files (*.blg)\0*.blg\0All Files (*.*)\0*.*\0");
|
||
ofn.lpstrCustomFilter = NULL;
|
||
ofn.nMaxCustFilter = 0;
|
||
ofn.nFilterIndex = lLogFileType + 1; // nFilterIndex is 1-based
|
||
ofn.lpstrFile = szFileName;
|
||
ofn.nMaxFile = MAX_PATH;
|
||
ofn.lpstrFileTitle = NULL;
|
||
ofn.nMaxFileTitle = 0;
|
||
ofn.lpstrInitialDir = (LPCTSTR)csInitialDir;
|
||
ofn.lpstrTitle = TEXT("Select Log Filename");
|
||
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
|
||
ofn.nFileOffset = 0;
|
||
ofn.nFileExtension = 0;
|
||
ofn.lpstrDefExt = NULL;
|
||
ofn.lCustData = 0;
|
||
ofn.lpfnHook = NULL;
|
||
ofn.lpTemplateName = NULL;
|
||
|
||
if (GetOpenFileName (&ofn) == IDOK) {
|
||
// Update the fields with the new information
|
||
cFileTypeCombo->SetCurSel(ofn.nFilterIndex-1);
|
||
// see if an file name extension needs to be added...
|
||
if (ofn.nFileExtension == 0) {
|
||
// then add the one that matches the current file type
|
||
switch (ofn.nFilterIndex-1) {
|
||
case OPD_CSV_FILE:
|
||
szDefExt = TEXT(".csv");
|
||
break;
|
||
|
||
case OPD_TSV_FILE:
|
||
szDefExt = TEXT(".tsv");
|
||
break;
|
||
|
||
case OPD_BIN_FILE:
|
||
szDefExt = TEXT(".blg");
|
||
break;
|
||
|
||
default:
|
||
szDefExt = NULL;
|
||
break;
|
||
}
|
||
}
|
||
if (szDefExt != NULL) {
|
||
lstrcat (szFileName, szDefExt);
|
||
}
|
||
|
||
SetDlgItemText (IDC_OUTPUT_FILE_EDIT, szFileName);
|
||
} // else ignore if they canceled out
|
||
}
|
||
|
||
void COutputPropPage::OnSelchangeLogFiletype()
|
||
{
|
||
UpdateData(TRUE);
|
||
UpdateSampleFilename();
|
||
if ((m_LogFileTypeIndex != OPD_BIN_FILE) &&
|
||
(QuerySiblings (PDLCNFIG_PSM_QS_LISTBOX_STARS, 0) ==
|
||
PDLCNFIG_LISTBOX_STARS_YES)) {
|
||
AfxMessageBox (IDS_NOT_WILDCARD_FMT, MB_OK, 0);
|
||
}
|
||
m_bFileNameChanged = TRUE;
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnSelchangeRenameUnits()
|
||
{
|
||
LONG lIndex;
|
||
LONG lNewDefault;
|
||
// Get new sample and update default extension based on rename
|
||
// interval units
|
||
lIndex = ((CComboBox *)GetDlgItem(IDC_RENAME_UNITS))->GetCurSel();
|
||
switch (lIndex) {
|
||
case OPD_RENAME_HOURS:
|
||
lNewDefault = OPD_NAME_YYMMDDHH;
|
||
break;
|
||
|
||
case OPD_RENAME_DAYS:
|
||
lNewDefault = OPD_NAME_YYMMDD;
|
||
break;
|
||
|
||
case OPD_RENAME_MONTHS:
|
||
lNewDefault = OPD_NAME_YYMM;
|
||
break;
|
||
|
||
case OPD_RENAME_KBYTES:
|
||
case OPD_RENAME_MBYTES:
|
||
default:
|
||
lNewDefault = OPD_NAME_NNNNNN;
|
||
break;
|
||
}
|
||
// update new default selection
|
||
((CComboBox *)GetDlgItem(IDC_AUTO_NAME_COMBO))->SetCurSel(lNewDefault);
|
||
|
||
UpdateSampleFilename();
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnDeltaposSpinRenameInterval(NMHDR* pNMHDR, LRESULT* pResult)
|
||
{
|
||
TCHAR szStringValue[MAX_PATH];
|
||
DWORD dwNumValue;
|
||
int nChange;
|
||
|
||
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
|
||
|
||
// get current value from edit window
|
||
GetDlgItemText (IDC_RENAME_INTERVAL, szStringValue, MAX_PATH);
|
||
|
||
// convert to integer
|
||
dwNumValue = _tcstoul (szStringValue, NULL, 10);
|
||
// delta is opposite of arrow direction
|
||
nChange = -pNMUpDown->iDelta;
|
||
|
||
// apply value from spin control
|
||
if (nChange < 0) { // 1 is the minimum
|
||
// make sure we haven't hit bottom already
|
||
if (dwNumValue > 1) {
|
||
dwNumValue += nChange;
|
||
}
|
||
} else {
|
||
dwNumValue += nChange;
|
||
}
|
||
|
||
// update edit window
|
||
_ultot (dwNumValue, szStringValue, 10);
|
||
|
||
SetDlgItemText(IDC_RENAME_INTERVAL, szStringValue);
|
||
|
||
SetModified(TRUE);
|
||
|
||
*pResult = 0;
|
||
}
|
||
|
||
void COutputPropPage::OnCancel()
|
||
{
|
||
// TODO: Add your specialized code here and/or call the base class
|
||
|
||
CPropertyPage::OnCancel();
|
||
}
|
||
|
||
void COutputPropPage::OnOK()
|
||
{
|
||
LONG lIndex;
|
||
LONG lStatus;
|
||
CString csFilename;
|
||
|
||
DWORD dwAutoNameFormat;
|
||
DWORD dwAutoChangeInterval;
|
||
BOOL bManual;
|
||
BOOL bBogus = FALSE;
|
||
|
||
bManual = IsDlgButtonChecked (IDC_MANUAL_NAME);
|
||
if (!bManual) {
|
||
dwAutoNameFormat = ((CComboBox *)GetDlgItem(IDC_AUTO_NAME_COMBO))->GetCurSel();
|
||
dwAutoChangeInterval = ((CComboBox *)GetDlgItem(IDC_RENAME_UNITS))->GetCurSel();
|
||
}
|
||
// save Log File Type
|
||
lIndex = ((CComboBox *)GetDlgItem(IDC_LOG_FILETYPE))->GetCurSel();
|
||
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log File Type"),
|
||
0L,
|
||
REG_DWORD,
|
||
(LPBYTE)&lIndex,
|
||
sizeof(lIndex));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
// is manual filename button pushed?
|
||
if (bManual) {
|
||
// YES:
|
||
csFilename.Empty();
|
||
// write output filename frome edit box
|
||
GetDlgItemText(IDC_OUTPUT_FILE_EDIT, csFilename);
|
||
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log Filename"),
|
||
0L,
|
||
REG_SZ,
|
||
(LPBYTE)(LPCTSTR)csFilename,
|
||
(csFilename.GetLength()+1)*sizeof(TCHAR));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
// write rename interval == 0
|
||
lIndex = 0;
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Auto Name Interval"),
|
||
0L,
|
||
REG_DWORD,
|
||
(LPBYTE)&lIndex,
|
||
sizeof(lIndex));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
// clear auto rename entries:
|
||
// Log File Auto Format
|
||
RegDeleteValue (m_hKeyLogSettingsDefault, TEXT("Log File Auto Format"));
|
||
// Log Auto Name Units
|
||
RegDeleteValue (m_hKeyLogSettingsDefault, TEXT("Auto Rename Units"));
|
||
// Log Base Filename
|
||
RegDeleteValue (m_hKeyLogSettingsDefault, TEXT("Base Log Filename"));
|
||
// Command File name
|
||
RegDeleteValue (m_hKeyLogSettingsDefault, TEXT("Command File"));
|
||
} else {
|
||
// auto is pressed so:
|
||
csFilename.Empty();
|
||
// save Log Default Directory
|
||
GetDlgItemText (IDC_LOG_DIRECTORY, csFilename);
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log Default Directory"),
|
||
0L,
|
||
REG_SZ,
|
||
(LPBYTE)(LPCTSTR)csFilename,
|
||
(csFilename.GetLength()+1)*sizeof(TCHAR));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
// save Log Base Filename
|
||
csFilename.Empty();
|
||
GetDlgItemText (IDC_BASE_FILENAME_EDIT, csFilename);
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Base Filename"),
|
||
0L,
|
||
REG_SZ,
|
||
(LPBYTE)(LPCTSTR)csFilename,
|
||
(csFilename.GetLength()+1)*sizeof(TCHAR));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
// save Log Auto Name Format
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log File Auto Format"),
|
||
0L,
|
||
REG_DWORD,
|
||
(LPBYTE)&dwAutoNameFormat,
|
||
sizeof(DWORD));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
if (lIndex == OPD_NAME_NNNNNN) {
|
||
if (m_bFileNameChanged) {
|
||
// reset serial number counter to 1
|
||
lIndex = 1;
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log File Serial Number"),
|
||
0L,
|
||
REG_DWORD,
|
||
(LPBYTE)&lIndex,
|
||
sizeof(DWORD));
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
}
|
||
} else {
|
||
// delete serial number entry
|
||
lStatus = RegDeleteValue (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Log File Serial Number"));
|
||
// this may fail if the key is already
|
||
// deleted. That's ok.
|
||
}
|
||
// save Log Rename Interval
|
||
csFilename.Empty();
|
||
GetDlgItemText (IDC_RENAME_INTERVAL, csFilename);
|
||
lIndex = _tcstol((LPCTSTR)csFilename, NULL, 10);
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Auto Name Interval"),
|
||
0L,
|
||
REG_DWORD,
|
||
(LPBYTE)&lIndex,
|
||
sizeof(DWORD));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
// save Log Rename Units
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Auto Rename Units"),
|
||
0L,
|
||
REG_DWORD,
|
||
(LPBYTE)&dwAutoChangeInterval,
|
||
sizeof(DWORD));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
|
||
if (m_ExecuteCmd != 0) {
|
||
csFilename.Empty();
|
||
GetDlgItemText (IDC_CMD_FILENAME, csFilename);
|
||
lStatus = RegSetValueEx (
|
||
m_hKeyLogSettingsDefault,
|
||
TEXT("Command File"),
|
||
0L,
|
||
REG_SZ,
|
||
(LPBYTE)(LPCTSTR)csFilename,
|
||
(csFilename.GetLength()+1)*sizeof(TCHAR));
|
||
|
||
ASSERT (lStatus == ERROR_SUCCESS);
|
||
} else {
|
||
// no command file to be executed
|
||
RegDeleteValue (m_hKeyLogSettingsDefault, TEXT("Command File"));
|
||
}
|
||
// clear Manual entries
|
||
// Log Filename
|
||
RegDeleteValue (m_hKeyLogSettingsDefault, TEXT("Log Filename"));
|
||
}
|
||
CancelToClose();
|
||
}
|
||
|
||
BOOL COutputPropPage::OnQueryCancel()
|
||
{
|
||
// TODO: Add your specialized code here and/or call the base class
|
||
|
||
return CPropertyPage::OnQueryCancel();
|
||
}
|
||
|
||
void COutputPropPage::OnChangeOutputFileEdit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnChangeRenameInterval()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified(TRUE);
|
||
}
|
||
|
||
void COutputPropPage::OnUpdateBaseFilenameEdit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
UpdateSampleFilename();
|
||
m_bFileNameChanged = TRUE;
|
||
}
|
||
|
||
void COutputPropPage::OnBrowseFolder()
|
||
{
|
||
OPENFILENAME ofn;
|
||
CComboBox *cFileTypeCombo;
|
||
CString csInitialDir;
|
||
LONG lLogFileType;
|
||
TCHAR szFileName[MAX_PATH];
|
||
CString csBaseFilename;
|
||
LONG lFileNameLength;
|
||
|
||
cFileTypeCombo = (CComboBox *)GetDlgItem(IDC_LOG_FILETYPE);
|
||
lLogFileType = cFileTypeCombo->GetCurSel();
|
||
if (lLogFileType == CB_ERR) lLogFileType = OPD_NUM_FILE_TYPES;
|
||
|
||
// should the default filename be the base or the synthesized one?
|
||
GetDlgItemText (IDC_BASE_FILENAME_EDIT, szFileName, MAX_PATH);
|
||
GetDlgItemText (IDC_LOG_DIRECTORY, csInitialDir);
|
||
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = m_hWnd;
|
||
ofn.hInstance = GetModuleHandle(NULL);
|
||
ofn.lpstrFilter = TEXT("CSV Files (*.csv)\0*.csv\0TSV Files (*.tsv)\0*.tsv\0BLG Files (*.blg)\0*.blg\0All Files (*.*)\0*.*\0");
|
||
ofn.lpstrCustomFilter = NULL;
|
||
ofn.nMaxCustFilter = 0;
|
||
ofn.nFilterIndex = lLogFileType + 1; // nFilterIndex is 1 based
|
||
ofn.lpstrFile = szFileName;
|
||
ofn.nMaxFile = MAX_PATH;
|
||
ofn.lpstrFileTitle = NULL;
|
||
ofn.nMaxFileTitle = 0;
|
||
ofn.lpstrInitialDir = csInitialDir;
|
||
ofn.lpstrTitle = TEXT("Select Log Folder and Base Filename");
|
||
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
|
||
ofn.nFileOffset = 0;
|
||
ofn.nFileExtension = 0;
|
||
ofn.lpstrDefExt = NULL;
|
||
ofn.lCustData = 0;
|
||
ofn.lpfnHook = NULL;
|
||
ofn.lpTemplateName = NULL;
|
||
|
||
if (GetOpenFileName (&ofn) == IDOK) {
|
||
// Update the fields with the new information
|
||
cFileTypeCombo->SetCurSel(ofn.nFilterIndex -1);
|
||
|
||
lFileNameLength = lstrlen(szFileName);
|
||
// truncate extension
|
||
if ((ofn.nFileExtension < lFileNameLength) && (ofn.nFileExtension > 0)) {
|
||
szFileName[ofn.nFileExtension-1] = 0;
|
||
}
|
||
if ((ofn.nFileOffset < lFileNameLength) && (ofn.nFileOffset >= 0)){
|
||
csBaseFilename = &szFileName[ofn.nFileOffset];
|
||
if (ofn.nFileOffset > 0) {
|
||
szFileName[ofn.nFileOffset-1] = 0;
|
||
}
|
||
SetDlgItemText (IDC_BASE_FILENAME_EDIT, csBaseFilename);
|
||
SetDlgItemText (IDC_LOG_DIRECTORY, szFileName);
|
||
}
|
||
UpdateSampleFilename();
|
||
} // else ignore if they canceled out
|
||
}
|
||
|
||
BOOL COutputPropPage::OnKillActive()
|
||
{
|
||
CString csFilename;
|
||
int nMbReturn;
|
||
|
||
DWORD dwAutoNameFormat;
|
||
DWORD dwAutoChangeInterval;
|
||
BOOL bManual;
|
||
BOOL bBogus = FALSE;
|
||
BOOL bPathHasFileName;
|
||
|
||
BOOL bReturn = TRUE; // assume all is OK
|
||
|
||
UpdateData(TRUE);
|
||
|
||
bManual = IsDlgButtonChecked (IDC_MANUAL_NAME);
|
||
if (!bManual) {
|
||
dwAutoNameFormat = ((CComboBox *)GetDlgItem(IDC_AUTO_NAME_COMBO))->GetCurSel();
|
||
dwAutoChangeInterval = ((CComboBox *)GetDlgItem(IDC_RENAME_UNITS))->GetCurSel();
|
||
// check for valid interval/name combinations
|
||
switch (dwAutoChangeInterval) {
|
||
case OPD_RENAME_HOURS:
|
||
if ((dwAutoNameFormat == OPD_NAME_YYDDD) ||
|
||
(dwAutoNameFormat == OPD_NAME_YYMM) ||
|
||
(dwAutoNameFormat == OPD_NAME_YYMMDD)) bBogus = TRUE;
|
||
break;
|
||
|
||
case OPD_RENAME_DAYS:
|
||
if (dwAutoNameFormat == OPD_NAME_YYMM) bBogus = TRUE;
|
||
break;
|
||
|
||
case OPD_RENAME_MONTHS:
|
||
break;
|
||
|
||
case OPD_RENAME_KBYTES:
|
||
case OPD_RENAME_MBYTES:
|
||
default:
|
||
if (dwAutoNameFormat != OPD_NAME_NNNNNN) bBogus = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (bBogus) {
|
||
// display warning
|
||
if (AfxMessageBox (IDS_NAME_FORMAT_NOT_COMPATIBLE,
|
||
MB_OKCANCEL, 0) == IDCANCEL) {
|
||
// the user has selected to change it so this is not valid
|
||
bReturn = FALSE;
|
||
}
|
||
}
|
||
|
||
// is manual filename button pushed?
|
||
if (bManual) {
|
||
// YES:
|
||
csFilename.Empty();
|
||
// write output filename frome edit box
|
||
csFilename = m_OutputFileName;
|
||
bPathHasFileName = TRUE;
|
||
} else {
|
||
// auto is pressed so:
|
||
csFilename.Empty();
|
||
// save Log Default Directory
|
||
csFilename = m_szLogDirectory;
|
||
bPathHasFileName = FALSE;
|
||
}
|
||
// check to see if the dir path is valid
|
||
if (!IsDirPathValid (csFilename, !bPathHasFileName, FALSE)) {
|
||
nMbReturn = AfxMessageBox (IDS_DIR_NOT_FOUND,
|
||
MB_YESNOCANCEL, 0);
|
||
if (nMbReturn == IDYES) {
|
||
// create the dir(s)
|
||
if (!IsDirPathValid (csFilename, !bPathHasFileName, TRUE)) {
|
||
// unable to create the dir, display message
|
||
nMbReturn = AfxMessageBox (IDS_DIR_NOT_MADE,
|
||
MB_OK, 0);
|
||
bReturn = FALSE;
|
||
}
|
||
} else if (nMbReturn == IDCANCEL) {
|
||
// then abort and return to the dialog
|
||
bReturn = FALSE;
|
||
}
|
||
} // else the path is OK
|
||
|
||
return bReturn;
|
||
}
|
||
|
||
void COutputPropPage::OnExecuteCheck()
|
||
{
|
||
BOOL bExecuteCmd;
|
||
m_ExecuteCmd = IsDlgButtonChecked (IDC_EXECUTE_CHECK);
|
||
|
||
bExecuteCmd = (m_ExecuteCmd != 0 ? TRUE : FALSE);
|
||
GetDlgItem(IDC_CMD_FILENAME)->EnableWindow(bExecuteCmd);
|
||
GetDlgItem(IDC_BROWSE_CMD_FILE)->EnableWindow(bExecuteCmd);
|
||
SetModified(TRUE);
|
||
|
||
}
|
||
|
||
void COutputPropPage::OnBrowseCmdFile()
|
||
{
|
||
OPENFILENAME ofn;
|
||
CComboBox *cFileTypeCombo;
|
||
CString csInitialDir;
|
||
LONG lLogFileType;
|
||
TCHAR szFileName[MAX_PATH];
|
||
CString csBaseFilename;
|
||
TCHAR szDrive[MAX_PATH];
|
||
TCHAR szDir[MAX_PATH];
|
||
TCHAR szExt[MAX_PATH];
|
||
LPTSTR szDefExt = NULL;
|
||
|
||
GetDlgItemText (IDC_CMD_FILENAME, csBaseFilename);
|
||
_tsplitpath((LPCTSTR)csBaseFilename,
|
||
szDrive, szDir, szFileName, szExt);
|
||
|
||
csInitialDir = szDrive;
|
||
csInitialDir += szDir;
|
||
|
||
lstrcat (szFileName, szExt);
|
||
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = m_hWnd;
|
||
ofn.hInstance = GetModuleHandle(NULL);
|
||
ofn.lpstrFilter = TEXT("Command Files (*.bat, *.cmd)\0*.cmd;*.bat\0Executable Files (*.exe)\0*.exe\0All Files (*.*)\0*.*\0");
|
||
ofn.lpstrCustomFilter = NULL;
|
||
ofn.nMaxCustFilter = 0;
|
||
ofn.nFilterIndex = 1; // nFilterIndex is 1-based
|
||
ofn.lpstrFile = szFileName;
|
||
ofn.nMaxFile = MAX_PATH;
|
||
ofn.lpstrFileTitle = NULL;
|
||
ofn.nMaxFileTitle = 0;
|
||
ofn.lpstrInitialDir = (LPCTSTR)csInitialDir;
|
||
ofn.lpstrTitle = TEXT("Select Command Filename");
|
||
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
|
||
ofn.nFileOffset = 0;
|
||
ofn.nFileExtension = 0;
|
||
ofn.lpstrDefExt = NULL;
|
||
ofn.lCustData = 0;
|
||
ofn.lpfnHook = NULL;
|
||
ofn.lpTemplateName = NULL;
|
||
|
||
if (GetOpenFileName (&ofn) == IDOK) {
|
||
SetDlgItemText (IDC_CMD_FILENAME, szFileName);
|
||
SetModified(TRUE);
|
||
} // else ignore if they canceled out
|
||
|
||
}
|
||
|
||
void COutputPropPage::OnChangeCmdFilename()
|
||
{
|
||
SetModified(TRUE);
|
||
}
|