garden_client/Assets/Tookits/TextUtility/RichText.cs

using UnityEngine.EventSystems;

namespace textUtility
{


		using System;
		using System.Collections.Generic;
		using System.Text;
		using System.Text.RegularExpressions;
		using UnityEditor.VisualStudioIntegration;
		using UnityEngine;
		using UnityEngine.UI;
	
	[Serializable]
	public class RichText : Text, IPointerClickHandler
	{
	    private class ParseResult
	    {
	        public int ExtraOffset;
	        public string NewText;
	        public BaseMatch Match;
	    }
	
	    #region Config
	
	    private List<string> OpenPatterns
	    {
	        get
	        {
	            if (!openPatterns.IsAvailable())
	            {
	                openPatterns = new List<string>();
	                openPatterns.Add(SpriteOpenPattern);
	                openPatterns.Add(UnderlineOpenPattern);
	                openPatterns.Add(SuperlinkOpenPattern);
	            }
	            return openPatterns;
	        }
	    }
	    private List<string> openPatterns;
	
	    private List<string> ClosePatterns
	    {
	        get
	        {
	            if (!closePatterns.IsAvailable())
	            {
	                closePatterns = new List<string>();
	                closePatterns.Add(SpriteClosePattern);
	                closePatterns.Add(UnderlineClosePattern);
	                closePatterns.Add(SuperlinkClosePattern);
	            }
	            return closePatterns;
	        }
	    }
	    private List<string> closePatterns;
	
	    private Dictionary<string, Func<string, MatchData, ParseResult>> OpenCloseParseFunctionDictionary
	    {
	        get
	        {
	            if (!openCloseParseFunctionDictionary.IsAvailable())
	            {
	                openCloseParseFunctionDictionary = new Dictionary<string, Func<string, MatchData, ParseResult>>();
	                openCloseParseFunctionDictionary.Add(SpriteOpenPattern, ParseSpritePattern);
	                openCloseParseFunctionDictionary.Add(UnderlineOpenPattern, ParseUnderlinePattern);
	                openCloseParseFunctionDictionary.Add(SuperlinkOpenPattern, ParseSuperlinkPattern);
	            }
	            return openCloseParseFunctionDictionary;
	        }
	    }
	    private Dictionary<string, Func<string, MatchData, ParseResult>> openCloseParseFunctionDictionary;
	
	    public bool SpriteFoldout;
	    public string SpriteOpenPattern = "<(";
	    public string SpriteClosePattern = ")>";
	    public char SpriteReplaceChar = ' ';
	    public List<SpriteSetting> SpriteSettings; //todo 可能为空
	    private Dictionary<int, SpriteSetting> SpriteSettingDictionary
	    {
	        get
	        {
	            if (!spriteSettingDictionary.IsAvailable())
	            {
	                spriteSettingDictionary = new Dictionary<int, SpriteSetting>();
	                foreach (var item in SpriteSettings)
	                {
	                    spriteSettingDictionary.Add(item.ID, item);
	                }
	            }
	            return spriteSettingDictionary;
	        }
	        set { spriteSettingDictionary = value; }
	    }
	    private Dictionary<int, SpriteSetting> spriteSettingDictionary;
	    private List<BaseMatch> AvailableSpriteMatches = new List<BaseMatch>();
	    private List<BaseMatch> TruncateSpriteMatches = new List<BaseMatch>();
	
	    public bool UnderlineFoldout;
	    public string UnderlineOpenPattern = "<[";
	    public string UnderlineClosePattern = "]>";
	    public List<UnderlineSetting> UnderlineSettings; //todo 可能为空
	    private Dictionary<int, UnderlineSetting> UnderlineSettingDictionary
	    {
	        get
	        {
	            if (!underlineSettingDictionary.IsAvailable())
	            {
	                underlineSettingDictionary = new Dictionary<int, UnderlineSetting>();
	                foreach (var item in UnderlineSettings)
	                {
	                    underlineSettingDictionary.Add(item.ID, item);
	                }
	            }
	            return underlineSettingDictionary;
	        }
	        set { underlineSettingDictionary = value; }
	    }
	    private Dictionary<int, UnderlineSetting> underlineSettingDictionary;
	    private List<BaseMatch> UnderlineMatches = new List<BaseMatch>();
	
	    public bool SuperlinkFoldout;
	    public string SuperlinkOpenPattern = "<{";
	    public string SuperlinkClosePattern = "}>";
	    public List<SuperlinkSetting> SuperlinkSettings; //todo 可能为空
	    public Dictionary<int, Action<int>> SuperlinkCallbackDictionary = new Dictionary<int, Action<int>>();
	    private Dictionary<int, SuperlinkSetting> SuperlinkSettingDictionary
	    {
	        get
	        {
	            if (superlinkSettingDictionary == null)
	            {
	                superlinkSettingDictionary = new Dictionary<int, SuperlinkSetting>();
	                foreach (var item in SuperlinkSettings)
	                {
	                    superlinkSettingDictionary.Add(item.ID, item);
	                }
	            }
	            return superlinkSettingDictionary;
	        }
	    }
	    private Dictionary<int, SuperlinkSetting> superlinkSettingDictionary;
	    private List<BaseMatch> SuperlinkMatches = new List<BaseMatch>();
	
	    private char TransferSpaceReplaceChar = 'i';
	    private List<BaseMatch> TransferSpaceMatches = new List<BaseMatch>();
	    private List<List<BaseMatch>> MatchesList = new List<List<BaseMatch>>();
	
	    public int MinSize
	    {
	        get { return minSize; }
	        set
	        {
	            minSize = value;
	            ApplyVerticalBestfitSize();
	        }
	    }
	    public int minSize = 10;
	
	    public int MaxSize
	    {
	        get { return maxSize; }
	        set
	        {
	            maxSize = value;
	            ApplyVerticalBestfitSize();
	        }
	    }
	    public int maxSize = 40;
	
	    public bool VerticalBestfitFoldout;
	    public bool UseOriginBestfit;
	    public bool UseVerticalBestfit;
	    public bool VerticalBestfitDirty;
	
	    public bool Debug;
	    public bool Foldout = true;
	    public bool CalculateFlag;
	    public string Content;
	    public string IDPattern = "\\(\\d+\\)";
	    public KerningSolution KerningSolution;
	    public RichTextImageManager ImageManager;
	
	    private char CalculateReferenceChar = 'i';
	    private TextGenerator CalculateTextGenerator;
	
	    #endregion
	
	    protected override void Awake()
	    {
	        base.Awake();
	
	        if (Debug)
	        {
	            text = Content;
	            UnityEngine.Debug.LogWarning("没有关闭Debug", gameObject);
	        }
	    }
	
