475 lines
27 KiB
C++
475 lines
27 KiB
C++
// ==========================================================================
|
||
// Class Implementation : COXTimeEdit, COXAngleEdit,
|
||
// COXLengthEdit, COXTempEdit
|
||
// ==========================================================================
|
||
|
||
// Source file : OXPhysicalEdit.cpp
|
||
|
||
// Version: 9.3
|
||
|
||
// This software along with its related components, documentation and files ("The Libraries")
|
||
// is ?1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
|
||
// governed by a software license agreement ("Agreement"). Copies of the Agreement are
|
||
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
|
||
// to obtain this file, or directly from our office. For a copy of the license governing
|
||
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
|
||
|
||
// //////////////////////////////////////////////////////////////////////////
|
||
|
||
#include "StdAfx.h" // standard MFC include
|
||
#include "OXPhysicalEditEx.h"
|
||
#include "OXMainRes.h" // resource ID's
|
||
|
||
#ifdef _DEBUG
|
||
#define new DEBUG_NEW
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[] = __FILE__;
|
||
#endif
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXLengthEdit static variables
|
||
|
||
LPCTSTR COXLengthEdit::m_rgpszLengthUnitNames[] =
|
||
{
|
||
_T("km"), // OX_LENGTH_KILOMETER
|
||
_T("m"), // OX_LENGTH_METER
|
||
_T("dm"), // OX_LENGTH_DECIMETER
|
||
_T("cm"), // OX_LENGTH_CENTIMETER
|
||
_T("mm"), // OX_LENGTH_MILLIMETER
|
||
_T("祄"), // OX_LENGTH_MICROMETER
|
||
_T("nm"), // OX_LENGTH_NANOMETER
|
||
_T("A"), // OX_LENGTH_ANGSTROM
|
||
_T("\""), // OX_LENGTH_INCH
|
||
_T("pt"), // OX_LENGTH_POINT
|
||
};
|
||
|
||
COXConversionParams COXLengthEdit::m_rgnLengthConversionParams[] =
|
||
{
|
||
{0, 1e3, 0}, // OX_LENGTH_KILOMETER (1 km = 1e3 m)
|
||
{0, 1, 0}, // OX_LENGTH_METER (1 m = 1 m)
|
||
{0, 1e-1, 0}, // OX_LENGTH_DECIMETER (1 dm = 1e-1 m)
|
||
{0, 1e-2, 0}, // OX_LENGTH_CENTIMETER (1 cm = 1e-2 m)
|
||
{0, 1e-3, 0}, // OX_LENGTH_MILLIMETER (1 mm = 1e-3 m)
|
||
{0, 1e-6, 0}, // OX_LENGTH_MICROMETER (1 祄 = 1e-6 m)
|
||
{0, 1e-9, 0}, // OX_LENGTH_NANOMETER (1 nm = 1e-9 m)
|
||
{0, 1e-10, 0}, // OX_LENGTH_ANGSTROM (1 ? = 1e-10 m)
|
||
{0, 2.54e-2, 0}, // OX_LENGTH_INCH (1 " = 2.54 * 1e-2 m)
|
||
{0, 3.527777777778e-4, 0}, // OX_LENGTH_POINT (1 pt = 2.54 / 72 * 1e-2 m)
|
||
};
|
||
|
||
COXConversionData COXLengthEdit::m_lengthConversionData =
|
||
{
|
||
OX_LENGTH_LAST + 1, // m_nNumberOfUnits
|
||
OX_LENGTH_METER, // m_nDefaultUnitIndex
|
||
m_rgpszLengthUnitNames, // m_ppszUnitNames
|
||
m_rgnLengthConversionParams, // m_pConversionParams
|
||
MAKEINTRESOURCE(IDS_OX_BAD_LENGTH_UNIT) // m_pszErrorMsg;
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXLengthEdit
|
||
|
||
IMPLEMENT_DYNCREATE(COXLengthEdit, COXPhysicalEdit)
|
||
|
||
BEGIN_MESSAGE_MAP(COXLengthEdit, COXPhysicalEdit)
|
||
//{{AFX_MSG_MAP(COXLengthEdit)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
COXLengthEdit::COXLengthEdit(int nDefaultUnitIndex/*=OX_LENGTH_METER*/) :
|
||
COXPhysicalEdit(&m_lengthConversionData,nDefaultUnitIndex)
|
||
{
|
||
}
|
||
|
||
void COXLengthEdit::SetLength(double dValue, int nUnit/*=-1*/,
|
||
LPCTSTR pszFormat/*=NULL*/)
|
||
{
|
||
COXPhysicalEdit::SetValue(dValue,nUnit,pszFormat);
|
||
}
|
||
|
||
double COXLengthEdit::GetLength(int nUnit/*=-1*/, BOOL bNotify/*=TRUE*/)
|
||
{
|
||
return COXPhysicalEdit::GetValue(nUnit,bNotify);
|
||
}
|
||
|
||
double COXLengthEdit::ConversionHelper(double dValue, int nUnitFrom, int nUnitTo)
|
||
{
|
||
return COXPhysicalEdit::ConversionHelper(
|
||
dValue,nUnitFrom,nUnitTo,m_lengthConversionData.m_pConversionParams);
|
||
}
|
||
|
||
BOOL COXLengthEdit::SetInputData(LPCTSTR pszInputData, int /*nBeginPos=0*/)
|
||
{
|
||
if (pszInputData == NULL || ::_tcslen(pszInputData) == 0)
|
||
return TRUE;
|
||
|
||
// Interpret the input data
|
||
double dLength;
|
||
TCHAR szUnitName[255];
|
||
CString strInputData = pszInputData;
|
||
strInputData.Remove(',');
|
||
#if _MSC_VER >= 1400
|
||
::_stscanf_s(strInputData, _T("%lf %s"), &dLength, szUnitName, 255);
|
||
#else
|
||
::_stscanf(strInputData, _T("%lf %s"), &dLength, szUnitName);
|
||
#endif
|
||
CString strUnitName(szUnitName);
|
||
|
||
// Resolve the unit name
|
||
int iUnit = 0;
|
||
for (int i = 0; i < m_lengthConversionData.m_nNumberOfUnits; i++)
|
||
if (m_rgpszLengthUnitNames[i] == strUnitName)
|
||
{
|
||
iUnit = i;
|
||
break;
|
||
}
|
||
|
||
SetLength(dLength, iUnit);
|
||
return TRUE;
|
||
}
|
||
|
||
COXLengthEdit::~COXLengthEdit()
|
||
{
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXTempEdit static variables
|
||
|
||
LPCTSTR COXTempEdit::m_rgpszTempUnitNames[] =
|
||
{
|
||
_T("K"), // OX_TEMP_KELVIN
|
||
_T("癈"), // OX_TEMP_CELSIUS
|
||
_T("癋"), // OX_TEMP_FAHRENHEIT
|
||
};
|
||
|
||
COXConversionParams COXTempEdit::m_rgnTempConversionParams[] =
|
||
{
|
||
{0, 1, -273.15}, // OX_TEMP_KELVIN (K - 273.15 = 癈)
|
||
{0, 1, 0}, // OX_TEMP_CELSIUS (癈 = 癈)
|
||
{-32, 0.5555555555556, 0}, // OX_TEMP_FAHRENHEIT ((癋 - 32) * 5/9 = 癈)
|
||
};
|
||
|
||
COXConversionData COXTempEdit::m_tempConversionData =
|
||
{
|
||
OX_TEMP_LAST + 1, // m_nNumberOfUnits
|
||
OX_TEMP_CELSIUS, // m_nDefaultUnitIndex
|
||
m_rgpszTempUnitNames, // m_ppszUnitNames
|
||
m_rgnTempConversionParams, // m_pConversionParams
|
||
MAKEINTRESOURCE(IDS_OX_BAD_TEMP_UNIT) // m_pszErrorMsg;
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXTempEdit
|
||
|
||
IMPLEMENT_DYNCREATE(COXTempEdit, COXPhysicalEdit)
|
||
|
||
BEGIN_MESSAGE_MAP(COXTempEdit, COXPhysicalEdit)
|
||
//{{AFX_MSG_MAP(COXTempEdit)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
COXTempEdit::COXTempEdit(int nDefaultUnitIndex/*=OX_TEMP_CELSIUS*/) :
|
||
COXPhysicalEdit(&m_tempConversionData, nDefaultUnitIndex)
|
||
{
|
||
}
|
||
|
||
void COXTempEdit::SetTemp(double dValue, int nUnit/*=-1*/,
|
||
LPCTSTR pszFormat/*=NULL*/)
|
||
{
|
||
COXPhysicalEdit::SetValue(dValue,nUnit,pszFormat);
|
||
}
|
||
|
||
double COXTempEdit::GetTemp(int nUnit/*=-1*/, BOOL bNotify/*=TRUE*/)
|
||
{
|
||
return COXPhysicalEdit::GetValue(nUnit,bNotify);
|
||
}
|
||
|
||
double COXTempEdit::ConversionHelper(double dValue, int nUnitFrom, int nUnitTo)
|
||
{
|
||
return COXPhysicalEdit::ConversionHelper(
|
||
dValue,nUnitFrom,nUnitTo,m_tempConversionData.m_pConversionParams);
|
||
}
|
||
|
||
BOOL COXTempEdit::SetInputData(LPCTSTR pszInputData, int /*nBeginPos=0*/)
|
||
{
|
||
if (pszInputData == NULL || ::_tcslen(pszInputData) == 0)
|
||
return TRUE;
|
||
|
||
// Interpret the input data
|
||
double dTemperature;
|
||
TCHAR szUnitName[255];
|
||
CString strInputData = pszInputData;
|
||
strInputData.Remove(',');
|
||
#if _MSC_VER >= 1400
|
||
::_stscanf_s(strInputData, _T("%lf %s"), &dTemperature, szUnitName, 255);
|
||
#else
|
||
::_stscanf(strInputData, _T("%lf %s"), &dTemperature, szUnitName);
|
||
#endif
|
||
CString strUnitName(szUnitName);
|
||
|
||
// Resolve the unit name
|
||
int iUnit = 0;
|
||
for (int i = 0; i < m_tempConversionData.m_nNumberOfUnits; i++)
|
||
if (m_rgpszTempUnitNames[i] == strUnitName)
|
||
{
|
||
iUnit = i;
|
||
break;
|
||
}
|
||
|
||
SetTemp(dTemperature, iUnit);
|
||
return TRUE;
|
||
}
|
||
|
||
COXTempEdit::~COXTempEdit()
|
||
{
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXTimeEdit static variables
|
||
|
||
LPCTSTR COXTimeEdit::m_rgpszTimeUnitNames[] =
|
||
{
|
||
_T("s"),
|
||
_T("min"),
|
||
_T("h"),
|
||
_T("d"),
|
||
_T("ms"),
|
||
_T("祍"),
|
||
_T("ns"),
|
||
_T("sec"),
|
||
};
|
||
|
||
COXConversionParams COXTimeEdit::m_rgnTimeConversionParams[] =
|
||
{
|
||
{0, 1, 0}, // OX_TIME_SECOND (1 s = 1 s)
|
||
{0, 60, 0}, // OX_TIME_MINUTE (1 min = 60 s)
|
||
{0, 3600, 0}, // OX_TIME_HOUR (1 d = 60 * 60 s)
|
||
{0, 86400, 0}, // OX_TIME_DAY (1 d = 24 * 60 * 60 s)
|
||
{0, 1e-3, 0}, // OX_TIME_MILLISECOND (1 ms = 1e-3 s)
|
||
{0, 1e-6, 0}, // OX_TIME_MICROSECOND (1 祍 = 1e-6 s)
|
||
{0, 1e-9, 0}, // OX_TIME_NANOSECOND (1 ns = 1e-9 s)
|
||
{0, 1, 0}, // OX_TIME_SECOND_2 (1 sec = 1 s)
|
||
};
|
||
|
||
COXConversionData COXTimeEdit::m_timeConversionData =
|
||
{
|
||
OX_TIME_LAST + 1, // m_nNumberOfUnits
|
||
OX_TIME_SECOND, // m_nDefaultUnitIndex
|
||
m_rgpszTimeUnitNames, // m_ppszUnitNames
|
||
m_rgnTimeConversionParams, // m_pConversionParams
|
||
MAKEINTRESOURCE(IDS_OX_BAD_TIME_UNIT) // m_pszErrorMsg;
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXTempEdit
|
||
|
||
IMPLEMENT_DYNCREATE(COXTimeEdit, COXPhysicalEdit)
|
||
|
||
BEGIN_MESSAGE_MAP(COXTimeEdit, COXPhysicalEdit)
|
||
//{{AFX_MSG_MAP(COXTimeEdit)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
COXTimeEdit::COXTimeEdit(int nDefaultUnitIndex/*=OX_TIME_SECOND*/) :
|
||
COXPhysicalEdit(&m_timeConversionData, nDefaultUnitIndex)
|
||
{
|
||
}
|
||
|
||
void COXTimeEdit::SetDuration(double dValue, int nUnit/*=-1*/, LPCTSTR pszFormat/*=NULL*/)
|
||
{
|
||
COXPhysicalEdit::SetValue(dValue,nUnit,pszFormat);
|
||
}
|
||
|
||
double COXTimeEdit::GetDuration(int nUnit/*=-1*/, BOOL bNotify/*=TRUE*/)
|
||
{
|
||
return COXPhysicalEdit::GetValue(nUnit,bNotify);
|
||
}
|
||
|
||
double COXTimeEdit::ConversionHelper(double dValue, int nUnitFrom, int nUnitTo)
|
||
{
|
||
return COXPhysicalEdit::ConversionHelper(
|
||
dValue,nUnitFrom,nUnitTo,m_timeConversionData.m_pConversionParams);
|
||
}
|
||
|
||
BOOL COXTimeEdit::SetInputData(LPCTSTR pszInputData, int /*nBeginPos=0*/)
|
||
{
|
||
if (pszInputData == NULL || ::_tcslen(pszInputData) == 0)
|
||
return TRUE;
|
||
|
||
// Interpret the input data
|
||
double dTime;
|
||
TCHAR szUnitName[255];
|
||
CString strInputData = pszInputData;
|
||
strInputData.Remove(',');
|
||
#if _MSC_VER >= 1400
|
||
::_stscanf_s(strInputData, _T("%lf %s"), &dTime, szUnitName, 255);
|
||
#else
|
||
::_stscanf(strInputData, _T("%lf %s"), &dTime, szUnitName);
|
||
#endif
|
||
CString strUnitName(szUnitName);
|
||
|
||
// Resolve the unit name
|
||
int iUnit = 0;
|
||
for (int i = 0; i < m_timeConversionData.m_nNumberOfUnits; i++)
|
||
if (m_rgpszTimeUnitNames[i] == strUnitName)
|
||
{
|
||
iUnit = i;
|
||
break;
|
||
}
|
||
|
||
SetDuration(dTime, iUnit);
|
||
return TRUE;
|
||
}
|
||
|
||
COXTimeEdit::~COXTimeEdit()
|
||
{
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXAngleEdit static variables
|
||
|
||
LPCTSTR COXAngleEdit::m_rgpszAngleUnitNames[] =
|
||
{
|
||
_T("deg"),
|
||
_T("rd"),
|
||
_T("grad"),
|
||
_T("deg"),
|
||
_T("rad"),
|
||
};
|
||
|
||
COXConversionParams COXAngleEdit::m_rgnAngleConversionParams[] =
|
||
{
|
||
{0, 1, 0}, // OX_ANGLE_DEGREE (1 * = 1 ?
|
||
{0, 57.29577951308, 0}, // OX_ANGLE_RADIAN (1 rd = 180/pi ?
|
||
{0, 0.9, 0}, // OX_ANGLE_GRAD (1 grad = 9/10 ?
|
||
{0, 1, 0}, // OX_ANGLE_DEGREE_2 (1 deg = 1 ?
|
||
{0, 57.29577951308, 0}, // OX_ANGLE_RADIAN_2 (1 rad = 180/pi ?
|
||
};
|
||
|
||
COXConversionData COXAngleEdit::m_angleConversionData =
|
||
{
|
||
OX_ANGLE_LAST + 1, // m_nNumberOfUnits
|
||
OX_ANGLE_DEGREE, // m_nDefaultUnitIndex
|
||
m_rgpszAngleUnitNames, // m_ppszUnitNames
|
||
m_rgnAngleConversionParams, // m_pConversionParams
|
||
MAKEINTRESOURCE(IDS_OX_BAD_ANGLE_UNIT) // m_pszErrorMsg;
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXTempEdit
|
||
|
||
IMPLEMENT_DYNCREATE(COXAngleEdit, COXPhysicalEdit)
|
||
|
||
BEGIN_MESSAGE_MAP(COXAngleEdit, COXPhysicalEdit)
|
||
//{{AFX_MSG_MAP(COXAngleEdit)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
COXAngleEdit::COXAngleEdit(int nDefaultUnitIndex/*=OX_ANGLE_DEGREE*/) :
|
||
COXPhysicalEdit(&m_angleConversionData, nDefaultUnitIndex)
|
||
{
|
||
}
|
||
|
||
BOOL COXAngleEdit::SetInputData(LPCTSTR pszInputData, int /*nBeginPos=0*/)
|
||
{
|
||
if (pszInputData == NULL || ::_tcslen(pszInputData) == 0)
|
||
return TRUE;
|
||
|
||
// Interpret the input data
|
||
double dAngle;
|
||
TCHAR szUnitName[255];
|
||
CString strInputData = pszInputData;
|
||
strInputData.Remove(',');
|
||
#if _MSC_VER >= 1400
|
||
::_stscanf_s(strInputData, _T("%lf %s"), &dAngle, szUnitName, 255);
|
||
#else
|
||
::_stscanf(strInputData, _T("%lf %s"), &dAngle, szUnitName);
|
||
#endif
|
||
CString strUnitName(szUnitName);
|
||
|
||
// Resolve the unit name
|
||
int iUnit = 0;
|
||
for (int i = 0; i < m_angleConversionData.m_nNumberOfUnits; i++)
|
||
if (m_rgpszAngleUnitNames[i] == strUnitName)
|
||
{
|
||
iUnit = i;
|
||
break;
|
||
}
|
||
|
||
SetAngle(dAngle, iUnit);
|
||
return TRUE;
|
||
}
|
||
|
||
void COXAngleEdit::SetAngle(double dValue, int nUnit/*=-1*/,
|
||
LPCTSTR pszFormat/*=NULL*/)
|
||
{
|
||
COXPhysicalEdit::SetValue(dValue,nUnit,pszFormat);
|
||
}
|
||
|
||
double COXAngleEdit::GetAngle(int nUnit/*=-1*/, BOOL bNotify/*=TRUE*/)
|
||
{
|
||
return COXPhysicalEdit::GetValue(nUnit,bNotify);
|
||
}
|
||
|
||
double COXAngleEdit::ConversionHelper(double dValue, int nUnitFrom, int nUnitTo)
|
||
{
|
||
return COXPhysicalEdit::ConversionHelper(
|
||
dValue,nUnitFrom,nUnitTo,m_angleConversionData.m_pConversionParams);
|
||
}
|
||
|
||
COXAngleEdit::~COXAngleEdit()
|
||
{
|
||
}
|
||
|
||
// global:
|
||
void AFXAPI DDX_OXLengthEdit(CDataExchange* pDX, int nIDC, double& dValue, int nUnits)
|
||
{
|
||
#ifdef _DEBUG
|
||
COXLengthEdit* pEdit = (COXLengthEdit*)pDX->m_pDlgWnd->GetDlgItem(nIDC);
|
||
ASSERT(pEdit->IsKindOf(RUNTIME_CLASS(COXLengthEdit)));
|
||
ASSERT_VALID(pEdit);
|
||
#endif
|
||
|
||
// ... Call base class imlementation
|
||
DDX_OXPhysicalEdit(pDX,nIDC,dValue,nUnits);
|
||
}
|
||
|
||
void AFXAPI DDX_OXTimeEdit(CDataExchange* pDX, int nIDC, double& dValue, int nUnits)
|
||
{
|
||
#ifdef _DEBUG
|
||
COXTimeEdit* pEdit = (COXTimeEdit*)pDX->m_pDlgWnd->GetDlgItem(nIDC);
|
||
ASSERT(pEdit->IsKindOf(RUNTIME_CLASS(COXTimeEdit)));
|
||
ASSERT_VALID(pEdit);
|
||
#endif
|
||
|
||
// ... Call base class imlementation
|
||
DDX_OXPhysicalEdit(pDX,nIDC,dValue,nUnits);
|
||
}
|
||
|
||
void AFXAPI DDX_OXTempEdit(CDataExchange* pDX, int nIDC, double& dValue, int nUnits)
|
||
{
|
||
#ifdef _DEBUG
|
||
COXTempEdit* pEdit = (COXTempEdit*)pDX->m_pDlgWnd->GetDlgItem(nIDC);
|
||
ASSERT(pEdit->IsKindOf(RUNTIME_CLASS(COXTempEdit)));
|
||
ASSERT_VALID(pEdit);
|
||
#endif
|
||
|
||
// ... Call base class imlementation
|
||
DDX_OXPhysicalEdit(pDX,nIDC,dValue,nUnits);
|
||
}
|
||
|
||
void AFXAPI DDX_OXAngleEdit(CDataExchange* pDX, int nIDC, double& dValue, int nUnits)
|
||
{
|
||
#ifdef _DEBUG
|
||
COXAngleEdit* pEdit = (COXAngleEdit*)pDX->m_pDlgWnd->GetDlgItem(nIDC);
|
||
ASSERT(pEdit->IsKindOf(RUNTIME_CLASS(COXAngleEdit)));
|
||
ASSERT_VALID(pEdit);
|
||
#endif
|
||
|
||
// ... Call base class imlementation
|
||
DDX_OXPhysicalEdit(pDX,nIDC,dValue,nUnits);
|
||
}
|
||
|
||
// ==========================================================================
|