DataBinding.h

#pragma once
 
#include "FrameworkElement.h"
 
namespace sw
{
    class DataBinding final : public BindingBase
    {
    private:
        FrameworkElement *_targetElement;
 
        std::unique_ptr<Binding> _innerBinding;
 
    private:
        DataBinding(FrameworkElement *targetElement, Binding *binding)
            : _targetElement(targetElement), _innerBinding(binding)
        {
            UpdateDataContextBinding();
            RegisterNotifications();
        }
 
    public:
        virtual ~DataBinding()
        {
            UnregisterNotifications();
        }
 
        virtual bool UpdateTarget() override
        {
            return _innerBinding->UpdateTarget();
        }
 
        virtual bool UpdateSource() override
        {
            return _innerBinding->UpdateSource();
        }
 
        virtual FieldId GetTargetPropertyId() const override
        {
            return _innerBinding->GetTargetPropertyId();
        }
 
        virtual FieldId GetSourcePropertyId() const override
        {
            return _innerBinding->GetSourcePropertyId();
        }
 
        FrameworkElement *GetTargetElement() const
        {
            return _targetElement;
        }
 
        void SetTargetElement(FrameworkElement *element)
        {
            if (_targetElement != element) {
                UnregisterNotifications();
                _targetElement = element;
                UpdateDataContextBinding();
                RegisterNotifications();
            }
        }
 
    private:
        void RegisterNotifications()
        {
            if (_targetElement == nullptr) {
                return;
            }
 
            _targetElement->ObjectDead +=
                ObjectDeadEventHandler(*this, &DataBinding::OnTargetElementDead);
 
            _targetElement->DataContextChanged +=
                DataContextChangedEventHandler(*this, &DataBinding::OnTargetElementDataContextChanged);
        }
 
        void UnregisterNotifications()
        {
            if (_targetElement == nullptr) {
                return;
            }
 
            _targetElement->ObjectDead -=
                ObjectDeadEventHandler(*this, &DataBinding::OnTargetElementDead);
 
            _targetElement->DataContextChanged -=
                DataContextChangedEventHandler(*this, &DataBinding::OnTargetElementDataContextChanged);
        }
 
        void UpdateDataContextBinding()
        {
            if (_targetElement == nullptr) {
                _innerBinding->SetBindingObjects(nullptr, nullptr);
            } else {
                _innerBinding->SetBindingObjects(_targetElement, _targetElement->CurrentDataContext);
            }
        }
 
        void OnTargetElementDead(INotifyObjectDead &sender, EventArgs &e)
        {
            SetTargetElement(nullptr);
        }
 
        void OnTargetElementDataContextChanged(FrameworkElement &sender, DataContextChangedEventArgs &e)
        {
            UpdateDataContextBinding();
        }
 
    public:
        static DataBinding *Create(FrameworkElement *targetElement, Binding *binding)
        {
            assert(binding != nullptr);
            return new DataBinding(targetElement, binding);
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(TTargetProperty TTargetObject::*targetProperty,
                           TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter = nullptr)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                DataBinding *>::type
        {
            return new DataBinding(nullptr, Binding::Create(targetProperty, sourceProperty, mode, converter));
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(TTargetProperty TTargetObject::*targetProperty,
                           TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    !std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                DataBinding *>::type
        {
            return new DataBinding(nullptr, Binding::Create(targetProperty, sourceProperty, mode, converter));
        }
    };
}