public CanvasPositionHandle(DesignItem adornedControlItem, AdornerPanel adornerPanel, HandleOrientation orientation)
{
Debug.Assert(adornedControlItem != null);
this.adornedControlItem = adornedControlItem;
this.adornerPanel = adornerPanel;
this.orientation = orientation;
Angle = (double) orientation;
canvas = (Canvas) adornedControlItem.Parent.Component;
adornedControl = (FrameworkElement) adornedControlItem.Component;
Stub = new MarginStub(this);
ShouldBeVisible = true;
leftDescriptor = DependencyPropertyDescriptor.FromProperty(Canvas.LeftProperty,
adornedControlItem.Component.GetType());
leftDescriptor.AddValueChanged(adornedControl, OnPropertyChanged);
rightDescriptor = DependencyPropertyDescriptor.FromProperty(Canvas.RightProperty,
adornedControlItem.Component.GetType());
rightDescriptor.AddValueChanged(adornedControl, OnPropertyChanged);
topDescriptor = DependencyPropertyDescriptor.FromProperty(Canvas.TopProperty,
adornedControlItem.Component.GetType());
topDescriptor.AddValueChanged(adornedControl, OnPropertyChanged);
bottomDescriptor = DependencyPropertyDescriptor.FromProperty(Canvas.BottomProperty,
adornedControlItem.Component.GetType());
bottomDescriptor.AddValueChanged(adornedControl, OnPropertyChanged);
widthDescriptor = DependencyPropertyDescriptor.FromProperty(Control.WidthProperty,
adornedControlItem.Component.GetType());
widthDescriptor.AddValueChanged(adornedControl, OnPropertyChanged);
heightDescriptor = DependencyPropertyDescriptor.FromProperty(Control.WidthProperty,
adornedControlItem.Component.GetType());
heightDescriptor.AddValueChanged(adornedControl, OnPropertyChanged);
BindAndPlaceHandle();
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableDependencyProperty"/> class.
/// </summary>
/// <param name="targetType">Type of the target</param>
/// <param name="dependencyProperty">Dependency property.</param>
/// <param name="OnDependencyPropertyChanged">Dependency property changed callback</param>
public ObservableDependencyProperty(Type targetType,
DependencyProperty dependencyProperty,
DependencyPropertyChangedEventHandler OnDependencyPropertyChanged)
{
_descriptor = DependencyPropertyDescriptor.FromProperty(dependencyProperty, targetType);
_dependencyProperty = dependencyProperty;
_onDependencyPropertyChanged = OnDependencyPropertyChanged;
}
private void CaptureComponent(TextBox button)
{
dpdWidth = DependencyPropertyDescriptor.FromProperty(TextBox.WidthProperty, typeof(TextBox));
dpdWidth.AddValueChanged(button, OnWidthChanged);
dpdText = DependencyPropertyDescriptor.FromProperty(TextBox.TextProperty, typeof(TextBox));
dpdText.AddValueChanged(button, OnTextChanged);
}
public ObjectTreeViewItem(object containingObject, Type baseType, string header = null)
{
Header = header;
ContainingObject = containingObject;
BaseType = baseType;
_isExpandendDpd = DependencyPropertyDescriptor.FromProperty(TreeViewItem.IsExpandedProperty, GetType());
_isExpandendDpd.AddValueChanged(this, IsExpandendChangedEventHandler);
}
public PenisDragCanvasControl()
{
this.InitializeComponent();
this.vaginaTopImageTopDependencyProperty = DependencyPropertyDescriptor.FromProperty(Canvas.TopProperty, typeof(Canvas));
this.vaginaTopImageLeftDependencyProperty = DependencyPropertyDescriptor.FromProperty(
Canvas.LeftProperty, typeof(Canvas));
this.vaginaTopImageTopDependencyProperty.AddValueChanged(this.VaginaTopImage, new EventHandler(this.VaginaTopImageTopChangedCallback));
this.vaginaTopImageLeftDependencyProperty.AddValueChanged(this.VaginaTopImage, new EventHandler(this.VaginaTopImageLeftChangedCallback));
}
public void Dispose()
{
if (_isExpandendDpd != null)
{
_isExpandendDpd.RemoveValueChanged(this, IsExpandendChangedEventHandler);
_isExpandendDpd = null;
ContainingObject = null;
this.DisposeChildren();
}
}
public static object GetPropertyChangeTracker(object component, DependencyPropertyDescriptor descriptor)
{
var dependencyObjectPropertyDescriptor = descriptor.GetType().GetProperty("Property", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(descriptor);
var trackers = GetTrackersFieldFromDependencyObjectPropertyDescriptor(dependencyObjectPropertyDescriptor);
//var key = DependencyObjectPropertyDescriptor.FromObj( component );
var fromObj = dependencyObjectPropertyDescriptor.GetType().GetMethod("FromObj", BindingFlags.Static | BindingFlags.NonPublic);
var key = fromObj.Invoke(null, new[] { component });
return trackers[key];
}
/// <summary>
/// Initializes a new instance of the <see cref="BindingEditorViewModel"/> class.
/// </summary>
/// <param name="propertyItem">The property item.</param>
public BindingEditorViewModel(PropertyItem propertyItem)
{
_instance = (DependencyObject)propertyItem.Instance;
Sources = new ListCollectionView(Enum.GetValues(typeof(BindingSource)));
Sources.MoveCurrentToFirst();
Sources.CurrentChanged += (s, e) => OnSourceChanged();
Modes = new ListCollectionView(Enum.GetValues(typeof(BindingMode)));
Modes.MoveCurrentToFirst();
Modes.CurrentChanged += (s, e) => UpdateBinding();
UpdateSourceTriggers = new ListCollectionView(Enum.GetValues(typeof (UpdateSourceTrigger)));
UpdateSourceTriggers.MoveCurrentToFirst();
UpdateSourceTriggers.CurrentChanged += (s, e) => UpdateBinding();
SourceList = new ListCollectionView(_pathItems);
BuildSourceTree();
_dpd = DependencyPropertyDescriptor.FromProperty(propertyItem.Property);
_binding = BindingOperations.GetBinding((DependencyObject) propertyItem.Instance, _dpd.DependencyProperty);
if (_binding == null)
{
UpdateBinding();
}
else
{
if( _binding.Source == null )
{
Sources.MoveCurrentTo(BindingSource.DataContext);
}
else if( _binding.RelativeSource != null )
{
if( _binding.RelativeSource.Mode == RelativeSourceMode.PreviousData )
{
Sources.MoveCurrentTo(BindingSource.PreviousData);
}
else if( _binding.RelativeSource.Mode == RelativeSourceMode.TemplatedParent)
{
Sources.MoveCurrentTo(BindingSource.TemplatedParent);
}
else if( _binding.RelativeSource.Mode == RelativeSourceMode.FindAncestor)
{
Sources.MoveCurrentTo(BindingSource.FindAncestor);
}
}
UpdateExpression();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyItem"/> class.
/// </summary>
public PropertyItem(PropertyDescriptor property, object instance)
{
Property = property;
Instance = instance;
ResetCommand = new Command<object>(ResetValue, CanResetValue);
EditBindingCommand = new Command<object>(ShowBindingEditor, o => !property.IsReadOnly);
EditResourceCommand = new Command<object>(ShowResourceEditor, o => !property.IsReadOnly);
_propertySortInfo = PropertySorter.GetSortInfo(property);
_markupObject = MarkupWriter.GetMarkupObjectFor(Instance);
property.AddValueChanged(instance, OnValueChanged);
_dpd = DependencyPropertyDescriptor.FromProperty(property);
}
protected override void OnInitialized()
{
base.OnInitialized();
extendedItemArray[0] = this.ExtendedItem;
this.ExtendedItem.PropertyChanged += OnPropertyChanged;
if (this.ExtendedItem.Properties.GetProperty(FrameworkElement.RenderTransformOriginProperty).IsSet) {
renderTransformOrigin = (Point)this.ExtendedItem.Properties.GetProperty(FrameworkElement.RenderTransformOriginProperty).ValueOnInstance;
}
AdornerPanel.SetPlacement(renderTransformOriginThumb,
new RelativePlacement(HorizontalAlignment.Left, VerticalAlignment.Top){XRelativeToContentWidth = renderTransformOrigin.X, YRelativeToContentHeight = renderTransformOrigin.Y});
renderTransformOriginPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(FrameworkElement.RenderTransformOriginProperty, typeof(FrameworkElement));
renderTransformOriginPropertyDescriptor.AddValueChanged(this.ExtendedItem.Component, OnRenderTransformOriginPropertyChanged);
}
IList <DependencyProperty> GetAttachedProperties(DependencyObject obj)
{
List <DependencyProperty> result = new List <DependencyProperty>();
foreach (System.ComponentModel.PropertyDescriptor pd in System.ComponentModel.TypeDescriptor.GetProperties(obj,
new Attribute[] { new System.ComponentModel.PropertyFilterAttribute(System.ComponentModel.PropertyFilterOptions.All) }))
{
System.ComponentModel.DependencyPropertyDescriptor dpd = System.ComponentModel.DependencyPropertyDescriptor.FromProperty(pd);
if (dpd != null)
{
result.Add(dpd.DependencyProperty);
}
}
return(result);
}
internal void UpdatePositionTraceState()
{
if (EventOptions.PositionChangeNotification)
{
_sxDescriptor = DependencyPropertyDescriptor.FromProperty(GraphAreaBase.XProperty, typeof(VertexControl));
_sxDescriptor.AddValueChanged(this, source_PositionChanged);
_syDescriptor = DependencyPropertyDescriptor.FromProperty(GraphAreaBase.YProperty, typeof(VertexControl));
_syDescriptor.AddValueChanged(this, source_PositionChanged);
}
else
{
if (_sxDescriptor != null)
_sxDescriptor.RemoveValueChanged(this, source_PositionChanged);
if (_syDescriptor != null)
_syDescriptor.RemoveValueChanged(this, source_PositionChanged);
}
}
protected DelayBinding(BindingExpressionBase bindingExpression, DependencyObject bindingTarget, DependencyProperty bindingTargetProperty, TimeSpan delay)
{
_bindingExpression = bindingExpression;
_delay = delay;
// Subscribe to notifications for when the target property changes. This event handler will be
// invoked when the user types, clicks, or anything else which changes the target property
_descriptor = DependencyPropertyDescriptor.FromProperty(bindingTargetProperty, bindingTarget.GetType());
// Add support so that the Enter key causes an immediate commit
bindingTarget.SaftyInvoke<FrameworkElement>(el =>
{
el.Loaded += OnBindingTargetLoaded;
});
// Setup the timer, but it won't be started until changes are detected
_timer = new DispatcherTimer();
_timer.Tick += TimerTick;
_timer.Interval = _delay;
}
static bool GetPropertyDefaultValueAsBool(DependencyPropertyDescriptor dependencyPropertyDescriptor)
{
return (bool)dependencyPropertyDescriptor.Metadata.DefaultValue;
}
static ImageAnimationController()
{
_sourceDescriptor = DependencyPropertyDescriptor.FromProperty(Image.SourceProperty, typeof (Image));
}
//-----------------------------------------------------
//
// Public Methods
//
//-----------------------------------------------------
#region Public Methods
/// <summary>
/// Static method that returns a DependencyPropertyDescriptor from a PropertyDescriptor.
/// </summary>
public static DependencyPropertyDescriptor FromProperty(PropertyDescriptor property)
{
if (property == null) throw new ArgumentNullException("property");
DependencyPropertyDescriptor dpd;
bool found;
lock(_cache)
{
found = _cache.TryGetValue(property, out dpd);
}
if (found)
{
return dpd;
}
// Locate the dependency property. We do this a fast way
// by searching for InternalPropertyDescriptor, and a slow
// way, by looking for an attribute. The fast way works unless
// someone has added another layer of metadata overrides to
// TypeDescriptor.
DependencyProperty dp = null;
bool isAttached = false;
DependencyObjectPropertyDescriptor idpd = property as DependencyObjectPropertyDescriptor;
if (idpd != null)
{
dp = idpd.DependencyProperty;
isAttached = idpd.IsAttached;
}
else
{
#pragma warning suppress 6506 // property is obviously not null
DependencyPropertyAttribute dpa = property.Attributes[typeof(DependencyPropertyAttribute)] as DependencyPropertyAttribute;
if (dpa != null)
{
dp = dpa.DependencyProperty;
isAttached = dpa.IsAttached;
}
}
if (dp != null)
{
dpd = new DependencyPropertyDescriptor(property, property.Name, property.ComponentType, dp, isAttached);
lock(_cache)
{
_cache[property] = dpd;
}
}
return dpd;
}
/// <summary>
/// Static method that returns a DependencyPropertyDescriptor from a DependencyProperty. The
/// DependencyProperty may refer to either a direct or attached property. The targetType is the
/// type of object to associate with the property: either the owner type for a direct property
/// or the type of object to attach to for an attached property.
/// </summary>
public static DependencyPropertyDescriptor FromProperty(DependencyProperty dependencyProperty, Type targetType)
{
if (dependencyProperty == null) throw new ArgumentNullException("dependencyProperty");
if (targetType == null) throw new ArgumentNullException("targetType");
// We have a different codepath here for attached and direct
// properties. For direct properties, we route through Type
// Descriptor because we need the underlying CLR property descriptor
// to create our wrapped property. For attached properties, all we
// need is the dp and the object type and we can create an attached
// property descriptor based on that. We must special case attached
// properties here because TypeDescriptor will only return attached
// properties for instances, not types.
DependencyPropertyDescriptor dpd = null;
DependencyPropertyKind dpKind = DependencyObjectProvider.GetDependencyPropertyKind(dependencyProperty, targetType);
if (dpKind.IsDirect)
{
// For direct properties we don't want to get the property descriptor
// yet because it is very expensive. Delay it until needed.
lock(_cache)
{
_cache.TryGetValue(dependencyProperty, out dpd);
}
if (dpd == null)
{
// Create a new DPD based on the type information we have. It
// will fill in the property descriptor by calling TypeDescriptor
// when needed.
dpd = new DependencyPropertyDescriptor(null, dependencyProperty.Name, targetType, dependencyProperty, false);
lock(_cache)
{
_cache[dependencyProperty] = dpd;
}
}
}
else if (!dpKind.IsInternal)
{
// If it isn't a direct property, we treat it as attached unless it is internal.
// We should never release internal properties to the user
PropertyDescriptor prop = DependencyObjectProvider.GetAttachedPropertyDescriptor(dependencyProperty, targetType);
if (prop != null)
{
dpd = FromProperty(prop);
}
}
return dpd;
}
public void anim2Completed(object sender, EventArgs e)
{
this.Visibility = Visibility.Collapsed;
artmodewin.DockedItems.Remove(this);
item.isDocked = false;
this.IsHitTestVisible = true;
item.MouseMove -= WorkspaceElement_MouseMove;
item.Center = trackedCenter;
item.Height = item.oldHeight;
item.Width = item.oldWidth;
dpd = null;
item.isAnimating = false;
}
private void RegisterEvent()
{
dpdDataContext = DependencyPropertyDescriptor.FromProperty(MaskAttach.DataContextProperty, this.GetType());
dpdDataContext.AddValueChanged(this, DataContextChanged);
dpdTemplate = DependencyPropertyDescriptor.FromProperty(MaskAttach.TemplateProperty, this.GetType());
dpdTemplate.AddValueChanged(this, TemplateChanged);
(_target as FrameworkElement).Loaded -= new RoutedEventHandler(MaskAttach_Loaded);
(_target as FrameworkElement).Unloaded += new RoutedEventHandler(MaskAttach_Unloaded);
}
/// <summary>
/// Create floating window
/// </summary>
/// <param name="pane">Relative pane</param>
public FloatingWindow(DockablePane pane)
{
InitializeComponent();
_isTooltipEnabled = true;
_paneHosted = pane;
Content = _paneHosted;
Title = _paneHosted.PaneContent.Title;
// add code to update window header.
_dpDescriptor = DependencyPropertyDescriptor.FromProperty(Window.TitleProperty, typeof(Window));
if (_dpDescriptor != null)
_dpDescriptor.AddValueChanged(_paneHosted.PaneContent, delegate
{
if (Content != null)
Title = ((DockablePane)Content).PaneContent.Title;
});
_paneHosted.PaneContent.DockManager.RegisterFloatingWnd(this);
}
/// <summary>
/// Subscribe to Datacontrol ItemsSource changes
/// </summary>
private void Subscribe()
{
_sourcePropertyDescriptor = DependencyPropertyDescriptor.FromProperty(ItemsSourceProperty,
typeof (ItemsControl));
_sourcePropertyDescriptor.AddValueChanged(DataControl, SourceChanged);
}
/// <summary>
/// Static method that returns a DependencyPropertyDescriptor from a DependencyProperty. The
/// DependencyProperty may refer to either a direct or attached property. The targetType is the
/// type of object to associate with the property: either the owner type for a direct property
/// or the type of object to attach to for an attached property.
/// </summary>
public static DependencyPropertyDescriptor FromProperty(DependencyProperty dependencyProperty, Type targetType)
{
if (dependencyProperty == null)
{
throw new ArgumentNullException("dependencyProperty");
}
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
// We have a different codepath here for attached and direct
// properties. For direct properties, we route through Type
// Descriptor because we need the underlying CLR property descriptor
// to create our wrapped property. For attached properties, all we
// need is the dp and the object type and we can create an attached
// property descriptor based on that. We must special case attached
// properties here because TypeDescriptor will only return attached
// properties for instances, not types.
DependencyPropertyDescriptor dpd = null;
DependencyPropertyKind dpKind = DependencyObjectProvider.GetDependencyPropertyKind(dependencyProperty, targetType);
if (dpKind.IsDirect)
{
// For direct properties we don't want to get the property descriptor
// yet because it is very expensive. Delay it until needed.
lock (_cache)
{
_cache.TryGetValue(dependencyProperty, out dpd);
}
if (dpd == null)
{
// Create a new DPD based on the type information we have. It
// will fill in the property descriptor by calling TypeDescriptor
// when needed.
dpd = new DependencyPropertyDescriptor(null, dependencyProperty.Name, targetType, dependencyProperty, false);
lock (_cache)
{
_cache[dependencyProperty] = dpd;
}
}
}
else if (!dpKind.IsInternal)
{
// If it isn't a direct property, we treat it as attached unless it is internal.
// We should never release internal properties to the user
PropertyDescriptor prop = DependencyObjectProvider.GetAttachedPropertyDescriptor(dependencyProperty, targetType);
if (prop != null)
{
dpd = FromProperty(prop);
}
}
return(dpd);
}
static OverlayAdorner() {
_isVisibleDescriptor = DependencyPropertyDescriptor.FromProperty(IsVisibleProperty, typeof(AdornerLayer));
}
/// <summary>
/// Initializes a new instance of the DatePicker class.
/// </summary>
public DatePicker() {
FocusManager.SetIsFocusScope(this, false);
_defaultText = string.Empty;
_timer = new DispatcherTimer();
_timer.Tick += RenewTodayButtonContent;
// Binding to FirstDayOfWeek and DisplayDate wont work
SetCurrentValue(FirstDayOfWeekProperty, CalendarEngine.GetCurrentCultureFirstDayOfWeek());
DisplayDate = DateTime.Today;
_isMouseOverPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(IsMouseOverProperty, typeof(UIElement));
if (_isMouseOverPropertyDescriptor != null)
_isMouseOverPropertyDescriptor.AddValueChanged(this, VisualStatePropertyChangedHandler);
_isFocusedPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(IsFocusedProperty, typeof(UIElement));
if (_isFocusedPropertyDescriptor != null)
_isFocusedPropertyDescriptor.AddValueChanged(this, VisualStatePropertyChangedHandler);
}
public DateTimePartGroupBehavior(DateTimePartGroup dateTimePartGroup, int step)
{
_dateTimePartGroup = dateTimePartGroup;
this.step = step;
dpDesc = DependencyPropertyDescriptor.FromProperty(DateTimePartGroup.ValueProperty, typeof(DateTimePartGroup));
_dateTimePartGroup.Unloaded += _dateTimePartGroup_Unloaded;
_dateTimePartGroup.Loaded += _dateTimePartGroup_Loaded;
}
private static void SetHasErrorDescriptor(DependencyObject d, DependencyPropertyDescriptor value)
{
d.SetValue(HasErrorDescriptorProperty, value);
}
public WpfDependencyPropertyDescriptor(DependencyPropertyDescriptor propertyDescriptor)
{
if (propertyDescriptor == null) throw new ArgumentNullException("propertyDescriptor");
_propertyDescriptor = propertyDescriptor;
}
public SelectorDefaultSelectedBeavaior(Selector selector, int value)
{
_selector = selector;
defaultValue = value;
_itemsSourceDescriptor = DependencyPropertyDescriptor.FromProperty(ItemsControl.ItemsSourceProperty, selector.GetType());
RegisterEvent();
_selector.SetValue(DefaultSelectedIndexProperty, value);
}
internal void UpdateAdvanceOptionsForItem( MarkupObject markupObject, DependencyObject dependencyObject, DependencyPropertyDescriptor dpDescriptor,
out string imageName, out object tooltip )
{
imageName = "AdvancedProperties11";
tooltip = "Advanced Properties";
bool isResource = false;
bool isDynamicResource = false;
var markupProperty = markupObject.Properties.Where( p => p.Name == PropertyName ).FirstOrDefault();
if( markupProperty != null )
{
//TODO: need to find a better way to determine if a StaticResource has been applied to any property not just a style
isResource = ( markupProperty.Value is Style );
isDynamicResource = ( markupProperty.Value is DynamicResourceExtension );
}
if( isResource || isDynamicResource )
{
imageName = "Resource11";
tooltip = "Resource";
}
else
{
if( ( dependencyObject != null ) && ( dpDescriptor != null ) )
{
if( BindingOperations.GetBindingExpressionBase( dependencyObject, dpDescriptor.DependencyProperty ) != null )
{
imageName = "Database11";
tooltip = "Databinding";
}
else
{
BaseValueSource bvs =
DependencyPropertyHelper
.GetValueSource( dependencyObject, dpDescriptor.DependencyProperty )
.BaseValueSource;
switch( bvs )
{
case BaseValueSource.Inherited:
case BaseValueSource.DefaultStyle:
case BaseValueSource.ImplicitStyleReference:
imageName = "Inheritance11";
tooltip = "Inheritance";
break;
case BaseValueSource.DefaultStyleTrigger:
break;
case BaseValueSource.Style:
imageName = "Style11";
tooltip = "Style Setter";
break;
case BaseValueSource.Local:
imageName = "Local11";
tooltip = "Local";
break;
}
}
}
}
}
internal void UpdateAdvanceOptionsForItem( MarkupObject markupObject, DependencyObject dependencyObject, DependencyPropertyDescriptor dpDescriptor,
out object tooltip )
{
tooltip = StringConstants.AdvancedProperties;
bool isResource = false;
bool isDynamicResource = false;
var markupProperty = markupObject.Properties.Where( p => p.Name == PropertyName ).FirstOrDefault();
if( ( markupProperty != null )
&& ( markupProperty.PropertyType != typeof( object ) )
&& !markupProperty.PropertyType.IsEnum
&& !markupProperty.PropertyType.IsArray )
{
//TODO: need to find a better way to determine if a StaticResource has been applied to any property not just a style
isResource = ( markupProperty.Value is Style );
isDynamicResource = ( markupProperty.Value is DynamicResourceExtension );
}
if( isResource || isDynamicResource )
{
tooltip = StringConstants.Resource;
}
else
{
if( ( dependencyObject != null ) && ( dpDescriptor != null ) )
{
if( BindingOperations.GetBindingExpressionBase( dependencyObject, dpDescriptor.DependencyProperty ) != null )
{
tooltip = StringConstants.Databinding;
}
else
{
BaseValueSource bvs =
DependencyPropertyHelper
.GetValueSource( dependencyObject, dpDescriptor.DependencyProperty )
.BaseValueSource;
switch( bvs )
{
case BaseValueSource.Inherited:
case BaseValueSource.DefaultStyle:
case BaseValueSource.ImplicitStyleReference:
tooltip = StringConstants.Inheritance;
break;
case BaseValueSource.DefaultStyleTrigger:
break;
case BaseValueSource.Style:
tooltip = StringConstants.StyleSetter;
break;
case BaseValueSource.Local:
tooltip = StringConstants.Local;
break;
}
}
}
}
}
private void ReleaseComponent(TextBox button)
{
if (dpdWidth != null)
{
dpdWidth.RemoveValueChanged(button, OnWidthChanged);
dpdWidth = null;
}
if (dpdText != null)
{
dpdText.RemoveValueChanged(button, OnTextChanged);
dpdText = null;
}
}
private void HookProperty(DependencyProperty property)
{
_dpd = DependencyPropertyDescriptor.FromProperty(property, _instance.GetType());
_dpd.AddValueChanged(_instance, OnPropertyValueChanged);
}
