/// <summary>A method used to calculate layout for Image and Text content with standard options.</summary>
/// <param name="bounds">The bounding Rectangle within which to draw.</param>
/// <param name="text">The text to draw.</param>
/// <param name="font">The font used to draw text.</param>
/// <param name="image">The image to draw (this may be null).</param>
/// <param name="textAlignment">The vertical and horizontal alignment of the text.</param>
/// <param name="imageAlignment">The vertical and horizontal alignment of the image.</param>
/// <param name="textImageRelation">The placement of the image and text relative to each other.</param>
/// <param name="wordWrap">set true if text should wrap.</param>
/// <param name="glowSize">The size in pixels of the glow around text.</param>
/// <param name="format">The format.</param>
/// <param name="actualTextBounds">The actual text bounds.</param>
/// <param name="actualImageBounds">The actual image bounds.</param>
public static void CalcImageAndTextBounds(Rectangle bounds, string text, Font font, Image image, ContentAlignment textAlignment,
ContentAlignment imageAlignment, TextImageRelation textImageRelation, bool wordWrap, int glowSize,
ref TextFormatFlags format, out Rectangle actualTextBounds, out Rectangle actualImageBounds)
{
var horizontalRelation = (int)textImageRelation > 2;
var imageHasPreference = textImageRelation == TextImageRelation.ImageBeforeText || textImageRelation == TextImageRelation.ImageAboveText;
var preferredAlignmentValue = imageHasPreference ? (int)imageAlignment : (int)textAlignment;
var contentRectangle = bounds;
format |= TextFormatFlags.TextBoxControl | (wordWrap ? TextFormatFlags.WordBreak : TextFormatFlags.SingleLine);
// Get ImageSize
var imageSize = image?.Size ?? Size.Empty;
// Get AvailableTextSize
var availableTextSize = horizontalRelation ?
new Size(bounds.Width - imageSize.Width, bounds.Height) :
new Size(bounds.Width, bounds.Height - imageSize.Height);
// Get ActualTextSize
var actualTextSize = text?.Length > 0 ? TextRenderer.MeasureText(text, font, availableTextSize, format) : Size.Empty;
// Get ContentRectangle based upon TextImageRelation
if (textImageRelation != 0)
{
// Get ContentSize
var contentSize = horizontalRelation ?
new Size(imageSize.Width + actualTextSize.Width, Math.Max(imageSize.Height, availableTextSize.Height)) :
new Size(Math.Max(imageSize.Width, availableTextSize.Width), imageSize.Height + actualTextSize.Height);
// Get ContentLocation
var contentLocation = bounds.Location;
if (horizontalRelation)
{
if (preferredAlignmentValue % 15 == 1)
{
contentLocation.X = bounds.Left;
}
else if (preferredAlignmentValue % 15 == 2)
{
contentLocation.X = bounds.Left + (bounds.Width / 2 - contentSize.Width / 2);
}
else if (preferredAlignmentValue % 15 == 4)
{
contentLocation.X = bounds.Right - contentSize.Width;
}
}
else
{
if (preferredAlignmentValue <= 4)
{
contentLocation.Y = bounds.Top;
}
else if (preferredAlignmentValue >= 256)
{
contentLocation.Y = bounds.Bottom - contentSize.Height;
}
else
{
contentLocation.Y = bounds.Top + (bounds.Height / 2 - contentSize.Height / 2);
}
}
contentRectangle = new Rectangle(contentLocation, contentSize);
}
actualImageBounds = Rectangle.Empty;
if (image != null)
{
// Get ActualImageBounds
actualImageBounds = new Rectangle(bounds.Location, imageSize);
if (horizontalRelation)
{
actualImageBounds.X = imageHasPreference ? contentRectangle.X : contentRectangle.Right - imageSize.Width;
actualImageBounds.Y = (int)imageAlignment <= 4 ?
contentRectangle.Y : (int)imageAlignment >= 256 ?
contentRectangle.Bottom - imageSize.Height :
contentRectangle.Y + contentRectangle.Height / 2 - imageSize.Height / 2;
}
else if (textImageRelation == 0)
{
if ((int)imageAlignment <= 4)
{
actualImageBounds.Y = bounds.Top;
}
else if ((int)imageAlignment >= 256)
{
actualImageBounds.Y = bounds.Bottom - imageSize.Height;
}
else
{
actualImageBounds.Y = bounds.Top + (bounds.Height / 2 - imageSize.Height / 2);
}
if ((int)imageAlignment % 15 == 1)
{
actualImageBounds.X = bounds.Left;
}
else if ((int)imageAlignment % 15 == 2)
{
actualImageBounds.X = bounds.Left + (bounds.Width / 2 - imageSize.Width / 2);
}
else if ((int)imageAlignment % 15 == 4)
{
actualImageBounds.X = bounds.Right - imageSize.Width;
}
}
else
{
actualImageBounds.Y = imageHasPreference ? contentRectangle.Y : contentRectangle.Bottom - imageSize.Height;
actualImageBounds.X = (int)imageAlignment % 15 == 1 ?
contentRectangle.X : (int)imageAlignment % 15 == 2 ?
contentRectangle.X + contentRectangle.Width / 2 - imageSize.Width / 2 :
contentRectangle.Right - imageSize.Width;
}
}
// Get ActualTextBounds
actualTextBounds = Rectangle.Empty;
if (!(text?.Length > 0))
{
return;
}
actualTextBounds = new Rectangle(Point.Empty, actualTextSize);
if (horizontalRelation)
{
actualTextBounds.X = imageHasPreference ? contentRectangle.Right - actualTextSize.Width : contentRectangle.X;
actualTextBounds.Y = (int)textAlignment <= 4
? contentRectangle.Y
: (int)textAlignment >= 256
? contentRectangle.Bottom - actualTextSize.Height
: contentRectangle.Y + (contentRectangle.Height / 2) - (actualTextSize.Height / 2);
}
else if (textImageRelation == 0)
{
if ((int)textAlignment <= 4)
{
actualTextBounds.Y = bounds.Top;
}
else if ((int)textAlignment >= 256)
{
actualTextBounds.Y = bounds.Bottom - actualTextSize.Height;
}
else
{
actualTextBounds.Y = bounds.Top + (bounds.Height / 2 - actualTextSize.Height / 2);
}
if ((int)textAlignment % 15 == 1)
{
actualTextBounds.X = bounds.Left;
}
else if ((int)textAlignment % 15 == 2)
{
actualTextBounds.X = bounds.Left + (bounds.Width / 2 - actualTextSize.Width / 2);
}
else if ((int)textAlignment % 15 == 4)
{
actualTextBounds.X = bounds.Right - actualTextSize.Width;
}
}
else
{
actualTextBounds.Y = imageHasPreference ? contentRectangle.Bottom - actualTextSize.Height : contentRectangle.Y;
actualTextBounds.X = (int)textAlignment % 15 == 1
? contentRectangle.X
: (int)textAlignment % 15 == 2
? contentRectangle.X + contentRectangle.Width / 2 - actualTextSize.Width / 2
: contentRectangle.Right - actualTextSize.Width;
}
}
/// <summary>A method used to draw standard Image and Text content with standard layout options.</summary>
/// <param name="graphics">The Graphics object on which to draw.</param>
/// <param name="bounds">The bounding Rectangle within which to draw.</param>
/// <param name="text">The text to draw.</param>
/// <param name="font">The font used to draw text.</param>
/// <param name="image">The image to draw (this may be null).</param>
/// <param name="textAlignment">The vertical and horizontal alignment of the text.</param>
/// <param name="imageAlignment">The vertical and horizontal alignment of the image.</param>
/// <param name="textImageRelation">The placement of the image and text relative to each other.</param>
/// <param name="textColor">The color to draw the text.</param>
/// <param name="wordWrap">set true if text should wrap.</param>
/// <param name="glowSize">The size in pixels of the glow around text.</param>
/// <param name="enabled">Set false to draw image grayed out.</param>
/// <param name="format">The <see cref="TextFormatFlags"/> used to format the text.</param>
public static void DrawImageAndText(this Graphics graphics, Rectangle bounds, string text, Font font, Image image,
ContentAlignment textAlignment, ContentAlignment imageAlignment, TextImageRelation textImageRelation, Color textColor,
bool wordWrap, int glowSize, bool enabled = true, TextFormatFlags format = TextFormatFlags.TextBoxControl)
{
CalcImageAndTextBounds(bounds, text, font, image, textAlignment, imageAlignment, textImageRelation, wordWrap, glowSize, ref format, out Rectangle tRect, out Rectangle iRect);
// Draw Image
if (image != null)
{
if (enabled)
{
graphics.DrawImage(image, iRect);
}
else
{
ControlPaint.DrawImageDisabled(graphics, image, iRect.X, iRect.Y, Color.Transparent);
}
}
// Draw text
if (text?.Length > 0)
{
TextRenderer.DrawText(graphics, text, font, tRect, textColor, format);
}
}
protected ButtonBase() : base()
{
flat_style = FlatStyle.Standard;
flat_button_appearance = new FlatButtonAppearance (this);
this.image_key = string.Empty;
this.text_image_relation = TextImageRelation.Overlay;
this.use_mnemonic = true;
use_visual_style_back_color = true;
image_index = -1;
image = null;
image_list = null;
image_alignment = ContentAlignment.MiddleCenter;
ImeMode = ImeMode.Disable;
text_alignment = ContentAlignment.MiddleCenter;
is_default = false;
is_pressed = false;
text_format = new StringFormat();
text_format.Alignment = StringAlignment.Center;
text_format.LineAlignment = StringAlignment.Center;
text_format.HotkeyPrefix = HotkeyPrefix.Show;
text_format.FormatFlags |= StringFormatFlags.LineLimit;
text_format_flags = TextFormatFlags.HorizontalCenter;
text_format_flags |= TextFormatFlags.VerticalCenter;
text_format_flags |= TextFormatFlags.TextBoxControl;
SetStyle (ControlStyles.ResizeRedraw |
ControlStyles.Opaque |
ControlStyles.UserMouse |
ControlStyles.SupportsTransparentBackColor |
ControlStyles.CacheText |
ControlStyles.OptimizedDoubleBuffer, true);
SetStyle (ControlStyles.StandardClick, false);
}
private ToolStripItem SetToolStripItem(ToolStripItem toolStripItem, Operation operation,
IResourceService resourceService, int rowCount, bool isTextShown, ContentAlignment txtAlign, TextImageRelation txtImgRelation, Font font)
{
string toolStripResourceName = string.Empty;
if (toolStripItem is ToolStripSplitButton)
{
toolStripResourceName = string.Format(resourceService.GetResourceString(operation.Name), rowCount);
toolStripItem.Tag = operation.Name + '#' + operation.Detail;
}
else
{
toolStripResourceName = resourceService.GetResourceString(operation.Name);
toolStripItem.Tag = operation.Name;
}
toolStripItem.ToolTipText = toolStripResourceName;
toolStripItem.Name = operation.Name;
toolStripItem.Image = GetIcon(operation.NormalResId, RESOURCE_TYPE); //
if (isTextShown)
{
toolStripItem.Text = toolStripResourceName;
toolStripItem.TextAlign = txtAlign;
toolStripItem.TextImageRelation = txtImgRelation;
toolStripItem.Font = font;
}
return toolStripItem;
}
public static bool IsValidTextImageRelation(TextImageRelation relation) => ClientUtils.IsEnumValid(relation, (int)relation, 0, 8, 1);
// IsValidTextImageRelation
// valid values are 0,1,2,4,8
// Method for verifying
// Verify that the number is between 0 and 8
// Verify that the bit that is on - thus forcing it to be a power of two.
//
public static bool IsValidTextImageRelation(TextImageRelation relation)
{
return(ClientUtils.IsEnumValid(relation, (int)relation, (int)TextImageRelation.Overlay, (int)TextImageRelation.TextBeforeImage, 1));
}
protected override SizeF ArrangeOverride(SizeF finalSize)
{
SizeF fieldSize = finalSize;
RectangleF layoutField = new RectangleF(PointF.Empty, finalSize);
RectangleF imageBounds = RectangleF.Empty;
RectangleF textBounds = RectangleF.Empty;
SizeF textSize = SizeF.Empty;
SizeF imageSize = SizeF.Empty;
ContentAlignment imageAlign = this.ImageAlignment;
ContentAlignment textAlign = this.TextAlignment;
TextImageRelation textImageRelation = this.TextImageRelation;
if (this.RightToLeft)
{
imageAlign = TelerikAlignHelper.RtlTranslateContent(ImageAlignment);
textAlign = TelerikAlignHelper.RtlTranslateContent(TextAlignment);
textImageRelation = TelerikAlignHelper.RtlTranslateRelation(TextImageRelation);
}
if ((this.textElement != null) && IsPrimitiveNullOrEmpty(this.imageElement))
{
this.textElement.Arrange(layoutField);
if (this.imageElement != null)
{
this.imageElement.Arrange(layoutField);
}
return(finalSize);
}
if ((this.imageElement != null) && IsPrimitiveNullOrEmpty(this.textElement))
{
this.imageElement.Arrange(layoutField);
if (this.textElement != null)
{
this.textElement.Arrange(layoutField);
}
return(finalSize);
}
textSize = this.GetInvariantLength(textElement.DesiredSize, textElement.Margin);
imageSize = this.GetInvariantLength(imageElement.DesiredSize, imageElement.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 = RectangleF.Empty;
maxFieldRectangle.Size = LayoutUtils.UnionSizes(fieldSize, newSize);
// 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);
}
}
textBounds.Size = SizeF.Subtract(textBounds.Size, this.textElement.Margin.Size);
imageBounds.Size = SizeF.Subtract(imageBounds.Size, this.imageElement.Margin.Size);
this.textElement.Arrange(textBounds);
this.imageElement.Arrange(imageBounds);
return(finalSize);
}
public ToolStripBuilderStyle(ToolStripItemDisplayStyle toolStripItemDisplayStyle, ToolStripItemAlignment toolStripItemAlignment, TextImageRelation textImageRelation)
{
_toolStripItemAlignment = toolStripItemAlignment;
_toolStripItemDisplayStyle = toolStripItemDisplayStyle;
_textImageRelation = textImageRelation;
}
public static Size AddAlignedRegion(Size textSize, Size imageSize, TextImageRelation relation) {
return AddAlignedRegionCore(textSize, imageSize, IsVerticalRelation(relation));
}
private TextImageRelation RtlTranslateRelation(TextImageRelation relation)
{
if (!this.layoutRTL)
{
return relation;
}
TextImageRelation relation2 = relation;
if (relation2 != TextImageRelation.ImageBeforeText)
{
if (relation2 == TextImageRelation.TextBeforeImage)
{
return TextImageRelation.ImageBeforeText;
}
return relation;
}
return TextImageRelation.TextBeforeImage;
}
/// <summary>
/// 两个大小相加,by关系.重叠关系(需要预先手动排除)
/// </summary>
/// <param name="contentSize1">内容大小1</param>
/// <param name="contentSize2">内容大小2</param>
/// <param name="relation">两个内容关系</param>
/// <returns>新大小</returns>
public static Size AddAlignedRegion(Size contentSize1, Size contentSize2, TextImageRelation relation)
{
return(AddAlignedRegionCore(contentSize1, contentSize2, IsVerticalRelation(relation)));
}
/// <summary>Draws the text image relation.</summary>
/// <param name="graphics">The graphics.</param>
/// <param name="relation">The relation type.</param>
/// <param name="image">The image rectangle.</param>
/// <param name="text">The text.</param>
/// <param name="font">The font.</param>
/// <param name="bounds">The outer bounds.</param>
/// <param name="imagePoint">Return image point.</param>
/// <returns>The <see cref="Point" />.</returns>
public static Point GetTextImageRelationLocation(Graphics graphics, TextImageRelation relation, Rectangle image, string text, Font font, Rectangle bounds, bool imagePoint)
{
Point _newPosition = new Point(0, 0);
Point _imageLocation = new Point(0, 0);
Point _textLocation = new Point(0, 0);
Size textSize = GraphicsManager.MeasureText(text, font, graphics);
switch (relation)
{
case TextImageRelation.Overlay:
{
// Set center
_newPosition.X = bounds.Width / 2;
_newPosition.Y = bounds.Height / 2;
// Set image
_imageLocation.X = _newPosition.X - (image.Width / 2);
_imageLocation.Y = _newPosition.Y - (image.Height / 2);
// Set text
_textLocation.X = _newPosition.X - (textSize.Width / 2);
_textLocation.Y = _newPosition.Y - (textSize.Height / 2);
break;
}
case TextImageRelation.ImageBeforeText:
{
// Set center
_newPosition.Y = bounds.Height / 2;
// Set image
_imageLocation.X = _newPosition.X + 4;
_imageLocation.Y = _newPosition.Y - (image.Height / 2);
// Set text
_textLocation.X = _imageLocation.X + image.Width;
_textLocation.Y = _newPosition.Y - (textSize.Height / 2);
break;
}
case TextImageRelation.TextBeforeImage:
{
// Set center
_newPosition.Y = bounds.Height / 2;
// Set text
_textLocation.X = _newPosition.X + 4;
_textLocation.Y = _newPosition.Y - (textSize.Height / 2);
// Set image
_imageLocation.X = _textLocation.X + textSize.Width;
_imageLocation.Y = _newPosition.Y - (image.Height / 2);
break;
}
case TextImageRelation.ImageAboveText:
{
// Set center
_newPosition.X = bounds.Width / 2;
// Set image
_imageLocation.X = _newPosition.X - (image.Width / 2);
_imageLocation.Y = _newPosition.Y + 4;
// Set text
_textLocation.X = _newPosition.X - (textSize.Width / 2);
_textLocation.Y = _imageLocation.Y + image.Height;
break;
}
case TextImageRelation.TextAboveImage:
{
// Set center
_newPosition.X = bounds.Width / 2;
// Set text
_textLocation.X = _newPosition.X - (textSize.Width / 2);
_textLocation.Y = _imageLocation.Y + 4;
// Set image
_imageLocation.X = _newPosition.X - (image.Width / 2);
_imageLocation.Y = _newPosition.Y + textSize.Height + 4;
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(relation), relation, null);
}
}
if (imagePoint)
{
return(_imageLocation);
}
else
{
return(_textLocation);
}
}
public override SizeF Measure(SizeF availableSize)
{
SizeF result = SizeF.Empty;
SizeF leftSize = SizeF.Empty;
SizeF rightSize = SizeF.Empty;
TextImageRelation textImageRelation = this.owner.TextImageRelation;
switch (textImageRelation)
{
case TextImageRelation.ImageAboveText:
case TextImageRelation.TextAboveImage:
if (this.left != null)
{
leftSize = this.left.Measure(availableSize);
}
if (this.right != null)
{
rightSize = this.right.Measure(new SizeF(availableSize.Width, availableSize.Height - leftSize.Height));
}
result.Height += leftSize.Height;
result.Height += rightSize.Height;
result.Width = Math.Max(leftSize.Width, rightSize.Width);
break;
case TextImageRelation.Overlay:
if (this.left != null)
{
leftSize = this.left.Measure(availableSize);
}
if (this.right != null)
{
rightSize = this.right.Measure(availableSize);
}
result.Height = Math.Max(leftSize.Height, rightSize.Height);
result.Width = Math.Max(leftSize.Width, rightSize.Width);
break;
case TextImageRelation.ImageBeforeText:
case TextImageRelation.TextBeforeImage:
if (this.left != null)
{
leftSize = this.left.Measure(availableSize);
}
if (this.right != null)
{
rightSize = this.right.Measure(new SizeF(availableSize.Width - leftSize.Width, availableSize.Height));
}
result.Width += leftSize.Width;
result.Width += rightSize.Width;
result.Height = Math.Max(leftSize.Height, rightSize.Height);
break;
default:
break;
}
this.DesiredSize = result;
return(result);
}
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);
}
TextImageRelation RtlTranslateRelation(TextImageRelation relation) {
// If RTL, we swap ImageBeforeText and TextBeforeImage
if (layoutRTL) {
switch(relation) {
case TextImageRelation.ImageBeforeText:
return TextImageRelation.TextBeforeImage;
case TextImageRelation.TextBeforeImage:
return TextImageRelation.ImageBeforeText;
}
}
return relation;
}
// IsValidTextImageRelation
// valid values are 0,1,2,4,8
// Method for verifying
// Verify that the number is between 0 and 8
// Verify that the bit that is on - thus forcing it to be a power of two.
//
public static bool IsValidTextImageRelation(TextImageRelation relation) {
return ClientUtils.IsEnumValid(relation, (int)relation, (int)TextImageRelation.Overlay, (int)TextImageRelation.TextBeforeImage,1);
}
static LayoutOptions()
{
TextImageRelation[] relationArray = new TextImageRelation[11];
relationArray[0] = TextImageRelation.ImageBeforeText | TextImageRelation.ImageAboveText;
relationArray[1] = TextImageRelation.ImageAboveText;
relationArray[2] = TextImageRelation.TextBeforeImage | TextImageRelation.ImageAboveText;
relationArray[4] = TextImageRelation.ImageBeforeText;
relationArray[6] = TextImageRelation.TextBeforeImage;
relationArray[8] = TextImageRelation.ImageBeforeText | TextImageRelation.TextAboveImage;
relationArray[9] = TextImageRelation.TextAboveImage;
relationArray[10] = TextImageRelation.TextBeforeImage | TextImageRelation.TextAboveImage;
_imageAlignToRelation = relationArray;
}
// True if text & image should be lined up vertically. False if horizontal or overlay.
public static bool IsVerticalRelation(TextImageRelation relation) {
return (relation & (TextImageRelation.TextAboveImage | TextImageRelation.ImageAboveText)) != 0;
}
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 void OnmyTextImageRelationChanged(TextImageRelation oldValue, TextImageRelation newValue)
{
SetTextImageRelation();
}
public void ButtonBase_TextImageRelation_SetInvalid_ThrowsInvalidEnumArgumentException(TextImageRelation value)
{
var button = new SubButtonBase();
Assert.Throws <InvalidEnumArgumentException>("value", () => button.TextImageRelation = value);
}
/// <summary>
///
/// </summary>
/// <param name="fieldSize"></param>
/// <param name="layoutField"></param>
/// <param name="newLayouts"></param>
public void LayoutTextAndImage(Size fieldSize, Rectangle layoutField, bool newLayouts)
{
Rectangle imageBounds = Rectangle.Empty;
Rectangle textBounds = Rectangle.Empty;
Size textSize = Size.Empty;
Size imageSize = Size.Empty;
ContentAlignment imageAlign = ImageAlignment;
ContentAlignment textAlign = TextAlignment;
TextImageRelation textImageRelation = TextImageRelation;
//DK_2006_07_28
if (!newLayouts)
{
List <PreferredSizeData> prefSizelist = new List <PreferredSizeData>();
FillList(prefSizelist, fieldSize);
}
if (this.RightToLeft)
{
imageAlign = TelerikAlignHelper.RtlTranslateContent(ImageAlignment);
textAlign = TelerikAlignHelper.RtlTranslateContent(TextAlignment);
textImageRelation = TelerikAlignHelper.RtlTranslateRelation(TextImageRelation);
}
if (textElement != null)
{
textSize = newLayouts ? Size.Ceiling(textElement.DesiredSize) : Size.Ceiling(textElement.GetPreferredSize(fieldSize));
textSize = this.GetInvariantLength(textSize, textElement.Margin);
}
if (imageElement != null)
{
imageSize = newLayouts ? Size.Ceiling(imageElement.DesiredSize) : Size.Ceiling(imageElement.GetPreferredSize(fieldSize));
imageSize = this.GetInvariantLength(imageSize, imageElement.Margin);
}
if ((textElement != null) && IsPrimitiveNullOrEmpty(this.imageElement))
{
Rectangle bounds = LayoutUtils.Align(textSize, new Rectangle(Point.Empty, fieldSize), textAlign);
bounds.Size = Size.Subtract(textSize, textElement.Margin.Size);
if (newLayouts)
{
textElement.Arrange(bounds);
}
else
{
textElement.Bounds = bounds;
}
return;
}
if ((imageElement != null) && IsPrimitiveNullOrEmpty(this.textElement))
{
Rectangle bounds = LayoutUtils.Align(imageSize, new Rectangle(Point.Empty, fieldSize), imageAlign);
bounds.Size = Size.Subtract(imageSize, imageElement.Margin.Size);
if (newLayouts)
{
imageElement.Arrange(bounds);
}
else
{
imageElement.Bounds = bounds;
}
return;
}
// Subtract the image size from the whole field size
Size textSizeLeft = LayoutUtils.SubAlignedRegion(fieldSize, imageSize, textImageRelation);
textSize = newLayouts ? Size.Ceiling(this.textElement.DesiredSize) : Size.Ceiling(this.textElement.GetPreferredSize(textSizeLeft));
textSize = this.GetInvariantLength(textSize, textElement.Margin);
// Create a new size based on the text size and the image size
Size newSize = LayoutUtils.AddAlignedRegion(textSize, imageSize, textImageRelation);
// The new field which is a union of the new sizes
Rectangle maxFieldRectangle = Rectangle.Empty;
maxFieldRectangle.Size = LayoutUtils.UnionSizes(fieldSize, newSize);
// 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
{
Rectangle 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))
{
int 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))
{
int 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 = Rectangle.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
Rectangle 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.Size = Size.Subtract(textBounds.Size, this.textElement.Margin.Size);
imageBounds.Size = Size.Subtract(newImageBounds.Size, this.imageElement.Margin.Size);
if (newLayouts)
{
this.textElement.Arrange(textBounds);
this.imageElement.Arrange(newImageBounds);
}
else
{
this.textElement.Bounds = textBounds;
this.imageElement.Bounds = newImageBounds;
}
}
/// <summary>Draws the internal text and image content.</summary>
/// <param name="graphics">The graphics to draw on.</param>
/// <param name="rectangle">The coordinates of the rectangle to draw.</param>
/// <param name="text">The string to draw.</param>
/// <param name="font">The font to use in the string.</param>
/// <param name="foreColor">The color of the string.</param>
/// <param name="image">The image to draw.</param>
/// <param name="textImageRelation">The text image relation.</param>
public static void DrawInternalContent(Graphics graphics, Rectangle rectangle, string text, Font font, Color foreColor, VisualBitmap image, TextImageRelation textImageRelation)
{
image.Point = GDI.ApplyTextImageRelation(graphics, textImageRelation, new Rectangle(image.Point, image.Size), text, font, rectangle, true);
Point textPoint = GDI.ApplyTextImageRelation(graphics, textImageRelation, new Rectangle(image.Point, image.Size), text, font, rectangle, false);
VisualBitmap.DrawImage(graphics, image.Border, image.Point, image.Image, image.Size, image.Visible);
graphics.DrawString(text, font, new SolidBrush(foreColor), textPoint);
}
public static void Set_TextImageRelation(this UpgradeHelpers.BasicViewModels.ButtonViewModel _ButtonBase, TextImageRelation TextImageRelation)
{
throw new NotImplementedException("This is an automatic generated code, please implement the requested logic.");
}
/// <summary>Draws the text image relation.</summary>
/// <param name="graphics">The graphics.</param>
/// <param name="relation">The relation type.</param>
/// <param name="imageRectangle">The image rectangle.</param>
/// <param name="text">The text.</param>
/// <param name="font">The font.</param>
/// <param name="outerBounds">The outer bounds.</param>
/// <param name="imagePoint">Return image point.</param>
/// <returns>The return point.</returns>
public static Point ApplyTextImageRelation(Graphics graphics, TextImageRelation relation, Rectangle imageRectangle, string text, Font font, Rectangle outerBounds, bool imagePoint)
{
Point newPosition = new Point(0, 0);
Point newImagePoint = new Point(0, 0);
Point newTextPoint = new Point(0, 0);
Size textSize = MeasureText(graphics, text, font);
switch (relation)
{
case TextImageRelation.Overlay:
{
// Set center
newPosition.X = outerBounds.Width / 2;
newPosition.Y = outerBounds.Height / 2;
// Set image
newImagePoint.X = newPosition.X - (imageRectangle.Width / 2);
newImagePoint.Y = newPosition.Y - (imageRectangle.Height / 2);
// Set text
newTextPoint.X = newPosition.X - (textSize.Width / 2);
newTextPoint.Y = newPosition.Y - (textSize.Height / 2);
break;
}
case TextImageRelation.ImageBeforeText:
{
// Set center
newPosition.Y = outerBounds.Height / 2;
// Set image
newImagePoint.X = newPosition.X + 4;
newImagePoint.Y = newPosition.Y - (imageRectangle.Height / 2);
// Set text
newTextPoint.X = newImagePoint.X + imageRectangle.Width;
newTextPoint.Y = newPosition.Y - (textSize.Height / 2);
break;
}
case TextImageRelation.TextBeforeImage:
{
// Set center
newPosition.Y = outerBounds.Height / 2;
// Set text
newTextPoint.X = newPosition.X + 4;
newTextPoint.Y = newPosition.Y - (textSize.Height / 2);
// Set image
newImagePoint.X = newTextPoint.X + textSize.Width;
newImagePoint.Y = newPosition.Y - (imageRectangle.Height / 2);
break;
}
case TextImageRelation.ImageAboveText:
{
// Set center
newPosition.X = outerBounds.Width / 2;
// Set image
newImagePoint.X = newPosition.X - (imageRectangle.Width / 2);
newImagePoint.Y = newPosition.Y + 4;
// Set text
newTextPoint.X = newPosition.X - (textSize.Width / 2);
newTextPoint.Y = newImagePoint.Y + imageRectangle.Height;
break;
}
case TextImageRelation.TextAboveImage:
{
// Set center
newPosition.X = outerBounds.Width / 2;
// Set text
newTextPoint.X = newPosition.X - (textSize.Width / 2);
newTextPoint.Y = newImagePoint.Y + 4;
// Set image
newImagePoint.X = newPosition.X - (imageRectangle.Width / 2);
newImagePoint.Y = newPosition.Y + textSize.Height + 4;
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(relation), relation, null);
}
}
if (imagePoint)
{
return(newImagePoint);
}
else
{
return(newTextPoint);
}
}
public GitToolbar(GuiProvider guiProvider)
{
Verify.Argument.IsNotNull(guiProvider, "guiProvider");
_guiProvider = guiProvider;
Text = Resources.StrGit;
const TextImageRelation tir = TextImageRelation.ImageAboveText;
const ToolStripItemDisplayStyle ds = ToolStripItemDisplayStyle.ImageAndText;
Items.AddRange(new ToolStripItem[]
{
_fetchButton = new ToolStripSplitButton(Resources.StrFetch, CachedResources.Bitmaps["ImgFetch"])
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipFetch
},
_pullButton = new ToolStripSplitButton(Resources.StrPull, CachedResources.Bitmaps["ImgPull"])
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipPull
},
_pushButton = new ToolStripButton(Resources.StrPush, CachedResources.Bitmaps["ImgPush"])
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipPush
},
new ToolStripSeparator(),
_historyButton = new ToolStripButton(Resources.StrHistory, CachedResources.Bitmaps["ImgHistory"], OnHistoryClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipHistory
},
new ToolStripSeparator(),
_commitButton = new ToolStripButton(Resources.StrCommit, CachedResources.Bitmaps["ImgCommit"], OnCommitClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipCommit
},
_applyPatchButton = new ToolStripButton(Resources.StrPatch, CachedResources.Bitmaps["ImgPatchApply"], OnApplyPatchClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipApplyPatches
},
_stashButton = new ToolStripSplitButton(Resources.StrStash, CachedResources.Bitmaps["ImgStash"])
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipStash
},
_cleanButton = new ToolStripButton(Resources.StrClean, CachedResources.Bitmaps["ImgClean"], OnCleanClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipClean
},
new ToolStripSeparator(),
_checkoutButton = new ToolStripButton(Resources.StrCheckout, CachedResources.Bitmaps["ImgCheckout"], OnCheckoutClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipCheckoutBranch
},
_branchButton = new ToolStripButton(Resources.StrBranch, CachedResources.Bitmaps["ImgBranch"], OnBranchClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipCreateBranch
},
_mergeButton = new ToolStripSplitButton(Resources.StrMerge, CachedResources.Bitmaps["ImgMerge"])
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipMerge
},
new ToolStripSeparator(),
_tagButton = new ToolStripButton(Resources.StrTag, CachedResources.Bitmaps["ImgTag"], OnTagClick)
{
TextImageRelation = tir, DisplayStyle = ds, ToolTipText = Resources.TipCreateTag
},
_noteButton = new ToolStripButton(Resources.StrNote, CachedResources.Bitmaps["ImgNote"], OnNoteClick)
{
TextImageRelation = tir, DisplayStyle = ds, Available = false /* GitFeatures.AdvancedNotesCommands.IsAvailable */
},
});
_fetchButton.ButtonClick += OnFetchClick;
_pullButton.ButtonClick += OnPullClick;
_pushButton.Click += OnPushClick;
_mergeButton.ButtonClick += OnMergeClick;
_mergeButton.DropDown.Items.Add(
_mergeMultipleItem = new ToolStripMenuItem(Resources.StrMergeMultipleBranches, null, OnMultipleMergeClick));
_stashButton.ButtonClick += OnStashClick;
_stashButton.DropDown.Items.Add(
_stashPopItem = new ToolStripMenuItem(Resources.StrSave, CachedResources.Bitmaps["ImgStashSave"], OnStashSaveClick));
_stashButton.DropDown.Items.Add(
_stashPopItem = new ToolStripMenuItem(Resources.StrPop, CachedResources.Bitmaps["ImgStashPop"], OnStashPopClick));
_stashButton.DropDown.Items.Add(
_stashApplyItem = new ToolStripMenuItem(Resources.StrApply, CachedResources.Bitmaps["ImgStashApply"], OnStashApplyClick));
if (guiProvider.Repository != null)
{
AttachToRepository(guiProvider.Repository);
}
}
public static bool IsHorizontalRelation(TextImageRelation relation)
{
return((relation & (TextImageRelation.ImageBeforeText | TextImageRelation.TextBeforeImage)) != TextImageRelation.Overlay);
}
public virtual void InitPopupCommandButtonLayout(
ToolStripPanel toolStripPanel,
IView hostedView,
Size btnSize,
bool isTextShown,
ContentAlignment txtAlign,
TextImageRelation txtImgRelation,
Font font,
IResourceService resourceService,
EventHandler buttonClickHandler)
{
if (hostedView == null)
return;
foreach (Control control in toolStripPanel.Controls)
{
ToolStrip toolStrip = control as ToolStrip;
if (toolStrip != null)
{
toolStrip.ImageScalingSize = btnSize;
IDictionary<string, CommandStatus> commandButtonList = GetCommandButtonList(hostedView.ProgramID);
IEnumerator<KeyValuePair<string, CommandStatus>> enumerator = commandButtonList.GetEnumerator();
while (enumerator.MoveNext())
{
ToolStripButton toolStripButton = new ToolStripButton();
string commandKey = enumerator.Current.Key;
toolStripButton.Image = GetIcon("img" + commandKey, RESOURCE_TYPE);
toolStripButton.Name = commandKey;
toolStripButton.ToolTipText = commandKey;
toolStripButton.Click += buttonClickHandler;
toolStrip.Items.Add(toolStripButton);
}
toolStripPanel.Controls.Add(toolStrip);
hostedView.AvailButtonList = commandButtonList;
}
}
}
public static bool IsVerticalRelation(TextImageRelation relation)
{
return((relation & (TextImageRelation.ImageAboveText | TextImageRelation.TextAboveImage)) != TextImageRelation.Overlay);
}
public static bool IsValidTextImageRelation(TextImageRelation relation)
{
}
public static TextImageRelation GetOppositeTextImageRelation(TextImageRelation relation)
{
return((TextImageRelation)GetOppositeAnchor((AnchorStyles)relation));
}
public static Size AddAlignedRegion(Size textSize, Size imageSize, TextImageRelation relation)
{
return(AddAlignedRegionCore(textSize, imageSize, IsVerticalRelation(relation)));
}
// True if text & image should be lined up horizontally. False if vertical or overlay.
public static bool IsHorizontalRelation(TextImageRelation relation)
{
return((relation & (TextImageRelation.TextBeforeImage | TextImageRelation.ImageBeforeText)) != 0);
}
public static TextImageRelation GetOppositeTextImageRelation(TextImageRelation relation) {
return (TextImageRelation) GetOppositeAnchor((AnchorStyles)relation);
}
// True if text & image should be lined up vertically. False if horizontal or overlay.
public static bool IsVerticalRelation(TextImageRelation relation)
{
return((relation & (TextImageRelation.TextAboveImage | TextImageRelation.ImageAboveText)) != 0);
}
// True if text & image should be lined up horizontally. False if vertical or overlay.
public static bool IsHorizontalRelation(TextImageRelation relation) {
return (relation & (TextImageRelation.TextBeforeImage | TextImageRelation.ImageBeforeText)) != 0;
}
public static Size SubAlignedRegion(Size currentSize, Size contentSize, TextImageRelation relation)
{
return(SubAlignedRegionCore(currentSize, contentSize, IsVerticalRelation(relation)));
}
public static Size SubAlignedRegion(Size currentSize, Size contentSize, TextImageRelation relation) {
return SubAlignedRegionCore(currentSize, contentSize, IsVerticalRelation(relation));
}
/// <summary>Draws a button control.</summary>
/// <param name="graphics">The graphics to draw on.</param>
/// <param name="rectangle">The coordinates of the rectangle to draw.</param>
/// <param name="backColor">The BackColor of the button.</param>
/// <param name="backgroundImage">The background image for the button.</param>
/// <param name="border">The border.</param>
/// <param name="mouseState">The mouse State.</param>
/// <param name="text">The string to draw.</param>
/// <param name="font">The font to use in the string.</param>
/// <param name="foreColor">The color of the string.</param>
/// <param name="image">The image to draw.</param>
/// <param name="imageSize">The image Size.</param>
/// <param name="textImageRelation">The text image relation.</param>
public static void DrawButton(Graphics graphics, Rectangle rectangle, Color backColor, Image backgroundImage, Border border, MouseStates mouseState, string text, Font font, Color foreColor, Image image, Size imageSize, TextImageRelation textImageRelation)
{
GraphicsPath _controlGraphicsPath = VisualBorderRenderer.CreateBorderTypePath(rectangle, border);
VisualBackgroundRenderer.DrawBackground(graphics, backColor, backgroundImage, mouseState, rectangle, border);
DrawContent(graphics, rectangle, text, font, foreColor, image, imageSize, textImageRelation);
VisualBorderRenderer.DrawBorderStyle(graphics, border, _controlGraphicsPath, mouseState);
}
protected ToolStripItem (string text, Image image, EventHandler onClick, string name)
{
this.alignment = ToolStripItemAlignment.Left;
this.anchor = AnchorStyles.Left | AnchorStyles.Top;
this.auto_size = true;
this.auto_tool_tip = this.DefaultAutoToolTip;
this.available = true;
this.back_color = Color.Empty;
this.background_image_layout = ImageLayout.Tile;
this.can_select = true;
this.display_style = this.DefaultDisplayStyle;
this.dock = DockStyle.None;
this.enabled = true;
this.fore_color = Color.Empty;
this.image = image;
this.image_align = ContentAlignment.MiddleCenter;
this.image_index = -1;
this.image_key = string.Empty;
this.image_scaling = ToolStripItemImageScaling.SizeToFit;
this.image_transparent_color = Color.Empty;
this.margin = this.DefaultMargin;
this.merge_action = MergeAction.Append;
this.merge_index = -1;
this.name = name;
this.overflow = ToolStripItemOverflow.AsNeeded;
this.padding = this.DefaultPadding;
this.placement = ToolStripItemPlacement.None;
this.right_to_left = RightToLeft.Inherit;
this.bounds.Size = this.DefaultSize;
this.text = text;
this.text_align = ContentAlignment.MiddleCenter;
this.text_direction = DefaultTextDirection;
this.text_image_relation = TextImageRelation.ImageBeforeText;
this.visible = true;
this.Click += onClick;
OnLayout (new LayoutEventArgs (null, string.Empty));
}
/// <summary>Draws the text and image content.</summary>
/// <param name="graphics">The graphics to draw on.</param>
/// <param name="rectangle">The coordinates of the rectangle to draw.</param>
/// <param name="text">The string to draw.</param>
/// <param name="font">The font to use in the string.</param>
/// <param name="foreColor">The color of the string.</param>
/// <param name="image">The image to draw.</param>
/// <param name="imageSize">The image Size.</param>
/// <param name="textImageRelation">The text image relation.</param>
public static void DrawContent(Graphics graphics, Rectangle rectangle, string text, Font font, Color foreColor, Image image, Size imageSize, TextImageRelation textImageRelation)
{
Rectangle _imageRectangle = new Rectangle(new Point(), imageSize);
Point _imagePoint = RelationManager.GetTextImageRelationLocation(graphics, textImageRelation, _imageRectangle, text, font, rectangle, true);
Point _textPoint = RelationManager.GetTextImageRelationLocation(graphics, textImageRelation, _imageRectangle, text, font, rectangle, false);
graphics.DrawImage(image, new Rectangle(_imagePoint, imageSize));
graphics.DrawString(text, font, new SolidBrush(foreColor), _textPoint);
}
private string GetStrFromTextImageRelation(TextImageRelation t)
{
string s = null;
if (t == TextImageRelation.ImageAboveText)
{
s = "ImageAboveText";
}
else if (t == TextImageRelation.ImageBeforeText)
{
s = "ImageBeforeText";
}
else if (t == TextImageRelation.Overlay)
{
s = "Overlay";
}
else if (t == TextImageRelation.TextAboveImage)
{
s = "TextAboveImage";
}
else if (t == TextImageRelation.TextBeforeImage)
{
s = "TextBeforeImage";
}
if (string.IsNullOrEmpty(s))
{
s = "ImageBeforeText";
return s;
}
else
{
return s;
}
}
public static bool IsValidTextImageRelation(TextImageRelation relation)
{
return System.Windows.Forms.ClientUtils.IsEnumValid(relation, (int) relation, 0, 8, 1);
}
