AvalonDock 2.0 Floating Window looses maximized state on MainWindow minimize / restore

Question

I am trying to achieve a VS style MainWindow + docking content host on secondary monitors. Avalon dock does the job gracefully. Until minimizing the window, that is.

Upon restore, the maximized 'docking host"(LayoutAnchorablePane) resets it's size and location to the pre-maximizing ones.

This is because when maximizing an avalon dock LayoutAnchorablePane, the Property Changed event doesn't fire. Also, the floating width property doesn't get updated.

This is why my first try __

    public Window3()
    {
        InitializeComponent();

        // Intercept the minimize event and cancel it.
        this.SourceInitialized += OnSourceInitialized; 

    }

    private void OnSourceInitialized(object sender, EventArgs e)
    {
        var source = (HwndSource)PresentationSource.FromVisual(this);
        if (source != null) source.AddHook(HandleMessages);
    }

    //These store the location and size of Left - the Layout Anchorable to be placed on a sec monitor
    private Point _location;
    private Size _size;

    private IntPtr HandleMessages(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        if (msg != 0x0112 || ((int) wParam & 0xFFF0) != 0xF020) return IntPtr.Zero;
        //This means a minimize for the Main Window. Cancel it.
        handled = true;
        //Get the sec monitor anchorable size and location
        _location = new Point(Left.FloatingLeft, Left.FloatingTop);
        _size = new Size(Left.FloatingWidth, Left.FloatingHeight);

        //finally minimize the window
        WindowState = WindowState.Minimized;


        return IntPtr.Zero;
    } 

    private void Window3_OnStateChanged(object sender, EventArgs e)
    {
        //Restore the width and location for the sec monitor anchorable
        // Fail. Cry. Cry a lot...
        if (WindowState == WindowState.Maximized)
        {
            Left.FloatingLeft = _location.X;
            Left.FloatingTop = _location.Y;
            Left.FloatingWidth = _size.Width;
            Left.FloatingHeight = _size.Height;
        }
    }

__ doesn't work.

These maximize / restore events are unreachable. They're stored in Controls/Shell/SystemCommands.cs

    public static void MaximizeWindow(Window window)
    {
        Verify.IsNotNull(window, "window");
        _PostSystemCommand(window, SC.MAXIMIZE);
    }

    private static void _PostSystemCommand(Window window, SC command)
    {
        IntPtr hwnd = new WindowInteropHelper(window).Handle;
        if (hwnd == IntPtr.Zero || !NativeMethods.IsWindow(hwnd))
        {
            return;
        }

        NativeMethods.PostMessage(hwnd, WM.SYSCOMMAND, new IntPtr((int)command), IntPtr.Zero);
    }

I've read some tips on avalondock's codeplex discussion but I think they applied to previous versions and were no longer valid.

I am thinking of using user32 GetWindowRect and SetWindowPos to get the location and size on minimize and restore it on maximize.

But, i simply have no ideea how to get the handle for the floating anchorables.

Any suggestion , on the floater handle or otherwise, will be greatly appreciated. Thank you for your time.

Did you find a solution to this? I have encountered this issue and looking for a fix. I noticed that LayoutFloatingWindowControl.OnStateChanged(EventArgs) is called on when I maximize with WindowState==Maximized, and again on restore from minimized with WindowState==Normal, but don't know where to go from there. — clcto

Julien Richard Julien Richard · Accepted Answer · 2015-06-05T10:10:32

I also had the same issues (also visible in the WPF Toolkit sample) and found a solution !

The general idea is to ignore WindowState changes sent by Windows and always restore internal state :

protected override void OnStateChanged(EventArgs e)
{
    // Windows sometimes send unwanted state changes (when minimizing application for instance)
    // We force internal state to be used
    WindowState = IsMaximized ? WindowState.Maximized : WindowState.Normal;
    base.OnStateChanged(e);
}

The WM_SYSCOMMAND was not well handled (the 0xFFF0 mask was missing) :

case Win32Helper.WM_SYSCOMMAND:
    int command = (int)wParam & 0xFFF0;
    if (command == Win32Helper.SC_MAXIMIZE || command == Win32Helper.SC_RESTORE)
    {
        UpdateMaximizedState(command == Win32Helper.SC_MAXIMIZE);
    }

I also updated the UpdateMaximizedState to also change internal state:

void UpdateMaximizedState( bool isMaximized )
{
    foreach( var posElement in Model.Descendents().OfType<ILayoutElementForFloatingWindow>() )
    {
        posElement.IsMaximized = isMaximized;
    }
    IsMaximized = isMaximized;
    WindowState = isMaximized ? WindowState.Maximized : WindowState.Normal;
}

As a side note, IsMaximized is now a get / set property :

public bool IsMaximized
{
    get { return (bool)GetValue(IsMaximizedProperty); }
    set
    {
        SetValue(IsMaximizedProperty, value);
        UpdatePositionAndSizeOfPanes();
    }
}

And that's it !

AvalonDock 2.0 Floating Window looses maximized state on MainWindow minimize / restore

2 Answers