Completed
Last Updated: 07 Nov 2019 14:11 by ADMIN
Release R1 2020 (LIB 2019.3.1111)

If you apply one theme to the entire application and want to apply another theme for RadDock as it is demonstrated in this help article, the ThemeName property of RadDock is not respected:

             

        public RadForm1()
        {
            InitializeComponent();

            radDock1.ElementTree.EnableApplicationThemeName = false;
            radDock1.ThemeName = "FluentDark"; 
            ThemeResolutionService.ApplicationThemeName = "Windows7"; 
        }

 

Completed
Last Updated: 07 Nov 2019 14:09 by ADMIN
Release R1 2020 (LIB 2019.3.1111)

Please run the attached sample project with the latest version. You will notice that the maximized floating window is not loaded properly. This used to work in versions prior to R1 2019.

Workaround: remove "WindowState=Maximized" from the XML.

Completed
Last Updated: 02 May 2019 16:07 by ADMIN
Release R2 2019

1. Add 4 ToolWindows - left, top, right, bottom. 

2. Add one DocumentWindow at the center.

3. In the Load event set the MainDocumentContainerVisible property to false. 

Please refer to the attached sample gif files. Even though the document container is not shown, the docking guides for the tabbed document are visible. 

Completed
Last Updated: 23 Nov 2018 12:38 by Dimitar
How to reproduce: add a textbox to to a document window of a RadDock in the designer of Visual Studio and set its Anchor property to Top | Left | Right

Workaround: set the anchors at run-time after loading the form
Completed
Last Updated: 16 May 2019 08:57 by ADMIN
Release R1 2019
To reproduce: run the attached sample project. Click the Close button and then the Show button. You will notice that the list view is no longer available. 

Workaround: instead of using MDI, set the hostWindow.DockState = DockState.TabbedDocument; before showing the form.
Completed
Last Updated: 04 Oct 2019 08:23 by ADMIN
Release R1 2019
Please use the project attached.

1.Run the application with multi-monitor configuration.
2.Undock toolWindow1 from RadForm1 and maximize it to the different window.
3.Close the application (the layout will be saved).
4.Run the application again.

Workaround: handle the FloatingWindowCreated event and set FormWindowState.Maximized for the floating window.


    protected override void OnLoad(EventArgs e)
    {
      base.OnLoad(e);
        this.radDock1.FloatingWindowCreated+=radDock1_FloatingWindowCreated;
      if (File.Exists(FileName))
        radDock1.LoadFromXml(FileName);
    }

    private void radDock1_FloatingWindowCreated(object sender, Telerik.WinControls.UI.Docking.FloatingWindowEventArgs e)
    {
        e.Window.WindowState = FormWindowState.Maximized;
    }
Completed
Last Updated: 17 Jul 2018 10:39 by Dimitar
How to reproduce: 
Check the attached project and video

Workaround:
Set the MaximumSize property of the control while designing the form and remove it when the application starts
Completed
Last Updated: 30 Apr 2019 07:59 by ADMIN
Release R2 2019
How to reproduce: check the attached project and video

Workaround:
public partial class RadForm1 : Telerik.WinControls.UI.RadForm
{
    public RadForm1()
    {
        InitializeComponent();
        radDock1.FloatingWindowCreated += RadDock1_FloatingWindowCreated;
    }

    private void RadDock1_FloatingWindowCreated(object sender, Telerik.WinControls.UI.Docking.FloatingWindowEventArgs e)
    {
        e.Window = new MyWindow(this.radDock1);
    }
}

public class MyWindow : FloatingWindow
{
    SizeF oldDpi = new SizeF(1, 1);

    public MyWindow(RadDock dockManager) : base (dockManager)
    { }
    protected override void HandleDpiChanged()
    {
        
        base.HandleDpiChanged();
        SizeF descale = new SizeF(1f / this.FormElement.DpiScaleFactor.Width, 1f / this.FormElement.DpiScaleFactor.Height);
        this.Scale(descale);
        var dpi = NativeMethods.GetMonitorDpi(Screen.FromRectangle(this.Bounds), NativeMethods.DpiType.Effective);
        if (oldDpi != dpi)
        {
            SizeF sz = new SizeF(dpi.Width / oldDpi.Width, dpi.Height / oldDpi.Height);

            this.Scale(dpi);
        }

        oldDpi = dpi;
    }
}
Completed
Last Updated: 06 Jul 2018 08:38 by Dimitar
Use attached project to reproduce.

