public static bool IsParentValid(DependencyObject parent)
{
bool valid = true;
LocalValueEnumerator localValues = parent.GetLocalValueEnumerator();
while (localValues.MoveNext())
{
LocalValueEntry entry = localValues.Current;
if (BindingOperations.IsDataBound(parent, entry.Property))
{
Binding binding = BindingOperations.GetBinding(parent, entry.Property);
if (binding.ValidationRules.Count > 0)
{
BindingExpression expression = BindingOperations.GetBindingExpression(parent, entry.Property);
expression.UpdateSource();
if (expression.HasError)
{
valid = false;
}
}
}
}
return(valid);
}
private static void GetBindings(FrameworkElement root, List <Tuple <FrameworkElement, DependencyProperty, Binding> > value)
{
foreach (FrameworkElement element in LogicalTreeHelper.GetChildren(root).OfType <FrameworkElement>())
{
FieldInfo[] properties = element.GetType().GetFields(BindingFlags.Public | BindingFlags.GetProperty |
BindingFlags.Static | BindingFlags.FlattenHierarchy);
foreach (FieldInfo field in properties)
{
if (field.FieldType == typeof(DependencyProperty))
{
DependencyProperty dp = (DependencyProperty)field.GetValue(null);
BindingExpression bindingExpression = BindingOperations.GetBindingExpression(element, dp);
//bindingExpression.
if (BindingOperations.IsDataBound(element, dp))
{
var b = BindingOperations.GetBinding(element, dp);
if (b != null)
{
value.Add(new Tuple <FrameworkElement, DependencyProperty, Binding>(element,
dp,
b
));
}
}
}
}
GetBindings(element, value);
}
}
/// <summary>
/// Sets or unsets the inner binding regarding to the passed source element value.
/// </summary>
/// <param name="sourceElement">The binding source element that must be assessed.</param>
private void ToggleBinding(object sourceElement)
{
if (TargetObject != null && TargetProperty != null && SourceType != null)
{
// If has binding while should not have, clear binding:
var currentBinding = BindingOperations.GetBindingBase(TargetObject, TargetProperty);
if (currentBinding != null && (sourceElement == null || SourceType == null ||
sourceElement?.GetType() != SourceType && !sourceElement.GetType().GetTypeInfo().IsSubclassOf(SourceType)))
{
BindingOperations.ClearBinding(TargetObject, TargetProperty);
if (BindingOperations.IsDataBound(TargetObject, TargetProperty)) // clearing may fail happen when called from datatemplate
{
BindingOperations.SetBinding(TargetObject, TargetProperty, selfPropertyBinding); // set set "null" value.
}
init_to_empty = true;
}
// If has no binding while should have, set binding:
else if (sourceElement != null && (currentBinding == null || ((currentBinding as Binding)?.IsEquivalentTo(selfPropertyBinding) == true)) &&
(sourceElement.GetType() == SourceType || sourceElement.GetType().GetTypeInfo().IsSubclassOf(SourceType)))
{
BindingOperations.SetBinding(TargetObject, TargetProperty, innerBinding ?? InnerBinding);
init_to_empty = false;
}
}
}
private void HandleMouseInput(Point position)
{
if (IsReadOnly)
{
return;
}
if (position.X < 0)
{
Value = Minimum;
}
else if (position.X > RenderSize.Width)
{
Value = Maximum;
}
else
{
Value = Math.Round(Minimum + ((position.X / RenderSize.Width) * (Maximum - Minimum)), Precision);
}
if (!BindingOperations.IsDataBound(this, ValueProperty))
{
return;
}
var bindingExpression = BindingOperations.GetBindingExpression(this, ValueProperty);
if (bindingExpression != null)
{
bindingExpression.UpdateTarget();
}
}
internal TabItem GetTabItem(int index)
{
if (BindingOperations.IsDataBound(this, ItemsSourceProperty))
{
IList list = ItemsSource as IList;
if (list != null)
{
return(this.ItemContainerGenerator.ContainerFromItem(list[index]) as TabItem);
}
// ItemsSource is at least an IEnumerable
int i = 0;
IEnumerator enumerator = ItemsSource.GetEnumerator();
while (enumerator.MoveNext())
{
if (i == index)
{
return(this.ItemContainerGenerator.ContainerFromItem(enumerator.Current) as TabItem);
}
i++;
}
return(null);
}
return(Items[index] as TabItem);
}
/// <summary>
/// Метод, който визуализира цвета при неправилно въведени данни
/// </summary>
private void BeginInvalidInputAnimation()
{
ColorAnimation animation = new ColorAnimation(this.AnimationBrushColor, TimeSpan.FromSeconds(0.1))
{
AutoReverse = true,
FillBehavior = FillBehavior.Stop,
DecelerationRatio = 0.8
};
// Ако свойството за Background участва в Binding, няма да може да бъде анимирано, затова временно
// откачаме Binding-а и го възстановяваме след края на анимацията (в метода storyBoard_Completed())
if (BindingOperations.IsDataBound(this.AssociatedTextBox, Control.BackgroundProperty))
{
this.animatedPropertyBinding = BindingOperations.GetBinding(this.AssociatedTextBox, Control.BackgroundProperty);
this.animatedPropertyMultiBinding = BindingOperations.GetMultiBinding(this.AssociatedTextBox, Control.BackgroundProperty);
if (this.animatedPropertyBinding != null || this.animatedPropertyMultiBinding != null)
{
// задаваме текущата стойност локално
Brush currentValue = this.AssociatedObject.GetValue(Control.BackgroundProperty) as Brush;
this.AssociatedTextBox.Background = currentValue;
}
}
Storyboard.SetTargetProperty(animation, new PropertyPath("(Control.Background).(SolidColorBrush.Color)"));
Storyboard storyBoard = new Storyboard();
storyBoard.Children.Add(animation);
storyBoard.Completed += new EventHandler(StoryBoard_Completed);
storyBoard.Begin(this.AssociatedTextBox);
SystemSounds.Beep.Play();
}
private static object CoerceMVVMHasError(DependencyObject dependencyObject, object baseValue)
{
bool hasError = (bool)baseValue;
if (BindingOperations.IsDataBound(dependencyObject, MVVMHasErrorProperty))
{
if (GetHasErrorDescriptor(dependencyObject) == null)
{
DependencyPropertyDescriptor descriptor = DependencyPropertyDescriptor.FromProperty(Validation.HasErrorProperty, dependencyObject.GetType());
descriptor.AddValueChanged(dependencyObject, OnHasErrorChanged);
SetHasErrorDescriptor(dependencyObject, descriptor);
hasError = Validation.GetHasError(dependencyObject);
}
}
else
{
if (GetHasErrorDescriptor(dependencyObject) != null)
{
DependencyPropertyDescriptor descriptor = GetHasErrorDescriptor(dependencyObject);
descriptor.RemoveValueChanged(dependencyObject, OnHasErrorChanged);
SetHasErrorDescriptor(dependencyObject, null);
}
}
return(hasError);
}
/// <summary>
/// Valida todos los controles de una ventana que se pase por parametro. Si existe algún error de validación se remarca
/// </summary>
/// <param name="parent"></param>
/// <returns></returns>
public static bool EsValido(DependencyObject parent)
{
bool valido = true;
LocalValueEnumerator localValues = parent.GetLocalValueEnumerator();
while (localValues.MoveNext())
{
LocalValueEntry entry = localValues.Current;
if (BindingOperations.IsDataBound(parent, entry.Property))
{
Binding binding = BindingOperations.GetBinding(parent, entry.Property);
foreach (ValidationRule reglaValidacion in binding.ValidationRules)
{
ValidationResult result = reglaValidacion.Validate(parent.GetValue(entry.Property), null);
if (!result.IsValid)
{
BindingExpression expresion = BindingOperations.GetBindingExpression(parent, entry.Property);
System.Windows.Controls.Validation.MarkInvalid(expresion, new ValidationError(reglaValidacion, expresion, result.ErrorContent, null));
valido = false;
}
}
}
}
for (int i = 0; i != VisualTreeHelper.GetChildrenCount(parent); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(parent, i);
if (!EsValido(child))
{
valido = false;
}
}
return(valido);
}
/// <summary> Устанавливает привязку данных для свойства к указанному Control </summary>
private void SetBinding(PropertyInfo property, Control control, Panel panel)
{
IsVisibleIfAttribute isVisibleIfAttribute = property.GetAttribute <IsVisibleIfAttribute>();
if (isVisibleIfAttribute != null)
{
Binding isVisibleBinding = new Binding(isVisibleIfAttribute.PropertyName);
isVisibleBinding.ConverterParameter = isVisibleIfAttribute.ValueOfIsVisible;
isVisibleBinding.Mode = BindingMode.OneWay;
isVisibleBinding.Converter = new ValueToVisibleConverter();
BindingOperations.SetBinding(panel, Panel.VisibilityProperty, isVisibleBinding);
}
DependencyProperty dependencyProperty = this.GetDependencyProperty(property.PropertyType);
if (!BindingOperations.IsDataBound(control, dependencyProperty))
{
Binding binding = new Binding(property.Name);
if (property.PropertyType.Is <id>() || property.GetSetMethod() == null)
{
binding.Mode = BindingMode.OneWay;
}
if (property.PropertyType.IsEnum)
{
binding.Mode = BindingMode.OneWay; //В другую сторону будет обрабатываться через код
binding.Converter = new EnumToIntConverter();
}
BindingOperations.SetBinding(control, dependencyProperty, binding);
}
}
internal int GetTabsCount()
{
if (BindingOperations.IsDataBound(this, ItemsSourceProperty))
{
IList list = ItemsSource as IList;
if (list != null)
{
return(list.Count);
}
// ItemsSource is only an IEnumerable.
// Check the ItemsSource nullable to make sure the designer show it correctly.
if (ItemsSource != null)
{
int i = 0;
IEnumerator enumerator = ItemsSource.GetEnumerator();
while (enumerator.MoveNext())
{
i++;
}
return(i);
}
}
if (Items != null)
{
return(Items.Count);
}
return(0);
}
/// <summary>
/// Gets control which represents quick access toolbar item
/// </summary>
/// <param name="element">Host control</param>
/// <returns>Control which represents quick access toolbar item</returns>
public static FrameworkElement?GetQuickAccessItem(UIElement element)
{
FrameworkElement?result = null;
// If control supports the interface just return what it provides
if (element is IQuickAccessItemProvider provider &&
provider.CanAddToQuickAccessToolBar)
{
result = provider.CreateQuickAccessItem();
}
// The control isn't supported
if (result is null)
{
throw new ArgumentException("The contol " + element.GetType().Name + " is not able to provide a quick access toolbar item");
}
RibbonProperties.SetIsElementInQuickAccessToolBar(result, true);
if (BindingOperations.IsDataBound(result, UIElement.VisibilityProperty) == false)
{
RibbonControl.Bind(element, result, nameof(UIElement.Visibility), UIElement.VisibilityProperty, BindingMode.OneWay);
}
if (BindingOperations.IsDataBound(result, UIElement.IsEnabledProperty) == false)
{
RibbonControl.Bind(element, result, nameof(UIElement.IsEnabled), UIElement.IsEnabledProperty, BindingMode.OneWay);
}
return(result);
}
private static object CoerceHasError(DependencyObject d, Object baseValue)
{
var ret = (bool)baseValue;
if (BindingOperations.IsDataBound(d, HasErrorProperty))
{
if (GetHasErrorDescriptor(d) == null)
{
var desc = DependencyPropertyDescriptor.FromProperty(Validation.HasErrorProperty, d.GetType());
desc.AddValueChanged(d, OnHasErrorChanged);
SetHasErrorDescriptor(d, desc);
ret = Validation.GetHasError(d);
}
}
else
{
if (GetHasErrorDescriptor(d) != null)
{
var desc = GetHasErrorDescriptor(d);
desc.RemoveValueChanged(d, OnHasErrorChanged);
SetHasErrorDescriptor(d, null);
}
}
return(ret);
}
private void ButtonOK_Click(object sender, RoutedEventArgs e)
{
//TODO make array and document types use this as well
foreach (var ctrl in customControls)
{
var control = ctrl.EditControl;
var values = control.GetLocalValueEnumerator();
while (values.MoveNext())
{
var current = values.Current;
if (BindingOperations.IsDataBound(control, current.Property))
{
var binding = control.GetBindingExpression(current.Property);
if (binding.IsDirty)
{
binding.UpdateSource();
}
}
}
}
if (documentReference != null)
{
documentReference.LiteDocument = currentDocument;
documentReference.Collection.UpdateItem(documentReference);
}
DialogResult = true;
Close();
}
public static FrameworkElement GetQuickAccessItem(UIElement element)
{
FrameworkElement result = null;
// If control supports the interface just return what it provides
var provider = element as IQuickAccessItemProvider;
if (provider != null &&
provider.CanAddToQuickAccessToolBar)
{
result = ((IQuickAccessItemProvider)element).CreateQuickAccessItem();
}
// The control isn't supported
if (result == null)
{
throw new ArgumentException("The contol " + element.GetType().Name + " is not able to provide a quick access toolbar item");
}
if (BindingOperations.IsDataBound(result, UIElement.VisibilityProperty) == false)
{
RibbonControl.Bind(element, result, "Visibility", UIElement.VisibilityProperty, BindingMode.OneWay);
}
if (BindingOperations.IsDataBound(result, UIElement.IsEnabledProperty) == false)
{
RibbonControl.Bind(element, result, "IsEnabled", UIElement.IsEnabledProperty, BindingMode.OneWay);
}
return(result);
}
void OnTaskCompleted(IProgressTask task)
{
switch (task.TaskNongeneric.Status)
{
case TaskStatus.RanToCompletion:
{
previousTask = task;
ProgressVisibility = Visibility.Collapsed;
if (!BindingOperations.IsDataBound(contentPresenter, ContentPresenter.ContentProperty))
{
contentPresenter.SetBinding(
ContentPresenter.ContentProperty,
new Binding("Child")
{
Source = this
}
);
}
childDataContext.Self = task.ResultNongeneric;
break;
}
case TaskStatus.Faulted:
case TaskStatus.Canceled:
Task = previousTask;
break;
default:
throw new InvalidOperationException();
}
}
//=====================================================================
/// <summary>
/// This is used to commit pending changes to the data source from
/// a bound object and its children.
/// </summary>
/// <param name="parent">The parent object</param>
public static void CommitChanges(this DependencyObject parent)
{
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
var localValues = parent.GetLocalValueEnumerator();
while (localValues.MoveNext())
{
var entry = localValues.Current;
if (BindingOperations.IsDataBound(parent, entry.Property))
{
var binding = BindingOperations.GetBindingExpression(parent, entry.Property);
if (binding != null)
{
binding.UpdateSource();
}
}
}
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
{
VisualTreeHelper.GetChild(parent, i).CommitChanges();
}
}
private static void dataGrid_Loaded(object sender, RoutedEventArgs e)
{
DataGrid dataGrid = sender as DataGrid;
if (dataGrid == null)
{
return;
}
if (BindingOperations.IsDataBound(dataGrid, DataGrid.ItemsSourceProperty))
{
Binding b = BindingOperations.GetBinding(dataGrid, DataGrid.ItemsSourceProperty);
dataGrid.TargetUpdated += new EventHandler <DataTransferEventArgs>(dataGrid_TargetUpdated);
string xaml = XamlWriter.Save(b);
Binding b2 = XamlReader.Parse(xaml) as Binding;
if (b2 != null)
{
b2.NotifyOnTargetUpdated = true;
BindingOperations.ClearBinding(dataGrid, DataGrid.ItemsSourceProperty);
BindingOperations.SetBinding(dataGrid, DataGrid.ItemsSourceProperty, b2);
}
}
else
{
SetupColumnHeaders(dataGrid);
}
}
internal TabItem GetTabItem(int index)
{
TabItem result;
if (BindingOperations.IsDataBound(this, ItemsControl.ItemsSourceProperty))
{
IList list = base.ItemsSource as IList;
if (list != null)
{
result = (base.ItemContainerGenerator.ContainerFromItem(list[index]) as TabItem);
}
else
{
int i = 0;
IEnumerator enumerator = base.ItemsSource.GetEnumerator();
while (enumerator.MoveNext())
{
if (i == index)
{
result = (base.ItemContainerGenerator.ContainerFromItem(enumerator.Current) as TabItem);
return(result);
}
i++;
}
result = null;
}
}
else
{
result = (base.Items[index] as TabItem);
}
return(result);
}
internal int GetTabsCount()
{
if (BindingOperations.IsDataBound(this, ItemsSourceProperty))
{
IList list = ItemsSource as IList;
if (list != null)
{
return(list.Count);
}
// ItemsSource is only an IEnumerable
int i = 0;
IEnumerator enumerator = ItemsSource.GetEnumerator();
while (enumerator.MoveNext())
{
i++;
}
return(i);
}
if (Items != null)
{
return(Items.Count);
}
return(0);
}
/// <summary>
/// Gets all bindings.
/// </summary>
/// <param name="obj">The obj.</param>
/// <returns></returns>
/// <remarks>http://stackoverflow.com/questions/5150983/how-to-invoke-updatesource-for-all-bindings-on-the-form</remarks>
public static IEnumerable <BindingExpression> GetAllBindings(this DependencyObject obj)
{
var stack = new Stack <DependencyObject>();
stack.Push(obj);
while (stack.Count > 0)
{
var cur = stack.Pop();
var lve = cur.GetLocalValueEnumerator();
while (lve.MoveNext())
{
if (BindingOperations.IsDataBound(cur, lve.Current.Property))
{
yield return(lve.Current.Value as BindingExpression);
}
}
int count = VisualTreeHelper.GetChildrenCount(cur);
for (int i = 0; i < count; ++i)
{
var child = VisualTreeHelper.GetChild(cur, i);
if (child is FrameworkElement)
{
stack.Push(child);
}
}
}
}
/// <summary>
/// Recorre todas las validaciones cargadas en el pariente para desactivarlas
/// </summary>
/// <param name="parent"></param>
public static void LimpiarValidaciones(DependencyObject parent)
{
LocalValueEnumerator localValues = parent.GetLocalValueEnumerator();
while (localValues.MoveNext())
{
LocalValueEntry entry = localValues.Current;
if (BindingOperations.IsDataBound(parent, entry.Property))
{
Binding binding = BindingOperations.GetBinding(parent, entry.Property);
foreach (ValidationRule reglaValidacion in binding.ValidationRules)
{
ValidationResult result = reglaValidacion.Validate(parent.GetValue(entry.Property), null);
if (!result.IsValid)
{
BindingExpression expresion = BindingOperations.GetBindingExpression(parent, entry.Property);
System.Windows.Controls.Validation.ClearInvalid(expresion);
}
}
}
}
for (int i = 0; i != VisualTreeHelper.GetChildrenCount(parent); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(parent, i);
LimpiarValidaciones(child);
}
}
private static void ComputeAutoToolTip(TextBlock textBlock)
{
//
// If the text block is not loaded, it doesn't make sense to check the ActualWidth.
//
if (!textBlock.IsLoaded)
{
return;
}
//
// A ToolTip should be generated if it was not set locally by the user. Hence, if both:
// 1. The ToolTip is not data bound in the xaml (by the user)
// 2. The ToolTip is generated before OR [it is null (i.e. not set by the user)]
//
if (
textBlock.Tag != null ||
!(BindingOperations.IsDataBound(textBlock, FrameworkElement.ToolTipProperty) && textBlock.ToolTip != null)
)
{
textBlock.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
var width = textBlock.DesiredSize.Width - textBlock.Margin.Left - textBlock.Margin.Right;
ToolTipService.SetToolTip(textBlock, textBlock.ActualWidth < width ? textBlock.Text : null);
ToolTipService.SetShowOnDisabled(textBlock, true);
//
// Ok ok, let's use a tag to indicate the tooltip was generated (and thus, could be not-null).
// Don't use some cached list with TextBlocks because this will lead to memory leaks.
//
textBlock.Tag = new object();
}
}
private static void EndEditing(DependencyObject dependencyObject)
{
Debug.Assert(dependencyObject != null);
// When in custom control templates, the GetLocalValueEnumerator doesn't return bound values to the templated parent, so I iterate All properties.
foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(dependencyObject, new Attribute[] { new PropertyFilterAttribute(PropertyFilterOptions.All) }))
{
DependencyPropertyDescriptor dependencyPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(propertyDescriptor);
if (dependencyPropertyDescriptor != null)
{
DependencyProperty dependencyProperty = dependencyPropertyDescriptor.DependencyProperty;
if (BindingOperations.IsDataBound(dependencyObject, dependencyProperty))
{
BindingExpression binding = BindingOperations.GetBindingExpression(dependencyObject, dependencyProperty);
if (binding != null)
{
binding.UpdateSource();
}
}
}
}
int childrenCount = VisualTreeHelper.GetChildrenCount(dependencyObject);
for (int i = 0; i < childrenCount; i++)
{
DependencyObject childDependencyObject = VisualTreeHelper.GetChild(dependencyObject, i);
EndEditing(childDependencyObject);
}
}
/// <summary>
/// Marks the specified FrameworkElement as invalid using the DummyRule
/// in combination with the DummyErrorProperty to fabricate a ValidationError.
/// </summary>
/// <param name="frameworkElement">The framework element that is supposed to have a validation error.</param>
/// <param name="errorContent">Content of the error that is added to the framework element.</param>
/// <param name="newMark">if set to <c>true</c> a new error is simply added else
/// any existing error is cleared before adding.</param>
/// <exception cref="ArgumentNullException" />
public static void MarkInvalid(FrameworkElement frameworkElement, object errorContent, bool newMark)
{
if (frameworkElement == null)
{
throw new ArgumentNullException("Argument 'frameworkElement' must not be null.");
}
if (newMark)
{
DummyRule.ClearInvalid(frameworkElement);
}
if (!BindingOperations.IsDataBound(frameworkElement, DummyRule.DummyErrorProperty))
{
DummyRule rule = new DummyRule(false, errorContent);
Binding binding = new Binding("ErrorContent")
{
Source = rule
};
binding.ValidationRules.Add(rule);
BindingOperations.SetBinding(frameworkElement, DummyRule.DummyErrorProperty, binding);
BindingExpression bindex = BindingOperations.GetBindingExpression(frameworkElement, DummyRule.DummyErrorProperty);
Validation.MarkInvalid(bindex, new ValidationError(rule, binding, errorContent, null));
bindex.UpdateSource();
}
}
public void CreateStateEditorTest()
{
var element = StateEditor.CreateElement(new object(), BindingMode.Default);
Assert.IsNotNull(element);
Assert.IsTrue(BindingOperations.IsDataBound(element, Selector.SelectedValueProperty));
}
/// <summary>
/// Returns a value that indicates whether the specified property is currently data-bound.
/// </summary>
/// <param name="target">The object where <paramref name="property"/> is.</param>
/// <param name="property">The dependency property to check.</param>
/// <returns>True if the specified property is data-bound, otherwise False.</returns>
public static bool IsDataBound(DependencyObject target, DependencyProperty property)
{
#if NETFX_CORE
return(target.ReadLocalValue(property) is BindingExpressionBase);
#else
return(BindingOperations.IsDataBound(target, property));
#endif
}
/// <summary>
/// Binds default properties of control to quick access element
/// </summary>
/// <param name="source">Source item</param>
/// <param name="element">Toolbar item</param>
public static void BindQuickAccessItem(FrameworkElement source, FrameworkElement element)
{
Bind(source, element, nameof(source.DataContext), DataContextProperty, BindingMode.OneWay);
if (source is ICommandSource)
{
if (source is MenuItem)
{
Bind(source, element, nameof(ICommandSource.CommandParameter), System.Windows.Controls.MenuItem.CommandParameterProperty, BindingMode.OneWay);
Bind(source, element, nameof(ICommandSource.CommandTarget), System.Windows.Controls.MenuItem.CommandTargetProperty, BindingMode.OneWay);
Bind(source, element, nameof(ICommandSource.Command), System.Windows.Controls.MenuItem.CommandProperty, BindingMode.OneWay);
}
else
{
Bind(source, element, nameof(ICommandSource.CommandParameter), ButtonBase.CommandParameterProperty, BindingMode.OneWay);
Bind(source, element, nameof(ICommandSource.CommandTarget), ButtonBase.CommandTargetProperty, BindingMode.OneWay);
Bind(source, element, nameof(ICommandSource.Command), ButtonBase.CommandProperty, BindingMode.OneWay);
}
}
Bind(source, element, nameof(FontFamily), FontFamilyProperty, BindingMode.OneWay);
Bind(source, element, nameof(FontSize), FontSizeProperty, BindingMode.OneWay);
Bind(source, element, nameof(FontStretch), FontStretchProperty, BindingMode.OneWay);
Bind(source, element, nameof(FontStyle), FontStyleProperty, BindingMode.OneWay);
Bind(source, element, nameof(FontWeight), FontWeightProperty, BindingMode.OneWay);
Bind(source, element, nameof(Foreground), ForegroundProperty, BindingMode.OneWay);
Bind(source, element, nameof(IsEnabled), IsEnabledProperty, BindingMode.OneWay);
Bind(source, element, nameof(Opacity), OpacityProperty, BindingMode.OneWay);
Bind(source, element, nameof(SnapsToDevicePixels), SnapsToDevicePixelsProperty, BindingMode.OneWay);
Bind(source, element, new PropertyPath(FocusManager.IsFocusScopeProperty), FocusManager.IsFocusScopeProperty, BindingMode.OneWay);
if (source is IHeaderedControl headeredControl)
{
if (headeredControl is HeaderedItemsControl)
{
Bind(source, element, nameof(HeaderedItemsControl.Header), HeaderedItemsControl.HeaderProperty, BindingMode.OneWay);
Bind(source, element, nameof(HeaderedItemsControl.HeaderStringFormat), HeaderedItemsControl.HeaderStringFormatProperty, BindingMode.OneWay);
Bind(source, element, nameof(HeaderedItemsControl.HeaderTemplate), HeaderedItemsControl.HeaderTemplateProperty, BindingMode.OneWay);
Bind(source, element, nameof(HeaderedItemsControl.HeaderTemplateSelector), HeaderedItemsControl.HeaderTemplateSelectorProperty, BindingMode.OneWay);
}
else
{
Bind(source, element, nameof(IHeaderedControl.Header), HeaderProperty, BindingMode.OneWay);
}
if (source.ToolTip is not null ||
BindingOperations.IsDataBound(source, ToolTipProperty))
{
Bind(source, element, nameof(ToolTip), ToolTipProperty, BindingMode.OneWay);
}
else
{
Bind(source, element, nameof(IHeaderedControl.Header), ToolTipProperty, BindingMode.OneWay);
}
}
/// <summary>
/// Checks all the validation rules associated with objects, forces the binding to execute all their validation rules.
/// </summary>
/// <param name="parent">The parent <see cref="DependencyObject"/>.</param>
/// <returns>True if valid.</returns>
public static bool IsValid(DependencyObject parent)
{
// parent properties validation
var valid = true;
// get the list of all the dependency properties, we can use a level of caching to avoid to use reflection
// more than one time for each object
foreach (var dp in GetDepenedencyProperties(parent.GetType()))
{
if (!BindingOperations.IsDataBound(parent, dp))
{
continue;
}
var binding = BindingOperations.GetBinding(parent, dp);
if ((binding == null) || (binding.ValidationRules.Count <= 0))
{
continue;
}
var expression = BindingOperations.GetBindingExpression(parent, dp);
if (expression == null)
{
continue;
}
switch (binding.Mode)
{
case BindingMode.OneTime:
case BindingMode.OneWay:
expression.UpdateTarget();
break;
default:
expression.UpdateSource();
break;
}
if (expression.HasError)
{
valid = false;
}
}
// Children properties validation
for (var i = 0; i != VisualTreeHelper.GetChildrenCount(parent); ++i)
{
var child = VisualTreeHelper.GetChild(parent, i);
if (!IsValid(child))
{
valid = false;
}
}
return(valid);
}
protected override void OnValueChanged(double oldValue, double newValue)
{
base.OnValueChanged(oldValue, newValue);
if (!this.m_withinChanging && !BindingOperations.IsDataBound(this, HueProperty))
{
this.m_withinChanging = true;
this.Hue = 360.0 - newValue;
this.m_withinChanging = false;
}
}
private async void btnSaveTxt2Bin_Click(object sender, RoutedEventArgs e)
{
// Выключим кнопку записи в файл чтобы сто раз не жмакали
// так как у нас включен биндинг, нужно его засейвить потом ресторить.
var btn = ((Button)sender);
BindingBase binding = null;
if (BindingOperations.IsDataBound(btn, IsEnabledProperty))
{
binding = BindingOperations.GetBinding(btn, IsEnabledProperty) ??
(BindingBase)BindingOperations.GetMultiBinding(btn, IsEnabledProperty);
}
btn.IsEnabled = false;
// Читаем ввод пользователя. Валидация ввода провдится еще в фазе ввода в форму.
var binPrefix = tbxBinPrefix.Text;
var filePath = tbxTxtPath.Text;
// Инициализируем прогресс бар
prgbTxt2Bin.IsIndeterminate = true;
// прогрессор, будет апдейтить прогрессбар и строку статуса
var progress = new Progress <ProgressReport>(report =>
{
var str = "";
if (report.Finished)
{
str = "Обработано: {0} Затрачено: {1}".Put(report.ProcessedCount, report.TimeUsed);
}
else
{
str = "Обработано: {0} Текущий: {1} Затрачено: {2}".Put(report.ProcessedCount, report.Date.Date.ToShortDateString(), report.TimeUsed);
}
lblBarProcessStatus.Content = str;
});
// заводим асинхронно конвертацию, если будут ошибки, они хэндлятся штатным образом.
try
{
await Common.TxtToBinTradesAsync(filePath, binPrefix, progress);
}
catch (Exception ex)
{
Trace.Fail(ex.ToString());
lblBarProcessStatus.Content = "Error: {0}".Put(ex.Message);
this.UpdateLayout();
}
// восстановим биндинг кнопки, сбросим прогрессбар
btn.SetBinding(IsEnabledProperty, binding);
prgbTxt2Bin.IsIndeterminate = false;
prgbTxt2Bin.Value = 0;
}