	    protected override void OnPopulateMesh(VertexHelper toFill)
	    {
	        if (CalculateFlag)
	        {
	            CalculateFlag = false;
	        }
	        else
	        {
	            string newText = Content;

	            if (Application.isPlaying || Debug)
	            {
	                bool addNewOpenCloseMatch = ParseAndFillMatches(ref newText);
	                if (addNewOpenCloseMatch)
	                {
	                    AddNewOpenCloseMatch(newText);
	                }
	                CalculateFlag = addNewOpenCloseMatch;
	            }
	
	            if (UseVerticalBestfit && horizontalOverflow != HorizontalWrapMode.Overflow && verticalOverflow != VerticalWrapMode.Overflow)
	            {
	                if (VerticalBestfitDirty)
	                {
	                    int verticalBestfitFontSize = GetVerticalBestfitFontSize(newText);
	                    if (fontSize != verticalBestfitFontSize)
	                    {
	                        DelayCall.Call(1, () => { fontSize = verticalBestfitFontSize; });
	                        VerticalBestfitDirty = false;
	                        CalculateFlag = true;
	                    }
	                }
	                else
	                {
	                    VerticalBestfitDirty = true;
	                }
	            }
	
	            if (CalculateFlag)
	            {
	                return;
	            }
	        }
	
	        base.OnPopulateMesh(toFill);
	
	        List<UIVertex> vertices = new List<UIVertex>();
	        toFill.GetUIVertexStream(vertices);
	        ImageManager.Vertices = vertices;
	
	        HandleTransferSpaceMatch(toFill, vertices);
	
	        for (int i = 0; i < vertices.Count; i += 6)
	        {
	            Vector3 position0 = transform.TransformPoint(vertices[0 + i].position);
	            Vector3 position1 = transform.TransformPoint(vertices[1 + i].position);
	            Vector3 position2 = transform.TransformPoint(vertices[2 + i].position);
	            Vector3 position3 = transform.TransformPoint(vertices[4 + i].position);
	
	            UnityEngine.Debug.DrawLine(position0, position1, Color.black, 1);
	            UnityEngine.Debug.DrawLine(position1, position2, Color.black, 1);
	            UnityEngine.Debug.DrawLine(position2, position3, Color.black, 1);
	            UnityEngine.Debug.DrawLine(position3, position0, Color.black, 1);
	        }
	
	        if (KerningSolution == KerningSolution.Precalculate)
	        {
	            for (int i = 0; i < AvailableSpriteMatches.Count; i++)
	            {
	                SpriteMatch spriteMatch = (SpriteMatch)AvailableSpriteMatches[i];
	                int index0 = 4 + spriteMatch.StartIndex * 6;
	                int index1 = 3 + spriteMatch.EndIndex * 6;
	                Vector3 leftPosition = vertices[index0].position;
	                Vector3 rightPosition = vertices[index1].position;
	                Vector3 bottomMiddle = (leftPosition + rightPosition) / 2;
	                Vector3 position0;
	                Vector3 position1;
	                Vector3 position2;
	                Vector3 position3;
	                spriteMatch.ScaledHeight = spriteMatch.SpriteInfo.GetScaledHeight(spriteMatch.ScaledWidth);
	                position0 = bottomMiddle + new Vector3(-spriteMatch.ScaledWidth / 2, 0, 0);
	                position1 = bottomMiddle + new Vector3(spriteMatch.ScaledWidth / 2, 0, 0);
	                position2 = bottomMiddle + new Vector3(spriteMatch.ScaledWidth / 2, spriteMatch.ScaledHeight, 0);
	                position3 = bottomMiddle + new Vector3(-spriteMatch.ScaledWidth / 2, spriteMatch.ScaledHeight, 0);
	                position0 = transform.TransformPoint(position0);
	                position1 = transform.TransformPoint(position1);
	                position2 = transform.TransformPoint(position2);
	                position3 = transform.TransformPoint(position3);
	                spriteMatch.Positions.Add(position0);
	                spriteMatch.Positions.Add(position1);
	                spriteMatch.Positions.Add(position2);
	                spriteMatch.Positions.Add(position3);
	            }
	        }
	        else if (KerningSolution == KerningSolution.Shrink)
	        {
	            Dictionary<SpriteInfo, Dictionary<int, List<SpriteMatch>>> dictionary = new Dictionary<SpriteInfo, Dictionary<int, List<SpriteMatch>>>();
	            for (int i = 0; i < AvailableSpriteMatches.Count; i++)
	            {
	                SpriteMatch spriteMatch = (SpriteMatch)AvailableSpriteMatches[i];
	                if (dictionary.ContainsKey(spriteMatch.SpriteInfo))
	                {
	                    if (dictionary[spriteMatch.SpriteInfo].ContainsKey(spriteMatch.Length))
	                    {
	                        dictionary[spriteMatch.SpriteInfo][spriteMatch.Length].Add(spriteMatch);
	                    }
	                    else
	                    {
	                        List<SpriteMatch> matches = new List<SpriteMatch>();
	                        matches.Add(spriteMatch);
	                        dictionary[spriteMatch.SpriteInfo].Add(spriteMatch.Length, matches);
	                    }
	                }
	                else
	                {
	                    List<SpriteMatch> matches = new List<SpriteMatch>();
	                    matches.Add(spriteMatch);
	                    Dictionary<int, List<SpriteMatch>> lengthDictionary = new Dictionary<int, List<SpriteMatch>>();
	                    lengthDictionary.Add(spriteMatch.Length, matches);
	                    dictionary.Add(spriteMatch.SpriteInfo, lengthDictionary);
	                }
	            }
	
	            foreach (var lengthDictionary in dictionary)
	            {
	                foreach (var matches in lengthDictionary.Value.Values)
	                {
	                    float minScaledWidth = Mathf.Infinity;
	                    for (int i = 0; i < matches.Count; i++)
	                    {
	                        float scaledWidth = matches[i].ScaledWidth;
	                        int frontIndex = matches[i].StartIndex - 1;
	                        int rearIndex = matches[i].EndIndex + 1;
	                        float frontKerning;
	                        float rearKerning;
	                        if (frontIndex < 0)
	                        {
	                            frontKerning = 0;
	                        }
	                        else
	                        {
	                            frontKerning = GetKerning(text[frontIndex], SpriteReplaceChar);
	                        }
	                        if (rearIndex >= text.Length)
	                        {
	                            rearKerning = 0;
	                        }
	                        else
	                        {
	                            rearKerning = GetKerning(SpriteReplaceChar, text[rearIndex]);
	                        }
	                        if (frontKerning < 0)
	                        {
	                            scaledWidth += frontKerning;
	                        }
	                        if (rearKerning < 0)
	                        {
	                            scaledWidth += rearKerning;
	                        }
	                        if (minScaledWidth > scaledWidth)
	                        {
	                            minScaledWidth = scaledWidth;
	                        }
	                        matches[i].FrontKerning = frontKerning;
	                        matches[i].RearKerning = rearKerning;
	                    }
	                    float minScaledHeight = lengthDictionary.Key.GetScaledHeight(minScaledWidth);
	                    for (int i = 0; i < matches.Count; i++)
	                    {
	                        matches[i].ScaledWidth = minScaledWidth;
	                        matches[i].ScaledHeight = minScaledHeight;
	                    }
	                }
	            }
	
	            for (int i = 0; i < AvailableSpriteMatches.Count; i++)
	            {
	                SpriteMatch spriteMatch = (SpriteMatch)AvailableSpriteMatches[i];
	                int index0 = 4 + spriteMatch.StartIndex * 6;
	                int index1 = 3 + spriteMatch.EndIndex * 6;
	                Vector3 leftPosition = vertices[index0].position;
	                Vector3 rightPosition = vertices[index1].position;
	                leftPosition.x -= spriteMatch.FrontKerning;
	                rightPosition.x += spriteMatch.RearKerning;
	                Vector3 bottomMiddle = (leftPosition + rightPosition) / 2;
	                Vector3 position0;
	                Vector3 position1;
	                Vector3 position2;
	                Vector3 position3;
	                position0 = bottomMiddle + new Vector3(-spriteMatch.ScaledWidth / 2, 0, 0);
	                position1 = bottomMiddle + new Vector3(spriteMatch.ScaledWidth / 2, 0, 0);
	                position2 = bottomMiddle + new Vector3(spriteMatch.ScaledWidth / 2, spriteMatch.ScaledHeight, 0);
	                position3 = bottomMiddle + new Vector3(-spriteMatch.ScaledWidth / 2, spriteMatch.ScaledHeight, 0);
	                position0 = transform.TransformPoint(position0);
	                position1 = transform.TransformPoint(position1);
	                position2 = transform.TransformPoint(position2);
	                position3 = transform.TransformPoint(position3);
	                spriteMatch.Positions.Add(position0);
	                spriteMatch.Positions.Add(position1);
	                spriteMatch.Positions.Add(position2);
	                spriteMatch.Positions.Add(position3);
	            }
	        }
	
	        for (int i = 0; i < UnderlineMatches.Count; i++)
	        {
	            UnderlineMatch match = UnderlineMatches[i] as UnderlineMatch;
	            //print(match.StartIndex + "  " + match.EndIndex);
	            GetSegments(text, CalculateTextGenerator, match, match.UnderlineSetting.UnderlineExcludeChars);
	            for (int j = 0; j < match.Segments.Count; j++)
	            {
	                int startCharIdx = match.Segments[j][0];
	                int endCharIdx = match.Segments[j][1];
	                //print(startCharIdx + "  " + endCharIdx);
	                int lineIndex = GetLineIndex(CalculateTextGenerator, startCharIdx);
	                int lineEndCharacterIndex;
	                float penPositionY = GetPenPositionY(lineIndex, CalculateTextGenerator.lineCount);
	                float lineHeight = CalculateTextGenerator.lines[lineIndex].height;
	                if (lineIndex != -1)
	                {
	                    lineEndCharacterIndex = GetLineEndCharacterIndex(CalculateTextGenerator, lineIndex, text.Length);
	                }
	                else
	                {
	                    break;
	                }
	                int newEndCharIdx = Mathf.Min(lineEndCharacterIndex, endCharIdx);
	                List<Vector3> positions = new List<Vector3>();
	                Vector3 position0 = vertices[4 + startCharIdx * 6].position;
	                Vector3 position1 = vertices[2 + newEndCharIdx * 6].position;
	                position0.y = penPositionY;
	                position1.y = penPositionY;
	                Vector3 position2 = position1;
	                Vector3 position3 = position0;
	                float underlineHeight = lineHeight * match.UnderlineSetting.Scale;
	                position2.y -= underlineHeight;
	                position3.y -= underlineHeight;
	                if (match.UnderlineSetting.Style == UnderlineStyle.Ellipse)
	                {
	                    if (vertices[1 + endCharIdx*6].position.x - vertices[0 + startCharIdx*6].position.x > underlineHeight*2)
	                    {
	                        position0.x += underlineHeight;
	                        position1.x -= underlineHeight;
	                        position2.x -= underlineHeight;
	                        position3.x += underlineHeight;
	                        List<Vector3> topHemispherePositions = new List<Vector3>();
	                        List<Vector3> bottomHemispherePositions = new List<Vector3>();
	                        int cutCount = Mathf.Max(4, Mathf.CeilToInt(underlineHeight));
	                        float radius = underlineHeight/2;
	                        for (int k = 0; k <= cutCount; k++)
	                        {
	                            float angle = 90f/cutCount*k;
	                            float radian = angle*Mathf.Deg2Rad;
	                            float x = radius * Mathf.Sin(radian);
	                            float y = radius * Mathf.Cos(radian);
	                            topHemispherePositions.Add(new Vector3(x, y, 0));
	                            if (k != cutCount)
	                            {
	                                bottomHemispherePositions.Insert(0, new Vector3(x, -y, 0));
	                            }
	                        }
	                        List<List<Vector3>> ellipsePositionsList = new List<List<Vector3>>();
	                        List<Vector3> ellipsePositions = new List<Vector3>(); //右半球
	                        ellipsePositions.Add((position1+position2)/2);
	                        foreach (var position in topHemispherePositions)
	                        {
	                            Vector3 newPosition = ellipsePositions[0] + position;
	                            ellipsePositions.Add(newPosition);
	                        }
	                        //ellipsePositions.Add(ellipsePositions[0] + new Vector3(radius, 0, 0));
	                        foreach (var position in bottomHemispherePositions)
	                        {
	                            Vector3 newPosition = ellipsePositions[0] + position;
	                            ellipsePositions.Add(newPosition);
	                        }
	                        for (int k = 0; k < ellipsePositions.Count; k++)
	                        {
	                            ellipsePositions[k] = rectTransform.TransformPoint(ellipsePositions[k]);
	                        }
	                        ellipsePositionsList.Add(ellipsePositions);
	                        ellipsePositions = new List<Vector3>(); //左半球
	                        ellipsePositions.Add((position0 + position3) / 2);
	                        foreach (var position in topHemispherePositions)
	                        {
	                            Vector3 newPosition = ellipsePositions[0];
	                            newPosition.x -= position.x;
	                            newPosition.y += position.y;
	                            ellipsePositions.Add(newPosition);
	                        }
	                        //ellipsePositions.Add(ellipsePositions[0] + new Vector3(-radius, 0, 0));
	                        foreach (var position in bottomHemispherePositions)
	                        {
	                            Vector3 newPosition = ellipsePositions[0];
	                            newPosition.x -= position.x;
	                            newPosition.y += position.y;
	                            ellipsePositions.Add(newPosition);
	                        }
	                        for (int k = 0; k < ellipsePositions.Count; k++)
	                        {
	                            ellipsePositions[k] = rectTransform.TransformPoint(ellipsePositions[k]);
	                        }
	                        ellipsePositionsList.Add(ellipsePositions);
	                        match.EllipsePositionsList.Add(ellipsePositionsList);
	                    }
	                }
	                positions.Add(position0);
	                positions.Add(position1);
	                positions.Add(position2);
	                positions.Add(position3);
	                positions[0] = rectTransform.TransformPoint(positions[0]);
	                positions[1] = rectTransform.TransformPoint(positions[1]);
	                positions[2] = rectTransform.TransformPoint(positions[2]);
	                positions[3] = rectTransform.TransformPoint(positions[3]);
	                match.RectanglePositionsList.Add(positions);
	                if (endCharIdx > lineEndCharacterIndex)
	                {
	                    break;
	                }
	            }
	        }
	        //print(SuperlinkMatches.Count);
	        for (int i = 0; i < SuperlinkMatches.Count; i++)
	        {
	            SuperlinkMatch match = SuperlinkMatches[i] as SuperlinkMatch;
	            //print(match.StartIndex + "  " + match.EndIndex);
	            GetSegments(text, CalculateTextGenerator, match, match.SuperlinkSetting.SuperlinkExcludeChars);
	            for (int j = 0; j < match.Segments.Count; j++)
	            {
	                int startCharIdx = match.Segments[j][0];
	                int endCharIdx = match.Segments[j][1];
	                //print(startCharIdx + "  " + endCharIdx);
	                int lineIndex = GetLineIndex(CalculateTextGenerator, startCharIdx);
	                int lineEndCharacterIndex;
	                float lineCenterY = GetLineCenterY(lineIndex, CalculateTextGenerator.lineCount);
	                float lineHeight = CalculateTextGenerator.lines[lineIndex].height;
	                if (lineIndex != -1)
	                {
	                    lineEndCharacterIndex = GetLineEndCharacterIndex(CalculateTextGenerator, lineIndex, text.Length);
	                }
	                else
	                {
	                    break;
	                }
	                int newEndCharIdx = Mathf.Min(lineEndCharacterIndex, endCharIdx);
	                List<Vector3> positions = new List<Vector3>();
	                float lineMaxY = lineCenterY + (lineHeight / 2) * match.SuperlinkSetting.Scale;
	                float lineMinY = lineCenterY - (lineHeight / 2) * match.SuperlinkSetting.Scale;
	                Vector3 position0 = vertices[4 + startCharIdx * 6].position;
	                Vector3 position1 = vertices[2 + newEndCharIdx * 6].position;
	                Vector3 position2 = position1;
	                Vector3 position3 = position0;
	                position0.y = lineMaxY;
	                position1.y = lineMaxY;
	                position2.y = lineMinY;
	                position3.y = lineMinY;
	                positions.Add(position0);
	                positions.Add(position1);
	                positions.Add(position2);
	                positions.Add(position3);
	                positions[0] = rectTransform.TransformPoint(positions[0]);
	                positions[1] = rectTransform.TransformPoint(positions[1]);
	                positions[2] = rectTransform.TransformPoint(positions[2]);
	                positions[3] = rectTransform.TransformPoint(positions[3]);
	                match.RectanglePositionsList.Add(positions);
	                if (endCharIdx > lineEndCharacterIndex)
	                {
	                    break;
	                }
	            }
	        }
	
	        for (int i = 0; i < AvailableSpriteMatches.Count; i++)
	        {
	            SpriteMatch match = (SpriteMatch)AvailableSpriteMatches[i];
	            Vector3 position0 = match.Positions[0];
	            Vector3 position1 = match.Positions[1];
	            Vector3 position2 = match.Positions[2];
	            Vector3 position3 = match.Positions[3];
	            UnityEngine.Debug.DrawLine(position0, position1, Color.red, 1);
	            UnityEngine.Debug.DrawLine(position1, position2, Color.red, 1);
	            UnityEngine.Debug.DrawLine(position2, position3, Color.red, 1);
	            UnityEngine.Debug.DrawLine(position3, position0, Color.red, 1);
	        }
	
	        for (int i = 0; i < UnderlineMatches.Count; i++)
	        {
	            UnderlineMatch match = (UnderlineMatch)UnderlineMatches[i];
	            for (int j = 0; j < match.RectanglePositionsList.Count; j++)
	            {
	                Vector3 position0 = match.RectanglePositionsList[j][0];
	                Vector3 position1 = match.RectanglePositionsList[j][1];
	                Vector3 position2 = match.RectanglePositionsList[j][2];
	                Vector3 position3 = match.RectanglePositionsList[j][3];
	                UnityEngine.Debug.DrawLine(position0, position1, Color.blue, 1);
	                UnityEngine.Debug.DrawLine(position1, position2, Color.blue, 1);
	                UnityEngine.Debug.DrawLine(position2, position3, Color.blue, 1);
	                UnityEngine.Debug.DrawLine(position3, position0, Color.blue, 1);
	            }
	            for (int j = 0; j < match.EllipsePositionsList.Count; j++)
	            {
	                for (int k = 0; k < match.EllipsePositionsList[j].Count; k++)
	                {
	                    for (int l = 1; l < match.EllipsePositionsList[j][k].Count - 1; l++)
	                    {
	                        Vector3 position0 = match.EllipsePositionsList[j][k][0];
	                        Vector3 position1 = match.EllipsePositionsList[j][k][l + 0];
	                        Vector3 position2 = match.EllipsePositionsList[j][k][l + 1];
	                        UnityEngine.Debug.DrawLine(position0, position1, Color.blue, 1);
	                        UnityEngine.Debug.DrawLine(position1, position2, Color.blue, 1);
	                        UnityEngine.Debug.DrawLine(position2, position0, Color.blue, 1);
	                    }
	                }
	            }
	        }
	
	        for (int i = 0; i < SuperlinkMatches.Count; i++)
	        {
	            SuperlinkMatch match = (SuperlinkMatch)SuperlinkMatches[i];
	            for (int j = 0; j < match.RectanglePositionsList.Count; j++)
	            {
	                Vector3 position0 = match.RectanglePositionsList[j][0];
	                Vector3 position1 = match.RectanglePositionsList[j][1];
	                Vector3 position2 = match.RectanglePositionsList[j][2];
	                Vector3 position3 = match.RectanglePositionsList[j][3];
	                UnityEngine.Debug.DrawLine(position0, position1, Color.green, 1);
	                UnityEngine.Debug.DrawLine(position1, position2, Color.green, 1);
	                UnityEngine.Debug.DrawLine(position2, position3, Color.green, 1);
	                UnityEngine.Debug.DrawLine(position3, position0, Color.green, 1);
                }
	        }
	    }
	
	
	    public void SetContent(string content)
	    {
	        Content = content;
	        text = content;
	    }
	
