//#define DRAWTEST
/*******************************************************************************
 * Copyright(c) 2012 dongke All rights reserved. / Confidential
 * 类的信息：
 *		1.程序名称：LayoutUtility.cs
 *		2.功能描述：Layout工具类
 * 编辑履历：
 *		作者				日期					版本				修改内容
 *		欧阳涛				2012/09/11				1.00				新建
 *******************************************************************************/
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
//using Microsoft.VisualBasic.PowerPacks;

namespace Dongke.WinForm.Controls.InvoiceLayout
{
	public static class LayoutUtility
	{
		#region 函数
		///// <summary>
		///// 获取图形实例
		///// </summary>
		///// <param name="item"></param>
		///// <returns></returns>
		//public static Shape GetNewShape(LayoutItem item)
		//{
		//	Shape shape = null;
		//	switch (item.ItemType)
		//	{
		//		case ItemType.Ellipse:
		//			OvalShape eShape = new OvalShape();
		//			eShape.SelectionColor = Color.Transparent;
		//			eShape.BorderStyle = DashStyle.Solid;
		//			eShape.BorderColor = Color.Black;
		//			shape = eShape;
		//			break;
		//		case ItemType.Rectangle:
		//			RectangleShape rShape = new RectangleShape();
		//			rShape.SelectionColor = Color.Transparent;
		//			rShape.BorderStyle = DashStyle.Solid;
		//			rShape.BorderColor = Color.Black;
		//			shape = rShape;
		//			break;
		//		case ItemType.Image:
		//		case ItemType.Text:
		//		case ItemType.Grid:
		//		case ItemType.PageNum:
		//		default:
		//			RectangleShape dShape = new RectangleShape();
		//			dShape.SelectionColor = Color.Transparent;
		//			dShape.BorderStyle = DashStyle.Custom;
		//			dShape.BorderColor = Color.Transparent;
		//			shape = dShape;
		//			break;
		//	}
		//	return shape;
		//}

		#region 绘制直线
		/// <summary>
		/// 绘制直线
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="startPoint">起点</param>
		/// <param name="endPoint">终点</param>
		/// <param name="lineColor">线的颜色</param>
		/// <param name="lineWidth">线宽（mm）</param>
		public static void DrawLine(
					Graphics graphics,
					PointF startPoint,
					PointF endPoint,
					Color lineColor,
					float lineWidth)
		{
			DrawLine(graphics, graphics.PageUnit, startPoint, endPoint, lineColor, lineWidth);
		}

		/// <summary>
		/// 绘制直线
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="unit">GraphicsUnit</param>
		/// <param name="startPoint">起点</param>
		/// <param name="endPoint">终点</param>
		/// <param name="lineColor">线的颜色</param>
		/// <param name="lineWidth">线宽（mm）</param>
		public static void DrawLine(
					Graphics graphics,
					GraphicsUnit unit,
					PointF startPoint,
					PointF endPoint,
					Color lineColor,
					float lineWidth)
		{
			if (lineWidth == 0 || ((startPoint.X == endPoint.X) && (startPoint.Y == endPoint.Y)))
			{
				return;
			}
			GraphicsContainer containerState = graphics.BeginContainer();
			graphics.PageUnit = unit;

			SmoothingMode smoothingMode = graphics.SmoothingMode;
			try
			{
				using (Pen pen = new Pen(lineColor))
				{
					graphics.SmoothingMode = SmoothingMode.AntiAlias;
					pen.Width = Math.Max(LayoutCommon.PixelToMillimeter(1), lineWidth);
					graphics.DrawLine(pen, startPoint, endPoint);
				}
			}
			finally
			{
				graphics.SmoothingMode = smoothingMode;
				graphics.EndContainer(containerState);
			}
		}
		#endregion 绘制直线

		#region 绘制椭圆
		/// <summary>
		/// 绘制椭圆
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="rectangle">图形范围</param>
		/// <param name="lineColor">边线颜色</param>
		/// <param name="fillColor">填充颜色</param>
		/// <param name="lineWidth">边线宽（mm）</param>
		/// <param name="isTransparent">背景是否透明</param>
		public static void DrawEllipse(
					Graphics graphics,
					RectangleF rectangle,
					Color lineColor,
					Color fillColor,
					float lineWidth,
					bool isTransparent)
		{
			DrawEllipse(graphics, graphics.PageUnit, rectangle,
				lineColor, fillColor, lineWidth, isTransparent);
		}

