ControlVisualResizer

Gets or sets which way a drag on the grip resizes the container.

Direction.None leaves the grip on show but a drag does not change the size; it also moves the grip to the bottom-left corner and hides the mouse pointer over it. To stop resizing, IsGripperEnabled or IsGripperVisible is usually the clearer choice.

Gets or sets how far the drop shadow falls below and to the right of the container.

Used only while IsDropShadowEnabled is true. The shadow is drawn outside the container's bounds and takes no room in the layout.

Gets or sets how dark the drop shadow is.

Used only while IsDropShadowEnabled is true.

Gets the command that finishes a resize, as the grip does when it is released.

It raises ResizeCompleted if a resize was in progress, and does nothing otherwise. The command parameter is not used.

Gets or sets the colour of the dots that make up the resize grip.

Set it on the control for a colour of your own, or redefine the resource key in the application's resources to change every resizer at once. Ignored by a ResizerStyle of your own unless that style binds it.

Gets or sets whether the container casts a drop shadow.

The shadow is set as the container's UIElement.Effect, shaped by DropShadowDepth and DropShadowOpacity. The container manages that property itself: turning the shadow off, or changing its depth or opacity while it is off, sets UIElement.Effect to null, removing any effect of your own. To give the container a different effect, leave the shadow off and set UIElement.Effect after the other properties.

Gets or sets whether the user can resize the container with the grip.

With the property off, the grip stays on show but does not respond to the mouse – useful to lock a layout while still showing that it can be unlocked. To hide the grip as well, use IsGripperVisible.

// Lock every panel on the dashboard while the layout is not being edited.
foreach (ControlVisualResizer panel in dashboardCanvas.Children.OfType<ControlVisualResizer>())
{
    panel.IsGripperEnabled = isEditingLayout;
}

Gets or sets whether the resize grip is shown.

A hidden grip cannot be dragged, so hiding it also stops the user resizing the container. The content does not move into the space the grip leaves, because the grip is drawn over the content's corner.

Gets or sets the style of the resize grip, to give it a look of your own.

The grip's size, position and cursor are set by the container's template and are not taken from this style.

<sizer:ControlVisualResizer.ResizerStyle>
    <Style TargetType="ResizeGrip">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="ResizeGrip">
                    <Path Data="M 0,17 L 17,0 L 17,17 Z" Fill="#802B579A" />
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</sizer:ControlVisualResizer.ResizerStyle>

Gets the command that starts a resize from the current position of the mouse pointer, as the grip does when it is pressed.

The grip uses these three commands to do its work, and they are public so that a grip of your own, or any element inside the container, can drive a resize the same way. Execute StartResizeCommand when the drag begins, UpdateSizeCommand as the mouse moves and EndResizeCommand when it is released, each with an element inside the container (or the container itself) as the target. Capture the mouse for the length of the drag, as the grip does, so that the moves keep arriving outside the container.

The command parameter must be a FrameworkElement – the element doing the dragging; any other parameter, including null, makes the command throw an InvalidOperationException. The command raises ResizeStarted.

// A custom handle inside the container that resizes it.
handle.MouseLeftButtonDown += (s, e) =>
{
    handle.CaptureMouse();
    ControlVisualResizer.StartResizeCommand.Execute(handle, handle);
};
handle.MouseMove += (s, e) =>
{
    if (handle.IsMouseCaptured) ControlVisualResizer.UpdateSizeCommand.Execute(null, handle);
};
handle.MouseLeftButtonUp += (s, e) =>
{
    ControlVisualResizer.EndResizeCommand.Execute(null, handle);
    handle.ReleaseMouseCapture();
};

Gets the command that resizes the container so that its bottom-right corner follows the mouse pointer's movement since the resize was started.

It sets FrameworkElement.Width and FrameworkElement.Height, never below 0, and does nothing unless StartResizeCommand has started a resize. With Direction set to Direction.None it sets them to the size the container had when the resize started. The command parameter is not used.

Connects the resize grip in the template to the mouse, and applies IsGripperVisible to it.

A custom template names its grip PART_ReSizerGrip, and it must be a ResizeGrip. A template without one shows its content and cannot be resized by dragging.

Clears the size the user set by dragging, so the container goes back to the size its content and its parent give it.

It clears FrameworkElement.Width and FrameworkElement.Height altogether, including a size set in markup or code before any drag. A double click on the grip does the same. ResizeCompleted is not raised.

// "Reset layout" on the View menu.
foreach (ControlVisualResizer panel in dashboardCanvas.Children.OfType<ControlVisualResizer>())
{
    panel.ResetSize();
}

Occurs when the user releases the grip at the end of a resize.

The new size is in FrameworkElement.Width and FrameworkElement.Height, which makes this the place to save a layout the user has arranged. Also raised when EndResizeCommand ends a resize started from code.

It is not raised by a double click on the grip or by ResetSize, which put the container back to its natural size.

Occurs when the user presses the grip to start resizing the container.

Raised before the size changes; the container's FrameworkElement.ActualWidth and FrameworkElement.ActualHeight are still the size it started at. Also raised when StartResizeCommand is executed from code.

Identifies the Direction dependency property.

Identifies the DropShadowDepth dependency property.

Identifies the DropShadowOpacity dependency property.

Identifies the GripperBrush dependency property.

Identifies the IsDropShadowEnabled dependency property.

Identifies the IsGripperEnabled dependency property.

Identifies the IsGripperVisible dependency property.

Identifies the ResizerStyle dependency property.