private dfFontRendererBase obtainRenderer()
{
Color32?nullable;
bool size = base.Size.sqrMagnitude <= 1.401298E-45f;
Vector2 vector2 = base.Size - new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
Vector2 vector21 = (this.autoSize || size ? this.getAutoSizeDefault() : vector2);
if (this.autoHeight)
{
vector21 = new Vector2(vector2.x, 2.14748365E+09f);
}
float units = base.PixelsToUnits();
Vector3 upperLeft = (this.pivot.TransformToUpperLeft(base.Size) + new Vector3((float)this.padding.left, (float)(-this.padding.top))) * units;
float textScale = this.TextScale * this.getTextScaleMultiplier();
dfFontRendererBase wordWrap = this.Font.ObtainRenderer();
wordWrap.WordWrap = this.WordWrap;
wordWrap.MaxSize = vector21;
wordWrap.PixelRatio = units;
wordWrap.TextScale = textScale;
wordWrap.CharacterSpacing = this.CharacterSpacing;
wordWrap.VectorOffset = upperLeft.Quantize(units);
wordWrap.MultiLine = true;
wordWrap.TabSize = this.TabSize;
wordWrap.TabStops = this.TabStops;
wordWrap.TextAlign = (!this.autoSize ? this.TextAlignment : UnityEngine.TextAlignment.Left);
wordWrap.ColorizeSymbols = this.ColorizeSymbols;
wordWrap.ProcessMarkup = this.ProcessMarkup;
wordWrap.DefaultColor = (!base.IsEnabled ? base.DisabledColor : base.Color);
dfFontRendererBase _dfFontRendererBase = wordWrap;
if (!this.enableGradient)
{
nullable = null;
}
else
{
nullable = new Color32?(this.BottomColor);
}
_dfFontRendererBase.BottomColor = nullable;
wordWrap.OverrideMarkupColors = !base.IsEnabled;
wordWrap.Opacity = base.CalculateOpacity();
wordWrap.Outline = this.Outline;
wordWrap.OutlineSize = this.OutlineSize;
wordWrap.OutlineColor = this.OutlineColor;
wordWrap.Shadow = this.Shadow;
wordWrap.ShadowColor = this.ShadowColor;
wordWrap.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer atlas = wordWrap as dfDynamicFont.DynamicFontRenderer;
if (atlas != null)
{
atlas.SpriteAtlas = this.Atlas;
atlas.SpriteBuffer = this.renderData;
}
if (this.vertAlign != dfVerticalAlignment.Top)
{
wordWrap.VectorOffset = this.getVertAlignOffset(wordWrap);
}
return(wordWrap);
}
private Vector3 getVertAlignOffset(dfFontRendererBase textRenderer)
{
var p2u = PixelsToUnits();
var renderedSize = textRenderer.MeasureString(this.text) * p2u;
var origin = textRenderer.VectorOffset;
var clientHeight = (Height - padding.vertical) * p2u;
if (renderedSize.y >= clientHeight)
{
return(origin);
}
switch (this.vertAlign)
{
case dfVerticalAlignment.Middle:
origin.y -= (clientHeight - renderedSize.y) * 0.5f;
break;
case dfVerticalAlignment.Bottom:
origin.y -= clientHeight - renderedSize.y;
break;
}
return(origin);
}
private void autoSizeToText()
{
if (((this.Font != null) && this.Font.IsValid) && !string.IsNullOrEmpty(this.Text))
{
using (dfFontRendererBase base2 = this.obtainTextRenderer())
{
Vector2 vector = base2.MeasureString(this.Text);
Vector2 vector2 = new Vector2(vector.x + this.padding.horizontal, vector.y + this.padding.vertical);
base.Size = vector2;
}
}
}
private dfFontRendererBase obtainTextRenderer()
{
Vector2 vector = base.Size - new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
Vector2 maxSize = (!this.autoSize) ? MaximumSize : (Vector2.one * 2.14748365E+09f);
float num = base.PixelsToUnits();
Vector3 vector2 = (this.pivot.TransformToUpperLeft(base.Size) + new Vector3((float)this.padding.left, (float)(-(float)this.padding.top))) * num;
float num2 = this.TextScale * this.getTextScaleMultiplier();
Color32 defaultColor = base.ApplyOpacity(this.getTextColorForState());
dfFontRendererBase dfFontRendererBase = this.Font.ObtainRenderer();
dfFontRendererBase.WordWrap = this.WordWrap;
dfFontRendererBase.MultiLine = this.WordWrap;
dfFontRendererBase.MaxSize = maxSize;
dfFontRendererBase.PixelRatio = num;
dfFontRendererBase.TextScale = num2;
dfFontRendererBase.CharacterSpacing = 0;
int num3 = this.textPixelOffset;
if (this.state == dfButton.ButtonState.Hover)
{
num3 = this.hoverTextPixelOffset;
}
if (this.state == dfButton.ButtonState.Pressed)
{
num3 = this.downTextPixelOffset;
}
if (this.state == dfButton.ButtonState.Disabled)
{
num3 = this.downTextPixelOffset;
}
dfFontRendererBase.VectorOffset = vector2.Quantize(num) + new Vector3(0f, (float)num3 * num, 0f);
dfFontRendererBase.TabSize = 0;
dfFontRendererBase.TextAlign = ((!this.autoSize) ? this.TextAlignment : TextAlignment.Left);
dfFontRendererBase.ProcessMarkup = true;
dfFontRendererBase.DefaultColor = defaultColor;
dfFontRendererBase.OverrideMarkupColors = false;
dfFontRendererBase.Opacity = base.CalculateOpacity();
dfFontRendererBase.Shadow = this.Shadow;
dfFontRendererBase.ShadowColor = this.ShadowColor;
dfFontRendererBase.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer dynamicFontRenderer = dfFontRendererBase as dfDynamicFont.DynamicFontRenderer;
if (dynamicFontRenderer != null)
{
dynamicFontRenderer.SpriteAtlas = base.Atlas;
dynamicFontRenderer.SpriteBuffer = this.renderData;
}
if (this.vertAlign != dfVerticalAlignment.Top)
{
dfFontRendererBase.VectorOffset = this.getVertAlignOffset(dfFontRendererBase);
}
return(dfFontRendererBase);
}
private void autoSizeToText()
{
if (this.Font == null || !this.Font.IsValid || string.IsNullOrEmpty(this.Text))
{
return;
}
using (dfFontRendererBase _dfFontRendererBase = this.obtainTextRenderer())
{
Vector2 vector2 = _dfFontRendererBase.MeasureString(this.Text);
Vector2 vector21 = new Vector2(vector2.x + (float)this.padding.horizontal, vector2.y + (float)this.padding.vertical);
base.Size = vector21;
}
}
private void renderItems(dfRenderData buffer)
{
if (this.font == null || this.items == null || (int)this.items.Length == 0)
{
return;
}
float units = base.PixelsToUnits();
Vector2 vector2 = new Vector2(this.size.x - (float)this.itemPadding.horizontal - (float)this.listPadding.horizontal, (float)(this.itemHeight - this.itemPadding.vertical));
Vector3 upperLeft = this.pivot.TransformToUpperLeft(base.Size);
Vector3 vector3 = new Vector3(upperLeft.x + (float)this.itemPadding.left + (float)this.listPadding.left, upperLeft.y - (float)this.itemPadding.top - (float)this.listPadding.top, 0f) * units;
vector3.y = vector3.y + this.scrollPosition * units;
Color32 color32 = (!base.IsEnabled ? base.DisabledColor : this.ItemTextColor);
float single = upperLeft.y * units;
float single1 = single - this.size.y * units;
for (int i = 0; i < (int)this.items.Length; i++)
{
using (dfFontRendererBase itemTextScale = this.font.ObtainRenderer())
{
itemTextScale.WordWrap = false;
itemTextScale.MaxSize = vector2;
itemTextScale.PixelRatio = units;
itemTextScale.TextScale = this.ItemTextScale * this.getTextScaleMultiplier();
itemTextScale.VectorOffset = vector3;
itemTextScale.MultiLine = false;
itemTextScale.TextAlign = this.ItemAlignment;
itemTextScale.ProcessMarkup = true;
itemTextScale.DefaultColor = color32;
itemTextScale.OverrideMarkupColors = false;
itemTextScale.Opacity = base.CalculateOpacity();
itemTextScale.Shadow = this.Shadow;
itemTextScale.ShadowColor = this.ShadowColor;
itemTextScale.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer atlas = itemTextScale as dfDynamicFont.DynamicFontRenderer;
if (atlas != null)
{
atlas.SpriteAtlas = base.Atlas;
atlas.SpriteBuffer = this.renderData;
}
if (vector3.y - (float)this.itemHeight * units <= single)
{
itemTextScale.Render(this.items[i], buffer);
}
vector3.y = vector3.y - (float)this.itemHeight * units;
itemTextScale.VectorOffset = vector3;
if (vector3.y < single1)
{
break;
}
}
}
}
private void renderItems(dfRenderData buffer)
{
if (((this.font != null) && (this.items != null)) && (this.items.Length != 0))
{
float num = base.PixelsToUnits();
Vector2 vector = new Vector2((this.size.x - this.itemPadding.horizontal) - this.listPadding.horizontal, (float)(this.itemHeight - this.itemPadding.vertical));
Vector3 vector2 = base.pivot.TransformToUpperLeft(base.Size);
Vector3 vector3 = (Vector3)(new Vector3((vector2.x + this.itemPadding.left) + this.listPadding.left, (vector2.y - this.itemPadding.top) - this.listPadding.top, 0f) * num);
vector3.y += this.scrollPosition * num;
Color32 color = !base.IsEnabled ? base.DisabledColor : this.ItemTextColor;
float num2 = vector2.y * num;
float num3 = num2 - (this.size.y * num);
for (int i = 0; i < this.items.Length; i++)
{
using (dfFontRendererBase base2 = this.font.ObtainRenderer())
{
base2.WordWrap = false;
base2.MaxSize = vector;
base2.PixelRatio = num;
base2.TextScale = this.ItemTextScale * this.getTextScaleMultiplier();
base2.VectorOffset = vector3;
base2.MultiLine = false;
base2.TextAlign = this.ItemAlignment;
base2.ProcessMarkup = true;
base2.DefaultColor = color;
base2.OverrideMarkupColors = false;
base2.Opacity = base.CalculateOpacity();
base2.Shadow = this.Shadow;
base2.ShadowColor = this.ShadowColor;
base2.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer renderer = base2 as dfDynamicFont.DynamicFontRenderer;
if (renderer != null)
{
renderer.SpriteAtlas = base.Atlas;
renderer.SpriteBuffer = base.renderData;
}
if ((vector3.y - (this.itemHeight * num)) <= num2)
{
base2.Render(this.items[i], buffer);
}
vector3.y -= this.itemHeight * num;
base2.VectorOffset = vector3;
if (vector3.y < num3)
{
break;
}
}
}
}
}
private dfFontRendererBase obtainRenderer()
{
bool flag = base.Size.sqrMagnitude <= float.Epsilon;
Vector2 vector = base.Size - new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
Vector2 vector2 = (!this.autoSize && !flag) ? vector : this.getAutoSizeDefault();
if (this.autoHeight)
{
vector2 = new Vector2(vector.x, 2.147484E+09f);
}
float discreteValue = base.PixelsToUnits();
Vector3 vector3 = (Vector3)((base.pivot.TransformToUpperLeft(base.Size) + new Vector3((float)this.padding.left, (float)-this.padding.top)) * discreteValue);
float num2 = this.TextScale * this.getTextScaleMultiplier();
dfFontRendererBase textRenderer = this.Font.ObtainRenderer();
textRenderer.WordWrap = this.WordWrap;
textRenderer.MaxSize = vector2;
textRenderer.PixelRatio = discreteValue;
textRenderer.TextScale = num2;
textRenderer.CharacterSpacing = this.CharacterSpacing;
textRenderer.VectorOffset = vector3.Quantize(discreteValue);
textRenderer.MultiLine = true;
textRenderer.TabSize = this.TabSize;
textRenderer.TabStops = this.TabStops;
textRenderer.TextAlign = !this.autoSize ? this.TextAlignment : UnityEngine.TextAlignment.Left;
textRenderer.ColorizeSymbols = this.ColorizeSymbols;
textRenderer.ProcessMarkup = this.ProcessMarkup;
textRenderer.DefaultColor = !base.IsEnabled ? base.DisabledColor : base.Color;
textRenderer.BottomColor = !this.enableGradient ? null : new Color32?(this.BottomColor);
textRenderer.OverrideMarkupColors = !base.IsEnabled;
textRenderer.Opacity = base.CalculateOpacity();
textRenderer.Outline = this.Outline;
textRenderer.OutlineSize = this.OutlineSize;
textRenderer.OutlineColor = this.OutlineColor;
textRenderer.Shadow = this.Shadow;
textRenderer.ShadowColor = this.ShadowColor;
textRenderer.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer renderer = textRenderer as dfDynamicFont.DynamicFontRenderer;
if (renderer != null)
{
renderer.SpriteAtlas = this.Atlas;
renderer.SpriteBuffer = base.renderData;
}
if (this.vertAlign != dfVerticalAlignment.Top)
{
textRenderer.VectorOffset = this.getVertAlignOffset(textRenderer);
}
return(textRenderer);
}
private dfRenderData renderText()
{
if (this.Font == null || !this.Font.IsValid || string.IsNullOrEmpty(this.Text))
{
return(null);
}
dfRenderData material = this.renderData;
if (this.font is dfDynamicFont)
{
dfDynamicFont _dfDynamicFont = (dfDynamicFont)this.font;
material = this.textRenderData;
material.Clear();
material.Material = _dfDynamicFont.Material;
}
using (dfFontRendererBase _dfFontRendererBase = this.obtainTextRenderer())
{
_dfFontRendererBase.Render(this.text, material);
}
return(material);
}
private dfRenderData renderText()
{
if (((this.Font == null) || !this.Font.IsValid) || string.IsNullOrEmpty(this.Text))
{
return(null);
}
dfRenderData renderData = base.renderData;
if (this.font is dfDynamicFont)
{
dfDynamicFont font = (dfDynamicFont)this.font;
renderData = this.textRenderData;
renderData.Clear();
renderData.Material = font.Material;
}
using (dfFontRendererBase base2 = this.obtainTextRenderer())
{
base2.Render(this.text, renderData);
}
return(renderData);
}
private Vector3 getVertAlignOffset(dfFontRendererBase textRenderer)
{
float num = base.PixelsToUnits();
Vector2 vector = (Vector2)(textRenderer.MeasureString(this.text) * num);
Vector3 vectorOffset = textRenderer.VectorOffset;
float num2 = (base.Height - this.padding.vertical) * num;
if (vector.y < num2)
{
dfVerticalAlignment vertAlign = this.vertAlign;
if (vertAlign != dfVerticalAlignment.Middle)
{
if (vertAlign == dfVerticalAlignment.Bottom)
{
vectorOffset.y -= num2 - vector.y;
}
return(vectorOffset);
}
vectorOffset.y -= (num2 - vector.y) * 0.5f;
}
return(vectorOffset);
}
private dfFontRendererBase obtainTextRenderer()
{
Vector2 vector = base.Size - new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
Vector2 vector2 = !this.autoSize ? vector : ((Vector2)(Vector2.one * 2.147484E+09f));
float discreteValue = base.PixelsToUnits();
Vector3 vector3 = (Vector3)((base.pivot.TransformToUpperLeft(base.Size) + new Vector3((float)this.padding.left, (float)-this.padding.top)) * discreteValue);
float num2 = this.TextScale * this.getTextScaleMultiplier();
Color32 color = base.ApplyOpacity(this.getTextColorForState());
dfFontRendererBase textRenderer = this.Font.ObtainRenderer();
textRenderer.WordWrap = this.WordWrap;
textRenderer.MultiLine = this.WordWrap;
textRenderer.MaxSize = vector2;
textRenderer.PixelRatio = discreteValue;
textRenderer.TextScale = num2;
textRenderer.CharacterSpacing = 0;
textRenderer.VectorOffset = vector3.Quantize(discreteValue);
textRenderer.TabSize = 0;
textRenderer.TextAlign = !this.autoSize ? this.TextAlignment : UnityEngine.TextAlignment.Left;
textRenderer.ProcessMarkup = true;
textRenderer.DefaultColor = color;
textRenderer.OverrideMarkupColors = false;
textRenderer.Opacity = base.CalculateOpacity();
textRenderer.Shadow = this.Shadow;
textRenderer.ShadowColor = this.ShadowColor;
textRenderer.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer renderer = textRenderer as dfDynamicFont.DynamicFontRenderer;
if (renderer != null)
{
renderer.SpriteAtlas = base.Atlas;
renderer.SpriteBuffer = base.renderData;
}
if (this.vertAlign != dfVerticalAlignment.Top)
{
textRenderer.VectorOffset = this.getVertAlignOffset(textRenderer);
}
return(textRenderer);
}
private void renderText(dfRenderData buffer)
{
if (this.selectedIndex < 0 || this.selectedIndex >= (int)this.items.Length)
{
return;
}
string str = this.items[this.selectedIndex];
float units = base.PixelsToUnits();
Vector2 vector2 = new Vector2(this.size.x - (float)this.textFieldPadding.horizontal, this.size.y - (float)this.textFieldPadding.vertical);
Vector3 upperLeft = this.pivot.TransformToUpperLeft(base.Size);
Vector3 vector3 = new Vector3(upperLeft.x + (float)this.textFieldPadding.left, upperLeft.y - (float)this.textFieldPadding.top, 0f) * units;
Color32 color32 = (!base.IsEnabled ? base.DisabledColor : this.TextColor);
using (dfFontRendererBase textScale = this.font.ObtainRenderer())
{
textScale.WordWrap = false;
textScale.MaxSize = vector2;
textScale.PixelRatio = units;
textScale.TextScale = this.TextScale;
textScale.VectorOffset = vector3;
textScale.MultiLine = false;
textScale.TextAlign = TextAlignment.Left;
textScale.ProcessMarkup = true;
textScale.DefaultColor = color32;
textScale.OverrideMarkupColors = false;
textScale.Opacity = base.CalculateOpacity();
textScale.Shadow = this.Shadow;
textScale.ShadowColor = this.ShadowColor;
textScale.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer atlas = textScale as dfDynamicFont.DynamicFontRenderer;
if (atlas != null)
{
atlas.SpriteAtlas = base.Atlas;
atlas.SpriteBuffer = buffer;
}
textScale.Render(str, buffer);
}
}
private dfFontRendererBase obtainTextRenderer()
{
Vector2 size = base.Size - new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
Vector2 vector2 = (!this.autoSize ? size : Vector2.one * 2.14748365E+09f);
float units = base.PixelsToUnits();
Vector3 upperLeft = (this.pivot.TransformToUpperLeft(base.Size) + new Vector3((float)this.padding.left, (float)(-this.padding.top))) * units;
float textScale = this.TextScale * this.getTextScaleMultiplier();
Color32 color32 = base.ApplyOpacity(this.getTextColorForState());
dfFontRendererBase wordWrap = this.Font.ObtainRenderer();
wordWrap.WordWrap = this.WordWrap;
wordWrap.MultiLine = this.WordWrap;
wordWrap.MaxSize = vector2;
wordWrap.PixelRatio = units;
wordWrap.TextScale = textScale;
wordWrap.CharacterSpacing = 0;
wordWrap.VectorOffset = upperLeft.Quantize(units);
wordWrap.TabSize = 0;
wordWrap.TextAlign = (!this.autoSize ? this.TextAlignment : UnityEngine.TextAlignment.Left);
wordWrap.ProcessMarkup = true;
wordWrap.DefaultColor = color32;
wordWrap.OverrideMarkupColors = false;
wordWrap.Opacity = base.CalculateOpacity();
wordWrap.Shadow = this.Shadow;
wordWrap.ShadowColor = this.ShadowColor;
wordWrap.ShadowOffset = this.ShadowOffset;
dfDynamicFont.DynamicFontRenderer atlas = wordWrap as dfDynamicFont.DynamicFontRenderer;
if (atlas != null)
{
atlas.SpriteAtlas = base.Atlas;
atlas.SpriteBuffer = this.renderData;
}
if (this.vertAlign != dfVerticalAlignment.Top)
{
wordWrap.VectorOffset = this.getVertAlignOffset(wordWrap);
}
return(wordWrap);
}
public override void Invalidate()
{
base.Invalidate();
if (this.Font == null || !this.Font.IsValid)
{
return;
}
bool flag = this.size.sqrMagnitude <= 1.401298E-45f;
if (!this.autoSize && !this.autoHeight && !flag)
{
return;
}
if (string.IsNullOrEmpty(this.Text))
{
if (flag)
{
base.Size = new Vector2(150f, 24f);
}
if (this.AutoSize || this.AutoHeight)
{
base.Height = (float)Mathf.CeilToInt((float)this.Font.LineHeight * this.TextScale);
}
return;
}
using (dfFontRendererBase _dfFontRendererBase = this.obtainRenderer())
{
Vector2 num = _dfFontRendererBase.MeasureString(this.text).RoundToInt();
if (this.AutoSize || flag)
{
this.size = num + new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
}
else if (this.AutoHeight)
{
this.size = new Vector2(this.size.x, num.y + (float)this.padding.vertical);
}
}
}
private Vector3 getVertAlignOffset(dfFontRendererBase textRenderer)
{
float units = base.PixelsToUnits();
Vector2 vector2 = textRenderer.MeasureString(this.text) * units;
Vector3 vectorOffset = textRenderer.VectorOffset;
float height = (base.Height - (float)this.padding.vertical) * units;
if (vector2.y >= height)
{
return(vectorOffset);
}
dfVerticalAlignment _dfVerticalAlignment = this.vertAlign;
if (_dfVerticalAlignment == dfVerticalAlignment.Middle)
{
vectorOffset.y = vectorOffset.y - (height - vector2.y) * 0.5f;
}
else if (_dfVerticalAlignment == dfVerticalAlignment.Bottom)
{
vectorOffset.y = vectorOffset.y - (height - vector2.y);
}
return(vectorOffset);
}
public override void Invalidate()
{
base.Invalidate();
if ((this.Font != null) && this.Font.IsValid)
{
bool flag = this.size.sqrMagnitude <= float.Epsilon;
if ((this.autoSize || this.autoHeight) || flag)
{
if (string.IsNullOrEmpty(this.Text))
{
if (flag)
{
base.Size = new Vector2(150f, 24f);
}
if (this.AutoSize || this.AutoHeight)
{
base.Height = Mathf.CeilToInt(this.Font.LineHeight * this.TextScale);
}
}
else
{
using (dfFontRendererBase base2 = this.obtainRenderer())
{
Vector2 vector = base2.MeasureString(this.text).RoundToInt();
if (this.AutoSize || flag)
{
base.size = vector + new Vector2((float)this.padding.horizontal, (float)this.padding.vertical);
}
else if (this.AutoHeight)
{
base.size = new Vector2(this.size.x, vector.y + this.padding.vertical);
}
}
}
}
}
}
private void renderText(dfRenderData textBuffer)
{
int num;
float units = base.PixelsToUnits();
Vector2 vector2 = new Vector2(this.size.x - (float)this.padding.horizontal, this.size.y - (float)this.padding.vertical);
Vector3 upperLeft = this.pivot.TransformToUpperLeft(base.Size);
Vector3 vector3 = new Vector3(upperLeft.x + (float)this.padding.left, upperLeft.y - (float)this.padding.top, 0f) * units;
string str = (!this.IsPasswordField || string.IsNullOrEmpty(this.passwordChar) ? this.text : this.passwordDisplayText());
Color32 color32 = (!base.IsEnabled ? base.DisabledColor : this.TextColor);
float textScaleMultiplier = this.getTextScaleMultiplier();
using (dfFontRendererBase textScale = this.font.ObtainRenderer())
{
textScale.WordWrap = false;
textScale.MaxSize = vector2;
textScale.PixelRatio = units;
textScale.TextScale = this.TextScale * textScaleMultiplier;
textScale.VectorOffset = vector3;
textScale.MultiLine = false;
textScale.TextAlign = UnityEngine.TextAlignment.Left;
textScale.ProcessMarkup = false;
textScale.DefaultColor = color32;
textScale.BottomColor = new Color32?(color32);
textScale.OverrideMarkupColors = false;
textScale.Opacity = base.CalculateOpacity();
textScale.Shadow = this.Shadow;
textScale.ShadowColor = this.ShadowColor;
textScale.ShadowOffset = this.ShadowOffset;
this.cursorIndex = Mathf.Min(this.cursorIndex, str.Length);
this.scrollIndex = Mathf.Min(Mathf.Min(this.scrollIndex, this.cursorIndex), str.Length);
this.charWidths = textScale.GetCharacterWidths(str);
Vector2 vector21 = vector2 * units;
this.leftOffset = 0f;
if (this.textAlign != UnityEngine.TextAlignment.Left)
{
this.scrollIndex = Mathf.Max(0, Mathf.Min(this.cursorIndex, str.Length - 1));
float single = 0f;
float fontSize = (float)this.font.FontSize * 1.25f * units;
while (this.scrollIndex > 0 && single < vector21.x - fontSize)
{
float[] singleArray = this.charWidths;
dfTextbox _dfTextbox = this;
int num1 = _dfTextbox.scrollIndex;
num = num1;
_dfTextbox.scrollIndex = num1 - 1;
single = single + singleArray[num];
}
float single1 = (str.Length <= 0 ? 0f : textScale.GetCharacterWidths(str.Substring(this.scrollIndex)).Sum());
UnityEngine.TextAlignment textAlignment = this.textAlign;
if (textAlignment == UnityEngine.TextAlignment.Center)
{
this.leftOffset = Mathf.Max(0f, (vector21.x - single1) * 0.5f);
}
else if (textAlignment == UnityEngine.TextAlignment.Right)
{
this.leftOffset = Mathf.Max(0f, vector21.x - single1);
}
vector3.x = vector3.x + this.leftOffset;
textScale.VectorOffset = vector3;
}
else
{
float single2 = 0f;
for (int i = this.scrollIndex; i < this.cursorIndex; i++)
{
single2 = single2 + this.charWidths[i];
}
while (single2 >= vector21.x && this.scrollIndex < this.cursorIndex)
{
float[] singleArray1 = this.charWidths;
dfTextbox _dfTextbox1 = this;
int num2 = _dfTextbox1.scrollIndex;
num = num2;
_dfTextbox1.scrollIndex = num2 + 1;
single2 = single2 - singleArray1[num];
}
}
if (this.selectionEnd != this.selectionStart)
{
this.renderSelection(this.scrollIndex, this.charWidths, this.leftOffset);
}
else if (this.cursorShown)
{
this.renderCursor(this.scrollIndex, this.cursorIndex, this.charWidths, this.leftOffset);
}
textScale.Render(str.Substring(this.scrollIndex), textBuffer);
}
}
private Vector3 getVertAlignOffset( dfFontRendererBase textRenderer )
{
var p2u = PixelsToUnits();
var renderedSize = textRenderer.MeasureString( this.text ) * p2u;
var origin = textRenderer.VectorOffset;
var clientHeight = ( Height - padding.vertical ) * p2u;
if( renderedSize.y >= clientHeight )
return origin;
switch( this.vertAlign )
{
case dfVerticalAlignment.Middle:
origin.y -= ( clientHeight - renderedSize.y ) * 0.5f;
break;
case dfVerticalAlignment.Bottom:
origin.y -= clientHeight - renderedSize.y;
break;
}
return origin;
}
public dfList <dfRenderData> RenderMultiple()
{
dfList <dfRenderData> dfRenderDatas;
try
{
if (this.Atlas == null || this.Font == null || !this.isVisible || !this.Font.IsValid)
{
dfRenderDatas = null;
}
else
{
if (this.renderData == null)
{
this.renderData = dfRenderData.Obtain();
this.textRenderData = dfRenderData.Obtain();
this.isControlInvalidated = true;
}
if (this.isControlInvalidated)
{
this.buffers.Clear();
this.renderData.Clear();
this.renderData.Material = this.Atlas.Material;
this.renderData.Transform = base.transform.localToWorldMatrix;
this.buffers.Add(this.renderData);
this.textRenderData.Clear();
this.textRenderData.Material = this.Atlas.Material;
this.textRenderData.Transform = base.transform.localToWorldMatrix;
this.buffers.Add(this.textRenderData);
this.renderBackground();
if (!string.IsNullOrEmpty(this.Text))
{
bool flag = this.size.sqrMagnitude <= 1.401298E-45f;
using (dfFontRendererBase _dfFontRendererBase = this.obtainRenderer())
{
_dfFontRendererBase.Render(this.text, this.textRenderData);
if (this.AutoSize || flag)
{
base.Size = (_dfFontRendererBase.RenderedSize + new Vector2((float)this.padding.horizontal, (float)this.padding.vertical)).CeilToInt();
}
else if (this.AutoHeight)
{
float single = this.size.x;
Vector2 renderedSize = _dfFontRendererBase.RenderedSize;
base.Size = (new Vector2(single, renderedSize.y + (float)this.padding.vertical)).CeilToInt();
}
}
this.updateCollider();
dfRenderDatas = this.buffers;
}
else
{
if (this.AutoSize || this.AutoHeight)
{
base.Height = (float)Mathf.CeilToInt((float)this.Font.LineHeight * this.TextScale);
}
dfRenderDatas = this.buffers;
}
}
else
{
for (int i = 0; i < this.buffers.Count; i++)
{
this.buffers[i].Transform = base.transform.localToWorldMatrix;
}
dfRenderDatas = this.buffers;
}
}
}
finally
{
this.isControlInvalidated = false;
}
return(dfRenderDatas);
}
public dfList <dfRenderData> RenderMultiple()
{
dfList <dfRenderData> buffers;
try
{
if (((this.Atlas == null) || (this.Font == null)) || (!base.isVisible || !this.Font.IsValid))
{
return(null);
}
if (base.renderData == null)
{
base.renderData = dfRenderData.Obtain();
this.textRenderData = dfRenderData.Obtain();
base.isControlInvalidated = true;
}
if (!base.isControlInvalidated)
{
for (int i = 0; i < this.buffers.Count; i++)
{
this.buffers[i].Transform = base.transform.localToWorldMatrix;
}
return(this.buffers);
}
this.buffers.Clear();
base.renderData.Clear();
base.renderData.Material = this.Atlas.Material;
base.renderData.Transform = base.transform.localToWorldMatrix;
this.buffers.Add(base.renderData);
this.textRenderData.Clear();
this.textRenderData.Material = this.Atlas.Material;
this.textRenderData.Transform = base.transform.localToWorldMatrix;
this.buffers.Add(this.textRenderData);
this.renderBackground();
if (string.IsNullOrEmpty(this.Text))
{
if (this.AutoSize || this.AutoHeight)
{
base.Height = Mathf.CeilToInt(this.Font.LineHeight * this.TextScale);
}
return(this.buffers);
}
bool flag = this.size.sqrMagnitude <= float.Epsilon;
using (dfFontRendererBase base2 = this.obtainRenderer())
{
base2.Render(this.text, this.textRenderData);
if (this.AutoSize || flag)
{
base.Size = (base2.RenderedSize + new Vector2((float)this.padding.horizontal, (float)this.padding.vertical)).CeilToInt();
}
else if (this.AutoHeight)
{
base.Size = new Vector2(this.size.x, base2.RenderedSize.y + this.padding.vertical).CeilToInt();
}
}
this.updateCollider();
buffers = this.buffers;
}
finally
{
base.isControlInvalidated = false;
}
return(buffers);
}
private Vector3 getVertAlignOffset(dfFontRendererBase textRenderer)
{
float units = base.PixelsToUnits();
Vector2 vector2 = textRenderer.MeasureString(this.text) * units;
Vector3 vectorOffset = textRenderer.VectorOffset;
float height = (base.Height - (float)this.padding.vertical) * units;
if (vector2.y >= height)
{
return vectorOffset;
}
dfVerticalAlignment _dfVerticalAlignment = this.vertAlign;
if (_dfVerticalAlignment == dfVerticalAlignment.Middle)
{
vectorOffset.y = vectorOffset.y - (height - vector2.y) * 0.5f;
}
else if (_dfVerticalAlignment == dfVerticalAlignment.Bottom)
{
vectorOffset.y = vectorOffset.y - (height - vector2.y);
}
return vectorOffset;
}
private extern Vector3 getVertAlignOffset(dfFontRendererBase textRenderer);
