Shulou(Shulou.com)06/02 Report--

This article introduces you how to program WPF controls, the content is very detailed, interested friends can refer to, hope to be helpful to you.

WPF provides a series of predefined components for use by UI developers. However, software developers often need to write their own controls that meet specific requirements. Take the Spinner control as an example to explain how to write a custom control in a derived way.

One. Think before you start.

Before we start writing controls, we need to think about how Spinner needs to be implemented. MSDN recommends three control implementations: derived from the UserControl class, derived from the Control class, and derived from the FrameworkElement class.

To make a correct choice between these three ways, software developers first need to understand the characteristics of these implementation methods. Deriving from the UserControl class is very similar to the WPF application development model: controls consist only of existing controls and are described by XAML. It supports styles and triggers. Custom controls defined in this way do not want software developers to specify their appearance through templates.

Deriving from the Control class is the way most control developers use. Unlike the method that derives from the UserControl class, its appearance is not specified by the associated XAML file, but often by the theme file. The features derived from this class are: 1) the appearance of the control can be customized through ControlTemplate. 2) controls can support different themes.

Deriving from the FrameworkElement class, on the other hand, requires a complete abandonment of the way you develop using combinations of control elements (whether in Template or UserControl definitions). There are two standard ways to generate FrameworkElement-based components: direct rendering and custom element combinations.

Direct rendering refers to overriding the OnRender method of FrameworkElement and providing DrawingContext operations that explicitly define the visual effects of the component, such as the Image class and the Border class. For example, the OnRender () function of the simplified Border class is as follows:

ProtectedoverridevoidOnRender (DrawingContext dc) {. Dc.DrawRoundedRectangle (…) ;. }

The other is to use an instance of the Visual class to combine object appearances. For example, Track is an example of using the appearance of a composite object. The Track class provides the Thumb attribute, and the use of this component is taken into account in its internal implementation, such as the ArrangeOverride () function.

The advantages derived from FrameworkElement are: 1) you can have precise control over the appearance of the control, not just a simple combination of elements. 2) define the appearance of the control by defining its own drawing logic.

Obviously, the Spinner control needs to use methods derived from the Control class to provide support for templates. Of course, this does not mean that the Spinner control derives directly from the Control class, but that a derived class of the Control class is selected as the base class for Spinner. This is actually related to the organization of control types in WPF. In WPF, the inheritance hierarchy that represents the types of controls is divided in a very detailed manner according to the control characteristics, and only one or two features are supported in each inheritance hierarchy. Take the Button class as an example. There are also two layers of derivation between this type and the Control class: the ContentControl class and the ButtonBase class. These two types not only provide Content properties and command-related properties respectively, but more importantly, they provide default implementations that support these properties internally. In this case, the software developer needs to change the logic provided by these default implementations only when the default implementations no longer meet the conditions, greatly reducing the time required to develop new controls.

It is for this reason that we need to carefully select the base class that we need to use before writing a control. The criterion for choosing an appropriate base class is that the type provides the most reusable functionality, but not too much redundancy. The search of the base class is also based on finding similar controls and filtering them one by one from high to low along the inheritance level of similar controls.

When looking for similar controls, software developers need to simply figure out how to use the control to find controls with similar functions. In general, Spinner needs to have a * value, a minimum value, and a current value. Software developers can resize the current value through the buttons on the Spinner, or enter the size of the current value directly through the input box. This is very similar to the scroll bar control, except that the direct input of the scroll bar is done through Thumb. Then we need to think the other way around about whether ScrollBar provides too much functionality that Spinner doesn't need or support. Obviously, the ViewportSize, Orientation, and so on provided by ScrollBar are not the attributes required by Spinner, so it is not suitable to be the base class of Spinner. Next we can consider the base classes of ScrollBar in turn until a more appropriate base class is selected. As far as Spinner is concerned, the RangeBase class is a more appropriate base class.

Here we will encounter a fork in the road, that is, whether we can meet the needs of users by simply changing the template of the existing control. If you can, then using custom templates is a better choice.

After determining that you need to derive from a class, the software developer should check whether the default value of each dependency property provided by the class is a reasonable default value. For example, the RangeBase class specifies that the default value of the Value property is 0, the minimum value is 0, and the * * value is 1. For Spinner, because it often needs to manipulate integers, these default values are not appropriate. Software developers need to override these default values in the static constructor of the type:

RangeBase.ValueProperty.OverrideMetadata (typeof (Spinner), newFrameworkPropertyMetadata (10.0, OnValuePropertyChanged))