	    public void ClearMatches()
	    {
	        AvailableSpriteMatches = new List<BaseMatch>();
	        TruncateSpriteMatches = new List<BaseMatch>();
	        UnderlineMatches = new List<BaseMatch>();
	        SuperlinkMatches = new List<BaseMatch>();
	        TransferSpaceMatches = new List<BaseMatch>();
	        MatchesList = new List<List<BaseMatch>>();
	        SuperlinkCallbackDictionary = new Dictionary<int, Action<int>>();
	    }
	
	    private bool ParseMatches(ref string newText)
	    {
	        bool haveMatch = false;
	        AvailableSpriteMatches = new List<BaseMatch>();
	        UnderlineMatches = new List<BaseMatch>();
	        SuperlinkMatches = new List<BaseMatch>();
	        TransferSpaceMatches = new List<BaseMatch>();
	        MatchesList = new List<List<BaseMatch>>
	        {
	            AvailableSpriteMatches,
	            UnderlineMatches,
	            SuperlinkMatches,
	            TransferSpaceMatches,
	        };
	
	        newText = ParseTransferSpaceMatches(newText);
	        newText = ParseOpenCloseMatches(newText);
	
	        if (TransferSpaceMatches.Count > 0)
	        {
	            haveMatch = true;
	        }
	        if (AvailableSpriteMatches.Count > 0)
	        {
	            haveMatch = true;
	        }
	        if (UnderlineMatches.Count > 0)
	        {
	            haveMatch = true;
	        }
	        if (SuperlinkMatches.Count > 0)
	        {
	            haveMatch = true;
	        }
	        return haveMatch;
	    }
	
