#172 – Changes to a Brush Cascade to Consumers of the Brush

December 31, 2010 Leave a comment

If you create a Brush object, in XAML or code, and use that Brush in some controls, any changes to the original Brush are automatically reflected in controls that use the brush.

For example, assume that we define a teal SolidColorBrush as a resource and use it to render a Label.

    <Window.Resources>
        <SolidColorBrush x:Key="tealBrush" Color="Teal"/>
    </Window.Resources>
    <StackPanel>
        <Label Content="I'm teal!" Foreground="{StaticResource tealBrush}"/>
    </StackPanel>

Now assume that we change the brush’s color at runtime:

            SolidColorBrush theBrush = (SolidColorBrush)this.Resources["tealBrush"];
            theBrush.Color = Colors.DarkMagenta;

You’ll see that the foreground color of the Label changes immediately, as soon as we change the color of the brush.

This change notification behavior is true not only of the Brush class, but of all other classes used in rendering WPF graphics.

Advertisement

Filed under Graphics Tagged with , ,

#171 – Other Base Classes – Freezable and Animatable

December 30, 2010 1 Comment

We can add two other important base classes to our class hierarchy–Freezable and Animatable.

  • Freezable – Implements a “freezable” pattern, in that the object can provide a “frozen” read-only copy of itself.
  • Animatable – Derives from Freezable and adds the ability to animate properties

Filed under Basics Tagged with , ,

#170 – Functionality That The Base Element Classes Provide

December 29, 2010 Leave a comment

The four main base element classes in WPF each provide slightly different functionality, above and beyond DependencyObject, which they all inherit from, directly or indirectly.

  • ContentElement adds (to DependencyObject)
    • Input events and commanding
    • Focus
    • Raise and respond to routed events
    • Animation support
  • FrameworkContentElement adds (to ContentElement)
    • Additional input elements (e.g. tooltips, context menus)
    • Storyboards
    • Data binding
    • Styles
    • Property value inheritance
  • UIElement adds (to DependencyObject)
    • via Visual
      • Hit testing
      • Clipping and coordinate transformations
      • Participation in visual tree via parent/child relationships
    • Layout behavior (measure/arrange)
    • Input events and commanding
    • Focus
    • Raise and respond to routed Events
    • Animation support
  • FrameworkElement adds (to UIElement)
    • Additional input elements (e.g. tooltips, context menus)
    • Storyboards
    • Data binding
    • Styles
    • Property value inheritance
    • Support for the logical tree

 

Filed under Basics Tagged with , , , ,

#169 – The Base Element Classes

December 28, 2010 1 Comment

There are four main classes that that serve as base classes for many of the other classes in WPF.  They also often serve as base classes for new custom classes that you write.

The four base element classes are:

  • ContentElement
  • FrameworkContentElement
  • UIElement
  • FrameworkElement

Filed under Basics Tagged with , ,

#168 – A More Complete Class Hierarchy

December 27, 2010 Leave a comment

Post #27 presented a class hierarchy that shows the most common classes used in WPF.  Here is an updated view, with ContentElement and FrameworkContentElement added.  These two classes are sometimes used as base classes for creating new elements, so it’s important to know where they fit in the class hierarchy.

(Click on the image to see the diagram full-sized).

 

Filed under Basics Tagged with ,

#167 – Implementing a Dependency Property That Is A Collection

December 26, 2010 3 Comments

When you create a custom dependency property that is based on a collection type, you need to define the default value of the property as a new instance of a collection, rather than as just a static value.

For example, we defined the Person.IQ dependency property, with a default value of 100, as follows:

internal static readonly DependencyPropertyKey IQPropertyKey =
    DependencyProperty.RegisterReadOnly("IQ", typeof(int), typeof(Person), new PropertyMetadata(100));

If we define a read-only Person.Friends property, whose type is List<Person>, the same call would look like this:

        internal static readonly DependencyPropertyKey FriendsPropertyKey =
            DependencyProperty.RegisterReadOnly("Friends", typeof(List<Person>), typeof(Person),
              new PropertyMetadata(new List<Person>()));      // Metadata constructor instantiates a new List

Filed under Dependency Properties Tagged with , ,

#166 – You Can Override Metadata for Any Dependency Property

December 25, 2010 1 Comment

Recall that you can set a dependency property value on a DependencyObject for any dependency property, not just the properties that the class implements or inherits.

Since any dependency property can be attached to any dependency object, you can override metadata for any dependency property in a class.

