private static void OnIsClickedByUserChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (((bool)e.NewValue) == true)
{
(d as DataPoint).UpdateSelection();
}
}
private static void RequestViewPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (d is MapView)
{
MapView mapView = d as MapView;
if (e.NewValue is Geometry)
{
if (mapView.Extent != null)
{
var _ = mapView.SetViewAsync((Geometry)e.NewValue);
}
else //Map not ready, wait till we have an extent and try again
{
//We could just set the InitialExtent instead, but this gives a cool zoom in effect.
EventHandler handler = null;
handler = async (s, e2) =>
{
mapView.ExtentChanged -= handler;
await Task.Delay(500); //Wait a little so map loads a little before zooming first time (better experience)
var __ = mapView.SetViewAsync((Geometry)e.NewValue);
};
mapView.ExtentChanged += handler;
}
}
}
}
private static void OnBehaviorsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var oldBehaviorCollection = (BehaviorCollection)e.OldValue;
var newBehaviorCollection = (BehaviorCollection)e.NewValue;
if (oldBehaviorCollection == newBehaviorCollection)
{
return;
}
if (oldBehaviorCollection != null)
{
#if WINDOWS_PHONE
var associatedObject = typeof(BehaviorCollection)
.GetProperty("AssociatedObject", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(oldBehaviorCollection);
#else
var associatedObject = oldBehaviorCollection.AssociatedObject;
#endif
if (associatedObject != null)
{
oldBehaviorCollection.Detach();
}
}
if (newBehaviorCollection == null || d == null)
{
return;
}
newBehaviorCollection.Attach(d);
}
/// <summary>
/// AxisLabelStyleProperty property changed handler.
/// </summary>
/// <param name="d">DisplayAxis that changed its AxisLabelStyle.</param>
/// <param name="e">Event arguments.</param>
private static void OnAxisLabelStylePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
DisplayAxis source = (DisplayAxis)d;
Style oldValue = (Style)e.OldValue;
Style newValue = (Style)e.NewValue;
source.OnAxisLabelStylePropertyChanged(oldValue, newValue);
}
private static void OnTriggersChanged(IDependencyObject obj, DependencyPropertyChangedEventArgs args)
{
var triggerCollection1 = args.OldValue as TriggerCollection;
var triggerCollection2 = args.NewValue as TriggerCollection;
if (triggerCollection1 == triggerCollection2)
{
return;
}
if (triggerCollection1 != null && triggerCollection1.AssociatedObject != null)
{
triggerCollection1.Detach();
}
if (triggerCollection2 == null || obj == null)
{
return;
}
if (triggerCollection2.AssociatedObject != null)
{
throw new InvalidOperationException("Cannot attach TriggerCollection multiple imes");
}
var fElement = obj as FormElement;
if (fElement == null)
{
throw new InvalidOperationException("Can only host TriggerCollection on FormElement");
}
triggerCollection2.Attach(fElement);
}
//------------------------------------------------------
//
// Public Properties
//
//-----------------------------------------------------
private static void PositionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
PointLightBase target = ((PointLightBase) d);
target.PropertyChanged(PositionProperty);
}
/// <summary>
/// RatioVisibleProperty property changed handler.
/// </summary>
/// <param name="d">PartialView that changed its RatioVisible.</param>
/// <param name="e">Event arguments.</param>
private static void OnRatioVisibleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Clipper source = (Clipper)d;
double oldValue = (double)e.OldValue;
double newValue = (double)e.NewValue;
source.OnRatioVisibleChanged(oldValue, newValue);
}
/// <summary>
/// Handles changes to the MenuFlyout DependencyProperty.
/// </summary>
/// <param name="o">DependencyObject that changed.</param>
/// <param name="e">Event data for the DependencyPropertyChangedEvent.</param>
private static void OnMenuFlyoutChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
var element = o as FrameworkElement;
if (null != element)
{
// just in case we were here before and there is no new menu
element.Holding -= OnElementHolding;
MenuFlyout oldMenuFlyout = e.OldValue as MenuFlyout;
if (null != oldMenuFlyout)
{
// Remove previous attachment
element.SetValue(FlyoutBase.AttachedFlyoutProperty, null);
}
MenuFlyout newMenuFlyout = e.NewValue as MenuFlyout;
if (null != newMenuFlyout)
{
// attach using FlyoutBase to easier show the menu
element.SetValue(FlyoutBase.AttachedFlyoutProperty, newMenuFlyout);
// need to show it
element.Holding += OnElementHolding;
}
}
}
/// <summary>
/// LocationProperty property changed handler.
/// </summary>
/// <param name="d">Axis that changed its Location.</param>
/// <param name="e">Event arguments.</param>
private static void OnLocationPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Axis source = (Axis)d;
AxisLocation oldValue = (AxisLocation)e.OldValue;
AxisLocation newValue = (AxisLocation)e.NewValue;
source.OnLocationPropertyChanged(oldValue, newValue);
}
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
private static void DirectionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
DirectionalLight target = ((DirectionalLight) d);
target.PropertyChanged(DirectionProperty);
}
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
private static void MatrixPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
MatrixTransform3D target = ((MatrixTransform3D) d);
target.PropertyChanged(MatrixProperty);
}
static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
var parameter = (Parameter)d;
if (parameter.Owner != null) {
parameter.Owner.UpdateAvailability();
}
}
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
private static void ColorPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
EmissiveMaterial target = ((EmissiveMaterial) d);
target.PropertyChanged(ColorProperty);
}
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
private static void FieldOfViewPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
PerspectiveCamera target = ((PerspectiveCamera) d);
target.PropertyChanged(FieldOfViewProperty);
}
private static void OnOtherContentTemplatePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var panControl = d as PanControl;
if (panControl == null) return;
panControl.OnOtherContentTemplateChanged((DataTemplate)e.OldValue, (DataTemplate)e.NewValue);
}
/// <summary>
/// IsCheckedProperty property changed handler.
/// </summary>
/// <param name="d">ToggleButton that changed its IsChecked.</param>
/// <param name="e">DependencyPropertyChangedEventArgs.</param>
private static void OnIsCheckedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ToggleButton source = d as ToggleButton;
System.Diagnostics.Debug.Assert(source != null,
"The source is not an instance of ToggleButton!");
System.Diagnostics.Debug.Assert(typeof(bool?).IsInstanceOfType(e.NewValue) || (e.NewValue == null),
"The value is not an instance of bool?!");
bool? value = (bool?) e.NewValue;
// Raise the appropriate changed event
RoutedEventArgs args = new RoutedEventArgs () { OriginalSource = source};
if (value == true)
{
source.OnChecked(args);
}
else if (value == false)
{
source.OnUnchecked(args);
}
else
{
source.OnIndeterminate(args);
}
}
private static void OnIsSelecedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var control = d as BigTabBarItem;
if (control == null || e.NewValue == null || e.NewValue == e.OldValue) return;
string state = (bool.Parse(e.NewValue.ToString())) ? "Selected" : "Unselected";
VisualStateManager.GoToState(control, state, true);
}
static void ModelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (Execute.InDesignMode || e.NewValue == null || e.NewValue == e.OldValue)
{
return;
}
var fe = d as FrameworkElement;
if (fe == null)
{
return;
}
View.ExecuteOnLoad(fe, delegate
{
var target = e.NewValue;
var containerKey = e.NewValue as string;
if (containerKey != null)
{
target = IoC.GetInstance(null, containerKey);
}
d.SetValue(View.IsScopeRootProperty, true);
var context = string.IsNullOrEmpty(fe.Name)
? fe.GetHashCode().ToString()
: fe.Name;
ViewModelBinder.Bind(target, d, context);
});
}
private static void OnMapPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ZoomSlider zs = d as ZoomSlider;
Map newValue = e.NewValue as Map;
Map oldValue = e.OldValue as Map;
if (oldValue != null)
{
oldValue.ViewBoundsChanged -= new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanged);
oldValue.ViewBoundsChanging -= new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanging);
if (oldValue.Layers != null)
{
oldValue.Layers.LayersInitialized -= new EventHandler(zs.Layers_LayersInitialized);
}
newValue.ResolutionsChanged -= new EventHandler<ResolutionsEventArgs>(zs.newValue_ResolutionsChanged);
}
if (newValue != null)
{
newValue.ViewBoundsChanged += new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanged);
newValue.ViewBoundsChanging += new EventHandler<ViewBoundsEventArgs>(zs.Map_ViewBoundsChanging);
if (newValue.Layers != null)
{
newValue.Layers.LayersInitialized += new EventHandler(zs.Layers_LayersInitialized);
}
//后设置Map的Scales也要起作用。
newValue.ResolutionsChanged += new EventHandler<ResolutionsEventArgs>(zs.newValue_ResolutionsChanged);
}
}
/// <summary>
/// Called when HeaderProperty is invalidated on "d."
/// </summary>
private static void OnHeaderChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
HeaderedItemsControl ctrl = (HeaderedItemsControl) d;
ctrl.SetValue(HasHeaderPropertyKey, (e.NewValue != null) ? BooleanBoxes.TrueBox : BooleanBoxes.FalseBox);
ctrl.OnHeaderChanged(e.OldValue, e.NewValue);
}
/// <summary>
/// MinimumDistanceBetweenChildrenProperty property changed handler.
/// </summary>
/// <param name="d">OrientedPanel that changed its MinimumDistanceBetweenChildren.</param>
/// <param name="e">Event arguments.</param>
private static void OnMinimumDistanceBetweenChildrenPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
OrientedPanel source = (OrientedPanel)d;
double oldValue = (double)e.OldValue;
double newValue = (double)e.NewValue;
source.OnMinimumDistanceBetweenChildrenPropertyChanged(oldValue, newValue);
}
private static void OnTargetChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
if (e.NewValue == null || obj == null)
return;
EditorAdapterBase target = e.NewValue as EditorAdapterBase;
EditorAdapterBase oldTarget = e.OldValue as EditorAdapterBase;
CompletionPopupView view = obj as CompletionPopupView;
EventHandler selectionChanged = (sender, args) => view.Publish(new SelectionChangedEvent(target.CaretIndex));
KeyEventHandler previewKeyDown = (sender, args) => view.Publish(new CancellableKeyEvent(args, EventSource.Editor));
KeyEventHandler keyUp = (sender, args) => view.Publish(new KeyUpEvent(args, EventSource.Editor));
KeyEventHandler keyDown = (sender, args) => view.Publish(new KeyEvent(args, EventSource.Editor));
if (target != null)
{
target.SelectionChanged += selectionChanged;
target.PreviewKeyDown += previewKeyDown;
target.KeyDown += keyDown;
target.KeyUp += keyUp;
}
if (oldTarget != null)
{
oldTarget.SelectionChanged -= selectionChanged;
target.PreviewKeyDown -= previewKeyDown;
target.KeyDown -= keyDown;
target.KeyUp -= keyUp;
}
}
private static void OnAttachChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Action<System.Windows.Interactivity.TriggerBase> action = null;
System.Windows.Interactivity.TriggerCollection allTriggers;
if (e.NewValue != e.OldValue)
{
System.Windows.Interactivity.TriggerBase[] enumerable = (System.Windows.Interactivity.TriggerBase[]) d.GetValue(MessageTriggersProperty);
allTriggers = Interaction.GetTriggers(d);
if (enumerable != null)
{
if (action == null)
{
action = (Action<System.Windows.Interactivity.TriggerBase>) (x => allTriggers.Remove(x));
}
enumerable.Apply<System.Windows.Interactivity.TriggerBase>(action);
}
System.Windows.Interactivity.TriggerBase[] baseArray2 = Parser.Parse(d, e.NewValue as string).ToArray<System.Windows.Interactivity.TriggerBase>();
baseArray2.Apply<System.Windows.Interactivity.TriggerBase>(new Action<System.Windows.Interactivity.TriggerBase>(allTriggers.Add));
if (baseArray2.Length > 0)
{
d.SetValue(MessageTriggersProperty, baseArray2);
}
else
{
d.ClearValue(MessageTriggersProperty);
}
}
}
//------------------------------------------------------
//
// Public Properties
//
//-----------------------------------------------------
private static void ViewMatrixPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
MatrixCamera target = ((MatrixCamera) d);
target.PropertyChanged(ViewMatrixProperty);
}
private static void OnIsSelectedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
BarPiece source = (BarPiece)d;
bool oldValue = (bool)e.OldValue;
bool newValue = (bool)e.NewValue;
source.OnIsSelectedPropertyChanged(oldValue, newValue);
}
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
private static void ColorPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Light target = ((Light) d);
target.PropertyChanged(ColorProperty);
}
/// <summary>
/// IsDraggingProperty property changed handler.
/// </summary>
/// <param name="d">Thumb that changed IsDragging.</param>
/// <param name="e">DependencyPropertyChangedEventArgs.</param>
private static void OnIsDraggingPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Thumb thumb = d as Thumb;
Debug.Assert(thumb != null);
thumb.OnDraggingChanged();
}
/// <summary>
/// SizeProperty property changed handler.
/// </summary>
/// <param name="d">BubbleDataPoint that changed its Size.</param>
/// <param name="e">Event arguments.</param>
private static void OnSizePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
BubbleDataPoint source = (BubbleDataPoint)d;
double oldValue = (double)e.OldValue;
double newValue = (double)e.NewValue;
source.OnSizePropertyChanged(oldValue, newValue);
}
/// <summary>
/// ExpandDirectionProperty property changed handler.
/// </summary>
/// <param name="d">ExpandDirectionView that changed its ExpandDirection.</param>
/// <param name="e">Event arguments.</param>
private static void OnExpandDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
LinearClipper source = (LinearClipper)d;
ExpandDirection oldValue = (ExpandDirection)e.OldValue;
ExpandDirection newValue = (ExpandDirection)e.NewValue;
source.OnExpandDirectionChanged(oldValue, newValue);
}
private static void OnSizePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
PredefinedMarkerStyle style = d as PredefinedMarkerStyle;
style.OnPropertyChanged("Size");
style.OnPropertyChanged("OffsetX");
style.OnPropertyChanged("OffsetY");
}
private static void OnSelectedItemChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
((DataSourcesControl)dependencyObject).OnSelectedItemChanged((IDataSourceViewModel)e.NewValue);
}
private void ViewModelChanged(object sender, DependencyPropertyChangedEventArgs e)
{
this.ViewModel_ = this.DataContext as StandardInstBaseViewModel;
this.ReferenceDatePicker_.DataContext = this.viewModel_;
this.PositionInfoGrid_.DataContext = this.viewModel_.InstPositionInfoViewModel_;
}
private void ScrollThumb_IsMouseCapturedChanged( object sender, DependencyPropertyChangedEventArgs e )
{
Thumb scrollThumb = sender as Thumb;
if( scrollThumb == null )
return;
if( !scrollThumb.IsMouseCaptured )
return;
if( !this.ShouldDisplayScrollTip )
return;
ScrollBar scrollBar = scrollThumb.TemplatedParent as ScrollBar;
if( scrollBar == null )
return;
// Register to LostMouseCapture to be sure to hide the ScrollTip when the ScrollThumb lost the focus
if( scrollThumb == m_horizontalScrollThumb )
{
m_horizontalScrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
}
else if( scrollThumb == m_verticalScrollThumb )
{
m_verticalScrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
}
else
{
Debug.Fail( "Unknown thumb used for scrolling." );
return;
}
DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
if( dataGridContext == null )
return;
if( dataGridContext.DataGridControl == null )
return;
// Update items scrolling orientation and pixel scrolling
m_itemsScrollingOrientation = ScrollViewerHelper.GetItemScrollingOrientation( dataGridContext.DataGridControl );
if( m_itemsScrollingOrientation == Orientation.Vertical )
{
if( scrollBar != m_verticalScrollBar )
return;
}
else
{
if( scrollBar != m_horizontalScrollBar )
return;
}
this.Visibility = Visibility.Visible;
this.IsPixelScrolling = ScrollViewerHelper.IsPixelScrolling( dataGridContext.DataGridControl, dataGridContext.DataGridControl.ItemsHost, dataGridContext.DataGridControl.ScrollViewer );
this.RefreshScrollTipContent( scrollBar );
}
private static void ParentGridControlPropertyChangedCallback( DependencyObject sender, DependencyPropertyChangedEventArgs e )
{
DataGridControl oldParentGridControl = e.OldValue as DataGridControl;
DataGridControl parentGridControl = e.NewValue as DataGridControl;
ScrollTip scrollTip = sender as ScrollTip;
scrollTip.IsInParentGridChanged = true;
try
{
if( oldParentGridControl != null )
{
if( scrollTip.UsingDefaultScrollTipContentTemplate )
{
// Unload DefaultTemplate
Xceed.Wpf.DataGrid.Views.UIViewBase uiViewBase = oldParentGridControl.GetView() as Xceed.Wpf.DataGrid.Views.UIViewBase;
if( uiViewBase != null )
{
uiViewBase.ClearValue( UIViewBase.ScrollTipContentTemplateProperty );
scrollTip.UsingDefaultScrollTipContentTemplate = false;
}
}
if( scrollTip.m_mainColumn != null )
{
PropertyChangedEventManager.RemoveListener( scrollTip.m_mainColumn, scrollTip, "DisplayMemberBinding" );
}
scrollTip.m_mainColumn = null;
scrollTip.m_horizontalScrollBar = null;
scrollTip.m_horizontalScrollThumb = null;
scrollTip.m_verticalScrollBar = null;
scrollTip.m_verticalScrollThumb = null;
scrollTip.UnregisterListeners( oldParentGridControl );
}
if( parentGridControl == null )
return;
scrollTip.PrepareDefaultStyleKey( parentGridControl.GetView() );
// Assert Template is applied in order to be notified for ScrollBars events
DataGridControl.SetDataGridContext( scrollTip, parentGridControl.DataGridContext );
if( !scrollTip.ApplyTemplate() )
scrollTip.RefreshDefaultScrollTipContentTemplate();
scrollTip.RegisterListeners( parentGridControl );
}
finally
{
scrollTip.IsInParentGridChanged = false;
}
}
void CustomerView_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
}
private static void OnDataSourcesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
((DataSourcesControl)d).OnDataSourcesChanged((IEnumerable <IDataSourceViewModel>)e.OldValue,
(IEnumerable <IDataSourceViewModel>)e.NewValue);
}
private static void OnStringFilterChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
((DataSourcesControl)dependencyObject).OnStringFilterChanged((string)e.OldValue, (string)e.NewValue);
}
private static async void OnSourcePropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
var element = dependencyObject as MediaElement;
if (element == null)
{
return;
}
var uri = e.NewValue as Uri;
await element.MediaCore.Open(uri);
}
private static void TypeIDPropertyChangedCallback(DependencyObject controlInstance, DependencyPropertyChangedEventArgs args)
{
((ItemDescriptionPanel)controlInstance).m_Model.TypeID = (TypeID)args.NewValue;
}
private static void OnStretchDirectionPropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
var element = dependencyObject as MediaElement;
if (element == null)
{
return;
}
element.VideoView.StretchDirection = (StretchDirection)e.NewValue;
}
private static void OnFlashingPeriodPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Led led = (Led)d;
led.timer.Interval = TimeSpan.FromMilliseconds((int)e.NewValue);
}
private static void IsSaveFileButtonBehaviorEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var button = d as FButton;
if (e.OldValue != e.NewValue && button != null)
{
button.CommandBindings.Add(SaveFileCommandBinding);
}
}
private static void ColumnsPropertyChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
var behavior = dependencyObject as DynamicGridColumnBehavior;
if (behavior == null)
{
return;
}
behavior.InitialiseColumns();
}
public static void OnValidationSummaryPropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
RadGridView gridView = dependencyObject as RadGridView;
bool isEnabled = (bool)e.NewValue;
if (gridView != null && isEnabled)
{
vGridValidationBehavior behavior = new vGridValidationBehavior(gridView, isEnabled);
}
}
private static void NavigationItemsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var control = d as ShellControl;
control.SelectFirstNavigationItem();
}
private void TimeDatePicker_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
TimeDatePicker.Background = Brushes.White;
}
private static void OnColonAtChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
((NumericField)d).OnColonAtChanged();
}
static void OnCpuUsageHistoryChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
((LiveDataChartElement)d).OnCpuUsageHistoryChanged((CpuUsageHistory)e.OldValue);
}
private static void OnRequestedStarMinWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
d.CoerceValue(RequestedStarMaxWidthProperty);
d.CoerceValue(AllocatedStarWidthProperty);
}
private static void DefaultCommandsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var control = d as ListToolbar;
control.UpdateControl();
}
static void OnWidthPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
RibbonToolBarControlDefinition definition = (RibbonToolBarControlDefinition) d;
definition.Invalidate("Width");
}
private void TextBox_IsEnabledChanged(object sender, DependencyPropertyChangedEventArgs e)
{
textBox.Text += Environment.NewLine;
textBox.Text += $"textBox.IsEnabled, OldValue:{e.OldValue}, NewValue:{e.NewValue}";
}
public void DCChange(object sender, DependencyPropertyChangedEventArgs args)
{
// StackPanel의 DataContext로 지정된 emps 컬렉션을 소스로 해서 ListCollectionView 생성
// 이를 이용하여 정렬, 탐색, 필터링 기능 등을 구현한다.
MyCollectionView = (ListCollectionView)CollectionViewSource.GetDefaultView(rootElement.DataContext);
}
private static void OnLoadingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var control = d as RadialMenuItemControl;
control.UpdateVisualState(true);
}
/// <summary>
/// VisibleStave changed callback.
/// </summary>
/// <param name="dependencyObject">The dependency object.</param>
/// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
private static void VisibleStaveChangedCallback(DependencyObject dependencyObject,
DependencyPropertyChangedEventArgs args)
{
}
private static void KindPropertyChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
if (e.NewValue != e.OldValue)
{
((PackIconSimpleIcons)dependencyObject).UpdateData();
}
}
/// <summary>
/// Bars changed callback.
/// </summary>
/// <param name="dependencyObject">The dependency object.</param>
/// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
private static void BarsChangedCallback(DependencyObject dependencyObject,
DependencyPropertyChangedEventArgs args)
{
}
private void btnHome_IsKeyboardFocusWithinChanged(object sender, DependencyPropertyChangedEventArgs e)
{
var imageBrush = (ImageBrush)btnHome.Background;
imageBrush.Stretch = Stretch.Fill;
}
/// <summary>
/// The visual appearance changed.
/// </summary>
/// <param name="d">The d.</param>
/// <param name="e">The <see cref="DependencyPropertyChangedEventArgs" /> instance containing the event data.</param>
private static void VisualChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
((BillboardTextGroupVisual3D)d).VisualChanged();
}
/// <summary>
/// TimeSignature changed callback.
/// </summary>
/// <param name="dependencyObject">The dependency object.</param>
/// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
private static void TimeSignatureChangedCallback(DependencyObject dependencyObject,
DependencyPropertyChangedEventArgs args)
{
}