	    private string ParseTransferSpaceMatches(string newText)
	    {
	        string pattern = "\\\\ ";
	        Match match = Regex.Match(newText, pattern);
	        while (match.Success)
	        {
	            MatchData matchData = new MatchData();
	            matchData.OpenPatternIndex = match.Index;
	            matchData.MatchLength = match.Length;
	
	            TransferSpaceMatch transferSpaceMatch = new TransferSpaceMatch();
	            transferSpaceMatch.StartIndex = matchData.OpenPatternIndex;
	            transferSpaceMatch.EndIndex = matchData.OpenPatternIndex;
	            TransferSpaceMatches.Add(transferSpaceMatch);
	
	            newText = newText.Replace(match.Index, match.Length, TransferSpaceReplaceChar.ToString());
	            match = Regex.Match(newText, pattern);
	        }
	        return newText;
	    }
	
	    private string ParseOpenCloseMatches(string newText)
	    {
	        if (OpenPatterns.Count == 0 || ClosePatterns.Count == 0)
	        {
	            return newText;
	        }
	        if (OpenPatterns.Count != ClosePatterns.Count)
	        {
	            return newText;
	        }
	
	        List<string> transferedOpenPatterns = new List<string>();
	        foreach (var openPattern in OpenPatterns)
	        {
	            transferedOpenPatterns.Add(openPattern.GetTransferedPattern());
	        }
	        List<string> transferedClosePatterns = new List<string>();
	        foreach (var closePattern in ClosePatterns)
	        {
	            transferedClosePatterns.Add(closePattern.GetTransferedPattern());
	        }
	        string orOpenPattern = transferedOpenPatterns.ToOrPattern();
	        string orClosePattern = transferedClosePatterns.ToOrPattern();
	        string regexPattern = string.Format("{0}.+{1}", orOpenPattern, orClosePattern);
	
	        Match match = Regex.Match(newText, regexPattern, RegexOptions.Singleline);
	        while (match.Success)
	        {
	            Dictionary<string, int> openPatternIndexDictionary = new Dictionary<string, int>();
	            Dictionary<string, int> closePatternIndexDictionary = new Dictionary<string, int>();
	            for (int i = 0; i < OpenPatterns.Count; i++)
	            {
	                int index = match.Value.LastIndexOf(OpenPatterns[i]);
	                if (index == -1) continue;
	                else openPatternIndexDictionary.Add(OpenPatterns[i], index);
	            }
	            for (int i = 0; i < ClosePatterns.Count; i++)
	            {
	                string closeRegexPattern = ClosePatterns[i].GetTransferedPattern();
	                Match closePatternMatch = Regex.Match(match.Value, closeRegexPattern);
	                while (closePatternMatch.Success)
	                {
	                    if (openPatternIndexDictionary[OpenPatterns[i]] > closePatternMatch.Index)
	                    {
	                        closePatternMatch = closePatternMatch.NextMatch();
	                    }
	                    else
	                    {
	                        closePatternIndexDictionary.Add(ClosePatterns[i], closePatternMatch.Index);
	                        break;
	                    }
	                }
	            }
	
	            int[] openPatternIndexLength = new int[2];
	            int[] closePatternIndexLength = new int[2];
	            int dictionaryIndex = openPatternIndexDictionary.MyMax((pattern, index) => index);
	            KVPair<string, int> pair = openPatternIndexDictionary.GetAtIndex(dictionaryIndex);
	            openPatternIndexLength[0] = pair.value;
	            openPatternIndexLength[1] = pair.key.Length;
	            pair = closePatternIndexDictionary.GetAtIndex(dictionaryIndex);
	            closePatternIndexLength[0] = pair.value;
	            closePatternIndexLength[1] = pair.key.Length;
	
	            int openPatternIndex = openPatternIndexLength[0];
	            int openPatternLength = openPatternIndexLength[1];
	            int closePatternIndex = closePatternIndexLength[0];
	            int closePatternLength = closePatternIndexLength[1];
	            int contentIndex = openPatternIndex + openPatternLength;
	            int contentLength = closePatternIndex - contentIndex;
	            int matchLength = closePatternIndex + closePatternLength - openPatternIndex;
	            string matchValue = match.Value.Substring(openPatternIndex, matchLength);
	            string openPattern = match.Value.Substring(openPatternIndex, openPatternLength);
	            string closePattern = match.Value.Substring(closePatternIndex, closePatternLength);
	
	            MatchData matchData = new MatchData();
	            matchData.OpenPatternIndex = openPatternIndex + match.Index;
	            matchData.OpenPatternLength = openPatternLength;
	            matchData.ClosePatternIndex = closePatternIndex + match.Index;
	            matchData.ClosePatternLength = closePatternLength;
	            matchData.ContentIndex = contentIndex + match.Index;
	            matchData.ContentLength = contentLength;
	            matchData.MatchLength = matchLength;
	            matchData.MatchValue = matchValue;
	            matchData.OpenPattern = openPattern;
	            matchData.ClosePattern = closePattern;
	
	            ParseResult parseResult = OpenCloseParseFunctionDictionary[openPattern].Invoke(newText, matchData);
	            for (int i = 0; i < OpenPatterns.Count; i++)
	            {
	                if (matchData.OpenPattern != OpenPatterns[i]) continue;
	                MatchesList[i].Add(parseResult.Match);
	                for (int j = 0; j < MatchesList.Count; j++)
	                {
	                    AdjustIndicesByMatch(parseResult.ExtraOffset, parseResult.Match, MatchesList[j]);
	                }
	            }
	            newText = parseResult.NewText;
	            match = Regex.Match(newText, regexPattern);
	        }
	        return newText;
	    }
	
	    private ParseResult ParseSpritePattern(string newText, MatchData matchData)
	    {
	        int id = 0;
	        string name;
	        string content = newText.Substring(matchData.ContentIndex, matchData.ContentLength);
	        Match idMatch = Regex.Match(content, IDPattern);
	        if (idMatch.Success)
	        {
	            Match match = Regex.Match(idMatch.Value, "\\d+");
	            id = int.Parse(match.Value);
	            name = content.Replace(idMatch.Index, idMatch.Length, "");
	        }
	        else
	        {
	            name = content;
	        }
	        newText = newText.Replace(matchData.OpenPatternIndex, matchData.MatchLength, SpriteReplaceChar.ToString());
	
	        SpriteMatch spriteMatch = new SpriteMatch();
	        spriteMatch.ID = id;
	        spriteMatch.Name = name;
	        spriteMatch.SpriteSetting = SpriteSettingDictionary[id];
	        spriteMatch.MatchData = matchData;
	        spriteMatch.StartIndex = matchData.OpenPatternIndex;
	        spriteMatch.EndIndex = matchData.OpenPatternIndex;
	        ParseResult parseResult = new ParseResult();
	        parseResult.Match = spriteMatch;
	        parseResult.ExtraOffset = -matchData.ContentLength + 1;
	        parseResult.NewText = newText;
	        return parseResult;
	    }
	
	    private ParseResult ParseUnderlinePattern(string newText, MatchData matchData)
	    {
	        newText = newText.Replace(matchData.ClosePatternIndex, matchData.ClosePatternLength, "");
	        int id = 0;
	        int extraOffset = 0;
	        string content = newText.Substring(matchData.ContentIndex, matchData.ContentLength);
	        Match idMatch = Regex.Match(content, IDPattern);
	        if (idMatch.Success)
	        {
	            Match match = Regex.Match(idMatch.Value, "\\d+");
	            id = int.Parse(match.Value);
	            extraOffset = idMatch.Length;
	            newText = newText.Replace(matchData.ContentIndex + idMatch.Index, idMatch.Length, "");
	        }
	        newText = newText.Replace(matchData.OpenPatternIndex, matchData.OpenPatternLength, "");
	
	        UnderlineMatch underlineMatch = new UnderlineMatch();
	        underlineMatch.ID = id;
	        underlineMatch.UnderlineSetting = UnderlineSettingDictionary[id];
	        underlineMatch.MatchData = matchData;
	        underlineMatch.StartIndex = matchData.OpenPatternIndex;
	        underlineMatch.EndIndex = matchData.OpenPatternIndex + matchData.MatchLength - matchData.OpenPatternLength - matchData.ClosePatternLength - 1 - extraOffset;
	        //print(newText);
	        //print(underlineMatch.StartIndex + "  " + underlineMatch.EndIndex);
	        ParseResult parseResult = new ParseResult();
	        parseResult.Match = underlineMatch;
	        parseResult.ExtraOffset = extraOffset;
	        parseResult.NewText = newText;
	        return parseResult;
	    }
	
	    private ParseResult ParseSuperlinkPattern(string newText, MatchData matchData)
	    {
	        newText = newText.Replace(matchData.ClosePatternIndex, matchData.ClosePatternLength, "");
	        int id = 0;
	        int extraOffset = 0;
	        string content = newText.Substring(matchData.ContentIndex, matchData.ContentLength);
	        Match idMatch = Regex.Match(content, IDPattern);
	        if (idMatch.Success)
	        {
	            Match match = Regex.Match(idMatch.Value, "\\d+");
	            id = int.Parse(match.Value);
	            extraOffset = idMatch.Length;
	            newText = newText.Replace(matchData.ContentIndex + idMatch.Index, idMatch.Length, "");
	        }
	        newText = newText.Replace(matchData.OpenPatternIndex, matchData.OpenPatternLength, "");
	
	        SuperlinkMatch superlinkMatch = new SuperlinkMatch();
	        superlinkMatch.ID = id;
	        superlinkMatch.SuperlinkSetting = SuperlinkSettingDictionary[id];
	        superlinkMatch.MatchData = matchData;
	        superlinkMatch.StartIndex = matchData.OpenPatternIndex;
	        superlinkMatch.EndIndex = matchData.OpenPatternIndex + matchData.MatchLength - matchData.OpenPatternLength - matchData.ClosePatternLength - 1 - extraOffset;
	        ParseResult parseResult = new ParseResult();
	        parseResult.Match = superlinkMatch;
	        parseResult.ExtraOffset = extraOffset;
	        parseResult.NewText = newText;
	        return parseResult;
	    }
	
