RoutedEventArgs.h

#pragma once
 
#include "Keys.h"
#include "Point.h"
#include "RoutedEvent.h"
#include "ScrollEnums.h"
#include "Size.h"
#include <type_traits>
 
namespace sw
{
    template <RoutedEventType Type, typename TBase = RoutedEventArgs>
    class TypedRoutedEventArgs : public TBase
    {
        // TBase必须派生自RoutedEventArgs
        static_assert(
            std::is_base_of<RoutedEventArgs, TBase>::value,
            "TBase must be derived from RoutedEventArgs.");
 
    public:
        static constexpr RoutedEventType EventType = Type;
 
        TypedRoutedEventArgs()
        { this->eventType = EventType; }
    };
 
    /*================================================================================*/
 
    template <typename T, typename = void>
    struct _HasEventType : std::false_type {
    };
 
    template <typename T>
    struct _HasEventType<T, decltype(void(T::EventType))> : std::true_type {
    };
 
    template <typename T>
    struct _IsTypedRoutedEventArgs : _HasEventType<T> {
    };
 
    /*================================================================================*/
 
    class SizeChangedEventArgs : public TypedRoutedEventArgs<UIElement_SizeChanged>
    {
    public:
        Size newClientSize;
 
        SizeChangedEventArgs(Size newClientSize) : newClientSize(newClientSize)
        {
        }
    };
 
    class PositionChangedEventArgs : public TypedRoutedEventArgs<UIElement_PositionChanged>
    {
    public:
        Point newClientPosition;
 
        PositionChangedEventArgs(Point newClientPosition) : newClientPosition(newClientPosition)
        {
        }
    };
 
    class GotCharEventArgs : public TypedRoutedEventArgs<UIElement_GotChar>
    {
    public:
        wchar_t ch;
 
        KeyFlags flags;
 
        GotCharEventArgs(wchar_t ch, KeyFlags flags) : ch(ch), flags(flags)
        {
        }
    };
 
    template <RoutedEventType Type>
    class KeyEventArgs : public TypedRoutedEventArgs<Type>
    {
    public:
        VirtualKey key;
 
        KeyFlags flags;
 
        KeyEventArgs(VirtualKey key, KeyFlags flags) : key(key), flags(flags)
        {
        }
    };
 
    class KeyDownEventArgs : public KeyEventArgs<UIElement_KeyDown>
    {
    public:
        using KeyEventArgs<UIElement_KeyDown>::KeyEventArgs;
    };
 
    class KeyUpEventArgs : public KeyEventArgs<UIElement_KeyUp>
    {
    public:
        using KeyEventArgs<UIElement_KeyUp>::KeyEventArgs;
    };
 
    template <RoutedEventType Type>
    class MouseEventArgs : public TypedRoutedEventArgs<Type>
    {
    public:
        Point mousePosition;
 
        MouseKey keyState;
 
        MouseEventArgs(Point mousePosition, MouseKey keyState)
            : mousePosition(mousePosition), keyState(keyState)
        {
        }
    };
 
    class MouseMoveEventArgs : public MouseEventArgs<UIElement_MouseMove>
    {
    public:
        using MouseEventArgs<UIElement_MouseMove>::MouseEventArgs;
    };
 
    class MouseWheelEventArgs : public MouseEventArgs<UIElement_MouseWheel>
    {
    public:
        int wheelDelta;
 
        MouseWheelEventArgs(int wheelDelta, Point mousePosition, MouseKey keyState)
            : MouseEventArgs<UIElement_MouseWheel>(mousePosition, keyState), wheelDelta(wheelDelta)
        {
        }
    };
 
    template <RoutedEventType Type>
    class MouseButtonEventArgs : public MouseEventArgs<Type>
    {
    public:
        MouseKey key;
 
        MouseButtonEventArgs(MouseKey key, Point mousePosition, MouseKey keyState)
            : MouseEventArgs<Type>(mousePosition, keyState), key(key)
        {
        }
    };
 
    class MouseButtonDownEventArgs : public MouseButtonEventArgs<UIElement_MouseButtonDown>
    {
    public:
        using MouseButtonEventArgs<UIElement_MouseButtonDown>::MouseButtonEventArgs;
    };
 
    class MouseButtonUpEventArgs : public MouseButtonEventArgs<UIElement_MouseButtonUp>
    {
    public:
        using MouseButtonEventArgs<UIElement_MouseButtonUp>::MouseButtonEventArgs;
    };
 
    class CancelableEventArgs : public RoutedEventArgs
    {
    public:
        bool cancel = false;
    };
 
    class ShowContextMenuEventArgs : public TypedRoutedEventArgs<UIElement_ShowContextMenu, CancelableEventArgs>
    {
    public:
        bool isKeyboardMsg;
 
        Point mousePosition;
 
        ShowContextMenuEventArgs(bool isKeyboardMsg, Point mousePosition)
            : isKeyboardMsg(isKeyboardMsg), mousePosition(mousePosition)
        {
        }
    };
 
