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); }