private void OnItemSelectedCommandExecute(object parameter)
{
if ((parameter as ItemSelectedEventArgs).Item is INode)
{
NodeViewModel node = (parameter as ItemSelectedEventArgs).Item as NodeViewModel;
foreach (IAnnotation annotation in node.Annotations as ObservableCollection <IAnnotation> )
{
this.FontFamilyValue = (annotation as TextAnnotationViewModel).FontFamily;
this.FontColor = (annotation as TextAnnotationViewModel).Foreground;
this.TextSize = (annotation as TextAnnotationViewModel).FontSize;
this.TextWrapValue = (annotation as TextAnnotationViewModel).TextWrapping;
this.TextTrimmingValue = (annotation as TextAnnotationViewModel).TextTrimming;
}
}
else if ((parameter as ItemSelectedEventArgs).Item is IConnector)
{
ConnectorViewModel connector = (parameter as ItemSelectedEventArgs).Item as ConnectorViewModel;
foreach (IAnnotation annotation in connector.Annotations as ObservableCollection <IAnnotation> )
{
this.FontFamilyValue = (annotation as TextAnnotationViewModel).FontFamily;
this.FontColor = (annotation as TextAnnotationViewModel).Foreground;
this.TextSize = (annotation as TextAnnotationViewModel).FontSize;
this.TextWrapValue = (annotation as TextAnnotationViewModel).TextWrapping;
this.TextTrimmingValue = (annotation as TextAnnotationViewModel).TextTrimming;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TextLayout" /> class.
/// </summary>
/// <param name="text">The text.</param>
/// <param name="typeface">The typeface.</param>
/// <param name="fontSize">Size of the font.</param>
/// <param name="foreground">The foreground.</param>
/// <param name="textAlignment">The text alignment.</param>
/// <param name="textWrapping">The text wrapping.</param>
/// <param name="textTrimming">The text trimming.</param>
/// <param name="textDecorations">The text decorations.</param>
/// <param name="maxWidth">The maximum width.</param>
/// <param name="maxHeight">The maximum height.</param>
/// <param name="lineHeight">The height of each line of text.</param>
/// <param name="maxLines">The maximum number of text lines.</param>
/// <param name="textStyleOverrides">The text style overrides.</param>
public TextLayout(
string text,
Typeface typeface,
double fontSize,
IBrush foreground,
TextAlignment textAlignment = TextAlignment.Left,
TextWrapping textWrapping = TextWrapping.NoWrap,
TextTrimming textTrimming = TextTrimming.None,
TextDecorationCollection textDecorations = null,
double maxWidth = double.PositiveInfinity,
double maxHeight = double.PositiveInfinity,
double lineHeight = double.NaN,
int maxLines = 0,
IReadOnlyList <ValueSpan <TextRunProperties> > textStyleOverrides = null)
{
_text = string.IsNullOrEmpty(text) ?
new ReadOnlySlice <char>() :
new ReadOnlySlice <char>(text.AsMemory());
_paragraphProperties =
CreateTextParagraphProperties(typeface, fontSize, foreground, textAlignment, textWrapping, textTrimming,
textDecorations, lineHeight);
_textStyleOverrides = textStyleOverrides;
LineHeight = lineHeight;
MaxWidth = maxWidth;
MaxHeight = maxHeight;
MaxLines = maxLines;
UpdateLayout();
}
public override void Deserialize(XElement itemXML, double OffsetX, double OffsetY)
{
base.Deserialize(itemXML, OffsetX, OffsetY);
try
{
this.Text = itemXML.Attribute("Text").Value as string;
}
catch { }
try
{
this.LineHeight = Double.Parse(itemXML.Attribute("LineHeight").Value, CultureInfo.InvariantCulture);
this.FontFamily = new FontFamily(itemXML.Attribute("FontFamily").Value);
this.FontSize = Double.Parse(itemXML.Attribute("FontSize").Value, CultureInfo.InvariantCulture);
}
catch { }
try
{
this.HorizontalContentAlignment = (HorizontalAlignment)(Enum.Parse(typeof(HorizontalAlignment), itemXML.Attribute("HorizontalContentAlignment").Value, true));
this.VerticalContentAlignment = (VerticalAlignment)(Enum.Parse(typeof(VerticalAlignment), itemXML.Attribute("VerticalContentAlignment").Value, true));
this.TextAlignment = (TextAlignment)(Enum.Parse(typeof(TextAlignment), itemXML.Attribute("TextAlignment").Value, true));
this.TextWrapping = (TextWrapping)(Enum.Parse(typeof(TextWrapping), itemXML.Attribute("TextWrapping").Value, true));
this.TextTrimming = (TextTrimming)(Enum.Parse(typeof(TextTrimming), itemXML.Attribute("TextTrimming").Value, true));
}
catch { }
try
{
this.Foreground = itemXML.Attribute("Foreground").Value != "" ? XamlReader.Parse(itemXML.Attribute("Foreground").Value) as Brush : null;
this.FontWeight = (FontWeight)(new FontWeightConverter().ConvertFromString(itemXML.Attribute("FontWeight").Value));
this.FontStyle = (FontStyle)(new FontStyleConverter().ConvertFromString(itemXML.Attribute("FontStyle").Value));
}
catch { }
}
static TextElementFlags GetTextFlags(object ownerControl)
{
TextTrimming textTrimming = TextTrimming.None;
TextWrapping textWrapping = TextWrapping.NoWrap;
if (ownerControl is TextControl textControl)
{
textTrimming = textControl.TextTrimming;
textWrapping = textControl.TextWrapping;
}
TextElementFlags flags = 0;
switch (textTrimming)
{
case TextTrimming.None: flags |= TextElementFlags.NoTrimming; break;
case TextTrimming.CharacterEllipsis: flags |= TextElementFlags.CharacterEllipsis; break;
case TextTrimming.WordEllipsis: flags |= TextElementFlags.WordEllipsis; break;
default: Debug.Fail($"Unknown trimming: {textTrimming}"); break;
}
switch (textWrapping)
{
case TextWrapping.WrapWithOverflow: flags |= TextElementFlags.WrapWithOverflow; break;
case TextWrapping.NoWrap: flags |= TextElementFlags.NoWrap; break;
case TextWrapping.Wrap: flags |= TextElementFlags.Wrap; break;
default: Debug.Fail($"Unknown wrapping: {textWrapping}"); break;
}
return(flags);
}
/// <summary>
/// Initializes a new instance of the <see cref="TextLayout" /> class.
/// </summary>
/// <param name="text">The text.</param>
/// <param name="typeface">The typeface.</param>
/// <param name="fontSize">Size of the font.</param>
/// <param name="foreground">The foreground.</param>
/// <param name="textAlignment">The text alignment.</param>
/// <param name="textWrapping">The text wrapping.</param>
/// <param name="textTrimming">The text trimming.</param>
/// <param name="textDecorations">The text decorations.</param>
/// <param name="flowDirection">The text flow direction.</param>
/// <param name="maxWidth">The maximum width.</param>
/// <param name="maxHeight">The maximum height.</param>
/// <param name="lineHeight">The height of each line of text.</param>
/// <param name="maxLines">The maximum number of text lines.</param>
/// <param name="textStyleOverrides">The text style overrides.</param>
public TextLayout(
string?text,
Typeface typeface,
double fontSize,
IBrush?foreground,
TextAlignment textAlignment = TextAlignment.Left,
TextWrapping textWrapping = TextWrapping.NoWrap,
TextTrimming?textTrimming = null,
TextDecorationCollection?textDecorations = null,
FlowDirection flowDirection = FlowDirection.LeftToRight,
double maxWidth = double.PositiveInfinity,
double maxHeight = double.PositiveInfinity,
double lineHeight = double.NaN,
int maxLines = 0,
IReadOnlyList <ValueSpan <TextRunProperties> >?textStyleOverrides = null)
{
_paragraphProperties =
CreateTextParagraphProperties(typeface, fontSize, foreground, textAlignment, textWrapping,
textDecorations, flowDirection, lineHeight);
_textSource = new FormattedTextSource(text.AsMemory(), _paragraphProperties.DefaultTextRunProperties, textStyleOverrides);
_textTrimming = textTrimming ?? TextTrimming.None;
LineHeight = lineHeight;
MaxWidth = maxWidth;
MaxHeight = maxHeight;
MaxLines = maxLines;
TextLines = CreateTextLines();
}
private void NotifyCellCharacterEllipsisChanged(TextTrimming newvalue)
{
if (tb.IsNotNull())
{
tb.TextTrimming = newvalue;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TextLayout" /> class.
/// </summary>
/// <param name="textSource">The text source.</param>
/// <param name="paragraphProperties">The default text paragraph properties.</param>
/// <param name="textTrimming">The text trimming.</param>
/// <param name="maxWidth">The maximum width.</param>
/// <param name="maxHeight">The maximum height.</param>
/// <param name="lineHeight">The height of each line of text.</param>
/// <param name="maxLines">The maximum number of text lines.</param>
public TextLayout(
ITextSource textSource,
TextParagraphProperties paragraphProperties,
TextTrimming?textTrimming = null,
double maxWidth = double.PositiveInfinity,
double maxHeight = double.PositiveInfinity,
double lineHeight = double.NaN,
int maxLines = 0)
{
_textSource = textSource;
_paragraphProperties = paragraphProperties;
_textTrimming = textTrimming ?? TextTrimming.None;
LineHeight = lineHeight;
MaxWidth = maxWidth;
MaxHeight = maxHeight;
MaxLines = maxLines;
TextLines = CreateTextLines();
}
/// <summary>
/// Method to change the text trimming value of the annotation.
/// </summary>
/// <param name="value"></param>
private void OnTextTrimmingChanged(TextTrimming value)
{
foreach (NodeViewModel node in (this.SelectedItems as SelectorViewModel).Nodes as IEnumerable <object> )
{
foreach (IAnnotation annotation in node.Annotations as ObservableCollection <IAnnotation> )
{
(annotation as TextAnnotationViewModel).TextTrimming = value;
if (value != TextTrimming.None && (annotation as TextAnnotationViewModel).TextWrapping == TextWrapping.NoWrap)
{
annotation.UnitWidth = 100;
}
else
{
annotation.UnitWidth = double.NaN;
}
}
}
foreach (ConnectorViewModel conn in (this.SelectedItems as SelectorViewModel).Connectors as IEnumerable <object> )
{
foreach (IAnnotation annotation in conn.Annotations as ObservableCollection <IAnnotation> )
{
(annotation as TextAnnotationViewModel).TextTrimming = value;
if (value != TextTrimming.None && (annotation as TextAnnotationViewModel).TextWrapping == TextWrapping.NoWrap)
{
annotation.UnitWidth = 100;
}
else
{
annotation.UnitWidth = double.NaN;
}
}
}
}
public WpfTextStringFormat(FlowDirection direction, TextTrimming trimming,
WpfTextAnchor anchor)
{
this.Direction = direction;
this.Trimming = trimming;
this.Anchor = anchor;
}
public void When_DefaultTextBlock_Clip(TextTrimming trimmingMode)
{
var SUT = new TextBlockMeasureCache();
var tb = new TextBlock {
Text = "42", TextTrimming = trimmingMode
}; // Used as key, never measured
SUT.CacheMeasure(tb, new Size(200, 100), new Size(125, 25));
SUT.CacheMeasure(tb, new Size(100, 100), new Size(100, 50));
SUT.CacheMeasure(tb, new Size(75, 100), new Size(75, 100));
SUT.CacheMeasure(tb, new Size(50, 100), new Size(50, 100));
Assert.AreEqual(
new Size(125, 25),
SUT.FindMeasuredSize(tb, new Size(125, 100))
);
Assert.AreEqual(
new Size(50, 100),
SUT.FindMeasuredSize(tb, new Size(50, 70))
);
Assert.AreEqual(
null,
SUT.FindMeasuredSize(tb, new Size(52, 70))
);
Assert.AreEqual(
null,
SUT.FindMeasuredSize(tb, new Size(500, 500))
);
}
/// <summary>
/// Allocates or re-alocates this resource.
/// </summary>
/// <param name="boxWidth"></param>
/// <param name="wrap"></param>
public void Allocate(float boxWidth, float boxHeight, bool wrap, TextTrimming textTrimming)
{
if (String.IsNullOrEmpty(_text))
{
DisposeBuffer();
return;
}
if (_font == null)
{
return;
}
// Get text quads
string[] lines = GetLines(boxWidth, boxHeight, wrap, textTrimming);
PositionColoredTextured[] verts = _font.CreateText(lines, _fontSize, true, out _lastTextSize, out _textLines);
// Re-use existing buffer if necessary
_buffer.Set(ref verts, PrimitiveType.TriangleList);
// Preserve state
_lastTextBoxWidth = boxWidth;
_lastWrap = wrap;
_lastTextTrimming = textTrimming;
_textChanged = false;
}
public WpfTextStringFormat(FlowDirection direction, TextTrimming trimming,
WpfTextAnchor anchor)
{
this.Direction = direction;
this.Trimming = trimming;
this.Anchor = anchor;
}
public TextRenderHelper()
{
List <char> list = new List <char>();
list.Add(',');
list.Add('.');
list.Add('。');
list.Add('、');
this.delimiters = list;
// base..ctor(); //FIXME:???
this.Font = UISystem.DefaultFont;
this.horizontalAlignment = HorizontalAlignment.Center;
this.verticalAlignment = VerticalAlignment.Middle;
this.horizontalOffset = 0f;
this.verticalOffset = 0f;
this.lineBreak = LineBreak.Character;
this.textTrimming = TextTrimming.None;
this.lineGap = 0f;
Dictionary <LineBreak, TextRenderHelper.ReflectLineBreak> dictionary = new Dictionary <LineBreak, TextRenderHelper.ReflectLineBreak>();
dictionary.Add(LineBreak.Character, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakCharacter));
dictionary.Add(LineBreak.Word, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakWord));
dictionary.Add(LineBreak.Hyphenation, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakHyphenation));
dictionary.Add(LineBreak.AtCode, new TextRenderHelper.ReflectLineBreak(this.ReflectLineBreakAtCode));
this.ReflectLineBreakFuncs = dictionary;
Dictionary <TextTrimming, TextRenderHelper.ReflectTextTrimming> dictionary2 = new Dictionary <TextTrimming, TextRenderHelper.ReflectTextTrimming>();
dictionary2.Add(TextTrimming.None, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingNone));
dictionary2.Add(TextTrimming.Character, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingCharacter));
dictionary2.Add(TextTrimming.Word, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingWord));
dictionary2.Add(TextTrimming.EllipsisCharacter, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingEllipsisCharacter));
dictionary2.Add(TextTrimming.EllipsisWord, new TextRenderHelper.ReflectTextTrimming(this.ReflectTextTrimmingEllipsisWord));
this.ReflectTextTrimmingFuncs = dictionary2;
}
public Text(System.Drawing.Font font, string content)
{
this._trimming = TextTrimming.WordEllipsis;
this._text = content;
this._font = font;
this._foreColor = Colors.Black;
}
public static string ProcessTrimming(Control control, string text, double availableWidth)
{
TextTrimming trimming = GetTextTrimming(control);
TrimmingSource source = GetTrimmingSource(control);
string wordSeparators = GetWordSeparators(control);
return(ProcessTrimming(control, text, availableWidth, trimming, source, wordSeparators));
}
public string[] GetLines(float maxWidth, float maxHeight, bool wrap, TextTrimming textTrimming)
{
string[] lines = wrap ? WrapText(maxWidth) : _text.Split(Environment.NewLine.ToCharArray());
if (textTrimming != TextTrimming.None)
{
lines = TrimText(lines, textTrimming, maxWidth, maxHeight);
}
return(lines);
}
public static void SetTextTrimming(this HtmlStyleDictionary style, TextTrimming textTrimming)
{
if (textTrimming == TextTrimming.None)
{
style.ClearValue("text-overflow");
}
else
{
style.SetValue("text-overflow", "ellipsis");
}
}
private void ApplyNativeTextTrimming(TextTrimming textTrimming)
{
if (textTrimming == TextTrimming.WordEllipsis)
{
((Android.Widget.TextView) this.NativeUIElement).Ellipsize = TextUtils.TruncateAt.End;
}
else
{
((Android.Widget.TextView) this.NativeUIElement).Ellipsize = null;
}
}
public wpf::System.Windows.TextTrimming Convert(TextTrimming textTrimming)
{
switch (textTrimming)
{
case TextTrimming.None: return(wpf::System.Windows.TextTrimming.None);
case TextTrimming.CharacterEllipsis: return(wpf::System.Windows.TextTrimming.CharacterEllipsis);
}
throw new Granular.Exception("Unexpected TextTrimming value \"{0}\"", textTrimming);
}
public static void SetHtmlTextTrimming(this HtmlElement element, TextTrimming textTrimming)
{
if (textTrimming == TextTrimming.None)
{
element.ClearHtmlStyleProperty("text-overflow");
}
else
{
element.SetHtmlStyleProperty("text-overflow", "ellipsis");
}
}
internal static string ToCssString(this TextTrimming value)
{
switch (value)
{
case TextTrimming.CharacterEllipsis:
return("ellipsis");
default:
return("clip");
}
}
public TextParagraphProperties(
TextStyle defaultTextStyle,
TextAlignment textAlignment = TextAlignment.Left,
TextWrapping textWrapping = TextWrapping.NoWrap,
TextTrimming textTrimming = TextTrimming.None)
{
DefaultTextStyle = defaultTextStyle;
TextAlignment = textAlignment;
TextWrapping = textWrapping;
TextTrimming = textTrimming;
}
public void SetTrimming(object backend, TextTrimming textTrimming)
{
Pango.Layout tl = (Pango.Layout)backend;
if (textTrimming == TextTrimming.WordElipsis)
{
tl.Ellipsize = Pango.EllipsizeMode.End;
}
if (textTrimming == TextTrimming.Word)
{
tl.Ellipsize = Pango.EllipsizeMode.None;
}
}
public Size Measure(TextAlignment alignment, TextWrapping wrapping, TextTrimming trimming, float maxWidth, float maxHeight, float lineHeight, LineStackingStrategy lineStacking)
{
IntPtr ret = NoesisGUI_PINVOKE.FormattedText_Measure(swigCPtr, (int)alignment, (int)wrapping, (int)trimming, maxWidth, maxHeight, lineHeight, (int)lineStacking);
if (ret != IntPtr.Zero)
{
return(Marshal.PtrToStructure <Size>(ret));
}
else
{
return(new Size());
}
}
public static StringTrimming ToGdi(this TextTrimming value)
{
if (value == TextTrimming.Word)
{
return(StringTrimming.Word);
}
if (value == TextTrimming.WordElipsis)
{
return(StringTrimming.EllipsisWord);
}
return(StringTrimming.Word);
}
public override void SetTrimming(object backend, TextTrimming textTrimming)
{
var tl = (PangoBackend)backend;
if (textTrimming == TextTrimming.WordElipsis)
{
tl.Layout.Ellipsize = Pango.EllipsizeMode.End;
}
if (textTrimming == TextTrimming.Word)
{
tl.Layout.Ellipsize = Pango.EllipsizeMode.None;
}
}
public GenericTextParagraphProperties(
TextRunProperties defaultTextRunProperties,
TextAlignment textAlignment = TextAlignment.Left,
TextWrapping textWrapping = TextWrapping.WrapWithOverflow,
TextTrimming textTrimming = TextTrimming.None,
double lineHeight = 0)
{
DefaultTextRunProperties = defaultTextRunProperties;
_textAlignment = textAlignment;
_textWrapping = textWrapping;
_textTrimming = textTrimming;
_lineHeight = lineHeight;
}
public static System.Windows.TextTrimming ToNativeTextTrimming(this TextTrimming textTrimming)
{
switch (textTrimming)
{
case TextTrimming.None:
return(System.Windows.TextTrimming.None);
case TextTrimming.CharacterEllipsis:
return(System.Windows.TextTrimming.CharacterEllipsis);
case TextTrimming.WordEllipsis:
return(System.Windows.TextTrimming.WordEllipsis);
default:
throw new ArgumentException();
}
}
/// <summary>
/// Method to change the stroke color of the nodes
/// </summary>
/// <param name="fillcolor"></param>
private void OnTextTrimmingChanged(TextTrimming value)
{
foreach (NodeViewModel node in (this.SelectedItems as SelectorViewModel).Nodes as IEnumerable <object> )
{
foreach (IAnnotation annotation in node.Annotations as ObservableCollection <IAnnotation> )
{
(annotation as TextAnnotationViewModel).TextTrimming = value;
}
}
foreach (ConnectorViewModel conn in (this.SelectedItems as SelectorViewModel).Connectors as IEnumerable <object> )
{
foreach (IAnnotation annotation in conn.Annotations as ObservableCollection <IAnnotation> )
{
(annotation as TextAnnotationViewModel).TextTrimming = value;
}
}
}
public bool DrawText(ref string text, Font font, Color color, int x, int y, int width, int height,
TextAlignment alignment, TextTrimming trimming)
{
VerifyAccess();
uint flags = Bitmap.DT_WordWrap;
// Text alignment
switch (alignment)
{
case TextAlignment.Left:
//flags |= Bitmap.DT_AlignmentLeft;
break;
case TextAlignment.Center:
flags |= Bitmap.DT_AlignmentCenter;
break;
case TextAlignment.Right:
flags |= Bitmap.DT_AlignmentRight;
break;
default:
throw new NotSupportedException();
}
// Trimming
switch (trimming)
{
case TextTrimming.CharacterEllipsis:
flags |= Bitmap.DT_TrimmingCharacterEllipsis;
break;
case TextTrimming.WordEllipsis:
flags |= Bitmap.DT_TrimmingWordEllipsis;
break;
}
int xRelStart = 0;
int yRelStart = 0;
return(_bitmap.DrawTextInRect(ref text, ref xRelStart, ref yRelStart, _x + x, _y + y,
width, height, flags, color, font));
}
public static Gdi.StringTrimming ToGdi(this TextTrimming trimming)
{
switch (trimming)
{
case TextTrimming.None:
return(Gdi.StringTrimming.None);
case TextTrimming.Character:
return(Gdi.StringTrimming.EllipsisCharacter);
case TextTrimming.Word:
return(Gdi.StringTrimming.EllipsisWord);
default:
break;
}
throw new NotImplementedException($"Text trimming {trimming} is not implemented");
}
public override void SetTrimming(object backend, TextTrimming textTrimming)
{
LayoutBackend la = (LayoutBackend) backend;
la.TextTrimming = textTrimming;
}
/// <summary>
/// Sets the value of the <see cref="TextTrimming"/> dependency property attached to the given <see cref="DependencyObject"/>.
/// </summary>
/// <param name="target">The target <see cref="DependencyObject"/>.</param>
/// <param name="value">The value to set.</param>
public static void SetTextTrimming(DependencyObject target, TextTrimming value)
{
target.SetValue(TextTrimmingProperty, value);
}
private void ApplyNativeTextTrimming(TextTrimming textTrimming)
{
if (textTrimming == TextTrimming.WordEllipsis)
{
((Android.Widget.TextView)this.NativeUIElement).Ellipsize = TextUtils.TruncateAt.End;
}
else
{
((Android.Widget.TextView)this.NativeUIElement).Ellipsize = null;
}
}
public static void SetTextTrimming(this HtmlStyleDictionary style, TextTrimming textTrimming)
{
if (textTrimming == TextTrimming.None)
{
style.ClearValue("text-overflow");
}
else
{
style.SetValue("text-overflow", "ellipsis");
}
}
public bool DrawText(ref string text, Font font, Color color, int x, int y, int width, int height, TextAlignment alignment, TextTrimming trimming, bool wordWrap)
{
if (font != null)
{
uint flags = 0;// Bitmap.DT_IgnoreHeight;
if (wordWrap)
flags |= Bitmap.DT_WordWrap;
// Text alignment
switch (alignment)
{
case TextAlignment.Left: flags |= Bitmap.DT_AlignmentLeft; break;
case TextAlignment.Center: flags |= Bitmap.DT_AlignmentCenter; break;
case TextAlignment.Right: flags |= Bitmap.DT_AlignmentRight; break;
default: throw new NotSupportedException();
}
// Trimming
switch (trimming)
{
case TextTrimming.CharacterEllipsis: flags |= Bitmap.DT_TrimmingCharacterEllipsis; break;
case TextTrimming.WordEllipsis: flags |= Bitmap.DT_TrimmingWordEllipsis; break;
}
int xRelStart = 0;
int yRelStart = 0;
return bitmap.DrawTextInRect(ref text, ref xRelStart, ref yRelStart, translationX + x, translationY + y, width, height, flags, (MSMedia.Color)color, font);
}
return false;
}
public bool DrawText(ref string text, Font font, Color color, int x, int y, int width, int height,
TextAlignment alignment, TextTrimming trimming)
{
VerifyAccess();
uint flags = Bitmap.DT_WordWrap;
// Text alignment
switch (alignment)
{
case TextAlignment.Left:
//flags |= Bitmap.DT_AlignmentLeft;
break;
case TextAlignment.Center:
flags |= Bitmap.DT_AlignmentCenter;
break;
case TextAlignment.Right:
flags |= Bitmap.DT_AlignmentRight;
break;
default:
throw new NotSupportedException();
}
// Trimming
switch (trimming)
{
case TextTrimming.CharacterEllipsis:
flags |= Bitmap.DT_TrimmingCharacterEllipsis;
break;
case TextTrimming.WordEllipsis:
flags |= Bitmap.DT_TrimmingWordEllipsis;
break;
}
int xRelStart = 0;
int yRelStart = 0;
return _bitmap.DrawTextInRect(ref text, ref xRelStart, ref yRelStart, _x + x, _y + y,
width, height, flags, color, font);
}
public override void SetTrimming(object backend, TextTrimming textTrimming)
{
((TextLayoutContext) backend).StringTrimming = textTrimming.ToDrawingStringTrimming();
}
private static double GetTextWidth(Control control, string text, TextTrimming trimming)
{
double[] dummy;
return GetTextWidth(control, text, trimming, out dummy);
}
public wpf::System.Windows.TextTrimming Convert(TextTrimming textTrimming)
{
switch (textTrimming)
{
case TextTrimming.None: return wpf::System.Windows.TextTrimming.None;
case TextTrimming.CharacterEllipsis: return wpf::System.Windows.TextTrimming.CharacterEllipsis;
}
throw new Granular.Exception("Unexpected TextTrimming value \"{0}\"", textTrimming);
}
public abstract void SetTrimming(object backend, TextTrimming textTrimming);
public void SetTrimming(object backend, TextTrimming textTrimming)
{
Pango.Layout tl = (Pango.Layout)backend;
if (textTrimming == TextTrimming.WordElipsis)
tl.Ellipsize = Pango.EllipsizeMode.End;
if (textTrimming == TextTrimming.Word)
tl.Ellipsize = Pango.EllipsizeMode.None;
}
/// <summary>
/// 设置裁剪文本
/// </summary>
/// <param name="obj"></param>
/// <param name="value"></param>
public static void SetYTextTrimming(DependencyObject obj, TextTrimming value)
{
obj.SetValue(YTextTrimmingProperty, value);
}
public override void SetTrimming(object backend, TextTrimming textTrimming)
{
var tl = (PangoBackend)backend;
if (textTrimming == TextTrimming.WordElipsis)
tl.Layout.Ellipsize = Pango.EllipsizeMode.End;
if (textTrimming == TextTrimming.Word)
tl.Layout.Ellipsize = Pango.EllipsizeMode.None;
}
private static double GetTextWidth(Control control, string text, TextTrimming trimming, out double[] sizes)
{
var wordSeparators = GetWordSeparators(control);
var typeface = new Typeface(control.FontFamily, control.FontStyle, control.FontWeight, control.FontStretch);
var totalWidth = 0.0;
// We use a period to ensure space characters will have their actual size used.
var period = new FormattedText(".", CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, typeface, control.FontSize, Brushes.Black);
double periodWidth = period.Width;
switch (trimming)
{
case TextTrimming.CharacterEllipsis:
sizes = new double[text.Length];
for (var i = 0; i < text.Length; i++)
{
string token = text[i].ToString(CultureInfo.CurrentUICulture) + ".";
var formattedText = new FormattedText(token, CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, typeface, control.FontSize, Brushes.Black);
double width = formattedText.Width - periodWidth;
sizes[i] = width;
totalWidth += width;
}
return totalWidth;
case TextTrimming.WordEllipsis:
var words = SplitWords(text, wordSeparators);
sizes = new double[words.Count];
for (var i = 0; i < words.Count; i++)
{
string token = words[i] + ".";
var formattedText = new FormattedText(token, CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, typeface, control.FontSize, Brushes.Black);
double width = formattedText.Width - periodWidth;
sizes[i] = width;
totalWidth += width;
}
return totalWidth;
default:
throw new ArgumentOutOfRangeException("trimming");
}
}
public override void SetTrimming (object backend, TextTrimming value)
{
LayoutInfo li = (LayoutInfo)backend;
li.TextTrimming = value;
}
private static string ProcessTrimming(Control control, string text, double availableWidth, TextTrimming trimming, TrimmingSource source, string wordSeparators)
{
if (trimming == TextTrimming.None)
{
return text;
}
double[] sizes;
var textWidth = GetTextWidth(control, text, trimming, out sizes);
if (availableWidth >= textWidth)
{
return text;
}
if (sizes.Length == 0)
{
return text;
}
List<string> words;
switch (trimming)
{
case TextTrimming.CharacterEllipsis:
words = text.ToCharArray().Select(c => c.ToString(CultureInfo.InvariantCulture)).ToList();
break;
case TextTrimming.WordEllipsis:
words = SplitWords(text, wordSeparators);
break;
default:
throw new ArgumentException("Invalid 'TextTrimming' argument.");
}
bool firstWord = true;
switch (source)
{
case TrimmingSource.Begin:
{
var currentWidth = GetTextWidth(control, Ellipsis, trimming);
var ending = new StringBuilder();
for (int i = words.Count - 1; i >= 0; --i)
{
var test = currentWidth + sizes[i];
if (test > availableWidth)
{
// If there's not enough room for a single word, fall back on character trimming from the beginning
if (trimming == TextTrimming.WordEllipsis && firstWord)
{
return ProcessTrimming(control, words[i], availableWidth, TextTrimming.CharacterEllipsis, TrimmingSource.Begin, wordSeparators);
}
break;
}
ending.Insert(0, words[i]);
currentWidth = test;
firstWord = false;
}
return string.Format("{0}{1}", Ellipsis, ending);
}
case TrimmingSource.Middle:
{
var currentWidth = GetTextWidth(control, Ellipsis, trimming);
var begin = new StringBuilder();
var ending = new StringBuilder();
for (int i = 0, j = words.Count - 1; i <= j; ++i, --j)
{
var test = currentWidth + sizes[i] + (i != j ? sizes[j] : 0);
if (test > availableWidth)
{
// If there's not enough room for a single word, fall back on character trimming from the end
if (trimming == TextTrimming.WordEllipsis && firstWord)
{
return ProcessTrimming(control, words[j], availableWidth, TextTrimming.CharacterEllipsis, TrimmingSource.End, wordSeparators);
}
break;
}
begin.Append(words[i]);
if (i != j)
ending.Insert(0, words[j]);
currentWidth = test;
firstWord = false;
}
return string.Format("{0}{2}{1}", begin, ending, Ellipsis);
}
case TrimmingSource.End:
{
var currentWidth = GetTextWidth(control, Ellipsis, trimming);
var begin = new StringBuilder();
for (int i = 0; i < words.Count; ++i)
{
var test = currentWidth + sizes[i];
if (test > availableWidth)
{
// If there's not enough room for a single word, fall back on character trimming from the end
if (trimming == TextTrimming.WordEllipsis && firstWord)
{
return ProcessTrimming(control, words[i], availableWidth, TextTrimming.CharacterEllipsis, TrimmingSource.Begin, wordSeparators);
}
break;
}
begin.Append(words[i]);
currentWidth = test;
firstWord = false;
}
return string.Format("{0}{1}", begin, Ellipsis);
}
default:
throw new ArgumentOutOfRangeException();
}
}