RangeBase.MaximumProperty.OverrideMetadata (typeof (Spinner), newFrameworkPropertyMetadata (20.0)

RangeBase.LargeChangeProperty.OverrideMetadata (typeof (Spinner), newFrameworkPropertyMetadata (1.0))

RangeBase.SmallChangeProperty.OverrideMetadata (typeof (Spinner), newFrameworkPropertyMetadata (1.0))

It is important to note that the default value of the attribute provided in the OverrideMetadata () function needs to match the type of the attribute. For example, if you use an integer value of 20 when specifying a default value for the Maximum property, a call to the OverrideMetadata () function will cause the program to crash.

When changing the default value of a property, the software developer needs to consider what the control should actually mean. Take ComboBox and ListBox as examples. Under what circumstances should ComboBox be used and when should ListBox be used? The decisive factor in answering this question is the characteristics of the two controls, which in turn leads to the difference in user experience. ComboBox can display all the options through the drop-down list and the current item by editing the box. This display of data takes up less space than ListBox and highlights the currently selected item. Compared with ComboBox,ListBox, it has more advantages in comprehensively displaying data, especially related data.

Similarly, Spinner has its own meaning. The Chinese name of Spinner is called a fine-tuning control. As can be seen from the name, the operation on Spinner is more of a minor adjustment. At the same time, the input boxes provided by Spinner often allow users to enter the required values directly, thus achieving accurate control of the values. In other words, it pays more attention to the precise assignment of values than components such as ScrollBar. This is one of the reasons why I added precision control attributes to Spinner. Of course, I will continue to introduce this part later.

Before we actually start writing controls, the other thing we need to think about is how the user uses it. In general, user input is done through the mouse and keyboard, so we classify the user's usage into two categories: mouse and keyboard.

Let's take a look at the mouse first. The mouse needs to consider mainly divided into keystroke and roller two kinds of operation. When the left mouse button clicks the increase and decrease buttons, the value needs to change with the mouse keystroke and provide appropriate appearance feedback. When the left mouse button clicks the input box, the cursor needs to move to the appropriate location. When the right mouse button clicks on the input box, the menu for manipulating the text needs to be popped up. As the mouse wheel scrolls, the value of Value needs to be changed at the same time.

Then there is the keyboard. In general, keyboard operations are often associated with non-character input keys. For example, after the user navigates to the control through operations such as Tab, the control consisting of an input box will automatically select all of its contents. The user tapping the enter key indicates that he agrees with the current value. The input focus should be shifted to the next control so that the user can continue. At the same time, for range type controls, Up and Down represent a small range of numerical changes, while PageUp and PageDown represent a large range of numerical changes. For Spinner, fine-tuning is its main function, so it is reasonable to equate the values of a small range of numerical changes with a large range of numerical changes.

* before we start writing controls, we need to learn from the implementation of similar controls based on the same base class in WPF. For information on how to get the WPF source code, see the article "starting with Dispatcher.PushFrame ()." By observing the implementation of these controls, we can better understand the extension points provided by the base class and how these extension points are used.

Two. start to realize

In this section, we will begin to implement Spinner. Right-click the project file and select "Add"-> "New Item" from the pop-up menu. Select "Custom Control (WPF)" in the pop-up dialog box and enter "Spinner.cs" in the name input box, as shown in the figure:

After clicking the Add button to decide to add the control, Visual Studio will add two files for us: Spinner.cs and Generic.xaml that represents the default theme.

2.1 template support

Typically, I place a simple template implementation of the control in the theme file. For example, at the beginning, I defined the following appearance for Spinner in Generic.xaml:

Although this is not the final control appearance, through the control template, we can test the logic contained in the Spinner control at any time.

In the control template definition, we provide special names for several components, such as PART_Input. In a template definition, a name that begins with PART_ indicates that the component corresponding to that name is an integral part of the template definition used within the control. Other templates provided for the control also need to provide the appropriate components for these names.

In the implementation of a custom control, the software developer needs to use the FrameworkTemplate.FindName () function to find a component with a specific name from an instance of the template used by the current control. The prerequisite for using this function is that the template for the control has been implemented. Therefore, the most appropriate place to call this function is the overloaded function OnApplyTemplate () function. As shown in the following code:

PublicoverridevoidOnApplyTemplate () {mInputTextBox = null; mDecreaseButton = null; mIncreaseButton = null; base.OnApplyTemplate (); if (Template! = null) {mInputTextBox = Template.FindName ("PART_Input", this) asTextBox; mDecreaseButton = Template.FindName ("PART_Decrease", this) asRepeatButton; mIncreaseButton = Template.FindName ("PART_Increase", this) asRepeatButton;}}

In order for template designers to know the names that must appear in the template definition and the control types corresponding to these names, WPF provides the TemplatePart feature. This feature provides two properties, Name and Type. Name is used to mark the component name that needs to be added to the template definition, while Type is used to indicate the type that the name needs to have. As shown in the following code:

[TemplatePart (Name= "PART_Input", Type=typeof (TextBox)), TemplatePart (Name= "PART_Decrease", Type=typeof (RepeatButton)), TemplatePart (Name= "PART_Increase", Type=typeof (RepeatButton))]

When this feature is used, the template designer can know the corresponding elements in the template and their types directly from the feature declaration.

2.2 functional implementation

Now we need to think about how to implement the corresponding functionality of the control. There are two main ways to interact between controls and templates: binding and listening for events emitted by the composition of the template. When implementing custom controls, we need to use binding as much as possible. However, for special processing logic, we are often unable to complete the corresponding functions through binding. In this case, the software developer needs to listen for events emitted by the template composition.

Now think about how Spinner needs to operate: input to the button control may change the current value, while executing the input in the input box and entering enter can also confirm the current value. Clicking on the button can trigger the Click event and even the command associated with the button control, while tapping the enter key in the input box will only trigger the Keydown event. So after each implementation of the template, we need to add this processing logic for a specific component:

PrivatevoidAttach () {if (mDecreaseButton! = null) mDecreaseButton.Command = mDecreaseCommand;. If (mInputTextBox! = null) {mInputTextBox.Text = Value.ToString (); mInputTextBox.InputBindings.Add (newKeyBinding (mIncreaseCommand, newKeyGesture (Key.Down)); …. MInputTextBox.PreviewKeyDown + = PreviewTextBoxKeyDown; mInputTextBox.LostKeyboardFocus + = TextBoxLostKeyboardFocus;}}

Correspondingly, before each implementation of the template, we need to cancel the processing logic:

PrivatevoidDetach () {if (mInputTextBox! = null) {mInputTextBox.PreviewKeyDown-= PreviewTextBoxKeyDown; mInputTextBox.LostKeyboardFocus-= TextBoxLostKeyboardFocus;}}

This is because the added message handler generates a reference to the message source. Canceling the listening for the message releases the reference.

Here, let's take a look at the interaction shown in the Attach () function.

First of all, orders. Here we use mDecreaseCommand to specify commands for the button. Why use commands instead of routing events? This depends on whether the user's behavior needs to be known by the user. Relative to the routing event, the routing command does not continue to execute the route after encountering the appropriate execution logic, making it invisible to the user.

To support these commands, software developers need to set up CommandBinding and InputBinding for Spinner. CommandBinding specifies the execution logic for the command, while InputBinding specifies the execution condition under which the command is triggered. This part of the logic is usually done in the constructor of Spinner:

PublicSpinner () {CommandBindings.Add (newCommandBinding (mIncreaseCommand, OnIncreaseCommand, CanExecuteIncreaseCommand)); … InputBindings.Add (newKeyBinding (mIncreaseCommand, newKeyGesture (Key.Down); }

The next thing to consider is to use another processing logic in addition to the command, events. In the event PreviewKeyDown, we need to determine whether the user pressed the enter key. If so, the user's current input will be validated and the value will be refreshed based on the correctness of the user's input. There are several problems that need to be written about. The first is why the Preview- event is used. TextBox sets the handled of the KeyDown event to true when processing user input, so software developers cannot use the KeyDown event directly, but the PreviewKeyDown event instead. The other is when InputBinding is effective. InputBinding is driven by the KeyDown event. Before the KeyDown event is processed by TextBox, the InputBinding set within the TextBox instance is processed; in TextBox, the handled property of the KeyDown event is set to true during processing, thus depriving the ancestor elements of TextBox of the opportunity to process InputBinding. This is why the Attach () function adds extra InputBinding to the TextBox type member mInputTextBox:

PrivatevoidAttach () {. If (mInputTextBox! = null) {. MInputTextBox.InputBindings.Add (newKeyBinding (…)) ;. }}

Next, considering that each adjustment of the fine-tuning control may not be an integer, we also need to provide a way for Spinner to control the display precision. This is why the Precision attribute is added. This property controls how the current value is formatted through the double.ToString () function to show a specific precision:

PrivatestringGetValueString () {intprecision = Precision

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.