806 lines
36 KiB
C#
806 lines
36 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
|
|
namespace DevComponents.DotNetBar.Layout
|
|
{
|
|
[Designer("DevComponents.DotNetBar.Layout.Design.LayoutGroupDesigner, DevComponents.DotNetBar.Layout.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=7eb7c3a35b91de04")]
|
|
public class LayoutGroup : LayoutItemBase
|
|
{
|
|
#region Constructor
|
|
/// <summary>
|
|
/// Initializes a new instance of the LayoutGroup class.
|
|
/// </summary>
|
|
public LayoutGroup()
|
|
{
|
|
_CaptionStyle = new SimpleStyle();
|
|
_CaptionStyle.PropertyChanged += CaptionStylePropertyChanged;
|
|
|
|
_Items = new LayoutItemCollection();
|
|
_Items.SetParentItem(this);
|
|
}
|
|
|
|
protected override void OnDispose()
|
|
{
|
|
_CaptionStyle.PropertyChanged -= CaptionStylePropertyChanged;
|
|
base.OnDispose();
|
|
}
|
|
#endregion
|
|
|
|
#region Implementation
|
|
private Rectangle _ActualBounds = Rectangle.Empty;
|
|
/// <summary>
|
|
/// Gets actual bounds of elements inside of group. The actual bounds may differ from requested layout bounds due to minium
|
|
/// size constraint.
|
|
/// </summary>
|
|
internal Rectangle ActualBounds
|
|
{
|
|
get
|
|
{
|
|
return _ActualBounds;
|
|
}
|
|
set
|
|
{
|
|
_ActualBounds = value;
|
|
}
|
|
}
|
|
protected override void OnPaint(PaintContext context)
|
|
{
|
|
OnPaintBackground(context);
|
|
|
|
if (!_CaptionBounds.IsEmpty)
|
|
{
|
|
bool isImageVisible = this.IsImageVisible;
|
|
Graphics g = context.Graphics;
|
|
//context.Graphics.FillRectangle(Brushes.Aqua, _CaptionBounds);
|
|
|
|
Color textColor = context.LabelTextColor;
|
|
bool dispose = false;
|
|
Brush textBrush = context.LabelTextBrush;
|
|
|
|
if (_Appearance == eGroupAppearance.Panel)
|
|
{
|
|
textColor = PaintPanelCaption(context);
|
|
textBrush = new SolidBrush(textColor);
|
|
dispose = true;
|
|
}
|
|
else if (_Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
textColor = PaintGroupPanelCaption(context);
|
|
textBrush = new SolidBrush(textColor);
|
|
dispose = true;
|
|
}
|
|
else if (_CaptionStyle.IsPainted)
|
|
{
|
|
DrawingHelpers.PaintStyle(g, _CaptionStyle, _CaptionBounds);
|
|
}
|
|
if (!_CaptionStyle.TextColor.IsEmpty)
|
|
{
|
|
textColor = _CaptionStyle.TextColor;
|
|
textBrush = new SolidBrush(textColor);
|
|
dispose = true;
|
|
}
|
|
if (this.TextPosition == eLayoutPosition.Top || this.TextPosition == eLayoutPosition.Bottom)
|
|
{
|
|
PaintText(context, isImageVisible, textColor, ActualTextBounds, textBrush);
|
|
}
|
|
else
|
|
{
|
|
// Rotate rendering
|
|
g.RotateTransform(-90);
|
|
//Rectangle r = new Rectangle(_CaptionBounds.Top, -_CaptionBounds.Right, _CaptionBounds.Height, _CaptionBounds.Width);
|
|
//Rectangle r = new Rectangle(-_CaptionBounds.Bottom, _CaptionBounds.X, _CaptionBounds.Height, _CaptionBounds.Width);
|
|
Rectangle r = new Rectangle(-ActualTextBounds.Bottom, ActualTextBounds.X, ActualTextBounds.Height, ActualTextBounds.Width);
|
|
PaintText(context, isImageVisible, textColor, r, textBrush);
|
|
g.ResetTransform();
|
|
}
|
|
if (dispose)
|
|
textBrush.Dispose();
|
|
|
|
if (isImageVisible)
|
|
PaintImage(context, textColor);
|
|
}
|
|
|
|
foreach (LayoutItemBase item in _Items)
|
|
{
|
|
if (!item.Visible) continue;
|
|
item.Paint(context);
|
|
}
|
|
//context.Graphics.DrawRectangle(Pens.Green, ActualBounds);
|
|
}
|
|
private Color PaintPanelCaption(PaintContext context)
|
|
{
|
|
Rectangle bounds = _CaptionBounds;
|
|
if (!this.CaptionStyle.Margin.IsEmpty)
|
|
bounds = Helpers.Deflate(bounds, this.CaptionStyle.Margin);
|
|
Graphics g = context.Graphics;
|
|
DevComponents.DotNetBar.Rendering.Office2007ColorTable table = ((DevComponents.DotNetBar.Rendering.Office2007Renderer)DevComponents.DotNetBar.Rendering.GlobalManager.Renderer).ColorTable;
|
|
|
|
Color border = table.LegacyColors.PanelBorder;
|
|
Color back1 = table.LegacyColors.PanelBackground;
|
|
Color back2 = table.LegacyColors.PanelBackground2;
|
|
Color textColor = table.LegacyColors.PanelText;
|
|
int backAngle = table.LegacyColors.PanelBackgroundGradientAngle;
|
|
|
|
PaintRectangle(bounds, g, border, back1, back2, backAngle);
|
|
|
|
return textColor;
|
|
}
|
|
private Color PaintGroupPanelCaption(PaintContext context)
|
|
{
|
|
Rectangle r = _CaptionBounds;
|
|
Graphics g = context.Graphics;
|
|
ElementStyleDisplayInfo info = new ElementStyleDisplayInfo(_GroupPanelStyle, g, r);
|
|
ElementStyleDisplay.Paint(info);
|
|
|
|
return _GroupPanelStyle.TextColor;
|
|
}
|
|
const int CaptionEdgeDistance = 4;
|
|
private Rectangle GetGroupPanelCaptionBounds(Rectangle r)
|
|
{
|
|
eLayoutPosition textPosition = TextPosition;
|
|
eTextAlignment textAlignment = TextAlignment;
|
|
Size imageSize = GetImageSize();
|
|
if (!imageSize.IsEmpty) imageSize.Width += this.ImageTextSpacing;
|
|
int captionWidth = this.RealTextSize.Width + TextPadding.Horizontal + imageSize.Width;
|
|
if (textPosition == eLayoutPosition.Top || textPosition == eLayoutPosition.Bottom)
|
|
{
|
|
if (textAlignment == eTextAlignment.Left || textAlignment == eTextAlignment.Default)
|
|
{
|
|
r.Width = captionWidth;
|
|
r.X += CaptionEdgeDistance;
|
|
}
|
|
else if (textAlignment == eTextAlignment.Right)
|
|
{
|
|
r.X = r.Right - (captionWidth) - CaptionEdgeDistance;
|
|
r.Width = captionWidth;
|
|
}
|
|
else if (textAlignment == eTextAlignment.Center)
|
|
{
|
|
r.X += (r.Width - captionWidth) / 2;
|
|
r.Width = captionWidth;
|
|
}
|
|
}
|
|
else // Left/Right
|
|
{
|
|
if (textAlignment == eTextAlignment.Left || textAlignment == eTextAlignment.Default)
|
|
{
|
|
r.Y = r.Bottom - captionWidth - CaptionEdgeDistance;
|
|
r.Height = captionWidth;
|
|
|
|
}
|
|
else if (textAlignment == eTextAlignment.Right)
|
|
{
|
|
r.Height = captionWidth;
|
|
r.Y += CaptionEdgeDistance;
|
|
}
|
|
else if (textAlignment == eTextAlignment.Center)
|
|
{
|
|
r.Y += (r.Height - captionWidth) / 2;
|
|
r.Height = captionWidth;
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints the background of the item.
|
|
/// </summary>
|
|
/// <param name="context"></param>
|
|
protected override void OnPaintBackground(PaintContext context)
|
|
{
|
|
if (_Appearance == eGroupAppearance.Panel)
|
|
PaintPanelBackground(context);
|
|
else if (_Appearance == eGroupAppearance.GroupPanel)
|
|
PaintGroupPanelBackground(context);
|
|
else
|
|
base.OnPaintBackground(context);
|
|
}
|
|
|
|
private void PaintPanelBackground(PaintContext context)
|
|
{
|
|
Rectangle bounds = this.Bounds;
|
|
if (!this.Style.Margin.IsEmpty)
|
|
bounds = Helpers.Deflate(bounds, this.Style.Margin);
|
|
Graphics g = context.Graphics;
|
|
DevComponents.DotNetBar.Rendering.Office2007ColorTable table = ((DevComponents.DotNetBar.Rendering.Office2007Renderer)DevComponents.DotNetBar.Rendering.GlobalManager.Renderer).ColorTable;
|
|
|
|
Color border = table.LegacyColors.PanelBorder;
|
|
Color back1 = table.LegacyColors.PanelBackground;
|
|
Color back2 = table.LegacyColors.PanelBackground2;
|
|
int backAngle = table.LegacyColors.PanelBackgroundGradientAngle;
|
|
|
|
PaintRectangle(bounds, g, border, back1, back2, backAngle);
|
|
}
|
|
private static void PaintRectangle(Rectangle bounds, Graphics g, Color border, Color back1, Color back2, int backAngle)
|
|
{
|
|
if (bounds.Width <= 0 || bounds.Height <= 0)
|
|
return;
|
|
|
|
if (back2.IsEmpty)
|
|
{
|
|
if (!back1.IsEmpty)
|
|
{
|
|
using (SolidBrush brush = new SolidBrush(back1))
|
|
g.FillRectangle(brush, bounds);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(bounds, back1, back2, backAngle))
|
|
g.FillRectangle(brush, bounds);
|
|
}
|
|
if (!border.IsEmpty)
|
|
{
|
|
Rectangle borderBounds = bounds;
|
|
borderBounds.Width--; borderBounds.Height--;
|
|
using (Pen pen = new Pen(border))
|
|
g.DrawRectangle(pen, borderBounds);
|
|
}
|
|
}
|
|
private ElementStyle _GroupPanelStyle = null;
|
|
private void PaintGroupPanelBackground(PaintContext context)
|
|
{
|
|
InitializeGroupPanelStyle();
|
|
DevComponents.DotNetBar.Rendering.Office2007ColorTable table = ((DevComponents.DotNetBar.Rendering.Office2007Renderer)DevComponents.DotNetBar.Rendering.GlobalManager.Renderer).ColorTable;
|
|
_GroupPanelStyle.SetColorScheme(table.LegacyColors);
|
|
Rectangle bounds = this.Bounds;
|
|
if (!_CaptionBounds.IsEmpty)
|
|
{
|
|
eLayoutPosition tp = this.TextPosition;
|
|
if (tp == eLayoutPosition.Top)
|
|
{
|
|
bounds.Y += _CaptionBounds.Height / 2;
|
|
bounds.Height -= _CaptionBounds.Height / 2;
|
|
}
|
|
else if (tp == eLayoutPosition.Bottom)
|
|
bounds.Height -= _CaptionBounds.Height / 2;
|
|
else if (tp == eLayoutPosition.Left || tp == eLayoutPosition.Default)
|
|
{
|
|
bounds.X += _CaptionBounds.Width / 2;
|
|
bounds.Width -= _CaptionBounds.Width / 2;
|
|
}
|
|
else // Right
|
|
bounds.Width -= _CaptionBounds.Width / 2;
|
|
}
|
|
if (!this.Style.Margin.IsEmpty)
|
|
bounds = Helpers.Deflate(bounds, this.Style.Margin);
|
|
Graphics g = context.Graphics;
|
|
ElementStyleDisplayInfo info = new ElementStyleDisplayInfo(_GroupPanelStyle, g, bounds);
|
|
ElementStyleDisplay.Paint(info);
|
|
}
|
|
private void InitializeGroupPanelStyle()
|
|
{
|
|
if (_GroupPanelStyle != null) return;
|
|
_GroupPanelStyle = new ElementStyle();
|
|
_GroupPanelStyle.BackColorSchemePart = eColorSchemePart.PanelBackground;
|
|
_GroupPanelStyle.BackColor2SchemePart = eColorSchemePart.PanelBackground2;
|
|
_GroupPanelStyle.BorderColorSchemePart = eColorSchemePart.PanelBorder;
|
|
_GroupPanelStyle.BackColorGradientAngle = 90;
|
|
_GroupPanelStyle.CornerDiameter = 4;
|
|
_GroupPanelStyle.BorderWidth = 1;
|
|
_GroupPanelStyle.Border = DevComponents.DotNetBar.eStyleBorderType.Solid;
|
|
_GroupPanelStyle.CornerType = DevComponents.DotNetBar.eCornerType.Rounded;
|
|
_GroupPanelStyle.TextColorSchemePart = eColorSchemePart.PanelText;
|
|
}
|
|
protected override void OnUpdateLayout()
|
|
{
|
|
base.OnUpdateLayout();
|
|
}
|
|
|
|
private Rectangle _ContentBounds = Rectangle.Empty;
|
|
private ItemLayout _Layout = new ItemLayout();
|
|
/// <summary>
|
|
/// Performs group layout.
|
|
/// </summary>
|
|
/// <param name="context">Layout context information.</param>
|
|
public void Layout(LayoutContext context)
|
|
{
|
|
Rectangle r = this.Bounds;
|
|
|
|
// Calculate text-position
|
|
r = LayoutGroupCaption(context, r);
|
|
|
|
if (!_IsRootGroup)
|
|
r = Helpers.Deflate(r, this.Padding);
|
|
_ContentBounds = r;
|
|
_Layout.Layout(this, r, context);
|
|
}
|
|
|
|
private int _CaptionHeight = 0;
|
|
/// <summary>
|
|
/// Indicates explicit caption height in pixels.
|
|
/// </summary>
|
|
[DefaultValue(0), Category("Appearance"), Description("Indicates caption height in pixels.")]
|
|
public int CaptionHeight
|
|
{
|
|
get { return _CaptionHeight; }
|
|
set
|
|
{
|
|
if (value != _CaptionHeight)
|
|
{
|
|
int oldValue = _CaptionHeight;
|
|
_CaptionHeight = value;
|
|
OnCaptionHeightChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Called when CaptionHeight property has changed.
|
|
/// </summary>
|
|
/// <param name="oldValue">Old property value</param>
|
|
/// <param name="newValue">New property value</param>
|
|
protected virtual void OnCaptionHeightChanged(int oldValue, int newValue)
|
|
{
|
|
this.InvalidateLayout();
|
|
OnPropertyChanged(new PropertyChangedEventArgs("CaptionHeight"));
|
|
}
|
|
|
|
protected override Font GetTextFont(Font defaultFont)
|
|
{
|
|
Font font = defaultFont;
|
|
if (_CaptionStyle.Font != null)
|
|
font = _CaptionStyle.Font;
|
|
return font;
|
|
}
|
|
/// <summary>
|
|
/// Updates the layout of the text inside of item.
|
|
/// </summary>
|
|
protected override void UpdateTextBounds()
|
|
{
|
|
if (_CaptionBounds.IsEmpty) return;
|
|
|
|
Rectangle actualTextBounds = Helpers.Deflate(_CaptionBounds, this.TextPadding);
|
|
Rectangle actualImageBounds = Rectangle.Empty;
|
|
bool isImageVisible = IsImageVisible;
|
|
Size imageSize = Size.Empty;
|
|
if (isImageVisible)
|
|
imageSize = GetImageSize();
|
|
|
|
eTextAlignment textAlignment = this.TextAlignment;
|
|
Size realTextSize = this.RealTextSize;
|
|
|
|
if (isImageVisible)
|
|
{
|
|
eLayoutPosition imagePosition = ImagePosition;
|
|
int imageTextSpacing = ImageTextSpacing;
|
|
|
|
if (TextPosition == eLayoutPosition.Top || TextPosition == eLayoutPosition.Bottom)
|
|
{
|
|
if (imagePosition == eLayoutPosition.Default || imagePosition == eLayoutPosition.Right)
|
|
{
|
|
if (textAlignment == eTextAlignment.Right)
|
|
actualImageBounds = new Rectangle(actualTextBounds.Right - imageSize.Width - imageTextSpacing, actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
else if (textAlignment == eTextAlignment.Center)
|
|
{
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.Right - (imageSize.Width + CaptionEdgeDistance), actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Width = realTextSize.Width;
|
|
}
|
|
else
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + actualTextBounds.Width / 2 + realTextSize.Width / 2 + this.ImageTextSpacing, actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
}
|
|
else
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + imageTextSpacing + realTextSize.Width, actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
actualImageBounds.X -= CaptionEdgeDistance;
|
|
}
|
|
}
|
|
else if (imagePosition == eLayoutPosition.Left)
|
|
{
|
|
if (textAlignment == eTextAlignment.Right)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.Right - (realTextSize.Width + imageSize.Width + imageTextSpacing), actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
actualImageBounds.X += CaptionEdgeDistance;
|
|
}
|
|
else if (textAlignment == eTextAlignment.Center)
|
|
{
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + CaptionEdgeDistance, actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.X = actualImageBounds.Right;
|
|
actualTextBounds.Width = realTextSize.Width;
|
|
}
|
|
else
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + actualTextBounds.Width / 2 - (realTextSize.Width / 2 + this.ImageTextSpacing + imageSize.Width), actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
}
|
|
else
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X, actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.X += actualImageBounds.Width + imageTextSpacing;
|
|
actualTextBounds.Width -= actualImageBounds.Width + imageTextSpacing;
|
|
}
|
|
}
|
|
else if (imagePosition == eLayoutPosition.Top)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2,
|
|
actualTextBounds.Y - (imageSize.Height + imageTextSpacing),
|
|
imageSize.Width,
|
|
imageSize.Height);
|
|
}
|
|
else if (imagePosition == eLayoutPosition.Bottom)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2,
|
|
actualTextBounds.Bottom + imageTextSpacing,
|
|
imageSize.Width,
|
|
imageSize.Height);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (imagePosition == eLayoutPosition.Default || imagePosition == eLayoutPosition.Right)
|
|
{
|
|
if (textAlignment == eTextAlignment.Right)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Y + imageTextSpacing, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Y += imageTextSpacing;
|
|
actualImageBounds.Height -= imageTextSpacing;
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
actualTextBounds.Y = actualImageBounds.Bottom - 10;
|
|
actualTextBounds.Height = (_CaptionBounds.Bottom - actualTextBounds.Y)+4;
|
|
}
|
|
}
|
|
else if (textAlignment == eTextAlignment.Center)
|
|
{
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Y + CaptionEdgeDistance, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Y = actualImageBounds.Bottom;
|
|
actualTextBounds.Height = _CaptionBounds.Bottom - actualTextBounds.Y;
|
|
}
|
|
else
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Y + actualTextBounds.Height / 2 - (realTextSize.Width / 2 + imageTextSpacing + imageSize.Height), imageSize.Width, imageSize.Height);
|
|
}
|
|
else
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Bottom - (realTextSize.Width + imageTextSpacing + imageSize.Height), imageSize.Width, imageSize.Height);
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
actualImageBounds.Y += CaptionEdgeDistance;
|
|
}
|
|
}
|
|
else if (imagePosition == eLayoutPosition.Left)
|
|
{
|
|
if (textAlignment == eTextAlignment.Right)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Y + imageTextSpacing, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Y += imageTextSpacing;
|
|
actualImageBounds.Height -= imageTextSpacing;
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Bottom - (CaptionEdgeDistance+imageSize.Width), imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Height = actualImageBounds.Y - _CaptionBounds.Y;
|
|
}
|
|
}
|
|
else if (textAlignment == eTextAlignment.Center)
|
|
{
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Bottom - (imageSize.Height + CaptionEdgeDistance), imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Height -= realTextSize.Height;
|
|
}
|
|
else
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Y + actualTextBounds.Height / 2 + realTextSize.Width / 2 + this.ImageTextSpacing, imageSize.Width, imageSize.Height);
|
|
}
|
|
else
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + (actualTextBounds.Width - imageSize.Width) / 2, actualTextBounds.Bottom - imageSize.Height - imageTextSpacing, imageSize.Width, imageSize.Height);
|
|
actualTextBounds.Height -= actualImageBounds.Height + imageTextSpacing;
|
|
}
|
|
}
|
|
else if (imagePosition == eLayoutPosition.Top)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.X + imageTextSpacing,
|
|
actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2,
|
|
imageSize.Width,
|
|
imageSize.Height);
|
|
actualTextBounds.X += imageSize.Width + imageTextSpacing;
|
|
actualTextBounds.Width -= imageSize.Width + imageTextSpacing;
|
|
}
|
|
else if (imagePosition == eLayoutPosition.Bottom)
|
|
{
|
|
actualImageBounds = new Rectangle(actualTextBounds.Right - (imageSize.Width + imageTextSpacing),
|
|
actualTextBounds.Y + (actualTextBounds.Height - imageSize.Height) / 2,
|
|
imageSize.Width,
|
|
imageSize.Height);
|
|
actualTextBounds.Width -= imageSize.Width + imageTextSpacing;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.ActualTextBounds = actualTextBounds;
|
|
this.ActualImageBounds = actualImageBounds;
|
|
}
|
|
private Rectangle _CaptionBounds = Rectangle.Empty;
|
|
protected virtual Rectangle LayoutGroupCaption(LayoutContext context, Rectangle r)
|
|
{
|
|
_CaptionBounds = Rectangle.Empty;
|
|
if (string.IsNullOrEmpty(this.Text) || !this.TextVisible)
|
|
return r;
|
|
|
|
eLayoutPosition textPosition = this.TextPosition;
|
|
|
|
Size textSize = new Size();
|
|
if (_CaptionHeight > 0)
|
|
{
|
|
textSize.Width = r.Width;
|
|
textSize.Height = _CaptionHeight;
|
|
}
|
|
else
|
|
{
|
|
textSize = MeasureText(context);
|
|
if (IsImageVisible)
|
|
{
|
|
Size imageSize = GetImageSize();
|
|
textSize.Height = Math.Max(textSize.Height, imageSize.Height);
|
|
}
|
|
}
|
|
|
|
if (textPosition == eLayoutPosition.Top)
|
|
{
|
|
_CaptionBounds = new Rectangle(r.X, r.Y, r.Width, textSize.Height);
|
|
r.Y += _CaptionBounds.Height;
|
|
r.Height -= _CaptionBounds.Height;
|
|
}
|
|
else if (textPosition == eLayoutPosition.Bottom)
|
|
{
|
|
_CaptionBounds = new Rectangle(r.X, r.Bottom - textSize.Height, r.Width, textSize.Height);
|
|
r.Height -= _CaptionBounds.Height;
|
|
}
|
|
else if (textPosition == eLayoutPosition.Left || textPosition == eLayoutPosition.Default) // Text rotated to the side
|
|
{
|
|
_CaptionBounds = new Rectangle(r.X, r.Y, textSize.Height, r.Height);
|
|
r.X += _CaptionBounds.Width;
|
|
r.Width -= _CaptionBounds.Width;
|
|
}
|
|
else if (textPosition == eLayoutPosition.Right) // Text rotated to the side
|
|
{
|
|
_CaptionBounds = new Rectangle(r.Right - textSize.Height, r.Y, textSize.Height, r.Height);
|
|
r.Width -= _CaptionBounds.Width;
|
|
}
|
|
|
|
if (Appearance == eGroupAppearance.GroupPanel)
|
|
_CaptionBounds = GetGroupPanelCaptionBounds(_CaptionBounds);
|
|
|
|
UpdateTextBounds();
|
|
|
|
//if (Appearance == eGroupAppearance.GroupPanel && !ActualImageBounds.IsEmpty)
|
|
//{
|
|
// if (textPosition == eLayoutPosition.Top || textPosition == eLayoutPosition.Bottom || textPosition == eLayoutPosition.Default)
|
|
// {
|
|
// if (TextAlignment != eTextAlignment.Center)
|
|
// ActualImageBounds = new Rectangle(ActualImageBounds.X + CaptionEdgeDistance, ActualImageBounds.Y, ActualImageBounds.Width, ActualImageBounds.Height);
|
|
// }
|
|
// else
|
|
// {
|
|
// ActualImageBounds = new Rectangle(ActualImageBounds.X, ActualImageBounds.Y + CaptionEdgeDistance, ActualImageBounds.Width, ActualImageBounds.Height);
|
|
// }
|
|
//}
|
|
|
|
return r;
|
|
}
|
|
|
|
private LayoutItemCollection _Items = null;
|
|
/// <summary>
|
|
/// Gets the collection of layout items objects assigned to the current group.
|
|
/// </summary>
|
|
[Browsable(true), Category("Items"), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public LayoutItemCollection Items
|
|
{
|
|
get
|
|
{
|
|
return _Items;
|
|
}
|
|
}
|
|
|
|
//private eLayoutType _LayoutType = eLayoutType.Horizontal;
|
|
///// <summary>
|
|
///// Indicates layout type performed by the group.
|
|
///// </summary>
|
|
//[DefaultValue(eLayoutType.Horizontal), Category("Appearance"), Description("Indicates layout type performed by the group.")]
|
|
//public eLayoutType LayoutType
|
|
//{
|
|
// get { return _LayoutType; }
|
|
// set
|
|
// {
|
|
// if (value != _LayoutType)
|
|
// {
|
|
// eLayoutType oldValue = _LayoutType;
|
|
// _LayoutType = value;
|
|
// OnLayoutTypeChanged(oldValue, value);
|
|
// }
|
|
// }
|
|
//}
|
|
///// <summary>
|
|
///// Called when LayoutType property has changed.
|
|
///// </summary>
|
|
///// <param name="oldValue">Old property value</param>
|
|
///// <param name="newValue">New property value</param>
|
|
//protected virtual void OnLayoutTypeChanged(eLayoutType oldValue, eLayoutType newValue)
|
|
//{
|
|
// OnPropertyChanged(new PropertyChangedEventArgs("LayoutType"));
|
|
//}
|
|
internal override void UpdateScrollBounds(int xScroll, int yScroll, bool moveControls)
|
|
{
|
|
base.UpdateScrollBounds(xScroll, yScroll, moveControls);
|
|
_ActualBounds.Offset(xScroll, yScroll);
|
|
_CaptionBounds.Offset(xScroll, yScroll);
|
|
_ContentBounds.Offset(xScroll, yScroll);
|
|
foreach (LayoutItemBase item in this.Items)
|
|
{
|
|
item.UpdateScrollBounds(xScroll, yScroll, moveControls);
|
|
}
|
|
}
|
|
|
|
private bool _IsRootGroup = false;
|
|
/// <summary>
|
|
/// Indicates whether group is used as a root group in LayoutControl.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public bool IsRootGroup
|
|
{
|
|
get { return _IsRootGroup; }
|
|
internal set
|
|
{
|
|
if (_IsRootGroup == value)
|
|
return;
|
|
_IsRootGroup = value;
|
|
OnPropertyChanged(new PropertyChangedEventArgs("IsRootGroup"));
|
|
}
|
|
}
|
|
|
|
private SimpleStyle _CaptionStyle;
|
|
/// <summary>
|
|
/// Gets the style for the group caption represented by Text property.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Gets the style for the group caption represented by Text property"), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public SimpleStyle CaptionStyle
|
|
{
|
|
get { return _CaptionStyle; }
|
|
}
|
|
private void CaptionStylePropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
this.Invalidate();
|
|
//throw new Exception("The method or operation is not implemented.");
|
|
}
|
|
/// <summary>
|
|
/// Returns whether item is contained as child item by this item or one of its children.
|
|
/// </summary>
|
|
/// <param name="value">Item to check.</param>
|
|
/// <returns>true if item is contained otherwise false</returns>
|
|
public override bool IsChildItem(LayoutItemBase value)
|
|
{
|
|
foreach (LayoutItemBase item in _Items)
|
|
{
|
|
if (item == value) return true;
|
|
if (item.IsChildItem(value)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private eGroupAppearance _Appearance = eGroupAppearance.None;
|
|
/// <summary>
|
|
/// Indicates the built-in appearance of group. When set group is painted using one of the pre-defined styles.
|
|
/// When set to None, default value, you can use Style and CaptionStyle properties to change the group appearance.
|
|
/// </summary>
|
|
[DefaultValue(eGroupAppearance.None), Category("Appearance"), Description("Indicates the built-in appearance of group.")]
|
|
public eGroupAppearance Appearance
|
|
{
|
|
get { return _Appearance; }
|
|
set
|
|
{
|
|
if (value != _Appearance)
|
|
{
|
|
eGroupAppearance oldValue = _Appearance;
|
|
_Appearance = value;
|
|
OnAppearanceChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Called when Appearance property has changed.
|
|
/// </summary>
|
|
/// <param name="oldValue">Old property value</param>
|
|
/// <param name="newValue">New property value</param>
|
|
protected virtual void OnAppearanceChanged(eGroupAppearance oldValue, eGroupAppearance newValue)
|
|
{
|
|
this.Invalidate();
|
|
this.InvalidateLayout();
|
|
OnPropertyChanged(new PropertyChangedEventArgs("Appearance"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scales item in response to the scaling of the LayoutControl. Should never be called directly.
|
|
/// </summary>
|
|
/// <param name="factor"></param>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public override void ScaleItem(SizeF factor)
|
|
{
|
|
base.ScaleItem(factor);
|
|
if (_CaptionHeight > 0)
|
|
{
|
|
bool widthChanged = factor.Width != 1f;
|
|
bool heightChanged = factor.Height != 1f;
|
|
|
|
if (heightChanged)
|
|
{
|
|
_CaptionHeight = (int)(_CaptionHeight * factor.Height);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether this item text-size is shared with other items inside of its parent group.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public override bool IsTextSizeShared
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets whether this item's text-baseline is shared with other items inside of its parent group.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public override bool IsTextBaselineShared
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected override void OnVisibleChanged(bool oldValue, bool newValue)
|
|
{
|
|
foreach (LayoutItemBase item in _Items)
|
|
{
|
|
item.Visible = newValue;
|
|
}
|
|
base.OnVisibleChanged(oldValue, newValue);
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the layout type.
|
|
/// </summary>
|
|
public enum eLayoutType
|
|
{
|
|
/// <summary>
|
|
/// Horizontal layout type where items are first ordered from left to right then wrapped to next line.
|
|
/// </summary>
|
|
Horizontal,
|
|
/// <summary>
|
|
/// Vertical layout type where items are ordered first from top to bottom then wrapped onto the next column.
|
|
/// </summary>
|
|
Vertical
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies built-in appearance for the LayoutGroup.
|
|
/// </summary>
|
|
public enum eGroupAppearance
|
|
{
|
|
/// <summary>
|
|
/// Group does not use any built-in appearance.
|
|
/// </summary>
|
|
None,
|
|
/// <summary>
|
|
/// Group is rendered like standard DotNetBar Panel control.
|
|
/// </summary>
|
|
Panel,
|
|
/// <summary>
|
|
/// Group is rendered like GroupPanel control.
|
|
/// </summary>
|
|
GroupPanel
|
|
}
|
|
}
|