How to create WPF Custom Control without ControlTemplate?

1
votes

I need to write a WPF Custom Control which consists of 4 other FrameworkElement derived custom classes. Normally I would use Grid to arrange them, but Grid has some layouting problems and I have to write my own class inheriting from Panel. Of course, my Custom Control could inherit from Panel, but would then expose Children and other Panel functionality, which it shouldn't.

I need a Custom Control which shows only some properties I added and the typical FrameworkElement properties. I am considering that my Custom Control inherits from Control. But I don't want to use ControlTemplates. I want to create the Panel and add the FrameworkElements from code behind. How can this be done ?

Let me summarise the questions: 1) Is Control the best class to derive from ?

2) How to add FrameworkElements to a Control derived class without using a ControlTemplate ?

2
wpfcustom-controls
Have you considered UserControl base class? That will allow you to design your control in XAML or code behind and expose only properties you want to be externally visible. - kidshaw
@kidshaw: I would prefer not to use XAML, because it makes everything unnecessary complicated and slow. I need to write my own Panel class anyway, even when using UserControl, because none of the Panels support the layouting I need. When inheriting from Control, I can do the layouting in MeasureOverride and ArrangeOverride, meaning I can do everything I need within 1 class. - Peter Huber
Not sure I agree that XAML makes it unnecessarily complicated but can appreciate that as an opinion :) - It makes the complex simple, and the simple complex. - kidshaw

2 Answers

1
votes

  1. Yes. Control is the best class to derive from.

  2. You need to override the method GetVisualChild() and the property VisualChildrenCount. I am considering you want to have 4 custom framework elements as your children and initialized that collection in constructor. Then the code would like below,

    private List<UIElement> visualChildren;

protected override int VisualChildrenCount
{
    get
    {
        return this.visualChildren.Count;
    }
}

protected override Visual GetVisualChild(int index)
{
    return this.visualChildren[index];
}

Also you can override MeasureOverride and ArrangeOverride methods to allocate size to the childrena nd arrange the children respectively.

More information

0
votes

Here is the implementation solving my problem based on the suggestions from XAML Lover and Marat Khasanov. The TestCustomControl places 2 TextBoxes diagonally of each other. The one on the top right uses as much width as needed and as much height as possible. The one on the bottom left uses as much height as needed and as much width as possible. 

+------------+--------+
|            |        |
|            |TextBox1|
|            |        |
+------------+--------+
|  TextBox2  |        |
+------------+--------+

This kind of arrangement is a problem for a Grid, because to measure the size of one TextBox it needs to know the size of the other TextBox, which is not possible. The Grid solves this dilemma by measuring first one TextBox using indefinite space, then measures the other TextBox using the size from the first one and then measures the first one again using the size of the second. This leads to all kinds of problems, which the TestCustomControl prevents completely.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;


namespace TestControl {


  public class TestCustomControl: Control  {

    VisualCollection visualCollection;
    Rectangle RectangleToLeft;
    TextBox TextBoxTopRight;
    TextBox TextBoxBottomLeft;
    Rectangle RectangleBottomRight;


    public TestCustomControl() {
      RectangleToLeft      = new Rectangle { Fill = Brushes.LightYellow };
      TextBoxTopRight      = new TextBox {Text = "TR", FontSize = 22, HorizontalAlignment=HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Stretch };
      TextBoxBottomLeft    = new TextBox {Text = "BL", FontSize = 22, HorizontalAlignment=HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Center };
      RectangleBottomRight = new Rectangle {Fill = Brushes.LightBlue };

      //new UIElementCollection(this, logicalParent);
      visualCollection = new VisualCollection(this);
      visualCollection.Add(RectangleToLeft);
      visualCollection.Add(TextBoxTopRight);
      visualCollection.Add(TextBoxBottomLeft);
      visualCollection.Add(RectangleBottomRight);
    }


    protected override int VisualChildrenCount {
      get {
        return visualCollection.Count;
      }
    }


    protected override System.Windows.Media.Visual GetVisualChild(int index) {
      return visualCollection[index];
    }


    protected override System.Windows.Size MeasureOverride(System.Windows.Size constraint) {
      TextBoxTopRight.Measure(constraint);
      TextBoxBottomLeft.Measure(constraint);
      Size returnedSize = constraint;
      if (double.IsInfinity(constraint.Height)) {
        returnedSize.Height = TextBoxTopRight.DesiredSize.Height + TextBoxBottomLeft.DesiredSize.Height;
      }
      if (double.IsInfinity(constraint.Width)) {
        returnedSize.Width = TextBoxTopRight.DesiredSize.Width + TextBoxBottomLeft.DesiredSize.Width;
      }
      return constraint;
    }


    protected override System.Windows.Size ArrangeOverride(System.Windows.Size arrangeBounds) {
      double remainingWidth = Math.Max(0, arrangeBounds.Width - TextBoxTopRight.DesiredSize.Width);
      double remainingHeight = Math.Max(0, arrangeBounds.Height - TextBoxBottomLeft.DesiredSize.Height);
      RectangleToLeft.Arrange(new Rect(0, 0, remainingWidth, remainingHeight));
      TextBoxTopRight.Arrange(new Rect(remainingWidth, 0, TextBoxTopRight.DesiredSize.Width, remainingHeight));
      TextBoxBottomLeft.Arrange(new Rect(0, remainingHeight, remainingWidth, TextBoxBottomLeft.DesiredSize.Height));
      RectangleBottomRight.Arrange(new Rect(remainingWidth, remainingHeight, TextBoxTopRight.DesiredSize.Width, TextBoxTopRight.DesiredSize.Height));
      return arrangeBounds;
    }


    protected override Geometry GetLayoutClip(Size layoutSlotSize) {
      if (ClipToBounds)
        return new RectangleGeometry(new Rect(RenderSize));
      else
        return null;
    }
  }
}