    class DropFilesEventArgs : public TypedRoutedEventArgs<UIElement_DropFiles>
    {
    public:
        HDROP hDrop;
 
        DropFilesEventArgs(HDROP hDrop) : hDrop(hDrop)
        {
        }
    };
 
    class WindowClosingEventArgs : public TypedRoutedEventArgs<Window_Closing, CancelableEventArgs>
    {
    };
 
    class ScrollingEventArgs : public TypedRoutedEventArgs<Layer_Scrolling, CancelableEventArgs>
    {
    public:
        ScrollOrientation scrollbar;
 
        ScrollEvent event;
 
        double pos;
 
        ScrollingEventArgs(ScrollOrientation scrollbar, ScrollEvent event, double pos)
            : scrollbar(scrollbar), event(event), pos(pos)
        {
        }
    };
 
    template <RoutedEventType Type, typename TBase = RoutedEventArgs>
    class ListViewItemEventArgs : public TypedRoutedEventArgs<Type, TBase>
    {
    public:
        int index;
 
        ListViewItemEventArgs(int index) : index(index)
        {
        }
    };
 
    template <RoutedEventType Type, typename TBase = RoutedEventArgs>
    class ListViewSubItemEventArgs : public ListViewItemEventArgs<Type, TBase>
    {
    public:
        int subIndex;
 
        ListViewSubItemEventArgs(int index, int subIndex)
            : ListViewItemEventArgs<Type, TBase>(index), subIndex(subIndex)
        {
        }
    };
 
    class ListViewCheckStateChangedEventArgs : public ListViewItemEventArgs<ListView_CheckStateChanged>
    {
    public:
        using ListViewItemEventArgs<ListView_CheckStateChanged>::ListViewItemEventArgs;
    };
 
    class ListViewHeaderClickedEventArgs : public ListViewItemEventArgs<ListView_HeaderClicked>
    {
    public:
        using ListViewItemEventArgs<ListView_HeaderClicked>::ListViewItemEventArgs;
    };
 
    class ListViewHeaderDoubleClickedEventArgs : public ListViewItemEventArgs<ListView_HeaderDoubleClicked>
    {
    public:
        using ListViewItemEventArgs<ListView_HeaderDoubleClicked>::ListViewItemEventArgs;
    };
 
    class ListViewItemClickedEventArgs : public ListViewSubItemEventArgs<ListView_ItemClicked>
    {
    public:
        using ListViewSubItemEventArgs<ListView_ItemClicked>::ListViewSubItemEventArgs;
    };
 
    class ListViewItemDoubleClickedEventArgs : public ListViewSubItemEventArgs<ListView_ItemDoubleClicked>
    {
    public:
        using ListViewSubItemEventArgs<ListView_ItemDoubleClicked>::ListViewSubItemEventArgs;
    };
 
    class ListViewEndEditEventArgs : public ListViewItemEventArgs<ListView_EndEdit, CancelableEventArgs>
    {
    public:
        std::wstring newText;
 
        ListViewEndEditEventArgs(int index, const std::wstring &newText)
            : ListViewItemEventArgs<ListView_EndEdit, CancelableEventArgs>(index), newText(newText)
        {
        }
    };
 
    template <RoutedEventType Type>
    class TimeChangedEventArgs : public TypedRoutedEventArgs<Type>
    {
    public:
        SYSTEMTIME time;
 
        TimeChangedEventArgs(const SYSTEMTIME &time) : time(time)
        {
        }
    };
 
    class DateTimePickerTimeChangedEventArgs : public TimeChangedEventArgs<DateTimePicker_TimeChanged>
    {
    public:
        using TimeChangedEventArgs<DateTimePicker_TimeChanged>::TimeChangedEventArgs;
    };
 
    class MonthCalendarTimeChangedEventArgs : public TimeChangedEventArgs<MonthCalendar_TimeChanged>
    {
    public:
        using TimeChangedEventArgs<MonthCalendar_TimeChanged>::TimeChangedEventArgs;
    };
 
    class SysLinkClickedEventArgs : public TypedRoutedEventArgs<SysLink_Clicked>
    {
    public:
        std::wstring id;
 
        std::wstring url;
 
        SysLinkClickedEventArgs(const std::wstring &id, const std::wstring &url) : id(id), url(url)
        {
        }
    };
 
    class HotKeyValueChangedEventArgs : public TypedRoutedEventArgs<HotKeyControl_ValueChanged>
    {
    public:
        VirtualKey key;
 
        HotKeyModifier modifier;
 
        HotKeyValueChangedEventArgs(VirtualKey key, HotKeyModifier modifier) : key(key), modifier(modifier)
        {
        }
    };
 
    class SplitButtonDropDownEventArgs : public TypedRoutedEventArgs<SplitButton_DropDown, CancelableEventArgs>
    {
    };
}