Widget.h

#ifndef PHWIDGETS_WIDGET_H
#define PHWIDGETS_WIDGET_H
 
#include <photon/PhT.h>
#include <photon/PtWidget.h>
#include <photon/PtContainer.h>
#include <photon/PtGridLayout.h>
#include <photon/PtRowLayout.h>
 
#include <map>
#include <string>
#include <list>
#include <set>
 
#include "./service/stdex/stdex.h"
#include "./service/phproperty.hpp"
#include "./service/phevent.hpp"
#include "./service/phbitmask.hpp"
#include "./service/tag_property.hpp"
#include "./service/WidgetResource.hpp"
 
#include "./Cursor.h"
#include "./Drawing/Color.h"
 
 
//typedef Ph_rect `PhRect_t`;
 
#ifndef __QNXNTO__
    typedef struct Ph_rect   PhRect_t;
#endif
 
// @defgroup Widgets PhWidgets library widgets
// @defgroup Values PhWidgets library flags and predefined values
// @defgroup Classes PhWidgets library helper classes
// @defgroup Resources PhWidgets library resource ID's and raw widgets flags
 
namespace PhWidgets
{
    using namespace cppproperties;
    using namespace phevents;
    using namespace cppbitmasks;
 
 
    struct AnchorStyles
    {
 
        enum type
        {
            LeftAnchoredRight = Pt_LEFT_ANCHORED_RIGHT, 
            RightAnchoredRight = Pt_RIGHT_ANCHORED_RIGHT, 
            TopAnchoredBottom = Pt_TOP_ANCHORED_BOTTOM, 
            BottomAnchoredBottom = Pt_BOTTOM_ANCHORED_BOTTOM, 
            LeftAnchoredLeft = Pt_LEFT_ANCHORED_LEFT, 
            RightAnchoredLeft = Pt_RIGHT_ANCHORED_LEFT, 
            TopAnchoredTop = Pt_TOP_ANCHORED_TOP, 
            BottomAnchoredTop = Pt_BOTTOM_ANCHORED_TOP, 
            BalloonsOn = Pt_BALLOONS_ON, 
 
            // Visual Studio like styles:
 
            Bottom = BottomAnchoredBottom, 
            Left = LeftAnchoredLeft, 
            None = 0, 
            Right = RightAnchoredRight, 
            Top = TopAnchoredTop, 
 
