/// <include file='doc\ToolStripControlHost.uex' path='docs/doc[@for="ToolStripControlHost.OnBoundsChanged"]/*' />
/// <devdoc>
/// Called when the items bounds are changed. Here, we update the Control's bounds.
/// </devdoc>
protected override void OnBoundsChanged()
{
if (control != null)
{
SuspendSizeSync();
IArrangedElement element = control as IArrangedElement;
if (element == null)
{
Debug.Fail("why are we here? control should not be null");
return;
}
Size size = LayoutUtils.DeflateRect(this.Bounds, this.Padding).Size;
Rectangle bounds = LayoutUtils.Align(size, this.Bounds, ControlAlign);
// use BoundsSpecified.None so we dont deal w/specified bounds - this way we can tell what someone has set the size to.
element.SetBounds(bounds, BoundsSpecified.None);
// sometimes a control can ignore the size passed in, use the adjustment
// to re-align.
if (bounds != control.Bounds)
{
bounds = LayoutUtils.Align(control.Size, this.Bounds, ControlAlign);
element.SetBounds(bounds, BoundsSpecified.None);
}
ResumeSizeSync();
}
}
private Rectangle GetTextRectangle(Size szText)
{
Size sz = new Size(szText.Width + _TextPadding * 2, szText.Height + _TextPadding * 2);
Rectangle ret = LayoutUtils.Align(sz, GetTextContainerRectangle(), _TextAlign);
ret.X += _TextPadding;
ret.Y += _TextPadding;
return(ret);
}
private void DrawTextNormal(Size szText, Rectangle rect, PaintEventArgs e)
{
Rectangle rectText = LayoutUtils.Align(szText + new Size(_TextPadding * 2, _TextPadding * 2), rect, _TextAlign);
rectText.X += _TextPadding;
rectText.Y += _TextPadding;
using (SolidBrush brush = new SolidBrush(this.ForeColor)) {
e.Graphics.DrawString(_Text, this.Font, brush, rectText.Location);
}
}
protected virtual void PaintImage(Graphics g, RectangleF rect)
{
if (this.image == null || rect.Size == (SizeF)Size.Empty)
{
return;
}
ContentAlignment imageAlignment = this.ImageAlignment;
switch (this.ImageLayout)
{
case ImageLayout.None:
Graphics graphics = g;
RectangleF rectangleF = LayoutUtils.Align(new SizeF(Math.Min(rect.Width, (float)this.image.Size.Width), Math.Min(rect.Height, (float)this.image.Size.Height)), rect, imageAlignment);
graphics.DrawImageUnscaledAndClipped(this.image, new Rectangle(new Point((int)rectangleF.Location.X, (int)rectangleF.Location.Y), rectangleF.Size.ToSize()));
break;
case ImageLayout.Tile:
for (float x = rect.X; (double)x <= (double)rect.Height - (double)this.image.Height; x += (float)this.image.Height)
{
for (float y = rect.Y; (double)y < (double)rect.Width - (double)this.image.Width; y += (float)this.image.Width)
{
g.DrawImage(this.image, (int)y, (int)x);
}
}
break;
case ImageLayout.Center:
PointF pointF = new PointF(Math.Max(0.0f, rect.X + Math.Max(0.0f, (float)(((double)rect.Width - (double)this.image.Width) / 2.0))), Math.Max(0.0f, rect.Y + Math.Max(0.0f, (float)(((double)rect.Height - (double)this.image.Height) / 2.0))));
SizeF sizeF = new SizeF(Math.Min(rect.Width, (float)this.image.Size.Width), Math.Min(rect.Height, (float)this.image.Size.Height));
g.DrawImageUnscaledAndClipped(this.image, new Rectangle(new Point((int)pointF.X, (int)pointF.Y), sizeF.ToSize()));
break;
case ImageLayout.Stretch:
g.DrawImage(this.image, rect.X, rect.Y, rect.Width, rect.Height);
break;
case ImageLayout.Zoom:
if (this.image.Width == 0 || this.image.Height == 0)
{
break;
}
float num = Math.Min(rect.Width / (float)this.image.Width, rect.Height / (float)this.image.Height);
if ((double)num <= 0.0)
{
break;
}
int width = (int)Math.Round((double)this.image.Width * (double)num);
int height = (int)Math.Round((double)this.image.Height * (double)num);
int x1 = (int)rect.X + ((int)rect.Width - width) / 2;
int y1 = (int)rect.Y + ((int)rect.Height - height) / 2;
g.DrawImage(this.image, x1, y1, width, height);
break;
}
}
protected override SizeF ArrangeOverride(SizeF finalSize)
{
RectangleF clientRect = GetClientRectangle(finalSize);
RadDropDownMenuLayout menuLayout = this.Parent as RadDropDownMenuLayout;
float leftColumn = 0;
float rightColumn = 0;
if (menuLayout != null)
{
leftColumn = menuLayout.LeftColumnMaxPadding + menuLayout.LeftColumnWidth;
rightColumn = menuLayout.LeftColumnMaxPadding + menuLayout.RightColumnWidth;
}
foreach (RadElement element in this.Children)
{
if (element == this.imagePrimitive)
{
float leftColumnWidth = menuLayout != null ? menuLayout.LeftColumnWidth : 0;
RectangleF finalRect = new RectangleF(clientRect.Left, clientRect.Top, leftColumnWidth, clientRect.Height);
if (this.RightToLeft)
{
finalRect = LayoutUtils.RTLTranslateNonRelative(finalRect, clientRect);
}
element.Arrange(finalRect);
}
else if (element == this.textPrimitive)
{
RectangleF cr = new RectangleF(clientRect.Left + leftColumn, clientRect.Top, clientRect.Width - rightColumn, clientRect.Height);
RectangleF r = LayoutUtils.Align(this.textPrimitive.DesiredSize, cr, this.textPrimitive.Alignment);
if (this.RightToLeft)
{
r = LayoutUtils.RTLTranslateNonRelative(r, clientRect);
}
element.Arrange(r);
}
else if (element.FitToSizeMode == RadFitToSizeMode.FitToParentBounds)
{
element.Arrange(new RectangleF(Point.Empty, finalSize));
}
else if (element.FitToSizeMode == RadFitToSizeMode.FitToParentPadding)
{
element.Arrange(new RectangleF(this.BorderThickness.Left, this.BorderThickness.Top, finalSize.Width - this.BorderThickness.Horizontal, finalSize.Height - this.BorderThickness.Vertical));
}
else
{
element.Arrange(clientRect);
}
}
return(finalSize);
}
protected override SizeF ArrangeOverride(SizeF finalSize)
{
RectangleF clientRectangle = this.GetClientRectangle(finalSize);
RadDropDownMenuLayout parent = this.Parent as RadDropDownMenuLayout;
float num1 = 0.0f;
float num2 = 0.0f;
if (parent != null)
{
num1 = parent.LeftColumnMaxPadding + parent.LeftColumnWidth;
num2 = parent.LeftColumnMaxPadding + parent.RightColumnWidth;
}
foreach (RadElement child in this.Children)
{
if (child == this.imagePrimitive)
{
float width = parent != null ? parent.LeftColumnWidth : 0.0f;
RectangleF rectangleF = new RectangleF(clientRectangle.Left, clientRectangle.Top, width, clientRectangle.Height);
if (this.RightToLeft)
{
rectangleF = LayoutUtils.RTLTranslateNonRelative(rectangleF, clientRectangle);
}
child.Arrange(rectangleF);
}
else if (child == this.textPrimitive)
{
RectangleF rectangleF = LayoutUtils.Align(this.textPrimitive.DesiredSize, new RectangleF(clientRectangle.Left + num1, clientRectangle.Top, clientRectangle.Width - num2, clientRectangle.Height), this.textPrimitive.Alignment);
if (this.RightToLeft)
{
rectangleF = LayoutUtils.RTLTranslateNonRelative(rectangleF, clientRectangle);
}
child.Arrange(rectangleF);
}
else if (child.FitToSizeMode == RadFitToSizeMode.FitToParentBounds)
{
child.Arrange(new RectangleF((PointF)Point.Empty, finalSize));
}
else if (child.FitToSizeMode == RadFitToSizeMode.FitToParentPadding)
{
child.Arrange(new RectangleF((float)this.BorderThickness.Left, (float)this.BorderThickness.Top, finalSize.Width - (float)this.BorderThickness.Horizontal, finalSize.Height - (float)this.BorderThickness.Vertical));
}
else
{
child.Arrange(clientRectangle);
}
}
return(finalSize);
}
protected override void OnBoundsChanged()
{
if (this.control != null)
{
this.SuspendSizeSync();
IArrangedElement control = this.control;
if (control != null)
{
Rectangle bounds = LayoutUtils.Align(LayoutUtils.DeflateRect(this.Bounds, this.Padding).Size, this.Bounds, this.ControlAlign);
control.SetBounds(bounds, BoundsSpecified.None);
if (bounds != this.control.Bounds)
{
bounds = LayoutUtils.Align(this.control.Size, this.Bounds, this.ControlAlign);
control.SetBounds(bounds, BoundsSpecified.None);
}
this.ResumeSizeSync();
}
}
}
[SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters")] // using "\t" to figure out the width of tab
private void CalculateInternalLayoutMetrics()
{
Size maxTextSize = Size.Empty;
Size maxImageSize = Size.Empty;
Size maxCheckSize = scaledDefaultImageSize;
Size maxArrowSize = Size.Empty;
Size maxNonMenuItemSize = Size.Empty;
// determine Text Metrics
for (int i = 0; i < Items.Count; i++)
{
ToolStripItem item = Items[i];
ToolStripMenuItem menuItem = item as ToolStripMenuItem;
if (menuItem != null)
{
Size menuItemTextSize = menuItem.GetTextSize();
if (menuItem.ShowShortcutKeys)
{
Size shortcutTextSize = menuItem.GetShortcutTextSize();
if (tabWidth == -1)
{
tabWidth = TextRenderer.MeasureText("\t", this.Font).Width;
}
menuItemTextSize.Width += tabWidth + shortcutTextSize.Width;
menuItemTextSize.Height = Math.Max(menuItemTextSize.Height, shortcutTextSize.Height);
}
// we truly only care about the maximum size we find.
maxTextSize.Width = Math.Max(maxTextSize.Width, menuItemTextSize.Width);
maxTextSize.Height = Math.Max(maxTextSize.Height, menuItemTextSize.Height);
// determine Image Metrics
Size imageSize = Size.Empty;
if (menuItem.Image != null)
{
imageSize = (menuItem.ImageScaling == ToolStripItemImageScaling.SizeToFit) ? ImageScalingSize : menuItem.Image.Size;
}
maxImageSize.Width = Math.Max(maxImageSize.Width, imageSize.Width);
maxImageSize.Height = Math.Max(maxImageSize.Height, imageSize.Height);
if (menuItem.CheckedImage != null)
{
Size checkedImageSize = menuItem.CheckedImage.Size;
maxCheckSize.Width = Math.Max(checkedImageSize.Width, maxCheckSize.Width);
maxCheckSize.Height = Math.Max(checkedImageSize.Height, maxCheckSize.Height);
}
}
else if (!(item is ToolStripSeparator))
{
maxNonMenuItemSize.Height = Math.Max(item.Bounds.Height, maxNonMenuItemSize.Height);
maxNonMenuItemSize.Width = Math.Max(item.Bounds.Width, maxNonMenuItemSize.Width);
}
}
this.maxItemSize.Height = Math.Max(maxTextSize.Height + scaledTextPadding.Vertical, Math.Max(maxCheckSize.Height + scaledCheckPadding.Vertical, maxArrowSize.Height + scaledArrowPadding.Vertical));
if (ShowImageMargin)
{
// only add in the image into the calculation if we're going to render it.
this.maxItemSize.Height = Math.Max(maxImageSize.Height + scaledImagePadding.Vertical, maxItemSize.Height);
}
bool useDefaultCheckMarginWidth = (ShowCheckMargin && (maxCheckSize.Width == 0));
bool useDefaultImageMarginWidth = (ShowImageMargin && (maxImageSize.Width == 0));
// Always save space for an arrow
maxArrowSize = new Size(scaledArrowSize, maxItemSize.Height);
maxTextSize.Height = maxItemSize.Height - scaledTextPadding.Vertical;
maxImageSize.Height = maxItemSize.Height - scaledImagePadding.Vertical;
maxCheckSize.Height = maxItemSize.Height - scaledCheckPadding.Vertical;
// fixup if there are non-menu items that are larger than our normal menu items
maxTextSize.Width = Math.Max(maxTextSize.Width, maxNonMenuItemSize.Width);
Point nextPoint = Point.Empty;
int checkAndImageMarginWidth = 0;
int extraImageWidth = Math.Max(0, maxImageSize.Width - scaledDefaultImageSize.Width);
if (ShowCheckMargin && ShowImageMargin)
{
// double column - check margin then image margin
// default to 46px - grow if necessary.
checkAndImageMarginWidth = scaledDefaultImageAndCheckMarginWidth;
// add in the extra space for the image... since the check size is locked down to 16x16.
checkAndImageMarginWidth += extraImageWidth;
// align the checkmark
nextPoint = new Point(scaledCheckPadding.Left, scaledCheckPadding.Top);
checkRectangle = LayoutUtils.Align(maxCheckSize, new Rectangle(nextPoint.X, nextPoint.Y, maxCheckSize.Width, maxItemSize.Height), ContentAlignment.MiddleCenter);
// align the image rectangle
nextPoint.X = checkRectangle.Right + scaledCheckPadding.Right + scaledImagePadding.Left;
nextPoint.Y = scaledImagePadding.Top;
imageRectangle = LayoutUtils.Align(maxImageSize, new Rectangle(nextPoint.X, nextPoint.Y, maxImageSize.Width, maxItemSize.Height), ContentAlignment.MiddleCenter);
}
else if (ShowCheckMargin)
{
// no images should be shown in a ShowCheckMargin only scenario.
// default to 24px - grow if necessary.
checkAndImageMarginWidth = scaledDefaultImageMarginWidth;
// align the checkmark
nextPoint = new Point(1, scaledCheckPadding.Top);
// nextPoint = new Point(scaledCheckPadding.Left, scaledCheckPadding.Top);
checkRectangle = LayoutUtils.Align(maxCheckSize, new Rectangle(nextPoint.X, nextPoint.Y, checkAndImageMarginWidth, maxItemSize.Height), ContentAlignment.MiddleCenter);
imageRectangle = Rectangle.Empty;
}
else if (ShowImageMargin)
{
// checks and images render in the same area.
// default to 24px - grow if necessary.
checkAndImageMarginWidth = scaledDefaultImageMarginWidth;
// add in the extra space for the image... since the check size is locked down to 16x16.
checkAndImageMarginWidth += extraImageWidth;
// NOTE due to the Padding property, we're going to have to recalc the vertical alignment in ToolStripMenuItemInternalLayout.
// Dont fuss here over the Y, X is what's critical.
// check and image rect are the same - take the max of the image size and the check size and align
nextPoint = new Point(1, scaledCheckPadding.Top);
checkRectangle = LayoutUtils.Align(LayoutUtils.UnionSizes(maxCheckSize, maxImageSize), new Rectangle(nextPoint.X, nextPoint.Y, checkAndImageMarginWidth - 1, maxItemSize.Height), ContentAlignment.MiddleCenter);
// align the image
imageRectangle = checkRectangle;
}
else
{
checkAndImageMarginWidth = 0;
}
nextPoint.X = checkAndImageMarginWidth + 1;
// calculate space for image
// if we didnt have a check - make sure to ignore check padding
// consider: should we constrain to a reasonable width?
//imageMarginBounds = new Rectangle(0, 0, Math.Max(imageMarginWidth,DefaultImageMarginWidth), this.Height);
imageMarginBounds = new Rectangle(0, 0, checkAndImageMarginWidth, this.Height);
// calculate space for shortcut and text
nextPoint.X = imageMarginBounds.Right + scaledTextPadding.Left;
nextPoint.Y = scaledTextPadding.Top;
textRectangle = new Rectangle(nextPoint, maxTextSize);
// calculate space for arrow
nextPoint.X = textRectangle.Right + scaledTextPadding.Right + scaledArrowPadding.Left;
nextPoint.Y = scaledArrowPadding.Top;
arrowRectangle = new Rectangle(nextPoint, maxArrowSize);
// calculate space required for all of these pieces
this.maxItemSize.Width = (arrowRectangle.Right + scaledArrowPadding.Right) - imageMarginBounds.Left;
this.Padding = DefaultPadding;
int trimPadding = imageMarginBounds.Width;
if (RightToLeft == RightToLeft.Yes)
{
// reverse the rectangle alignment in RightToLeft.Yes
trimPadding += scaledTextPadding.Right;
int width = maxItemSize.Width;
checkRectangle.X = width - checkRectangle.Right;
imageRectangle.X = width - imageRectangle.Right;
textRectangle.X = width - textRectangle.Right;
arrowRectangle.X = width - arrowRectangle.Right;
imageMarginBounds.X = width - imageMarginBounds.Right;
}
else
{
trimPadding += scaledTextPadding.Left;
}
// We need to make sure that the text really appears vertically centered - this can be a problem in
// systems which force the text rectangle to be odd.
// force this to be an even height.
this.maxItemSize.Height += this.maxItemSize.Height % 2;
textRectangle.Y = LayoutUtils.VAlign(textRectangle.Size, new Rectangle(Point.Empty, maxItemSize), ContentAlignment.MiddleCenter).Y;
textRectangle.Y += (textRectangle.Height % 2); // if the height is odd, push down by one px
state[stateMaxItemSizeValid] = true;
this.PaddingToTrim = trimPadding;
}
public virtual void PaintImage(
IGraphics graphics,
Image image,
RectangleF rect,
ImageLayout imageLayout,
ContentAlignment imageAlignment,
float opacity,
bool rtl)
{
SizeF size = rect.Size;
if (image == null || size == SizeF.Empty)
{
return;
}
if (rtl)
{
imageAlignment = TelerikAlignHelper.RtlTranslateContent(imageAlignment);
}
switch (imageLayout)
{
case ImageLayout.None:
RectangleF rectangleF = LayoutUtils.Align(new SizeF(Math.Min(rect.Width, (float)image.Size.Width), Math.Min(rect.Height, (float)image.Size.Height)), rect, imageAlignment);
((Graphics)graphics.UnderlayGraphics).DrawImageUnscaledAndClipped(image, new Rectangle(new Point((int)rectangleF.Location.X, (int)rectangleF.Location.Y), rectangleF.Size.ToSize()));
break;
case ImageLayout.Tile:
float num1 = rect.Y - (float)image.Height;
do
{
num1 += (float)image.Height;
float num2 = rect.X - (float)image.Width;
do
{
num2 += (float)image.Width;
if ((double)opacity == 1.0)
{
graphics.DrawBitmap(image, (int)num2, (int)num1);
}
else
{
graphics.DrawBitmap(image, (int)num2, (int)num1, (double)opacity);
}
}while ((double)num2 < (double)rect.X + (double)rect.Width - (double)image.Width);
}while ((double)num1 <= (double)rect.Y + (double)rect.Height - (double)image.Height);
break;
case ImageLayout.Center:
PointF pointF = new PointF(Math.Max(0.0f, rect.X + Math.Max(0.0f, (float)(((double)size.Width - (double)image.Width) / 2.0))), Math.Max(0.0f, rect.Y + Math.Max(0.0f, (float)(((double)size.Height - (double)image.Height) / 2.0))));
pointF.X = Math.Min(pointF.X, rect.Right);
pointF.Y = Math.Min(pointF.Y, rect.Bottom);
SizeF sizeF = new SizeF(Math.Min(rect.Width, (float)image.Size.Width), Math.Min(rect.Height, (float)image.Size.Height));
if ((double)opacity == 1.0)
{
((Graphics)graphics.UnderlayGraphics).DrawImageUnscaledAndClipped(image, new Rectangle(new Point((int)pointF.X, (int)pointF.Y), sizeF.ToSize()));
break;
}
graphics.DrawBitmap(image, (int)pointF.X, (int)pointF.Y, (double)opacity);
break;
case ImageLayout.Stretch:
if ((double)opacity == 1.0)
{
graphics.DrawBitmap(image, (int)rect.X, (int)rect.Y, (int)size.Width, (int)size.Height);
break;
}
graphics.DrawBitmap(image, 0, 0, (int)size.Width, (int)size.Height, (double)opacity);
break;
case ImageLayout.Zoom:
if (image.Width == 0 || image.Height == 0)
{
break;
}
float num3 = Math.Min(size.Width / (float)image.Width, size.Height / (float)image.Height);
if ((double)num3 <= 0.0)
{
break;
}
int width = (int)Math.Round((double)image.Width * (double)num3);
int height = (int)Math.Round((double)image.Height * (double)num3);
int x = (int)rect.X + (int)(((double)size.Width - (double)width) / 2.0);
int y = (int)rect.Y + (int)(((double)size.Height - (double)height) / 2.0);
if ((double)opacity == 1.0)
{
graphics.DrawBitmap(image, x, y, width, height);
break;
}
graphics.DrawBitmap(image, x, y, width, height, (double)opacity);
break;
}
}
protected override void OnPaint(PaintEventArgs e)
{
if (bsState == FlatButtonState.Down)
{
e.Graphics.Clear(_BackColorDown.Lerp(_BackShadeColor, _BackShadeRatio));
}
else if (bsState == FlatButtonState.Over)
{
e.Graphics.Clear(_BackColorOver.Lerp(_BackShadeColor, _BackShadeRatio));
}
else
{
e.Graphics.Clear(this.BackColor.Lerp(_BackShadeColor, _BackShadeRatio));
}
Rectangle rect = new Rectangle(0, 0, this.Width, this.Height);
Size szText = e.Graphics.MeasureString(_Text, this.Font).ToSize();
if (_Image != null)
{
Rectangle rectImage = LayoutUtils.Align(_Image.Size + new Size(_ImagePadding * 2, _ImagePadding * 2), rect, _ImageAlign);
rectImage.X += _ImagePadding;
rectImage.Y += _ImagePadding;
e.Graphics.DrawImage(_Image, new Rectangle(rectImage.Location, _Image.Size));
if (_TextImageRelation == FlatTextImageRelation.After)
{
using (SolidBrush brush = new SolidBrush(this.ForeColor)) {
e.Graphics.DrawString(_Text, this.Font, brush, new Point(
rectImage.X + _Image.Width + _ImagePadding,
rectImage.Y + _Image.Height / 2 - szText.Height / 2
));
}
}
else if (_TextImageRelation == FlatTextImageRelation.Before)
{
using (SolidBrush brush = new SolidBrush(this.ForeColor)) {
e.Graphics.DrawString(_Text, this.Font, brush, new Point(
rectImage.X - szText.Width - _ImagePadding,
rectImage.Y + _Image.Height / 2 - szText.Height / 2
));
}
}
else
{
DrawTextNormal(szText, rect, e);
}
}
else
{
DrawTextNormal(szText, rect, e);
}
if (_HasBorder)
{
using (Pen pen = new Pen(_BorderColor)) {
e.Graphics.DrawRectangle(pen, new Rectangle(0, 0, this.Width - 1, this.Height - 1));
}
}
base.OnPaint(e);
}
protected override SizeF ArrangeOverride(SizeF arrangeSize)
{
RadCommandBarBaseItemCollection children = this.items;
int count = children.Count;
// Get desired children size if EqualChildrenHeight or EqualChildrenWidth is used
// ********************************************************* //
SizeF maxDesiredChildrenSize = SizeF.Empty;
bool equalChildrenHeight = false; // this.EqualChildrenHeight;
bool equalChildrenWidth = false; // this.EqualChildrenWidth;
if (equalChildrenHeight || equalChildrenWidth)
{
for (int i = 0; i < count; i++)
{
RadElement element = children[i];
if (equalChildrenHeight)
{
maxDesiredChildrenSize.Height = Math.Max(element.DesiredSize.Height, maxDesiredChildrenSize.Height);
}
if (equalChildrenWidth)
{
maxDesiredChildrenSize.Width = Math.Max(element.DesiredSize.Width, maxDesiredChildrenSize.Width);
}
}
}
// Parameters
// ********************************************************* //
bool isHorizontal = this.Orientation == Orientation.Horizontal;
bool isRightToLeft = this.RightToLeft;
float length = 0;
RectangleF finalRect = new RectangleF(PointF.Empty, arrangeSize);
if (isHorizontal && isRightToLeft)
{
finalRect.X = arrangeSize.Width;
}
float stretchedItemArrangedSpace = ArrangeStretchedItems(arrangeSize);
// Main loop that does the actual arrangement of the children
// ********************************************************* //
for (int i = 0; i < count; i++)
{
RadElement element = children[i];
SizeF childArea = element.DesiredSize;
if (element.Visibility == ElementVisibility.Collapsed)
{
element.Arrange(new RectangleF(PointF.Empty, childArea));
continue;
}
// ** 1. Calculate the ChildArea
if (equalChildrenHeight)
{
if (isHorizontal)
{
childArea.Height = Math.Max(arrangeSize.Height, maxDesiredChildrenSize.Height);
}
else
{
childArea.Height = maxDesiredChildrenSize.Height;
}
}
if (equalChildrenWidth)
{
if (isHorizontal)
{
childArea.Width = maxDesiredChildrenSize.Width;
}
else
{
childArea.Width = Math.Max(arrangeSize.Width, maxDesiredChildrenSize.Width);
}
}
if (element.StretchHorizontally && isHorizontal && !float.IsInfinity(stretchedItemArrangedSpace))
{
childArea.Width = stretchedItemArrangedSpace;
}
if (element.StretchVertically && !isHorizontal && !float.IsInfinity(stretchedItemArrangedSpace))
{
childArea.Height = stretchedItemArrangedSpace;
}
// ** 2. Calculate the location and size (finalRect) that will be passed to the child's Arrange
if (isHorizontal)
{
if (isRightToLeft)
{
length = childArea.Width;
finalRect.X -= length;
}
else
{
finalRect.X += length;
length = childArea.Width;
}
finalRect.Width = length;
if (equalChildrenHeight)
{
SizeF arrangeArea = finalRect.Size;
finalRect.Height = childArea.Height;
// Compensate the alignment for EqualChildrenHeight because the basic logic will be bypassed
// by the size forcing
// Note that the vertical alignment is not affected by RightToLeft...
RectangleF alignedRect = LayoutUtils.Align(finalRect.Size, new RectangleF(PointF.Empty, arrangeArea), this.Alignment);
finalRect.Y += alignedRect.Y;
}
else
{
finalRect.Height = arrangeSize.Height;// Math.Max(arrangeSize.Height, childArea.Height);
}
}
else
{
finalRect.Y += length;
length = childArea.Height;
finalRect.Height = length;
if (equalChildrenWidth)
{
SizeF arrangeArea = finalRect.Size;
finalRect.Width = childArea.Width;
// Compensate the alignment for EqualChildrenHeight because the basic logic will be bypassed
// by the size forcing
// Note that the horizontal alignment is translated if RightToLeft is true.
ContentAlignment alignment = isRightToLeft ? TelerikAlignHelper.RtlTranslateContent(this.Alignment) : this.Alignment;
RectangleF alignedRect = LayoutUtils.Align(finalRect.Size, new RectangleF(PointF.Empty, arrangeArea), alignment);
finalRect.X += alignedRect.X;
}
else
{
finalRect.Width = arrangeSize.Width;// Math.Max(arrangeSize.Width, childArea.Width);
}
}
// ** 3. Arrange the child
if (element.StretchVertically && isHorizontal)
{
finalRect.Height = arrangeSize.Height;
}
else if (element.StretchHorizontally && !isHorizontal)
{
finalRect.Width = arrangeSize.Width;
}
element.Arrange(finalRect);
}
return(arrangeSize);
}
private void CalculateInternalLayoutMetrics()
{
Size empty = Size.Empty;
Size alignThis = Size.Empty;
Size defaultImageSize = ToolStripDropDownMenu.defaultImageSize;
Size size = Size.Empty;
Size size5 = Size.Empty;
for (int i = 0; i < this.Items.Count; i++)
{
ToolStripItem item = this.Items[i];
ToolStripMenuItem item2 = item as ToolStripMenuItem;
if (item2 != null)
{
Size textSize = item2.GetTextSize();
if (item2.ShowShortcutKeys)
{
Size shortcutTextSize = item2.GetShortcutTextSize();
if (this.tabWidth == -1)
{
this.tabWidth = TextRenderer.MeasureText("\t", this.Font).Width;
}
textSize.Width += this.tabWidth + shortcutTextSize.Width;
textSize.Height = Math.Max(textSize.Height, shortcutTextSize.Height);
}
empty.Width = Math.Max(empty.Width, textSize.Width);
empty.Height = Math.Max(empty.Height, textSize.Height);
Size size8 = Size.Empty;
if (item2.Image != null)
{
size8 = (item2.ImageScaling == ToolStripItemImageScaling.SizeToFit) ? base.ImageScalingSize : item2.Image.Size;
}
alignThis.Width = Math.Max(alignThis.Width, size8.Width);
alignThis.Height = Math.Max(alignThis.Height, size8.Height);
if (item2.CheckedImage != null)
{
Size size9 = item2.CheckedImage.Size;
defaultImageSize.Width = Math.Max(size9.Width, defaultImageSize.Width);
defaultImageSize.Height = Math.Max(size9.Height, defaultImageSize.Height);
}
}
else if (!(item is ToolStripSeparator))
{
size5.Height = Math.Max(item.Bounds.Height, size5.Height);
size5.Width = Math.Max(item.Bounds.Width, size5.Width);
}
}
this.maxItemSize.Height = Math.Max(empty.Height + TextPadding.Vertical, Math.Max((int)(defaultImageSize.Height + CheckPadding.Vertical), (int)(size.Height + ArrowPadding.Vertical)));
if (this.ShowImageMargin)
{
this.maxItemSize.Height = Math.Max(alignThis.Height + ImagePadding.Vertical, this.maxItemSize.Height);
}
if (this.ShowCheckMargin)
{
int num1 = defaultImageSize.Width;
}
if (this.ShowImageMargin)
{
int num6 = alignThis.Width;
}
size = new Size(10, this.maxItemSize.Height);
empty.Height = this.maxItemSize.Height - TextPadding.Vertical;
alignThis.Height = this.maxItemSize.Height - ImagePadding.Vertical;
defaultImageSize.Height = this.maxItemSize.Height - CheckPadding.Vertical;
empty.Width = Math.Max(empty.Width, size5.Width);
Point location = Point.Empty;
int width = 0;
int num3 = Math.Max(0, alignThis.Width - ToolStripDropDownMenu.defaultImageSize.Width);
if (this.ShowCheckMargin && this.ShowImageMargin)
{
width = DefaultImageAndCheckMarginWidth + num3;
location = new Point(CheckPadding.Left, CheckPadding.Top);
this.checkRectangle = LayoutUtils.Align(defaultImageSize, new Rectangle(location.X, location.Y, defaultImageSize.Width, this.maxItemSize.Height), ContentAlignment.MiddleCenter);
location.X = (this.checkRectangle.Right + CheckPadding.Right) + ImagePadding.Left;
location.Y = ImagePadding.Top;
this.imageRectangle = LayoutUtils.Align(alignThis, new Rectangle(location.X, location.Y, alignThis.Width, this.maxItemSize.Height), ContentAlignment.MiddleCenter);
}
else if (this.ShowCheckMargin)
{
width = DefaultImageMarginWidth;
location = new Point(1, CheckPadding.Top);
this.checkRectangle = LayoutUtils.Align(defaultImageSize, new Rectangle(location.X, location.Y, width, this.maxItemSize.Height), ContentAlignment.MiddleCenter);
this.imageRectangle = Rectangle.Empty;
}
else if (this.ShowImageMargin)
{
width = DefaultImageMarginWidth + num3;
location = new Point(1, CheckPadding.Top);
this.checkRectangle = LayoutUtils.Align(LayoutUtils.UnionSizes(defaultImageSize, alignThis), new Rectangle(location.X, location.Y, width - 1, this.maxItemSize.Height), ContentAlignment.MiddleCenter);
this.imageRectangle = this.checkRectangle;
}
else
{
width = 0;
}
location.X = width + 1;
this.imageMarginBounds = new Rectangle(0, 0, width, base.Height);
location.X = this.imageMarginBounds.Right + TextPadding.Left;
location.Y = TextPadding.Top;
this.textRectangle = new Rectangle(location, empty);
location.X = (this.textRectangle.Right + TextPadding.Right) + ArrowPadding.Left;
location.Y = ArrowPadding.Top;
this.arrowRectangle = new Rectangle(location, size);
this.maxItemSize.Width = (this.arrowRectangle.Right + ArrowPadding.Right) - this.imageMarginBounds.Left;
base.Padding = this.DefaultPadding;
int num4 = this.imageMarginBounds.Width;
if (this.RightToLeft == RightToLeft.Yes)
{
num4 += TextPadding.Right;
int num5 = this.maxItemSize.Width;
this.checkRectangle.X = num5 - this.checkRectangle.Right;
this.imageRectangle.X = num5 - this.imageRectangle.Right;
this.textRectangle.X = num5 - this.textRectangle.Right;
this.arrowRectangle.X = num5 - this.arrowRectangle.Right;
this.imageMarginBounds.X = num5 - this.imageMarginBounds.Right;
}
else
{
num4 += TextPadding.Left;
}
this.maxItemSize.Height += this.maxItemSize.Height % 2;
this.textRectangle.Y = LayoutUtils.VAlign(this.textRectangle.Size, new Rectangle(Point.Empty, this.maxItemSize), ContentAlignment.MiddleCenter).Y;
this.textRectangle.Y += this.textRectangle.Height % 2;
this.state[stateMaxItemSizeValid] = true;
this.PaddingToTrim = num4;
}
public override SizeF Arrange(RectangleF bounds)
{
SizeF size = bounds.Size;
if (this.lastFinalSize != size || this.isDirty)
{
this.lastFinalSize = size;
this.Measure(size);
}
SizeF sizeF1 = size;
RectangleF rectangleF1 = new RectangleF(bounds.Location, size);
RectangleF empty1 = RectangleF.Empty;
RectangleF region2 = RectangleF.Empty;
SizeF empty2 = SizeF.Empty;
SizeF empty3 = SizeF.Empty;
ContentAlignment contentAlignment = this.Owner.ImageAlignment;
TextImageRelation relation = this.Owner.TextImageRelation;
if (this.Owner.RightToLeft)
{
contentAlignment = TelerikAlignHelper.RtlTranslateContent(contentAlignment);
relation = TelerikAlignHelper.RtlTranslateRelation(relation);
}
if (this.left != null && this.Owner.Image == null)
{
this.left.Arrange(rectangleF1);
if (this.right != null)
{
this.right.Arrange(rectangleF1);
}
return(size);
}
if (this.right != null && (string.IsNullOrEmpty(this.Owner.Text) || !this.Owner.DrawText))
{
this.right.Arrange(rectangleF1);
if (this.left != null)
{
this.left.Arrange(rectangleF1);
}
return(size);
}
SizeF invariantLength1 = (SizeF)this.GetInvariantLength(Size.Ceiling(this.left.DesiredSize), this.left.Margin);
SizeF invariantLength2 = (SizeF)this.GetInvariantLength(Size.Ceiling(this.right.DesiredSize), this.right.Margin);
LayoutUtils.SubAlignedRegion(sizeF1, invariantLength1, relation);
SizeF sizeF2 = LayoutUtils.AddAlignedRegion(invariantLength2, invariantLength1, relation);
RectangleF empty4 = (RectangleF)Rectangle.Empty;
empty4.Size = LayoutUtils.UnionSizes(sizeF1, sizeF2);
empty4.X += rectangleF1.X;
empty4.Y += rectangleF1.Y;
bool flag1 = (TelerikAlignHelper.ImageAlignToRelation(contentAlignment) & relation) != TextImageRelation.Overlay;
bool flag2 = (TelerikAlignHelper.TextAlignToRelation(this.Owner.TextAlignment) & relation) != TextImageRelation.Overlay;
if (flag1)
{
LayoutUtils.SplitRegion(empty4, invariantLength1, (AnchorStyles)relation, out empty1, out region2);
}
else if (flag2)
{
LayoutUtils.SplitRegion(empty4, invariantLength2, (AnchorStyles)LayoutUtils.GetOppositeTextImageRelation(relation), out region2, out empty1);
}
else if (relation == TextImageRelation.Overlay)
{
LayoutUtils.SplitRegion(empty4, invariantLength1, (AnchorStyles)relation, out empty1, out region2);
}
else
{
LayoutUtils.SplitRegion(LayoutUtils.Align(sizeF2, empty4, ContentAlignment.MiddleCenter), invariantLength1, (AnchorStyles)relation, out empty1, out region2);
LayoutUtils.ExpandRegionsToFillBounds(empty4, (AnchorStyles)relation, ref empty1, ref region2);
}
if (relation == TextImageRelation.TextBeforeImage || relation == TextImageRelation.ImageBeforeText)
{
float num = Math.Min(region2.Bottom, rectangleF1.Bottom);
region2.Y = Math.Max(Math.Min(region2.Y, rectangleF1.Y + (float)(((double)rectangleF1.Height - (double)region2.Height) / 2.0)), rectangleF1.Y);
region2.Height = num - region2.Y;
}
if (relation == TextImageRelation.TextAboveImage || relation == TextImageRelation.ImageAboveText)
{
float num = Math.Min(region2.Right, rectangleF1.Right);
region2.X = Math.Max(Math.Min(region2.X, rectangleF1.X + (float)(((double)rectangleF1.Width - (double)region2.Width) / 2.0)), rectangleF1.X);
region2.Width = num - region2.X;
}
if (relation == TextImageRelation.ImageBeforeText && (double)empty1.Size.Width != 0.0)
{
empty1.Width = Math.Max(0.0f, Math.Min(sizeF1.Width - region2.Width, empty1.Width));
region2.X = empty1.X + empty1.Width;
}
if (relation == TextImageRelation.ImageAboveText && (double)empty1.Size.Height != 0.0)
{
empty1.Height = Math.Max(0.0f, Math.Min(sizeF1.Height - region2.Height, empty1.Height));
region2.Y = empty1.Y + empty1.Height;
}
region2 = RectangleF.Intersect(region2, rectangleF1);
RectangleF rectangleF2 = LayoutUtils.Align(invariantLength1, empty1, contentAlignment);
if ((double)rectangleF2.Width > (double)empty1.Width)
{
rectangleF2.X = empty1.Width - invariantLength1.Width;
}
if ((double)rectangleF2.Height > (double)empty1.Height)
{
rectangleF2.Y = empty1.Height - invariantLength1.Height;
}
region2.Size = SizeF.Subtract(region2.Size, (SizeF)this.left.Margin.Size);
empty1.Size = SizeF.Subtract(empty1.Size, (SizeF)this.right.Margin.Size);
this.left.Arrange(empty1);
this.right.Arrange(region2);
return(size);
}
public override SizeF Arrange(RectangleF bounds)
{
SizeF finalSize = bounds.Size;
if (this.lastFinalSize != finalSize || this.isDirty)
{
this.lastFinalSize = finalSize;
this.Measure(finalSize);
}
SizeF fieldSize = finalSize;
RectangleF layoutField = new RectangleF(bounds.Location, finalSize);
RectangleF imageBounds = RectangleF.Empty;
RectangleF textBounds = RectangleF.Empty;
SizeF textSize = SizeF.Empty;
SizeF imageSize = SizeF.Empty;
ContentAlignment imageAlign = this.owner.ImageAlignment;
ContentAlignment textAlign = this.owner.TextAlignment;
TextImageRelation textImageRelation = this.owner.TextImageRelation;
if (this.owner.RightToLeft)
{
imageAlign = TelerikAlignHelper.RtlTranslateContent(imageAlign);
textAlign = TelerikAlignHelper.RtlTranslateContent(textAlign);
textImageRelation = TelerikAlignHelper.RtlTranslateRelation(textImageRelation);
}
if ((this.left != null) && (this.owner.Image == null))
{
this.left.Arrange(layoutField);
if (this.right != null)
{
this.right.Arrange(layoutField);
}
return(finalSize);
}
if (this.right != null && (string.IsNullOrEmpty(this.owner.Text) || !this.owner.DrawText))
{
this.right.Arrange(layoutField);
if (this.left != null)
{
this.left.Arrange(layoutField);
}
return(finalSize);
}
imageSize = this.GetInvariantLength(Size.Ceiling(this.left.DesiredSize), this.left.Margin);
textSize = this.GetInvariantLength(Size.Ceiling(this.right.DesiredSize), this.right.Margin);
// Subtract the image size from the whole field size
SizeF textSizeLeft = LayoutUtils.SubAlignedRegion(fieldSize, imageSize, textImageRelation);
// Create a new size based on the text size and the image size
SizeF newSize = LayoutUtils.AddAlignedRegion(textSize, imageSize, textImageRelation);
// The new field which is a union of the new sizes
RectangleF maxFieldRectangle = Rectangle.Empty;
maxFieldRectangle.Size = LayoutUtils.UnionSizes(fieldSize, newSize);
maxFieldRectangle.X += layoutField.X;
maxFieldRectangle.Y += layoutField.Y;
// Image doesn't overlay text
bool imageAlignNoOverlay = (TelerikAlignHelper.ImageAlignToRelation(imageAlign) & textImageRelation) != TextImageRelation.Overlay;
// Text doesn't overlay image
bool textAlignNoOverlay = (TelerikAlignHelper.TextAlignToRelation(textAlign) & textImageRelation) != TextImageRelation.Overlay;
if (imageAlignNoOverlay)
{
LayoutUtils.SplitRegion(maxFieldRectangle, imageSize, (AnchorStyles)textImageRelation, out imageBounds, out textBounds);
}
else if (textAlignNoOverlay)
{
LayoutUtils.SplitRegion(maxFieldRectangle, textSize, (AnchorStyles)LayoutUtils.GetOppositeTextImageRelation(textImageRelation), out textBounds, out imageBounds);
}
else
{
// Both image overlays text and text overlays image
if (textImageRelation == TextImageRelation.Overlay)
{
LayoutUtils.SplitRegion(maxFieldRectangle, imageSize, (AnchorStyles)textImageRelation, out imageBounds, out textBounds);
}
else
{
RectangleF alignedField = LayoutUtils.Align(newSize, maxFieldRectangle, ContentAlignment.MiddleCenter);
LayoutUtils.SplitRegion(alignedField, imageSize, (AnchorStyles)textImageRelation, out imageBounds, out textBounds);
LayoutUtils.ExpandRegionsToFillBounds(maxFieldRectangle, (AnchorStyles)textImageRelation, ref imageBounds, ref textBounds);
}
}
///////////////////////////////////////////////////////////////////////////
//set image and text bounds according the size of the field
if ((textImageRelation == TextImageRelation.TextBeforeImage) || (textImageRelation == TextImageRelation.ImageBeforeText))
{
float num1 = Math.Min(textBounds.Bottom, layoutField.Bottom);
textBounds.Y = Math.Max(Math.Min(textBounds.Y, layoutField.Y + ((layoutField.Height - textBounds.Height) / 2)), layoutField.Y);
textBounds.Height = num1 - textBounds.Y;
}
if ((textImageRelation == TextImageRelation.TextAboveImage) || (textImageRelation == TextImageRelation.ImageAboveText))
{
float num2 = Math.Min(textBounds.Right, layoutField.Right);
textBounds.X = Math.Max(Math.Min(textBounds.X, layoutField.X + ((layoutField.Width - textBounds.Width) / 2)), layoutField.X);
textBounds.Width = num2 - textBounds.X;
}
if ((textImageRelation == TextImageRelation.ImageBeforeText) && (imageBounds.Size.Width != 0))
{
imageBounds.Width = Math.Max(0, Math.Min(fieldSize.Width - textBounds.Width, imageBounds.Width));
textBounds.X = imageBounds.X + imageBounds.Width;
}
if ((textImageRelation == TextImageRelation.ImageAboveText) && (imageBounds.Size.Height != 0))
{
imageBounds.Height = Math.Max(0, Math.Min(fieldSize.Height - textBounds.Height, imageBounds.Height));
textBounds.Y = imageBounds.Y + imageBounds.Height;
}
textBounds = RectangleF.Intersect(textBounds, layoutField);
//align image and if its size is greater than the field's size it is become offseted as much as the difference
RectangleF newImageBounds = LayoutUtils.Align(imageSize, imageBounds, imageAlign);
if (newImageBounds.Width > imageBounds.Width)
{
newImageBounds.X = imageBounds.Width - imageSize.Width;
}
if (newImageBounds.Height > imageBounds.Height)
{
newImageBounds.Y = imageBounds.Height - imageSize.Height;
}
textBounds = LayoutUtils.Align(textSize, textBounds, textAlign);
//textBounds.Offset(layoutField.Location);
//imageBounds.Offset(layoutField.Location);
/////////////////////////////////////////////////////////////////////////
textBounds.Size = SizeF.Subtract(textBounds.Size, this.left.Margin.Size);
imageBounds.Size = SizeF.Subtract(imageBounds.Size, this.right.Margin.Size);
this.left.Arrange(imageBounds);
this.right.Arrange(textBounds);
return(finalSize);
}
protected override SizeF ArrangeOverride(SizeF arrangeSize)
{
RadCommandBarBaseItemCollection items = this.items;
int count = items.Count;
SizeF empty = SizeF.Empty;
bool flag1 = false;
bool flag2 = false;
if (flag1 || flag2)
{
for (int index = 0; index < count; ++index)
{
RadElement radElement = (RadElement)items[index];
if (flag1)
{
empty.Height = Math.Max(radElement.DesiredSize.Height, empty.Height);
}
if (flag2)
{
empty.Width = Math.Max(radElement.DesiredSize.Width, empty.Width);
}
}
}
bool flag3 = this.Orientation == Orientation.Horizontal;
bool rightToLeft = this.RightToLeft;
float num = 0.0f;
RectangleF finalRect = new RectangleF(PointF.Empty, arrangeSize);
if (flag3 && rightToLeft)
{
finalRect.X = arrangeSize.Width;
}
float f = this.ArrangeStretchedItems(arrangeSize);
for (int index = 0; index < count; ++index)
{
RadElement radElement = (RadElement)items[index];
SizeF desiredSize = radElement.DesiredSize;
if (radElement.Visibility == ElementVisibility.Collapsed)
{
radElement.Arrange(new RectangleF(PointF.Empty, desiredSize));
}
else
{
if (flag1)
{
desiredSize.Height = !flag3 ? empty.Height : Math.Max(arrangeSize.Height, empty.Height);
}
if (flag2)
{
desiredSize.Width = !flag3?Math.Max(arrangeSize.Width, empty.Width) : empty.Width;
}
if (radElement.StretchHorizontally && flag3 && !float.IsInfinity(f))
{
desiredSize.Width = f;
}
if (radElement.StretchVertically && !flag3 && !float.IsInfinity(f))
{
desiredSize.Height = f;
}
if (flag3)
{
if (rightToLeft)
{
num = desiredSize.Width;
finalRect.X -= num;
}
else
{
finalRect.X += num;
num = desiredSize.Width;
}
finalRect.Width = num;
if (flag1)
{
SizeF size = finalRect.Size;
finalRect.Height = desiredSize.Height;
RectangleF rectangleF = LayoutUtils.Align(finalRect.Size, new RectangleF(PointF.Empty, size), this.Alignment);
finalRect.Y += rectangleF.Y;
}
else
{
finalRect.Height = arrangeSize.Height;
}
}
else
{
finalRect.Y += num;
num = desiredSize.Height;
finalRect.Height = num;
if (flag2)
{
SizeF size = finalRect.Size;
finalRect.Width = desiredSize.Width;
ContentAlignment align = rightToLeft ? TelerikAlignHelper.RtlTranslateContent(this.Alignment) : this.Alignment;
RectangleF rectangleF = LayoutUtils.Align(finalRect.Size, new RectangleF(PointF.Empty, size), align);
finalRect.X += rectangleF.X;
}
else
{
finalRect.Width = arrangeSize.Width;
}
}
if (radElement.StretchVertically && flag3)
{
finalRect.Height = arrangeSize.Height;
}
else if (radElement.StretchHorizontally && !flag3)
{
finalRect.Width = arrangeSize.Width;
}
radElement.Arrange(finalRect);
}
}
return(arrangeSize);
}
