private static void TintPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
var value = obj?.GetValue(TintProperty);
if (!(value is Color)) return;
var tint = (Color) value;
obj.SetCurrentValue(LightTintProperty, tint.Lighten(0.1f));
obj.SetCurrentValue(DarkTintProperty, tint.Darken(0.1f));
}
protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
{
if (!Equals(element, item))
element.SetCurrentValue(DataContextProperty, item); //dont want to set the datacontext to itself.
base.PrepareContainerForItemOverride(element, item);
}
protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
{
if (element != item)
element.SetCurrentValue(DataContextProperty, item); //dont want to set the datacontext to itself. taken from MetroTabControl.cs
base.PrepareContainerForItemOverride(element, item);
}
internal static void InternalSetIsValid(DependencyObject obj, bool value)
{
if (GetIsValid(obj) != value)
{
// Only change the value when it is different; otherwise unnecessary binding updates are raised.
obj.SetCurrentValue(IsValidProperty, value);
}
}
private static void Clone(DependencyObject from, DependencyObject to)
{
var localValueEnumerator = from.GetLocalValueEnumerator();
while (localValueEnumerator.MoveNext())
{
if (localValueEnumerator.Current.Property.ReadOnly ||
localValueEnumerator.Current.Value is FrameworkElement) continue;
if (!(localValueEnumerator.Current.Value is BindingExpressionBase))
to.SetCurrentValue(localValueEnumerator.Current.Property, localValueEnumerator.Current.Value);
}
}
static void EnsureHidden(DependencyObject d)
{
if (Visibility.Visible.Equals(d.GetValue(UIElement.VisibilityProperty))) {
d.SetCurrentValue(UIElement.VisibilityProperty, Visibility.Hidden);
}
}
private static void OnCellItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (Equals(d.GetValue(IsUpdatingProperty), BooleanBoxes.True))
{
return;
}
d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.True);
try
{
var dataGrid = (DataGrid)d;
dataGrid.UnselectAllCells();
if (e.NewValue == null)
{
dataGrid.SetIndex(null);
return;
}
for (var r = 0; r < dataGrid.Items.Count; r++)
{
for (var c = 0; c < dataGrid.Columns.Count; c++)
{
var column = dataGrid.Columns[c];
var cellItem = GetCellItem(column, dataGrid.Items[r]);
if (Equals(cellItem, e.NewValue))
{
var index = new RowColumnIndex(r, c);
dataGrid.SetIndex(index);
var cell = dataGrid.GetCell(index);
cell.SetCurrentValue(DataGridCell.IsSelectedProperty, true);
return;
}
}
}
dataGrid.SetIndex(null);
}
finally
{
d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.False);
}
}
/// <summary>
/// Sets the IsThreeState property. This dependency property
/// indicates whether the control supports two or three states.
/// IsChecked can be set to null as a third state when IsThreeState is true.
/// </summary>
public static void SetIsThreeState(DependencyObject d, bool value)
{
d.SetCurrentValue(IsThreeStateProperty, value);
}
private static void OnIndexChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (Equals(d.GetValue(IsUpdatingProperty), BooleanBoxes.True))
{
return;
}
d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.True);
try
{
var dataGrid = (DataGrid)d;
dataGrid.UnselectAllCells();
var rowColumnIndex = (RowColumnIndex?)e.NewValue;
if (rowColumnIndex == null)
{
return;
}
var cell = dataGrid.GetCell(rowColumnIndex.Value);
cell?.SetCurrentValue(DataGridCell.IsSelectedProperty, true);
UpdateSelectedCellItemFromView(dataGrid);
}
finally
{
d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.False);
}
}
/// <summary>
/// Sets the IsVirtualToggleButton property. This dependency property
/// indicates whether the object to which the property is attached is treated as a VirtualToggleButton.
/// If true, the object will respond to keyboard and mouse input the same way a ToggleButton would.
/// </summary>
public static void SetIsVirtualToggleButton(DependencyObject d, bool value)
{
d.SetCurrentValue(IsVirtualToggleButtonProperty, value);
}
/// <summary>
/// Sets the IsChecked property. This dependency property
/// indicates whether the toggle button is checked.
/// </summary>
public static void SetIsChecked(DependencyObject d, bool? value)
{
d.SetCurrentValue(IsCheckedProperty, value);
}
public static void SetTargetVisual(DependencyObject obj, UIElement value)
{
obj.SetCurrentValue(TargetVisualProperty, value);
}
public static void SetDimmerOpacity(DependencyObject obj, double value)
{
obj.SetCurrentValue(DimmerOpacityProperty, value);
}
public static void SetDimBackground(DependencyObject obj, bool value)
{
obj.SetCurrentValue(DimBackgroundProperty, value);
}
private static void OnSourceProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
d.SetCurrentValue(TargetProxyProperty, e.NewValue);
}
public static void SetDimmerBrush(DependencyObject obj, Brush value)
{
obj.SetCurrentValue(DimmerBrushProperty, value);
}
public static void SetDimTransitionDuration(DependencyObject obj, Duration value)
{
obj.SetCurrentValue(DimTransitionDurationProperty, value);
}
public static void SetAddMargins(DependencyObject obj, bool value)
{
obj.SetCurrentValue(AddMarginsProperty, value);
}
private static void OnPropertySourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (e.NewValue == null)
{
d.SetCurrentValue(TransposedSourceProperty, null);
}
else
{
var source = CreateSingletonEnumerable(e.NewValue);
d.SetCurrentValue(TransposedSourceProperty, source);
}
}
private static void OnTextProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Debug.WriteLine(e);
var baseBox = (BaseBox)d;
if (baseBox.Status == Status.Idle)
{
baseBox.Status = Status.UpdatingFromUserInput;
baseBox.TextSource = TextSource.UserInput;
d.SetCurrentValue(TextBindableProperty, e.NewValue);
baseBox.Status = Status.Idle;
}
}
private void SetCurrentValue (DependencyObject tranformation, DependencyProperty dp, double value)
{
_Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate()
{
tranformation.SetCurrentValue(dp, value);
}));
}
public static void SetBusyState(DependencyObject obj, bool value)
{
obj.SetCurrentValue(BusyStateProperty, value);
}
private static void OnErrorsProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
d.SetCurrentValue(ErrorsProperty, e.NewValue);
}
/// <summary>
/// Sets all values saved in ItemValueStorage for the given item onto the container
/// </summary>
/// <param name="container"></param>
/// <param name="item"></param>
private void SetItemValuesOnContainer(DependencyObject container, object item, int[] dpIndices)
{
List<KeyValuePair<int, object>> itemValues = GetItemValues(item);
if (itemValues != null)
{
for (int i = 0; i < itemValues.Count; i++)
{
int dpIndex = itemValues[i].Key;
for (int j = 0; j < dpIndices.Length; j++)
{
if (dpIndex == dpIndices[j])
{
object value = itemValues[i].Value;
EntryIndex entryIndex = container.LookupEntry(dpIndex);
ModifiedItemValue modifiedItemValue = value as ModifiedItemValue;
DependencyProperty dp = DependencyProperty.RegisteredPropertyList.List[dpIndex];
if (modifiedItemValue == null)
{
// set as local value
if (dp != null)
{
// for real properties, call SetValue so that the property's
// change-callback is called
container.SetValue(dp, value);
}
else
{
// for "fake" properties (no corresponding DP - e.g. VSP's desired-size),
// set the property directly into the effective value table
container.SetEffectiveValue(entryIndex, null /*dp*/, dpIndex, null /*metadata*/, value, BaseValueSourceInternal.Local);
}
}
else if (modifiedItemValue.IsCoercedWithCurrentValue)
{
// set as current-value
container.SetCurrentValue(dp, modifiedItemValue.Value);
}
break;
}
}
}
}
}