            All =     LeftAnchoredRight | RightAnchoredRight | 
                    TopAnchoredBottom | BottomAnchoredBottom |
                    LeftAnchoredLeft | RightAnchoredLeft |
                    TopAnchoredTop | BottomAnchoredTop |
                    BalloonsOn
        };
    };
 
 
    class Widget:
        protected detail::IPtWidget,
        public IPhWidgetsProperty
    {
    protected:
        struct ResourceTag
        {
            struct Struct;
            struct Callback;
            struct Alloc;
            struct Color;
            struct Flag;
            struct String;
            struct Scalar;
        };
    public:
 
        
        typedef phevent::ph_callback_t callback_t;
        
 
        template<class ParentT, typename ParentT::template Callbacks<PtCallback_t>::Callback CallbackID>
        class phwidgets_event
        {
            
        public:
            phwidgets_event(ParentT *parent) :
                _obj(parent)
            {}
 
            inline void add(callback_t value)
            {
                _obj->resource.callback[CallbackID].add(value);
            }
 
            inline void remove(callback_t value)
            {
                _obj->resource.callback[CallbackID].remove(value);
            }
 
 
            inline void raise(PtCallbackInfo_t * info) const
            {
                _obj->resource.callback[CallbackID].raise(info);
            }
 
            inline void operator+=(callback_t value)
            {
                add(value);
            }
 
            inline void operator-=(callback_t value)
            {
                remove(value);
            }
 
 
            inline void operator()(PtCallbackInfo_t * info) const
            {
                raise(info);
            }
 
 
        private:
            ParentT *_obj;
 
            phwidgets_event(const phwidgets_event &rhs);
 
            inline phwidgets_event &operator=(callback_t);
            inline phwidgets_event &operator=(phwidgets_event const &);
        };
 
 
        /*template<class ParentT, ParentT::Callbacks::eRawCallback callback>
        class phwidgets_event
        {
            typedef phevent::ph_callback_t value_t;
 
        public:
            phwidgets_event(ParentT *parent) :
                _obj(parent)
            {}
 
            inline void add(value_t value)
            {
                _obj->resource.callback[callback].add(value);
            }
 
            inline void remove(value_t value)
            {
                _obj->resource.callback[callback].remove(value);
            }
 
            inline void operator+=(value_t value)
            {
                add(value);
            }
 
            inline void operator-=(value_t value)
            {
                remove(value);
            }
 
 
        private:
            ParentT *_obj;
 
            phwidgets_event(const phwidgets_event &rhs);
 
            inline phwidgets_event &operator=(value_t);
            inline phwidgets_event &operator=(phwidgets_event const &);
        };*/
 
    protected:
        template<int>
        struct ResourceTypeTag;
 
    public:
 
        template<class T = void, class Disabled = ResourceTypeTag<-1>, bool Dummy = false>
        struct Arguments
        {
            typedef void type;
        };
 
        template<class T, int TypeID>
        struct Arguments<T, ResourceTypeTag<TypeID> >
            : Arguments<T, ResourceTag::Alloc>
            , Arguments<T, ResourceTag::Callback>
            , Arguments<T, ResourceTag::Color>
            , Arguments<T, ResourceTag::Flag>
            , Arguments<T, ResourceTag::Scalar>
            , Arguments<T, ResourceTag::String>
            , Arguments<T, ResourceTag::Struct>
        { };
 
        template<class T>
        struct Arguments<Widget, T, false>
            : Arguments<T>
        { };
 
        template<bool Dummy>
        struct Arguments<PhArea_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {            
                Area = Pt_ARG_AREA 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<unsigned, ResourceTag::Flag, Dummy>
        {
 
            typedef enum Flag
            {
                AnchorFlags = Pt_ARG_ANCHOR_FLAGS 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<unsigned short, ResourceTag::Scalar, Dummy>
        {
 
            typedef enum Scalar
            {
                BevelWidth = Pt_ARG_BEVEL_WIDTH, 
                CursorType = Pt_ARG_CURSOR_TYPE, 
                Height = Pt_ARG_HEIGHT, 
                Width = Pt_ARG_WIDTH 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<unsigned long, ResourceTag::Flag, Dummy>
        {
 
            typedef enum Flag
            {
                ExtendedFlags = Pt_ARG_EFLAGS 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<long, ResourceTag::Flag, Dummy>
        {
 
            typedef enum Flag
            {
                Flags = Pt_ARG_FLAGS, 
                Resiztype = Pt_ARG_RESIZE_FLAGS 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<char*, ResourceTag::String, Dummy>
        {
 
            typedef enum String
            {
                HelpTopic = Pt_ARG_HELP_TOPIC 
 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<void*, ResourceTag::Alloc, Dummy>
        {
 
            typedef enum Alloc
            {
                LayoutData = Pt_ARG_LAYOUT_DATA, 
                Data = Pt_ARG_DATA, 
                UserData = Pt_ARG_USER_DATA 
            } type;
 
 
            typedef enum Pointer
            {
                Pointer = Pt_ARG_POINTER 
            } PointerResource;
        };
 
        template<bool Dummy>
        struct Arguments<PhRect_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                EnchorOffsets = Pt_ARG_ANCHOR_OFFSETS, 
                
                Extent = Pt_ARG_EXTENT 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PgColor_t, ResourceTag::Color, Dummy>
        {
 
            typedef enum Color
            {
                CursorColor = Pt_ARG_CURSOR_COLOR 
            } type;    
        };
 
        template<bool Dummy>
        struct Arguments<PhCursorDef_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                BitmapCursor = Pt_ARG_BITMAP_CURSOR 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PtGridLayoutData_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                GridLayoutData = Pt_ARG_GRID_LAYOUT_DATA 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PhPoint_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                Position = Pt_ARG_POS 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PtRowLayoutData_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                RowLayoutData = Pt_ARG_ROW_LAYOUT_DATA 
            } type;
        };
 
        template<bool Dummy>
        struct Arguments<PhDim_t, ResourceTag::Struct, Dummy>
        {
 
            typedef enum Struct
            {
                Dimension = Pt_ARG_DIM, 
                DimensionMax = Pt_ARG_MAXIMUM_DIM, 
                DimensionMin = Pt_ARG_MINIMUM_DIM 
            } type;
        };
 
        template<class T = void, class Disabled = void, bool Dummy = false>
        struct Callbacks
        {
            typedef Callbacks<> type;
        };
 
        template<class T>
        struct Callbacks<Widget, T>
            : Callbacks<T>
        { };
 
        template<class T, bool Dummy>
        struct Callbacks<T, void, Dummy>
            : Callbacks<T, ResourceTag::Callback, Dummy>
        { };
 
        template<bool Dummy>
        struct Callbacks<PtRawCallback_t, ResourceTag::Callback, Dummy>
        {
 
            typedef enum RawCallback
            {
                Filter = Pt_CB_FILTER, 
 
                Raw = Pt_CB_RAW 
 
            } type;
        };
 
        template<bool Dummy>
        struct Callbacks<PtCallback_t, ResourceTag::Callback, Dummy>
        {
 
            typedef enum Callback
            {
                Blocked = Pt_CB_BLOCKED, 
 
                Destroyed = Pt_CB_DESTROYED, 
 
                DragAndDrop = Pt_CB_DND, 
 
                IsDestroyed = Pt_CB_IS_DESTROYED, 
                Released = IsDestroyed,
 
                Outbound = Pt_CB_OUTBOUND, 
 
                Realized = Pt_CB_REALIZED, 
 
                Unrealized = Pt_CB_UNREALIZED 
            } type;
        };
 
        template<bool Dummy>
        struct Callbacks<PtHotkeyCallback_t, ResourceTag::Callback, Dummy>
        {
 
            typedef enum HotkeyCallback
            {
                
                Hotkey = Pt_CB_HOTKEY
            } type;
        };
 
        template<int TypeID>
        struct Arguments<void, ResourceTypeTag<TypeID>>
            : Arguments<PhArea_t, ResourceTypeTag<__LINE__>>
            , Arguments<unsigned, ResourceTypeTag<__LINE__>>
            , Arguments<unsigned short, ResourceTypeTag<__LINE__>>
            , Arguments<unsigned long, ResourceTypeTag<__LINE__>>
            , Arguments<long, ResourceTypeTag<__LINE__>>
            , Arguments<char*, ResourceTypeTag<__LINE__>>
            , Arguments<void*, ResourceTypeTag<__LINE__>>
            , Arguments<PhRect_t, ResourceTypeTag<__LINE__>>
            , Arguments<PgColor_t, ResourceTypeTag<__LINE__>>
            , Arguments<PhCursorDef_t, ResourceTypeTag<__LINE__>>
            , Arguments<PtGridLayoutData_t, ResourceTypeTag<__LINE__>>
            , Arguments<PhPoint_t, ResourceTypeTag<__LINE__>>
            , Arguments<PtRowLayoutData_t, ResourceTypeTag<__LINE__>>
            , Arguments<PhDim_t, ResourceTypeTag<__LINE__>>
        { };
 
        template<bool Dummy>
        struct Callbacks<void, void, Dummy>
            : Callbacks<PtRawCallback_t>
            , Callbacks<PtCallback_t>
            , Callbacks<PtHotkeyCallback_t>
        { };
 
        struct Flags
        {
            struct Cursor
            {
 
                enum type
                {
                    Inherit = Ph_CURSOR_INHERIT, 
 
                    BitmapNoInherit = Ph_CURSOR_BITMAP,    
 
                    BitmapInherit = Ph_CURSOR_BITMAP & ~Ph_CURSOR_NO_INHERIT,    
 
                    Bitmap = BitmapNoInherit 
 
                };
            };
 
            struct Extended
            {
 
                enum type
                {
                    ConsumeEvents = Pt_CONSUME_EVENTS,
 
                    InternalHelp = Pt_INTERNAL_HELP, 
                    //damage_parent = Pt_DAMAGE_PARENT, //!< If the widget is damaged for any reason, damage its parent instead (internal use only). 
                    SkipLayout = Pt_SKIP_LAYOUT 
                };
            };
            
            struct Anchor:
                public AnchorStyles
            {};
 
            struct Resize
            {
 
                enum type
                {
                    None = 0,
                    ResizeX_asRequired = Pt_RESIZE_X_AS_REQUIRED,
                    ResizeX_always = Pt_RESIZE_X_ALWAYS,
                    ResizeX_initial = Pt_RESIZE_X_INITIAL,
                    ResizeX_bits = Pt_RESIZE_X_BITS,
                    ResizeY_asRequired = Pt_RESIZE_Y_AS_REQUIRED,
                    ResizeY_always = Pt_RESIZE_Y_ALWAYS,
                    ResizeY_initial = Pt_RESIZE_Y_INITIAL,
                    ResizeY_bits = Pt_RESIZE_Y_BITS,
                    ResizeXY_asRequired = Pt_RESIZE_XY_ALWAYS,
                    ResizeXY_always = Pt_RESIZE_XY_AS_REQUIRED,
                    ResizeXY_initial = Pt_RESIZE_XY_INITIAL,
                    ResizeXY_bits = Pt_RESIZE_XY_BITS
 
                };
            };
 
 
            enum type
            {
                AllButtons = Pt_ALL_BUTTONS, 
                Autohighlight = Pt_AUTOHIGHLIGHT, 
                Blocked = Pt_BLOCKED, 
 
                CallbacksActive = Pt_CALLBACKS_ACTIVE,
 
                Clear = Pt_CLEAR, 
                ClipHighlight = Pt_CLIP_HIGHLIGHT, 
                Damaged = Pt_DAMAGED, 
                DamageFamily = Pt_DAMAGE_FAMILY, 
                DelayRealize = Pt_DELAY_REALIZE, 
                Destroyed = Pt_DESTROYED, 
                FocusRender = Pt_FOCUS_RENDER, 
                GetsFocus = Pt_GETS_FOCUS, 
                Ghost = Pt_GHOST, 
                Highlighted = Pt_HIGHLIGHTED, 
                InFlux = Pt_IN_FLUX, 
                Menuable = Pt_MENUABLE, 
                MenuButton = Pt_MENU_BUTTON, 
                Obscured = Pt_OBSCURED, 
                Opaque = Pt_OPAQUE, 
                Procreated = Pt_PROCREATED, 
                Realized = Pt_REALIZED, 
                Realizing = Pt_REALIZING, 
                Region = Pt_REGION, 
                Selectable = Pt_SELECTABLE, 
                SelectNoredraw = Pt_SELECT_NOREDRAW, 
                Set = Pt_SET, 
 
                Toggle = Pt_TOGGLE, 
    
                WidgetRebuild = Pt_WIDGET_REBUILD, 
                WidgetResize = Pt_WIDGET_RESIZE 
            };
 
        };
 
 
                
    private:
    
        int _abn;
        mutable PtWidget_t *_widget;
        
        using IPhWidgetsProperty::setArgument;
        using IPhWidgetsProperty::getArgument;
        
    protected:
 
        typedef ResourceFrom<>::
            Define::String<Arguments<char*>::String>::
            Define::Alloc<Arguments<void*>::Alloc>::
            Define::Pointer<Arguments<void*>::PointerResource>::
            Define::Color<Arguments<PgColor_t>::Color>::
            Define::Struct<Arguments<PhCursorDef_t>::Struct, PhCursorDef_t>::
            Define::Struct<Arguments<PtGridLayoutData_t>::Struct, PtGridLayoutData_t>::
            Define::Struct<Arguments<PhPoint_t>::Struct, PhPoint_t>::
            Define::Struct<Arguments<PtRowLayoutData_t>::Struct, PtRowLayoutData_t>::
            Define::Struct<Arguments<PhArea_t>::Struct, PhArea_t>::
            Define::Struct<Arguments<PhRect_t>::Struct, PhRect_t>::
            Define::Scalar<Arguments<unsigned short>::Scalar, unsigned short>::
            Define::Struct<Arguments<PhDim_t>::Struct, PhDim_t>::
            Define::Flag<Arguments<long>::Flag, long>::
            Define::Flag<Arguments<unsigned long>::Flag, unsigned long>::
            Define::Flag<Arguments<unsigned>::Flag, unsigned>::
 
            Define::Link<Callbacks<PtCallback_t>::type, PtCallback_t*>::
            //Define::Link<RawCallback::eRawCallback, `PtRawCallback_t`*>::
            //Define::Link<HotkeyCallback::eHotkeyCallback, `PtHotkeyCallback_t`*>::
 
        resource_type WidgetResourcesSingleton;
    
        virtual PtWidget_t *widget() const;
        virtual void check();
        
        //for properties:
        
        void setAllowDrop(bool);
        bool getAllowDrop() const;
 
        void setEnabled(bool);
        bool getEnabled() const;
 
        void setHelpTopic(std::string);
        std::string getHelpTopic() const;
 
        void setLocation(PhPoint_t);
        PhPoint_t getLocation() const;
 
        void setBounds(PhArea_t);
        PhArea_t getBounds() const;
 
        short getBottom() const;
 
        void setCursor(PhWidgets::Cursor);
        PhWidgets::Cursor getCursor() const;
 
        bool getCanFocus() const;
 
        bool getCanSelect() const;
 
        bool getContainsFocus() const;
 
        bool getFocused() const;
 
        bool hasChildren() const;
        bool hasParent() const;
 
        void setLeft(short);
        short getLeft() const;
 
        void setTag(const void*, std::size_t);
        const void * getTag() const;
 
        void setTop(short);
        short getTop() const;
 
        short getRight() const;
 
        void setVisible(bool);
        bool getVisible() const;
 
        bool getIsRealized() const;
 
        void setParent(PtWidget_t*);
        PtWidget_t* getParent() const;
 
        std::set<Widget> getWidgets() const;
                        
    public:
 
        explicit Widget(int abn);
 
 
        explicit Widget(PtWidget_t *wdg);
 
 
        Widget(const Widget &other);
 
 
        void swap(Widget &other);
        
 
        Widget &operator=(const Widget &other);
 
 
        Widget &operator=(PtWidget_t *wdg);
 
 
        bool operator==(const Widget &other) const;
 
 
        bool operator!=(const Widget &other) const;
 
 
        bool operator<(const Widget &other) const;
 
 
        bool operator<=(const Widget &other) const;
 
 
        bool operator>(const Widget &other) const;
 
 
        bool operator>=(const Widget &other) const;
 
        PtWidget_t* get() const;
        
        operator PtWidget_t*();
 
        operator const PtWidget_t*() const;
 
 
        void BringToFront();
 
 
        bool Contains(const Widget &widget);
 
 
        bool Focus();
 
 
        Widget GetNextWidget(const Widget &widget, bool forward = true) const;
 
 
        void Hide();
 
 
        void Invalidate(PhRect_t rc, bool invalidateChildren = false);
 
 
        void Invalidate(bool invalidateChildren = false);
 
 
        bool Realize();
 
 
        void Refresh();
 
 
        void SendToBack();
 
 
        void SetBounds(short x, short y, unsigned short width, unsigned short height);
 
 
        void SetBounds(short x, short y);
 
 
        void Select();
 
 
        void Show();
 
 
        bool Unrealize();
 
 
        static void Update();
 
 
        WidgetResourcesSingleton resource;
 
 
 
        property<bool>::bind<Widget, &Widget::getAllowDrop, &Widget::setAllowDrop> AllowDrop;
        
 
        phbitmask<unsigned, Flags::Anchor::type, Flags::Anchor::All>::
            bind<Widget, Arguments<unsigned>::Flag, Arguments<unsigned>::AnchorFlags> Anchor;
 
 
        phproperty<unsigned short>::bind<Widget, Arguments<unsigned short>::Scalar, Arguments<unsigned short>::BevelWidth>    BevelWidth; 
        
 
        property<short, property<>::ro>::bind<Widget, &Widget::getBottom> Bottom;
        
 
        property<PhArea_t>::bind<Widget, &Widget::getBounds, &Widget::setBounds> Bounds;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::getCanFocus> CanFocus;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::getCanSelect> CanSelect;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::getContainsFocus> ContainsFocus;
 
 
        property<PhWidgets::Cursor>::bind<Widget, &Widget::getCursor, &Widget::setCursor> Cursor;
 
 
        phproperty<Drawing::Color>::bind<Widget, Arguments<PgColor_t>::Color, Arguments<PgColor_t>::CursorColor> CursorColor;
 
 
        property<bool>::bind<Widget, &Widget::getEnabled, &Widget::setEnabled> Enabled;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::getFocused> Focused;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::hasChildren> HasChildren;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::hasParent> HasParent;
 
 
        phproperty<unsigned short>::bind<Widget, Arguments<unsigned short>::Scalar, Arguments<unsigned short>::Height> Height;
 
 
        property<std::string>::bind<Widget, &Widget::getHelpTopic, &Widget::setHelpTopic> HelpTopic;
 
 
        property<bool, property<>::ro>::bind<Widget, &Widget::getIsRealized> IsRealized;
 
 
        property<short>::bind<Widget, &Widget::getLeft, &Widget::setLeft> Left;
 
 
        property<PhPoint_t>::bind<Widget, &Widget::getLocation, &Widget::setLocation> Location;
 
 
        property<PtWidget_t*>::bind<Widget, &Widget::getParent, &Widget::setParent> Parent;
 
 
        phproperty<PhPoint_t>::bind<Widget, Arguments<PhPoint_t>::Struct, Arguments<PhPoint_t>::Position> Position;
 
 
 
        property<short, property<>::ro>::bind<Widget, &Widget::getRight> Right;
 
 
        phproperty<PhDim_t>::bind<Widget, Arguments<PhDim_t>::Struct, Arguments<PhDim_t>::Dimension> Size;
        
 
        tag_property<Widget, &Widget::getTag, &Widget::setTag> Tag;
 
 
        property<short>::bind<Widget, &Widget::getTop, &Widget::setTop> Top;
 
 
        property<bool>::bind<Widget, &Widget::getVisible, &Widget::setVisible> Visible;
 
 
        property<std::set<PhWidgets::Widget>, property<>::ro>::bind<Widget, &Widget::getWidgets> Widgets;
 
 
        phproperty<unsigned short>::bind<Widget, Arguments<unsigned short>::Scalar, Arguments<unsigned short>::Width> Width;
 
        phbitmask<unsigned long, Flags::Extended::type>::
            bind<Widget, Arguments<unsigned long>::Flag, Arguments<unsigned long>::ExtendedFlags>    ExtendedFlags; 
 
 
        phbitmask<long, Flags::type>::
            bind<Widget, Arguments<long>::Flag, Arguments<long>::Flags> WidgetFlags;
 
        phbitmask<long, Flags::Resize::type>::
            bind<Widget, Arguments<long>::Flag, Arguments<long>::Resiztype> Resiztype; 
 
 
        phwidgets_event<Widget, Widget::Callbacks<>::Destroyed>      Destroyed; 
        phwidgets_event<Widget, Widget::Callbacks<>::Blocked>        Blocked; 
        phwidgets_event<Widget, Widget::Callbacks<>::DragAndDrop>    DragDrop; 
        phwidgets_event<Widget, Widget::Callbacks<>::IsDestroyed>    IsDestroyed; 
        phwidgets_event<Widget, Widget::Callbacks<>::Outbound>       Outbound; 
        phwidgets_event<Widget, Widget::Callbacks<>::Realized>       Realized; 
        phwidgets_event<Widget, Widget::Callbacks<>::Unrealized>     Unrealized; 
 
 
        void OnDestroyed(PtCallbackInfo_t *info); 
        void OnBlocked(PtCallbackInfo_t *info); 
        void OnDragDrop(PtCallbackInfo_t *info); 
        void OnOutbound(PtCallbackInfo_t *info); 
        void OnRealized(PtCallbackInfo_t *info); 
        void OnUnrealized(PtCallbackInfo_t *info); 
 
        
 
    };
 
 
#ifdef __DOXYGEN__ // ugly hack for Doxygen docs
    template<class WidgetT>
    PtWidget_t* dynamic_widget_cast(const Widget &widget);
#else
    template<class WidgetT>
    inline
    PtWidget_t* dynamic_widget_cast(
        typename
        stdex::enable_if<
            cppproperties::detail::is_convertable<
                typename stdex::remove_cv<WidgetT>::type, 
                Widget&
            >::value,
            const Widget&
        >::type widget) throw()
    try
    {
        WidgetT result = widget;
        return result;
    }
    catch(const std::exception&)
    {
        return nullptr;
    }
#endif
 
    namespace typedefs
    {
        typedef
        cppbitmasks::bitmask<
            unsigned, 
            PhWidgets::Widget::Flags::Anchor::type,
            PhWidgets::Widget::Flags::Anchor::All
        >
        anchor_flags_bitmask;
    }
} // namespace PhWidgets
 
 
 
cppbitmasks::bitmask<unsigned long, PhWidgets::Widget::Flags::Extended::type> operator|(const PhWidgets::Widget::Flags::Extended::type &flag1, const PhWidgets::Widget::Flags::Extended::type &flag2);
cppbitmasks::bitmask<unsigned long, PhWidgets::Widget::Flags::Extended::type> operator&(const PhWidgets::Widget::Flags::Extended::type &flag1, const PhWidgets::Widget::Flags::Extended::type &flag2);
cppbitmasks::bitmask<unsigned long, PhWidgets::Widget::Flags::Extended::type> operator^(const PhWidgets::Widget::Flags::Extended::type &flag1, const PhWidgets::Widget::Flags::Extended::type &flag2);
 
cppbitmasks::bitmask<long, PhWidgets::Widget::Flags::type> operator|(const PhWidgets::Widget::Flags::type &flag1, const PhWidgets::Widget::Flags::type &flag2);
cppbitmasks::bitmask<long, PhWidgets::Widget::Flags::type> operator&(const PhWidgets::Widget::Flags::type &flag1, const PhWidgets::Widget::Flags::type &flag2);
cppbitmasks::bitmask<long, PhWidgets::Widget::Flags::type> operator^(const PhWidgets::Widget::Flags::type &flag1, const PhWidgets::Widget::Flags::type &flag2);
 
cppbitmasks::bitmask<long, PhWidgets::Widget::Flags::Resize::type> operator|(const PhWidgets::Widget::Flags::Resize::type &flag1, const PhWidgets::Widget::Flags::Resize::type &flag2);
cppbitmasks::bitmask<long, PhWidgets::Widget::Flags::Resize::type> operator&(const PhWidgets::Widget::Flags::Resize::type &flag1, const PhWidgets::Widget::Flags::Resize::type &flag2);
cppbitmasks::bitmask<long, PhWidgets::Widget::Flags::Resize::type> operator^(const PhWidgets::Widget::Flags::Resize::type &flag1, const PhWidgets::Widget::Flags::Resize::type &flag2);
 
PhWidgets::typedefs::anchor_flags_bitmask operator|(const PhWidgets::Widget::Flags::Anchor::type &flag1, const PhWidgets::Widget::Flags::Anchor::type &flag2);
PhWidgets::typedefs::anchor_flags_bitmask operator&(const PhWidgets::Widget::Flags::Anchor::type &flag1, const PhWidgets::Widget::Flags::Anchor::type &flag2);
PhWidgets::typedefs::anchor_flags_bitmask operator^(const PhWidgets::Widget::Flags::Anchor::type &flag1, const PhWidgets::Widget::Flags::Anchor::type &flag2);
 
bool operator==(const PhArea_t &lhs, const PhArea_t &rhs);
bool operator!=(const PhArea_t &lhs, const PhArea_t &rhs);
 
#endif // PHWIDGETS_WIDGET_H