public static void Text(this MeshGenerationContext mgc, TextParams textParams, TextHandle handle, float pixelsPerPoint)
{
if (textParams.font != null)
{
mgc.painter.DrawText(textParams, handle, pixelsPerPoint);
}
}
public static void Text(this MeshGenerationContext mgc, TextElement te)
{
if (TextUtilities.IsFontAssigned(te))
{
mgc.painter.DrawText(te);
}
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
if (image == null && sprite == null && vectorImage == null)
{
return;
}
var rectParams = new MeshGenerationContextUtils.RectangleParams();
if (image != null)
{
rectParams = MeshGenerationContextUtils.RectangleParams.MakeTextured(contentRect, uv, image, scaleMode, panel.contextType);
}
else if (sprite != null)
{
var slices = Vector4.zero;
rectParams = MeshGenerationContextUtils.RectangleParams.MakeSprite(contentRect, sprite, scaleMode, panel.contextType, false, ref slices);
}
else if (vectorImage != null)
{
rectParams = MeshGenerationContextUtils.RectangleParams.MakeVectorTextured(contentRect, uv, vectorImage, scaleMode, panel.contextType);
}
rectParams.color = tintColor;
mgc.Rectangle(rectParams);
}
internal void OnGenerateVisualContent(MeshGenerationContext mgc)
{
string drawText = text;
if (isPasswordField)
{
drawText = "".PadRight(text.Length, maskChar);
}
if (touchScreenTextField)
{
var touchScreenEditor = editorEventHandler as TouchScreenTextEditorEventHandler;
if (touchScreenEditor != null)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, drawText), m_TextHandle, scaledPixelsPerPoint);
}
}
else
{
if (!hasFocus)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, drawText), m_TextHandle, scaledPixelsPerPoint);
}
else
{
DrawWithTextSelectionAndCursor(mgc, drawText, scaledPixelsPerPoint);
}
}
}
internal void OnGenerateVisualContent(MeshGenerationContext mgc)
{
string text = this.text;
bool isPasswordField = this.isPasswordField;
if (isPasswordField)
{
text = "".PadRight(this.text.Length, this.maskChar);
}
bool touchScreenTextField = this.touchScreenTextField;
if (touchScreenTextField)
{
TouchScreenTextEditorEventHandler touchScreenTextEditorEventHandler = this.editorEventHandler as TouchScreenTextEditorEventHandler;
bool flag = touchScreenTextEditorEventHandler != null;
if (flag)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, text), this.m_TextHandle, base.scaledPixelsPerPoint);
}
}
else
{
bool flag2 = !this.hasFocus;
if (flag2)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, text), this.m_TextHandle, base.scaledPixelsPerPoint);
}
else
{
this.DrawWithTextSelectionAndCursor(mgc, text, base.scaledPixelsPerPoint);
}
}
}
private void OnOnGenerateVisualContentTextInput(MeshGenerationContext mgc)
{
if (isPasswordField)
{
// if we use system keyboard we will have normal text returned (hiding symbols is done inside os)
// so before drawing make sure we hide them ourselves
string drawText = "".PadRight(text.Length, parentTextField.maskChar);
if (!hasFocus)
{
// We don't have the focus, don't draw the selection and cursor
if (!string.IsNullOrEmpty(drawText) && contentRect.width > 0.0f && contentRect.height > 0.0f)
{
var textParams = MeshGenerationContextUtils.TextParams.MakeStyleBased(this, text);
textParams.text = drawText;
mgc.Text(textParams);
}
}
else
{
DrawWithTextSelectionAndCursor(mgc, drawText);
}
}
else
{
base.OnGenerateVisualContent(mgc);
}
}
public static void Text(this MeshGenerationContext mgc, TextParams textParams)
{
if (textParams.font != null)
{
mgc.painter.DrawText(textParams);
}
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
UpdateVisibleText();
mgc.Text(m_TextParams, m_TextHandle, this.scaledPixelsPerPoint);
m_UpdateTextParams = true;
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
lastWorldClip = elementPanel.repaintData.currentWorldClip;
// Access to the painter is internal and is not exposed to public
// The IStylePainter is kept as an interface rather than a concrete class for now to support tests
mgc.painter.DrawImmediate(DoIMGUIRepaint, cullingEnabled);
}
public static void Text(this MeshGenerationContext mgc, MeshGenerationContextUtils.TextParams textParams, TextHandle handle, float pixelsPerPoint)
{
bool flag = textParams.font != null;
if (flag)
{
mgc.painter.DrawText(textParams, handle, pixelsPerPoint);
}
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
Texture current = image;
if (current == null)
{
return;
}
var rectParams = MeshGenerationContextUtils.RectangleParams.MakeTextured(contentRect, uv, current, scaleMode, panel.contextType);
rectParams.color = tintColor;
mgc.Rectangle(rectParams);
}
internal void OnGenerateVisualContent(MeshGenerationContext mgc)
{
// When this is used, we can get rid of the content.text trick and use mask char directly in the text to print
if (touchScreenTextField)
{
var touchScreenEditor = editorEventHandler as TouchScreenTextEditorEventHandler;
if (touchScreenEditor != null && editorEngine.keyboardOnScreen != null)
{
UpdateText(CullString(editorEngine.keyboardOnScreen.text));
if (editorEngine.keyboardOnScreen.status != TouchScreenKeyboard.Status.Visible)
{
editorEngine.keyboardOnScreen = null;
GUI.changed = true;
}
}
// if we use system keyboard we will have normal text returned (hiding symbols is done inside os)
// so before drawing make sure we hide them ourselves
string drawText = text;
if (touchScreenEditor != null && !string.IsNullOrEmpty(touchScreenEditor.secureText))
{
drawText = "".PadRight(touchScreenEditor.secureText.Length, maskChar);
}
text = drawText;
}
else
{
if (!hasFocus)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, text));
}
else
{
DrawWithTextSelectionAndCursor(mgc, text);
}
}
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
bool flag = this.image == null && this.vectorImage == null;
if (!flag)
{
MeshGenerationContextUtils.RectangleParams rectParams = default(MeshGenerationContextUtils.RectangleParams);
bool flag2 = this.image != null;
if (flag2)
{
rectParams = MeshGenerationContextUtils.RectangleParams.MakeTextured(base.contentRect, this.uv, this.image, this.scaleMode, base.panel.contextType);
}
else
{
bool flag3 = this.vectorImage != null;
if (flag3)
{
rectParams = MeshGenerationContextUtils.RectangleParams.MakeVectorTextured(base.contentRect, this.uv, this.vectorImage, this.scaleMode, base.panel.contextType);
}
}
rectParams.color = this.tintColor;
mgc.Rectangle(rectParams);
}
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, this.text), m_TextHandle, this.scaledPixelsPerPoint);
}
internal void DrawWithTextSelectionAndCursor(MeshGenerationContext mgc, string newText, float pixelsPerPoint)
{
Color playmodeTintColor = (base.panel.contextType == ContextType.Editor) ? UIElementsUtility.editorPlayModeTintColor : Color.white;
KeyboardTextEditorEventHandler keyboardTextEditorEventHandler = this.editorEventHandler as KeyboardTextEditorEventHandler;
bool flag = keyboardTextEditorEventHandler == null;
if (!flag)
{
keyboardTextEditorEventHandler.PreDrawCursor(newText);
int cursorIndex = this.editorEngine.cursorIndex;
int selectIndex = this.editorEngine.selectIndex;
Rect localPosition = this.editorEngine.localPosition;
Vector2 scrollOffset = this.editorEngine.scrollOffset;
float scaling = TextHandle.ComputeTextScaling(base.worldTransform, pixelsPerPoint);
MeshGenerationContextUtils.TextParams textParams = MeshGenerationContextUtils.TextParams.MakeStyleBased(this, this.text);
textParams.text = " ";
textParams.wordWrapWidth = 0f;
textParams.wordWrap = false;
float num = this.m_TextHandle.ComputeTextHeight(textParams, scaling);
float wordWrapWidth = 0f;
bool flag2 = this.editorEngine.multiline && base.resolvedStyle.whiteSpace == WhiteSpace.Normal;
if (flag2)
{
wordWrapWidth = base.contentRect.width;
}
Vector2 p = this.editorEngine.graphicalCursorPos - scrollOffset;
p.y += num;
GUIUtility.compositionCursorPos = this.LocalToWorld(p);
Color cursorColor = this.cursorColor;
int num2 = string.IsNullOrEmpty(GUIUtility.compositionString) ? selectIndex : (cursorIndex + GUIUtility.compositionString.Length);
bool flag3 = cursorIndex != num2 && !this.isDragging;
if (flag3)
{
int cursorIndex2 = (cursorIndex < num2) ? cursorIndex : num2;
int cursorIndex3 = (cursorIndex > num2) ? cursorIndex : num2;
CursorPositionStylePainterParameters @default = CursorPositionStylePainterParameters.GetDefault(this, this.text);
@default.text = this.editorEngine.text;
@default.wordWrapWidth = wordWrapWidth;
@default.cursorIndex = cursorIndex2;
Vector2 vector = this.m_TextHandle.GetCursorPosition(@default, scaling);
@default.cursorIndex = cursorIndex3;
Vector2 vector2 = this.m_TextHandle.GetCursorPosition(@default, scaling);
vector -= scrollOffset;
vector2 -= scrollOffset;
bool flag4 = Mathf.Approximately(vector.y, vector2.y);
if (flag4)
{
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(vector.x, vector.y, vector2.x - vector.x, num),
color = this.selectionColor,
playmodeTintColor = playmodeTintColor
});
}
else
{
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(vector.x, vector.y, base.contentRect.xMax - vector.x, num),
color = this.selectionColor,
playmodeTintColor = playmodeTintColor
});
float num3 = vector2.y - vector.y - num;
bool flag5 = num3 > 0f;
if (flag5)
{
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(base.contentRect.xMin, vector.y + num, base.contentRect.width, num3),
color = this.selectionColor,
playmodeTintColor = playmodeTintColor
});
}
bool flag6 = vector2.x != base.contentRect.x;
if (flag6)
{
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(base.contentRect.xMin, vector2.y, vector2.x, num),
color = this.selectionColor,
playmodeTintColor = playmodeTintColor
});
}
}
}
bool flag7 = !string.IsNullOrEmpty(this.editorEngine.text) && base.contentRect.width > 0f && base.contentRect.height > 0f;
if (flag7)
{
textParams = MeshGenerationContextUtils.TextParams.MakeStyleBased(this, this.text);
textParams.rect = new Rect(base.contentRect.x - scrollOffset.x, base.contentRect.y - scrollOffset.y, base.contentRect.width + scrollOffset.x, base.contentRect.height + scrollOffset.y);
textParams.text = this.editorEngine.text;
mgc.Text(textParams, this.m_TextHandle, base.scaledPixelsPerPoint);
}
bool flag8 = !this.isReadOnly && !this.isDragging;
if (flag8)
{
bool flag9 = cursorIndex == num2 && base.computedStyle.unityFont.value != null;
if (flag9)
{
CursorPositionStylePainterParameters @default = CursorPositionStylePainterParameters.GetDefault(this, this.text);
@default.text = this.editorEngine.text;
@default.wordWrapWidth = wordWrapWidth;
@default.cursorIndex = cursorIndex;
Vector2 vector3 = this.m_TextHandle.GetCursorPosition(@default, scaling);
vector3 -= scrollOffset;
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(vector3.x, vector3.y, 1f, num),
color = cursorColor,
playmodeTintColor = playmodeTintColor
});
}
bool flag10 = this.editorEngine.altCursorPosition != -1;
if (flag10)
{
CursorPositionStylePainterParameters @default = CursorPositionStylePainterParameters.GetDefault(this, this.text);
@default.text = this.editorEngine.text.Substring(0, this.editorEngine.altCursorPosition);
@default.wordWrapWidth = wordWrapWidth;
@default.cursorIndex = this.editorEngine.altCursorPosition;
Vector2 vector4 = this.m_TextHandle.GetCursorPosition(@default, scaling);
vector4 -= scrollOffset;
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(vector4.x, vector4.y, 1f, num),
color = cursorColor,
playmodeTintColor = playmodeTintColor
});
}
}
keyboardTextEditorEventHandler.PostDrawCursor();
}
}
internal void DrawWithTextSelectionAndCursor(MeshGenerationContext mgc, string newText, float pixelsPerPoint)
{
var playmodeTintColor = panel.contextType == ContextType.Editor
? UIElementsUtility.editorPlayModeTintColor
: Color.white;
var keyboardTextEditor = editorEventHandler as KeyboardTextEditorEventHandler;
if (keyboardTextEditor == null)
{
return;
}
keyboardTextEditor.PreDrawCursor(newText);
int cursorIndex = editorEngine.cursorIndex;
int selectIndex = editorEngine.selectIndex;
Rect localPosition = editorEngine.localPosition;
var scrollOffset = editorEngine.scrollOffset;
float textScaling = TextHandle.ComputeTextScaling(worldTransform, pixelsPerPoint);
var textParams = MeshGenerationContextUtils.TextParams.MakeStyleBased(this, text);
textParams.text = " ";
textParams.wordWrapWidth = 0.0f;
textParams.wordWrap = false;
float lineHeight = m_TextHandle.ComputeTextHeight(textParams, textScaling);
float wordWrapWidth = 0.0f;
// Make sure to take into account the word wrap style...
if (editorEngine.multiline && (resolvedStyle.whiteSpace == WhiteSpace.Normal))
{
wordWrapWidth = contentRect.width;
// Since the wrapping is enabled, there is no need to offset the text... It will always fit the space on screen !
scrollOffset = Vector2.zero;
}
Vector2 pos = editorEngine.graphicalCursorPos - scrollOffset;
pos.y += lineHeight;
GUIUtility.compositionCursorPos = this.LocalToWorld(pos);
Color drawCursorColor = cursorColor;
int selectionEndIndex = string.IsNullOrEmpty(GUIUtility.compositionString)
? selectIndex
: cursorIndex + GUIUtility.compositionString.Length;
CursorPositionStylePainterParameters cursorParams;
// Draw highlighted section, if any
if ((cursorIndex != selectionEndIndex) && !isDragging)
{
int min = cursorIndex < selectionEndIndex ? cursorIndex : selectionEndIndex;
int max = cursorIndex > selectionEndIndex ? cursorIndex : selectionEndIndex;
cursorParams = CursorPositionStylePainterParameters.GetDefault(this, text);
cursorParams.text = editorEngine.text;
cursorParams.wordWrapWidth = wordWrapWidth;
cursorParams.cursorIndex = min;
Vector2 minPos = m_TextHandle.GetCursorPosition(cursorParams, textScaling);
cursorParams.cursorIndex = max;
Vector2 maxPos = m_TextHandle.GetCursorPosition(cursorParams, textScaling);
minPos -= scrollOffset;
maxPos -= scrollOffset;
if (Mathf.Approximately(minPos.y, maxPos.y))
{
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams()
{
rect = new Rect(minPos.x, minPos.y, maxPos.x - minPos.x, lineHeight),
color = selectionColor,
playmodeTintColor = playmodeTintColor
});
}
else
{
// Draw first line
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams()
{
rect = new Rect(minPos.x, minPos.y, contentRect.xMax - minPos.x, lineHeight),
color = selectionColor,
playmodeTintColor = playmodeTintColor
});
var inbetweenHeight = (maxPos.y - minPos.y) - lineHeight;
if (inbetweenHeight > 0f)
{
// Draw all lines in-between
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams()
{
rect = new Rect(contentRect.xMin, minPos.y + lineHeight, contentRect.width, inbetweenHeight),
color = selectionColor,
playmodeTintColor = playmodeTintColor
});
}
// Draw last line if not empty
if (maxPos.x != contentRect.x)
{
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams()
{
rect = new Rect(contentRect.xMin, maxPos.y, maxPos.x, lineHeight),
color = selectionColor,
playmodeTintColor = playmodeTintColor
});
}
}
}
// Draw the text with the scroll offset
if (!string.IsNullOrEmpty(editorEngine.text) && contentRect.width > 0.0f && contentRect.height > 0.0f)
{
textParams = MeshGenerationContextUtils.TextParams.MakeStyleBased(this, text);
textParams.rect = new Rect(contentRect.x - scrollOffset.x, contentRect.y - scrollOffset.y, contentRect.width + scrollOffset.x, contentRect.height + scrollOffset.y);
textParams.text = editorEngine.text;
mgc.Text(textParams, m_TextHandle, scaledPixelsPerPoint);
}
// Draw the cursor
if (!isReadOnly && !isDragging)
{
if (cursorIndex == selectionEndIndex && computedStyle.unityFont.value != null)
{
cursorParams = CursorPositionStylePainterParameters.GetDefault(this, text);
cursorParams.text = editorEngine.text;
cursorParams.wordWrapWidth = wordWrapWidth;
cursorParams.cursorIndex = cursorIndex;
Vector2 cursorPosition = m_TextHandle.GetCursorPosition(cursorParams, textScaling);
cursorPosition -= scrollOffset;
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(cursorPosition.x, cursorPosition.y, 1f, lineHeight),
color = drawCursorColor,
playmodeTintColor = playmodeTintColor
});
}
// Draw alternate cursor, if any
if (editorEngine.altCursorPosition != -1)
{
cursorParams = CursorPositionStylePainterParameters.GetDefault(this, text);
cursorParams.text = editorEngine.text.Substring(0, editorEngine.altCursorPosition);
cursorParams.wordWrapWidth = wordWrapWidth;
cursorParams.cursorIndex = editorEngine.altCursorPosition;
Vector2 altCursorPosition = m_TextHandle.GetCursorPosition(cursorParams, textScaling);
altCursorPosition -= scrollOffset;
mgc.Rectangle(new MeshGenerationContextUtils.RectangleParams
{
rect = new Rect(altCursorPosition.x, altCursorPosition.y, 1f, lineHeight),
color = drawCursorColor,
playmodeTintColor = playmodeTintColor
});
}
}
keyboardTextEditor.PostDrawCursor();
}
// Instantiated internally by UIR, users shouldn't derive from this class.
internal Painter2D(MeshGenerationContext ctx)
{
m_Handle = new SafeHandleAccess(UIPainter2D.Create(maxArcRadius));
m_Ctx = ctx;
Reset();
}
internal void DrawWithTextSelectionAndCursor(MeshGenerationContext mgc, string newText)
{
m_TextInputBase.DrawWithTextSelectionAndCursor(mgc, newText, scaledPixelsPerPoint);
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
mgc.Text(MeshGenerationContextUtils.TextParams.MakeStyleBased(this, this.text));
}
public static void Border(this MeshGenerationContext mgc, BorderParams borderParams)
{
mgc.painter.DrawBorder(borderParams);
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
mgc.painter.DrawImmediate(new Action(this.ImmediateRepaint), this.cullingEnabled);
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
mgc.painter.DrawImmediate(ImmediateRepaint, cullingEnabled);
}
public static void Rectangle(this MeshGenerationContext mgc, RectangleParams rectParams)
{
mgc.painter.DrawRectangle(rectParams);
}
private void OnGenerateVisualContent(MeshGenerationContext mgc)
{
this.lastWorldClip = base.elementPanel.repaintData.currentWorldClip;
mgc.painter.DrawImmediate(new Action(this.DoIMGUIRepaint), this.cullingEnabled);
}
