Basic.h

#ifndef PHWIDGETS_BASIC_H
#define PHWIDGETS_BASIC_H
 
#include <photon/PtBasic.h>
 
#include "./Widget.h"
#include "./Drawing/Color.h"
 
 
namespace PhWidgets
{
 
    class Basic:
        public Widget
    {
    public:
 
        template<class T = void, class Disabled = Widget::ResourceTypeTag<-1>, bool Dummy = false>
        struct Arguments
        {
            typedef void type;
        };
 
        template<class T, int TypeID>
        struct Arguments<T, Widget::ResourceTypeTag<TypeID> >
            : Basic::Arguments<T, Widget::ResourceTag::Alloc>
            , Basic::Arguments<T, Widget::ResourceTag::Callback>
            , Basic::Arguments<T, Widget::ResourceTag::Color>
            , Basic::Arguments<T, Widget::ResourceTag::Flag>
            , Basic::Arguments<T, Widget::ResourceTag::Scalar>
            , Basic::Arguments<T, Widget::ResourceTag::String>
            , Basic::Arguments<T, Widget::ResourceTag::Struct>
        { };
 
        template<class T>
        struct Arguments<Basic, T, false>
            : Basic::Arguments<T>
        { };
 
        template<bool Dummy>
        struct Arguments<unsigned short, ResourceTag::Scalar, Dummy>
        {
 
            typedef enum Scalar
            {
                MarginHeight = Pt_ARG_MARGIN_HEIGHT, 
                MarginWidth = Pt_ARG_MARGIN_WIDTH 
            } type;
        };
        
        template<bool Dummy>
        struct Arguments<unsigned long, ResourceTag::Scalar, Dummy>
        {
 
            typedef enum Scalar
            {
                BandwidthThreshold = Pt_ARG_BANDWIDTH_THRESHOLD, 
                BasicFlags = Pt_ARG_BASIC_FLAGS 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PgColor_t, ResourceTag::Color, Dummy>
        {
 
            typedef enum Color
            {
                BevelColor = Pt_ARG_BEVEL_COLOR, 
                Color = Pt_ARG_COLOR, 
                DarkBevelColor = Pt_ARG_DARK_BEVEL_COLOR, 
                DarkFillColor = Pt_ARG_DARK_FILL_COLOR, 
                FillColor = Pt_ARG_FILL_COLOR, 
                InlineColor = Pt_ARG_INLINE_COLOR, 
                LightBevelColor = Pt_ARG_LIGHT_BEVEL_COLOR, 
                LightFillColor = Pt_ARG_LIGHT_FILL_COLOR, 
                OutlineColor = Pt_ARG_OUTLINE_COLOR 
 
                , DrawingColor = Color 
            } type, ColorResource;
        };
 
        template<bool Dummy>
        struct Arguments<char, ResourceTag::Scalar, Dummy>
        {        
 
            typedef enum Scalar
            {
                BevelContrast = Pt_ARG_BEVEL_CONTRAST, 
                Contrast = Pt_ARG_CONTRAST 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PgPattern_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                FillPattern = Pt_ARG_FILL_PATTERN, 
                TransPattern = Pt_ARG_TRANS_PATTERN 
            } type;
        };
        
        template<bool Dummy>
        struct Arguments<unsigned char, ResourceTag::Scalar, Dummy>
        {
 
            typedef enum Scalar
            {
                HighlihgtRoundness = Pt_ARG_HIGHLIGHT_ROUNDNESS 
            } type;
        };
        
        template<bool Dummy>
        struct Arguments<char*, ResourceTag::String, Dummy>
        {
 
            enum String
            {
                Style = Pt_ARG_STYLE 
            } type;
        };    
 
        template<class T = void, class Disabled = void, bool Dummy = false>
        struct Callbacks
        {
            typedef Callbacks<> type;
        };
 
        template<class T>
        struct Callbacks<Basic, T>
            : Callbacks<T>
        { };
 
        template<class T, bool Dummy>
        struct Callbacks<T, void, Dummy>
            : Callbacks<T, ResourceTag::Callback, Dummy>
        { };
 
        template<bool Dummy>
        struct Callbacks<PtCallback_t, ResourceTag::Callback, Dummy>
        {
 
            typedef enum Callback
            {
                Activate = Pt_CB_ACTIVATE,     
 
                Arm = Pt_CB_ARM, 
 
                Disarm = Pt_CB_DISARM,     
 
                GotFocus = Pt_CB_GOT_FOCUS, 
 
                LostFocus = Pt_CB_LOST_FOCUS, 
 
                Menu = Pt_CB_MENU, 
 
                Repeat = Pt_CB_REPEAT     
            } type;
        };
 
        struct Flags
            : Widget::Flags
        {
            struct Basic
            {
 
                enum type
                {
 
                    // Edge-control bits:
 
                    TopEtch = Pt_TOP_ETCH,
                    BottomEtch = Pt_BOTTOM_ETCH,
                    LeftEtch = Pt_LEFT_ETCH,
                    RightEtch = Pt_RIGHT_ETCH, // Render a single alpha line on an edge of the widget. The top and left lines are dark, and the bottom and right lines are light. This can make a widget look like it's slightly inset. 
                    BlankEtches = Pt_BLANK_ETCHES, 
                    OpaqueEtches = Pt_OPAQUE_ETCHES, 
                    TopOutline = Pt_TOP_OUTLINE,
                    BottomOutline = Pt_BOTTOM_OUTLINE,
                    LeftOutline = Pt_LEFT_OUTLINE,
                    RightOutline = Pt_RIGHT_OUTLINE, // Render a single-pixel outline on an edge of the widget. 
                    TopBevel = Pt_TOP_BEVEL,
                    BottomBevel = Pt_BOTTOM_BEVEL,
                    LeftBevel = Pt_LEFT_BEVEL,
                    RightBevel = Pt_RIGHT_BEVEL, // Render a bevel Pt_ARG_BEVEL_WIDTH pixels wide on an edge of the widget. 
                    FullBevels = Pt_FULL_BEVELS, // Render a full bevel (i.e. half-round) instead of a half bevel (quarter-round). 
                    TopInline =  Pt_TOP_INLINE,
                    BottomInline = Pt_BOTTOM_INLINE,
                    LeftInline = Pt_LEFT_INLINE,
                    RightInline = Pt_RIGHT_INLINE, // Render a single-pixel inline on an edge of the widget. 
 
                    // These convenience manifests make working with these bits easier:
 
                    TopLeftEtch = Pt_TOP_LEFT_ETCH, 
                    BottomRightEtch = Pt_BOTTOM_RIGHT_ETCH, 
                    AllEtches = Pt_ALL_ETCHES, 
                    TopLeftOutline = Pt_TOP_LEFT_OUTLINE, 
                    BottomRightOutline = Pt_BOTTOM_RIGHT_OUTLINE, 
                    AllOutlines = Pt_ALL_OUTLINES, 
                    TopLeftBevel = Pt_TOP_LEFT_BEVEL, 
                    BottomRightBevel = Pt_BOTTOM_RIGHT_BEVEL, 
                    AllBevels = Pt_ALL_BEVELS, 
                    TopLeftInline = Pt_TOP_LEFT_INLINE, 
                    BottomRightInline= Pt_BOTTOM_RIGHT_INLINE, 
                    AllInlines = Pt_ALL_INLINES, 
                    AllTop = Pt_ALL_TOP, 
                    AllBottom = Pt_ALL_BOTTOM, 
                    AllLeft = Pt_ALL_LEFT, 
                    AllRight = Pt_ALL_RIGHT, 
                    All = Pt_ALL, 
 
                    // Fill-control bits:
 
                    FlatFill = Pt_FLAT_FILL, 
                    HorizontalGradient = Pt_HORIZONTAL_GRADIENT, 
                    ReverseGradient = Pt_REVERSE_GRADIENT, 
                    StaticBevelColors = Pt_STATIC_BEVEL_COLORS, 
                    PreventFill = Pt_BASIC_PREVENT_FILL, 
 
                    // Behavior on state change:
 
                    // These bits affect how the widget behaves when set (depressed) or unset (raised):
 
                    StaticGradient = Pt_STATIC_GRADIENT, 
                    StaticBevels = Pt_STATIC_BEVELS 
                };
            };
        };
 
        template<int TypeID>
        struct Arguments<void, Widget::ResourceTypeTag<TypeID> >
            : Basic::Arguments<unsigned short, Widget::ResourceTypeTag<__LINE__>>
            , Basic::Arguments<unsigned long, Widget::ResourceTypeTag<__LINE__>>
            , Basic::Arguments<PgColor_t, Widget::ResourceTypeTag<__LINE__>>
            , Basic::Arguments<char, Widget::ResourceTypeTag<__LINE__>>
            , Basic::Arguments<PgPattern_t, Widget::ResourceTypeTag<__LINE__>>
            , Basic::Arguments<unsigned char, Widget::ResourceTypeTag<__LINE__>>
            , Basic::Arguments<char*, Widget::ResourceTypeTag<__LINE__>>
            , Widget::Arguments<>
        { };
 
        template<bool Dummy>
        struct Callbacks<void, void, Dummy>
            : Basic::Callbacks<PtCallback_t, ResourceTag::Callback>
            , Widget::Callbacks<>
        { };
 
    protected:
 
        typedef ResourceFrom<Widget::WidgetResourcesSingleton>::
            Define::String<Arguments<char*>::String>::
            Define::Color<Arguments<PgColor_t>::ColorResource>::
            Define::Scalar<Arguments<unsigned short>::Scalar, unsigned short>::
            Define::Scalar<Arguments<char>::Scalar, char>::
            //Define::Flag<ThisArgs::ArgLong::eArgLong, long>::
            Define::Flag<Arguments<unsigned long>::Scalar, unsigned long>::
            //Define::Flag<ThisArgs::ArgUnsigned::eArgUnsigned, unsigned>::
 
            Define::Link<Callbacks<PtCallback_t>::type, PtCallback_t*>::
 
        resource_type WidgetResourcesSingleton;
 
        virtual void check();
                        
    public:
 
        explicit Basic(int abn);
 
 
        explicit Basic(PtWidget_t *wdg);
        
 
        Basic(const Basic &other);
 
 
        Basic &operator=(const Basic &other);
 
 
        WidgetResourcesSingleton resource;
        
        
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::BevelColor> BevelColor;
        
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::DrawingColor> Color;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::DarkBevelColor> DarkBevelColor;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::DarkFillColor> DarkFillColor;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::FillColor> FillColor;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::InlineColor> InlineColor;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::LightBevelColor> LightBevelColor;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::LightFillColor> LightFillColor;
 
 
        phproperty<unsigned short>::bind<Basic, Arguments<unsigned short>::Scalar, Arguments<>::MarginHeight> MarginHeight;
 
 
        phproperty<unsigned short>::bind<Basic, Arguments<unsigned short>::Scalar, Arguments<>::MarginWidth> MarginWidth;
 
 
        phproperty<Drawing::Color>::bind<Basic, Arguments<PgColor_t>::ColorResource, Arguments<>::OutlineColor> OutlineColor;
 
        phbitmask<unsigned long, Flags::Basic::type>::
            bind<Basic, Arguments<unsigned long>::Scalar, Arguments<>::BasicFlags>    BasicFlags; 
 
 
        phwidgets_event<Basic, Basic::Callbacks<>::Activate>      Activate; 
        phwidgets_event<Basic, Basic::Callbacks<>::Arm>           Arm; 
        phwidgets_event<Basic, Basic::Callbacks<>::Disarm>        Disarm; 
        phwidgets_event<Basic, Basic::Callbacks<>::GotFocus>      GotFocus; 
        phwidgets_event<Basic, Basic::Callbacks<>::LostFocus>     LostFocus; 
        phwidgets_event<Basic, Basic::Callbacks<>::Menu>          Menu; 
        phwidgets_event<Basic, Basic::Callbacks<>::Repeat>        Repeat; 
 
 
        void OnActivated(PtCallbackInfo_t *info); 
        void OnArmed(PtCallbackInfo_t *info); 
        void OnDisarmed(PtCallbackInfo_t *info); 
        void OnGotFocused(PtCallbackInfo_t *info); 
        void OnLostFocus(PtCallbackInfo_t *info); 
        void OnMenu(PtCallbackInfo_t *info); 
        void OnRepeat(PtCallbackInfo_t *info); 
 
    };          
 
 
    
} // namespace PhWidgets
 
cppbitmasks::bitmask<unsigned long, PhWidgets::Basic::Flags::Basic::type> operator|(const PhWidgets::Basic::Flags::Basic::type &flag1, const PhWidgets::Basic::Flags::Basic::type &flag2);
cppbitmasks::bitmask<unsigned long, PhWidgets::Basic::Flags::Basic::type> operator&(const PhWidgets::Basic::Flags::Basic::type &flag1, const PhWidgets::Basic::Flags::Basic::type &flag2);
cppbitmasks::bitmask<unsigned long, PhWidgets::Basic::Flags::Basic::type> operator^(const PhWidgets::Basic::Flags::Basic::type &flag1, const PhWidgets::Basic::Flags::Basic::type &flag2);
 
 
#endif // PHWIDGETS_BASIC_H