	    private void AddNewOpenCloseMatch(string newText)
	    {
	        DelayCall.Call
	        (
	            1,
	            () =>
	            {
	                text = newText;
	                //ImageManager.Init(this);
	                //ImageManager.ClearRenderTask();
	                //ImageManager.RenderSprites(SpriteMatches);
	                //ImageManager.RenderUnderlines(UnderlineMatches);
	                //ImageManager.RenderSuperlinks(SuperlinkMatches);   
	            }
	        );
	    }
	
	
	    private void FillSpriteMatches(List<BaseMatch> spriteMatches, List<BaseMatch> truncateSpriteMatches, ref string newText/*, bool fillTruncate*/)
	    {
	        spriteMatches.MySort((match0, match1) => match1.StartIndex < match0.StartIndex);
	
	        float replaceCharWidth = GetCharacterWidth(SpriteReplaceChar);
	        //bool isTextChanged = false;
	        //if (!fillTruncate)
	        //{
	            /*isTextChanged = */ReplaceAllSpriteMatch(spriteMatches, replaceCharWidth, ref newText);
	        //}
	
	        if (horizontalOverflow == HorizontalWrapMode.Overflow)
	        {
	            return;
	        }
	
	        /*isTextChanged = isTextChanged | */CalculateSpriteMatchPosition(spriteMatches, truncateSpriteMatches, replaceCharWidth, ref newText);
	        //return isTextChanged;
	    }
	
	    private void ReplaceAllSpriteMatch(List<BaseMatch> spriteMatches, float replaceCharWidth, ref string newText)
	    {
	        foreach (var match in spriteMatches)
	        {
	            SpriteMatch spriteMatch = match as SpriteMatch;
	            SpriteInfo spriteInfo = SpriteInfoManager.GetSpriteInfo(spriteMatch.Name);
	            float scaledWidth = replaceCharWidth * 2 * spriteMatch.SpriteSetting.Scale;
	            float minReplaceWidth = scaledWidth;
	            if (KerningSolution == KerningSolution.Precalculate)
	            {
	                int frontIndex = spriteMatch.StartIndex - 1;
	                int rearIndex = spriteMatch.EndIndex + 1;
	                float frontKerning;
	                float rearKerning;
	                if (frontIndex < 0)
	                {
	                    frontKerning = 0;
	                }
	                else
	                {
	                    frontKerning = GetKerning(text[frontIndex], SpriteReplaceChar);
	                }
	                if (rearIndex >= text.Length)
	                {
	                    rearKerning = 0;
	                }
	                else
	                {
	                    rearKerning = GetKerning(SpriteReplaceChar, text[rearIndex]);
	                }
	                if (frontKerning < 0)
	                {
	                    minReplaceWidth -= frontKerning;
	                }
	                if (rearKerning < 0)
	                {
	                    minReplaceWidth -= rearKerning;
	                }
	                spriteMatch.FrontKerning = frontKerning;
	                spriteMatch.RearKerning = rearKerning;
	            }
	            int replaceCharCount = Mathf.CeilToInt(minReplaceWidth / replaceCharWidth);
	            
	            for (int j = 0; j < MatchesList.Count; j++)
	            {
	                AdjustIndicesByIndex(replaceCharCount - 1, spriteMatch, MatchesList[j]);
	            }
	
	            StringBuilder stringBuilder = new StringBuilder();
	            for (int j = 0; j < replaceCharCount; j++)
	            {
	                stringBuilder.Append(SpriteReplaceChar);
	            }
	            newText = newText.Replace(spriteMatch.StartIndex, spriteMatch.Length, stringBuilder.ToString());
	
	            spriteMatch.SpriteInfo = spriteInfo;
	            spriteMatch.ReplaceWidth = replaceCharCount*replaceCharWidth;
	            spriteMatch.ScaledWidth = scaledWidth;
	            spriteMatch.EndIndex += replaceCharCount - 1;
	        }
	    }
	
	    private void CalculateSpriteMatchPosition(List<BaseMatch> spriteMatches, List<BaseMatch> stashSpriteMatches, float replaceCharWidth, ref string newText/*, bool fillTruncate*/)
	    {
	        float changeLineAccuracy = replaceCharWidth/5;
	        //bool isTextChanged = false;
	        TextGenerationSettings settings = GetGenerationSettings(rectTransform.rect.size);
	        settings.textAnchor = alignment;
	        CalculateTextGenerator = new TextGenerator();
	        CalculateTextGenerator.Populate(newText, settings);
	        AdjustVerts(CalculateTextGenerator.verts);
	        //if (IsSpritesOutOfBound(spriteMatches))
	        //{
	        //    UnityEngine.Debug.LogWarning("文本框过小");
	        //    if (!fillTruncate)
	        //    {
	        //        StashSpriteMatch(0, spriteMatches, stashSpriteMatches);
	        //    }
	        //    return false;
	        //}
	        for (int i = 0; i < spriteMatches.Count; i++)
	        {
	            SpriteMatch spriteMatch = spriteMatches[i] as SpriteMatch;
	            //print(CalculateTextGenerator.lineCount);
	            int lineIndex = GetLineIndex(CalculateTextGenerator, spriteMatch.StartIndex);
	            int lineStartCharacterIndex;
	            int lineEndCharacterIndex;
	            if (lineIndex != -1)
	            {
	                lineStartCharacterIndex = CalculateTextGenerator.lines[lineIndex].startCharIdx;
	                lineEndCharacterIndex = GetLineEndCharacterIndex(CalculateTextGenerator, lineIndex, newText.Length);
	            }
	            else
	            {
	                lineStartCharacterIndex = -1;
	                lineEndCharacterIndex = -1;
	            }
	            //int lineCharacterCount = lineEndCharacterIndex - lineStartCharacterIndex;
	            //print(spriteMatch.EndIndex);
	            //print(lineEndCharacterIndex);
	            if (spriteMatch.EndIndex > lineEndCharacterIndex) //被Truncate
	            {
	                //if (!fillTruncate)
	                //{
	                    StashSpriteMatch(i, spriteMatches, stashSpriteMatches);
	                //}
	                break;
	            }
	            List<BaseMatch> matches = GetMatchesInLine(spriteMatches, CalculateTextGenerator, lineIndex, lineEndCharacterIndex);
	            if (matches.Count == 1)
	            {
	                continue;
	            }
	            else if (matches.Count > 1)
	            {
	                bool changeLine = false;
	                if (spriteMatch.ReplaceWidth > rectTransform.rect.width) //图片太大 需要换行
	                {
	                    if (i < spriteMatches.Count - 1)
	                    {
	                        i++;
	                        spriteMatch = spriteMatches[i] as SpriteMatch;
	                        changeLine = true;
	                        //isTextChanged = true;
	                    }
	                }
	                else
	                {
	                    float leftMargin = rectTransform.rect.xMin - CalculateTextGenerator.verts[0 + lineStartCharacterIndex * 4].position.x;
	                    float rightMargin = CalculateTextGenerator.verts[1 + lineEndCharacterIndex * 4].position.x - rectTransform.rect.xMax;
	                    float horizontalMargin = CalculateTextGenerator.verts[1 + lineEndCharacterIndex * 4].position.x - CalculateTextGenerator.verts[0 + lineStartCharacterIndex * 4].position.x - rectTransform.rect.width;
	                    if (alignment == TextAnchor.LowerLeft || alignment == TextAnchor.MiddleLeft || alignment == TextAnchor.UpperLeft)
	                    {
	                        if (leftMargin <= 0 && rightMargin > changeLineAccuracy)
	                        {
	                            //向右突出
	                            matches.MySort((match0, match1) => match1.StartIndex > match0.StartIndex);
	                            float margin = horizontalMargin;
	                            spriteMatch = GetMarginSpriteMatch(matches, margin, replaceCharWidth) as SpriteMatch;
	                            i = spriteMatches.IndexOf(spriteMatch);
	                            changeLine = true;
	                            //isTextChanged = true;
	                        }
	                    }
	                    else if (alignment == TextAnchor.LowerCenter || alignment == TextAnchor.MiddleCenter || alignment == TextAnchor.UpperCenter)
	                    {
	                        if (leftMargin > changeLineAccuracy && rightMargin > changeLineAccuracy)
	                        {
	                            //左右同时突出
	                            matches.MySort((match0, match1) => match1.StartIndex > match0.StartIndex);
	                            float margin = leftMargin + rightMargin;
	                            spriteMatch = GetMarginSpriteMatch(matches, margin, replaceCharWidth) as SpriteMatch;
	                            i = spriteMatches.IndexOf(spriteMatch);
	                            changeLine = true;
	                            //isTextChanged = true;
	                        }
	                        else if (leftMargin <= 0 && rightMargin > changeLineAccuracy)
	                        {
	                            //向右突出
	                            matches.MySort((match0, match1) => match1.StartIndex > match0.StartIndex);
	                            float margin = horizontalMargin;
	                            spriteMatch = GetMarginSpriteMatch(matches, margin, replaceCharWidth) as SpriteMatch;
	                            i = spriteMatches.IndexOf(spriteMatch);
	                            changeLine = true;
	                            //isTextChanged = true;
	                        }
	                    }
	                    else if (alignment == TextAnchor.LowerRight || alignment == TextAnchor.MiddleRight || alignment == TextAnchor.UpperRight)
	                    {
	                        if (leftMargin > changeLineAccuracy && rightMargin <= 0)
	                        {
	                            //向左突出
	                            matches.MySort((match0, match1) => match1.StartIndex > match0.StartIndex);
	                            float margin = leftMargin;
	                            spriteMatch = GetMarginSpriteMatch(matches, margin, replaceCharWidth) as SpriteMatch;
	                            i = spriteMatches.IndexOf(spriteMatch);
	                            changeLine = true;
	                            //isTextChanged = true;
	                        }
	                        else if (leftMargin <= 0 && rightMargin > changeLineAccuracy)
	                        {
	                            //向右突出
	                            matches.MySort((match0, match1) => match1.StartIndex > match0.StartIndex);
	                            float margin = horizontalMargin;
	                            spriteMatch = GetMarginSpriteMatch(matches, margin, replaceCharWidth) as SpriteMatch;
	                            i = spriteMatches.IndexOf(spriteMatch);
	                            changeLine = true;
	                            //isTextChanged = true;
	                        }
	                    }
	                }
	                if (changeLine)
	                {
	                    lineIndex++;
	                    if (lineIndex < GetMaxLineCount()) //换行后不被Truncate
	                    {
	                        newText = newText.Insert(spriteMatch.StartIndex, "\n");
	                        for (int j = 0; j < MatchesList.Count; j++)
	                        {
	                            AdjustIndicesByIndex(1, spriteMatch, MatchesList[j]);
	                        }
	                        spriteMatch.StartIndex += 1;
	                        spriteMatch.EndIndex += 1;
	
	                        CalculateTextGenerator = new TextGenerator();
	                        CalculateTextGenerator.Populate(newText, settings);
	                        AdjustVerts(CalculateTextGenerator.verts);
	                    }
	                }
	            }
	            //if (fillTruncate)
	            //{
	            //    stashSpriteMatches.Add(spriteMatch);
	            //    spriteMatches.Remove(spriteMatch);
	            //}
	        }
	        //return isTextChanged;
	    }
	
