changes
---------------------------------
event is changed to ItemSelecting - tabstrip now is pageview (documentTabStrip1.TabStripElement.ItemSelecting += new EventHandler<Telerik.WinControls.UI.RadPageViewItemSelectingEventArgs>(TabStripElement_ItemSelecting))
introduce new powefull events for RadDock - SelectedTabChanging / SelectedTabChanged


Create a dock with couple of documents.
Subscribe to the TabSelecting event of RadTabStripElement and cancel it showing a message box indicating the cancellation.
The message box will be shown 5 times.

To reproduce:
case #1 Dock a window to RadDock. Drag a window out of the Dock to make it floating. Check the FloatingWindowsCollection. Dock the window again, you will notice that the collection did not change.
case #2 Have a RadDock with a docked ToolWindow. Undock the ToolWindow by double-clicking it and dock it back. Now undock it by dragging it. If you now check the FloatingWindows collection you will see that there are two windows with the same name.

Resolution: 
The FloatingWindows property gets a list of the floating windows. Can contain duplicates, empty or hidden toolwindows which are used internally as re-dock targets. Use the ActiveFloatingWindows property instead of it. 

To reproduce:
Add a RadDock and a DockWindow, AutoHide it, add a RadPropertyGrid to its controls and dock it. Set the SelectedObject of the property grid to the current form and start the application. Edit the BackColor value and you will notice that the window will hide.

To reproduce:

Scenario 1:

ToolWindow window1 = new ToolWindow();
window1.Name = "window1";
this.radDock1.DockWindow(window1, DockPosition.Left);

ToolWindow window2 = new ToolWindow();
window2.Name = "window2";
this.radDock1.DockWindow(window2, window1, DockPosition.Right);

window1.TabStrip.SizeInfo.SizeMode = Telerik.WinControls.UI.Docking.SplitPanelSizeMode.Relative;
window1.TabStrip.SizeInfo.RelativeRatio = new SizeF(0.7f, 0);

The expected result is that "window1" takes 70% of the container hosting "window1" and "window2".

Scenario 2:

ToolWindow window1 = new ToolWindow();
window1.Name = "window1";
this.radDock1.DockWindow(window1, DockPosition.Left);

DocumentWindow doc1 = new DocumentWindow();          
this.radDock1.AddDocument(doc1, window1, DockPosition.Right);
window1.TabStrip.SizeInfo.SizeMode = Telerik.WinControls.UI.Docking.SplitPanelSizeMode.Relative;
window1.TabStrip.SizeInfo.RelativeRatio = new SizeF(0.7f, 0);

The expected result is that "window1" takes 70% of the container hosting "window1" and the document window.

Workaround: use the SplitPanelSizeMode.Absolute as below:
ToolWindow window1 = new ToolWindow(); 
DocumentWindow doc1 = new DocumentWindow(); 

private void RadForm1_Load(object sender, EventArgs e)
{
    window1.Name = "window1";
    this.radDock1.DockWindow(window1, DockPosition.Left);
            
    this.radDock1.AddDocument(doc1, window1, DockPosition.Right);
   
    window1.TabStrip.SizeInfo.SizeMode = Telerik.WinControls.UI.Docking.SplitPanelSizeMode.Absolute;
    window1.TabStrip.SizeInfo.AbsoluteSize = new Size((int)(this.Size.Width * 0.7),0);

    this.radDock1.SizeChanged += radDock1_SizeChanged;
}

private void radDock1_SizeChanged(object sender, EventArgs e)
{
     window1.TabStrip.SizeInfo.AbsoluteSize = new Size((int)(this.Size.Width * 0.7),0);
}

To reproduce:
- Load a layout with a floating window in it. 
- The close button is disabled.


Workaround:
private void RadDock1_LoadedFromXml(object sender, EventArgs e)
{
    foreach (FloatingWindow item in radDock1.FloatingWindows)
    {
        item.UpdateCloseButton();
    }
}

To reproduce:

Add RadDock and ToolWindow to the RadDock and dock it. Start the application and drag out the ToolWindow. You will notice that when you try to drag it back in the RadDock you are not able to.

To reproduce:

Add a RadDock to a Form, add two ToolWindows and dock them. Drag out one of the toolwindows to the edge of the other one until the drag hint is selected and continue dragging out of the form. You will notice that the drag hint is still selected.

Use the attached project to reproduce.

Workaround:
private void RadForm1_SizeChanged(object sender, EventArgs e)
{
    toolWindow1.EnsureVisible();
}

To reproduce:

Add a RadDock and two ToolWindows with many controls inside (~100). Drag out the one toolwindow and dock it back by dragging. Now drag it out again and dock it by clicking in its title bar and clicking Docked. You will notice that the second way is faster.

Workaround: FloatingWindow.FormElement.TitleBar.CloseButton.Enabled = True