Workaround:
https://docs.telerik.com/devtools/winforms/dock/object-model/customizing-tabstrip-items#documenttabstrip-multi-line-row-layout-with-a-custom-tab-shape
Completed
Last Updated: 13 Mar 2018 07:36 by Dimitar
To reproduce:
            ThemeResolutionService.ApplicationThemeName = "FluentDark";

            this.documentTabStrip1.TabStripAlignment = Telerik.WinControls.UI.TabStripAlignment.Left;
            this.documentTabStrip1.TabStripTextOrientation = Telerik.WinControls.UI.TabStripTextOrientation.Vertical;

Workaround:  this.documentTabStrip1.TabStripElement.ItemBorderAndFillOrientation = Telerik.WinControls.UI.PageViewContentOrientation.Horizontal;
Completed
Last Updated: 20 Mar 2018 12:53 by Dimitar
The expected behavior should be similar to Visual Studio, once a maximized floating window starts being dragged it should go to a normal state so that the window under it is visible.

How to reproduce: just maximize a floating window, then start dragging it from the title bar, the docking guides will appear which do not help much since the window is still maximized.

Workaround: handle the Starting event of the DragDropService and change the WindowState of the window
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        
        DragDropService service = this.radDock1.GetService<DragDropService>();
        service.Starting += Service_Starting;
    }

    private void Service_Starting(object sender, StateServiceStartingEventArgs e)
    {
        FloatingWindow fw = e.Context as FloatingWindow;
        if (fw != null && fw.WindowState == FormWindowState.Maximized)
        {
            fw.WindowState = FormWindowState.Normal;
            fw.Location = new Point(Cursor.Position.X - fw.Size.Width / 2, Cursor.Position.Y);
        }
    }
}

Completed
Last Updated: 24 Jan 2018 15:54 by ADMIN
When a document tab is already current, if the user clicks and holds the mouse button on the this tab label, the sibling tab is brought to the front and overlays it visually, so the corners of tab2 obscure the edges of tab1.
Completed
Last Updated: 11 Apr 2019 14:50 by Dimitar
Release R2 2019 (LIB 2019.1.415)
Use attached to reproduce.

Tested on Windows 10 (1607 and 1703)

Workaround:

RadControl.EnableDpiScaling = False

Completed
Last Updated: 07 Dec 2017 15:00 by ADMIN
Use the attached project to reproduce.

Workaround:
 radDock1.DocumentManager.BoldActiveDocument = false;
Completed
Last Updated: 22 Jan 2018 13:45 by Dimitar
Workaround:
            ContextMenuService menuService = this.radDock1.GetService<ContextMenuService>();
            menuService.ContextMenuDisplaying += menuService_ContextMenuDisplaying;

        private void menuService_ContextMenuDisplaying(object sender, ContextMenuDisplayingEventArgs e)
        {
            foreach (RadMenuItem listMenuItem in e.MenuItems)
            {
                TextPrimitive textPrimitive = listMenuItem.Layout.TextPanel.Children[0] as TextPrimitive;
                textPrimitive.UseMnemonic = false;
            }
        }
Completed
Last Updated: 28 Aug 2017 10:08 by ADMIN
How to reproduce: try resizing a too window using its splitter

Workaround: create a custom RadDock using special layout strategy
public class MyRadDock : RadDock
{
    public override string ThemeClassName
    {
        get
        {
            return typeof(RadDock).FullName;
        }
    }

    protected override SplitContainerLayoutStrategy CreateLayoutStrategy()
    {
        MySplitContainerLayoutStrategy strategy = null;
        if (this.LayoutStrategyType != null)
        {
            try
            {
                strategy = Activator.CreateInstance(this.LayoutStrategyType) as MySplitContainerLayoutStrategy;
            }
            catch
            {
                strategy = null;
            }
        }

        if (strategy == null)
        {
            strategy = new MySplitContainerLayoutStrategy();
        }

        strategy.RootContainerType = typeof(RadDock);
        return strategy;
    }
}

public class MySplitContainerLayoutStrategy : SplitContainerLayoutStrategy
{
    protected override void Measure()
    {
        SplitContainerLayoutInfo layoutInfo = (SplitContainerLayoutInfo)typeof(SplitContainerLayoutStrategy).GetField("layoutInfo", BindingFlags.Instance | BindingFlags.NonPublic).
            GetValue(this);

        SplitPanel fillPanel = (SplitPanel)typeof(SplitContainerLayoutInfo).GetField("fillPanel", BindingFlags.Instance | BindingFlags.NonPublic).
            GetValue(layoutInfo);

        if (fillPanel == null)
        {
            base.Measure();
        }

        this.MeasureWithFillPanel();

        typeof(SplitContainerLayoutStrategy).GetMethod("ClampMeasuredLength", BindingFlags.Instance | BindingFlags.NonPublic).
            Invoke(this, new object[] { });
    }

