#region Imports
|
|
using DPumpHydr.WinFrmUI.RLT.Enum.Crown;
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Linq;
|
using System.Windows.Forms;
|
using static DPumpHydr.WinFrmUI.RLT.Helper.CrownHelper;
|
|
#endregion
|
|
namespace DPumpHydr.WinFrmUI.RLT.Docking.Crown
|
{
|
#region CrownDockGroupDocking
|
|
[ToolboxItem(false)]
|
public class CrownDockGroup : Panel
|
{
|
#region Field Region
|
|
private readonly List<CrownDockContent> _contents = new();
|
|
private readonly Dictionary<CrownDockContent, CrownDockTab> _tabs = new();
|
|
private readonly CrownDockTabArea _tabArea;
|
|
private CrownDockTab _dragTab = null;
|
|
#endregion
|
|
#region Property Region
|
|
public CrownDockPanel DockPanel { get; private set; }
|
|
public CrownDockRegion DockRegion { get; private set; }
|
|
public DockArea DockArea { get; private set; }
|
|
public CrownDockContent VisibleContent { get; private set; }
|
|
public int Order { get; set; }
|
|
public int ContentCount => _contents.Count;
|
|
#endregion
|
|
#region Constructor Region
|
|
public CrownDockGroup(CrownDockPanel dockPanel, CrownDockRegion dockRegion, int order)
|
{
|
SetStyle(ControlStyles.OptimizedDoubleBuffer |
|
ControlStyles.ResizeRedraw |
|
ControlStyles.UserPaint, true);
|
|
DockPanel = dockPanel;
|
DockRegion = dockRegion;
|
DockArea = dockRegion.DockArea;
|
|
Order = order;
|
|
_tabArea = new CrownDockTabArea(DockArea);
|
|
DockPanel.ActiveContentChanged += DockPanel_ActiveContentChanged;
|
}
|
|
#endregion
|
|
#region Method Region
|
|
public void AddContent(CrownDockContent dockContent)
|
{
|
dockContent.DockGroup = this;
|
dockContent.Dock = DockStyle.Fill;
|
|
dockContent.Order = 0;
|
|
if (_contents.Count > 0)
|
{
|
int order = -1;
|
foreach (CrownDockContent otherContent in _contents)
|
{
|
if (otherContent.Order >= order)
|
{
|
order = otherContent.Order + 1;
|
}
|
}
|
|
dockContent.Order = order;
|
}
|
|
_contents.Add(dockContent);
|
Controls.Add(dockContent);
|
|
dockContent.DockTextChanged += DockContent_DockTextChanged;
|
|
_tabs.Add(dockContent, new CrownDockTab(dockContent));
|
|
if (VisibleContent == null)
|
{
|
dockContent.Visible = true;
|
VisibleContent = dockContent;
|
}
|
else
|
{
|
dockContent.Visible = false;
|
}
|
|
ToolStripMenuItem menuItem = new(dockContent.DockText)
|
{
|
Tag = dockContent
|
};
|
menuItem.Click += TabMenuItem_Select;
|
menuItem.Image = dockContent.Icon;
|
_tabArea.AddMenuItem(menuItem);
|
|
UpdateTabArea();
|
}
|
|
public void RemoveContent(CrownDockContent dockContent)
|
{
|
dockContent.DockGroup = null;
|
|
int order = dockContent.Order;
|
|
_contents.Remove(dockContent);
|
Controls.Remove(dockContent);
|
|
foreach (CrownDockContent otherContent in _contents)
|
{
|
if (otherContent.Order > order)
|
{
|
otherContent.Order--;
|
}
|
}
|
|
dockContent.DockTextChanged -= DockContent_DockTextChanged;
|
|
if (_tabs.ContainsKey(dockContent))
|
{
|
_tabs.Remove(dockContent);
|
}
|
|
if (VisibleContent == dockContent)
|
{
|
VisibleContent = null;
|
|
if (_contents.Count > 0)
|
{
|
CrownDockContent newContent = _contents[0];
|
newContent.Visible = true;
|
VisibleContent = newContent;
|
}
|
}
|
|
ToolStripMenuItem menuItem = _tabArea.GetMenuItem(dockContent);
|
|
menuItem.Click -= TabMenuItem_Select;
|
_tabArea.RemoveMenuItem(menuItem);
|
|
UpdateTabArea();
|
}
|
|
public List<CrownDockContent> GetContents()
|
{
|
return _contents.OrderBy(c => c.Order).ToList();
|
}
|
|
private void UpdateTabArea()
|
{
|
if (DockArea == DockArea.Document)
|
{
|
_tabArea.Visible = _contents.Count > 0;
|
}
|
else
|
{
|
_tabArea.Visible = _contents.Count > 1;
|
}
|
|
int size = 0;
|
|
switch (DockArea)
|
{
|
case DockArea.Document:
|
size = _tabArea.Visible ? ThemeProvider.Theme.Sizes.DocumentTabAreaSize : 0;
|
Padding = new Padding(0, size, 0, 0);
|
_tabArea.ClientRectangle = new(Padding.Left, 0, ClientRectangle.Width - Padding.Horizontal, size);
|
break;
|
case DockArea.Left:
|
case DockArea.Right:
|
size = _tabArea.Visible ? ThemeProvider.Theme.Sizes.ToolWindowTabAreaSize : 0;
|
Padding = new Padding(0, 0, 0, size);
|
_tabArea.ClientRectangle = new(Padding.Left, ClientRectangle.Bottom - size, ClientRectangle.Width - Padding.Horizontal, size);
|
break;
|
case DockArea.Bottom:
|
size = _tabArea.Visible ? ThemeProvider.Theme.Sizes.ToolWindowTabAreaSize : 0;
|
Padding = new Padding(1, 0, 0, size);
|
_tabArea.ClientRectangle = new(Padding.Left, ClientRectangle.Bottom - size, ClientRectangle.Width - Padding.Horizontal, size);
|
break;
|
}
|
|
if (DockArea == DockArea.Document)
|
{
|
int dropdownSize = ThemeProvider.Theme.Sizes.DocumentTabAreaSize;
|
_tabArea.DropdownRectangle = new(_tabArea.ClientRectangle.Right - dropdownSize, 0, dropdownSize, dropdownSize);
|
}
|
|
BuildTabs();
|
|
EnsureVisible();
|
}
|
|
private void BuildTabs()
|
{
|
if (!_tabArea.Visible)
|
{
|
return;
|
}
|
|
SuspendLayout();
|
|
int closeButtonSize = Properties.Resources.close_normal.Width;
|
|
// Calculate areas of all tabs
|
int totalSize = 0;
|
|
IOrderedEnumerable<CrownDockContent> orderedContent = _contents.OrderBy(c => c.Order);
|
|
foreach (CrownDockContent content in orderedContent)
|
{
|
int width;
|
|
CrownDockTab tab = _tabs[content];
|
|
using (Graphics g = CreateGraphics())
|
{
|
width = tab.CalculateWidth(g, Font);
|
}
|
|
// Add additional width for document tab items
|
if (DockArea == DockArea.Document)
|
{
|
width += 5;
|
width += closeButtonSize;
|
|
if (tab.DockContent.Icon != null)
|
{
|
width += tab.DockContent.Icon.Width + 5;
|
}
|
}
|
|
// Show separator on all tabs for now
|
tab.ShowSeparator = true;
|
width += 1;
|
|
int y = DockArea == DockArea.Document ? 0 : ClientRectangle.Height - ThemeProvider.Theme.Sizes.ToolWindowTabAreaSize;
|
int height = DockArea == DockArea.Document ? ThemeProvider.Theme.Sizes.DocumentTabAreaSize : ThemeProvider.Theme.Sizes.ToolWindowTabAreaSize;
|
|
Rectangle tabRect = new(_tabArea.ClientRectangle.Left + totalSize, y, width, height);
|
tab.ClientRectangle = tabRect;
|
|
totalSize += width;
|
}
|
|
// Cap the size if too large for the tab area
|
if (DockArea != DockArea.Document)
|
{
|
if (totalSize > _tabArea.ClientRectangle.Width)
|
{
|
int difference = totalSize - _tabArea.ClientRectangle.Width;
|
|
// No matter what, we want to slice off the 1 pixel separator from the final tab.
|
CrownDockTab lastTab = _tabs[orderedContent.Last()];
|
Rectangle tabRect = lastTab.ClientRectangle;
|
lastTab.ClientRectangle = new(tabRect.Left, tabRect.Top, tabRect.Width - 1, tabRect.Height);
|
lastTab.ShowSeparator = false;
|
|
int differenceMadeUp = 1;
|
|
// Loop through and progressively resize the larger tabs until the total size fits within the tab area.
|
while (differenceMadeUp < difference)
|
{
|
int largest = _tabs.Values.OrderByDescending(tab => tab.ClientRectangle.Width)
|
.First()
|
.ClientRectangle.Width;
|
|
foreach (CrownDockContent content in orderedContent)
|
{
|
CrownDockTab tab = _tabs[content];
|
|
// Check if previous iteration of loop met the difference
|
if (differenceMadeUp >= difference)
|
{
|
break;
|
}
|
|
if (tab.ClientRectangle.Width >= largest)
|
{
|
Rectangle rect = tab.ClientRectangle;
|
tab.ClientRectangle = new(rect.Left, rect.Top, rect.Width - 1, rect.Height);
|
differenceMadeUp += 1;
|
}
|
}
|
}
|
|
// After resizing the tabs reposition them accordingly.
|
int xOffset = 0;
|
foreach (CrownDockContent content in orderedContent)
|
{
|
CrownDockTab tab = _tabs[content];
|
|
Rectangle rect = tab.ClientRectangle;
|
tab.ClientRectangle = new(_tabArea.ClientRectangle.Left + xOffset, rect.Top, rect.Width, rect.Height);
|
|
xOffset += rect.Width;
|
}
|
}
|
}
|
|
// Build close button rectangles
|
if (DockArea == DockArea.Document)
|
{
|
foreach (CrownDockContent content in orderedContent)
|
{
|
if (content.IsShowCloseIcon)
|
{
|
CrownDockTab tab = _tabs[content];
|
Rectangle closeRect = new(tab.ClientRectangle.Right - 7 - closeButtonSize - 1,
|
tab.ClientRectangle.Top + (tab.ClientRectangle.Height / 2) - (closeButtonSize / 2) - 1,
|
closeButtonSize, closeButtonSize);
|
tab.CloseButtonRectangle = closeRect;
|
}
|
|
}
|
}
|
|
// Update the tab area with the new total tab width
|
totalSize = 0;
|
foreach (CrownDockContent content in orderedContent)
|
{
|
CrownDockTab tab = _tabs[content];
|
totalSize += tab.ClientRectangle.Width;
|
}
|
|
_tabArea.TotalTabSize = totalSize;
|
|
ResumeLayout();
|
|
Invalidate();
|
}
|
|
public void EnsureVisible()
|
{
|
if (DockArea != DockArea.Document)
|
{
|
return;
|
}
|
|
if (VisibleContent == null)
|
{
|
return;
|
}
|
|
int width = ClientRectangle.Width - Padding.Horizontal - _tabArea.DropdownRectangle.Width;
|
Rectangle offsetArea = new(Padding.Left, 0, width, 0);
|
|
CrownDockTab tab = _tabs[VisibleContent];
|
|
if (tab.ClientRectangle.IsEmpty)
|
{
|
return;
|
}
|
|
if (RectangleToTabArea(tab.ClientRectangle).Left < offsetArea.Left)
|
{
|
_tabArea.Offset = tab.ClientRectangle.Left;
|
}
|
else if (RectangleToTabArea(tab.ClientRectangle).Right > offsetArea.Right)
|
{
|
_tabArea.Offset = tab.ClientRectangle.Right - width;
|
}
|
|
if (_tabArea.TotalTabSize < offsetArea.Width)
|
{
|
_tabArea.Offset = 0;
|
}
|
|
if (_tabArea.TotalTabSize > offsetArea.Width)
|
{
|
IOrderedEnumerable<CrownDockContent> orderedContent = _contents.OrderBy(x => x.Order);
|
CrownDockTab lastTab = _tabs[orderedContent.Last()];
|
if (lastTab != null)
|
{
|
if (RectangleToTabArea(lastTab.ClientRectangle).Right < offsetArea.Right)
|
{
|
_tabArea.Offset = lastTab.ClientRectangle.Right - width;
|
}
|
}
|
}
|
|
Invalidate();
|
}
|
|
public void SetVisibleContent(CrownDockContent content)
|
{
|
if (!_contents.Contains(content))
|
{
|
return;
|
}
|
|
if (VisibleContent != content)
|
{
|
VisibleContent = content;
|
content.Visible = true;
|
|
foreach (CrownDockContent otherContent in _contents)
|
{
|
if (otherContent != content)
|
{
|
otherContent.Visible = false;
|
}
|
}
|
|
Invalidate();
|
}
|
}
|
|
private Point PointToTabArea(Point point)
|
{
|
return new Point(point.X - _tabArea.Offset, point.Y);
|
}
|
|
private Rectangle RectangleToTabArea(Rectangle rectangle)
|
{
|
return new Rectangle(PointToTabArea(rectangle.Location), rectangle.Size);
|
}
|
|
#endregion
|
|
#region Event Handler Region
|
|
protected override void OnResize(EventArgs eventargs)
|
{
|
base.OnResize(eventargs);
|
|
UpdateTabArea();
|
}
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
{
|
base.OnMouseMove(e);
|
|
if (_dragTab != null)
|
{
|
int offsetX = e.Location.X + _tabArea.Offset;
|
if (offsetX < _dragTab.ClientRectangle.Left)
|
{
|
if (_dragTab.DockContent.Order > 0)
|
{
|
List<CrownDockTab> otherTabs = _tabs.Values.Where(t => t.DockContent.Order == _dragTab.DockContent.Order - 1).ToList();
|
if (otherTabs.Count == 0)
|
{
|
return;
|
}
|
|
CrownDockTab otherTab = otherTabs.First();
|
|
if (otherTab == null)
|
{
|
return;
|
}
|
|
int oldIndex = _dragTab.DockContent.Order;
|
_dragTab.DockContent.Order = oldIndex - 1;
|
otherTab.DockContent.Order = oldIndex;
|
|
BuildTabs();
|
EnsureVisible();
|
|
_tabArea.RebuildMenu();
|
|
return;
|
}
|
}
|
else if (offsetX > _dragTab.ClientRectangle.Right)
|
{
|
int maxOrder = _contents.Count;
|
|
if (_dragTab.DockContent.Order < maxOrder)
|
{
|
List<CrownDockTab> otherTabs = _tabs.Values.Where(t => t.DockContent.Order == _dragTab.DockContent.Order + 1).ToList();
|
if (otherTabs.Count == 0)
|
{
|
return;
|
}
|
|
CrownDockTab otherTab = otherTabs.First();
|
|
if (otherTab == null)
|
{
|
return;
|
}
|
|
int oldIndex = _dragTab.DockContent.Order;
|
_dragTab.DockContent.Order = oldIndex + 1;
|
otherTab.DockContent.Order = oldIndex;
|
|
BuildTabs();
|
EnsureVisible();
|
|
_tabArea.RebuildMenu();
|
|
return;
|
}
|
}
|
|
return;
|
}
|
|
if (_tabArea.DropdownRectangle.Contains(e.Location))
|
{
|
_tabArea.DropdownHot = true;
|
|
foreach (CrownDockTab tab in _tabs.Values)
|
{
|
tab.Hot = false;
|
}
|
|
Invalidate();
|
return;
|
}
|
|
_tabArea.DropdownHot = false;
|
|
foreach (CrownDockTab tab in _tabs.Values)
|
{
|
Rectangle rect = RectangleToTabArea(tab.ClientRectangle);
|
bool hot = rect.Contains(e.Location);
|
|
if (tab.Hot != hot)
|
{
|
tab.Hot = hot;
|
Invalidate();
|
}
|
|
Rectangle closeRect = RectangleToTabArea(tab.CloseButtonRectangle);
|
bool closeHot = closeRect.Contains(e.Location);
|
|
if (tab.CloseButtonHot != closeHot)
|
{
|
tab.CloseButtonHot = closeHot;
|
Invalidate();
|
}
|
}
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
base.OnMouseDown(e);
|
|
if (_tabArea.DropdownRectangle.Contains(e.Location))
|
{
|
_tabArea.DropdownHot = true;
|
return;
|
}
|
|
foreach (CrownDockTab tab in _tabs.Values)
|
{
|
Rectangle rect = RectangleToTabArea(tab.ClientRectangle);
|
if (rect.Contains(e.Location))
|
{
|
if (e.Button == MouseButtons.Middle)
|
{
|
tab.DockContent.Close();
|
return;
|
}
|
|
Rectangle closeRect = RectangleToTabArea(tab.CloseButtonRectangle);
|
if (closeRect.Contains(e.Location))
|
{
|
_tabArea.ClickedCloseButton = tab;
|
return;
|
}
|
else
|
{
|
DockPanel.ActiveContent = tab.DockContent;
|
EnsureVisible();
|
|
_dragTab = tab;
|
|
return;
|
}
|
}
|
}
|
|
if (VisibleContent != null)
|
{
|
DockPanel.ActiveContent = VisibleContent;
|
}
|
}
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
{
|
base.OnMouseUp(e);
|
|
_dragTab = null;
|
|
if (_tabArea.DropdownRectangle.Contains(e.Location))
|
{
|
if (_tabArea.DropdownHot)
|
{
|
_tabArea.ShowMenu(this, new Point(_tabArea.DropdownRectangle.Left, _tabArea.DropdownRectangle.Bottom - 2));
|
}
|
|
return;
|
}
|
|
if (_tabArea.ClickedCloseButton == null)
|
{
|
return;
|
}
|
|
Rectangle closeRect = RectangleToTabArea(_tabArea.ClickedCloseButton.CloseButtonRectangle);
|
if (closeRect.Contains(e.Location))
|
{
|
_tabArea.ClickedCloseButton.DockContent.Close();
|
}
|
}
|
|
protected override void OnMouseLeave(EventArgs e)
|
{
|
base.OnMouseLeave(e);
|
|
foreach (CrownDockTab tab in _tabs.Values)
|
{
|
tab.Hot = false;
|
}
|
|
Invalidate();
|
}
|
|
private void TabMenuItem_Select(object sender, EventArgs e)
|
{
|
using ToolStripMenuItem menuItem = sender as ToolStripMenuItem;
|
if (menuItem == null)
|
{
|
return;
|
}
|
|
if (menuItem.Tag is not CrownDockContent content)
|
{
|
return;
|
}
|
|
DockPanel.ActiveContent = content;
|
}
|
|
private void DockPanel_ActiveContentChanged(object sender, DockContentEventArgs e)
|
{
|
if (!_contents.Contains(e.Content))
|
{
|
return;
|
}
|
|
if (e.Content == VisibleContent)
|
{
|
VisibleContent.Focus();
|
return;
|
}
|
|
VisibleContent = e.Content;
|
|
foreach (CrownDockContent content in _contents)
|
{
|
content.Visible = content == VisibleContent;
|
}
|
|
VisibleContent.Focus();
|
|
EnsureVisible();
|
Invalidate();
|
}
|
|
private void DockContent_DockTextChanged(object sender, EventArgs e)
|
{
|
BuildTabs();
|
}
|
|
#endregion
|
|
#region Render Region
|
|
public void Redraw()
|
{
|
Invalidate();
|
|
foreach (CrownDockContent content in _contents)
|
{
|
content.Invalidate();
|
}
|
}
|
|
protected override void OnPaint(PaintEventArgs e)
|
{
|
Graphics g = e.Graphics;
|
|
using (SolidBrush b = new(System.Drawing.Color.White))//tangxu ThemeProvider.Theme.Colors.GreyBackground))
|
{
|
g.FillRectangle(b, ClientRectangle);
|
}
|
|
if (!_tabArea.Visible)
|
{
|
return;
|
}
|
|
using (SolidBrush b = new(System.Drawing.Color.White))//tangxu ThemeProvider.Theme.Colors.MediumBackground))
|
{
|
g.FillRectangle(b, _tabArea.ClientRectangle);
|
}
|
|
foreach (CrownDockTab tab in _tabs.Values)
|
{
|
if (DockArea == DockArea.Document)
|
{
|
PaintDocumentTab(g, tab);
|
}
|
else
|
{
|
PaintToolWindowTab(g, tab);
|
}
|
}
|
|
if (DockArea == DockArea.Document)
|
{
|
// Color divider
|
bool isActiveGroup = DockPanel.ActiveGroup == this;
|
Color divColor = isActiveGroup ? ThemeProvider.Theme.Colors.BlueSelection : System.Drawing.Color.White;// ThemeProvider.Theme.Colors.GreySelection;
|
using (SolidBrush b = new(divColor))
|
{
|
Rectangle divRect = new(_tabArea.ClientRectangle.Left, _tabArea.ClientRectangle.Bottom - 2, _tabArea.ClientRectangle.Width, 2);
|
g.FillRectangle(b, divRect);
|
}
|
|
// Content dropdown list
|
Rectangle dropdownRect = new(_tabArea.DropdownRectangle.Left, _tabArea.DropdownRectangle.Top, _tabArea.DropdownRectangle.Width, _tabArea.DropdownRectangle.Height - 2);
|
|
using (SolidBrush b = new(System.Drawing.Color.White))//tangxu 箭头背景色 ThemeProvider.Theme.Colors.MediumBackground))
|
{
|
g.FillRectangle(b, dropdownRect);
|
}
|
|
using Bitmap img = Properties.Resources.arrow;//箭头是灰色, 以后改成别的颜色
|
g.DrawImageUnscaled(img, dropdownRect.Left + (dropdownRect.Width / 2) - (img.Width / 2), dropdownRect.Top + (dropdownRect.Height / 2) - (img.Height / 2) + 1);
|
}
|
}
|
|
private void PaintDocumentTab(Graphics g, CrownDockTab tab)
|
{
|
Rectangle tabRect = RectangleToTabArea(tab.ClientRectangle);
|
|
bool isVisibleTab = VisibleContent == tab.DockContent;
|
bool isActiveGroup = DockPanel.ActiveGroup == this;
|
|
Color bgColor = isVisibleTab ? ThemeProvider.Theme.Colors.BlueSelection : System.Drawing.Color.White;// ThemeProvider.Theme.Colors.DarkBackground;
|
|
//if (!isActiveGroup)
|
//{
|
// bgColor = isVisibleTab ? ThemeProvider.Theme.Colors.GreySelection : System.Drawing.Color.White;//ThemeProvider.Theme.Colors.DarkBackground;
|
// //bgColor = isVisibleTab ? : ThemeProvider.Theme.Colors.DarkBackground;
|
//}
|
|
if (tab.Hot && !isVisibleTab)
|
{
|
bgColor = System.Drawing.Color.Gray;// ThemeProvider.Theme.Colors.MediumBackground;
|
}
|
|
using (SolidBrush b = new(bgColor))
|
{
|
g.FillRectangle(b, tabRect);
|
}
|
|
// Draw separators
|
if (tab.ShowSeparator)
|
{
|
using Pen p = new(ThemeProvider.Theme.Colors.DarkBorder);
|
g.DrawLine(p, tabRect.Right - 1, tabRect.Top, tabRect.Right - 1, tabRect.Bottom);
|
}
|
|
int xOffset = 0;
|
|
// Draw icon
|
if (tab.DockContent.Icon != null)
|
{
|
g.DrawImageUnscaled(tab.DockContent.Icon, tabRect.Left + 5, tabRect.Top + 4);
|
xOffset += tab.DockContent.Icon.Width + 2;
|
}
|
|
StringFormat tabTextFormat = new()
|
{
|
Alignment = StringAlignment.Near,
|
LineAlignment = StringAlignment.Center,
|
FormatFlags = StringFormatFlags.NoWrap,
|
Trimming = StringTrimming.EllipsisCharacter
|
};
|
|
// Draw text
|
Color textColor = isVisibleTab ? ThemeProvider.Theme.Colors.LightText : ThemeProvider.Theme.Colors.DisabledText;
|
using (SolidBrush b = new(textColor))
|
{
|
Rectangle textRect = new(tabRect.Left + 5 + xOffset, tabRect.Top, tabRect.Width - tab.CloseButtonRectangle.Width - 7 - 5 - xOffset, tabRect.Height);
|
g.DrawString(tab.DockContent.DockText, Font, b, textRect, tabTextFormat);
|
}
|
|
// Close button
|
Bitmap img = tab.CloseButtonHot ? Properties.Resources.inactive_close_selected : Properties.Resources.inactive_close;
|
|
if (isVisibleTab)
|
{
|
if (isActiveGroup)
|
{
|
img = tab.CloseButtonHot ? Properties.Resources.close_selected : Properties.Resources.close_normal;
|
}
|
else
|
{
|
img = tab.CloseButtonHot ? Properties.Resources.close_selected : Properties.Resources.active_inactive_close;
|
}
|
}
|
if (tab.DockContent == null || tab.DockContent.IsShowCloseIcon)
|
{
|
Rectangle closeRect = RectangleToTabArea(tab.CloseButtonRectangle);
|
g.DrawImageUnscaled(img, closeRect.Left, closeRect.Top);
|
}
|
}
|
|
private void PaintToolWindowTab(Graphics g, CrownDockTab tab)
|
{
|
Rectangle tabRect = tab.ClientRectangle;
|
|
bool isVisibleTab = VisibleContent == tab.DockContent;
|
|
Color bgColor = isVisibleTab ? ThemeProvider.Theme.Colors.GreyBackground : ThemeProvider.Theme.Colors.DarkBackground;
|
//System.Drawing.Color.White : System.Drawing.Color.Gray;//
|
if (tab.Hot && !isVisibleTab)
|
{
|
bgColor = System.Drawing.Color.Gray;//ThemeProvider.Theme.Colors.MediumBackground;
|
}
|
|
using (SolidBrush b = new(bgColor))
|
{
|
g.FillRectangle(b, tabRect);
|
}
|
|
// Draw separators
|
if (tab.ShowSeparator)
|
{
|
using Pen p = new(ThemeProvider.Theme.Colors.DarkBorder);
|
g.DrawLine(p, tabRect.Right - 1, tabRect.Top, tabRect.Right - 1, tabRect.Bottom);
|
}
|
|
StringFormat tabTextFormat = new()
|
{
|
Alignment = StringAlignment.Near,
|
LineAlignment = StringAlignment.Center,
|
FormatFlags = StringFormatFlags.NoWrap,
|
Trimming = StringTrimming.EllipsisCharacter
|
};
|
|
Color textColor = isVisibleTab ? ThemeProvider.Theme.Colors.BlueHighlight : ThemeProvider.Theme.Colors.DisabledText;
|
using (SolidBrush b = new(textColor))
|
{
|
Rectangle textRect = new(tabRect.Left + 5, tabRect.Top, tabRect.Width - 5, tabRect.Height);
|
g.DrawString(tab.DockContent.DockText, Font, b, textRect, tabTextFormat);
|
}
|
}
|
|
protected override void OnPaintBackground(PaintEventArgs e)
|
{
|
// Absorb event
|
}
|
|
#endregion
|
}
|
|
#endregion
|
}
|
