SvgText.cs 12.7 KB
Newer Older
davescriven's avatar
davescriven committed
1
2
3
4
5
6
7
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
8
9
using Svg.DataTypes;
using System.Linq;
davescriven's avatar
davescriven committed
10
11
12
13
14
15

namespace Svg
{
    /// <summary>
    /// The <see cref="SvgText"/> element defines a graphics element consisting of text.
    /// </summary>
16
    [SvgElement("text")]
17
    public class SvgText : SvgVisualElement
davescriven's avatar
davescriven committed
18
19
20
21
22
23
    {
        private SvgUnit _x;
        private SvgUnit _y;
        private SvgUnit _letterSpacing;
        private SvgUnit _wordSpacing;
        private SvgUnit _fontSize;
24
		private SvgFontWeight _fontWeight;
Tebjan Halm's avatar
Tebjan Halm committed
25
26
        private string _font;
        private string _fontFamily;
davescriven's avatar
davescriven committed
27
28
        private GraphicsPath _path;
        private SvgTextAnchor _textAnchor = SvgTextAnchor.Start;
29
        private static readonly SvgRenderer _stringMeasure;
samjudson's avatar
samjudson committed
30
31
        private const string DefaultFontFamily = "Times New Roman";

davescriven's avatar
davescriven committed
32
33
34
35
36
37
        /// <summary>
        /// Initializes the <see cref="SvgText"/> class.
        /// </summary>
        static SvgText()
        {
            Bitmap bitmap = new Bitmap(1, 1);
38
            _stringMeasure = SvgRenderer.FromImage(bitmap);
39
            _stringMeasure.TextRenderingHint = TextRenderingHint.AntiAlias;
davescriven's avatar
davescriven committed
40
41
42
43
44
45
46
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SvgText"/> class.
        /// </summary>
        public SvgText()
        {
samjudson's avatar
samjudson committed
47
            this._fontFamily = DefaultFontFamily;
davescriven's avatar
davescriven committed
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
            this._fontSize = new SvgUnit(0.0f);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SvgText"/> class.
        /// </summary>
        /// <param name="text">The text.</param>
        public SvgText(string text) : this()
        {
            this.Text = text;
        }

        /// <summary>
        /// Gets or sets the text to be rendered.
        /// </summary>
        public virtual string Text
        {
            get { return base.Content; }
Tebjan Halm's avatar
Tebjan Halm committed
66
            set { base.Content = value; this.IsPathDirty = true; this.Content = value; }
davescriven's avatar
davescriven committed
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
        }

        /// <summary>
        /// Gets or sets the text anchor.
        /// </summary>
        /// <value>The text anchor.</value>
        [SvgAttribute("text-anchor")]
        public virtual SvgTextAnchor TextAnchor
        {
            get { return this._textAnchor; }
            set { this._textAnchor = value; this.IsPathDirty = true; }
        }

        /// <summary>
        /// Gets or sets the X.
        /// </summary>
        /// <value>The X.</value>
        [SvgAttribute("x")]
        public virtual SvgUnit X
        {
            get { return this._x; }
Tebjan Halm's avatar
Tebjan Halm committed
88
89
90
91
92
93
            set 
            { 
            	this._x = value; 
            	this.IsPathDirty = true;
            	OnAttributeChanged(new AttributeEventArgs{ Attribute = "x", Value = value });
            }
davescriven's avatar
davescriven committed
94
95
96
97
98
99
100
101
102
103
        }

        /// <summary>
        /// Gets or sets the Y.
        /// </summary>
        /// <value>The Y.</value>
        [SvgAttribute("y")]
        public virtual SvgUnit Y
        {
            get { return this._y; }
Tebjan Halm's avatar
Tebjan Halm committed
104
105
106
107
108
109
            set 
            { 
            	this._y = value; 
            	this.IsPathDirty = true; 
            	OnAttributeChanged(new AttributeEventArgs{ Attribute = "y", Value = value });
            }
davescriven's avatar
davescriven committed
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
        }

        /// <summary>
        /// Specifies spacing behavior between text characters.
        /// </summary>
        [SvgAttribute("letter-spacing")]
        public virtual SvgUnit LetterSpacing
        {
            get { return this._letterSpacing; }
            set { this._letterSpacing = value; this.IsPathDirty = true; }
        }

        /// <summary>
        /// Specifies spacing behavior between words.
        /// </summary>
        [SvgAttribute("word-spacing")]
        public virtual SvgUnit WordSpacing
        {
            get { return this._wordSpacing; }
            set { this._wordSpacing = value; this.IsPathDirty = true; }
        }

        /// <summary>
        /// Indicates which font family is to be used to render the text.
        /// </summary>
        [SvgAttribute("font-family")]
Tebjan Halm's avatar
Tebjan Halm committed
136
        public virtual string FontFamily
davescriven's avatar
davescriven committed
137
        {
Tebjan Halm's avatar
Tebjan Halm committed
138
            get { return this._fontFamily; }
samjudson's avatar
samjudson committed
139
140
141
142
143
            set
            {
                this._fontFamily = ValidateFontFamily(value);
                this.IsPathDirty = true;
            }
davescriven's avatar
davescriven committed
144
145
146
147
148
149
150
151
152
153
154
155
        }

        /// <summary>
        /// Refers to the size of the font from baseline to baseline when multiple lines of text are set solid in a multiline layout environment.
        /// </summary>
        [SvgAttribute("font-size")]
        public virtual SvgUnit FontSize
        {
            get { return this._fontSize; }
            set { this._fontSize = value; this.IsPathDirty = true; }
        }

156
157
158
159
160
161
162
163
164
165
166
167

		/// <summary>
		/// Refers to the boldness of the font.
		/// </summary>
		[SvgAttribute("font-weight")]
		public virtual SvgFontWeight FontWeight
		{
			get { return this._fontWeight; }
			set { this._fontWeight = value; this.IsPathDirty = true; }
		}


davescriven's avatar
davescriven committed
168
169
170
171
        /// <summary>
        /// Set all font information.
        /// </summary>
        [SvgAttribute("font")]
Tebjan Halm's avatar
Tebjan Halm committed
172
        public virtual string Font
davescriven's avatar
davescriven committed
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
        {
            get { return this._font; }
            set { this._font = value; this.IsPathDirty = true; }
        }

        /// <summary>
        /// Gets or sets the fill.
        /// </summary>
        /// <remarks>
        /// <para>Unlike other <see cref="SvgGraphicsElement"/>s, <see cref="SvgText"/> has a default fill of black rather than transparent.</para>
        /// </remarks>
        /// <value>The fill.</value>
        public override SvgPaintServer Fill
        {
            get { return (this.Attributes["Fill"] == null) ? new SvgColourServer(Color.Black) : (SvgPaintServer)this.Attributes["Fill"]; }
            set { this.Attributes["Fill"] = value; }
        }

        /// <summary>
        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
        /// </summary>
        /// <returns>
        /// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
        /// </returns>
        public override string ToString()
        {
            return this.Text;
        }

        /// <summary>
        /// Gets or sets a value to determine if anti-aliasing should occur when the element is being rendered.
        /// </summary>
        /// <value></value>
        protected override bool RequiresSmoothRendering
        {
            get { return true; }
        }

        /// <summary>
        /// Gets the bounds of the element.
        /// </summary>
        /// <value>The bounds.</value>
        public override System.Drawing.RectangleF Bounds
        {
            get { return this.Path.GetBounds(); }
        }

Tebjan Halm's avatar
Tebjan Halm committed
220
        static private RectangleF MeasureString(SvgRenderer renderer, string text, Font font)
221
222
223
        {
            GraphicsPath p = new GraphicsPath();
            p.AddString(text, font.FontFamily, 0, font.Size, new PointF(0.0f, 0.0f), StringFormat.GenericTypographic);
224
            
225
            p.Transform(renderer.Transform);
Tebjan Halm's avatar
Tebjan Halm committed
226
            return p.GetBounds();
227
228
        }

davescriven's avatar
davescriven committed
229
230
231
232
233
234
235
236
237
        /// <summary>
        /// Gets the <see cref="GraphicsPath"/> for this element.
        /// </summary>
        /// <value></value>
        public override System.Drawing.Drawing2D.GraphicsPath Path
        {
            get
            {
                // Make sure the path is always null if there is no text
238
239
240
241
242
				//if (string.IsNullOrEmpty(this.Text))
				//    _path = null;
				//NOT SURE WHAT THIS IS ABOUT - Path gets created again anyway - WTF?

				if (_path == null || this.IsPathDirty)
davescriven's avatar
davescriven committed
243
244
                {
                    float fontSize = this.FontSize.ToDeviceValue(this);
245
246
247
248
                    if (fontSize == 0.0f)
                    {
                        fontSize = 1.0f;
                    }
249

250
251
                	FontStyle fontWeight = (this.FontWeight == SvgFontWeight.bold ? FontStyle.Bold : FontStyle.Regular);
					Font font = new Font(this._fontFamily, fontSize, fontWeight, GraphicsUnit.Pixel);
davescriven's avatar
davescriven committed
252
253
254
255

                    _path = new GraphicsPath();
                    _path.StartFigure();

256
257
					if (!string.IsNullOrEmpty(this.Text))
	                	DrawString(_path, this.X, this.Y, SvgUnit.Empty, SvgUnit.Empty, font, fontSize, this.Text);
davescriven's avatar
davescriven committed
258

259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
					foreach (var tspan in this.Children.Where(x => x is SvgTextSpan).Select(x => x as SvgTextSpan))
					{
						if (!string.IsNullOrEmpty(tspan.Text))
							DrawString(
							_path, 
							tspan.X == SvgUnit.Empty ? this.X: tspan.X,
							tspan.Y == SvgUnit.Empty ? this.Y : tspan.Y, 
							tspan.DX,
							tspan.DY,
							font, 
							fontSize,
							tspan.Text);
					}

                	_path.CloseFigure();
davescriven's avatar
davescriven committed
274
275
276
277
278
                    this.IsPathDirty = false;
                }
                return _path;
            }
        }
279

samjudson's avatar
samjudson committed
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
        private static string ValidateFontFamily(string fontFamilyList)
        {
            // Split font family list on "," and then trim start and end spaces and quotes.
            var fontParts = fontFamilyList.Split(new[] { ',' }).Select(fontName => fontName.Trim(new[] { '"', ' ' }));

            var families = System.Drawing.FontFamily.Families;

            // Find a the first font that exists in the list of installed font families.
            foreach (var f in fontParts.Where(f => families.Any(family => family.Name == f)))
            {
                return f;
            }
            // No valid font family found from the list requested.
            return DefaultFontFamily;
        }
295
296
297
298

		private void DrawString(GraphicsPath path, SvgUnit x, SvgUnit y, SvgUnit dx, SvgUnit dy, Font font, float fontSize, string text)
		{
			PointF location = PointF.Empty;
299
300
301
302
303
304
			SizeF stringBounds;

			lock (_stringMeasure)
			{
				stringBounds = _stringMeasure.MeasureString(text, font);
			}
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382

			float xToDevice = x.ToDeviceValue(this) + dx.ToDeviceValue(this);
			float yToDevice = y.ToDeviceValue(this, true) + dy.ToDeviceValue(this, true);

			// Minus FontSize because the x/y coords mark the bottom left, not bottom top.
			switch (this.TextAnchor)
			{
				case SvgTextAnchor.Start:
					location = new PointF(xToDevice, yToDevice - stringBounds.Height);
					break;
				case SvgTextAnchor.Middle:
					location = new PointF(xToDevice - (stringBounds.Width / 2), yToDevice - stringBounds.Height);
					break;
				case SvgTextAnchor.End:
					location = new PointF(xToDevice - stringBounds.Width, yToDevice - stringBounds.Height);
					break;
			}

			// No way to do letter-spacing or word-spacing, so do manually
			if (this.LetterSpacing.Value > 0.0f || this.WordSpacing.Value > 0.0f)
			{
				// Cut up into words, or just leave as required
				string[] words = (this.WordSpacing.Value > 0.0f) ? text.Split(' ') : new string[] { text };
				float wordSpacing = this.WordSpacing.ToDeviceValue(this);
				float letterSpacing = this.LetterSpacing.ToDeviceValue(this);
				float start = this.X.ToDeviceValue(this);

				foreach (string word in words)
				{
					// Only do if there is line spacing, just write the word otherwise
					if (this.LetterSpacing.Value > 0.0f)
					{
						char[] characters = word.ToCharArray();
						foreach (char currentCharacter in characters)
						{
							path.AddString(currentCharacter.ToString(), new FontFamily(this._fontFamily), (int)font.Style, fontSize, location, StringFormat.GenericTypographic);
							location = new PointF(path.GetBounds().Width + start + letterSpacing, location.Y);
						}
					}
					else
					{
						path.AddString(word, new FontFamily(this._fontFamily), (int)font.Style, fontSize, location, StringFormat.GenericTypographic);
					}

					// Move the location of the word to be written along
					location = new PointF(path.GetBounds().Width + start + wordSpacing, location.Y);
				}
			}
			else
			{
				if (!string.IsNullOrEmpty(text))
				{
					path.AddString(text, new FontFamily(this._fontFamily), (int)font.Style, fontSize, location, StringFormat.GenericTypographic);
				}
			}

		}


		public override SvgElement DeepCopy()
		{
			return DeepCopy<SvgText>();
		}

		public override SvgElement DeepCopy<T>()
		{
			var newObj = base.DeepCopy<T>() as SvgText;
			newObj.TextAnchor = this.TextAnchor;
			newObj.WordSpacing = this.WordSpacing;
			newObj.LetterSpacing = this.LetterSpacing;
			newObj.Font = this.Font;
			newObj.FontFamily = this.FontFamily;
			newObj.FontSize = this.FontSize;
			newObj.FontWeight = this.FontWeight;
			newObj.X = this.X;
			newObj.Y = this.Y;
			return newObj;
		}
davescriven's avatar
davescriven committed
383
    }
samjudson's avatar
samjudson committed
384
}