public static void SetBindingObject(FrameworkElement obj, BindingMode mode, object source, DependencyProperty dp, string propertyName) { Type propertyType = source.GetType().GetProperty(propertyName).PropertyType; PropertyInfo info = source.GetType().GetProperty("RangeList"); FANumberRangeRule rangeRule = null; if (info != null) { object value = info.GetValue(source, null); if (value != null) { FALibrary.Utility.SerializableDictionary<string, FARange> dic = (FALibrary.Utility.SerializableDictionary<string, FARange>)value; if (dic.ContainsKey(propertyName)) { rangeRule = new FANumberRangeRule(propertyType); rangeRule.Range = dic[propertyName]; obj.Tag = rangeRule; obj.Style = (Style)App.Current.Resources["TextBoxErrorStyle"]; } } } Binding bd = new Binding(propertyName); bd.Source = source; bd.Mode = mode; bd.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged; if (rangeRule != null) { bd.NotifyOnValidationError = true; bd.ValidationRules.Add(rangeRule); } obj.SetBinding(dp, bd); }
internal static void SetBinding(this DependencyObject sourceObject, DependencyObject targetObject, DependencyProperty sourceProperty, DependencyProperty targetProperty) { Binding b = new Binding(); b.Source = sourceObject; b.Path = new PropertyPath(sourceProperty); BindingOperations.SetBinding(targetObject, targetProperty, b); }
static ImageButton() { DefaultStyleKeyProperty.OverrideMetadata(typeof(ImageButton), new FrameworkPropertyMetadata(typeof(ImageButton))); ImageButton.OrientationProperty = DependencyProperty.Register("Orientation", typeof(Orientation), typeof(ImageButton), new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure)); ImageButton.ImageSourceProperty = DependencyProperty.Register("ImageSource", typeof(ImageSource), typeof(ImageButton), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure)); ImageButton.IsToolStyleProperty = DependencyProperty.Register("IsToolStyle", typeof(bool), typeof(ImageButton), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsArrange)); ImageButton.ContentHorizontalAlignmentProperty = DependencyProperty.Register( "ContentHorizontalAlignment", typeof(HorizontalAlignment), typeof(ImageButton), new FrameworkPropertyMetadata(HorizontalAlignment.Center, FrameworkPropertyMetadataOptions.AffectsRender)); ImageButton.ContentVerticalAlignmentProperty = DependencyProperty.Register( "ContentVerticalAlignment", typeof(VerticalAlignment), typeof(ImageButton), new FrameworkPropertyMetadata(VerticalAlignment.Center, FrameworkPropertyMetadataOptions.AffectsRender)); }
static InputHelper() { InputBindingsProperty = DependencyProperty.RegisterAttached("InputBindings", typeof(ICollection), typeof(InputHelper), new FrameworkPropertyMetadata((d, e) => { var element = d as UIElement; if (element != null) { element.InputBindings.Clear(); element.InputBindings.AddRange(e.NewValue as ICollection); if (e.NewValue is INotifyCollectionChanged) { ((INotifyCollectionChanged)e.NewValue).CollectionChanged += (x, y) => { if (y.Action == NotifyCollectionChangedAction.Add || y.Action == NotifyCollectionChangedAction.Replace) { element.InputBindings.AddRange(y.NewItems as ICollection); } if (y.Action == NotifyCollectionChangedAction.Remove || y.Action == NotifyCollectionChangedAction.Replace) { foreach (InputBinding b in y.NewItems as ICollection) element.InputBindings.Remove(b); } if (y.Action == NotifyCollectionChangedAction.Reset) { element.InputBindings.Clear(); element.InputBindings.AddRange(x as ICollection); } }; } } })); }
static LixeiraProperty() { var metadata = new FrameworkPropertyMetadata((ImageSource)null); ImageProperty = DependencyProperty.RegisterAttached("Image", typeof(ImageSource), typeof(LixeiraProperty), metadata); }
static PivotGridDemoModule() { Type ownerType = typeof(PivotGridDemoModule); PivotGridControlProperty = DependencyPropertyManager.Register("PivotGridControl", typeof(PivotGridControl), ownerType, new PropertyMetadata(null, OnPivotGridControlChanged)); }
/// <summary> /// Starts an animation to a particular value on the specified dependency property. /// You can pass in an event handler to call when the animation has completed. /// </summary> public static void StartAnimation(UIElement animatableElement, DependencyProperty dependencyProperty, double toValue, double animationDurationSeconds, EventHandler completedEvent) { double fromValue = (double)animatableElement.GetValue(dependencyProperty); DoubleAnimation animation = new DoubleAnimation(); animation.From = fromValue; animation.To = toValue; animation.Duration = TimeSpan.FromSeconds(animationDurationSeconds); animation.Completed += delegate(object sender, EventArgs e) { // // When the animation has completed bake final value of the animation // into the property. // animatableElement.SetValue(dependencyProperty, animatableElement.GetValue(dependencyProperty)); CancelAnimation(animatableElement, dependencyProperty); if (completedEvent != null) { completedEvent(sender, e); } }; animation.Freeze(); animatableElement.BeginAnimation(dependencyProperty, animation); }
public static void UpdateBinding(this FrameworkElement instance, DependencyProperty prop) { var bindingExpression = instance.GetBindingExpression(prop); if (bindingExpression != null) bindingExpression.UpdateSource(); }
internal DependencyPropertyChangedEventArgs( DependencyProperty property, PropertyMetadata metadata, bool isAValueChange, EffectiveValueEntry oldEntry, EffectiveValueEntry newEntry, OperationType operationType) { _property = property; _metadata = metadata; _oldEntry = oldEntry; _newEntry = newEntry; _flags = 0; _operationType = operationType; IsAValueChange = isAValueChange; // This is when a mutable default is promoted to a local value. On this operation mutable default // value acquires a freezable context. However this value promotion operation is triggered // whenever there has been a sub property change to the mutable default. Eg. Adding a TextEffect // to a TextEffectCollection instance which is the mutable default. Since we missed the sub property // change due to this add, we flip the IsASubPropertyChange bit on the following change caused by // the value promotion to coalesce these operations. IsASubPropertyChange = (operationType == OperationType.ChangeMutableDefaultValue); }
/// <summary> /// Class ctor /// </summary> static ToolBarButton() { ImageProperty = DependencyProperty.Register("Image", typeof(ImageSource), typeof(ToolBarButton), new FrameworkPropertyMetadata((ImageSource)null, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure, ImageChanged)); DisabledImageProperty = DependencyProperty.Register("DisabledImage", typeof(ImageSource), typeof(ToolBarButton), new FrameworkPropertyMetadata((ImageSource)null, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure, DisabledImageChanged)); FlipProperty = DependencyProperty.Register("Flip", typeof(bool), typeof(ToolBarButton), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure, FlipChanged)); TextProperty = DependencyProperty.Register("Text", typeof(String), typeof(ToolBarButton), new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.Inherits, TextChanged)); DisplayStyleProperty = DependencyProperty.RegisterAttached("DisplayStyle", typeof(DisplayStyleE), typeof(ToolBarButton), new FrameworkPropertyMetadata(DisplayStyleE.Text, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsParentArrange | FrameworkPropertyMetadataOptions.AffectsParentMeasure | FrameworkPropertyMetadataOptions.Inherits, DisplayStyleChanged)); IsEnabledProperty.OverrideMetadata(typeof(ToolBarButton), new FrameworkPropertyMetadata(true, new PropertyChangedCallback(IsEnabledChanged))); }
static CoinFlipCounter() { TossProperty = DependencyProperty.Register("Toss", typeof(Boolean), typeof(CoinFlipCounter), new PropertyMetadata(true)); Image1SourceProperty = DependencyProperty.Register("Image1Source", typeof(String), typeof(CoinFlipCounter), new PropertyMetadata("")); Image2SourceProperty = DependencyProperty.Register("Image1Source", typeof(String), typeof(CoinFlipCounter), new PropertyMetadata("")); }
static GraphElementBehavior() { IsSemiHighlightedProperty = IsSemiHighlightedPropertyKey.DependencyProperty; SemiHighlightInfoProperty = SemiHighlightInfoPropertyKey.DependencyProperty; HighlightInfoProperty = HighlightInfoPropertyKey.DependencyProperty; IsHighlightedProperty = IsHighlightedPropertyKey.DependencyProperty; }
/// <summary> /// Creates a new dependency property descriptor. A note on perf: We don't /// pass the property descriptor down as the default member descriptor here. Doing /// so takes the attributes off of the property descriptor, which can be costly if they /// haven't been accessed yet. Instead, we wait until someone needs to access our /// Attributes property and demand create the attributes at that time. /// </summary> internal DependencyObjectPropertyDescriptor(DependencyProperty dp, Type ownerType) : base(string.Concat(dp.OwnerType.Name, ".", dp.Name), null) { _dp = dp; _componentType = ownerType; _metadata = _dp.GetMetadata(ownerType); }
static FocusScopeManager() { // Must do this explicitly because the default value of the FocusScopePriorityProperty depends on DefaultFocusScopePriority being properly initialized. FocusScopeManager.DefaultFocusScopePriority = Int32.MaxValue; FocusScopeManager.FocusScopePriorityProperty = DependencyProperty.RegisterAttached("FocusScopePriority", typeof(int), typeof(FocusScopeManager), new FrameworkPropertyMetadata(FocusScopeManager.DefaultFocusScopePriority, new PropertyChangedCallback(FocusScopeManager.FocusScopePriorityChanged))); FocusManager.FocusedElementProperty.OverrideMetadata(typeof(FrameworkElement), new PropertyMetadata(null, null, new CoerceValueCallback(FocusScopeManager.FocusManager_CoerceFocusedElement))); }
public OriginElement() { FrameworkPropertyMetadata meta = new FrameworkPropertyMetadata(); meta.AffectsRender = true; OriginProperty = DependencyProperty.Register("Origin", typeof(Point), typeof(OriginElement), meta); }
public static IDisposable PropertyChanged( this DependencyObject source, DependencyProperty property, Action<DependencyPropertyChangedEventArgs> onChanged = null) { return new DependencyPropertyListener(source, property, onChanged); }
/// <summary> /// Replaces the content for a <see cref="DataField"/> with another control and updates the bindings. /// </summary> /// <param name="field">The <see cref="DataField"/> whose <see cref="TextBox"/> will be replaced.</param> /// <param name="newControl">The new control you're going to set as <see cref="DataField.Content" />.</param> /// <param name="dataBindingProperty">The control's property that will be used for data binding.</param> /// <param name="bindingSetupFunction"> /// An optional <see cref="Action"/> you can use to change parameters on the newly generated binding before /// it is applied to <paramref name="newControl"/> /// </param> /// <param name="sourceProperty">The source dependency property to use for the binding.</param> public static void ReplaceContent(this DataField field, FrameworkElement newControl, DependencyProperty dataBindingProperty, Action<Binding> bindingSetupFunction, DependencyProperty sourceProperty) { if (field == null) { throw new ArgumentNullException("field"); } if (newControl == null) { throw new ArgumentNullException("newControl"); } // Construct new binding by copying existing one, and sending it to bindingSetupFunction // for any changes the caller wants to perform Binding newBinding = field.Content.GetBindingExpression(sourceProperty).ParentBinding.CreateCopy(); if (bindingSetupFunction != null) { bindingSetupFunction(newBinding); } // Replace field newControl.SetBinding(dataBindingProperty, newBinding); field.Content = newControl; }
static DataPager() { PagedItemsSourceProperty = DependencyProperty.Register("PagedItemsSource" , typeof(IPagedCollectionView) , typeof(DataPager) , new FrameworkPropertyMetadata(new PropertyChangedCallback(PagedItemsSourceChanged))); TotalItemCountProperty = DependencyProperty.Register("TotalItemCount" , typeof(int) , typeof(DataPager)); PageIndexProperty = DependencyProperty.Register("PageIndex" , typeof(int) , typeof(DataPager)); PageCountProperty = DependencyProperty.Register("PageCount" , typeof(int) , typeof(DataPager)); PageSizeProperty = DependencyProperty.Register("PageSize" , typeof(int) , typeof(DataPager)); ResultsTextProperty = DependencyProperty.Register("ResultsText" , typeof(string) , typeof(DataPager)); PageTextProperty = DependencyProperty.Register("PageText" , typeof(string) , typeof(DataPager)); PageOfTextProperty = DependencyProperty.Register("PageOfText" , typeof(string) , typeof(DataPager)); DefaultStyleKeyProperty.OverrideMetadata(typeof(DataPager), new FrameworkPropertyMetadata(typeof(DataPager))); }
public XamlDependencyPropertyInfo(DependencyProperty property, bool isAttached) { Debug.Assert(property != null); this.property = property; this.isAttached = isAttached; this.isCollection = CollectionSupport.IsCollectionType(property.PropertyType); }
public override object ProvideValue(IServiceProvider serviceProvider) { var pvt = serviceProvider as IProvideValueTarget; if (pvt == null) { return null; } _frameworkElement = pvt.TargetObject as FrameworkElement; if (_frameworkElement == null) { return this; } _target = pvt.TargetProperty as DependencyProperty; if (_target == null) { return this; } _frameworkElement.DataContextChanged += FrameworkElement_DataContextChanged; var proxy = new Proxy(); var binding = new Binding() { Source = proxy, Path = new PropertyPath("Value") }; // Make sure we don't leak subscriptions _frameworkElement.Unloaded += (e, v) => _subscription.Dispose(); return binding.ProvideValue(serviceProvider); }
/// <summary> /// Initializes a new instance of the <see cref="WpfMemberToken"/> class. /// </summary> /// <param name="objectToObserve">The object to observe.</param> /// <param name="dependencyProperty">The dependency property.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="remainingPath">The remaining path.</param> /// <param name="callback">The callback.</param> /// <param name="pathNavigator">The path navigator.</param> public WpfMemberToken(DependencyObject objectToObserve, DependencyProperty dependencyProperty, string propertyName, string remainingPath, Action<object, string> callback, IPathNavigator pathNavigator) : base(objectToObserve, propertyName, remainingPath, callback, pathNavigator) { _dependencyProperty = dependencyProperty; AcquireTarget(objectToObserve); }
static WPFClickTypeWatch() { DefaultStyleKeyProperty.OverrideMetadata( typeof( WPFClickTypeWatch ), new FrameworkPropertyMetadata( typeof( WPFClickTypeWatch ) ) ); ValueProperty = DependencyProperty.Register( "Value", typeof( int ), typeof( WPFClickTypeWatch ) ); DisabledColorProperty = DependencyProperty.Register( "DisabledColor", typeof( LinearGradientBrush ), typeof( WPFClickTypeWatch ) ); IsPausedProperty = DependencyProperty.Register( "IsPaused", typeof( bool ), typeof( WPFClickTypeWatch ) ); }
static RichTextBlock() { //This OverrideMetadata call tells the system that this element wants to provide a style that is different than its base class. //This style is defined in themes\generic.xaml DefaultStyleKeyProperty.OverrideMetadata(typeof(RichTextBlock), new FrameworkPropertyMetadata(typeof(RichTextBlock))); InlineProperty = DependencyProperty.Register("RichText", typeof(List<Inline>), typeof(RichTextBlock), new PropertyMetadata(null, new PropertyChangedCallback(OnInlineChanged))); }
//------------------------------------------------------ // // Internal Methods // //----------------------------------------------------- #region Internal Methods // Returns non-null string if this value can be converted to a string, // null otherwise. internal static string GetStringValue(DependencyProperty property, object propertyValue) { string stringValue = null; // Special cases working around incorrectly implemented type converters if (property == UIElement.BitmapEffectProperty) { return null; // Always treat BitmapEffects as complex value } if (property == Inline.TextDecorationsProperty) { stringValue = TextDecorationsFixup((TextDecorationCollection)propertyValue); } else if (typeof(CultureInfo).IsAssignableFrom(property.PropertyType)) //NumberSubstitution.CultureOverrideProperty { stringValue = CultureInfoFixup(property, (CultureInfo)propertyValue); } if (stringValue == null) { DPTypeDescriptorContext context = new DPTypeDescriptorContext(property, propertyValue); System.ComponentModel.TypeConverter typeConverter = System.ComponentModel.TypeDescriptor.GetConverter(property.PropertyType); Invariant.Assert(typeConverter != null); if (typeConverter.CanConvertTo(context, typeof(string))) { stringValue = (string)typeConverter.ConvertTo( context, System.Globalization.CultureInfo.InvariantCulture, propertyValue, typeof(string)); } } return stringValue; }
// Existing GetPropertyValue for the TextDecorationCollection will return the first collection, even if it is empty. // this skips empty collections so we can get the actual value. // slightly modified code from https://social.msdn.microsoft.com/Forums/vstudio/en-US/3ac626cf-60aa-427f-80e9-794f3775a70e/how-to-tell-if-richtextbox-selection-is-underlined?forum=wpf public static object GetRealPropertyValue(this swd.TextRange textRange, sw.DependencyProperty formattingProperty, out swd.TextRange fullRange) { object value = null; fullRange = null; var pointer = textRange.Start as swd.TextPointer; if (pointer != null) { var needsContinue = true; swd.TextElement text = null; sw.DependencyObject element = pointer.Parent as swd.TextElement; while (needsContinue && (element is swd.Inline || element is swd.Paragraph || element is swc.TextBlock)) { value = element.GetValue(formattingProperty); text = element as swd.TextElement; var seq = value as IEnumerable; needsContinue = (seq == null) ? value == null : seq.Cast <object>().Count() == 0; element = element is swd.TextElement ? ((swd.TextElement)element).Parent : null; } if (text != null) { fullRange = new swd.TextRange(text.ElementStart, text.ElementEnd); } } return(value); }
static CornerRadiusAnimation() { Type typeofProp = typeof(CornerRadius?); Type typeofThis = typeof(CornerRadiusAnimation); PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed); ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue); FromProperty = DependencyProperty.Register( "From", typeofProp, typeofThis, new PropertyMetadata((CornerRadius?)null, propCallback), validateCallback); ToProperty = DependencyProperty.Register( "To", typeofProp, typeofThis, new PropertyMetadata((CornerRadius?)null, propCallback), validateCallback); ByProperty = DependencyProperty.Register( "By", typeofProp, typeofThis, new PropertyMetadata((CornerRadius?)null, propCallback), validateCallback); }
public static object CoerceKeyTip(ISyncKeyTipAndContent syncElement, object baseValue, DependencyProperty contentProperty) { DependencyObject element = syncElement as DependencyObject; Debug.Assert(element != null); if (syncElement.KeepKeyTipAndContentInSync && !syncElement.IsKeyTipSyncSource) { syncElement.KeepKeyTipAndContentInSync = false; if (string.IsNullOrEmpty((string)baseValue)) { string stringContent = element.GetValue(contentProperty) as string; if (stringContent != null) { int accessIndex = RibbonHelper.FindAccessKeyMarker(stringContent); if (accessIndex >= 0 && accessIndex < stringContent.Length - 1) { syncElement.KeepKeyTipAndContentInSync = true; return StringInfo.GetNextTextElement(stringContent, accessIndex + 1); } } } } return baseValue; }
static ZoomBox() { DefaultStyleKeyProperty.OverrideMetadata(typeof(ZoomBox), new FrameworkPropertyMetadata(typeof(ZoomBox))); ImageSourceProperty = DependencyProperty.Register("ImageSource", typeof(string), typeof(ZoomBox), new FrameworkPropertyMetadata()); ZoomProperty = DependencyProperty.Register("Zoom", typeof(Double), typeof(ZoomBox), new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.None, ZoomPropertyChangedCallback)); }
public CategorySelectionStop(CiderCategoryContainer parent, bool isAdvanced) { if (parent == null) { throw FxTrace.Exception.ArgumentNull("parent"); } if (parent.Category == null) { throw FxTrace.Exception.ArgumentNull("parent.Category"); } _parent = parent; _expansionProperty = isAdvanced ? Blend.CategoryContainer.AdvancedSectionPinnedProperty : Blend.CategoryContainer.ExpandedProperty; _selectionPath = CategoryContainerSelectionPathInterpreter.Instance.ConstructSelectionPath(parent.Category.CategoryName, isAdvanced); _description = isAdvanced ? string.Format( CultureInfo.CurrentCulture, System.Activities.Presentation.Internal.Properties.Resources.PropertyEditing_SelectionStatus_AdvancedCategory, parent.Category.CategoryName) : string.Format( CultureInfo.CurrentCulture, System.Activities.Presentation.Internal.Properties.Resources.PropertyEditing_SelectionStatus_Category, parent.Category.CategoryName); }
public static Task SmoothSetAsync(this FrameworkElement @this, DependencyProperty dp, double targetvalue, TimeSpan iDuration, CancellationToken iCancellationToken) { TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(); DoubleAnimation anim = new DoubleAnimation(targetvalue, new Duration(iDuration)); PropertyPath p = new PropertyPath("(0)", dp); Storyboard.SetTargetProperty(anim, p); Storyboard sb = new Storyboard(); sb.Children.Add(anim); EventHandler handler = null; handler = delegate { sb.Completed -= handler; sb.Remove(@this); @this.SetValue(dp, targetvalue); tcs.TrySetResult(null); }; sb.Completed += handler; sb.Begin(@this, true); iCancellationToken.Register(() => { double v = (double)@this.GetValue(dp); sb.Stop(); sb.Remove(@this); @this.SetValue(dp, v); tcs.TrySetCanceled(); }); return tcs.Task; }
internal TemplateBindingExpression(DependencyObject source, TemplateBindingExtension binding, bool runtimeCheck) { this.Source = source; this.sourceProperty = binding.Property; this.bindingExtension = binding; this.runtimeCheck = runtimeCheck; }
internal void SourcePropertyChanged(object sender, DependencyProperty dp) { if (dp == this.sourceProperty) { this.target.RefreshExpression(this.targetProperty); } }
static DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression() { StringProperty = DependencyProperty.Register("String", typeof(string), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression)); DoubleProperty = DependencyProperty.Register("Double", typeof(double), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata()); FloatProperty = DependencyProperty.Register("Float", typeof(float), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(float))); IntProperty = DependencyProperty.Register("Int", typeof(int), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(int), OnDependencyPropertyChanged)); BooleanProperty = DependencyProperty.Register("Boolean", typeof(bool), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(bool), OnDependencyPropertyChanged, CoerceValueCallback)); OtherStringProperty = Register("OtherString", typeof(string), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression)); OtherDoubleProperty = Register("OtherDouble", typeof(double), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata()); OtherFloatProperty = Register("OtherFloat", typeof(float), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(float))); OtherIntProperty = Register("OtherInt", typeof(int), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(int), OnDependencyPropertyChanged)); OtherBooleanProperty = Register("OtherBoolean", typeof(bool), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(bool), OnDependencyPropertyChanged, CoerceValueCallback)); MoreStringProperty = DependencyProperty.Register("MoreString", typeof(string), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression)); MoreDoubleProperty = DependencyProperty.Register("MoreDouble", typeof(double), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata()); MoreFloatProperty = DependencyProperty.Register("MoreFloat", typeof(float), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(float))); MoreIntProperty = DependencyProperty.Register("MoreInt", typeof(int), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(int), OnDependencyPropertyChanged)); MoreBooleanProperty = DependencyProperty.Register("MoreBoolean", typeof(bool), typeof(DependencyPropertyDeclarationsInConstructorThatAreCandidatesToUseNameofExpression), new PropertyMetadata(default(bool), OnDependencyPropertyChanged, CoerceValueCallback)); }
static StringTemplateEditor() { SuggestionsKeyProperty = System.Windows.DependencyProperty.Register( "SuggestionsKey", typeof(string), typeof(StringTemplateEditor), new FrameworkPropertyMetadata(OnSuggestionsKeyChanged) ); }
static ReportField() { // ColumnId Property ReportField.ColumnIdProperty = DependencyProperty.Register("ColumnId", typeof(String), typeof(ReportField)); // Width Property ReportField.WidthProperty = DependencyProperty.Register("Width", typeof(System.Double), typeof(ReportField), new PropertyMetadata(new PropertyChangedCallback(OnWidthChanged))); }
/// <summary> /// Creates the static resources used by this class. /// </summary> static RowHeaderCanvas() { // This value is used to prevent modifications to the colum header. Once frozen, selecting a part of the header will // select the entire row. When not frozen, dragging rows around will change the order and size of the rows. RowHeaderCanvas.IsHeaderFrozenProperty = DependencyProperty.Register("IsHeaderFrozen", typeof(object), typeof(RowHeaderCanvas), new FrameworkPropertyMetadata(true)); // Select Row Command RowHeaderCanvas.FreezeRowHeaders = new RoutedUICommand("FreezeRowHeaders", "Freeze Row Headers", typeof(RowHeaderCanvas)); }
public static PropertyChangeNotifier Register(sw.DependencyProperty property, EventHandler handler, sw.DependencyObject propertySource = null) { var notifier = new PropertyChangeNotifier(property); if (propertySource != null) { notifier.PropertySource = propertySource; } notifier.ValueChanged += handler; return(notifier); }
public DependencyPropertySubscription(T element, DependencyProperty dependencyProperty) { this.Element = element; this.DependencyProperty = dependencyProperty; var sourceBinding = new System.Windows.Data.Binding("Value") { Source = this, Mode = BindingMode.TwoWay }; element.SetBinding(this.DependencyProperty, sourceBinding); }
public ColumnChangedEventArgs(RoutedEvent routedEvent, UndoAction undoAction, ReportColumn reportColumn, DependencyProperty dependencyProperty, object oldValue, object newValue) : base(routedEvent) { // Initialize the object. this.UndoAction = undoAction; this.ColumnDefinition = reportColumn; this.DependencyProperty = dependencyProperty; this.OldValue = oldValue; this.NewValue = newValue; }
internal void SetActive(bool active) { if (_isInitializing) { afterInit = () => SetActive(active); return; } if (Storyboard != null) { if (active) { Storyboard.Begin(); } else { Storyboard.Stop(); } } //var storyboard = new System.Windows.Media.Animation.Storyboard(); foreach (var setter in _setters.OfType <System.Windows.Setter>()) { System.Windows.DependencyProperty property = setter.Property; object value = setter.Value; //Why doesn't this return the actual value??? string targetName = setter.TargetName; //var s = new System.Windows.Media.Animation.DoubleAnimation() { }; //System.Windows.Media.Animation.Storyboard.SetTargetName(s, setter.TargetName); //System.Windows.Media.Animation.Storyboard.SetTargetProperty(s, new System.Windows.PropertyPath(string.Format("({0}.{1})", setter.Property.OwnerType.Name, setter.Property.Name ))); //s.To = (double)setter.Value; //storyboard.Children.Add(s); //This isn't really working... need a better way //if (System.Windows.Application.Current.MainWindow != null) //{ // if (System.Windows.Application.Current.MainWindow.IsLoaded) // { // var target = System.Windows.Application.Current.MainWindow.FindName(targetName) as System.Windows.DependencyObject; // if (target != null) // target.SetValue(property, value); // } // else // System.Windows.Application.Current.MainWindow.Loaded += (s, e) => // { // var target = System.Windows.Application.Current.MainWindow.FindName(targetName) as System.Windows.DependencyObject; // if (target != null) // target.SetValue(property, value); // }; //} } //storyboard.Begin() }
// Thay đổi 1 loại thuộc tính dp cho văn bản đang chọn public void changePropertyText(System.Windows.DependencyProperty dp, object value) { if (rtbox != null) { TextSelection textSelection = rtbox.Selection; if (!textSelection.IsEmpty) { textSelection.ApplyPropertyValue(dp, value); rtbox.Focus(); } } }
/// <summary> /// Create the static resources for the ItemSelector. /// </summary> static ItemSelector() { // ItemsSource Property ItemSelector.ItemsSourceProperty = DependencyProperty.Register("ItemsSource", typeof(IEnumerable), typeof(ItemSelector)); // SelectedValue Property ItemSelector.SelectedValueProperty = DependencyProperty.Register("SelectedValue", typeof(Object), typeof(ItemSelector), new FrameworkPropertyMetadata(OnSelectedValueChanged)); // SelectedValuePath Property ItemSelector.SelectedValuePathProperty = DependencyProperty.Register("SelectedValuePath", typeof(String), typeof(ItemSelector)); }
void SetSelectionAttribute(sw.DependencyProperty property, object value) { selectionAttributes = selectionAttributes ?? new Dictionary <sw.DependencyProperty, object>(); if (value == null) { if (selectionAttributes.ContainsKey(property)) { selectionAttributes.Remove(property); } } else { selectionAttributes[property] = value; } Control.Selection.ApplyPropertyValue(property, value); }
// Existing GetPropertyValue for the TextDecorationCollection will return the first collection, even if it is empty. // this skips empty collections so we can get the actual value. // slightly modified code from https://social.msdn.microsoft.com/Forums/vstudio/en-US/3ac626cf-60aa-427f-80e9-794f3775a70e/how-to-tell-if-richtextbox-selection-is-underlined?forum=wpf object GetPropertyValue(swd.TextRange textRange, sw.DependencyProperty formattingProperty) { object value = null; var pointer = textRange.Start as swd.TextPointer; if (pointer != null) { var needsContinue = true; sw.DependencyObject element = pointer.Parent as swd.TextElement; while (needsContinue && (element is swd.Inline || element is swd.Paragraph || element is swc.TextBlock)) { value = element.GetValue(formattingProperty); var seq = value as IEnumerable; needsContinue = (seq == null) ? value == null : seq.Cast <Object>().Count() == 0; element = element is swd.TextElement ? ((swd.TextElement)element).Parent : null; } } return(value); }
static AnimatedImage() { AnimatedImage.CurrentFrameProperty = DependencyProperty.Register( "CurrentFrame", typeof(ImageSource), typeof(AnimatedImage) ); AnimatedImage.StretchDirectionProperty = DependencyProperty.Register( "StretchDirection", typeof(StretchDirection), typeof(AnimatedImage) ); AnimatedImage.StretchProperty = DependencyProperty.Register( "Stretch", typeof(Stretch), typeof(AnimatedImage) ); FrameworkElement.DefaultStyleKeyProperty.OverrideMetadata(typeof(AnimatedImage), new FrameworkPropertyMetadata(typeof(AnimatedImage))); }
/// <summary> /// Initializes the static elements of the document viewer. /// </summary> static DynamicReport() { // These namespaces prevent name conflicts by qualifying the XAML values used in the source code for this report. DynamicReport.namespaceXaml = "http://schemas.microsoft.com/winfx/2006/xaml"; DynamicReport.namespacePresentation = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"; DynamicReport.xNameReport = DynamicReport.namespacePresentation + "DynamicReport"; // Cell DynamicReport.CellProperty = DependencyProperty.RegisterAttached("Cell", typeof(ReportCell), typeof(DynamicReport)); // Content DynamicReport.ContentProperty = DependencyProperty.Register( "Content", typeof(IContent), typeof(DynamicReport), new FrameworkPropertyMetadata(new PropertyChangedCallback(OnContentChanged))); // IsActive DynamicReport.IsActiveProperty = DependencyProperty.RegisterAttached( "IsActive", typeof(Boolean), typeof(DynamicReport), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.Inherits)); // IsEven DynamicReport.IsEvenProperty = DependencyProperty.RegisterAttached("IsEven", typeof(Boolean), typeof(DynamicReport), new PropertyMetadata(false)); // IsSelected DynamicReport.IsSelectedProperty = DependencyProperty.RegisterAttached("IsSelected", typeof(Boolean), typeof(DynamicReport), new PropertyMetadata(false)); // IsPopup DynamicReport.IsPopupProperty = DependencyProperty.RegisterAttached("IsPopup", typeof(Boolean), typeof(DynamicReport), new PropertyMetadata(false)); // IsLayoutFrozen DynamicReport.IsLayoutFrozenProperty = DependencyProperty.Register( "IsLayoutFrozen", typeof(Object), typeof(DynamicReport), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsArrange, new PropertyChangedCallback(OnIsLayoutFrozenChanged))); // IsHeaderFrozen DynamicReport.IsHeaderFrozenProperty = DependencyProperty.Register( "IsHeaderFrozen", typeof(Boolean), typeof(DynamicReport), new PropertyMetadata(true, new PropertyChangedCallback(OnIsHeaderFrozenChanged))); // Scale DynamicReport.ScaleProperty = DependencyProperty.Register("Scale", typeof(Double), typeof(DynamicReport), new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.None, new PropertyChangedCallback(OnScaleChanged))); // Source DynamicReport.SourceProperty = DependencyProperty.Register("Source", typeof(XDocument), typeof(DynamicReport), new FrameworkPropertyMetadata(OnSourceChanged)); // The Split property determines where the row and column headers are positioned. DynamicReport.SplitProperty = DependencyProperty.Register("Split", typeof(Size), typeof(DynamicReport), new FrameworkPropertyMetadata(new Size(), FrameworkPropertyMetadataOptions.AffectsMeasure, new PropertyChangedCallback(OnSplitChanged))); // UndoPropertyChanged DynamicReport.UndoPropertyChangedEvent = EventManager.RegisterRoutedEvent("UndoPropertyChanged", RoutingStrategy.Bubble, typeof(UndoPropertyChangedEventHandler), typeof(DynamicReport)); // ClearContents DynamicReport.ClearContents = new RoutedUICommand("Clear Contents", "ClearContents", typeof(DynamicReport)); // Select Column DynamicReport.SelectColumn = new RoutedUICommand("Select", "SelectColumn", typeof(DynamicReport)); // SetIsLayoutFrozen DynamicReport.SetIsLayoutFrozen = new RoutedUICommand("Is Layout Frozen", "SetIsLayoutFrozen", typeof(DynamicReport)); //openReports = new Dictionary<Guid, DateTime>(); }
public static T GetValueThreadSafe <T>(this System.Windows.DependencyObject obj, System.Windows.DependencyProperty p) { return((T)obj.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Background, (System.Windows.Threading.DispatcherOperationCallback) delegate { return obj.GetValue(p); }, p)); }
static BitmapString() { BitmapString.SourceProperty = DependencyProperty.Register("Source", typeof(string), typeof(BitmapString), new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.None, new PropertyChangedCallback(OnSourceChanged))); }
internal void InvokeMerge(PropertyMetadata baseMetadata, DependencyProperty dp) { Merge(baseMetadata, dp); }
public PropertyChangeNotifier(sw.DependencyProperty property) : this(new sw.PropertyPath(property)) { }
public static DependencyPropertyReferenceStep GetReferenceStep(ITypeResolver typeResolver, Type targetType, System.Windows.DependencyProperty dependencyProperty, Microsoft.Expression.DesignModel.Metadata.MemberType memberTypes) { return(DependencyPropertyReferenceStep.GetReferenceStep(typeResolver, targetType, dependencyProperty, dependencyProperty.OwnerType, dependencyProperty.Name, Microsoft.Expression.DesignModel.Metadata.MemberType.Property)); }
[FriendAccessAllowed] // Built into Base, also used by Framework. internal object GetDefaultValue(DependencyObject owner, DependencyProperty property) { Debug.Assert(owner != null && property != null, "Caller must provide owner and property or this method will throw in the event of a cache miss."); // If we are not using a DefaultValueFactory (common case) // just return _defaultValue DefaultValueFactory defaultFactory = _defaultValue as DefaultValueFactory; if (defaultFactory == null) { return(_defaultValue); } // If the owner is Sealed it must not have a cached Freezable default value, // regardless of whether or not the owner is a Freezable. The reason // for this is that a default created using the FreezableDefaultValueFactory // will attempt to set itself as a local value if it is changed. Since the owner // is Sealed this will throw an exception. // // The solution to this if the owner is a Freezable is to toss out all cached // default values when we Seal. If the owner is not a Freezable we'll promote // the value to locally cached. Either way no Sealed DO can have a cached // default value, so we'll return the frozen default value instead. if (owner.IsSealed) { return(defaultFactory.DefaultValue); } // See if we already have a valid default value that was // created by a prior call to GetDefaultValue. object result = GetCachedDefaultValue(owner, property); if (result != DependencyProperty.UnsetValue) { // When sealing a DO we toss out all the cached values (see DependencyObject.Seal()). // We technically only need to throw out cached values created via the // FreezableDefaultValueFactory, but it's more consistent this way. Debug.Assert(!owner.IsSealed, "If the owner is Sealed we should not have a cached default value"); return(result); } // Otherwise we need to invoke the factory to create the DefaultValue // for this property. result = defaultFactory.CreateDefaultValue(owner, property); // Default value validation ensures that default values do not have // thread affinity. This is because a default value is typically // stored in the shared property metadata and handed out to all // instances of the owning DependencyObject type. // // DefaultValueFactory.CreateDefaultValue ensures that the default // value has thread-affinity to the current thread. We can thus // skip that portion of the default value validation by calling // ValidateFactoryDefaultValue. Debug.Assert(!(result is DispatcherObject) || ((DispatcherObject)result).Dispatcher == owner.Dispatcher); property.ValidateFactoryDefaultValue(result); // Cache the created DefaultValue so that we can consistently hand // out the same default each time we are asked. SetCachedDefaultValue(owner, property, result); return(result); }
public static void LoadAndMonitor(INotifyPropertyChanged source, string sourceProperty, System.Windows.Controls.Control control, System.Windows.DependencyProperty controlProperty = null) { if (controlProperty == null) { if (control is System.Windows.Controls.TextBox) { controlProperty = System.Windows.Controls.TextBox.TextProperty; } if (control is System.Windows.Controls.CheckBox) { controlProperty = System.Windows.Controls.Primitives.ToggleButton.IsCheckedProperty; } if (control is System.Windows.Controls.ComboBox || control is System.Windows.Controls.ListBox) { controlProperty = System.Windows.Controls.Primitives.Selector.SelectedValueProperty; } } var binding = new System.Windows.Data.Binding(sourceProperty); binding.Source = source; binding.IsAsync = true; control.SetBinding(controlProperty, binding); }
public static void SetValueThreadSafe(this System.Windows.DependencyObject obj, System.Windows.DependencyProperty p, object value) { obj.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background, (System.Threading.SendOrPostCallback) delegate { obj.SetValue(p, value); }, value); }
private static bool DefaultFreezeValueCallback( DependencyObject d, DependencyProperty dp, EntryIndex entryIndex, PropertyMetadata metadata, bool isChecking) { // The expression check only needs to be done when isChecking is true // because if we return false here the Freeze() call will fail. if (isChecking) { if (d.HasExpression(entryIndex, dp)) { if (TraceFreezable.IsEnabled) { TraceFreezable.Trace( TraceEventType.Warning, TraceFreezable.UnableToFreezeExpression, d, dp, dp.OwnerType); } return(false); } } if (!dp.IsValueType) { object value = d.GetValueEntry( entryIndex, dp, metadata, RequestFlags.FullyResolved).Value; if (value != null) { Freezable valueAsFreezable = value as Freezable; if (valueAsFreezable != null) { if (!valueAsFreezable.Freeze(isChecking)) { if (TraceFreezable.IsEnabled) { TraceFreezable.Trace( TraceEventType.Warning, TraceFreezable.UnableToFreezeFreezableSubProperty, d, dp, dp.OwnerType); } return(false); } } else // not a Freezable { DispatcherObject valueAsDispatcherObject = value as DispatcherObject; if (valueAsDispatcherObject != null) { if (valueAsDispatcherObject.Dispatcher == null) { // The property is a free-threaded DispatcherObject; since it's // already free-threaded it doesn't prevent this Freezable from // becoming free-threaded too. // It is up to the creator of this type to ensure that the // DispatcherObject is actually immutable } else { // The value of this property derives from DispatcherObject and // has thread affinity; return false. if (TraceFreezable.IsEnabled) { TraceFreezable.Trace( TraceEventType.Warning, TraceFreezable.UnableToFreezeDispatcherObjectWithThreadAffinity, d, dp, dp.OwnerType, valueAsDispatcherObject); } return(false); } } // The property isn't a DispatcherObject. It may be immutable (such as a string) // or the user may have made it thread-safe. It's up to the creator of the type to // do the right thing; we return true as an extensibility point. } } } return(true); }
public object GetAnimationBaseValue(DependencyProperty dp) { throw new NotImplementedException(); }
public virtual void ApplyAnimationClock(DependencyProperty dp, AnimationClock clock, HandoffBehavior handoffBehavior) { throw new NotImplementedException(); }
public Setter(DependencyProperty property, Object value, string targetName) { Contract.Ensures(!property.ReadOnly); }
/// <summary> /// Notification that this metadata has been applied to a property /// and the metadata is being sealed /// </summary> /// <remarks> /// Normally, any mutability of the data structure should be marked /// as immutable at this point /// </remarks> /// <param name="dp">DependencyProperty</param> /// <param name="targetType">Type associating metadata (null if default metadata)</param> protected virtual void OnApply(DependencyProperty dp, Type targetType) { }
public virtual void BeginAnimation(DependencyProperty dp, AnimationTimeline animation) { throw new NotImplementedException(); }