Gauge.h

#ifndef PHWIDGETS_GAUGE_H
#define PHWIDGETS_GAUGE_H
 
#include <photon/PtGauge.h>
 
#include "./Basic.h"
#include "./Drawing/Font.h"
 
 
namespace PhWidgets
{

      
    class Gauge:
        public Basic
    {
    public:

        struct ThisArgs
        {
            struct ArgLong
            {

                enum eArgLong
                {
                    gauge_value = Pt_ARG_GAUGE_VALUE, 
                    maximum = Pt_ARG_MAXIMUM, 
                    minimum = Pt_ARG_MINIMUM 
                };
            };

            struct ArgShort
            {

                enum eArgShort
                {
                    gauge_flags = Pt_ARG_GAUGE_FLAGS 
                };
            };
            
            struct ArgChar
            {

                enum eArgChar
                {
                    gauge_orientation = Pt_ARG_GAUGE_ORIENTATION 
                };
            };

            struct ArgUnsignedChar
            {

                enum eArgUnsignedChar
                {
                    gauge_horizontal_align = Pt_ARG_GAUGE_H_ALIGN, 
                    gauge_vertical_align = Pt_ARG_GAUGE_V_ALIGN 
                };
            };

            struct ArgPChar
            {

                enum eArgPChar
                {
                    value_prefix = Pt_ARG_GAUGE_VALUE_PREFIX, 
                    value_suffix = Pt_ARG_GAUGE_VALUE_SUFFIX, 
                    gauge_font = Pt_ARG_GAUGE_FONT 
                };
            };  
            
        };

        struct ThisFlags
        {   
            struct Gauge
            {

                enum eGaugeFlags
                {
 
#ifndef Pt_SHOW_VALUE
    #define Pt_SHOW_VALUE_IMPL Pt_GAUGE_SHOW_VALUE
#else
    #define Pt_SHOW_VALUE_IMPL Pt_SHOW_VALUE
#endif
 
#ifndef Pt_VALUE_XOR
    #define Pt_VALUE_XOR_IMPL Pt_GAUGE_VALUE_XOR
#else
    #define Pt_VALUE_XOR_IMPL Pt_VALUE_XOR
#endif
 
#ifndef Pt_GAUGE_MAX_ON_RIGHT
    #define Pt_GAUGE_MAX_ON_RIGHT_IMPL 0
#else
    #define Pt_GAUGE_MAX_ON_RIGHT_IMPL Pt_GAUGE_MAX_ON_RIGHT
#endif
 
#ifndef Pt_GAUGE_MAX_ON_BOTTOM
    #define Pt_GAUGE_MAX_ON_BOTTOM_IMPL 0
#else
    #define Pt_GAUGE_MAX_ON_BOTTOM_IMPL Pt_GAUGE_MAX_ON_BOTTOM
#endif
 
#ifndef Pt_GAUGE_INDETERMINATE
    #define Pt_GAUGE_INDETERMINATE_IMPL 0
#else
    #define Pt_GAUGE_INDETERMINATE_IMPL Pt_GAUGE_INDETERMINATE
#endif
 
#ifndef Pt_GAUGE_INTERACTIVE
    #define Pt_GAUGE_INTERACTIVE_IMPL 0
#else
    #define Pt_GAUGE_INTERACTIVE_IMPL Pt_GAUGE_INTERACTIVE
#endif
 
                    ShowValue = Pt_SHOW_VALUE_IMPL, 
                    ValueXOR = Pt_VALUE_XOR_IMPL, 
                    MaximumOnTop = Pt_GAUGE_MAX_ON_TOP, 
                    MaximumOnRight = Pt_GAUGE_MAX_ON_RIGHT_IMPL, 
                    MaximumOnLeft = Pt_GAUGE_MAX_ON_LEFT, 
                    MaximumOnBottom = Pt_GAUGE_MAX_ON_BOTTOM_IMPL, 
                    Indeterminate = Pt_GAUGE_INDETERMINATE_IMPL, 
                    Interactive = Pt_GAUGE_INTERACTIVE_IMPL
 
#undef Pt_SHOW_VALUE_IMPL
#undef Pt_VALUE_XOR_IMPL
#undef Pt_GAUGE_MAX_ON_RIGHT_IMPL
#undef Pt_GAUGE_MAX_ON_BOTTOM_IMPL
#undef Pt_GAUGE_INDETERMINATE_IMPL
#undef Pt_GAUGE_INTERACTIVE_IMPL
                };
            };

            struct Orientation
            {

                enum eOrientation
                {
                    Horizontal = Pt_HORIZONTAL, 
                    Vertical = Pt_VERTICAL 
                };
            };

            struct Alignment
            {
                struct Horizontal
                {

                    enum eHorizontal
                    {
                        Left = Pt_LEFT, 
                        Right = Pt_RIGHT, 
                        Center = Pt_CENTER 
                    };
                };

                struct Vertical
                {

                    enum eVertical
                    {
                        Top = Pt_TOP, 
                        Bottom = Pt_BOTTOM, 
                        Center = Pt_CENTER 
                    };
                };
            };
        };

        struct ArgLong:
            public ArgumentsEx<Basic::ArgLong>,
            public ThisArgs::ArgLong
        {
            typedef ThisArgs::ArgLong::eArgLong eArgLong;
        };
        
        struct ArgShort:
            public ThisArgs::ArgShort
        { };
        
        struct ArgChar:
            public ArgumentsEx<Basic::ArgChar>,
            public ThisArgs::ArgChar
        {
            typedef ThisArgs::ArgChar::eArgChar eArgChar;
        };  

        struct ArgUnsignedChar:
            public ArgumentsEx<Basic::ArgUnsignedChar>,
            public ThisArgs::ArgUnsignedChar
        {
            typedef ThisArgs::ArgUnsignedChar::eArgUnsignedChar eArgUnsignedChar;
        };

        struct ArgPChar:
            public ArgumentsEx<Basic::ArgPChar>,
            public ThisArgs::ArgPChar
        {
            typedef ThisArgs::ArgPChar::eArgPChar eArgPChar;
        };  

        struct Arguments:
            public ArgLong,
            public ArgShort,
            public ArgChar,
            public ArgUnsignedChar,
            public ArgPChar,
            public Basic::Arguments
        { };

        struct Flags:
            public ThisFlags,
            public Basic::Flags
        { };
 
    protected:
        typedef ResourceFrom<Basic::WidgetResourcesSingleton>::
            Define::String<ThisArgs::ArgPChar::eArgPChar>::
            Define::Scalar<ThisArgs::ArgLong::eArgLong, long>::
            Define::Flag<ThisArgs::ArgShort::eArgShort, short int>::
            Define::Scalar<ThisArgs::ArgChar::eArgChar, char>::
            Define::Scalar<ThisArgs::ArgUnsignedChar::eArgUnsignedChar, unsigned char>::
 
        resource_type WidgetResourcesSingleton;
 
        Drawing::Font getFont() const;
        void setFont(Drawing::Font);
 
        std::string getPrefix() const;
        void setPrefix(std::string text);
 
        std::string getSuffix() const;
        void setSuffix(std::string text);
 
        virtual void check();
        
                        
    public:

        WidgetResourcesSingleton resource;


        explicit Gauge(int abn);

      
        explicit Gauge(PtWidget_t *wdg);


        Gauge(const Gauge &other);


        Gauge &operator=(const Gauge &other);




        property<Drawing::Font>::bind<Gauge, &Gauge::getFont, &Gauge::setFont> Font;


        property<std::string>::bind<Gauge, &Gauge::getPrefix, &Gauge::setPrefix> Prefix;


        property<std::string>::bind<Gauge, &Gauge::getSuffix, &Gauge::setSuffix> Suffix;


        phproperty<long>::bind<Gauge, ArgLong::eArgLong, Arguments::gauge_value> Value;


        phproperty<long>::bind<Gauge, ArgLong::eArgLong, Arguments::maximum> Maximum;


        phproperty<long>::bind<Gauge, ArgLong::eArgLong, Arguments::minimum> Minimum;
        

        phbitmask<short int, Flags::Gauge::eGaugeFlags>::bind<Gauge, ArgShort::eArgShort, ArgShort::gauge_flags> GaugeFlags; 
 
        
    };
} // namespace PhWidgets
 
 
#endif // PHWIDGETS_GAUGE_H