Here’s an example where we override the Grid.Row and Grid.Column properties in a class that derives from Button.  If this ButtonLoner object is defined in a Grid in XAML, it will automatically appear in Row 1, Col 1, rather than Row 0, Col 0.

    public class ButtonLoner : Button
    {
        static ButtonLoner()
        {
            Grid.RowProperty.OverrideMetadata(typeof(ButtonLoner), new FrameworkPropertyMetadata(1));
            Grid.ColumnProperty.OverrideMetadata(typeof(ButtonLoner), new FrameworkPropertyMetadata(1));
        }
    }

Here’s an example of the button being used:

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition/>
            <ColumnDefinition/>
        </Grid.ColumnDefinitions>
        <app:ButtonLoner x:Name="btnLoner" Content="Loner" Width="100" Height="25"/>
    </Grid>

Filed under Dependency Properties Tagged with , , ,

#165 – Overriding Metadata Can Result in Merged Metadata

December 24, 2010 Leave a comment

If you override metadata for a dependency property that a class inherits from its parent, you can specify one or more things to override:

  • The default value
  • The PropertyChangedCallback
  • The CoerceValueCallback
  • Other flags specified for UIPropertyMetadata or FrameworkPropertyMetadata

If you don’t specify all of these things, however, the items that you do not specify will be inherited from the parent.

For example, we created a child class of Slider and overrode metadata to provide a new default value for the Maximum property.  But the coercion behavior of Maximum in our new class behaves as it does for Slider.Maximum.  (Maximum can’t be set below Minimum).

Because we didn’t specify a CoerceValueCallback, the existing coercion logic is used.

When you do specify new metadata:

  • New default value replaces the existing one
  • PropertyChangedCallback is merged with the existing one  (both are invoked)
  • CoerceValueCallback replaces the existing one

Filed under Dependency Properties Tagged with , , , ,

#164 – Overriding Metadata for an Inherited Dependency Property

December 23, 2010 3 Comments

When deriving a new child class, you inherit the parent’s dependency properties.  You might also want to change the behavior of one or more of the dependency properties.  You can do this to some extent by overriding the metadata for a dependency property.

Overriding the metadata in the child class doesn’t change the behavior of the dependency property in the parent class.

In the example below, we create a new class and override metadata for several properties, changing the default values.

    public class ThermometerSlider : Slider
    {
        static ThermometerSlider()
        {
            // Defaults for standard Slider: Min = 0, Max = 10, Value = 0
            // Defaults for ThermometerSlider: Min = -40, Max = 120, Value = 70

            // Change default Minimum to -40.0
            MinimumProperty.OverrideMetadata(typeof(ThermometerSlider), new FrameworkPropertyMetadata(-40.0));

            // Change default Maximum to 120
            MaximumProperty.OverrideMetadata(typeof(ThermometerSlider), new FrameworkPropertyMetadata(120.0));

            // Change default Value to 70
            ValueProperty.OverrideMetadata(typeof(ThermometerSlider), new FrameworkPropertyMetadata(70.0));
        }
    }

The metadata type must match the type in the original property (e.g. FrameworkPropertyMetadata, UIPropertyMetadata, or PropertyMetadata).

Filed under Dependency Properties Tagged with , ,

#163 – Constructing FrameworkPropertyMetadata

December 22, 2010 Leave a comment

When you look at the metadata for a dependency property that is storing its metadata as an instance of FrameworkPropertyMetadata, you’ll see a series of boolean properties.

As a convenience, when constructing an instance of FrameworkPropertyMetadata, you don’t have to pass all of these boolean values into the constructor individually.  Instead, the constructor accepts a flags parameter that is a logical OR of a series of enumeration values.  The individual enumeration values come from the FrameworkPropertyMetadataOptions enum.

        // Register ZHeightProperty dependency property
        private static FrameworkPropertyMetadata meta = new FrameworkPropertyMetadata(1,   // default = 1
            FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.AffectsMeasure |
            FrameworkPropertyMetadataOptions.AffectsParentArrange | FrameworkPropertyMetadataOptions.AffectsParentMeasure |
            FrameworkPropertyMetadataOptions.BindsTwoWayByDefault);

        public static readonly DependencyProperty ZHeightProperty =
            DependencyProperty.Register("ZHeightProperty", typeof(int), typeof(ThreeDButton), meta);

Filed under Dependency Properties Tagged with , , ,

← Older posts