C++ 2D библиотека составления мозаики?

Вы можете использовать мой CommandParameterBehavior, что я отправил на форумы Призмы вчера. Это добавляет недостающее поведение, где изменение в эти CommandParameter заставляет Command быть повторно запрошенным.

существует некоторая сложность, здесь вызванная моими попытками избежать утечки памяти, вызванной, если Вы звоните PropertyDescriptor.AddValueChanged без более позднего вызова PropertyDescriptor.RemoveValueChanged. Я пытаюсь зафиксировать это путем нерегистрации обработчика, когда элемент разгружен.

необходимо будет, вероятно, удалить эти IDelegateCommand материал, если Вы не будете использовать Призму (и хотят внести те же изменения как я к библиотеке Prism). Также обратите внимание, что мы обычно не используем RoutedCommand с здесь (мы используем Призму DelegateCommand для в значительной степени всего), поэтому не держите меня ответственный, если мой вызов к CommandManager.InvalidateRequerySuggested выделяет своего рода квант wavefuntion каскад коллапса, который уничтожает известную вселенную или что-либо.

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;

namespace Microsoft.Practices.Composite.Wpf.Commands
{
    /// 

    /// This class provides an attached property that, when set to true, will cause changes to the element's CommandParameter to 
    /// trigger the CanExecute handler to be called on the Command.
    /// 
    public static class CommandParameterBehavior
    {
        /// 

        /// Identifies the IsCommandRequeriedOnChange attached property
        /// 
        /// 
        /// When a control has the 
        /// attached property set to true, then any change to it's 
        ///  property will cause the state of
        /// the command attached to it's  property to 
        /// be reevaluated.
        /// 
        public static readonly DependencyProperty IsCommandRequeriedOnChangeProperty =
            DependencyProperty.RegisterAttached("IsCommandRequeriedOnChange",
                                                typeof(bool),
                                                typeof(CommandParameterBehavior),
                                                new UIPropertyMetadata(false, new PropertyChangedCallback(OnIsCommandRequeriedOnChangeChanged)));

        /// 

        /// Gets the value for the  attached property.
        /// 
        /// The object to adapt.
        /// Whether the update on change behavior is enabled.
        public static bool GetIsCommandRequeriedOnChange(DependencyObject target)
        {
            return (bool)target.GetValue(IsCommandRequeriedOnChangeProperty);
        }

        /// 

        /// Sets the  attached property.
        /// 
        /// The object to adapt. This is typically a , 
        ///  or 
        /// Whether the update behaviour should be enabled.
        public static void SetIsCommandRequeriedOnChange(DependencyObject target, bool value)
        {
            target.SetValue(IsCommandRequeriedOnChangeProperty, value);
        }

        private static void OnIsCommandRequeriedOnChangeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!(d is ICommandSource))
                return;

            if (!(d is FrameworkElement || d is FrameworkContentElement))
                return;

            if ((bool)e.NewValue)
            {
                HookCommandParameterChanged(d);
            }
            else
            {
                UnhookCommandParameterChanged(d);
            }

            UpdateCommandState(d);
        }

        private static PropertyDescriptor GetCommandParameterPropertyDescriptor(object source)
        {
            return TypeDescriptor.GetProperties(source.GetType())["CommandParameter"];
        }

        private static void HookCommandParameterChanged(object source)
        {
            var propertyDescriptor = GetCommandParameterPropertyDescriptor(source);
            propertyDescriptor.AddValueChanged(source, OnCommandParameterChanged);

            // N.B. Using PropertyDescriptor.AddValueChanged will cause "source" to never be garbage collected,
            // so we need to hook the Unloaded event and call RemoveValueChanged there.
            HookUnloaded(source);
        }

        private static void UnhookCommandParameterChanged(object source)
        {
            var propertyDescriptor = GetCommandParameterPropertyDescriptor(source);
            propertyDescriptor.RemoveValueChanged(source, OnCommandParameterChanged);

            UnhookUnloaded(source);
        }

        private static void HookUnloaded(object source)
        {
            var fe = source as FrameworkElement;
            if (fe != null)
            {
                fe.Unloaded += OnUnloaded;
            }

            var fce = source as FrameworkContentElement;
            if (fce != null)
            {
                fce.Unloaded += OnUnloaded;
            }
        }

        private static void UnhookUnloaded(object source)
        {
            var fe = source as FrameworkElement;
            if (fe != null)
            {
                fe.Unloaded -= OnUnloaded;
            }

            var fce = source as FrameworkContentElement;
            if (fce != null)
            {
                fce.Unloaded -= OnUnloaded;
            }
        }

        static void OnUnloaded(object sender, RoutedEventArgs e)
        {
            UnhookCommandParameterChanged(sender);
        }

        static void OnCommandParameterChanged(object sender, EventArgs ea)
        {
            UpdateCommandState(sender);
        }

        private static void UpdateCommandState(object target)
        {
            var commandSource = target as ICommandSource;

            if (commandSource == null)
                return;

            var rc = commandSource.Command as RoutedCommand;
            if (rc != null)
            {
                CommandManager.InvalidateRequerySuggested();
            }

            var dc = commandSource.Command as IDelegateCommand;
            if (dc != null)
            {
                dc.RaiseCanExecuteChanged();
            }

        }
    }
}