TnbMfcEditFloat.h

[詳解]

#pragma once
#include "TnbMfcEditValue.h"
#include <math.h>
#include <wchar.h>
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
#ifndef _TnbDOXYGEN
 
template<UINT n> struct TPowerValue {
    enum {
        VALUE = TPowerValue<n - 1>::VALUE * 10
    };
};
template<> struct TPowerValue<0> {
    enum {VALUE = 1};
};
#define _POW10(X) (TPowerValue<X>::VALUE)
 
#endif //_TnbDOXYGEN
 
 
 
template<int POW = 1>
class CEditFloatT : public CEditValueT<double, 0, 0>
{
    typedef CEditValueT<double, 0, 0> _super;
protected:
    enum { POWER = _POW10(POW) };
    virtual bool IsValidChar(UINT& _nChar, LONG& _lFlags, const CString& strNowText)
    {
        if ( _nChar == '.' && strNowText.Find('.') < 0 )
        {
            return true;
        }
        return _super::IsValidChar(_nChar, _lFlags, strNowText);
    }
 
    virtual void OnUpdateChar(void)
    {
    }
 
    virtual void OnEditEnd(void)
    {
        CString s = _super::GetText();
        if ( ! s.IsEmpty() )
        {
            double d = _tcstod(s, NULL);
            double dd = d;
            double mx = static_cast<double>(m_xMax) / POWER;
            double mn = static_cast<double>(m_xMin) / POWER;
            if ( d > mx )
            {
                d = mx;
            }
            else if ( d < mn )
            {
                d = mn;
            }
            LONGLONG i = ToInteger(s);
            LONGLONG ii = AdjustValue(i);
            _super::SetText(ToString(ii));
            if ( i != ii || d != dd )
            {
                ::MessageBeep(MB_ICONASTERISK); //入力制限より内容が変化した時
            }
        }
    }
 
    virtual CString ToString(LONGLONG ll) const
    {
        double r = static_cast<double>(ll) / POWER;
        CString str;
        if ( m_iZeroPlace > 0 )
        {
            CString s;
            s.Format(_T("%%0%d.%df"), m_iZeroPlace, POW); 
            str.Format(s, r);
        }
        else
        {
            CString s;
            s.Format(_T("%%.%df"), POW); 
            str.Format(s, r);
        }
        return str;
    }
    
    virtual LONGLONG ToInteger(LPCTSTR s) const
    {
        double d = _tcstod(s, NULL) * POWER;
        d += (d < 0.0) ? -0.5 : 0.5;
        return static_cast<LONGLONG>(d);
    }
 
public:
    
    CEditFloatT(void)
    {
        m_xMin = 0;
        m_xMax = 0;
        m_step = 1;
    }
 
    virtual CString ValueToString(double xValue) const
    {
        double d = xValue * POWER;
        d += (d < 0.0) ? -0.5 : 0.5;
        LONGLONG l = AdjustValue(static_cast<LONGLONG>(d));
        return ToString(l);
    }
 
    virtual void SetValue(double xValue)
    {
        _super::SetText(ValueToString(xValue));
    }
 
    virtual bool GetValue(double& _xValue) const
    {
        CString s = _super::GetText();
        if ( s.IsEmpty() )
        {
            return false;
        }
        _xValue = static_cast<double>(AdjustValue(ToInteger(s))) / POWER;
        return true;
    }
    
    virtual void SetRange(double xMin, double xMax, double step = 0.0)
    {
        m_xMin = static_cast<LONGLONG>(xMin * POWER);
        m_xMax = static_cast<LONGLONG>(xMax * POWER);
        if ( m_xMin > m_xMax )
        {
            Swap(m_xMin, m_xMax);
        }
        if ( step <= 0.0 )
        {
            step = 1.0 / POWER;
        }
        m_step = static_cast<int>(step * POWER);
    }
};
 
 
 
}; //MFC
}; //TNB