	    //private bool IsSpritesOutOfBound(List<BaseMatch> spriteMatches)
	    //{
	    //    for (int i = 0; i < spriteMatches.Count; i++)
	    //    {
	    //        SpriteMatch spriteMatch = spriteMatches[i] as SpriteMatch;
	    //        if (spriteMatch.ReplaceWidth > rectTransform.rect.width)
	    //        {
	    //            return true;
	    //        }
	    //    }
	    //    return false;
	    //}
	
	    private void StashSpriteMatch(int startIndex, List<BaseMatch> spriteMatches, List<BaseMatch> stashSpriteMatches)
	    {
	        for (int i = startIndex; i < spriteMatches.Count; i++)
	        {
	            stashSpriteMatches.Add(spriteMatches[i]);
	            spriteMatches.Remove(spriteMatches[i]);
	            i--;
	        }
	    }
	
	    private List<BaseMatch> GetMatchesInLine(List<BaseMatch> matches, TextGenerator textGenerator, int lineIndex, int endCharacterIndex)
	    {
	        List<BaseMatch> result = new List<BaseMatch>();
	        foreach (var match in matches)
	        {
	            if (match.StartIndex > endCharacterIndex)
	            {
	                continue;
	            }
	            int matchLineIndex = GetLineIndex(textGenerator, match.StartIndex);
	            if (matchLineIndex == lineIndex)
	            {
	                result.Add(match);
	            }
	        }
	        return result;
	    }
	
	    private BaseMatch GetMarginSpriteMatch(List<BaseMatch> matches, float margin, float replaceCharWidth)
	    {
	        foreach (var match in matches)
	        {
	            margin -= replaceCharWidth * match.Length;
	            if (margin <= 0)
	            {
	                return match;
	            }
	        }
	        throw new Exception();
	    }
	
	    //private bool IsCharacterTruncated(TextGenerator textGenerator, int characterIndex)
	    //{
	    //    print(textGenerator.characterCount - 1);
	    //    print(characterIndex + 1);
	    //    if (textGenerator.characterCount - 1 < characterIndex + 1)
	    //    {
	    //        return true;
	    //    }
	    //    else
	    //    {
	    //        return false;
	    //    }
	    //}
	
	    private void HandleTransferSpaceMatch(VertexHelper toFill, List<UIVertex> vertices)
	    {
	        foreach (var transferSpaceMatch in TransferSpaceMatches)
	        {
	            int index0 = 0 + transferSpaceMatch.StartIndex * 4;
	            int index1 = 1 + transferSpaceMatch.EndIndex * 4;
	            int index2 = 2 + transferSpaceMatch.EndIndex * 4;
	            int index3 = 3 + transferSpaceMatch.StartIndex * 4;
	            UIVertex vertex0 = vertices[index0];
	            UIVertex vertex1 = vertices[index1];
	            UIVertex vertex2 = vertices[index2];
	            UIVertex vertex3 = vertices[index3];
	            vertex0.color = new Color32(0, 0, 0, 0);
	            vertex1.color = new Color32(0, 0, 0, 0);
	            vertex2.color = new Color32(0, 0, 0, 0);
	            vertex3.color = new Color32(0, 0, 0, 0);
	            vertices[index0] = vertex0;
	            vertices[index1] = vertex1;
	            vertices[index2] = vertex2;
	            vertices[index3] = vertex3;
	            toFill.SetUIVertex(vertex0, index0);
	            toFill.SetUIVertex(vertex1, index1);
	            toFill.SetUIVertex(vertex2, index2);
	            toFill.SetUIVertex(vertex3, index3);
	        }
	    }
	
	
	    public string GetUnparsedText()
	    {
	        List<BaseMatch> matches = new List<BaseMatch>();
	        matches.AddRange(TransferSpaceMatches);
	        matches.AddRange(AvailableSpriteMatches);
	        matches.AddRange(UnderlineMatches);
	        matches.AddRange(SuperlinkMatches);
	        matches.MySort((match0, match1) => match1.StartIndex > match0.StartIndex);
	        string result = text;
	        foreach (var baseMatch in matches)
	        {
	            if (baseMatch is TransferSpaceMatch)
	            {
	                result = result.Insert(baseMatch.StartIndex, "\\");
	            }
	            else
	            {
	                string openPattern = baseMatch.MatchData.OpenPattern;
	                string idPattern = IDPattern.Replace("\\d+", baseMatch.ID.ToString());
	                idPattern = idPattern.Replace("\\", "");
	                string closePattern = baseMatch.MatchData.ClosePattern;
	                result = result.Insert(baseMatch.StartIndex + baseMatch.EndIndex, idPattern + closePattern);
	                result = result.Insert(baseMatch.StartIndex, openPattern);
	            }
	        }
	        return result;
	    }
	
	
	    private Vector3[] GetLocalCorners()
	    {
	        Vector3[] corners = new Vector3[4];
	        rectTransform.GetLocalCorners(corners);
	        return corners;
	    }
	
	    private Vector3[] GetWorldCorners()
	    {
	        Vector3[] corners = new Vector3[4];
	        rectTransform.GetWorldCorners(corners);
	        return corners;
	    }
	
	    private float GetKerning(char c0, char c1)
	    {
	        TextGenerator textGenerator = new TextGenerator(0);
	        textGenerator.Populate(string.Format("{0}{1}", c0, c1), GetGenerationSettings(rectTransform.rect.size));
	        //AdjustVerts(textGenerator.verts);
	        float kerning = textGenerator.verts[4].position.x - textGenerator.verts[1].position.x;
	        kerning /= canvas.scaleFactor;
	        return kerning;
	        //return textGenerator.verts[4].position.x - textGenerator.verts[1].position.x;
	    }
	
	    private float GetCharacterHeight(char c)
	    {
	        TextGenerator textGenerator = new TextGenerator(0);
	        textGenerator.Populate(c.ToString(), GetGenerationSettings(rectTransform.rect.size));
	        //AdjustVerts(textGenerator.verts);
	        float height = textGenerator.verts[0].position.y - textGenerator.verts[2].position.y;
	        height /= canvas.scaleFactor;
	        return height;
	        //return textGenerator.verts[0].position.y - textGenerator.verts[2].position.y;
	    }
	
	    private float GetCharacterWidth(char c)
	    {
	        TextGenerator textGenerator = new TextGenerator(0);
	        textGenerator.Populate(c.ToString(), GetGenerationSettings(rectTransform.rect.size));
	        //AdjustVerts(textGenerator.verts);
	        float width = textGenerator.verts[1].position.x - textGenerator.verts[0].position.x;
	        width /= canvas.scaleFactor;
	        return width;
	        //return textGenerator.verts[1].position.x - textGenerator.verts[0].position.x;
	    }
	
	    public float GetPenPositionY(int lineIndex, int lineCount)
	    {
	        StringBuilder stringBuilder = new StringBuilder();
	        for (int i = 0; i < lineCount; i++)
	        {
	            stringBuilder.Append(CalculateReferenceChar);
	            if (i < lineCount - 1)
	            {
	                stringBuilder.Append("\n");
	            }
	        }
	        TextGenerator textGenerator = new TextGenerator();
	        textGenerator.Populate(stringBuilder.ToString(), GetGenerationSettings(rectTransform.rect.size));
	        AdjustVerts(textGenerator.verts);
	        return textGenerator.verts[2 + lineIndex*8].position.y;
	    }
	
