HeavenStudioPlus/Assets/Plugins/com.unity.uiextensions/Runtime/Scripts/Controls/TextPic.cs

735 lines
22 KiB
C#
Raw Normal View History

2022-01-06 00:11:33 +00:00
/// Credit drobina, w34edrtfg, playemgames
/// Sourced from - http://forum.unity3d.com/threads/sprite-icons-with-text-e-g-emoticons.265927/
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using UnityEngine.Events;
using UnityEngine.EventSystems;
namespace UnityEngine.UI.Extensions {
// Image according to the label inside the name attribute to load, read from the Resources directory. The size of the image is controlled by the size property.
// Use: Add Icon name and sprite to the icons list
[AddComponentMenu("UI/Extensions/TextPic")]
[ExecuteInEditMode] // Needed for culling images that are not used //
public class TextPic : Text, IPointerClickHandler, IPointerExitHandler, IPointerEnterHandler, ISelectHandler {
// Icon entry to replace text with
[Serializable]
public struct IconName {
public string name;
public Sprite sprite;
public Vector2 offset;
public Vector2 scale;
}
// Icons and text to replace
public IconName[] inspectorIconList;
[Tooltip("Global scaling factor for all images")]
public float ImageScalingFactor = 1;
// Write the name or hex value of the hyperlink color
public string hyperlinkColor = "blue";
// Offset image by x, y
public Vector2 imageOffset = Vector2.zero;
public bool isCreating_m_HrefInfos = true;
[Serializable]
public class HrefClickEvent : UnityEvent<string> { }
[SerializeField]
private HrefClickEvent m_OnHrefClick = new HrefClickEvent();
/// <summary>
/// Hyperlink Click Event
/// </summary>
public HrefClickEvent onHrefClick {
get { return m_OnHrefClick; }
set { m_OnHrefClick = value; }
}
/// <summary>
/// Image Pool
/// </summary>
private readonly List<Image> m_ImagesPool = new List<Image>();
private readonly List<GameObject> culled_ImagesPool = new List<GameObject>();
// Used for check for culling images
private bool clearImages = false;
// Lock to ensure images get culled properly
private Object thisLock = new Object();
/// <summary>
/// Vertex Index
/// </summary>
private readonly List<int> m_ImagesVertexIndex = new List<int>();
/// <summary>
/// Regular expression to replace
/// </summary>
private static readonly Regex s_Regex =
new Regex(@"<quad name=(.+?) size=(\d*\.?\d+%?) width=(\d*\.?\d+%?) />", RegexOptions.Singleline);
/// <summary>
/// Hyperlink Regular Expression
/// </summary>
private static readonly Regex s_HrefRegex =
new Regex(@"<a href=([^>\n\s]+)>(.*?)(</a>)", RegexOptions.Singleline);
// String to create quads
private string fixedString;
// Update the quad images when true
private bool updateQuad = false;
/// <summary>
/// After parsing the final text
/// </summary>
private string m_OutputText;
private Button button;
// Used for custom selection as a variable for other scripts
private bool selected = false;
public bool Selected
{
get { return selected; }
set { selected = value; }
}
// Positions of images for icon placement
private List<Vector2> positions = new List<Vector2>();
// Little hack to support multiple hrefs with same name
private string previousText = "";
/// <summary>
/// Hyperlinks Info
/// </summary>
[Serializable]
public class HrefInfo {
public int startIndex;
public int endIndex;
public string name;
public readonly List<Rect> boxes = new List<Rect>();
}
/// <summary>
/// Hyperlink List
/// </summary>
private readonly List<HrefInfo> m_HrefInfos = new List<HrefInfo>();
/// <summary>
/// Text Builder
/// </summary>
private static readonly StringBuilder s_TextBuilder = new StringBuilder();
// Matches for quad tags
private MatchCollection matches;
// Matches for quad tags
private MatchCollection href_matches;
// Matches for removing characters
private MatchCollection removeCharacters;
// Index of current pic
private int picIndex;
// Index of current pic vertex
private int vertIndex;
/// <summary>
/// Unity 2019.1.5 Fixes to text placement resulting from the removal of verts for spaces and non rendered characters
/// </summary>
// There is no directive for incremented versions so will have to hack together
private bool usesNewRendering = false;
#if UNITY_2019_1_OR_NEWER
/// <summary>
/// Regular expression to remove non rendered characters
/// </summary>
private static readonly Regex remove_Regex =
new Regex(@"<b>|</b>|<i>|</i>|<size=.*?>|</size>|<color=.*?>|</color>|<material=.*?>|</material>|<quad name=(.+?) size=(\d*\.?\d+%?) width=(\d*\.?\d+%?) />|<a href=([^>\n\s]+)>|</a>|\s", RegexOptions.Singleline);
// List of indexes that are compared against matches to remove quad tags
List<int> indexes = new List<int>();
// Characters to remove from string for finding the correct index for vertices for images
private int charactersRemoved = 0;
// Characters to remove from string for finding the correct start index for vertices for href bounds
private int startCharactersRemoved = 0;
// Characters to remove from string for finding the correct end index for vertices for href bounds
private int endCharactersRemoved = 0;
#endif
// Count of current href
private int count = 0;
// Index of current href
private int indexText = 0;
// Original text temporary variable holder
private string originalText;
// Vertex we are modifying
private UIVertex vert;
// Local Point for Href
private Vector2 lp;
/// METHODS ///
public void ResetIconList() {
Reset_m_HrefInfos ();
base.Start();
}
protected void UpdateQuadImage() {
#if UNITY_EDITOR && !UNITY_2018_3_OR_NEWER
if (UnityEditor.PrefabUtility.GetPrefabType(this) == UnityEditor.PrefabType.Prefab) {
return;
}
#endif
m_OutputText = GetOutputText();
matches = s_Regex.Matches(m_OutputText);
if (matches != null && matches.Count > 0) {
for (int i = 0; i < matches.Count; i++) {
m_ImagesPool.RemoveAll(image => image == null);
if (m_ImagesPool.Count == 0) {
GetComponentsInChildren<Image>(true, m_ImagesPool);
}
if (matches.Count > m_ImagesPool.Count) {
DefaultControls.Resources resources = new DefaultControls.Resources();
GameObject go = DefaultControls.CreateImage(resources);
go.layer = gameObject.layer;
RectTransform rt = go.transform as RectTransform;
if (rt) {
rt.SetParent(rectTransform);
rt.anchoredPosition3D = Vector3.zero;
rt.localRotation = Quaternion.identity;
rt.localScale = Vector3.one;
}
m_ImagesPool.Add(go.GetComponent<Image>());
}
string spriteName = matches[i].Groups[1].Value;
Image img = m_ImagesPool[i];
Vector2 imgoffset = Vector2.zero;
if (img.sprite == null || img.sprite.name != spriteName) {
if (inspectorIconList != null && inspectorIconList.Length > 0) {
for (int s = 0; s < inspectorIconList.Length; s++) {
if (inspectorIconList[s].name == spriteName) {
img.sprite = inspectorIconList[s].sprite;
img.preserveAspect = true;
img.rectTransform.sizeDelta = new Vector2(fontSize * ImageScalingFactor * inspectorIconList[s].scale.x,
fontSize * ImageScalingFactor * inspectorIconList[s].scale.y);
imgoffset = inspectorIconList[s].offset;
break;
}
}
}
}
img.enabled = true;
if (positions.Count > 0 && i < positions.Count) {
img.rectTransform.anchoredPosition = positions[i] += imgoffset;
}
}
}
else {
// If there are no matches, remove the images from the pool
for (int i = m_ImagesPool.Count - 1; i > 0; i--) {
if (m_ImagesPool[i]) {
if (!culled_ImagesPool.Contains(m_ImagesPool[i].gameObject)) {
culled_ImagesPool.Add(m_ImagesPool[i].gameObject);
m_ImagesPool.Remove(m_ImagesPool[i]);
}
}
}
}
// Remove any images that are not being used
for (int i = m_ImagesPool.Count - 1; i >= matches.Count; i--) {
if (i >= 0 && m_ImagesPool.Count > 0) {
if (m_ImagesPool[i]) {
if (!culled_ImagesPool.Contains(m_ImagesPool[i].gameObject)) {
culled_ImagesPool.Add(m_ImagesPool[i].gameObject);
m_ImagesPool.Remove(m_ImagesPool[i]);
}
}
}
}
// Clear the images when it is safe to do so
if (culled_ImagesPool.Count > 0) {
clearImages = true;
}
}
// Reseting m_HrefInfos array if there is any change in text
void Reset_m_HrefInfos () {
previousText = text;
m_HrefInfos.Clear();
isCreating_m_HrefInfos = true;
}
/// <summary>
/// Finally, the output text hyperlinks get parsed
/// </summary>
/// <returns></returns>
protected string GetOutputText() {
s_TextBuilder.Length = 0;
indexText = 0;
fixedString = this.text;
if (inspectorIconList != null && inspectorIconList.Length > 0) {
for (int i = 0; i < inspectorIconList.Length; i++) {
if (!string.IsNullOrEmpty(inspectorIconList[i].name)) {
fixedString = fixedString.Replace(inspectorIconList[i].name,
"<quad name=" + inspectorIconList[i].name + " size=" + fontSize + " width=1 />");
}
}
}
count = 0;
href_matches = s_HrefRegex.Matches(fixedString);
if (href_matches != null && href_matches.Count > 0) {
for (int i = 0; i < href_matches.Count; i++ ) {
s_TextBuilder.Append(fixedString.Substring(indexText, href_matches[i].Index - indexText));
s_TextBuilder.Append("<color=" + hyperlinkColor + ">"); // Hyperlink color
var group = href_matches[i].Groups[1];
if (isCreating_m_HrefInfos) {
HrefInfo hrefInfo = new HrefInfo {
// Hyperlinks in text starting index
startIndex = (usesNewRendering ? s_TextBuilder.Length : s_TextBuilder.Length * 4),
endIndex = (usesNewRendering ? (s_TextBuilder.Length + href_matches[i].Groups[2].Length - 1) : (s_TextBuilder.Length + href_matches[i].Groups[2].Length - 1) * 4 + 3),
name = group.Value
};
m_HrefInfos.Add(hrefInfo);
}
else {
if (count <= m_HrefInfos.Count - 1) {
// Hyperlinks in text starting index
m_HrefInfos[count].startIndex = (usesNewRendering ? s_TextBuilder.Length : s_TextBuilder.Length * 4);
m_HrefInfos[count].endIndex = (usesNewRendering ? (s_TextBuilder.Length + href_matches[i].Groups[2].Length - 1) : (s_TextBuilder.Length + href_matches[i].Groups[2].Length - 1) * 4 + 3);
count++;
}
}
s_TextBuilder.Append(href_matches[i].Groups[2].Value);
s_TextBuilder.Append("</color>");
indexText = href_matches[i].Index + href_matches[i].Length;
}
}
// we should create array only once or if there is any change in the text
if (isCreating_m_HrefInfos)
isCreating_m_HrefInfos = false;
s_TextBuilder.Append(fixedString.Substring(indexText, fixedString.Length - indexText));
m_OutputText = s_TextBuilder.ToString();
m_ImagesVertexIndex.Clear();
matches = s_Regex.Matches(m_OutputText);
#if UNITY_2019_1_OR_NEWER
href_matches = s_HrefRegex.Matches(m_OutputText);
indexes.Clear();
for (int r = 0; r < matches.Count; r++) {
indexes.Add(matches[r].Index);
}
#endif
if (matches != null && matches.Count > 0) {
for (int i = 0; i < matches.Count; i++) {
picIndex = matches[i].Index;
#if UNITY_2019_1_OR_NEWER
if (usesNewRendering) {
charactersRemoved = 0;
removeCharacters = remove_Regex.Matches(m_OutputText);
for (int r = 0; r < removeCharacters.Count; r++) {
if (removeCharacters[r].Index < picIndex && !indexes.Contains(removeCharacters[r].Index)) {
charactersRemoved += removeCharacters[r].Length;
}
}
for (int r = 0; r < i; r++) {
charactersRemoved += (matches[r].Length - 1);
}
picIndex -= charactersRemoved;
}
#endif
vertIndex = picIndex * 4 + 3;
m_ImagesVertexIndex.Add(vertIndex);
}
}
#if UNITY_2019_1_OR_NEWER
if (usesNewRendering) {
if (m_HrefInfos != null && m_HrefInfos.Count > 0) {
for (int i = 0; i < m_HrefInfos.Count; i++) {
startCharactersRemoved = 0;
endCharactersRemoved = 0;
removeCharacters = remove_Regex.Matches(m_OutputText);
for (int r = 0; r < removeCharacters.Count; r++) {
if (removeCharacters[r].Index < m_HrefInfos[i].startIndex && !indexes.Contains(removeCharacters[r].Index)) {
startCharactersRemoved += removeCharacters[r].Length;
}
else if (removeCharacters[r].Index < m_HrefInfos[i].startIndex && indexes.Contains(removeCharacters[r].Index)) {
startCharactersRemoved += removeCharacters[r].Length - 1;
}
if (removeCharacters[r].Index < m_HrefInfos[i].endIndex && !indexes.Contains(removeCharacters[r].Index)) {
endCharactersRemoved += removeCharacters[r].Length;
}
else if (removeCharacters[r].Index < m_HrefInfos[i].endIndex && indexes.Contains(removeCharacters[r].Index)) {
endCharactersRemoved += removeCharacters[r].Length - 1;
}
}
m_HrefInfos[i].startIndex -= startCharactersRemoved;
m_HrefInfos[i].startIndex = m_HrefInfos[i].startIndex * 4;
m_HrefInfos[i].endIndex -= endCharactersRemoved;
m_HrefInfos[i].endIndex = m_HrefInfos[i].endIndex * 4 + 3;
}
}
}
#endif
return m_OutputText;
}
// Process href links to open them as a url, can override this function for custom functionality
public virtual void OnHrefClick(string hrefName) {
Application.OpenURL(hrefName);
// Debug.Log(hrefName);
}
/// UNITY METHODS ///
protected override void OnPopulateMesh(VertexHelper toFill) {
originalText = m_Text;
m_Text = GetOutputText();
base.OnPopulateMesh(toFill);
m_DisableFontTextureRebuiltCallback = true;
m_Text = originalText;
positions.Clear();
vert = new UIVertex();
for (int i = 0; i < m_ImagesVertexIndex.Count; i++) {
int endIndex = m_ImagesVertexIndex[i];
if (endIndex < toFill.currentVertCount) {
toFill.PopulateUIVertex(ref vert, endIndex);
positions.Add(new Vector2((vert.position.x + fontSize / 2), (vert.position.y + fontSize / 2)) + imageOffset);
// Erase the lower left corner of the black specks
toFill.PopulateUIVertex(ref vert, endIndex - 3);
Vector3 pos = vert.position;
for (int j = endIndex, m = endIndex - 3; j > m; j--) {
toFill.PopulateUIVertex(ref vert, endIndex);
vert.position = pos;
toFill.SetUIVertex(vert, j);
}
}
}
// Hyperlinks surround processing box
for (int h = 0; h < m_HrefInfos.Count; h++) {
m_HrefInfos[h].boxes.Clear();
if (m_HrefInfos[h].startIndex >= toFill.currentVertCount) {
continue;
}
// Hyperlink inside the text is added to surround the vertex index coordinate frame
toFill.PopulateUIVertex(ref vert, m_HrefInfos[h].startIndex);
Vector3 pos = vert.position;
Bounds bounds = new Bounds(pos, Vector3.zero);
for (int i = m_HrefInfos[h].startIndex, m = m_HrefInfos[h].endIndex; i < m; i++) {
if (i >= toFill.currentVertCount) {
break;
}
toFill.PopulateUIVertex(ref vert, i);
pos = vert.position;
// Wrap re-add surround frame
if (pos.x < bounds.min.x) {
m_HrefInfos[h].boxes.Add(new Rect(bounds.min, bounds.size));
bounds = new Bounds(pos, Vector3.zero);
}
else {
bounds.Encapsulate(pos); // Extended enclosed box
}
}
m_HrefInfos[h].boxes.Add(new Rect(bounds.min, bounds.size));
}
// Update the quad images
updateQuad = true;
m_DisableFontTextureRebuiltCallback = false;
}
/// <summary>
/// Click event is detected whether to click a hyperlink text
/// </summary>
/// <param name="eventData"></param>
public void OnPointerClick(PointerEventData eventData) {
RectTransformUtility.ScreenPointToLocalPointInRectangle(
rectTransform, eventData.position, eventData.pressEventCamera, out lp);
for (int h = 0; h < m_HrefInfos.Count; h++) {
for (int i = 0; i < m_HrefInfos[h].boxes.Count; ++i) {
if (m_HrefInfos[h].boxes[i].Contains(lp)) {
m_OnHrefClick.Invoke(m_HrefInfos[h].name);
return;
}
}
}
}
public void OnPointerEnter(PointerEventData eventData) {
//do your stuff when highlighted
selected = true;
if (m_ImagesPool.Count >= 1) {
for (int i = 0; i < m_ImagesPool.Count; i++) {
if (button != null && button.isActiveAndEnabled) {
m_ImagesPool[i].color = button.colors.highlightedColor;
}
}
}
}
public void OnPointerExit(PointerEventData eventData) {
//do your stuff when highlighted
selected = false;
if (m_ImagesPool.Count >= 1) {
for (int i = 0; i < m_ImagesPool.Count; i++) {
if (button != null && button.isActiveAndEnabled) {
m_ImagesPool[i].color = button.colors.normalColor;
}
else {
m_ImagesPool[i].color = color;
}
}
}
}
public void OnSelect(BaseEventData eventData) {
//do your stuff when selected
selected = true;
if (m_ImagesPool.Count >= 1) {
for (int i = 0; i < m_ImagesPool.Count; i++) {
if (button != null && button.isActiveAndEnabled) {
m_ImagesPool[i].color = button.colors.highlightedColor;
}
}
}
}
public void OnDeselect(BaseEventData eventData) {
//do your stuff when selected
selected = false;
if (m_ImagesPool.Count >= 1) {
for (int i = 0; i < m_ImagesPool.Count; i++) {
if (button != null && button.isActiveAndEnabled) {
m_ImagesPool[i].color = button.colors.normalColor;
}
}
}
}
public override void SetVerticesDirty() {
base.SetVerticesDirty();
// Update the quad images
updateQuad = true;
}
#if UNITY_EDITOR
protected override void OnValidate() {
base.OnValidate();
// Update the quad images
updateQuad = true;
if (inspectorIconList != null) {
for (int i = 0; i < inspectorIconList.Length; i++) {
if (inspectorIconList[i].scale == Vector2.zero) {
inspectorIconList[i].scale = Vector2.one;
}
}
}
}
#endif
protected override void OnEnable() {
#if UNITY_2019_1_OR_NEWER
// Here is the hack to see if Unity is using the new rendering system for text
usesNewRendering = false;
if (Application.unityVersion.StartsWith("2019.1.")) {
if (!Char.IsDigit(Application.unityVersion[8])) {
int number = Convert.ToInt32(Application.unityVersion[7].ToString());
if (number > 4) {
usesNewRendering = true;
}
}
else {
usesNewRendering = true;
}
}
else {
usesNewRendering = true;
}
#endif
base.OnEnable();
supportRichText = true;
alignByGeometry = true;
// Enable images on TextPic disable
if (m_ImagesPool.Count >= 1) {
for (int i = 0; i < m_ImagesPool.Count; i++) {
if(m_ImagesPool[i] != null) {
m_ImagesPool[i].enabled = true;
}
}
}
// Update the quads on re-enable
updateQuad = true;
this.onHrefClick.AddListener(OnHrefClick);
}
protected override void OnDisable() {
base.OnDisable();
// Disable images on TextPic disable
if (m_ImagesPool.Count >= 1) {
for (int i = 0; i < m_ImagesPool.Count; i++) {
if (m_ImagesPool[i] != null) {
m_ImagesPool[i].enabled = false;
}
}
}
this.onHrefClick.RemoveListener(OnHrefClick);
}
new void Start() {
button = GetComponent<Button>();
ResetIconList();
}
void LateUpdate() {
// Reset the hrefs if text is changed
if (previousText != text) {
Reset_m_HrefInfos();
// Update the quad on text change
updateQuad = true;
}
// Need to lock to remove images properly
lock (thisLock) {
// Can only update the images when it is not in a rebuild, this prevents the error
if (updateQuad) {
UpdateQuadImage();
updateQuad = false;
}
// Destroy any images that are not in use
if (clearImages) {
for (int i = 0; i < culled_ImagesPool.Count; i++) {
DestroyImmediate(culled_ImagesPool[i]);
}
culled_ImagesPool.Clear();
clearImages = false;
}
}
}
}
}