public void WatermarkFileWithText(string inputFile, string outputFile, string text, Font font, int x, int y,
bool renderOver,
Brush under, Brush over, StringAlignment xAlignment,
StringAlignment yAlignment)
{
Image imgPhoto = null;
Image outputPhoto = null;
try
{
try
{
imgPhoto = Image.FromFile(inputFile);
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to open file \"" + inputFile + "\"", ex);
}
WatermarkImageWithText(imgPhoto, ref outputPhoto, SmoothingMode.AntiAlias, text, font, x, y, renderOver,
under, over, xAlignment, yAlignment);
imgPhoto.Dispose();
imgPhoto = null;
outputPhoto.Save(outputFile, ImageFormat.Jpeg);
}
finally
{
if (imgPhoto != null) imgPhoto.Dispose();
if (outputPhoto != null) outputPhoto.Dispose();
}
}
public VMergedCell(int firstRow, int lastRow, StringAlignment alignment,
StringAlignment lineAlignment)
: this(firstRow, lastRow)
{
this.alignment = alignment;
this.lineAlignment = lineAlignment;
}
internal MonthViewBoxEventArgs(Graphics g, Rectangle bounds, string text, StringAlignment textAlign, Color textColor, Color backColor, Color borderColor)
{
_graphics = g;
_bounds = bounds;
Text = text;
TextColor = textColor;
BackgroundColor = backColor;
BorderColor = borderColor;
switch (textAlign)
{
case StringAlignment.Center:
TextFlags |= TextFormatFlags.HorizontalCenter;
break;
case StringAlignment.Far:
TextFlags |= TextFormatFlags.Right;
break;
case StringAlignment.Near:
TextFlags |= TextFormatFlags.Left;
break;
default:
break;
}
TextFlags |= TextFormatFlags.VerticalCenter;
}
protected override object GetTextBoxColumn(StringAlignment alignment)
{
var column = new DataGridTextColumn();
// TODO: set alignment in style
column.Width = alignment == StringAlignment.Near ? 160 : 80;
return column;
}
public SimpleLabel(
string text = "",
float x = 0.0f, float y = 0.0f,
Font font = null, Brush brush = null,
float width = float.MaxValue, float height = float.MaxValue,
StringAlignment horizontalAlignment = StringAlignment.Near,
StringAlignment verticalAlignment = StringAlignment.Near,
IEnumerable<string> alternateText = null)
{
Text = text;
X = x;
Y = y;
Font = font ?? new Font("Arial", 1.0f);
Brush = brush ?? new SolidBrush(Color.Black);
Width = width;
Height = height;
HorizontalAlignment = horizontalAlignment;
VerticalAlignment = verticalAlignment;
IsMonospaced = false;
HasShadow = true;
ShadowColor = Color.FromArgb(128, 0, 0, 0);
((List<string>)(AlternateText = new List<string>())).AddRange(alternateText ?? new string[0]);
Format = new StringFormat
{
Alignment = HorizontalAlignment,
LineAlignment = VerticalAlignment,
FormatFlags = StringFormatFlags.NoWrap,
Trimming = StringTrimming.EllipsisCharacter
};
}
/// <summary>
/// converts two given alignment values to one content alignment
/// </summary>
public static ContentAlignment GetAlignmentFromStringAlignment(StringAlignment alignment,
StringAlignment linealignment)
{
ContentAlignment ret;
//horizontal
switch(alignment)
{
case StringAlignment.Near:
ret=anyleft; break;
case StringAlignment.Center:
ret=anycenter; break;
default:
ret=anyright; break;
}
//vertical
switch(linealignment)
{
case StringAlignment.Near:
ret&=anytop; break;
case StringAlignment.Center:
ret&=anymiddle; break;
default:
ret&=anybottom; break;
}
return ret;
}
private static Bitmap CreateInfomationBitmap(string content, int width, int height,
StringAlignment hAlign = StringAlignment.Near,
StringAlignment vAlign = StringAlignment.Near)
{
Bitmap b = new Bitmap(width, height);
Graphics g = Graphics.FromImage(b);
GraphicsPath path = new GraphicsPath();
FontFamily fontFamily = new FontFamily("微软雅黑");
StringFormat format = new StringFormat();
format.Alignment = hAlign;
format.LineAlignment = vAlign;
path.AddString(content,
fontFamily, (int)FontStyle.Bold, 16, new Rectangle(0, 0, width, height), format);
fontFamily.Dispose();
g.SmoothingMode = SmoothingMode.AntiAlias;
g.FillPath(Brushes.Black, path);
Pen pen = new Pen(Color.Black, 2);
g.DrawPath(pen, path);
g.Dispose();
pen.Dispose();
Bitmap infoBitmap = RenderUtils.BoxBlur(b, 1);
g = Graphics.FromImage(infoBitmap);
g.SmoothingMode = SmoothingMode.AntiAlias;
g.FillPath(Brushes.White, path);
g.Dispose();
return infoBitmap;
}
public HeadingButton(string aString, string aFontName, int pointSize, FontStyle style, int x, int y, int width, int height, StringAlignment align, StringAlignment lineAlign, uint txtColor, Graphic background)
:base(aString,aFontName,pointSize,style, x,y,width,height,align,lineAlign,txtColor,background)
{
//GFont aFont = new GFont(aFontName, pointSize, Guid.NewGuid());
//this.Font = aFont;
Enabled = true;
}
public FixedWidthColumn(string name, int width, StringAlignment align, char blankChar)
{
this._name = name;
this._w = width;
this._align = align;
this._blank = blankChar;
}
public HMergedCell(int leftColumn, int rightColumn, StringAlignment alignment,
StringAlignment lineAlignment)
: this(leftColumn, rightColumn)
{
this.alignment = alignment;
this.lineAlignment = lineAlignment;
}
/* ==========================================================
* PUBLIC METHODS
* ==========================================================
*/
public void addButton(int xPos, int yPos, int width, int height, string label = "", bool showText = true, StringAlignment alignment = StringAlignment.CENTER)
{
BasicButton button = new BasicButton(xPos, yPos, width, height, basicBox, buttonFontStyle1, label, alignment, showText);
componentsOnScreen.Add(button);
buttonsOnScreen.Add(button);
}
public MprStlTxt(Font f, Color c, bool rtl, StringAlignment a, StringAlignment la)
{
Font = f;
Color = c;
DirectionRightToLeft = rtl;
Alignment = a;
LineAlignment = la;
}
public ListColumnDefinition(string id, string text, string groupName, int width, StringAlignment align)
{
this.align = align;
this.groupName = groupName;
this.id = id;
this.width = width;
this.text = text;
}
public StringFormat(StringFormatFlags options) {
this.native = LibIGraph.CreateStringFormat
(StringAlignment.Near, options, StringAlignment.Near, StringTrimming.None);
this.trimming = StringTrimming.None;
this.alignment = StringAlignment.Near;
this.lineAlignment = StringAlignment.Near;
this.stringFormatFlags = options;
}
public TextField(string text) {
Alignment = StringAlignment.Near;
Outline = 0;
OutlineColor = Color.Black;
Text = text;
TextColor = Color.White;
VerticalAlignment = StringAlignment.Near;
}
public StringFormat(StringFormatFlags options, int lang) {
_alignment = StringAlignment.Near;
_digitSubstituteLanguage = lang;
_digitSubstituteMethod = StringDigitSubstitute.User;
_flags = options;
_hotkeyPrefix = HotkeyPrefix.None;
_lineAlignment = StringAlignment.Near;
_trimming = StringTrimming.Character;
}
public void AlignedString(MovieClip mc, string s, Brush brush, StringAlignment align, float size)
{
StringFormat sf = new StringFormat();
sf.Alignment = align;
sf.LineAlignment = align;
Font f = new Font("Times", size);
mc.Graphics.DrawString(s, f, brush, new Rectangle(0, 0, (int) (mc.Width * mc.Xscale), (int) (mc.Height * mc.Yscale)), sf);
}
public static StringFormat BuildStringFormat(StringAlignment h, StringAlignment v)
{
StringFormat sf = new StringFormat();
sf.Alignment = h;
sf.LineAlignment = v;
sf.FormatFlags = StringFormatFlags.NoWrap;
sf.Trimming = StringTrimming.None;
return sf;
}
public TextLabel(int xPos, int yPos, SpriteFont fontStyle, string label = "", StringAlignment alignment = StringAlignment.CENTER)
{
this.xPos = xPos;
this.yPos = yPos;
this.fontStyle = fontStyle;
this.alignment = alignment;
Initialize();
}
public static Bitmap TextToBitmapAligned(this string text, int width, int height, float fontSize,
StringAlignment horizAlign, StringAlignment vertAlign)
{
var font = new Font ("Arial", fontSize);
var brush = new SolidBrush (Color.Black);
var stringFormat = new StringFormat ();
stringFormat.Alignment = horizAlign;
stringFormat.LineAlignment = vertAlign;
return TextToBitmap (text, width, height, PixelFormat.Format32bppArgb, font, brush, stringFormat);
}
public CustomListBoxColumn(int id, string name, bool visible)
{
_id = id;
_name = name;
_isVisible = visible;
_sizeMode = ColumnSizeMode.Sizeable;
_contentWidth = -1;
_contentAlignment = StringAlignment.Near;
_headerAlignment = StringAlignment.Near;
}
// -------------------------------------------------
public Form_TextLimitedPositioning (Point ptScreenClick, Side textside, StringAlignment textalignment)
{
InitializeComponent ();
//Font = new Font ("Timies New Roman", 14);
ptMouseScreenInit = ptScreenClick;
side = textside;
alignment = textalignment;
}
public ListaKontaktowUI(Font czcionkaTytul, Font czcionkaDetal, Size rozmiarIkony,
StringAlignment ulozenie, StringAlignment ulozeniePionowe)
{
this.czcionkaTytul = czcionkaTytul;
this.czcionkaDetal = czcionkaDetal;
this.rozmiarIkony = rozmiarIkony;
this.ItemHeight = rozmiarIkony.Height + this.Margin.Vertical;
format = new StringFormat();
format.Alignment = ulozenie;
format.LineAlignment = ulozeniePionowe;
}
public strTextos(int xi, int yi, string cTexto)
{
this.x1 = xi;
this.y1 = yi;
this.x2 = 0;
this.y2 = 0;
this.x3 = 0;
this.y3 = 0;
this.Texto = cTexto;
this.Bold = false;
this.Align = StringAlignment.Far;
}
public strTextos(int xi1, int yi1, int xi2, int yi2, int xi3, int yi3, string cTexto, bool lBold, StringAlignment sAlign)
{
this.x1 = xi1;
this.y1 = yi1;
this.x2 = xi2;
this.y2 = yi2;
this.x3 = xi3;
this.y3 = yi3;
this.Texto = cTexto;
this.Bold = lBold;
this.Align = sAlign;
}
public StringFormat (StringFormat source) {
if (source == null)
throw new ArgumentNullException("format");
_alignment = source.LineAlignment;
_digitSubstituteLanguage = source.DigitSubstitutionLanguage;
_digitSubstituteMethod = source.DigitSubstitutionMethod;
_flags = source.FormatFlags;
_hotkeyPrefix = source.HotkeyPrefix;
_lineAlignment = source.LineAlignment;
_trimming = source.Trimming;
}
/// <summary>
/// Initializes a new instance of the <see cref="NuGenWeekday"/> class.
/// </summary>
public NuGenWeekday(NuGenCalendar calendar)
{
m_calendar = calendar;
m_backColor1 = Color.White;
m_backColor2 = Color.White;
m_gradientMode = NuGenGradientMode.None;
m_textColor = Color.FromArgb(0, 84, 227);
m_font = new Font("Microsoft Sans Serif", (float)8.25);
m_dayFormat = NuGenDayFormat.Short;
m_align = StringAlignment.Center;
m_borderColor = Color.Black;
}
/// <summary>
/// Constructor with defining parameters
/// </summary>
/// <param name="titleFont"></param>
/// <param name="imageSize"></param>
/// <param name="aligment"></param>
/// <param name="lineAligment"></param>
public CheckedListBoxWithImage(Font titleFont, Size imageSize,
StringAlignment aligment, StringAlignment lineAligment)
{
_imageSize = imageSize;
_fmt = new StringFormat();
_fmt.Alignment = aligment;
_fmt.LineAlignment = lineAligment;
this.ItemHeight = _imageSize.Height + this.Margin.Vertical;
_fmt.Alignment = aligment;
_fmt.LineAlignment = lineAligment;
_titleFont = titleFont;
}
public exListBox(Font titleFont, Font detailsFont,
StringAlignment aligment, StringAlignment lineAligment )
{
_titleFont = titleFont;
_detailsFont = detailsFont;
this.ItemHeight = this.Margin.Vertical;
_fmt = new StringFormat();
_fmt.Alignment = aligment;
_fmt.LineAlignment = lineAligment;
_titleFont = titleFont;
_detailsFont = detailsFont;
}
private Color _TextColor; // VBConversions Note: Initial value cannot be assigned here since it is non-static. Assignment has been moved to the class constructors.
#endregion Fields
#region Constructors
public MonoFlat_Button()
{
SetStyle((System.Windows.Forms.ControlStyles)(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw | ControlStyles.SupportsTransparentBackColor | ControlStyles.UserPaint), true);
BackColor = Color.Transparent;
DoubleBuffered = true;
Font = new Font("Segoe UI", 12);
ForeColor = Color.FromArgb(255, 255, 255);
Size = new Size(146, 41);
_TextAlignment = StringAlignment.Center;
P1 = new Pen(Color.FromArgb(181, 41, 42)); // P1 = Border color
P3 = new Pen(Color.FromArgb(165, 37, 37)); // P3 = Border color when pressed
}
static public void DrawMorseText(Graphics g, GraphicsPath gp2, ref PointF pos, string sSplit, Font newFont, FontStyle fontStyle, StringAlignment stringAlign, RectangleF newLabelBounds)
{
string sText = TextExpression.GetTextWithoutTag(sSplit);
SizeF stringfSize = g.MeasureString(sText, newFont);
var format = new StringFormat {
Alignment = StringAlignment.Near
};
PointF posText = new PointF(pos.X, pos.Y);
float fHeightUsed = stringfSize.Height;
float fHeightUsedMorse = 0.0F;
float fWidthUsed = stringfSize.Width;
Font newFontMorse = new Font(new FontFamily("CGXAERO-MorseCode"), TextExpression.GetSizeFromTag(sSplit, newFont.SizeInPoints));
SizeF fSizeMorse = g.MeasureString(sText, newFontMorse);
float fMorsePos = pos.Y;
fWidthUsed += TextExpression.GetLargerMorseWidth(g, sText, TextExpression.GetSizeFromTag(sSplit, newFont.SizeInPoints));
if (stringAlign == StringAlignment.Center)
{
posText = new PointF((pos.X + newLabelBounds.Width / 2) - (fWidthUsed / 2) + 1, pos.Y);
}
if (stringAlign == StringAlignment.Far)
{
posText = new PointF((pos.X + newLabelBounds.Width) - (fWidthUsed + 3), pos.Y);
}
PointF posMorse = new PointF(posText.X + stringfSize.Width, posText.Y);
foreach (char c in sText)
{
//gp2.AddString(c.ToString(), new FontFamily("CGXAERO-MorseCode"), (int)fontStyle, newFont.Size * g.DpiY / 72F, posMorse, format);
g.DrawString(c.ToString(), newFontMorse, new SolidBrush(Color.Black), posMorse, format);
posMorse = new PointF(posMorse.X, posMorse.Y + fSizeMorse.Height);
fHeightUsedMorse += fSizeMorse.Height;
}
float fLargerHighOffset = fHeightUsed;
if (fHeightUsedMorse > fHeightUsed)
{
posText = new PointF(posText.X, posText.Y + (fHeightUsedMorse / 2) - stringfSize.Height / 2);
fLargerHighOffset = fHeightUsedMorse;
}
//gp2.AddString(sText + " ", newFont.FontFamily, (int)fontStyle, newFont.Size * g.DpiY / 72F, posText, format);
g.DrawString(sText + " ", newFont, new SolidBrush(Color.Black), posText, format);
pos.Y += fLargerHighOffset;
}
private static void DrawRect(IGraphics canvas, string id, Rectangle rect, StringAlignment horizontalAlignment, StringAlignment verticalAlignment)
{
var format = new StringFormat();
format.Alignment = horizontalAlignment;
format.LineAlignment = verticalAlignment;
format.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.NoClip;
var pen = new Pen(new SolidBrush(Color.Black), 1);
canvas.DrawRectangle(pen, rect);
var aFont = Control.DefaultFont;
var font = new Font(aFont.Name, RectFontSize, aFont.Style, aFont.Unit);
{
// Draw label
var labelFormat = new StringFormat();
labelFormat.Alignment = StringAlignment.Near;
labelFormat.LineAlignment = StringAlignment.Center;
labelFormat.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.NoClip;
var labelRect = new Rectangle(rect.X, rect.Y - RectGap, RectGap, RectGap);
var labelFont = new Font(aFont.Name, RectFontSize * 0.8f, aFont.Style, aFont.Unit);
canvas.DrawString(id, labelFont, new SolidBrush(Color.Black), labelRect, labelFormat);
}
canvas.DrawString("Helloy", font, new SolidBrush(Color.Blue), rect, format);
}
private void picSlider_Paint(object sender, PaintEventArgs e)
{
e.Graphics.Clear(BackColor);
// Any messages in case of any errors
string errorMessage = null;
if (Animation == null)
{
errorMessage = "No animation! Create or select animation to start editing.";
}
else if (Animation.DirectXAnimation.KeyFrames.Count == 0)
{
errorMessage = "No frames! Add some frames to start editing.";
}
if (!string.IsNullOrEmpty(errorMessage))
{
using (var b = new SolidBrush(Colors.DisabledText))
e.Graphics.DrawString(errorMessage, Font, b, ClientRectangle,
new StringFormat {
Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center
});
return;
}
e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
// Draw state change ranges
foreach (var sch in Animation.WadAnimation.StateChanges)
{
foreach (var disp in sch.Dispatches)
{
int realOutFrame = disp.OutFrame >= realFrameCount ? realFrameCount - 1 : disp.OutFrame;
e.Graphics.FillRectangle(_stateChangeBrush, new RectangleF(picSlider.Padding.Left + (disp.InFrame * frameStep),
picSlider.Padding.Top,
(realOutFrame - disp.InFrame) * frameStep,
picSlider.ClientSize.Height / _stateChangeMarkerThicknessDivider - picSlider.Padding.Bottom - 2));
}
}
int halfCursorWidth = (int)Math.Round(_cursorWidth / 2.0f);
// Shift the cursor at start/stop positions to prevent clipping
int addShift = -halfCursorWidth;
if (Value == 0)
{
addShift += halfCursorWidth;
}
else if (Value == Maximum)
{
addShift += -halfCursorWidth;
}
// Draw selection and highlight in 2 passes
for (int passes = 0; passes < 2; passes++)
{
int x = passes == 0 ? Selection.X : _highlightStart;
int y = passes == 0 ? Selection.Y : _highlightEnd;
int realX = ValueToX(x);
int realY = ValueToX(y);
int size = realY - realX;
if ((passes == 0 && !SelectionIsEmpty) || (passes == 1 && _highlightTimer.Enabled))
{
int width = size == 0 ? _cursorWidth : size + _cursorWidth;
Rectangle rect = new Rectangle(realX + picSlider.Padding.Left - halfCursorWidth, picSlider.Padding.Top, width, picSlider.ClientSize.Height - picSlider.Padding.Bottom);;
if (size == 0)
{
if (y != Minimum && y == Maximum)
{
rect.X -= halfCursorWidth;
}
else if (x == Minimum)
{
rect.X += halfCursorWidth;
}
}
else
{
if (x == Minimum)
{
rect.X += halfCursorWidth;
rect.Width -= halfCursorWidth;
}
if (y == Maximum)
{
rect.Width -= halfCursorWidth;
}
}
if (passes == 0)
{
e.Graphics.FillRectangle(_selectionBrush, rect);
e.Graphics.DrawRectangle(_selectionPen, rect);
}
else
{
using (SolidBrush currBrush = (SolidBrush)_highlightBrush.Clone())
{
currBrush.Color = Color.FromArgb((int)((float)currBrush.Color.A * _highlightCounter), currBrush.Color);
e.Graphics.FillRectangle(currBrush, rect);
}
}
}
}
// Measure maximum label size
SizeF maxLabelSize = TextRenderer.MeasureText(realFrameCount.ToString(), Font,
new Size(picSlider.Width - picSlider.Padding.Horizontal, picSlider.Height - picSlider.Padding.Vertical),
TextFormatFlags.WordBreak);
// Precache animcommands so we don't iterate them every drawn frame
var acList = new List <KeyValuePair <int, WadAnimCommand> >();
foreach (var ac in Animation.WadAnimation.AnimCommands.Where(ac => ac.FrameBased))
{
acList.Add(new KeyValuePair <int, WadAnimCommand>(ac.Parameter1, ac));
}
// Precache some variables for speeding up renderer with ultra-long animations (5000+ frames)
var step = frameStep;
var padding = picSlider.Padding;
var drawStepWidth = _keyFrameBorderPen.Width * 4;
// Draw frame-specific animcommands, numericals and dividers
for (int passes = 0; passes < 2; passes++)
{
for (int i = 0; i < realFrameCount; ++i)
{
int currX = (int)MathC.Round(step * i) + padding.Left;
bool isKeyFrame = (i % (Animation.WadAnimation.FrameRate == 0 ? 1 : Animation.WadAnimation.FrameRate) == 0);
bool first = i == 0;
bool last = i >= realFrameCount - 1;
if (passes == 0)
{
int count = 0;
// Draw animcommands
if (acList.Count > 0)
{
foreach (var acPair in acList)
{
var ac = acPair.Value;
Rectangle currRect = new Rectangle(currX - _animCommandMarkerRadius / 2, padding.Top - _animCommandMarkerRadius / 2 + (_animCommandMarkerRadius / 3 * count), _animCommandMarkerRadius, _animCommandMarkerRadius);
float startAngle = !first ? (!last ? 0 : 90) : 0;
float endAngle = !first ? (!last ? 180 : 90) : 90;
if (ac.Parameter1 == i)
{
using (SolidBrush currBrush = (SolidBrush)(ac.Type == WadAnimCommandType.PlaySound ? _animCommandSoundBrush : _animCommandFlipeffectBrush).Clone())
{
currBrush.Color = Color.FromArgb((int)((float)currBrush.Color.A / (1.0f + ((float)count / 3.0f))), currBrush.Color);
e.Graphics.FillPie(currBrush, currRect, startAngle, endAngle);
count++;
}
}
}
acList.RemoveAll(ac => ac.Key == i); // Remove already drawn animcommands from list
}
// Determine if current line should be drawn.
bool drawCurrentLine = true;
if (step < drawStepWidth)
{
int period = (int)MathC.Round(drawStepWidth / step);
if (i % period != 0 && i != realFrameCount - 1)
{
drawCurrentLine = false;
}
}
if (drawCurrentLine)
{
// Draw frame lines
e.Graphics.SmoothingMode = SmoothingMode.Default;
var lineHeight = picSlider.Height / (isKeyFrame ? 2 : 3);
if (isKeyFrame)
{
e.Graphics.DrawLine(_keyFrameBorderPen, currX, padding.Top, currX, lineHeight); // Draw keyframe
}
else
{
e.Graphics.DrawLine(_frameBorderPen, currX, padding.Top, currX, lineHeight); // Draw ordinary frame
}
e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
}
}
// Draw cursor on 2nd pass's first occurence (only for real animations, not for single-frame ones)
if (i == 0 && passes == 1 && realFrameCount > 1)
{
e.Graphics.FillRectangle(_cursorBrush, new RectangleF(ValueToX(Value) + addShift + padding.Left, padding.Top, _cursorWidth, picSlider.ClientSize.Height - padding.Bottom - 2));
}
// Draw labels
bool drawCurrentLabel = true;
if ((passes == 0 && !isKeyFrame) || (passes != 0 && isKeyFrame))
{
// Determine if labels are overlapping and decide on drawing
if (step < maxLabelSize.Width * 1.25)
{
int period = (int)MathC.Round(maxLabelSize.Width * 1.25 / step);
if (i % period != 0)
{
drawCurrentLabel = false;
}
}
if (drawCurrentLabel)
{
// Align first and last numerical entries so they are not concealed by control border
StringAlignment align = StringAlignment.Center;
int shift = 0;
if (first)
{
shift -= padding.Left;
align = StringAlignment.Near;
}
else if (last)
{
shift += padding.Left;
align = StringAlignment.Far;
}
// Finally draw it after all these tests
e.Graphics.DrawString(i.ToString(), Font, (isKeyFrame ? _lblKeyframeBrush : _lblFrameBrush), currX + shift, picSlider.Height,
new StringFormat {
Alignment = align, LineAlignment = StringAlignment.Far
});
}
}
}
}
// Draw horizontal guide (only for real anims, for single-frame anims we wouldn't wanna show that
if (realFrameCount > 1)
{
e.Graphics.SmoothingMode = SmoothingMode.Default;
e.Graphics.DrawLine(_keyFrameBorderPen, padding.Left, padding.Top + 1, picSlider.ClientSize.Width - padding.Left, padding.Top + 1);
}
}
public void AddTextBlock(StringAlignment alignment, List <string> content)
{
AddTextBlock(new TextBlock {
Alignment = alignment, Content = content
});
}
public static void DrawText(string text, QFont font, Color color, Vector4 bounds,
StringAlignment vAlign = StringAlignment.Near,
StringAlignment hAlign = StringAlignment.Near)
{
DrawText(text, font, color, new RectangleF(bounds.X, bounds.Y, bounds.Z, bounds.W), vAlign, hAlign);
}
public static void DrawString(this Graphics graphics, string text, Font font, Brush brush, Rectangle layoutRectangle, StringAlignment alignment, StringTrimming trimming)
{
graphics.DrawString(text, font, brush, layoutRectangle, new StringFormat {
Trimming = trimming, LineAlignment = alignment, Alignment = alignment
});
}
/// <summary>Retrieves the appropriate string format.</summary>
/// <param name="orientation">The orientation.</param>
/// <param name="alignment">The alignment.</param>
/// <param name="lineAlignment">The line Alignment.</param>
/// <returns>The <see cref="StringFormat" />.</returns>
public static StringFormat GetOrientedStringFormat(Orientation orientation, StringAlignment alignment, StringAlignment lineAlignment)
{
StringFormat orientedStringFormat;
switch (orientation)
{
case Orientation.Horizontal:
{
orientedStringFormat = new StringFormat {
Alignment = alignment, LineAlignment = lineAlignment
};
break;
}
case Orientation.Vertical:
{
orientedStringFormat = new StringFormat(StringFormatFlags.DirectionVertical);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
return(orientedStringFormat);
}
private static void annotate(XGraphics graphics, Palette palette, LineSegment lineSegment, TextBlock text, StringAlignment alignment)
{
Vector point;
var delta = lineSegment.Delta;
switch (alignment)
{
default:
point = lineSegment.Start;
delta.Negate();
break;
case StringAlignment.Center:
point = lineSegment.Mid;
break;
case StringAlignment.Far:
point = lineSegment.End;
break;
}
var bounds = new Rect(point, Vector.Zero);
bounds.Inflate(Settings.TextOffsetFromConnection);
float angle;
var compassPoint = CompassPointHelper.DirectionFromAngle(out angle, delta);
var pos = bounds.GetCorner(compassPoint);
var format = new XStringFormat();
Drawing.SetAlignmentFromCardinalOrOrdinalDirection(format, compassPoint);
if (alignment == StringAlignment.Center && Numeric.InRange(angle, -10, 10))
{
// HACK: if the line segment is pretty horizontal and we're drawing mid-line text,
// move text below the line to get it out of the way of any labels at the ends,
// and center the text so it fits onto a line between two proximal rooms.
pos = bounds.GetCorner(CompassPoint.South);
format.Alignment = XStringAlignment.Center;
format.LineAlignment = XLineAlignment.Near;
}
if (!Settings.DebugDisableTextRendering)
{
text.Draw(graphics, Settings.SubtitleFont, palette.LineTextBrush, pos, Vector.Zero, format);
}
}
static StringFormat CreateTipStringFormat(StringAlignment horizontalAlignment, StringAlignment verticalAlignment)
{
StringFormat format = (StringFormat)StringFormat.GenericTypographic.Clone();
format.FormatFlags = StringFormatFlags.FitBlackBox | StringFormatFlags.MeasureTrailingSpaces;
// note: Align Near, Line Center seemed to do something before
format.Alignment = horizontalAlignment;
format.LineAlignment = verticalAlignment;
return(format);
}
/// <summary>
/// Draws hand-drawn-looking highlighter color stick lines on top of text. The text itself is not drawn.
/// Text may span multiple lines
/// </summary>
/// <param name="gr">Graphical context</param>
/// <param name="rect">Bounding rectangle</param>
/// <param name="font">Font to measure text in</param>
/// <param name="text">Text to measure, the text is not drawn rather charecters position is determined</param>
/// <param name="align">Text alignment</param>
/// <param name="color">Color of highlighter including opacity</param>
public static void DrawTextHighlight(System.Drawing.Graphics gr,
Rectangle rect,
Font font,
string text,
StringAlignment align,
Color color)
{
Rectangle textRect;
int lineHeight;
using (StringFormat fmt = new StringFormat())
{
fmt.Alignment = align;
SizeF size = gr.MeasureString(text, font, new SizeF(rect.Width, rect.Height), fmt);
lineHeight = (int)gr.MeasureString("`~_W", font).Height;
if (//RIGHT
(align == StringAlignment.Near && Thread.CurrentThread.CurrentUICulture.TextInfo.IsRightToLeft) ||
(align == StringAlignment.Far)
)
{
textRect = new Rectangle(rect.Right - (int)size.Width,
rect.Top,
(int)size.Width, (int)size.Height);
}
else
if (align == StringAlignment.Center)
{
textRect = new Rectangle(rect.Left + (rect.Width / 2) - (int)size.Width / 2,
rect.Location.Y,
(int)size.Width, (int)size.Height);
}
else//LEFT
{
textRect = new Rectangle(rect.Left, rect.Top, (int)size.Width, (int)size.Height);
}
}
textRect.Inflate(lineHeight, 0);
if (textRect.Left < rect.Left)
{
textRect.X = rect.Left;
}
if (textRect.Right > rect.Right)
{
textRect.Width -= textRect.Right - rect.Right;
}
Rectangle brRect = textRect;//gets rid of brush wrap
brRect.Inflate(lineHeight / 2, lineHeight / 2);
using (LinearGradientBrush br =
new LinearGradientBrush(brRect,
color,
Color.FromArgb(16, Color.Silver),
(align == StringAlignment.Far) ? 180f : 360f))
{
gr.SmoothingMode = SmoothingMode.AntiAlias;
Random rnd = new Random();
//gr.DrawRectangle(Pens.Red, textRect);
int y = textRect.Top + lineHeight / 2;
Point[] pnt = new Point[4];
while (y /*+ lineHeight / 2*/ < textRect.Bottom)
{
pnt[0] = new Point(textRect.Left, y - lineHeight / 2);
pnt[1] = new Point(textRect.Right - lineHeight / 2, y - lineHeight / 2);
pnt[2] = new Point(textRect.Right - lineHeight, y + lineHeight / 2);
pnt[3] = new Point(textRect.Left + lineHeight / 2, y + lineHeight / 2);
for (int i = 0; i < pnt.Length; i++)
{
pnt[i].Offset(rnd.Next(0, 2), rnd.Next(-2, 2));
}
gr.FillClosedCurve(br, pnt, FillMode.Alternate, 0.07f + (float)(rnd.NextDouble() / 6d));
y += lineHeight + 2;//1 px padding top and bottom
}
}//using brush
}
protected static void DrawString(Graphics graphics, RectangleF layoutRectangle, Font font, Color fontColor, string strText, RightToLeft rightToLeft, StringAlignment stringAlignment)
{
if (graphics == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, Resources.IDS_ArgumentException, new object[1]
{
typeof(Graphics).Name
}));
}
using (SolidBrush brush = new SolidBrush(fontColor))
{
using (StringFormat stringFormat = new StringFormat())
{
stringFormat.FormatFlags = StringFormatFlags.NoWrap;
if (rightToLeft == RightToLeft.Yes)
{
stringFormat.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
}
stringFormat.Trimming = StringTrimming.EllipsisCharacter;
stringFormat.LineAlignment = StringAlignment.Center;
stringFormat.Alignment = stringAlignment;
graphics.DrawString(strText, font, brush, layoutRectangle, stringFormat);
}
}
}
private bool HitTest1D(ref float point, float location, float size, float maxSize, StringAlignment alignment)
{
if (alignment == StringAlignment.Far)
{
location += maxSize - size;
}
else if (alignment == StringAlignment.Center)
{
location += (maxSize - size) * 0.5f;
}
float old = point;
point = Range.PutInRange(point, location, location + size);
return(point == old);
}
public void SetJustify(StringAlignment horizontal, StringAlignment vertical = StringAlignment.Near)
{
Justify = Justification(horizontal, vertical);
}
private static StatusBarElement createStatusBarElement(StatusBarElementType elementType, StatusBarElementSize statusBarElementSize, StatusBarElementAlignment statusBarElementAlignment, int width, StringAlignment textAlignment = StringAlignment.Near)
{
var statusBarElement = new StatusBarElement(elementType, statusBarElementSize, statusBarElementAlignment, width, textAlignment)
{
Index = _allElements.Count
};
_allElements.Add(statusBarElement);
return statusBarElement;
}
static public void Label(Rectangle rect, string text, StringAlignment sa)
{
Label(rect, text, 20, sa);
}
public void DrawStringLine(Graphics g, string text, Font font, Rectangle textRect, Color textColor, StringAlignment align = StringAlignment.Near, StringAlignment lineAlign = StringAlignment.Center, StringTrimming trimming = StringTrimming.EllipsisCharacter)
{
if (textRect.Width < 1 || textRect.Height < 1)
{
return;
}
if (text == null)
{
return;
}
// Expand text rect, because DrawString stops too soon
textRect.Y += GetFontYOffset(font);
textRect.Width += DrawStringWidthAdd;
textRect.Height = Math.Max(textRect.Height, font.Height);
bool manualEllipsis = trimming == StringTrimming.EllipsisCharacter || trimming == StringTrimming.EllipsisWord;
if (trimming == StringTrimming.EllipsisCharacter)
{
trimming = StringTrimming.Character;
}
if (trimming == StringTrimming.EllipsisWord)
{
trimming = StringTrimming.Word;
}
if (manualEllipsis)
{
textRect.Width -= 5;
}
StringFormat nameLabelFormat = StringFormat.GenericDefault;
nameLabelFormat.Alignment = align;
nameLabelFormat.LineAlignment = lineAlign;
nameLabelFormat.Trimming = trimming;
nameLabelFormat.FormatFlags |= StringFormatFlags.NoWrap;
int charsFit, lines;
SizeF nameLabelSize = g.MeasureString(text, font, textRect.Size, nameLabelFormat, out charsFit, out lines);
bool isEllipsisActive = charsFit < text.Length && manualEllipsis;
if (textRect.Width >= 1)
{
g.DrawString(text, font, new SolidBrush(textColor), textRect, nameLabelFormat);
}
if (isEllipsisActive)
{
Pen ellipsisPen = new Pen(textColor);
ellipsisPen.DashStyle = DashStyle.Dot;
g.DrawLine(ellipsisPen,
textRect.Right - DrawStringWidthAdd,
(textRect.Y + textRect.Height * 0.5f) + (nameLabelSize.Height * 0.3f),
textRect.Right - DrawStringWidthAdd + 3,
(textRect.Y + textRect.Height * 0.5f) + (nameLabelSize.Height * 0.3f));
}
}
public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
{
m_ePreviousStringAlignment = zProcessData.CurrentStringAlignment;
zProcessData.CurrentStringAlignment = MarkupAlignment;
return(false);
}
internal MonthViewBoxEventArgs(Graphics g, Rectangle bounds, string text, StringAlignment textAlign, Color textColor)
: this(g, bounds, text, textAlign, textColor, Color.Empty, Color.Empty)
{
}
public static void Label(System.Windows.Forms.PaintEventArgs pe, Rectangle area, string text, Font font, StringAlignment horizontalAlignment, StringAlignment verticalAlignment, Color color, bool selected)
{
StringFormat format = new StringFormat();
format.Alignment = horizontalAlignment;
format.LineAlignment = verticalAlignment;
pe.Graphics.DrawString(text, font, new SolidBrush(color), area, format);
if (selected)
{
pe.Graphics.DrawRectangle(new System.Drawing.Pen(Color.Blue, 1f), area);
}
}
public IStringLayout CreateStringLayout(string pString, string pFont, float pSize, StringAlignment pAlignment)
{
return(new OpenGLStringLayout(pString, pFont, pSize, pAlignment));
}
/// <summary>Renders the text reflection.</summary>
/// <param name="graphics">The specified graphics to draw on.</param>
/// <param name="orientation">The orientation.</param>
/// <param name="text">The text to draw.</param>
/// <param name="font">The font to draw.</param>
/// <param name="color">The fore color.</param>
/// <param name="clientRectangle">The client rectangle.</param>
/// <param name="spacing">The reflection spacing.</param>
/// <param name="offset">The location offset.</param>
/// <param name="alignment">The alignment.</param>
/// <param name="lineAlignment">The line Alignment.</param>
public static void RenderTextReflection(Graphics graphics, Orientation orientation, string text, Font font, Color color, Rectangle clientRectangle, int spacing, Point offset, StringAlignment alignment, StringAlignment lineAlignment)
{
Point reflectionLocation;
Bitmap reflectionBitmap = new Bitmap(clientRectangle.Width, clientRectangle.Height);
Graphics imageGraphics = Graphics.FromImage(reflectionBitmap);
// Setup text render
imageGraphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
// Rotate reflection
switch (orientation)
{
case Orientation.Horizontal:
{
imageGraphics.TranslateTransform(0, StringUtil.MeasureText(text, font, graphics).Height);
imageGraphics.ScaleTransform(1, -1);
reflectionLocation = new Point(0, offset.Y - (StringUtil.MeasureText(text, font, graphics).Height / 2) - spacing);
break;
}
case Orientation.Vertical:
{
imageGraphics.ScaleTransform(-1, 1);
reflectionLocation = new Point((offset.X - (StringUtil.MeasureText(text, font, graphics).Width / 2)) + spacing, 0);
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(orientation));
}
}
// Draw reflected string
imageGraphics.DrawString(text, font, new SolidBrush(color), reflectionLocation, GetOrientedStringFormat(orientation, alignment, lineAlignment));
// Draw the reflection image
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.DrawImage(reflectionBitmap, clientRectangle, 0, 0, reflectionBitmap.Width, reflectionBitmap.Height, GraphicsUnit.Pixel);
graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
}
private static void PrintImage(Surface surface, float left, float width, Line line, StringAlignment alignment)
{
Graphics g = surface.Graphics;
Image image = ((ImageNode)line.Node).Image;
float w = image.Width;
float h = image.Height;
float x = left;
if (w < width)
{
switch (alignment)
{
case StringAlignment.Near:
break;
case StringAlignment.Center:
x += (width - image.Width) / 2;
break;
case StringAlignment.Far:
x += (width - image.Width);
break;
}
}
else // Scale down image to fit into available width
{
h = h * (width / w);
w = width;
}
g.DrawImage(image, x, surface.CurrentY, w, h);
surface.CurrentY += h;
}
// Token: 0x060003BD RID: 957 RVA: 0x000036DF File Offset: 0x000018DF
static void smethod_17(StringFormat stringFormat_2, StringAlignment stringAlignment_0)
{
stringFormat_2.LineAlignment = stringAlignment_0;
}
/// <summary>
/// Create content based on text data. Chinese won't be rotated.
/// </summary>
/// <param name="text">Text data.</param>
/// <param name="autoFit">Auto fit.</param>
/// <param name="aligment">Alignment.</param>
/// <returns>The btimap</returns>
public Bitmap CreateContent(string text, bool autoFit = true, StringAlignment aligment = StringAlignment.Center)
{
//int calWidth = Horizontal ? Width : Height;
//int calHeight = Horizontal ? Height : Width;
//Bitmap textBitmap = new Bitmap(Width, Height);
Horizontal = true;
int calWidth = 80;
int calHeight = 64;
Bitmap textBitmap = Horizontal ? new Bitmap(calWidth, calHeight) : new Bitmap(calHeight, calWidth);
Font font = new Font("宋体", 9f);
Graphics textG = Graphics.FromImage(textBitmap);
textG.FillRectangle(new SolidBrush(Color.Black), 0, 0, textBitmap.Width, textBitmap.Height);
textG.DrawString(text, font, Brushes.White, new PointF()
{
X = 0, Y = 0
});
string b = string.Join("", Enumerable.Range(0, 5120).Select(a => new { x = a % 80, y = a / 80 })
.Select(x => textBitmap.GetPixel(x.x, x.y).GetBrightness() > 0.5f ? "1" : "0"));
//textBox5.Text += b;
textBitmap.Save("1.bmp");
DisplayFont = new Font("宋体", 12, FontStyle.Regular);
Font textFont = DisplayFont;
SizeF textSize = textG.MeasureString(text, textFont);
Font tempFont = DisplayFont;
if (autoFit)
{
if (textSize.Width < calWidth && textSize.Height < calHeight)
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size + (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Width < calWidth && textSize.Height < calHeight);
textSize = textG.MeasureString(text, textFont);
}
else
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size - (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Width >= calHeight || textSize.Height >= calHeight);
textFont = tempFont;
}
}
else
{
if (textSize.Height < DisplayFont.Size)
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size + (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Height < DisplayFont.Size);
textFont = tempFont;
}
else
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size - (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Height >= DisplayFont.Size);
textFont = tempFont;
}
}
StringFormat textFormat = new StringFormat();
textFormat.Alignment = aligment;
textFormat.LineAlignment = StringAlignment.Center;
if (Horizontal) // 横屏
{
float x = 0.0f;
float y = textBitmap.Height / 2 + textBitmap.Height / 16;
switch (aligment)
{
case StringAlignment.Near:
x = 1;
break;
case StringAlignment.Center:
x = textBitmap.Width / 2;
break;
case StringAlignment.Far:
x = textBitmap.Width - 1;
break;
}
textG.DrawString(
text,
textFont,
new SolidBrush(ForeColor),
x,
y,
textFormat);
}
else // 竖屏
{
//float x = textBitmap.Width / 2 - textBitmap.Width / 16;
float x = textBitmap.Width / 2;
float y = 0.0f;
switch (aligment)
{
case StringAlignment.Near:
y = 2;
break;
case StringAlignment.Center:
y = textBitmap.Height / 2;
break;
case StringAlignment.Far:
y = textBitmap.Height - 2;
break;
}
textFormat.FormatFlags = StringFormatFlags.DirectionVertical;
textG.DrawString(
text,
textFont,
new SolidBrush(ForeColor),
x,
y,
textFormat);
}
// 竖屏
if (!Horizontal)
{
textBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
}
return(textBitmap);
}
public StringFormat SetPosition(StringAlignment horizontal = StringAlignment.Center, StringAlignment vertical = StringAlignment.Center)
{
return(new StringFormat
{
Alignment = horizontal,
LineAlignment = vertical
});
}
/// <summary>
/// Create content based on text data. Chinese will be rotated.
/// </summary>
/// <param name="text">Text data.</param>
/// <param name="autoFit">Auto fit.</param>
/// <param name="aligment">Alignment.</param>
/// <returns>The btimap</returns>
public Bitmap CreateContent2(string text, bool autoFit = true, StringAlignment aligment = StringAlignment.Center)
{
Bitmap textBitmap = new Bitmap(Width, Height);
Graphics textG = Graphics.FromImage(textBitmap);
textG.FillRectangle(new SolidBrush(Color.Black), 0, 0, textBitmap.Width, textBitmap.Height);
Font textFont = DisplayFont;
SizeF textSize = textG.MeasureString(text, textFont);
Font tempFont = DisplayFont;
if (autoFit)
{
if (textSize.Width < Width && textSize.Height < Height)
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size + (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Width < Width && textSize.Height < Height);
textSize = textG.MeasureString(text, textFont);
}
else
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size - (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Width >= Width || textSize.Height >= Height);
textFont = tempFont;
}
}
else
{
if (textSize.Height < DisplayFont.Size)
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size + (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Height < DisplayFont.Size);
textFont = tempFont;
}
else
{
do
{
textFont = tempFont;
tempFont = new Font(DisplayFont.FontFamily, textFont.Size - (float)0.2);
textSize = textG.MeasureString(text, tempFont);
}while (textSize.Height >= DisplayFont.Size);
textFont = tempFont;
}
}
StringFormat textFormat = new StringFormat();
textFormat.Alignment = aligment;
textFormat.LineAlignment = StringAlignment.Center;
// 横屏
float x = 0.0f;
float y = textBitmap.Height / 2 + textBitmap.Height / 16;
switch (aligment)
{
case StringAlignment.Near:
x = 1;
break;
case StringAlignment.Center:
x = textBitmap.Width / 2;
break;
case StringAlignment.Far:
x = textBitmap.Width - 1;
break;
}
textG.DrawString(
text,
textFont,
new SolidBrush(ForeColor),
x,
y,
textFormat);
// 竖屏
if (!Horizontal)
{
textBitmap.RotateFlip(RotateFlipType.Rotate90FlipNone);
}
return(textBitmap);
}
/// <summary>
/// Resets the PanelBorder property to its default value.
/// </summary>
public void ResetAlignment()
{
Alignment = StringAlignment.Near;
}
static public void Label(Rectangle rect, string text, int fontSize, StringAlignment sa)
{
Label(rect, text, fontSize, sa, Color.White);
}
public int PickCharStringLine(string text, Font font, Rectangle textRect, Point pickLoc, StringAlignment align = StringAlignment.Near, StringAlignment lineAlign = StringAlignment.Center)
{
if (text == null)
{
return(-1);
}
if (!textRect.Contains(pickLoc))
{
return(-1);
}
// Expand text rect, because DrawString stops too soon
textRect.Width += DrawStringWidthAdd;
textRect.Height = Math.Max(textRect.Height, font.Height);
// Assume manual ellipsis
textRect.Width -= 5;
StringFormat nameLabelFormat = StringFormat.GenericDefault;
nameLabelFormat.Alignment = align;
nameLabelFormat.LineAlignment = lineAlign;
nameLabelFormat.Trimming = StringTrimming.Character;
nameLabelFormat.FormatFlags |= StringFormatFlags.LineLimit;
nameLabelFormat.FormatFlags |= StringFormatFlags.NoWrap | StringFormatFlags.MeasureTrailingSpaces;
RectangleF pickRect = new RectangleF(textRect.X, textRect.Y, pickLoc.X - textRect.X, textRect.Height);
using (var image = new Bitmap(1, 1)) { using (var g = Graphics.FromImage(image)) {
// Pick chars
float oldUsedWidth = 0.0f;
SizeF usedSize = SizeF.Empty;
for (int i = 0; i <= text.Length; i++)
{
oldUsedWidth = usedSize.Width;
nameLabelFormat.SetMeasurableCharacterRanges(new [] { new CharacterRange(0, i) });
Region[] usedSizeRegions = g.MeasureCharacterRanges(text, font, textRect, nameLabelFormat);
usedSize = usedSizeRegions.Length > 0 ? usedSizeRegions[0].GetBounds(g).Size : SizeF.Empty;
if (usedSize.Width > pickRect.Width)
{
if (Math.Abs(oldUsedWidth - pickRect.Width) < Math.Abs(usedSize.Width - pickRect.Width))
{
return(i - 1);
}
else
{
return(i);
}
}
}
} }
return(-1);
}
public Region[] MeasureStringLine(Graphics g, string text, CharacterRange[] measureRanges, Font font, Rectangle textRect, StringAlignment align = StringAlignment.Near, StringAlignment lineAlign = StringAlignment.Center)
{
// Expand text rect, because DrawString stops too soon
textRect.Width += DrawStringWidthAdd;
textRect.Height = Math.Max(textRect.Height, font.Height);
// Assume manual ellipsis
textRect.Width -= 5;
StringFormat nameLabelFormat = StringFormat.GenericDefault;
nameLabelFormat.Alignment = align;
nameLabelFormat.LineAlignment = lineAlign;
nameLabelFormat.Trimming = StringTrimming.Character;
nameLabelFormat.FormatFlags |= StringFormatFlags.NoWrap | StringFormatFlags.MeasureTrailingSpaces;
nameLabelFormat.SetMeasurableCharacterRanges(measureRanges);
return(g.MeasureCharacterRanges(text, font, textRect, nameLabelFormat));
}
