Dependency Property Inheritance

Question

i need my control to inherit the UIElement.IsEnabledProperty from an Ancestor of type Grid (Optionally Window or any other element i could wrap my grid with )

CS : below i override the meta data of UIElement.IsEnabledProperty and set it with Change and Coerce delegates .

    static PipeControl()
    {
        PipeControl.IsEnabledProperty.OverrideMetadata(typeof(PipeControl), new FrameworkPropertyMetadata(false, OnIsEnabledPropertyChanged, OnIsEnabledPropertyCoerce));
    }

    private static void OnIsEnabledPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var isEnabled = (bool)e.NewValue;
    }

    private static object OnIsEnabledPropertyCoerce(DependencyObject d, object baseValue)
    {
        var valueSource = DependencyPropertyHelper.GetValueSource(d, PipeControl.IsEnabledProperty);

        var pipeContorl = d as PipeControl;
        if (pipeContorl == null) return baseValue;

        return (bool)baseValue && pipeContorl.IsMyPipe;
    }

XAML :

    <Grid IsEnabled="{Binding IsMyCondition , Mode=OneWay}">        
         <game:PipeControl Grid.Row="2"  />            
         <game:PipeControl  Grid.Row="2" Grid.Column="1" />
    </Grid>

each time IsMyCondition changes OnIsEnabledPropertyCoerce is called in each PipeContorl , OnIsEnabledPropertyChanged is never called , the ValueSource in OnIsEnabledProerty Coerce is "Default" (show the Coerce always gets the default false value).

i must of missed something in the manner in which i need to use Inheritance , i would expect the value source the be "Inherited" and the OnIsEnabledPropertyChanged to be called.

score 6 · Accepted Answer · answered Apr 10 '13 at 15:18

UIElement has a virtual property IsEnabledCore which should(?) be used to coerce IsEnabled property. This is how, for example, Button or MenuItem coerce IsEnabled property depending on their CanExecute properties. In your custom control, you can override the property as:

    protected override bool IsEnabledCore
    {
        get
        {
            return ( base.IsEnabledCore && IsMyPipe );
        }
    }

The important thing is to call CoerceValue when any of the properties ( ex. IsMyPipe) on which IsEnabled depends changes.

So the custom control implementation would be:

    static PipeControl()
    {
        DefaultStyleKeyProperty.OverrideMetadata( typeof( PipeControl ), new FrameworkPropertyMetadata( typeof( PipeControl ) ) );
    }

    public bool IsMyPipe
    {
        get { return ( bool )GetValue( IsMyPipeProperty ); }
        set { SetValue( IsMyPipeProperty, value ); }
    }

    public static readonly DependencyProperty IsMyPipeProperty =
            DependencyProperty.Register(
                    "IsMyPipe",
                    typeof( bool ),
                    typeof( UIElement ),
                    new PropertyMetadata(
                            true,
                            new PropertyChangedCallback( OnIsMyPipeChanged ) ) );

    private static void OnIsMyPipeChanged( DependencyObject d, DependencyPropertyChangedEventArgs e )
    {
        d.CoerceValue( UIElement.IsEnabledProperty );
    }

Hope this helps, and any comments on the solution are more than welcome.

that's great , but there's one more thing , i would still like to get notified when PipeControl's IsEnabledProperty changes , and Coerce the value from there . could i do that with out a different notification like the callback notification for IsMyPipe — eran otzap, Apr 10 '13 at 18:05

score 2 · Answer 2 · edited May 23 '17 at 12:15

with Adnan's answer above , and this answer :

How can I add logic to an existing dependency-property callback?

I comprised a full answer .

CS :

    static PipeControl()
    {
        PipeControl.IsEnabledProperty.OverrideMetadata(typeof(PipeControl), new UIPropertyMetadata(new PropertyChangedCallback(OnIsEnabledPropertyChanged)));
    }



    private static void OnIsEnabledPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {           
        var isEnabled = (bool)e.NewValue;
    }


    protected override bool IsEnabledCore
    {
        get
        {
            return (base.IsEnabledCore && IsMyPipe);
        }
    }

IsEnabledCore returns the value to the Callback , so the Coercion happens there , and then the CallBack .

FYI , setting a local default value seems to override the inherited , so if overriding an Inherited Property's Metadata do nut give a default local value , like so :

  PipeControl.IsEnabledProperty.OverrideMetadata(typeof(PipeControl), new UIPropertyMetadata(false,new PropertyChangedCallback(OnIsEnabledPropertyChanged)));

in addition , if you only need to add coercion logic you can just override IsEnabledCore , and do nothing else with the Metadata of IsEnabledProperty .

You say that you should not give a default local value, but then you're assigning `false` to be the default value in `new UIPropertyMetadata(false, ... )`. Am I not understanding an overload or misunderstanding your words? — Zach Mierzejewski, Oct 05 '16 at 01:32
I'm not sure , it's hard to remember after all this time... It's logical that the default value set in this dependency object will be the one for this it uses. and will override the default. Maybe i men't you should pay attention not to use the inherited value. which i believe is 'True' — eran otzap, Oct 05 '16 at 10:52

Dependency Property Inheritance

2 Answers2