	    public float GetLineCenterY(int lineIndex, int lineCount)
	    {
	        StringBuilder stringBuilder = new StringBuilder();
	        for (int i = 0; i < lineCount; i++)
	        {
	            stringBuilder.Append(CalculateReferenceChar);
	            if (i < lineCount - 1)
	            {
	                stringBuilder.Append("\n");
	            }
	        }
	        TextGenerator textGenerator = new TextGenerator();
	        textGenerator.Populate(stringBuilder.ToString(), GetGenerationSettings(rectTransform.rect.size));
	        AdjustVerts(textGenerator.verts);
	        return (textGenerator.verts[0 + lineIndex*8].position.y + textGenerator.verts[2 + lineIndex*8].position.y)/2;
	    }
	
	    public int GetLineIndex(TextGenerator textGenerator, int charIndex)
	    {
	        for (int i = 0; i < textGenerator.lines.Count; i++)
	        {
	            if (charIndex >= textGenerator.lines.Back(i).startCharIdx)
	            {
	                return textGenerator.lines.Count - 1 - i;
	            }
	        }
	        return -1;
	    }
	
	    public int GetMaxLineCount()
	    {
	        TextGenerationSettings settings = GetGenerationSettings(rectTransform.rect.size);
	        settings.textAnchor = alignment;
	        CalculateTextGenerator = new TextGenerator();
	        int lineCount = 0;
	        StringBuilder stringBuilder = new StringBuilder();
	        while (CalculateTextGenerator.GetPreferredHeight(stringBuilder.ToString(), settings) / canvas.scaleFactor < rectTransform.rect.height)
	        {
	            lineCount++;
	            stringBuilder.Append("\n");
	        }
	        return lineCount;
	    }
	
	    public int GetLineEndCharacterIndex(TextGenerator textGenerator, int lineIndex, int realCharacterCount)
	    {
	        if (lineIndex >= textGenerator.lines.Count)
	        {
	            throw new Exception();
	        }
	
	        if (textGenerator.lines.Count == 1 || lineIndex == textGenerator.lines.Count - 1)
	        {
	            if (textGenerator.characterCount - 1 == realCharacterCount) //TextGenerator会自动在结尾添加换行符
	            {
	                return realCharacterCount - 1;
	            }
	            else
	            {
	                return textGenerator.characterCount - 1;
	            }
	        }
	        else
	        {
	            return textGenerator.lines[lineIndex + 1].startCharIdx - 1;
	        }
	    }
	
	    public int GetLineCharacterCount(TextGenerator textGenerator, int lineIndex)
	    {
	        if (lineIndex >= textGenerator.lines.Count)
	        {
	            throw new Exception();
	        }
	
	        if (textGenerator.lines.Count == 1)
	        {
	            return textGenerator.characterCount;
	        }
	
	        if (lineIndex == textGenerator.lines.Count - 1)
	        {
	            return textGenerator.characterCount - textGenerator.lines.Back(0).startCharIdx;
	        }
	        else
	        {
	            return textGenerator.lines[lineIndex + 1].startCharIdx - textGenerator.lines[lineIndex].startCharIdx;
	        }
	    }
	
	    public float GetLineMaxY(TextGenerator textGenerator, int lineIndex)
	    {
	        float lineCenterY = GetLineCenterY(lineIndex, textGenerator.lineCount);
	        float lineHeight = textGenerator.lines[lineIndex].height;
	        return lineCenterY + lineHeight/2;
	    }
	
	    public float GetLineMinY(TextGenerator textGenerator, int lineIndex)
	    {
	        float lineCenterY = GetLineCenterY(lineIndex, textGenerator.lineCount);
	        float lineHeight = textGenerator.lines[lineIndex].height;
	        return lineCenterY - lineHeight/2;
	    }
	
	    public float GetLineTopY(TextGenerator textGenerator, int lineIndex)
	    {
	        return textGenerator.lines[lineIndex].topY;
	    }
	
	    public float GetLineBottomY(TextGenerator textGenerator, int lineIndex)
	    {
	        return textGenerator.lines[lineIndex].topY - textGenerator.lines[lineIndex].height;
	    }
	
	    public bool IsSameLine(TextGenerator textGenerator, int charIndex0, int charIndex1)
	    {
	        if (textGenerator.lines.Count == 1)
	        {
	            return true;
	        }
	        else
	        {
	            for (int i = 0; i < textGenerator.lines.Count - 1; i++)
	            {
	                if ((charIndex0 >= textGenerator.lines[i].startCharIdx && charIndex0 < textGenerator.lines[i + 1].startCharIdx) && charIndex1 >= textGenerator.lines[i + 1].startCharIdx)
	                {
	                    return false;
	                }
	            }
	            return true;
	        }
	    }
	
	
	    private void AdjustVerts(IList<UIVertex> verts) //取自UGUI源代码
	    {
	        float unitsPerPixel = 1/pixelsPerUnit;
	        int vertCount = verts.Count - 4;
	
	        Vector2 roundingOffset = new Vector2(verts[0].position.x, verts[0].position.y)*unitsPerPixel;
	        roundingOffset = PixelAdjustPoint(roundingOffset) - roundingOffset;
	        if (roundingOffset != Vector2.zero)
	        {
	            for (int i = 0; i < vertCount; ++i)
	            {
	                UIVertex vertex = verts[i];
	                vertex.position *= unitsPerPixel;
	                vertex.position.x += roundingOffset.x;
	                vertex.position.y += roundingOffset.y;
	                verts[i] = vertex;
	            }
	        }
	        else
	        {
	            for (int i = 0; i < vertCount; ++i)
	            {
	                UIVertex vertex = verts[i];
	                vertex.position *= unitsPerPixel;
	                verts[i] = vertex;
	            }
	        }
	    }
	
	    private void AdjustIndicesByIndex(int indexOffset, BaseMatch referenceMatch, List<BaseMatch> adjusteeMatches)
	    {
	        for (int i = 0; i < adjusteeMatches.Count; i++)
	        {
	            BaseMatch adjusteeMatch = adjusteeMatches[i];
	            if (referenceMatch == adjusteeMatch) continue;
	            if (referenceMatch.StartIndex < adjusteeMatch.StartIndex) //referenceIndex-adjusteeMatch-adjusteeMatch
	            {
	                adjusteeMatch.StartIndex += indexOffset; 
	                adjusteeMatch.EndIndex += indexOffset;
	            }
	            else if (referenceMatch.StartIndex < adjusteeMatch.EndIndex) //adjusteeMatch-referenceIndex-adjusteeMatch
	            {
	                adjusteeMatch.EndIndex += indexOffset;
	            }
	        }
	    }
	