		/// <summary>
		/// 绘制椭圆
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="unit">GraphicsUnit</param>
		/// <param name="rectangle">图形范围</param>
		/// <param name="lineColor">边线颜色</param>
		/// <param name="fillColor">填充颜色</param>
		/// <param name="lineWidth">边线宽（mm）</param>
		/// <param name="isTransparent">背景是否透明</param>
		public static void DrawEllipse(
					Graphics graphics,
					GraphicsUnit unit,
					RectangleF rectangle,
					Color lineColor,
					Color fillColor,
					float lineWidth,
					bool isTransparent)
		{
			if ((rectangle.Width < 0) || (rectangle.Height < 0))
			{
				return;
			}
			GraphicsContainer containerState = graphics.BeginContainer();
			graphics.PageUnit = unit;

			SmoothingMode smoothingMode = graphics.SmoothingMode;
			try
			{
				if (!isTransparent && (rectangle.Width > 0) && (rectangle.Height > 0))
				{
					graphics.SmoothingMode = SmoothingMode.Default;
					using (Brush brush = new SolidBrush(fillColor))
					{
						graphics.FillEllipse(brush, rectangle);
					}
				}
				if (lineWidth != 0)
				{
					float minWidth = LayoutCommon.PixelToMillimeter(1);
					using (Pen pen = new Pen(lineColor))
					{
						if ((rectangle.Width > 0) && (rectangle.Height == 0))
						{
							pen.Width = minWidth;
							graphics.SmoothingMode = SmoothingMode.AntiAlias;
							graphics.DrawLine(pen, rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Top);
						}
						else if ((rectangle.Width == 0) && (rectangle.Height > 0))
						{
							pen.Width = minWidth;
							graphics.SmoothingMode = SmoothingMode.AntiAlias;
							graphics.DrawLine(pen, rectangle.Left, rectangle.Top, rectangle.Left, rectangle.Bottom);
						}
						else
						{
							float num = Math.Min(rectangle.Width, rectangle.Height) / 2;
							num = Math.Min(num, lineWidth);
							pen.Width = Math.Max(minWidth, num);
							graphics.SmoothingMode = SmoothingMode.Default;
							graphics.DrawEllipse(pen, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
						}
					}
				}
			}
			finally
			{
				graphics.SmoothingMode = smoothingMode;
				graphics.EndContainer(containerState);
			}
		}
		#endregion 绘制椭圆

		#region 绘制矩形
		/// <summary>
		/// 绘制矩形
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="unit">GraphicsUnit</param>
		/// <param name="rectangle">图形范围</param>
		/// <param name="lineColor">边线颜色</param>
		/// <param name="fillColor">填充颜色</param>
		/// <param name="lineWidth">边线宽（mm）</param>
		/// <param name="isTransparent">背景是否透明</param>
		public static void DrawRectangle(
					Graphics graphics,
					RectangleF rectangle,
					Color lineColor,
					Color fillColor,
					float lineWidth,
					bool isTransparent)
		{
			DrawRectangle(graphics, graphics.PageUnit, rectangle,
				lineColor, fillColor, lineWidth, isTransparent);
		}

		/// <summary>
		/// 绘制矩形
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="unit">GraphicsUnit</param>
		/// <param name="rectangle">图形范围</param>
		/// <param name="lineColor">边线颜色</param>
		/// <param name="fillColor">填充颜色</param>
		/// <param name="lineWidth">边线宽（mm）</param>
		/// <param name="isTransparent">背景是否透明</param>
		public static void DrawRectangle(
					Graphics graphics,
					GraphicsUnit unit,
					RectangleF rectangle,
					Color lineColor,
					Color fillColor,
					float lineWidth,
					bool isTransparent)
		{
			if ((rectangle.Width < 0) || (rectangle.Height < 0))
			{
				return;
			}
			GraphicsContainer containerState = graphics.BeginContainer();
			graphics.PageUnit = unit;

			SmoothingMode smoothingMode = graphics.SmoothingMode;
			try
			{
				if (!isTransparent && (rectangle.Width > 0) && (rectangle.Height > 0))
				{
					graphics.SmoothingMode = SmoothingMode.Default;
					using (Brush brush = new SolidBrush(fillColor))
					{
						graphics.FillRectangle(brush, rectangle);
					}
				}
				if (lineWidth != 0)
				{
					float minWidth = LayoutCommon.PixelToMillimeter(1);
					using (Pen pen = new Pen(lineColor))
					{
						if ((rectangle.Width > 0) && (rectangle.Height == 0))
						{
							pen.Width = minWidth;
							graphics.SmoothingMode = SmoothingMode.AntiAlias;
							graphics.DrawLine(pen, rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Top);
						}
						else if ((rectangle.Width == 0) && (rectangle.Height > 0))
						{
							pen.Width = minWidth;
							graphics.SmoothingMode = SmoothingMode.AntiAlias;
							graphics.DrawLine(pen, rectangle.Left, rectangle.Top, rectangle.Left, rectangle.Bottom);
						}
						else
						{
							float num = Math.Min(rectangle.Width, rectangle.Height) / 2;
							num = Math.Min(num, lineWidth);
							pen.Width = Math.Max(minWidth, num);
							graphics.SmoothingMode = SmoothingMode.Default;
							graphics.DrawRectangle(pen, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
						}
					}
				}
			}
			finally
			{
				graphics.SmoothingMode = smoothingMode;
				graphics.EndContainer(containerState);
			}
		}
		#endregion 绘制矩形

		#region 绘制图片
		/// <summary>
		/// 绘制图片
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="rectangle">图片范围</param>
		/// <param name="image">图片</param>
		public static void DrawImage(
					Graphics graphics,
					RectangleF rectangle,
					Image image)
		{
			DrawImage(graphics, graphics.PageUnit, rectangle, image);
		}

		/// <summary>
		/// 绘制图片
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="unit">GraphicsUnit</param>
		/// <param name="rectangle">图片范围</param>
		/// <param name="image">图片</param>
		public static void DrawImage(
					Graphics graphics,
					GraphicsUnit unit,
					RectangleF rectangle,
					Image image)
		{
			if (image == null || (rectangle.Width < 0) || (rectangle.Height < 0))
			{
				return;
			}
			GraphicsContainer containerState = graphics.BeginContainer();
			graphics.PageUnit = unit;

			graphics.DrawImage(image, rectangle);

			graphics.EndContainer(containerState);
		}
		#endregion 绘制图片

		#region 绘制文本
		/// <summary>
		/// 绘制文本
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="rectangleM">绘制范围（余白）</param>
		/// <param name="rectangle">绘制范围</param>
		/// <param name="context">文本</param>
		/// <param name="font">字体</param>
		/// <param name="foreColor">字体颜色</param>
		/// <param name="lineSpace">行间隔</param>
		/// <param name="characterSpace">字间隔</param>
		/// <param name="charCount">行文字数</param>
		/// <param name="alignment">文本对齐方式</param>
		/// <param name="alignmentVertical">文本垂直对齐方式</param>
		/// <param name="wrap">是否自动文本换行</param>
		/// <param name="clip">是否剪裁延伸到边框外侧的文本</param>
		/// <param name="selected">是否选择</param>
		public static void DrawText(
					Graphics graphics,
					RectangleF rectangleM,
					RectangleF rectangle,
					string context,
					Font font,
					Color foreColor,
					float lineSpace,
					float charSpace,
					int charCount,
					TextAlignment alignment,
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 begin
					TextAlignment alignmentVertical,
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 end
					bool wrap,
					bool clip,
					bool selected)
		{
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 begin
			//DrawText(graphics, graphics.PageUnit, rectangleM, rectangle, context, font, foreColor,
			//    lineSpace, charSpace, charCount, alignment, wrap, clip, selected);

			DrawText(graphics, graphics.PageUnit, rectangleM, rectangle, context, font, foreColor,
					lineSpace, charSpace, charCount, alignment, alignmentVertical, wrap, clip, selected);
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 end
		}

		/// <summary>
		/// 绘制文本
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="unit">GraphicsUnit</param>
		/// <param name="rectangleM">绘制范围（余白）</param>
		/// <param name="rectangle">绘制范围</param>
		/// <param name="context">文本</param>
		/// <param name="font">字体</param>
		/// <param name="foreColor">字体颜色</param>
		/// <param name="lineSpace">行间隔</param>
		/// <param name="characterSpace">字间隔</param>
		/// <param name="charCount">行文字数</param>
		/// <param name="alignment">文本对齐方式</param>
		/// <param name="alignmentVertical">文本垂直对齐方式</param>
		/// <param name="wrap">是否自动文本换行</param>
		/// <param name="clip">是否剪裁延伸到边框外侧的文本</param>
		/// <param name="selected">是否选择</param>
		public static void DrawText(
					Graphics graphics,
					GraphicsUnit unit,
					RectangleF rectangleM,
					RectangleF rectangle,
					string context,
					Font font,
					Color foreColor,
					float lineSpace,
					float charSpace,
					int charCount,
					TextAlignment alignment,
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 begin
					TextAlignment alignmentVertical,
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 end
					bool wrap,
					bool clip,
					bool selected)
		{
			clip = false;
			selected = false;

			if (string.IsNullOrEmpty(context)
				|| rectangle.Width <= 0
				|| rectangle.Height <= 0)
			{
				return;
			}

			GraphicsContainer containerState = graphics.BeginContainer();
			graphics.PageUnit = unit;
			graphics.SetClip(rectangleM, CombineMode.Intersect);

			string[] lines = System.Text.RegularExpressions.Regex
				.Split(context, System.Environment.NewLine);
			using (SolidBrush textBrush = new SolidBrush(foreColor))
			{
#if DRAWTEST
				graphics.DrawRectangle(new Pen(Color.Red, 0.1f), rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
#endif

				// 文本垂直对齐方式 modify by chenxy 2014-03-28 begin
				//DrawString(graphics, lines, font, textBrush, lineSpace, charSpace,
				//    charCount, rectangle, alignment, wrap, clip, selected);
				DrawString(graphics, lines, font, textBrush, lineSpace, charSpace,
					charCount, rectangle, alignment, alignmentVertical, wrap, clip, selected);
				// 文本垂直对齐方式 modify by chenxy 2014-03-28 end
			}

			graphics.EndContainer(containerState);
		}

		/// <summary>
		/// 横向绘制文本
		/// </summary>
		/// <param name="graphics">Graphics</param>
		/// <param name="lines">多行文本</param>
		/// <param name="font">字体</param>
		/// <param name="textBrush">字体笔刷</param>
		/// <param name="lineSpace">行间隔</param>
		/// <param name="characterSpace">字间隔</param>
		/// <param name="charCount">行文字数</param>
		/// <param name="rectangle">文本范围</param>
		/// <param name="alignment">文本对齐方式</param>
		/// <param name="wrap">是否自动文本换行</param>
		/// <param name="clip">是否剪裁延伸到边框外侧的文本</param>
		/// <param name="selected">是否选择</param>
		private static void DrawString(
					Graphics graphics,
					string[] lines,
					Font font,
					SolidBrush textBrush,
					float lineSpace,
					float charSpace,
					int charCount,
					RectangleF rectangle,
					TextAlignment alignment,
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 begin
					TextAlignment alignmentVertical,
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 end
					bool wrap,
					bool clip,
					bool selected)
		{
			SizeF fullSizeF = graphics.MeasureString(LayoutConsts.FULLSHAPE_TEXT,
													font,
													PointF.Empty,
													LayoutCommon.StringFormatHorizontal);
			// 单行文字数限制。
			if (0 < charCount)
			{
				System.Text.StringBuilder sbLine = new System.Text.StringBuilder();
				List<string> newLines = new List<string>();
				foreach (string line in lines)
				{
					char[] chars = line.ToCharArray();
					int index = 0;
					while (index < chars.Length)
					{
						int nextIndex = index + charCount;
						if (nextIndex <= chars.Length)
						{
							for (int i = index; i < nextIndex; i++)
							{
								sbLine.Append(chars[i]);
							}
						}
						else
						{
							for (int i = index; i < chars.Length; i++)
							{
								sbLine.Append(chars[i]);
							}
						}
						newLines.Add(sbLine.ToString());
						sbLine.Length = 0;
						index = nextIndex;
					}
				}
				lines = newLines.ToArray();
				if (charCount == 1)
				{
					alignment = TextAlignment.Evenness;
				}
				else
				{
					alignment = TextAlignment.LeftOrTop;
					charSpace = (rectangle.Width - fullSizeF.Width * charCount)
									/ (charCount - 1);
				}
			}

			SizeF halfSizeF = graphics.MeasureString(LayoutConsts.HALFSHAPE_TEXT,
													font,
													PointF.Empty,
													LayoutCommon.StringFormatHorizontal);
			// 单行文字绘制开始
			bool isRowStart = false;
			// 单行文字绘制结束
			bool isRowEnd = false;
			// 一行文字绘制开始
			//bool isLineStart = true;
			// 一行文字绘制结束
			bool isLineEnd = false;
			// 多行文字绘制开始
			bool isLinesStart = true;
			// 多行文字绘制结束
			bool isLinesEnd = false;
			// 文字整体（字间隔，行间隔）范围
			float pointerTop = rectangle.Top;
			float pointerBottom = rectangle.Top + fullSizeF.Height;
			float pointerLeft = rectangle.Left;
			// 文字范围
			float textTop = rectangle.Top;
			float textLeft = rectangle.Left;
			//// 选择状态行间隔范围
			//RectangleF lineSpaceSelectedRectangleF = RectangleF.Empty;
			// 文字范围
			List<TextRectangleF> textRectangleFs = new List<TextRectangleF>();

			// 文本垂直对齐方式 modify by chenxy 2014-03-28 begin
			List<TextRectangleF[]> allTextRectFs = new List<TextRectangleF[]>();
			// 文本垂直对齐方式 modify by chenxy 2014-03-28 end

			// 文本绘制
			for (int lineIndex = 0; lineIndex < lines.Length; lineIndex++)
			{
				// 一行文本绘制
				//isLineStart = true;
				isLineEnd = false;
				int colIndex = 0;
				int lineCharCount = lines[lineIndex].Length;
				char[] chars = lines[lineIndex].ToCharArray();
				while (true)
				{
					isRowStart = true;
					isRowEnd = false;
					textLeft = rectangle.Left;
					pointerLeft = rectangle.Left;
					if (colIndex < lineCharCount)
					{
						// 单行文字绘制
						for (int charIndex = colIndex; charIndex < lineCharCount; charIndex++, colIndex++)
						{
							SizeF nextTeatSizeF;
							TextRectangleF nextTextRectangleF = new TextRectangleF();
							nextTextRectangleF.Text = chars[charIndex].ToString();

							// 单行文字数限制
							if (0 < charCount)
							{
								nextTeatSizeF = fullSizeF;
							}
							else
							{
								// 半角空格的时候
								if (LayoutConsts.SPACE_HALFSHAPE_CHAR.Equals(chars[charIndex]))
								{
									nextTeatSizeF = halfSizeF;
									nextTeatSizeF.Height = fullSizeF.Height;
								}
								// 全角空格的时候
								else if (LayoutConsts.SPACE_FULLSHAPE_CHAR.Equals(chars[charIndex]))
								{
									nextTeatSizeF = fullSizeF;
								}
								// 其他
								else
								{
									nextTeatSizeF = graphics.MeasureString(nextTextRectangleF.Text,
										font, PointF.Empty, LayoutCommon.StringFormatHorizontal);
									nextTeatSizeF.Height = fullSizeF.Height;
								}
							}

							if (isRowStart)
							{
								float bottom = textTop;
								if (!isLinesStart)
								{
									bottom += lineSpace;
								}
								// 剪裁
								if (clip)
								{
									bottom += nextTeatSizeF.Height;
								}
								// 多行绘制结束
								if (rectangle.Bottom < bottom)
								{
									isLinesEnd = true;
									break;
								}

								//// 选择状态行间隔范围填充
								//if (selected
								//    && 0 < lineSpace
								//    && lineSpaceSelectedRectangleF != RectangleF.Empty)
								//{
								//    lineSpaceSelectedRectangleF.Height = lineSpace;
								//    graphics.FillRectangle(LayoutCommon.SelectedBrush, lineSpaceSelectedRectangleF);
								//    lineSpaceSelectedRectangleF = RectangleF.Empty;
								//}

								if (0 == charCount)
								{
									// 自动换行
									float right = textLeft;
									if (rectangle.Right < right)
									{
										if (wrap)
										{
											// 单行结束
											isRowEnd = true;
											break;
										}
										else
										{
											if (clip)
											{
												// 一行结束
												isLineEnd = true;
												break;
											}
										}
									}
								}
							}
							else
							{
								if (0 == charCount)
								{
									float right = textLeft + charSpace + nextTeatSizeF.Width;
									// 自动换行
									if (wrap)
									{
										if (rectangle.Right < right)
										{
											// 文本对齐方式
											float correcting = 0;
											if (alignment == TextAlignment.RightOrBottom)
											{
												correcting = rectangle.Right - textLeft;
												if (0 < correcting)
												{
													foreach (TextRectangleF rf in textRectangleFs)
													{
														rf.RectangleX = rf.RectangleF.X + correcting;
													}
												}
											}
											else if (alignment == TextAlignment.Center)
											{
												correcting = (rectangle.Right - textLeft) / 2;
												if (0 < correcting)
												{
													foreach (TextRectangleF rf in textRectangleFs)
													{
														rf.RectangleX = rf.RectangleF.X + correcting;
													}
												}
											}
											else if (alignment == TextAlignment.Evenness)
											{
												if (1 < textRectangleFs.Count)
												{
													correcting = (rectangle.Right - textLeft)
																/ (textRectangleFs.Count - 1);
													if (0 < correcting)
													{
														for (int j = 0; j < textRectangleFs.Count; j++)
														{
															textRectangleFs[j].RectangleX +=
																correcting * j;
														}
													}
												}
												else
												{
													textRectangleFs[0].RectangleX +=
														(rectangle.Right - textLeft) / 2;
												}
											}
											// 单行结束
											isRowEnd = true;
											break;
										}
									}
									else if (alignment == TextAlignment.LeftOrTop || alignment == TextAlignment.Evenness)
									{
										if (clip)
										{
											if (rectangle.Right < right)
											{
												// 一行结束
												isLineEnd = true;
												break;
											}
										}
										else
										{
											if (rectangle.Right < textLeft + charSpace)
											{
												// 一行结束
												isLineEnd = true;
												break;
											}
										}
									}
								}
							}
							nextTextRectangleF.RectangleF = new RectangleF(pointerLeft, pointerTop,
								nextTeatSizeF.Width, nextTeatSizeF.Height);
							textRectangleFs.Add(nextTextRectangleF);
							// 一行绘制结束
							if (isLineEnd)
							{
								break;
							}
							// 下一个文字位置计算
							if (isRowStart)
							{
								textLeft = textLeft + nextTeatSizeF.Width;
								isRowStart = false;
							}
							else
							{
								textLeft = textLeft + charSpace + nextTeatSizeF.Width;
							}
							pointerLeft = pointerLeft + nextTeatSizeF.Width + charSpace;
						}
						// 多行绘制结束
						if (isLinesEnd)
						{
							break;
						}
						// 一行绘制结束
						if (isLineEnd)
						{
							break;
						}
						// 单行绘制结束
						if (isRowEnd)
						{
							if (isLinesStart)
							{
								textTop = textTop + fullSizeF.Height;
								isLinesStart = false;
							}
							else
							{
								textTop = textTop + lineSpace + fullSizeF.Height;
							}
							pointerTop = pointerTop + fullSizeF.Height + lineSpace;
							pointerBottom = pointerTop + fullSizeF.Height;
							// 单行文字绘制
							if (textRectangleFs.Count > 0)
							{
								//lineSpaceSelectedRectangleF = DrawStringRow(graphics, textRectangleFs, font, textBrush, selected);
								TextRectangleF[] trfs = new TextRectangleF[textRectangleFs.Count];
								for (int i = 0; i < textRectangleFs.Count; i++)
								{
									trfs[i] = textRectangleFs[i];
								}
								textRectangleFs.Clear();
								allTextRectFs.Add(trfs);
							}
						}
					}
					else
					{
						// 空白行
						if (0 == lineCharCount)
						{
							float bottom = textTop;
							if (!isLinesStart)
							{
								bottom += lineSpace;
							}
							// 剪裁
							if (clip)
							{
								bottom += fullSizeF.Height;
							}
							// 多行绘制结束
							if (rectangle.Bottom < bottom)
							{
								isLinesEnd = true;
								break;
							}

							//// 选择状态行间隔范围填充
							//if (selected && 0 < lineSpace && lineSpaceSelectedRectangleF != RectangleF.Empty)
							//{
							//    lineSpaceSelectedRectangleF.Height = lineSpace;
							//    graphics.FillRectangle(LayoutCommon.SelectedBrush,
							//        lineSpaceSelectedRectangleF);
							//    lineSpaceSelectedRectangleF = RectangleF.Empty;
							//}

							//// 选择状态文本背景绘制
							//if (selected)
							//{
							//    float correcting = 0;
							//    if (alignment == TextAlignment.RightOrBottom)
							//    {
							//        correcting = rectangle.Right - textLeft;
							//    }
							//    else if (alignment == TextAlignment.Center)
							//    {
							//        correcting = (rectangle.Right - textLeft) / 2;
							//    }
							//    else if (alignment == TextAlignment.Evenness)
							//    {
							//        correcting = (rectangle.Right - textLeft) / 2;
							//    }
							//    RectangleF textRectangleF =
							//        new RectangleF(pointerLeft + correcting,
							//                        pointerTop,
							//                        fullSizeF.Width / 4,
							//                        fullSizeF.Height + lineSpace);
							//    graphics.FillRectangle(LayoutCommon.SelectedBrush, textRectangleF);
							//}
						}
						// 一行结束
						isLineEnd = true;
						break;
					}
				}
				// 多行绘制结束
				if (isLinesEnd)
				{
					break;
				}
				// 一行绘制结束
				if (isLineEnd)
				{
					// 下一个文字位置计算
					if (isLinesStart)
					{
						textTop = textTop + fullSizeF.Height;
						isLinesStart = false;
					}
					else
					{
						textTop = textTop + lineSpace + fullSizeF.Height;
					}
					pointerTop = pointerTop + fullSizeF.Height + lineSpace;
					pointerBottom = pointerTop + fullSizeF.Height;
					// 一行文本绘制
					//lineSpaceSelectedRectangleF = DrawLineHorizontal(graphics, textRectangleFs,
					//    font, underline, strikeout, textBrush, rectangle, alignment, selected);
					if (textRectangleFs.Count > 0)
					{
						SetStringAlignmentH(textRectangleFs, rectangle, alignment, wrap, clip);
						//lineSpaceSelectedRectangleF = DrawStringRow(graphics, textRectangleFs, font, textBrush, selected);
						TextRectangleF[] trfs = new TextRectangleF[textRectangleFs.Count];
						for (int i = 0; i < textRectangleFs.Count; i++)
						{
							trfs[i] = textRectangleFs[i];
						}
						textRectangleFs.Clear();
						allTextRectFs.Add(trfs);
					}
				}
			}
			// 文本绘制结束
			if (isLinesEnd)
			{
				//if (selected && isLinesStart && isLinesEnd)
				//{
				//    // 选择状态空文本背景绘制
				//    graphics.FillRectangle(LayoutCommon.SelectedBrush, rectangle);
				//}
				if (textRectangleFs.Count > 0)
				{
					SetStringAlignmentH(textRectangleFs, rectangle, alignment, wrap, clip);
					//DrawStringRow(graphics, textRectangleFs, font, textBrush, selected);
					TextRectangleF[] trfs = new TextRectangleF[textRectangleFs.Count];
					for (int i = 0; i < textRectangleFs.Count; i++)
					{
						trfs[i] = textRectangleFs[i];
					}
					textRectangleFs.Clear();
					allTextRectFs.Add(trfs);
				}
			}

			// 垂直方向文本位置设定
			float correctingV = 0;
			if (alignmentVertical == TextAlignment.RightOrBottom)
			{
				float bottom = allTextRectFs[allTextRectFs.Count - 1][0].RectangleF.Bottom;
				correctingV = rectangle.Bottom - bottom;
				if (correctingV < 0)
				{
					correctingV = 0;
				}
				foreach (TextRectangleF[] rfs in allTextRectFs)
				{
					foreach (TextRectangleF rf in rfs)
					{
						rf.RectangleY = rf.RectangleY + correctingV;

						graphics.DrawString(rf.Text, font, textBrush, rf.RectangleF,
							LayoutCommon.StringFormatHorizontal);
					}
				}
			}
			else if (alignmentVertical == TextAlignment.Center)
			{
				float bottom = allTextRectFs[allTextRectFs.Count - 1][0].RectangleF.Bottom;
				correctingV = (rectangle.Bottom - bottom) / 2;
				if (correctingV < 0)
				{
					correctingV = 0;
				}
				foreach (TextRectangleF[] rfs in allTextRectFs)
				{
					foreach (TextRectangleF rf in rfs)
					{
						rf.RectangleY = rf.RectangleY + correctingV;

						graphics.DrawString(rf.Text, font, textBrush, rf.RectangleF,
							LayoutCommon.StringFormatHorizontal);
					}
				}
			}
			else
			{
				foreach (TextRectangleF[] rfs in allTextRectFs)
				{
					foreach (TextRectangleF rf in rfs)
					{
						graphics.DrawString(rf.Text, font, textBrush, rf.RectangleF,
							LayoutCommon.StringFormatHorizontal);
					}
				}
			}
		}

		/// <summary>
		/// 根据横向文本对齐方式，设定文本位子
		/// </summary>
		/// <param name="textRectangleFs">每个文字的范围</param>
		/// <param name="rectangleF">文本范围</param>
		/// <param name="alignment">文本对齐方式</param>
		/// <param name="wrap">是否自动文本换行</param>
		/// <param name="clip">是否剪裁延伸到边框外侧的文本</param>
		private static void SetStringAlignmentH(
					List<TextRectangleF> textRectangleFs,
					RectangleF rectangleF,
					TextAlignment alignment,
					bool wrap,
					bool clip)
		{
			//if (0 < textRectangleFs.Count)
			{
				float correcting = 0;
				float right = textRectangleFs[textRectangleFs.Count - 1].RectangleF.Right;
				// 文本对齐方式
				if (alignment == TextAlignment.RightOrBottom)
				{
					correcting = rectangleF.Right - right;
					if (wrap)
					{
						if (0 < correcting)
						{
							foreach (TextRectangleF rf in textRectangleFs)
							{
								rf.RectangleX += correcting;
							}
						}
					}
					// 不自动换行
					else
					{
						// 剪裁
						if (clip)
						{
							int count = 0;
							foreach (TextRectangleF rf in textRectangleFs)
							{
								rf.RectangleX += correcting;
								if (rf.RectangleX < rectangleF.Left)
								{
									count++;
								}
							}
							if (count > 0)
							{
								textRectangleFs.RemoveRange(0, count);
							}
						}
						// 不剪裁
						else
						{
							int count = 0;
							foreach (TextRectangleF rf in textRectangleFs)
							{
								rf.RectangleX += correcting;
								if (rf.RectangleF.Right < rectangleF.Left)
								{
									count++;
								}
							}
							if (count > 0)
							{
								textRectangleFs.RemoveRange(0, count);
							}
						}
					}
				}
				else if (alignment == TextAlignment.Center)
				{
					correcting = (rectangleF.Right - right) / 2;
					if (wrap)
					{
						if (0 < correcting)
						{
							foreach (TextRectangleF rf in textRectangleFs)
							{
								rf.RectangleX += correcting;
							}
						}
					}
					// 不自动换行
					else
					{
						// 剪裁
						if (clip)
						{
							int index = -1;
							int count = 0;
							int start = -1;
							int length = 0;
							foreach (TextRectangleF rf in textRectangleFs)
							{
								index++;
								rf.RectangleX += correcting;
								if (rf.RectangleX < rectangleF.Left)
								{
									count++;
								}
								else if (rectangleF.Right < rf.RectangleF.Right)
								{
									if (start < 0)
									{
										start = index;
									}
									length++;
								}
							}
							if (length > 0)
							{
								textRectangleFs.RemoveRange(start, length);
							}
							if (count > 0)
							{
								textRectangleFs.RemoveRange(0, count);
							}
						}
						else
						{
							int index = -1;
							int count = 0;
							int start = -1;
							int length = 0;
							foreach (TextRectangleF rf in textRectangleFs)
							{
								index++;
								rf.RectangleX += correcting;
								if (rf.RectangleF.Right < rectangleF.Left)
								{
									count++;
								}
								else if (rectangleF.Right < rf.RectangleX)
								{
									if (start < 0)
									{
										start = index;
									}
									length++;
								}
							}
							if (length > 0)
							{
								textRectangleFs.RemoveRange(start, length);
							}
							if (count > 0)
							{
								textRectangleFs.RemoveRange(0, count);
							}
						}
					}
				}
				else if (alignment == TextAlignment.Evenness)
				{
					if (1 < textRectangleFs.Count)
					{
						correcting = (rectangleF.Right - right) / (textRectangleFs.Count - 1);
						if (correcting > 0)
						{
							for (int i = 0; i < textRectangleFs.Count; i++)
							{
								textRectangleFs[i].RectangleX += correcting * i;
							}
						}
					}
					else
					{
						textRectangleFs[0].RectangleX += (rectangleF.Right - right) / 2;
					}
				}
			}
		}

//        /// <summary>
//        /// 横向绘制单行文本
//        /// </summary>
//        /// <param name="graphics">Graphics</param>
//        /// <param name="textRectangleFs">每个文字的范围</param>
//        /// <param name="font">字体</param>
//        /// <param name="textBrush">文本笔刷</param>
//        /// <param name="selected">是否选择</param>
//        /// <returns>文本行间隔范围</returns>
//        private static RectangleF DrawStringRow(
//                    Graphics graphics,
//                    List<TextRectangleF> textRectangleFs,
//                    Font font,
//                    SolidBrush textBrush,
//                    bool selected)
//        {
//            //if (0 < textRectangleFs.Count)
//            {
//                //// 文字绘制范围
//                //float width = textRectangleFs[textRectangleFs.Count - 1].RectangleF.Right
//                //        - textRectangleFs[0].RectangleF.Left;
//                //RectangleF selectedRectangleF =
//                //    new RectangleF(textRectangleFs[0].RectangleF.Left,
//                //                   textRectangleFs[0].RectangleF.Top,
//                //                   width,
//                //                   textRectangleFs[0].RectangleF.Height);

//                //RectangleF lineSpaceSelectedRectangleF = RectangleF.Empty;
//                //if (selected)
//                //{
//                //    // 选择状态文字的背景绘制
//                //    graphics.FillRectangle(LayoutCommon.SelectedBrush, selectedRectangleF);
//                //    lineSpaceSelectedRectangleF.X = selectedRectangleF.Left;
//                //    lineSpaceSelectedRectangleF.Y = selectedRectangleF.Bottom;
//                //    lineSpaceSelectedRectangleF.Width = selectedRectangleF.Width;
//                //}
//                foreach (TextRectangleF rf in textRectangleFs)
//                {
//#if DRAWTEST
//                    graphics.DrawRectangle(new Pen(Color.Blue, 0.1f), rf.RectangleF.X, rf.RectangleF.Y, rf.RectangleF.Width, rf.RectangleF.Height);
//#endif
//                    graphics.DrawString(rf.Text, font, textBrush, rf.RectangleF,
//                        LayoutCommon.StringFormatHorizontal);
//                }
//                textRectangleFs.Clear();
//                //return lineSpaceSelectedRectangleF;
//            }
//        }
		#endregion 绘制文本
		#endregion 函数
	}
}