To reproduce:
1.Add a RadDock with a ToolWindow and a DocumentWindow. Add several controls to all windows. Use the following code:


protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);
    if (System.IO.File.Exists(@"..\..\..\layoutTest.xml"))
        this.radDock1.LoadFromXml(@"..\..\..\layoutTest.xml");
}


protected override void OnClosing(CancelEventArgs e)
{
    this.radDock1.SaveToXml(@"..\..\..\layoutTest.xml");
    base.OnClosing(e);
}


2. Run the application and change the current layout. 
3. Close the form and run the application again. The controls which belong to the RadDock's DocumentWindow disappear from the dialog.

Workaround:
class MyDock : RadDock
{
    protected override void LoadFromXmlCore(System.Xml.XmlReader reader, bool oldXmlFormat)
    {
        //stop the base logic
        //base.LoadFromXmlCore(reader, oldXmlFormat);
 
        if (reader == null)
        {
            return;
        }
 
        this.ActiveWindow = null;
 
        FieldInfo prevActiveWindow = typeof(RadDock).GetField("prevActiveWindow", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetField);
        prevActiveWindow.SetValue(this, null); //this.prevActiveWindow = null;
 
        FieldInfo attachedWindows = typeof(RadDock).GetField("attachedWindows", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
        SortedList<string, DockWindow> _attachedWindows = attachedWindows.GetValue(this) as SortedList<string, DockWindow>;
        MethodInfo CleanAutoHideTabs = typeof(RadDock).GetMethod("CleanAutoHideTabs", System.Reflection.BindingFlags.NonPublic | BindingFlags.Instance);
        CleanAutoHideTabs.Invoke(this, new object[] { _attachedWindows.Values, true }); //this.CleanAutoHideTabs(this.attachedWindows.Values, true);
 
        MethodInfo ResetDesiredDockState = typeof(RadDock).GetMethod("ResetDesiredDockState", System.Reflection.BindingFlags.NonPublic | BindingFlags.Instance);
        ResetDesiredDockState.Invoke(this, null); //this.ResetDesiredDockState();
 
        MethodInfo OnLoadingFromXML = this.DocumentManager.GetType().GetMethod("OnLoadingFromXML", System.Reflection.BindingFlags.NonPublic | BindingFlags.Instance);
        OnLoadingFromXML.Invoke(this.DocumentManager, null); //this.DocumentManager.OnLoadingFromXML();
 
        if (oldXmlFormat)
        {
            this.BeginTransactionBlock(false);
 
            MethodInfo LoadFromOldXml = typeof(RadDock).GetMethod("LoadFromOldXml", System.Reflection.BindingFlags.NonPublic | BindingFlags.Instance);
            LoadFromOldXml.Invoke(this, new object[] {reader}); // this.LoadFromOldXml(reader);
 
            this.EndTransactionBlock();
        }
        else
        {
            MethodInfo LoadFromNewXml = typeof(RadDock).GetMethod("LoadFromNewXml", System.Reflection.BindingFlags.NonPublic |  BindingFlags.Instance);
            LoadFromNewXml.Invoke(this, new object[] { reader }); // this.LoadFromNewXml(reader);
        }
 
        this.EnsureInitialized();
        this.OnLoadedFromXml();
    }
 
    public override string ThemeClassName
    {
        get
        {
            return typeof(RadDock).FullName;
        }
    }
}

To reproduce:
- Add RadDock to a blank form and dock a tool window to the bottom.
- Add RadRichTextBox to the tool window and set its anchor property to all for sides.
- Save and close the form.
- Reopen the form, you will notice that the RadRichtextBox has different size.

Please refer to the attached sample project and follow the steps illustrated on the gif file.

Workaround: you can control which items to be closed:

public RadForm1()
{
    InitializeComponent();
    ContextMenuService menuService = this.radDock1.GetService<ContextMenuService>();
    menuService.ContextMenuDisplaying += menuService_ContextMenuDisplaying;
}

RadDockLocalizationProvider localizationProvider = RadDockLocalizationProvider.CurrentProvider;

private void menuService_ContextMenuDisplaying(object sender, ContextMenuDisplayingEventArgs e)
{
    foreach (RadItem item in e.MenuItems)
    {
        if (item.Text == localizationProvider.GetLocalizedString(RadDockStringId.ContextMenuCloseAll))
        {
            item.Click += item_ClickContextMenuCloseAll;
        }
        else if (item.Text == localizationProvider.GetLocalizedString(RadDockStringId.ContextMenuCloseAllButThis))
        {
            item.Click += item_ClickContextMenuCloseAllButThis;
        }
    }
}

private void item_ClickContextMenuCloseAllButThis(object sender, EventArgs e)
{
    foreach (DockWindow dw in this.radDock1.DockWindows)
    {
        if (dw == this.radDock1.ActiveWindow)
        {
            continue;
        }
        dw.CloseAction = DockWindowCloseAction.Hide;
        dw.Close();
    }
}

private void item_ClickContextMenuCloseAll(object sender, EventArgs e)
{
    foreach (DockWindow dw in this.radDock1.DockWindows)
    {
        dw.CloseAction = DockWindowCloseAction.Hide;
        dw.Close();
    }
}

To reproduce:

Add a few ToolWindows to RadDock and start the application. Drag one window out of the form and dock the others inside of it. Dock the window back to the RadDock. You will notice that only the current window will be docked leaving the rest of the windows floating. The correct behavior is the whole window with its child windows to be docked.

Workaround:

Subscribe to the DockStateChanging and DockStateChanged events and manually add the windows.

private IEnumerable<DockWindow> windows;
void RadDock_DockStateChanging(object sender, DockStateChangingEventArgs e)
{
    if (e.NewWindow.FloatingParent == null)
    {
        this.windows = Enumerable.Empty<DockWindow>();
        return;
    }


    this.windows = DockHelper.GetDockWindows(e.NewWindow.FloatingParent, true, this.RadDock).Where(x => x != e.NewWindow);
}


void RadDock_DockStateChanged(object sender, DockWindowEventArgs e)
{
    foreach (DockWindow window in windows)
    {
        this.RadDock.DockWindow(window, e.DockWindow.DockTabStrip, DockPosition.Fill);
    }
}

When you add a few DocumentWindows to RadDock and you undock one of them to a floating window, then undock another one in the same floating window you will see two tabs. In the main area the selected tab is bolded, the functionality should be the same in the floating windows

For the time being use the following code to manually bold the tabs:

this.RadDock.FloatingWindowCreated += RadDock_FloatingWindowCreated;
...
void RadDock_FloatingWindowCreated(object sender, FloatingWindowEventArgs e)
{
    e.Window.Controls[0].ControlAdded += Form1_ControlAdded;
}

void Form1_ControlAdded(object sender, ControlEventArgs e)
{
    DocumentTabStrip tabStrip = e.Control as DocumentTabStrip;
    tabStrip.ControlAdded -= Form1_ControlAdded;
    if (tabStrip != null)
    {
        tabStrip.SelectedIndexChanged += tabStrip_SelectedIndexChanged;
    }
}

void tabStrip_SelectedIndexChanged(object sender, EventArgs e)
{
    DocumentTabStrip tabStrip = sender as DocumentTabStrip;
    if (tabStrip != null)
    {
        foreach (DocumentWindow item in tabStrip.Controls)
        {
            item.TabStripItem.ResetValue(RadItem.FontProperty, ValueResetFlags.Local);
        }

        tabStrip.SelectedTab.TabStripItem.Font = new Font(tabStrip.SelectedTab.Font.FontFamily, tabStrip.SelectedTab.Font.Size, FontStyle.Bold);
    }
}

To reproduce:
- Add a document window uppopn a button click. Put the button inside a tool window.

Workaround:
Use ActiveWindowChanged event.

Steps to reproduce:

1. Open the form at design time
2. Add a RadDock
3. Add a MS Panel
4. Put the RadDock inside the panel
5. Dock the Panel to Fill, dock RadDock to Fill as well.
6. Open RadDock's Advanced Layout Designer
7. Add two ToolWindows to the left and redock them in order to share one common container.
8. Hide the ToolWindows by unchecking the check-boxes in the Advanced Layout Designer and save the changes
9. Add a RadPanel (Dock=Fill) to the active ToolWindow.
10. Add a RadGridView (Anchor = Top, Left, Right, Bottom ), a left RadButton (Anchor = Bottom, Left) and a right RadButton (Anchor = Bottom, Right)to the panel.
11. Save thfs in the designer. Select the RadPanel with the grid and the buttons and click Copy.
12. Select the other ToolWindow and paste.
13. Save the form. Close the designer and reopen it again. You will notice that the pasted panel is not as expected.

The attached video (drag and drop over the browser to play it) illustrates better the performed steps.

Workaround: do not place the RadDock inside a MS Panel. RadDock is supposed to be used as a main container in a form.

To reproduce:

Use the following methods which adds host windows to ToolTabStrip and set the ShowItemCloseButton:

private void AddDocumentStrip()
{
    // Create and add a document strip to the dock.
    this.documentstrip = new ToolTabStrip();
    this.documentstrip.TabStripAlignment = TabStripAlignment.Top;
    this.documentstrip.CaptionVisible = false;
    this.documentstrip.ActionMenuButton.Visibility = ElementVisibility.Hidden;
    this.DocumentDock.Controls.Add(documentstrip);
    this.DocumentDock.ShowToolCloseButton = true;
}

private void radCommandBar1_Click(object sender, EventArgs e)
{
    RadForm testdoc = new RadForm();

    // Create a hostwindow to hold the document (so can interact with the dock)
    HostWindow hostwindow = new HostWindow();
    hostwindow.Text = "Document " + DocumentDock.DockWindows.Count.ToString();
    hostwindow.ToolCaptionButtons = ToolStripCaptionButtons.Close;

    // Load the document into the host window
    hostwindow.LoadContent(testdoc);

    // Set the floating size when it is undocked
    Size size = new Size(660, 440);
    hostwindow.DefaultFloatingSize = size;

    // Make sure a closed document releases its resources
    hostwindow.CloseAction = DockWindowCloseAction.CloseAndDispose;

    // Check if we are opening our first document, requires additional setup
    //if (currentdocuments.Count == 0)
    if (DocumentDock.ActiveWindow == null)
    {
        if (this.DocumentDock.Controls.Count < 2)
        {
            this.documentstrip.Controls.Add(hostwindow);
            this.documentstrip.CaptionVisible = true;
            this.DocumentDock.Controls.Add(documentstrip);
            this.DocumentDock.ShowToolCloseButton = true;
        }
        else
        {
            ((ToolTabStrip)this.DocumentDock.Controls[1]).Controls.Add(hostwindow);
            ((ToolTabStrip)this.DocumentDock.Controls[1]).CaptionVisible = true;
            this.DocumentDock.ShowToolCloseButton = true;
        }
    }
    else
    {
        documentstrip.Controls.Add(hostwindow);
        documentstrip.Show();
    }
    this.documentstrip.Text = "Document " + DocumentDock.DockWindows.Count.ToString();

    //Bring Analyzer to the front
    this.Activate();
}


Click the button a few times, close all windows and click again. You will notice that the close button will not be visible in the new windows.

Alternatively, you can download the sample project.

Workaround:

Manually set the ShowItemCloseButton property to each child ToolTabStrip:

private void AddDocumentStrip()
{
    // Create and add a document strip to the dock.
    this.documentstrip = new ToolTabStrip();
    this.documentstrip.TabStripAlignment = TabStripAlignment.Top;
    this.documentstrip.CaptionVisible = false;
    this.documentstrip.ActionMenuButton.Visibility = ElementVisibility.Hidden;
    this.DocumentDock.Controls.Add(documentstrip);
    this.DocumentDock.ShowToolCloseButton = true;
}

private void radCommandBar1_Click(object sender, EventArgs e)
{
    RadForm testdoc = new RadForm();

    // Create a hostwindow to hold the document (so can interact with the dock)
    HostWindow hostwindow = new HostWindow();
    hostwindow.Text = "Document " + DocumentDock.DockWindows.Count.ToString();
    hostwindow.ToolCaptionButtons = ToolStripCaptionButtons.Close;

    // Load the document into the host window
    hostwindow.LoadContent(testdoc);

    // Set the floating size when it is undocked
    Size size = new Size(660, 440);
    hostwindow.DefaultFloatingSize = size;

    // Make sure a closed document releases its resources
    hostwindow.CloseAction = DockWindowCloseAction.CloseAndDispose;

    // Check if we are opening our first document, requires additional setup
    //if (currentdocuments.Count == 0)
    if (DocumentDock.ActiveWindow == null)
    {
        if (this.DocumentDock.Controls.Count < 2)
        {
            this.documentstrip.Controls.Add(hostwindow);
            this.documentstrip.CaptionVisible = true;
            this.DocumentDock.Controls.Add(documentstrip);
            this.DocumentDock.ShowToolCloseButton = true;
        }
        else
        {
            ((ToolTabStrip)this.DocumentDock.Controls[1]).Controls.Add(hostwindow);
            ((ToolTabStrip)this.DocumentDock.Controls[1]).CaptionVisible = true;
            foreach (ToolTabStrip strip in this.DocumentDock.EnumFrameworkControls<ToolTabStrip>())
            {
                strip.ShowItemCloseButton = true;
            }
        }
    }
    else
    {
        documentstrip.Controls.Add(hostwindow);
        documentstrip.Show();
    }
    this.documentstrip.Text = "Document " + DocumentDock.DockWindows.Count.ToString();

    //Bring Analyzer to the front
    this.Activate();
}

To reproduce:
Use the BugTracker project from the {IntallationFolder}\Examples\BugTracker
1. Change the CloseAction for all DocumentWindows to "Hide".
2. Run the application.
3. Close tab "Bugs"
4. Save the layout, pressing the "Save" button ribbon tab "view"
5. Load the layout.
 You will notice that the "Bugs" tab is visible but in a invalid state.

Workaround: use  DocumentWindow.CloseAction = Close or call  DocumentWindow.Show method before loading the layout.