	    private void AdjustIndicesByMatch(int extraOffset, BaseMatch referenceMatch, List<BaseMatch> adjusteeMatches)
	    {
	        for (int i = 0; i < adjusteeMatches.Count; i++)
	        {
	            BaseMatch adjusteeMatch = adjusteeMatches[i];
	            if (referenceMatch == adjusteeMatch) continue;
	            if (referenceMatch.StartIndex < adjusteeMatch.EndIndex) //排除 adjusteeMatch...adjusteeMatch...refeMatch-refeMatch
	            {
	                if (referenceMatch.EndIndex < adjusteeMatch.StartIndex) //refeMatch-refeMatch...adjusteeMatch-adjusteeMatch 
	                {
	                    int indexOffset = -referenceMatch.MatchData.OpenPatternLength - referenceMatch.MatchData.ClosePatternLength + extraOffset;
	                    adjusteeMatch.StartIndex += indexOffset;
	                    adjusteeMatch.EndIndex += indexOffset;
	                }
	                else if (referenceMatch.EndIndex < adjusteeMatch.EndIndex) //refeMatch...adjusteeMatch...refeMatch...adjusteeMatch
	                {
	                    int indexOffset = -referenceMatch.MatchData.ClosePatternLength + extraOffset;
	                    adjusteeMatch.StartIndex += indexOffset;
	                    adjusteeMatch.EndIndex += indexOffset;
	                }
	                else if (referenceMatch.EndIndex > adjusteeMatch.EndIndex) //adjusteeMatch...refeMatch...adjusteeMatch...refeMatch
	                {
	                    int indexOffset = -referenceMatch.MatchData.OpenPatternLength + extraOffset;
	                    adjusteeMatch.StartIndex += indexOffset;
	                    adjusteeMatch.EndIndex += indexOffset;
	                }
	                //不应该出现的情况refeMatch...adjusteeMatch-adjusteeMatch...refeMatch    adjusteeMatch...refeMatch...refeMatch...adjusteeMatch
	            }
	        }
	    }
	
	
	    public void GetSegments<T>(string newText, TextGenerator textGenerator, T match, List<char> excludeChars) where T : SegmentMatch
	    {
	        //print(excludeChars.Count);
	        if (textGenerator.lines.Count == 1)
	        {
	            match.Segments.Add(new List<int> {match.StartIndex, match.EndIndex});
	        }
	        else
	        {
	            int endLineIndex;
	            int startLineIndex;
	            for (int i = 0; i < textGenerator.lines.Count; i++)
	            {
	                startLineIndex = textGenerator.lines.Count - 1 - i;
	                if (match.StartIndex >= textGenerator.lines[startLineIndex].startCharIdx)
	                {
	                    if (startLineIndex == textGenerator.lines.Count - 1)
	                    {
	                        match.Segments.Add(new List<int> {match.StartIndex, match.EndIndex});
	                        goto jumpOut;
	                    }
	                    else
	                    {
	                        if (match.EndIndex >= textGenerator.lines.Back(0).startCharIdx)
	                        {
	                            endLineIndex = textGenerator.lines.Count - 1;
	                        }
	                        else
	                        {
	                            for (int j = startLineIndex; j < textGenerator.lines.Count; j++)
	                            {
	                                if (match.EndIndex < textGenerator.lines[j + 1].startCharIdx)
	                                {
	                                    if (j == startLineIndex)
	                                    {
	                                        match.Segments.Add(new List<int> {match.StartIndex, match.EndIndex});
	                                        goto jumpOut;
	                                    }
	                                    else
	                                    {
	                                        endLineIndex = j;
	                                        goto segment;
	                                    }
	                                }
	                            }
	                            throw new Exception();
	                        }
	                        segment:
	                        int segmentCount = endLineIndex - startLineIndex + 1;
	                        match.Segments.Add(new List<int> {match.StartIndex, textGenerator.lines[startLineIndex + 1].startCharIdx - 1}); //第一段
	                        match.Segments.Add(new List<int> {textGenerator.lines[endLineIndex].startCharIdx, match.EndIndex}); //最后一段
	                        for (int k = 0; k < segmentCount - 2; k++)
	                        {
	                            match.Segments.Add(new List<int> {textGenerator.lines[startLineIndex + 1 + k].startCharIdx, textGenerator.lines[startLineIndex + 2 + k].startCharIdx - 1});
	                        }
	                        goto jumpOut;
	                    }
	                }
	            }
	        }
	        jumpOut:
	
	        //for (int i = 0; i < match.Segments.Count; i++)
	        //{
	        //    Debug.LogWarning(match.Segments[i][0] + "\t" + match.Segments[i][1]);
	        //}
	
	        exclude:
	        for (int i = 0; i < match.Segments.Count; i++)
	        {
	            int startIndex = match.Segments[i][0];
	            int endIndex = match.Segments[i][1];
	            for (int j = startIndex; j <= endIndex; j++)
	            {
	                //print((int)newText[j]);
	                if (excludeChars.Contains(newText[j]))
	                {
	                    if (j == startIndex)
	                    {
	                        //Debug.Log("start " + match.Segments[i][0] + "\t" + match.Segments[i][1]);
	                        //Debug.Log(j);
	                        //newText = newText.Remove(startIndex, 1);
	                        match.Segments[i][0] = startIndex + 1;
	                        //Debug.Log("start " + match.Segments[i][0] + "\t" + match.Segments[i][1]);
	                    }
	                    else if (j == endIndex)
	                    {
	                        //Debug.Log("end " + match.Segments[i][0] + "\t" + match.Segments[i][1]);
	                        //Debug.Log(j);
	                        //newText = newText.Remove(endIndex, 1);
	                        match.Segments[i][1] = endIndex - 1;
	                        //Debug.Log("end " + match.Segments[i][0] + "\t" + match.Segments[i][1]);
	                    }
	                    else
	                    {
	                        //Debug.Log(j);
	                        //newText = newText.Remove(j, 1);
	                        //Debug.Log("remove " + match.Segments[i][0] + "\t" + match.Segments[i][1]);
	                        match.Segments.RemoveAt(i);
	                        match.Segments.Insert(0, new List<int> {startIndex, j - 1});
	                        //Debug.Log("add " + match.Segments[0][0] + "\t" + match.Segments[0][1]);
	                        match.Segments.Insert(0, new List<int> {j + 1, endIndex});
	                        //Debug.Log("add " + match.Segments[0][0] + "\t" + match.Segments[0][1]);
	                    }
	                    goto exclude;
	                }
	            }
	        }
	
	        for (int i = 0; i < match.Segments.Count; i++)
	        {
	            if (match.Segments[i][1] < match.Segments[i][0])
	            {
	                match.Segments.RemoveAt(i--);
	            }
	        }
	
	        //for (int i = 0; i < match.Segments.Count; i++)
	        //{
	        //    Debug.Log(match.Segments[i][0] + "\t" + match.Segments[i][1]);
	        //}
	    }
	
	
	    private int GetVerticalBestfitFontSize(string newText)
	    {
	        int antiCrush = 0;
	        TextGenerationSettings settings = GetGenerationSettings(rectTransform.rect.size);
	        List<int> leftSizes = new List<int> {resizeTextMinSize};
	        List<int> rightSizes = new List<int> {resizeTextMaxSize};
	        settings.fontSize = (leftSizes[0] + rightSizes[0])/2;
	        while (true)
	        {
	            if (antiCrush++ > 300)
	            {
	                throw new Exception("Crush");
	            }
	
	            float preferredHeight = cachedTextGenerator.GetPreferredHeight(newText, settings);
	            if (preferredHeight > rectTransform.rect.size.y*canvas.scaleFactor)
	            {
	                rightSizes.Add(settings.fontSize);
	                settings.fontSize = (leftSizes[leftSizes.Count - 1] + settings.fontSize)/2;
	            }
	            else if (preferredHeight < rectTransform.rect.size.y*canvas.scaleFactor)
	            {
	                if (leftSizes.Contains(settings.fontSize))
	                {
	                    return settings.fontSize;
	                }
	                else
	                {
	                    leftSizes.Add(settings.fontSize);
	                }
	
	                settings.fontSize = (rightSizes[rightSizes.Count - 1] + settings.fontSize)/2;
	            }
	            else
	            {
	                return settings.fontSize;
	            }
	        }
	    }
	
	    public void ApplyVerticalBestfitSize()
	    {
	        resizeTextMinSize = MinSize;
	        resizeTextMaxSize = MaxSize;
	    }
	
	    public void DisableOriginBestfit()
	    {
	        resizeTextForBestFit = false;
	    }
	
	    public void EnableVerticalBestfit()
	    {
	        UseOriginBestfit = resizeTextForBestFit;
	        MinSize = resizeTextMinSize;
	        MaxSize = resizeTextMaxSize;
	        UseVerticalBestfit = true;
	        VerticalBestfitDirty = true;
	        DisableOriginBestfit();
	    }
	
	    public void DisableVerticalBestfit()
	    {
	        resizeTextForBestFit = UseOriginBestfit;
	        UseVerticalBestfit = false;
	    }
	
	
	    private bool ParseAndFillMatches(ref string newText)
	    {
	        bool haveMatch = ParseMatches(ref newText);
	        if (haveMatch)
	        {
	            FillSpriteMatches(AvailableSpriteMatches, TruncateSpriteMatches, ref newText);
	        }
	        return haveMatch;
	    }
	
	    public void EnableDebugMode()
	    {
	        //TextGenerationSettings settings = GetGenerationSettings(rectTransform.rect.size);
	        //settings.textAnchor = alignment;
	        //CalculateTextGenerator = new TextGenerator();
	        //print(CalculateTextGenerator.GetPreferredHeight("", settings) / canvas.scaleFactor);
	
	        //print(cachedTextGenerator.characterCount);
	        //print(cachedTextGenerator.lineCount);
	
	        Debug = true;
	        Content = text;
	        SetVerticesDirty();
	        SetLayoutDirty();
	        //string newText = Content;
	        //if (ParseAndFillMatches(ref newText))
	        //{
	        //    AddNewOpenCloseMatch(newText);
	        //}
	    }
	
	    public void DisableDebugMode()
	    {
	        Debug = false;
	        text = Content;
	        ClearMatches();
	        ImageManager.ClearRenderTask();
	    }



        public void OnPointerClick(PointerEventData eventData)
        {
            //Vector3 clickPosition = eventData.position;
            //Debug.Log(clickPosition);
            OnPointerClick(eventData.position);
        }

	    private Dictionary<int, List<List<Vector3>>> SuperlinkPositionsDictionary = new Dictionary<int, List<List<Vector3>>>();
        public void OnPointerClick(Vector3 worldPosition)
        {
            SuperlinkPositionsDictionary = new Dictionary<int, List<List<Vector3>>>();
            foreach (var match in SuperlinkMatches)
            {
                SuperlinkMatch superlinkMatch = (SuperlinkMatch) match;
                SuperlinkPositionsDictionary.Add(superlinkMatch.ID, superlinkMatch.RectanglePositionsList);
            }

            Vector3 clickPosition = worldPosition;
            //Vector3 clickPosition = rectTransform.InverseTransformPoint(worldPosition);
            foreach (var kv in SuperlinkPositionsDictionary)
            {
                foreach (var positions in kv.Value)
                {
                    float minX = positions.MyMin(vector => vector.x).x;
                    float maxX = positions.MyMax(vector => vector.x).x;
                    float minY = positions.MyMin(vector => vector.y).y;
                    float maxY = positions.MyMax(vector => vector.y).y;
                    //UnityEngine.Debug.Log(clickPosition);
                    //UnityEngine.Debug.Log(minX + "  " + maxX + "  " + minY + "  " + maxY);
                    if ((minX <= clickPosition.x && clickPosition.x <= maxX) && (minY <= clickPosition.y && clickPosition.y <= maxY))
                    {
                        if (SuperlinkCallbackDictionary.ContainsKey(kv.Key))
                        {
                            SuperlinkCallbackDictionary[kv.Key].Invoke(kv.Key);
                        }
                        else
                        {
                            UnityEngine.Debug.LogWarning(string.Format("没有找到事件 id : {0}", kv.Key));
                        }
                    }
                }
            }
        }
    }


}