    private void MeasureWithFillPanel()
    {
        FieldInfo layoutInfoFi = typeof(SplitContainerLayoutStrategy).GetField("layoutInfo", BindingFlags.Instance | BindingFlags.NonPublic);
        SplitContainerLayoutInfo layoutInfo = (SplitContainerLayoutInfo)layoutInfoFi.GetValue(this);

        int availableLength = (int)typeof(SplitContainerLayoutInfo).GetField("availableLength", BindingFlags.Instance | BindingFlags.NonPublic).
          GetValue(layoutInfo);

        int remaining = availableLength;
        SplitPanel panel;

        //calculate the desired size of all non-fill panels
        int desiredNonFillLength = 0;

        List<SplitPanel> layoutTargets = (List<SplitPanel>)typeof(SplitContainerLayoutInfo).GetField("layoutTargets", BindingFlags.Instance | BindingFlags.NonPublic).
            GetValue(layoutInfo);

        SplitPanel fillPanel = (SplitPanel)typeof(SplitContainerLayoutInfo).GetField("fillPanel", BindingFlags.Instance | BindingFlags.NonPublic).
              GetValue(layoutInfo);

        int count = layoutTargets.Count;
        for (int i = 0; i < count; i++)
        {
            panel = layoutTargets[i];
            if (panel == fillPanel)
            {
                continue;
            }

            desiredNonFillLength += this.GetLength(panel.SizeInfo.AbsoluteSize);
        }

        SplitPanelSizeInfo fillInfo = fillPanel.SizeInfo;

        int totalSplitterLength = (int)typeof(SplitContainerLayoutInfo).GetField("totalSplitterLength", BindingFlags.Instance | BindingFlags.NonPublic).
              GetValue(layoutInfo);
        int layoutableLength = availableLength - totalSplitterLength;
        int correction = 0;

        int totalMinLength = (int)typeof(SplitContainerLayoutInfo).GetField("totalMinLength", BindingFlags.Instance | BindingFlags.NonPublic).
              GetValue(layoutInfo);

        int desiredFillLength = totalMinLength;
        if (desiredNonFillLength + desiredFillLength > layoutableLength)
        {
            correction = (desiredNonFillLength + desiredFillLength) - layoutableLength;
        }

        int remainingCorrection = correction;
        for (int i = 0; i < layoutTargets.Count; i++)
        {
            panel = layoutTargets[i];
            if (panel == fillPanel)
            {
                continue;
            }

            int length = this.GetLength(TelerikDpiHelper.ScaleSize(panel.SizeInfo.AbsoluteSize, new SizeF(1f / panel.SplitPanelElement.DpiScaleFactor.Width, 1f / panel.SplitPanelElement.DpiScaleFactor.Height)));
            if (remainingCorrection > 0 && panel.SizeInfo.SizeMode != SplitPanelSizeMode.Absolute)
            {
                float factor = (float)length / desiredNonFillLength;
                int panelCorrection = Math.Max(1, (int)(factor * correction));
                remainingCorrection -= panelCorrection;
                length -= panelCorrection;
            }

            panel.SizeInfo.MeasuredLength = length;
            int splitterLength = (int)typeof(SplitContainerLayoutInfo).GetField("splitterLength", BindingFlags.Instance | BindingFlags.NonPublic).
             GetValue(layoutInfo);
            remaining -= (panel.SizeInfo.MeasuredLength + splitterLength);
        }
        
        fillPanel.SizeInfo.MeasuredLength = remaining;
    }
}

Completed
Last Updated: 15 Aug 2017 11:03 by ADMIN
To reproduce:
- Auto-hide some windows to the left.
- Save the layout 
- Load the layout
- The auto-hide popup is shown. 
Completed
Last Updated: 15 Aug 2017 10:54 by ADMIN
Please refer to the attached sample project and follow the steps in the gif file.

The issue appears when the ToolWindow DockState is set to auto-hide for the firs time as well.
 
Completed
Last Updated: 19 Jun 2017 12:59 by ADMIN
ADMIN
Created by: Dimitar
Comments: 2
Category: Dock
Type: Bug Report
5
To reproduce:
Use the approach here:  http://docs.telerik.com/devtools/winforms/dock/object-model/customizing-floating-windows

Workaround:
private void RadDock1_FloatingWindowCreated(object sender, Telerik.WinControls.UI.Docking.FloatingWindowEventArgs e)
{
    e.Window = new MyWindow(radDock1);
    e.Window.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Sizable;

}

class MyWindow : FloatingWindow
{
    public MyWindow(RadDock dock): base(dock)
    {

    }
    protected override CreateParams CreateParams
    {
        get
        {
            CreateParams cp = base.CreateParams;
            cp.Style |= NativeMethods.WS_THICKFRAME;
            return cp;
        }
    }
}
1 2 3 4 5 6